libelf_ar.c
1 /*- 2 * Copyright (c) 2006,2008,2010 Joseph Koshy 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND 15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 24 * SUCH DAMAGE. 25 */ 26 27 #include <sys/cdefs.h> 28 29 #include <assert.h> 30 #include <ctype.h> 31 #include <libelf.h> 32 #include <stdlib.h> 33 #include <string.h> 34 35 #include "_libelf.h" 36 #include "_libelf_ar.h" 37 38 ELFTC_VCSID("$Id$"); 39 40 #define LIBELF_NALLOC_SIZE 16 41 42 /* 43 * `ar' archive handling. 44 * 45 * `ar' archives start with signature `ARMAG'. Each archive member is 46 * preceded by a header containing meta-data for the member. This 47 * header is described in <ar.h> (struct ar_hdr). The header always 48 * starts on an even address. File data is padded with "\n" 49 * characters to keep this invariant. 50 * 51 * Special considerations for `ar' archives: 52 * 53 * There are two variants of the `ar' archive format: traditional BSD 54 * and SVR4. These differ in the way long file names are treated, and 55 * in the layout of the archive symbol table. 56 * 57 * The `ar' header only has space for a 16 character file name. 58 * 59 * In the SVR4 format, file names are terminated with a '/', so this 60 * effectively leaves 15 characters for the actual file name. Longer 61 * file names stored in a separate 'string table' and referenced 62 * indirectly from the name field. The string table itself appears as 63 * an archive member with name "// ". An `indirect' file name in an 64 * `ar' header matches the pattern "/[0-9]*". The digits form a 65 * decimal number that corresponds to a byte offset into the string 66 * table where the actual file name of the object starts. Strings in 67 * the string table are padded to start on even addresses. 68 * 69 * In the BSD format, file names can be upto 16 characters. File 70 * names shorter than 16 characters are padded to 16 characters using 71 * (ASCII) space characters. File names with embedded spaces and file 72 * names longer than 16 characters are stored immediately after the 73 * archive header and the name field set to a special indirect name 74 * matching the pattern "#1/[0-9]+". The digits form a decimal number 75 * that corresponds to the actual length of the file name following 76 * the archive header. The content of the archive member immediately 77 * follows the file name, and the size field of the archive member 78 * holds the sum of the sizes of the member and of the appended file 79 * name. 80 * 81 * Archives may also have a symbol table (see ranlib(1)), mapping 82 * program symbols to object files inside the archive. 83 * 84 * In the SVR4 format, a symbol table uses a file name of "/ " in its 85 * archive header. The symbol table is structured as: 86 * - a 4-byte count of entries stored as a binary value, MSB first 87 * - 'n' 4-byte offsets, stored as binary values, MSB first 88 * - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded. 89 * 90 * In the BSD format, the symbol table uses a file name of "__.SYMDEF". 91 * It is structured as two parts: 92 * - The first part is an array of "ranlib" structures preceded by 93 * the size of the array in bytes. Each "ranlib" structure 94 * describes one symbol. Each structure contains an offset into 95 * the string table for the symbol name, and a file offset into the 96 * archive for the member defining the symbol. 97 * - The second part is a string table containing NUL-terminated 98 * strings, preceded by the size of the string table in bytes. 99 * 100 * If the symbol table and string table are is present in an archive 101 * they must be the very first objects and in that order. 102 */ 103 104 105 /* 106 * Retrieve an archive header descriptor. 107 */ 108 109 Elf_Arhdr * 110 _libelf_ar_gethdr(Elf *e) 111 { 112 Elf *parent; 113 Elf_Arhdr *eh; 114 char *namelen; 115 size_t n, nlen; 116 struct ar_hdr *arh; 117 118 if ((parent = e->e_parent) == NULL) { 119 LIBELF_SET_ERROR(ARGUMENT, 0); 120 return (NULL); 121 } 122 123 assert((e->e_flags & LIBELF_F_AR_HEADER) == 0); 124 125 arh = (struct ar_hdr *) (uintptr_t) e->e_hdr.e_rawhdr; 126 127 assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG); 128 assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + 129 parent->e_rawsize - sizeof(struct ar_hdr)); 130 131 if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) { 132 LIBELF_SET_ERROR(RESOURCE, 0); 133 return (NULL); 134 } 135 136 e->e_hdr.e_arhdr = eh; 137 e->e_flags |= LIBELF_F_AR_HEADER; 138 139 eh->ar_name = eh->ar_rawname = NULL; 140 141 if ((eh->ar_name = _libelf_ar_get_translated_name(arh, parent)) == 142 NULL) 143 goto error; 144 145 if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, 146 &n) == 0) 147 goto error; 148 eh->ar_uid = (uid_t) n; 149 150 if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, 151 &n) == 0) 152 goto error; 153 eh->ar_gid = (gid_t) n; 154 155 if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, 156 &n) == 0) 157 goto error; 158 eh->ar_mode = (mode_t) n; 159 160 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, 161 &n) == 0) 162 goto error; 163 164 /* 165 * Get the true size of the member if extended naming is being used. 166 */ 167 if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { 168 namelen = arh->ar_name + 169 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; 170 if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - 171 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nlen) == 0) 172 goto error; 173 n -= nlen; 174 } 175 176 eh->ar_size = n; 177 178 if ((eh->ar_rawname = _libelf_ar_get_raw_name(arh)) == NULL) 179 goto error; 180 181 eh->ar_flags = 0; 182 183 return (eh); 184 185 error: 186 if (eh) { 187 if (eh->ar_name) 188 free(eh->ar_name); 189 if (eh->ar_rawname) 190 free(eh->ar_rawname); 191 free(eh); 192 } 193 194 e->e_flags &= ~LIBELF_F_AR_HEADER; 195 e->e_hdr.e_rawhdr = (unsigned char *) arh; 196 197 return (NULL); 198 } 199 200 Elf * 201 _libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf) 202 { 203 Elf *e; 204 off_t next; 205 size_t nsz, sz; 206 struct ar_hdr *arh; 207 char *member, *namelen; 208 209 assert(elf->e_kind == ELF_K_AR); 210 211 next = elf->e_u.e_ar.e_next; 212 213 /* 214 * `next' is only set to zero by elf_next() when the last 215 * member of an archive is processed. 216 */ 217 if (next == (off_t) 0) 218 return (NULL); 219 220 assert((next & 1) == 0); 221 222 arh = (struct ar_hdr *) (elf->e_rawfile + next); 223 224 /* 225 * Retrieve the size of the member. 226 */ 227 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, 228 &sz) == 0) { 229 LIBELF_SET_ERROR(ARCHIVE, 0); 230 return (NULL); 231 } 232 233 /* 234 * Adjust the size field for members in BSD archives using 235 * extended naming. 236 */ 237 if (IS_EXTENDED_BSD_NAME(arh->ar_name)) { 238 namelen = arh->ar_name + 239 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE; 240 if (_libelf_ar_get_number(namelen, sizeof(arh->ar_name) - 241 LIBELF_AR_BSD_EXTENDED_NAME_PREFIX_SIZE, 10, &nsz) == 0) { 242 LIBELF_SET_ERROR(ARCHIVE, 0); 243 return (NULL); 244 } 245 246 member = (char *) (arh + 1) + nsz; 247 sz -= nsz; 248 } else 249 member = (char *) (arh + 1); 250 251 252 if ((e = elf_memory(member, sz)) == NULL) 253 return (NULL); 254 255 e->e_fd = fd; 256 e->e_cmd = c; 257 e->e_hdr.e_rawhdr = (unsigned char *) arh; 258 259 elf->e_u.e_ar.e_nchildren++; 260 e->e_parent = elf; 261 262 return (e); 263 } 264 265 /* 266 * A BSD-style ar(1) symbol table has the following layout: 267 * 268 * - A count of bytes used by the following array of 'ranlib' 269 * structures, stored as a 'long'. 270 * - An array of 'ranlib' structures. Each array element is 271 * two 'long's in size. 272 * - A count of bytes used for the following symbol table. 273 * - The symbol table itself. 274 */ 275 276 /* 277 * A helper macro to read in a 'long' value from the archive. 278 * 279 * We use memcpy() since the source pointer may be misaligned with 280 * respect to the natural alignment for a C 'long'. 281 */ 282 #define GET_LONG(P, V)do { \ 283 memcpy(&(V), (P), sizeof(long)); \ 284 (P) += sizeof(long); \ 285 } while (0) 286 287 Elf_Arsym * 288 _libelf_ar_process_bsd_symtab(Elf *e, size_t *count) 289 { 290 Elf_Arsym *symtab, *sym; 291 unsigned int n, nentries; 292 unsigned char *end, *p, *p0, *s, *s0; 293 const size_t entrysize = 2 * sizeof(long); 294 long arraysize, fileoffset, stroffset, strtabsize; 295 296 assert(e != NULL); 297 assert(count != NULL); 298 assert(e->e_u.e_ar.e_symtab == NULL); 299 300 symtab = NULL; 301 302 /* 303 * The BSD symbol table always contains the count fields even 304 * if there are no entries in it. 305 */ 306 if (e->e_u.e_ar.e_rawsymtabsz < 2 * sizeof(long)) 307 goto symtaberror; 308 309 p = p0 = (unsigned char *) e->e_u.e_ar.e_rawsymtab; 310 end = p0 + e->e_u.e_ar.e_rawsymtabsz; 311 312 /* 313 * Retrieve the size of the array of ranlib descriptors and 314 * check it for validity. 315 */ 316 GET_LONG(p, arraysize); 317 318 if (arraysize < 0 || p0 + arraysize >= end || 319 ((size_t) arraysize % entrysize != 0)) 320 goto symtaberror; 321 322 /* 323 * Check the value of the string table size. 324 */ 325 s = p + arraysize; 326 GET_LONG(s, strtabsize); 327 328 s0 = s; /* Start of string table. */ 329 if (strtabsize < 0 || s0 + strtabsize > end) 330 goto symtaberror; 331 332 nentries = (size_t) arraysize / entrysize; 333 334 /* 335 * Allocate space for the returned Elf_Arsym array. 336 */ 337 if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries + 1))) == NULL) { 338 LIBELF_SET_ERROR(RESOURCE, 0); 339 return (NULL); 340 } 341 342 /* Read in symbol table entries. */ 343 for (n = 0, sym = symtab; n < nentries; n++, sym++) { 344 GET_LONG(p, stroffset); 345 GET_LONG(p, fileoffset); 346 347 if (stroffset < 0 || fileoffset < 0 || 348 (size_t) fileoffset >= e->e_rawsize) 349 goto symtaberror; 350 351 s = s0 + stroffset; 352 353 if (s >= end) 354 goto symtaberror; 355 356 sym->as_off = (off_t) fileoffset; 357 sym->as_hash = elf_hash((char *) s); 358 sym->as_name = (char *) s; 359 } 360 361 /* Fill up the sentinel entry. */ 362 sym->as_name = NULL; 363 sym->as_hash = ~0UL; 364 sym->as_off = (off_t) 0; 365 366 /* Remember the processed symbol table. */ 367 e->e_u.e_ar.e_symtab = symtab; 368 369 *count = e->e_u.e_ar.e_symtabsz = nentries + 1; 370 371 return (symtab); 372 373 symtaberror: 374 if (symtab) 375 free(symtab); 376 LIBELF_SET_ERROR(ARCHIVE, 0); 377 return (NULL); 378 } 379 380 /* 381 * An SVR4-style ar(1) symbol table has the following layout: 382 * 383 * - The first 4 bytes are a binary count of the number of entries in the 384 * symbol table, stored MSB-first. 385 * - Then there are 'n' 4-byte binary offsets, also stored MSB first. 386 * - Following this, there are 'n' null-terminated strings. 387 */ 388 389 #define GET_WORD(P, V) do { \ 390 (V) = 0; \ 391 (V) = (P)[0]; (V) <<= 8; \ 392 (V) += (P)[1]; (V) <<= 8; \ 393 (V) += (P)[2]; (V) <<= 8; \ 394 (V) += (P)[3]; \ 395 } while (0) 396 397 #define INTSZ 4 398 399 400 Elf_Arsym * 401 _libelf_ar_process_svr4_symtab(Elf *e, size_t *count) 402 { 403 uint32_t off; 404 size_t n, nentries; 405 Elf_Arsym *symtab, *sym; 406 unsigned char *p, *s, *end; 407 408 assert(e != NULL); 409 assert(count != NULL); 410 assert(e->e_u.e_ar.e_symtab == NULL); 411 412 symtab = NULL; 413 414 if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) 415 goto symtaberror; 416 417 p = (unsigned char *) e->e_u.e_ar.e_rawsymtab; 418 end = p + e->e_u.e_ar.e_rawsymtabsz; 419 420 GET_WORD(p, nentries); 421 p += INTSZ; 422 423 if (nentries == 0 || p + nentries * INTSZ >= end) 424 goto symtaberror; 425 426 /* Allocate space for a nentries + a sentinel. */ 427 if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) { 428 LIBELF_SET_ERROR(RESOURCE, 0); 429 return (NULL); 430 } 431 432 s = p + (nentries * INTSZ); /* start of the string table. */ 433 434 for (n = nentries, sym = symtab; n > 0; n--) { 435 if (s >= end) 436 goto symtaberror; 437 438 GET_WORD(p, off); 439 if (off >= e->e_rawsize) 440 goto symtaberror; 441 442 sym->as_off = (off_t) off; 443 sym->as_hash = elf_hash((char *) s); 444 sym->as_name = (char *) s; 445 446 p += INTSZ; 447 sym++; 448 449 for (; s < end && *s++ != '\0';) /* skip to next string */ 450 ; 451 } 452 453 /* Fill up the sentinel entry. */ 454 sym->as_name = NULL; 455 sym->as_hash = ~0UL; 456 sym->as_off = (off_t) 0; 457 458 *count = e->e_u.e_ar.e_symtabsz = nentries + 1; 459 e->e_u.e_ar.e_symtab = symtab; 460 461 return (symtab); 462 463 symtaberror: 464 if (symtab) 465 free(symtab); 466 LIBELF_SET_ERROR(ARCHIVE, 0); 467 return (NULL); 468 }