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 } 258