usr/src/cmd/sgs/libelf/common/getarsym.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21
  22 /*
  23  * Copyright (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
  24  */
  25
  26 /*      Copyright (c) 1988 AT&T */
  27 /*        All Rights Reserved   */
  28
  29 #include <stdlib.h>
  30 #include <errno.h>
  31 #include <libelf.h>
  32 #include "decl.h"
  33 #include "msg.h"
  34
  35
  36 /*
  37  * Convert archive symbol table to memory format
  38  *
  39  * This takes a pointer to file's archive symbol table, alignment
  40  * unconstrained.  Returns null terminated vector of Elf_Arsym
  41  * structures. Elf_Arsym uses size_t to represent offsets, which
  42  * will be 32-bit in 32-bit versions, and 64-bits otherwise.
  43  *
  44  * There are two forms of archive symbol table, the original 32-bit
  45  * form, and a 64-bit form originally found in IRIX64. The two formats
  46  * differ only in the width of the integer word:
  47  *
  48  *              # offsets       4/8-byte word
  49  *              offset[0...]    4/8-byte word each
  50  *              strings         null-terminated, for offset[x]
  51  *
  52  * By default, the 64-bit form is only used when the archive exceeds
  53  * the limits of 32-bits (4GB) in size. However, this is not required,
  54  * and the ar -S option can be used to create a 64-bit symbol table in
  55  * an archive that is under 4GB.
  56  *
  57  * Both 32 and 64-bit versions of libelf can read the 32-bit format
  58  * without loss of information. Similarly, a 64-bit version of libelf
  59  * will have no problem reading a 64-bit symbol table. This leaves the
  60  * case where a 32-bit libelf reads a 64-bit symbol table, which requires
  61  * some explanation. The offsets in a 64-bit symbol table will have zeros
  62  * in the upper half of the words until the size of the archive exceeds 4GB.
  63  * However, 32-bit libelf is unable to read any files larger than 2GB
  64  * (see comments in update.c). As such, any archive that the 32-bit version
  65  * of this code will encounter will be under 4GB in size. The upper 4
  66  * bytes of each word will be zero, and can be safely ignored.
  67  */
  68
  69
  70 /*
  71  * Offsets in archive headers are written in MSB (large endian) order
  72  * on all platforms, regardless of native byte order. These macros read
  73  * 4 and 8 byte values from unaligned memory.
  74  *
  75  * note:
  76  * -    The get8() macro for 32-bit code can ignore the first 4 bytes of
  77  *      of the word, because they are known to be 0.
  78  *
  79  * -    The inner most value in these macros is cast to an unsigned integer
  80  *      of the final width in order to prevent the C comilier from doing
  81  *      unwanted sign extension when the topmost bit of a byte is set.
  82  */
  83 #define get4(p) (((((((uint32_t)p[0]<<8)+p[1])<<8)+p[2])<<8)+p[3])
  84
  85 #ifdef _LP64
  86 #define get8(p) (((((((((((((((uint64_t)p[0]<<8)+p[1])<<8)+p[2])<<8)+   \
  87     p[3])<<8)+p[4])<<8)+p[5])<<8)+p[6])<<8)+p[7])
  88 #else
  89 #define get8(p) (((((((uint64_t)p[4]<<8)+p[5])<<8)+p[6])<<8)+p[7])
  90 #endif
  91
  92
  93 static Elf_Void *
  94 arsym(Byte *off, size_t sz, size_t *e, int is64)
  95 {
  96         char            *endstr = (char *)off + sz;
  97         register char   *str;
  98         Byte            *endoff;
  99         Elf_Void        *oas;
 100         size_t          eltsize = is64 ? 8 : 4;
 101
 102         {
 103                 register size_t n;
 104
 105                 if (is64) {
 106                         if (sz < 8 || (sz - 8) / 8 < (n = get8(off))) {
 107                                 _elf_seterr(EFMT_ARSYMSZ, 0);
 108                                 return (NULL);
 109                         }
 110                 } else {
 111                         if (sz < 4 || (sz - 4) / 4 < (n = get4(off))) {
 112                                 _elf_seterr(EFMT_ARSYMSZ, 0);
 113                                 return (NULL);
 114                         }
 115                 }
 116                 off += eltsize;
 117                 endoff = off + n * eltsize;
 118
 119                 /*
 120                  * If there are symbols in the symbol table, a
 121                  * string table must be present and NULL terminated.
 122                  *
 123                  * The format dictates that the string table must always be
 124                  * present, however in the case of an archive containing no
 125                  * symbols GNU ar will not create one.  We are permissive for
 126                  * the sake of compatibility.
 127                  */
 128                 if ((n > 0) && (((str = (char *)endoff) >= endstr) ||
 129                     (*(endstr - 1) != '\0'))) {
 130                         _elf_seterr(EFMT_ARSYM, 0);
 131                         return (NULL);
 132                 }
 133
 134                 /*
 135                  * There is always at least one entry returned if a symtab
 136                  * exists since the table's last entry is an artificial one
 137                  * with a NULL as_name, but is included in the count.
 138                  *
 139                  * overflow can occur here, but not likely
 140                  */
 141                 *e = n + 1;
 142                 if ((oas = calloc(n + 1, sizeof (Elf_Arsym))) == NULL) {
 143                         _elf_seterr(EMEM_ARSYM, errno);
 144                         return (NULL);
 145                 }
 146         }
 147         {
 148                 register Elf_Arsym      *as = (Elf_Arsym *)oas;
 149
 150                 while (off < endoff) {
 151                         if (str >= endstr) {
 152                                 _elf_seterr(EFMT_ARSYMSTR, 0);
 153                                 free(oas);
 154                                 return (NULL);
 155                         }
 156                         if (is64)
 157                                 as->as_off = get8(off);
 158                         else
 159                                 as->as_off = get4(off);
 160                         as->as_name = str;
 161                         as->as_hash = elf_hash(str);
 162                         ++as;
 163                         off += eltsize;
 164                         while (*str++ != '\0')
 165                                 /* LINTED */
 166                                 ;
 167                 }
 168                 as->as_name = NULL;
 169                 as->as_off = 0;
 170                 as->as_hash = ~(unsigned long)0L;
 171         }
 172         return (oas);
 173 }
 174
 175
 176 Elf_Arsym *
 177 elf_getarsym(Elf *elf, size_t *ptr)
 178 {
 179         Byte            *as;
 180         size_t          sz;
 181         Elf_Arsym       *rc;
 182         int             is64;
 183
 184         if (ptr != 0)
 185                 *ptr = 0;
 186         if (elf == NULL)
 187                 return (0);
 188         ELFRLOCK(elf);
 189         if (elf->ed_kind != ELF_K_AR) {
 190                 ELFUNLOCK(elf);
 191                 _elf_seterr(EREQ_AR, 0);
 192                 return (0);
 193         }
 194         if ((as = (Byte *)elf->ed_arsym) == 0) {
 195                 ELFUNLOCK(elf);
 196                 return (0);
 197         }
 198         if (elf->ed_myflags & EDF_ASALLOC) {
 199                 if (ptr != 0)
 200                         *ptr = elf->ed_arsymsz;
 201                 ELFUNLOCK(elf);
 202                 /* LINTED */
 203                 return ((Elf_Arsym *)as);
 204         }
 205         is64 = (elf->ed_myflags & EDF_ARSYM64) != 0;
 206
 207         /*
 208          * We're gonna need a write lock.
 209          */
 210         ELFUNLOCK(elf)
 211         ELFWLOCK(elf)
 212         sz = elf->ed_arsymsz;
 213         if (_elf_vm(elf, (size_t)(as - (Byte *)elf->ed_ident), sz) !=
 214             OK_YES) {
 215                 ELFUNLOCK(elf);
 216                 return (0);
 217         }
 218         if ((elf->ed_arsym = arsym(as, sz, &elf->ed_arsymsz, is64)) == 0) {
 219                 ELFUNLOCK(elf);
 220                 return (0);
 221         }
 222         elf->ed_myflags |= EDF_ASALLOC;
 223         if (ptr != 0)
 224                 *ptr = elf->ed_arsymsz;
 225         rc = (Elf_Arsym *)elf->ed_arsym;
 226         ELFUNLOCK(elf);
 227         return (rc);
 228 }
 229
 230 /*
 231  * Private function to obtain the value sizeof() would return
 232  * for a word from the symbol table from the given archive. Normally,
 233  * this is an unimportant implementation detail hidden within
 234  * elf_getarsym(). However, it is useful to elfdump for formatting the
 235  * output correctly, and for the file command.
 236  *
 237  * exit:
 238  *      Returns 4 (32-bit) or 8 (64-bit) if a symbol table is present.
 239  *      Returns 0 in all other cases.
 240  */
 241 size_t
 242 _elf_getarsymwordsize(Elf *elf)
 243 {
 244         size_t  size;
 245
 246         if (elf == NULL)
 247                 return (0);
 248
 249         ELFRLOCK(elf);
 250         if ((elf->ed_kind == ELF_K_AR) && (elf->ed_arsym != 0))
 251                 size = (elf->ed_myflags & EDF_ARSYM64) ? 8 : 4;
 252         else
 253                 size = 0;
 254         ELFUNLOCK(elf);
 255
 256         return (size);
 257 }