1: /* Show local PLT use in DSOs.
    2:    Copyright (C) 2006 Free Software Foundation, Inc.
    3:    This file is part of the GNU C Library.
    4:    Contribute by Ulrich Drepper <drepper@redhat.com>. 2006.
    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: #include <byteswap.h>
   22: #include <elf.h>
   23: #include <endian.h>
   24: #include <fcntl.h>
   25: #include <stdint.h>
   26: #include <stdio.h>
   27: #include <stdlib.h>
   28: #include <string.h>
   29: #include <unistd.h>
   30: 
   31: 
   32: #ifdef BITS
   33: 
   34: # define AB(name) _AB (name, BITS)
   35: # define _AB(name, bits) __AB (name, bits)
   36: # define __AB(name, bits) name##bits
   37: # define E(name) _E (name, BITS)
   38: # define _E(name, bits) __E (name, bits)
   39: # define __E(name, bits) Elf##bits##_##name
   40: # define EE(name) _EE (name, BITS)
   41: # define _EE(name, bits) __EE (name, bits)
   42: # define __EE(name, bits) ELF##bits##_##name
   43: # define SWAP(val) \
   44:   ({ __typeof (val) __res;                                                    \
   45:      if (((ehdr.e_ident[EI_DATA] == ELFDATA2MSB                               \
   46:            && BYTE_ORDER == LITTLE_ENDIAN)                                   \
   47:           || (ehdr.e_ident[EI_DATA] == ELFDATA2LSB                           \
   48:               && BYTE_ORDER == BIG_ENDIAN))                                  \
   49:          && sizeof (val) != 1)                                               \
   50:        {                                                                      \
   51:          if (sizeof (val) == 2)                                                      \
   52:            __res = bswap_16 (val);                                           \
   53:          else if (sizeof (val) == 4)                                         \
   54:            __res = bswap_32 (val);                                           \
   55:          else                                                                \
   56:            __res = bswap_64 (val);                                           \
   57:        }                                                                      \
   58:      else                                                                     \
   59:        __res = (val);                                                         \
   60:      __res; })
   61: 
   62: 
   63: static int
   64: AB(handle_file) (const char *fname, int fd)
   65: {
   66:   E(Ehdr) ehdr;
   67: 
   68:   if (pread (fd, &ehdr, sizeof (ehdr), 0) != sizeof (ehdr))
   69:     {
   70:     read_error:
   71:       printf ("%s: read error: %m\n", fname);
   72:       return 1;
   73:     }
   74: 
   75:   const size_t phnum = SWAP (ehdr.e_phnum);
   76:   const size_t phentsize = SWAP (ehdr.e_phentsize);
   77: 
   78:   /* Read the program header.  */
   79:   E(Phdr) *phdr = alloca (phentsize * phnum);
   80:   if (pread (fd, phdr, phentsize * phnum, SWAP (ehdr.e_phoff))
   81:       != phentsize * phnum)
   82:     goto read_error;
   83: 
   84:   /* Search for the PT_DYNAMIC entry.  */
   85:   size_t cnt;
   86:   E(Phdr) *dynphdr = NULL;
   87:   for (cnt = 0; cnt < phnum; ++cnt)
   88:     if (SWAP (phdr[cnt].p_type) == PT_DYNAMIC)
   89:       {
   90:         dynphdr = &phdr[cnt];
   91:         break;
   92:       }
   93: 
   94:   if (dynphdr == NULL)
   95:     {
   96:       printf ("%s: no DYNAMIC segment found\n", fname);
   97:       return 1;
   98:     }
   99: 
  100:   /* Read the dynamic segment.  */
  101:   size_t pmemsz = SWAP(dynphdr->p_memsz);
  102:   E(Dyn) *dyn = alloca (pmemsz);
  103:   if (pread64 (fd, dyn, pmemsz, SWAP(dynphdr->p_offset)) != pmemsz)
  104:     goto read_error;
  105: 
  106:   /* Search for an DT_PLTREL, DT_JMPREL, DT_PLTRELSZ, DT_STRTAB,
  107:      DT_STRSZ, and DT_SYMTAB entries.  */
  108:   size_t pltrel_idx = SIZE_MAX;
  109:   size_t jmprel_idx = SIZE_MAX;
  110:   size_t pltrelsz_idx = SIZE_MAX;
  111:   size_t strtab_idx = SIZE_MAX;
  112:   size_t strsz_idx = SIZE_MAX;
  113:   size_t symtab_idx = SIZE_MAX;
  114:   for (cnt = 0; (cnt + 1) * sizeof (E(Dyn)) - 1 < pmemsz; ++cnt)
  115:     {
  116:       unsigned int tag = SWAP (dyn[cnt].d_tag);
  117: 
  118:       if (tag == DT_NULL)
  119:         /* We reached the end.  */
  120:         break;
  121: 
  122:       if (tag == DT_PLTREL)
  123:         pltrel_idx = cnt;
  124:       else if (tag == DT_JMPREL)
  125:         jmprel_idx = cnt;
  126:       else if (tag == DT_PLTRELSZ)
  127:         pltrelsz_idx = cnt;
  128:       else if (tag == DT_STRTAB)
  129:         strtab_idx = cnt;
  130:       else if (tag == DT_STRSZ)
  131:         strsz_idx = cnt;
  132:       else if (tag == DT_SYMTAB)
  133:         symtab_idx = cnt;
  134:     }
  135: 
  136:   if (pltrel_idx == SIZE_MAX || jmprel_idx == SIZE_MAX
  137:       || pltrelsz_idx == SIZE_MAX || strtab_idx == SIZE_MAX
  138:       || strsz_idx == SIZE_MAX || symtab_idx == SIZE_MAX)
  139:     {
  140:       puts ("not all PLT information found");
  141:       return 1;
  142:     }
  143: 
  144:   E(Xword) relsz = SWAP (dyn[pltrelsz_idx].d_un.d_val);
  145: 
  146:   void *relmem = NULL;
  147:   char *strtab = NULL;
  148:   E(Xword) symtab_offset = 0;
  149: 
  150:   /* Find the offset of DT_JMPREL and load the data.  */
  151:   for (cnt = 0; cnt < phnum; ++cnt)
  152:     if (SWAP (phdr[cnt].p_type) == PT_LOAD)
  153:       {
  154:         E(Addr) vaddr = SWAP (phdr[cnt].p_vaddr);
  155:         E(Xword) memsz = SWAP (phdr[cnt].p_memsz);
  156: 
  157:         if (vaddr <= SWAP (dyn[jmprel_idx].d_un.d_val)
  158:             && vaddr + memsz >= SWAP (dyn[jmprel_idx].d_un.d_val) + relsz)
  159:           {
  160:             relmem = alloca (SWAP (dyn[pltrelsz_idx].d_un.d_val));
  161:             if (pread64 (fd, relmem, relsz,
  162:                          SWAP (phdr[cnt].p_offset)
  163:                          + SWAP (dyn[jmprel_idx].d_un.d_val) - vaddr)
  164:                 != relsz)
  165:               {
  166:                 puts ("cannot read JMPREL");
  167:                 return 1;
  168:               }
  169:           }
  170: 
  171:         if (vaddr <= SWAP (dyn[symtab_idx].d_un.d_val)
  172:             && vaddr + memsz > SWAP (dyn[symtab_idx].d_un.d_val))
  173:           symtab_offset = (SWAP (phdr[cnt].p_offset)
  174:                            + SWAP (dyn[symtab_idx].d_un.d_val) - vaddr);
  175: 
  176:         if (vaddr <= SWAP (dyn[strtab_idx].d_un.d_val)
  177:             && vaddr + memsz >= (SWAP (dyn[strtab_idx].d_un.d_val)
  178:                                  + SWAP(dyn[strsz_idx].d_un.d_val)))
  179:           {
  180:             strtab = alloca (SWAP(dyn[strsz_idx].d_un.d_val));
  181:             if (pread64 (fd, strtab, SWAP(dyn[strsz_idx].d_un.d_val),
  182:                          SWAP (phdr[cnt].p_offset)
  183:                          + SWAP (dyn[strtab_idx].d_un.d_val) - vaddr)
  184:                 != SWAP(dyn[strsz_idx].d_un.d_val))
  185:               {
  186:                 puts ("cannot read STRTAB");
  187:                 return 1;
  188:               }
  189:           }
  190:       }
  191: 
  192:   if (relmem == NULL || strtab == NULL || symtab_offset == 0)
  193:     {
  194:       puts ("couldn't load PLT data");
  195:       return 1;
  196:     }
  197: 
  198:   if (SWAP (dyn[pltrel_idx].d_un.d_val) == DT_RELA)
  199:     for (E(Rela) *rela = relmem; (char *) rela - (char *) relmem < relsz;
  200:          ++rela)
  201:       {
  202:         E(Sym) sym;
  203: 
  204:         if (pread64 (fd, &sym, sizeof (sym),
  205:                      symtab_offset
  206:                      + EE(R_SYM) (SWAP (rela->r_info)) * sizeof (sym))
  207:             != sizeof (sym))
  208:           {
  209:             puts ("cannot read symbol");
  210:             return 1;
  211:           }
  212: 
  213:         if (sym.st_value != 0)
  214:           /* This symbol is locally defined.  */
  215:           printf ("%s: %s\n", basename (fname), strtab + SWAP (sym.st_name));
  216:       }
  217:   else
  218:     for (E(Rel) *rel = relmem; (char *) rel - (char *) relmem < relsz; ++rel)
  219:       {
  220:         E(Sym) sym;
  221: 
  222:         if (pread64 (fd, &sym, sizeof (sym),
  223:                      symtab_offset
  224:                      + EE(R_SYM) (SWAP (rel->r_info)) * sizeof (sym))
  225:             != sizeof (sym))
  226:           {
  227:             puts ("cannot read symbol");
  228:             return 1;
  229:           }
  230: 
  231:         if (sym.st_value != 0)
  232:           /* This symbol is locally defined.  */
  233:           printf ("%s: %s\n", basename (fname), strtab + SWAP (sym.st_name));
  234:       }
  235: 
  236:   return 0;
  237: }
  238: 
  239: # undef BITS
  240: #else
  241: 
  242: # define BITS 32
  243: # include "check-localplt.c"
  244: 
  245: # define BITS 64
  246: # include "check-localplt.c"
  247: 
  248: 
  249: static int
  250: handle_file (const char *fname)
  251: {
  252:   int fd = open (fname, O_RDONLY);
  253:   if (fd == -1)
  254:     {
  255:       printf ("cannot open %s: %m\n", fname);
  256:       return 1;
  257:     }
  258: 
  259:   /* Read was is supposed to be the ELF header.  Read the initial
  260:      bytes to determine whether this is a 32 or 64 bit file.  */
  261:   char ident[EI_NIDENT];
  262:   if (read (fd, ident, EI_NIDENT) != EI_NIDENT)
  263:     {
  264:       printf ("%s: read error: %m\n", fname);
  265:       close (fd);
  266:       return 1;
  267:     }
  268: 
  269:   if (memcmp (&ident[EI_MAG0], ELFMAG, SELFMAG) != 0)
  270:     {
  271:       printf ("%s: not an ELF file\n", fname);
  272:       close (fd);
  273:       return 1;
  274:     }
  275: 
  276:   int result;
  277:   if (ident[EI_CLASS] == ELFCLASS64)
  278:     result = handle_file64 (fname, fd);
  279:   else
  280:     result = handle_file32 (fname, fd);
  281: 
  282:   close (fd);
  283: 
  284:   return result;
  285: }
  286: 
  287: 
  288: int
  289: main (int argc, char *argv[])
  290: {
  291:   int cnt;
  292:   int result = 0;
  293: 
  294:   for (cnt = 1; cnt < argc; ++cnt)
  295:     result |= handle_file (argv[cnt]);
  296: 
  297:   return result;
  298: }
  299: #endif