elf/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   ElfW(Addr) 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 == (ElfW(Addr)) -1)
 104             loadaddr = segment->p_vaddr - segment->p_offset;
 105           break;
 106
 107         case PT_DYNAMIC:
 108           if (dynamic_addr)
 109             error (0, 0, _("more than one dynamic segment\n"));
 110
 111           dynamic_addr = segment->p_offset;
 112           dynamic_size = segment->p_filesz;
 113           break;
 114
 115         case PT_INTERP:
 116           program_interpreter = (char *) (file_contents + segment->p_offset);
 117           check_ptr (program_interpreter);
 118
 119           /* Check if this is enough to classify the binary.  */
 120           for (j = 0; j < sizeof (interpreters) / sizeof (interpreters [0]);
 121                ++j)
 122             if (strcmp (program_interpreter, interpreters[j].soname) == 0)
 123               {
 124                 *flag = interpreters[j].flag;
 125                 break;
 126               }
 127           break;
 128
 129         case PT_NOTE:
 130           if (!*osversion && segment->p_filesz == 32 && segment->p_align >= 4)
 131             {
 132               ElfW(Word) *abi_note = (ElfW(Word) *) (file_contents
 133                                                      + segment->p_offset);
 134               if (abi_note [0] == 4 && abi_note [1] == 16 && abi_note [2] == 1
 135                   && memcmp (abi_note + 3, "GNU", 4) == 0)
 136                 *osversion = (abi_note [4] << 24) |
 137                              ((abi_note [5] & 0xff) << 16) |
 138                              ((abi_note [6] & 0xff) << 8) |
 139                              (abi_note [7] & 0xff);
 140             }
 141           break;
 142
 143         default:
 144           break;
 145         }
 146
 147     }
 148   if (loadaddr == (ElfW(Addr)) -1)
 149     {
 150       /* Very strange. */
 151       loadaddr = 0;
 152     }
 153
 154   /* Now we can read the dynamic sections.  */
 155   if (dynamic_size == 0)
 156     return 1;
 157
 158   dynamic_segment = (ElfW(Dyn) *) (file_contents + dynamic_addr);
 159   check_ptr (dynamic_segment);
 160
 161   /* Find the string table.  */
 162   dynamic_strings = NULL;
 163   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 164        ++dyn_entry)
 165     {
 166       check_ptr (dyn_entry);
 167       if (dyn_entry->d_tag == DT_STRTAB)
 168         {
 169           dynamic_strings = (char *) (file_contents + dyn_entry->d_un.d_val - loadaddr);
 170           check_ptr (dynamic_strings);
 171           break;
 172         }
 173     }
 174
 175   if (dynamic_strings == NULL)
 176     return 1;
 177
 178   /* Now read the DT_NEEDED and DT_SONAME entries.  */
 179   for (dyn_entry = dynamic_segment; dyn_entry->d_tag != DT_NULL;
 180        ++dyn_entry)
 181     {
 182       if (dyn_entry->d_tag == DT_NEEDED || dyn_entry->d_tag == DT_SONAME)
 183         {
 184           char *name = dynamic_strings + dyn_entry->d_un.d_val;
 185           check_ptr (name);
 186
 187           if (dyn_entry->d_tag == DT_NEEDED)
 188             {
 189
 190               if (*flag == FLAG_ELF)
 191                 {
 192                   /* Check if this is enough to classify the binary.  */
 193                   for (j = 0;
 194                        j < sizeof (known_libs) / sizeof (known_libs [0]);
 195                        ++j)
 196                     if (strcmp (name, known_libs [j].soname) == 0)
 197                       {
 198                         *flag = known_libs [j].flag;
 199                         break;
 200                       }
 201                 }
 202             }
 203
 204           else if (dyn_entry->d_tag == DT_SONAME)
 205             *soname = xstrdup (name);
 206
 207           /* Do we have everything we need?  */
 208           if (*soname && *flag != FLAG_ELF)
 209             return 0;
 210         }
 211     }
 212
 213   /* We reach this point only if the file doesn't contain a DT_SONAME
 214      or if we can't classify the library.  If it doesn't have a
 215      soname, return the name of the library.  */
 216   if (*soname == NULL)
 217     *soname = xstrdup (lib);
 218
 219   return 0;
 220 }