endian-ness_handling.patch 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454
  1. Upstream-Status: Inappropriate [embedded specific]
  2. Do data input/output handling according to endien-ness of the library file. That
  3. enables use of ldconfig in the cross fashion for any architecture.
  4. 2011/04/04
  5. Richard Purdie <richard.purdie@linuxfoundation.org>
  6. Nitin Kamble <nitin.a.kamble@intel.com>
  7. Index: ldconfig-native-2.12.1/readelflib.c
  8. ===================================================================
  9. --- ldconfig-native-2.12.1.orig/readelflib.c
  10. +++ ldconfig-native-2.12.1/readelflib.c
  11. @@ -38,6 +38,28 @@ do \
  12. } \
  13. while (0);
  14. +int be;
  15. +static uint16_t read16(uint16_t x, int be)
  16. +{
  17. + if (be)
  18. + return be16toh(x);
  19. + return le16toh(x);
  20. +}
  21. +
  22. +static uint32_t read32(uint32_t x, int be)
  23. +{
  24. + if (be)
  25. + return be32toh(x);
  26. + return le32toh(x);
  27. +}
  28. +
  29. +static uint64_t read64(uint64_t x, int be)
  30. +{
  31. + if (be)
  32. + return be64toh(x);
  33. + return le64toh(x);
  34. +}
  35. +
  36. /* Returns 0 if everything is ok, != 0 in case of error. */
  37. int
  38. process_elf_file32 (const char *file_name, const char *lib, int *flag,
  39. @@ -59,15 +81,17 @@ process_elf_file32 (const char *file_nam
  40. elf_header = (Elf32_Ehdr *) file_contents;
  41. *osversion = 0;
  42. - if (elf_header->e_type != ET_DYN)
  43. + be = (elf_header->e_ident[EI_DATA] == ELFDATA2MSB);
  44. +
  45. + if (read16(elf_header->e_type, be) != ET_DYN)
  46. {
  47. error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
  48. - elf_header->e_type);
  49. + read16(elf_header->e_type, be));
  50. return 1;
  51. }
  52. /* Get information from elf program header. */
  53. - elf_pheader = (Elf32_Phdr *) (elf_header->e_phoff + file_contents);
  54. + elf_pheader = (Elf32_Phdr *) (read32(elf_header->e_phoff, be) + file_contents);
  55. check_ptr (elf_pheader);
  56. /* The library is an elf library, now search for soname and
  57. @@ -79,27 +103,27 @@ process_elf_file32 (const char *file_nam
  58. dynamic_size = 0;
  59. program_interpreter = NULL;
  60. for (i = 0, segment = elf_pheader;
  61. - i < elf_header->e_phnum; i++, segment++)
  62. + i < read16(elf_header->e_phnum, be); i++, segment++)
  63. {
  64. check_ptr (segment);
  65. - switch (segment->p_type)
  66. + switch (read32(segment->p_type, be))
  67. {
  68. case PT_LOAD:
  69. if (loadaddr == (Elf32_Addr) -1)
  70. - loadaddr = segment->p_vaddr - segment->p_offset;
  71. + loadaddr = read32(segment->p_vaddr, be) - read32(segment->p_offset, be);
  72. break;
  73. case PT_DYNAMIC:
  74. if (dynamic_addr)
  75. error (0, 0, _("more than one dynamic segment\n"));
  76. - dynamic_addr = segment->p_offset;
  77. - dynamic_size = segment->p_filesz;
  78. + dynamic_addr = read32(segment->p_offset, be);
  79. + dynamic_size = read32(segment->p_filesz, be);
  80. break;
  81. case PT_INTERP:
  82. - program_interpreter = (char *) (file_contents + segment->p_offset);
  83. + program_interpreter = (char *) (file_contents + read32(segment->p_offset, be));
  84. check_ptr (program_interpreter);
  85. /* Check if this is enough to classify the binary. */
  86. @@ -113,20 +137,20 @@ process_elf_file32 (const char *file_nam
  87. break;
  88. case PT_NOTE:
  89. - if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4)
  90. + if (!*osversion && read32(segment->p_filesz, be) >= 32 && segment->p_align >= 4)
  91. {
  92. Elf32_Word *abi_note = (Elf32_Word *) (file_contents
  93. - + segment->p_offset);
  94. - Elf32_Addr size = segment->p_filesz;
  95. + + read32(segment->p_offset, be));
  96. + Elf32_Addr size = read32(segment->p_filesz, be);
  97. - while (abi_note [0] != 4 || abi_note [1] != 16
  98. - || abi_note [2] != 1
  99. + while (read32(abi_note [0], be) != 4 || read32(abi_note [1], be) != 16
  100. + || read32(abi_note [2], be) != 1
  101. || memcmp (abi_note + 3, "GNU", 4) != 0)
  102. {
  103. -#define ROUND(len) (((len) + sizeof (Elf32_Word)) - 1) & -sizeof (Elf32_Word)))
  104. - Elf32_Addr) note_size = 3 * sizeof (Elf32_Word))
  105. - + ROUND (abi_note[0])
  106. - + ROUND (abi_note[1]);
  107. +#define ROUND(len) (((len) + sizeof (Elf32_Word) - 1) & -sizeof (Elf32_Word))
  108. + Elf32_Addr note_size = 3 * sizeof (Elf32_Word)
  109. + + ROUND (read32(abi_note[0], be))
  110. + + ROUND (read32(abi_note[1], be));
  111. if (size - 32 < note_size || note_size == 0)
  112. {
  113. @@ -140,10 +164,10 @@ process_elf_file32 (const char *file_nam
  114. if (size == 0)
  115. break;
  116. - *osversion = (abi_note [4] << 24) |
  117. - ((abi_note [5] & 0xff) << 16) |
  118. - ((abi_note [6] & 0xff) << 8) |
  119. - (abi_note [7] & 0xff);
  120. + *osversion = (read32(abi_note [4], be) << 24) |
  121. + ((read32(abi_note [5], be) & 0xff) << 16) |
  122. + ((read32(abi_note [6], be) & 0xff) << 8) |
  123. + (read32(abi_note [7], be) & 0xff);
  124. }
  125. break;
  126. @@ -167,13 +191,13 @@ process_elf_file32 (const char *file_nam
  127. /* Find the string table. */
  128. dynamic_strings = NULL;
  129. - for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
  130. + for (dyn_entry = dynamic_segment; read32(dyn_entry->d_tag, be) != DT_NULL;
  131. ++dyn_entry)
  132. {
  133. check_ptr (dyn_entry);
  134. - if (dyn_entry->d_tag == DT_STRTAB)
  135. + if (read32(dyn_entry->d_tag, be) == DT_STRTAB)
  136. {
  137. - dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr);
  138. + dynamic_strings = (char *) (file_contents + read32(dyn_entry->d_un.d_val, be) - loadaddr);
  139. check_ptr (dynamic_strings);
  140. break;
  141. }
  142. @@ -183,15 +207,15 @@ process_elf_file32 (const char *file_nam
  143. return 1;
  144. /* Now read the DT_NEEDED and DT_SONAME entries. */
  145. - for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
  146. + for (dyn_entry = dynamic_segment; read32(dyn_entry->d_tag, be) != DT_NULL;
  147. ++dyn_entry)
  148. {
  149. - if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
  150. + if (read32(dyn_entry->d_tag, be) == DT_NEEDED || read32(dyn_entry->d_tag, be) == DT_SONAME)
  151. {
  152. - char *name = dynamic_strings + dyn_entry->d_un.d_val;
  153. + char *name = dynamic_strings + read32(dyn_entry->d_un.d_val, be);
  154. check_ptr (name);
  155. - if (dyn_entry->d_tag == DT_NEEDED)
  156. + if (read32(dyn_entry->d_tag, be) == DT_NEEDED)
  157. {
  158. if (*flag == FLAG_ELF)
  159. @@ -208,7 +232,7 @@ process_elf_file32 (const char *file_nam
  160. }
  161. }
  162. - else if (dyn_entry->d_tag == DT_SONAME)
  163. + else if (read32(dyn_entry->d_tag, be) == DT_SONAME)
  164. *soname = xstrdup (name);
  165. /* Do we have everything we need? */
  166. @@ -246,15 +270,17 @@ process_elf_file64 (const char *file_nam
  167. elf_header = (Elf64_Ehdr *) file_contents;
  168. *osversion = 0;
  169. - if (elf_header->e_type != ET_DYN)
  170. + be = (elf_header->e_ident[EI_DATA] == ELFDATA2MSB);
  171. +
  172. + if (read16(elf_header->e_type, be) != ET_DYN)
  173. {
  174. error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
  175. - elf_header->e_type);
  176. + read16(elf_header->e_type, be));
  177. return 1;
  178. }
  179. /* Get information from elf program header. */
  180. - elf_pheader = (Elf64_Phdr *) (elf_header->e_phoff + file_contents);
  181. + elf_pheader = (Elf64_Phdr *) (read64(elf_header->e_phoff, be) + file_contents);
  182. check_ptr (elf_pheader);
  183. /* The library is an elf library, now search for soname and
  184. @@ -266,27 +292,27 @@ process_elf_file64 (const char *file_nam
  185. dynamic_size = 0;
  186. program_interpreter = NULL;
  187. for (i = 0, segment = elf_pheader;
  188. - i < elf_header->e_phnum; i++, segment++)
  189. + i < read16(elf_header->e_phnum, be); i++, segment++)
  190. {
  191. check_ptr (segment);
  192. - switch (segment->p_type)
  193. + switch (read32(segment->p_type, be))
  194. {
  195. case PT_LOAD:
  196. if (loadaddr == (Elf64_Addr) -1)
  197. - loadaddr = segment->p_vaddr - segment->p_offset;
  198. + loadaddr = read64(segment->p_vaddr, be) - read64(segment->p_offset, be);
  199. break;
  200. case PT_DYNAMIC:
  201. if (dynamic_addr)
  202. error (0, 0, _("more than one dynamic segment\n"));
  203. - dynamic_addr = segment->p_offset;
  204. - dynamic_size = segment->p_filesz;
  205. + dynamic_addr = read64(segment->p_offset, be);
  206. + dynamic_size = read32(segment->p_filesz, be);
  207. break;
  208. case PT_INTERP:
  209. - program_interpreter = (char *) (file_contents + segment->p_offset);
  210. + program_interpreter = (char *) (file_contents + read64(segment->p_offset, be));
  211. check_ptr (program_interpreter);
  212. /* Check if this is enough to classify the binary. */
  213. @@ -300,20 +326,21 @@ process_elf_file64 (const char *file_nam
  214. break;
  215. case PT_NOTE:
  216. - if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4)
  217. + if (!*osversion && read32(segment->p_filesz, be) >= 32 && read32(segment->p_align, be) >= 4)
  218. {
  219. Elf64_Word *abi_note = (Elf64_Word *) (file_contents
  220. - + segment->p_offset);
  221. - Elf64_Addr size = segment->p_filesz;
  222. + + read64(segment->p_offset, be));
  223. + Elf64_Addr size = read32(segment->p_filesz, be);
  224. - while (abi_note [0] != 4 || abi_note [1] != 16
  225. - || abi_note [2] != 1
  226. + while (read32(abi_note [0], be) != 4 || read32(abi_note [1], be) != 16
  227. + || read32(abi_note [2], be) != 1
  228. || memcmp (abi_note + 3, "GNU", 4) != 0)
  229. {
  230. +#undef ROUND
  231. #define ROUND(len) (((len) + sizeof (Elf64_Word) - 1) & -sizeof (Elf64_Word))
  232. Elf64_Addr note_size = 3 * sizeof (Elf64_Word)
  233. - + ROUND (abi_note[0])
  234. - + ROUND (abi_note[1]);
  235. + + ROUND (read32(abi_note[0], be))
  236. + + ROUND (read32(abi_note[1], be));
  237. if (size - 32 < note_size || note_size == 0)
  238. {
  239. @@ -327,10 +354,10 @@ process_elf_file64 (const char *file_nam
  240. if (size == 0)
  241. break;
  242. - *osversion = (abi_note [4] << 24) |
  243. - ((abi_note [5] & 0xff) << 16) |
  244. - ((abi_note [6] & 0xff) << 8) |
  245. - (abi_note [7] & 0xff);
  246. + *osversion = (read32(abi_note [4], be) << 24) |
  247. + ((read32(abi_note [5], be) & 0xff) << 16) |
  248. + ((read32(abi_note [6], be) & 0xff) << 8) |
  249. + (read32(abi_note [7], be) & 0xff);
  250. }
  251. break;
  252. @@ -354,13 +381,13 @@ process_elf_file64 (const char *file_nam
  253. /* Find the string table. */
  254. dynamic_strings = NULL;
  255. - for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
  256. + for (dyn_entry = dynamic_segment; read64(dyn_entry->d_tag, be) != DT_NULL;
  257. ++dyn_entry)
  258. {
  259. check_ptr (dyn_entry);
  260. - if (dyn_entry->d_tag == DT_STRTAB)
  261. + if (read64(dyn_entry->d_tag, be) == DT_STRTAB)
  262. {
  263. - dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr);
  264. + dynamic_strings = (char *) (file_contents + read64(dyn_entry->d_un.d_val, be) - loadaddr);
  265. check_ptr (dynamic_strings);
  266. break;
  267. }
  268. @@ -370,15 +397,15 @@ process_elf_file64 (const char *file_nam
  269. return 1;
  270. /* Now read the DT_NEEDED and DT_SONAME entries. */
  271. - for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
  272. + for (dyn_entry = dynamic_segment; read64(dyn_entry->d_tag, be) != DT_NULL;
  273. ++dyn_entry)
  274. {
  275. - if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
  276. + if (read64(dyn_entry->d_tag, be) == DT_NEEDED || read64(dyn_entry->d_tag, be) == DT_SONAME)
  277. {
  278. - char *name = dynamic_strings + dyn_entry->d_un.d_val;
  279. + char *name = dynamic_strings + read64(dyn_entry->d_un.d_val, be);
  280. check_ptr (name);
  281. - if (dyn_entry->d_tag == DT_NEEDED)
  282. + if (read64(dyn_entry->d_tag, be) == DT_NEEDED)
  283. {
  284. if (*flag == FLAG_ELF)
  285. @@ -395,7 +422,7 @@ process_elf_file64 (const char *file_nam
  286. }
  287. }
  288. - else if (dyn_entry->d_tag == DT_SONAME)
  289. + else if (read64(dyn_entry->d_tag, be) == DT_SONAME)
  290. *soname = xstrdup (name);
  291. /* Do we have everything we need? */
  292. Index: ldconfig-native-2.12.1/readlib.c
  293. ===================================================================
  294. --- ldconfig-native-2.12.1.orig/readlib.c
  295. +++ ldconfig-native-2.12.1/readlib.c
  296. @@ -169,7 +169,8 @@ process_file (const char *real_file_name
  297. ret = 1;
  298. }
  299. /* Libraries have to be shared object files. */
  300. - else if (elf_header->e_type != ET_DYN)
  301. + else if ((elf_header->e_ident[EI_DATA] == ELFDATA2MSB && be16toh(elf_header->e_type) != ET_DYN) ||
  302. + (elf_header->e_ident[EI_DATA] == ELFDATA2LSB && le16toh(elf_header->e_type) != ET_DYN))
  303. ret = 1;
  304. else if (process_elf_file (file_name, lib, flag, osversion, soname,
  305. file_contents, statbuf.st_size))
  306. Index: ldconfig-native-2.12.1/cache.c
  307. ===================================================================
  308. --- ldconfig-native-2.12.1.orig/cache.c
  309. +++ ldconfig-native-2.12.1/cache.c
  310. @@ -39,6 +39,29 @@
  311. # define N_(msgid) msgid
  312. #define _(msg) msg
  313. +extern int be;
  314. +
  315. +static uint16_t write16(uint16_t x, int be)
  316. +{
  317. + if (be)
  318. + return htobe16(x);
  319. + return htole16(x);
  320. +}
  321. +
  322. +static uint32_t write32(uint32_t x, int be)
  323. +{
  324. + if (be)
  325. + return htobe32(x);
  326. + return htole32(x);
  327. +}
  328. +
  329. +static uint64_t write64(uint64_t x, int be)
  330. +{
  331. + if (be)
  332. + return htobe64(x);
  333. + return htole64(x);
  334. +}
  335. +
  336. struct cache_entry
  337. {
  338. char *lib; /* Library name. */
  339. @@ -279,7 +302,12 @@ save_cache (const char *cache_name)
  340. /* Number of normal cache entries. */
  341. int cache_entry_old_count = 0;
  342. - for (entry = entries; entry != NULL; entry = entry->next)
  343. + if (be)
  344. + printf("saving cache in big endian encoding\n");
  345. + else
  346. + printf("saving cache in little endian encoding\n");
  347. +
  348. + for (entry = entries; entry != NULL; entry = entry->next)
  349. {
  350. /* Account the final NULs. */
  351. total_strlen += strlen (entry->lib) + strlen (entry->path) + 2;
  352. @@ -310,7 +338,7 @@ save_cache (const char *cache_name)
  353. memset (file_entries, '\0', sizeof (struct cache_file));
  354. memcpy (file_entries->magic, CACHEMAGIC, sizeof CACHEMAGIC - 1);
  355. - file_entries->nlibs = cache_entry_old_count;
  356. + file_entries->nlibs = write32(cache_entry_old_count, be);
  357. }
  358. struct cache_file_new *file_entries_new = NULL;
  359. @@ -330,8 +358,8 @@ save_cache (const char *cache_name)
  360. memcpy (file_entries_new->version, CACHE_VERSION,
  361. sizeof CACHE_VERSION - 1);
  362. - file_entries_new->nlibs = cache_entry_count;
  363. - file_entries_new->len_strings = total_strlen;
  364. + file_entries_new->nlibs = write32(cache_entry_count, be);
  365. + file_entries_new->len_strings = write32(total_strlen, be);
  366. }
  367. /* Pad for alignment of cache_file_new. */
  368. @@ -358,9 +386,9 @@ save_cache (const char *cache_name)
  369. /* First the library. */
  370. if (opt_format != 2 && entry->hwcap == 0)
  371. {
  372. - file_entries->libs[idx_old].flags = entry->flags;
  373. + file_entries->libs[idx_old].flags = write32(entry->flags, be);
  374. /* XXX: Actually we can optimize here and remove duplicates. */
  375. - file_entries->libs[idx_old].key = str_offset + pad;
  376. + file_entries->libs[idx_old].key = write32(str_offset + pad, be);
  377. }
  378. if (opt_format != 0)
  379. {
  380. @@ -368,10 +396,10 @@ save_cache (const char *cache_name)
  381. not doing so makes the code easier, the string table
  382. always begins at the beginning of the the new cache
  383. struct. */
  384. - file_entries_new->libs[idx_new].flags = entry->flags;
  385. - file_entries_new->libs[idx_new].osversion = entry->osversion;
  386. - file_entries_new->libs[idx_new].hwcap = entry->hwcap;
  387. - file_entries_new->libs[idx_new].key = str_offset;
  388. + file_entries_new->libs[idx_new].flags = write32(entry->flags, be);
  389. + file_entries_new->libs[idx_new].osversion = write32(entry->osversion, be);
  390. + file_entries_new->libs[idx_new].hwcap = write64(entry->hwcap, be);
  391. + file_entries_new->libs[idx_new].key = write32(str_offset, be);
  392. }
  393. size_t len = strlen (entry->lib) + 1;
  394. @@ -379,9 +407,9 @@ save_cache (const char *cache_name)
  395. str_offset += len;
  396. /* Then the path. */
  397. if (opt_format != 2 && entry->hwcap == 0)
  398. - file_entries->libs[idx_old].value = str_offset + pad;
  399. + file_entries->libs[idx_old].value = write32(str_offset + pad, be);
  400. if (opt_format != 0)
  401. - file_entries_new->libs[idx_new].value = str_offset;
  402. + file_entries_new->libs[idx_new].value = write32(str_offset, be);
  403. len = strlen (entry->path) + 1;
  404. str = mempcpy (str, entry->path, len);
  405. str_offset += len;