Upstream-Status: Inappropriate [embedded specific] We run the ldconfig in the cross fashion. make the code bitsize aware so that we can cross build ldconfig cache for various architectures. Richard Purdie 2009/05/19 Nitin A Kamble 2009/03/29 Index: ldconfig-native-2.12.1/readelflib.c =================================================================== --- ldconfig-native-2.12.1.orig/readelflib.c +++ ldconfig-native-2.12.1/readelflib.c @@ -40,39 +40,212 @@ do \ /* Returns 0 if everything is ok, != 0 in case of error. */ int -process_elf_file (const char *file_name, const char *lib, int *flag, +process_elf_file32 (const char *file_name, const char *lib, int *flag, unsigned int *osversion, char **soname, void *file_contents, size_t file_length) { int i; unsigned int j; - ElfW(Addr) loadaddr; + Elf32_Addr loadaddr; unsigned int dynamic_addr; size_t dynamic_size; char *program_interpreter; - ElfW(Ehdr) *elf_header; - ElfW(Phdr) *elf_pheader, *segment; - ElfW(Dyn) *dynamic_segment, *dyn_entry; + Elf32_Ehdr *elf_header; + Elf32_Phdr *elf_pheader, *segment; + Elf32_Dyn *dynamic_segment, *dyn_entry; char *dynamic_strings; - elf_header = (ElfW(Ehdr) *) file_contents; + elf_header = (Elf32_Ehdr *) file_contents; *osversion = 0; - if (elf_header->e_ident [EI_CLASS] != ElfW (CLASS)) + if (elf_header->e_type != ET_DYN) { - if (opt_verbose) + error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name, + elf_header->e_type); + return 1; + } + + /* Get information from elf program header. */ + elf_pheader = (Elf32_Phdr *) (elf_header->e_phoff + file_contents); + check_ptr (elf_pheader); + + /* The library is an elf library, now search for soname and + libc5/libc6. */ + *flag = FLAG_ELF; + + loadaddr = -1; + dynamic_addr = 0; + dynamic_size = 0; + program_interpreter = NULL; + for (i = 0, segment = elf_pheader; + i < elf_header->e_phnum; i++, segment++) + { + check_ptr (segment); + + switch (segment->p_type) { - if (elf_header->e_ident [EI_CLASS] == ELFCLASS32) - error (0, 0, _("%s is a 32 bit ELF file.\n"), file_name); - else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64) - error (0, 0, _("%s is a 64 bit ELF file.\n"), file_name); - else - error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name); + case PT_LOAD: + if (loadaddr == (Elf32_Addr) -1) + loadaddr = segment->p_vaddr - segment->p_offset; + break; + + case PT_DYNAMIC: + if (dynamic_addr) + error (0, 0, _("more than one dynamic segment\n")); + + dynamic_addr = segment->p_offset; + dynamic_size = segment->p_filesz; + break; + + case PT_INTERP: + program_interpreter = (char *) (file_contents + segment->p_offset); + check_ptr (program_interpreter); + + /* Check if this is enough to classify the binary. */ + for (j = 0; j < sizeof (interpreters) / sizeof (interpreters [0]); + ++j) + if (strcmp (program_interpreter, interpreters[j].soname) == 0) + { + *flag = interpreters[j].flag; + break; + } + break; + + case PT_NOTE: + if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4) + { + Elf32_Word *abi_note = (Elf32_Word *) (file_contents + + segment->p_offset); + Elf32_Addr size = segment->p_filesz; + + while (abi_note [0] != 4 || abi_note [1] != 16 + || abi_note [2] != 1 + || memcmp (abi_note + 3, "GNU", 4) != 0) + { +#define ROUND(len) (((len) + sizeof (Elf32_Word)) - 1) & -sizeof (Elf32_Word))) + Elf32_Addr) note_size = 3 * sizeof (Elf32_Word)) + + ROUND (abi_note[0]) + + ROUND (abi_note[1]); + + if (size - 32 < note_size || note_size == 0) + { + size = 0; + break; + } + size -= note_size; + abi_note = (void *) abi_note + note_size; + } + + if (size == 0) + break; + + *osversion = (abi_note [4] << 24) | + ((abi_note [5] & 0xff) << 16) | + ((abi_note [6] & 0xff) << 8) | + (abi_note [7] & 0xff); + } + break; + + default: + break; + } + + } + if (loadaddr == (Elf32_Addr) -1) + { + /* Very strange. */ + loadaddr = 0; + } + + /* Now we can read the dynamic sections. */ + if (dynamic_size == 0) + return 1; + + dynamic_segment = (Elf32_Dyn *) (file_contents + dynamic_addr); + check_ptr (dynamic_segment); + + /* Find the string table. */ + dynamic_strings = NULL; + for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL; + ++dyn_entry) + { + check_ptr (dyn_entry); + if (dyn_entry->d_tag == DT_STRTAB) + { + dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr); + check_ptr (dynamic_strings); + break; } - return 1; } + if (dynamic_strings == NULL) + return 1; + + /* Now read the DT_NEEDED and DT_SONAME entries. */ + for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL; + ++dyn_entry) + { + if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME) + { + char *name = dynamic_strings + dyn_entry->d_un.d_val; + check_ptr (name); + + if (dyn_entry->d_tag == DT_NEEDED) + { + + if (*flag == FLAG_ELF) + { + /* Check if this is enough to classify the binary. */ + for (j = 0; + j < sizeof (known_libs) / sizeof (known_libs [0]); + ++j) + if (strcmp (name, known_libs [j].soname) == 0) + { + *flag = known_libs [j].flag; + break; + } + } + } + + else if (dyn_entry->d_tag == DT_SONAME) + *soname = xstrdup (name); + + /* Do we have everything we need? */ + if (*soname && *flag != FLAG_ELF) + return 0; + } + } + + /* We reach this point only if the file doesn't contain a DT_SONAME + or if we can't classify the library. If it doesn't have a + soname, return the name of the library. */ + if (*soname == NULL) + *soname = xstrdup (lib); + + return 0; +} + +int +process_elf_file64 (const char *file_name, const char *lib, int *flag, + unsigned int *osversion, char **soname, void *file_contents, + size_t file_length) +{ + int i; + unsigned int j; + Elf64_Addr loadaddr; + unsigned int dynamic_addr; + size_t dynamic_size; + char *program_interpreter; + + Elf64_Ehdr *elf_header; + Elf64_Phdr *elf_pheader, *segment; + Elf64_Dyn *dynamic_segment, *dyn_entry; + char *dynamic_strings; + + elf_header = (Elf64_Ehdr *) file_contents; + *osversion = 0; + if (elf_header->e_type != ET_DYN) { error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name, @@ -81,7 +254,7 @@ process_elf_file (const char *file_name, } /* Get information from elf program header. */ - elf_pheader = (ElfW(Phdr) *) (elf_header->e_phoff + file_contents); + elf_pheader = (Elf64_Phdr *) (elf_header->e_phoff + file_contents); check_ptr (elf_pheader); /* The library is an elf library, now search for soname and @@ -100,7 +273,7 @@ process_elf_file (const char *file_name, switch (segment->p_type) { case PT_LOAD: - if (loadaddr == (ElfW(Addr)) -1) + if (loadaddr == (Elf64_Addr) -1) loadaddr = segment->p_vaddr - segment->p_offset; break; @@ -129,16 +302,16 @@ process_elf_file (const char *file_name, case PT_NOTE: if (!*osversion && segment->p_filesz >= 32 && segment->p_align >= 4) { - ElfW(Word) *abi_note = (ElfW(Word) *) (file_contents + Elf64_Word *abi_note = (Elf64_Word *) (file_contents + segment->p_offset); - ElfW(Addr) size = segment->p_filesz; + Elf64_Addr size = segment->p_filesz; while (abi_note [0] != 4 || abi_note [1] != 16 || abi_note [2] != 1 || memcmp (abi_note + 3, "GNU", 4) != 0) { -#define ROUND(len) (((len) + sizeof (ElfW(Word)) - 1) & -sizeof (ElfW(Word))) - ElfW(Addr) note_size = 3 * sizeof (ElfW(Word)) +#define ROUND(len) (((len) + sizeof (Elf64_Word) - 1) & -sizeof (Elf64_Word)) + Elf64_Addr note_size = 3 * sizeof (Elf64_Word) + ROUND (abi_note[0]) + ROUND (abi_note[1]); @@ -166,7 +339,7 @@ process_elf_file (const char *file_name, } } - if (loadaddr == (ElfW(Addr)) -1) + if (loadaddr == (Elf64_Addr) -1) { /* Very strange. */ loadaddr = 0; @@ -176,7 +349,7 @@ process_elf_file (const char *file_name, if (dynamic_size == 0) return 1; - dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr); + dynamic_segment = (Elf64_Dyn *) (file_contents + dynamic_addr); check_ptr (dynamic_segment); /* Find the string table. */ @@ -233,3 +406,33 @@ process_elf_file (const char *file_name, return 0; } +/* Returns 0 if everything is ok, != 0 in case of error. */ +int +process_elf_file (const char *file_name, const char *lib, int *flag, + unsigned int *osversion, char **soname, void *file_contents, + size_t file_length) +{ + int i; + unsigned int j; + ElfW(Addr) loadaddr; + unsigned int dynamic_addr; + size_t dynamic_size; + char *program_interpreter; + + ElfW(Ehdr) *elf_header; + ElfW(Phdr) *elf_pheader, *segment; + ElfW(Dyn) *dynamic_segment, *dyn_entry; + char *dynamic_strings; + + elf_header = (ElfW(Ehdr) *) file_contents; + *osversion = 0; + + if (elf_header->e_ident [EI_CLASS] == ELFCLASS32) + return process_elf_file32(file_name, lib,flag, osversion, soname, file_contents, file_length); + else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64) + return process_elf_file64(file_name, lib,flag, osversion, soname, file_contents, file_length); + error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name); + return 1; +} + +