sysdeps/generic/readelflib.c

   1 /* Copyright (C) 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Andreas Jaeger <aj@suse.de>, 1999 and
   4                   Jakub Jelinek <jakub@redhat.com>, 1999.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 /* This code is a heavily simplified version of the readelf program
  22    that's part of the current binutils development version.  For architectures
  23    which need to handle both 32bit and 64bit ELF libraries,  this file is
  24    included twice for each arch size.  */
  25
  26 /* check_ptr checks that a pointer is in the mmaped file and doesn't
  27    point outside it.  */
  28 #undef check_ptr
  29 #define check_ptr(ptr)                                          \
  30 do                                                              \
  31   {                                                             \
  32     if ((void *)(ptr) < file_contents                           \
  33         || (void *)(ptr) > (file_contents+file_length))         \
  34       {                                                         \
  35         error (0, 0, _("file %s is truncated\n"), file_name);   \
  36         return 1;                                               \
  37       }                                                         \
  38   }                                                             \
  39  while (0);
  40
  41 /* Returns 0 if everything is ok, != 0 in case of error.  */
  42 int
  43 process_elf_file (const char *file_name, const char *lib, int *flag,
  44                   unsigned int *osversion, char **soname, void *file_contents,
  45                   size_t file_length)
  46 {
  47   int i;
  48   unsigned int j;
  49   int loadaddr;
  50   unsigned int dynamic_addr;
  51   size_t dynamic_size;
  52   char *program_interpreter;
  53
  54   ElfW(Ehdr) *elf_header;
  55   ElfW(Phdr) *elf_pheader, *segment;
  56   ElfW(Dyn) *dynamic_segment, *dyn_entry;
  57   char *dynamic_strings;
  58
  59   elf_header = (ElfW(Ehdr) *) file_contents;
  60   *osversion = 0;
  61
  62   if (elf_header->e_ident [EI_CLASS] != ElfW (CLASS))
  63     {
  64       if (opt_verbose)
  65         {
  66           if (elf_header->e_ident [EI_CLASS] == ELFCLASS32)
  67             error (0, 0, _("%s is a 32 bit ELF file.\n"), file_name);
  68           else if (elf_header->e_ident [EI_CLASS] == ELFCLASS64)
  69             error (0, 0, _("%s is a 64 bit ELF file.\n"), file_name);
  70           else
  71             error (0, 0, _("Unknown ELFCLASS in file %s.\n"), file_name);
  72         }
  73       return 1;
  74     }
  75
  76   if (elf_header->e_type != ET_DYN)
  77     {
  78       error (0, 0, _("%s is not a shared object file (Type: %d).\n"), file_name,
  79              elf_header->e_type);
  80       return 1;
  81     }
  82
  83   /* Get information from elf program header.  */
  84   elf_pheader = (ElfW(Phdr) *) (elf_header->e_phoff + file_contents);
  85   check_ptr (elf_pheader);
  86
  87   /* The library is an elf library, now search for soname and
  88      libc5/libc6.  */
  89   *flag = FLAG_ELF;
  90
  91   loadaddr = -1;
  92   dynamic_addr = 0;
  93   dynamic_size = 0;
  94   program_interpreter = NULL;
  95   for (i = 0, segment = elf_pheader;
  96        i < elf_header->e_phnum; i++, segment++)
  97     {
  98       check_ptr (segment);
  99
 100       switch (segment->p_type)
 101         {
 102         case PT_LOAD:
 103           if (loadaddr == -1)
 104             loadaddr = (segment->p_vaddr & 0xfffff000)
 105               - (segment->p_offset & 0xfffff000);
 106           break;
 107
 108         case PT_DYNAMIC:
 109           if (dynamic_addr)
 110             error (0, 0, _("more than one dynamic segment\n"));
 111
 112           dynamic_addr = segment->p_offset;
 113           dynamic_size = segment->p_filesz;
 114           break;
 115
 116         case PT_INTERP:
 117           program_interpreter = (char *) (file_contents + segment->p_offset);
 118           check_ptr (program_interpreter);
 119
 120           /* Check if this is enough to classify the binary.  */
 121           for (j = 0; j < sizeof (interpreters) / sizeof (interpreters [0]);
 122                ++j)
 123             if (strcmp (program_interpreter, interpreters[j].soname) == 0)
 124               {
 125                 *flag = interpreters[j].flag;
 126                 break;
 127               }
 128           break;
 129
 130         case PT_NOTE:
 131           if (!*osversion && segment->p_filesz == 32 && segment->p_align >= 4)
 132             {
 133               ElfW(Word) *abi_note = (ElfW(Word) *) (file_contents
 134                                                      + segment->p_offset);
 135               if (abi_note [0] == 4 && abi_note [1] == 16 && abi_note [2] == 1
 136                   && memcmp (abi_note + 3, "GNU", 4) == 0)
 137                 *osversion = (abi_note [4] << 24) |
 138                              ((abi_note [5] & 0xff) << 16) |
 139                              ((abi_note [6] & 0xff) << 8) |
 140                              (abi_note [7] & 0xff);
 141             }
 142           break;
 143
 144         default:
 145           break;
 146         }
 147
 148     }
 149   if (loadaddr == -1)
 150     {
 151       /* Very strange. */
 152       loadaddr = 0;
 153     }
 154
 155   /* Now we can read the dynamic sections.  */
 156   if (dynamic_size == 0)
 157     return 1;
 158
 159   dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr);
 160   check_ptr (dynamic_segment);
 161
 162   /* Find the string table.  */
 163   dynamic_strings = NULL;
 164   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 165        ++dyn_entry)
 166     {
 167       check_ptr (dyn_entry);
 168       if (dyn_entry->d_tag == DT_STRTAB)
 169         {
 170           dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr);
 171           check_ptr (dynamic_strings);
 172           break;
 173         }
 174     }
 175
 176   if (dynamic_strings == NULL)
 177     return 1;
 178
 179   /* Now read the DT_NEEDED and DT_SONAME entries.  */
 180   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 181        ++dyn_entry)
 182     {
 183       if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
 184         {
 185           char *name = dynamic_strings + dyn_entry->d_un.d_val;
 186           check_ptr (name);
 187
 188           if (dyn_entry->d_tag == DT_NEEDED)
 189             {
 190
 191               if (*flag == FLAG_ELF)
 192                 {
 193                   /* Check if this is enough to classify the binary.  */
 194                   for (j = 0;
 195                        j < sizeof (known_libs) / sizeof (known_libs [0]);
 196                        ++j)
 197                     if (strcmp (name, known_libs [j].soname) == 0)
 198                       {
 199                         *flag = known_libs [j].flag;
 200                         break;
 201                       }
 202                 }
 203             }
 204
 205           else if (dyn_entry->d_tag == DT_SONAME)
 206             *soname = xstrdup (name);
 207
 208           /* Do we have everything we need?  */
 209           if (*soname && *flag != FLAG_ELF)
 210             return 0;
 211         }
 212     }
 213
 214   /* We reach this point only if the file doesn't contain a DT_SONAME
 215      or if we can't classify the library.  If it doesn't have a
 216      soname, return the name of the library.  */
 217   if (*soname == NULL)
 218     *soname = xstrdup (lib);
 219
 220   return 0;
 221 }