2 * Copyright (c) 2006 Joseph Koshy
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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
27 #include <sys/cdefs.h>
28 __FBSDID("$FreeBSD$");
39 #define LIBELF_NALLOC_SIZE 16
42 * `ar' archive handling.
44 * `ar' archives start with signature `ARMAG'. Each archive member is
45 * preceded by a header containing meta-data for the member. This
46 * header is described in <ar.h> (struct ar_hdr). The header always
47 * starts on an even address. File data is padded with "\n"
48 * characters to keep this invariant.
50 * Special considerations for `ar' archives:
52 * The `ar' header only has space for a 16 character file name. File
53 * names are terminated with a '/', so this effectively leaves 15
54 * characters for the actual file name. In order to accomodate longer
55 * file names, names may be stored in a separate 'string table' and
56 * referenced indirectly by a member header. The string table itself
57 * appears as an archive member with name "// ". An indirect file name
58 * in an `ar' header matches the pattern "/[0-9]*". The digits form a
59 * decimal number that corresponds to a byte offset into the string
60 * table where the actual file name of the object starts. Strings in
61 * the string table are padded to start on even addresses.
63 * Archives may also have a symbol table (see ranlib(1)), mapping
64 * program symbols to object files inside the archive. A symbol table
65 * uses a file name of "/ " in its archive header. The symbol table
67 * - a 4-byte count of entries stored as a binary value, MSB first
68 * - 'n' 4-byte offsets, stored as binary values, MSB first
69 * - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
71 * If the symbol table and string table are is present in an archive
72 * they must be the very first objects and in that order.
76 * Convert a string bounded by `start' and `start+sz' (exclusive) to a
77 * number in the specified base.
80 _libelf_ar_get_number(char *s, size_t sz, int base, size_t *ret)
90 /* skip leading blanks */
91 for (;s < e && (c = *s) == ' '; s++)
98 if (c < '0' || c > '9')
101 if (v >= base) /* Illegal digit. */
113 * Retrieve a string from a name field. If `rawname' is set, leave
114 * ar(1) control characters in.
117 _libelf_ar_get_string(const char *buf, size_t bufsize, int rawname)
126 /* Skip back over trailing blanks. */
127 for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q)
132 * If the input buffer only had blanks in it,
133 * return a zero-length string.
139 * Remove the trailing '/' character, but only
140 * if the name isn't one of the special names
144 (q == (buf + 1) && *buf != '/'))
147 sz = q - buf + 2; /* Space for a trailing NUL. */
151 if ((r = malloc(sz)) == NULL) {
152 LIBELF_SET_ERROR(RESOURCE, 0);
156 (void) strncpy(r, buf, sz);
163 * Retrieve the full name of the archive member.
166 _libelf_ar_get_name(char *buf, size_t bufsize, Elf *e)
172 assert(e->e_kind == ELF_K_AR);
174 if (buf[0] == '/' && (c = buf[1]) >= '0' && c <= '9') {
176 * The value in field ar_name is a decimal offset into
177 * the archive string table where the actual name
180 if (_libelf_ar_get_number(buf + 1, bufsize - 1, 10,
182 LIBELF_SET_ERROR(ARCHIVE, 0);
186 if (offset > e->e_u.e_ar.e_rawstrtabsz) {
187 LIBELF_SET_ERROR(ARCHIVE, 0);
191 s = q = e->e_u.e_ar.e_rawstrtab + offset;
192 r = e->e_u.e_ar.e_rawstrtab + e->e_u.e_ar.e_rawstrtabsz;
194 for (s = q; s < r && *s != '/'; s++)
196 len = s - q + 1; /* space for the trailing NUL */
198 if ((s = malloc(len)) == NULL) {
199 LIBELF_SET_ERROR(RESOURCE, 0);
203 (void) strncpy(s, q, len);
212 return (_libelf_ar_get_string(buf, bufsize, 0));
217 _libelf_ar_gethdr(Elf *e)
224 if ((parent = e->e_parent) == NULL) {
225 LIBELF_SET_ERROR(ARGUMENT, 0);
229 arh = (struct ar_hdr *) ((uintptr_t) e->e_rawfile - sizeof(struct ar_hdr));
231 assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
232 assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + parent->e_rawsize -
233 sizeof(struct ar_hdr));
235 if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
236 LIBELF_SET_ERROR(RESOURCE, 0);
241 eh->ar_name = eh->ar_rawname = NULL;
243 if ((eh->ar_name = _libelf_ar_get_name(arh->ar_name, sizeof(arh->ar_name),
247 if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, &n) == 0)
249 eh->ar_uid = (uid_t) n;
251 if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, &n) == 0)
253 eh->ar_gid = (gid_t) n;
255 if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, &n) == 0)
257 eh->ar_mode = (mode_t) n;
259 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &n) == 0)
263 if ((eh->ar_rawname = _libelf_ar_get_string(arh->ar_name,
264 sizeof(arh->ar_name), 1)) == NULL)
274 free(eh->ar_rawname);
283 _libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
290 assert(elf->e_kind == ELF_K_AR);
292 next = elf->e_u.e_ar.e_next;
295 * `next' is only set to zero by elf_next() when the last
296 * member of an archive is processed.
298 if (next == (off_t) 0)
301 assert((next & 1) == 0);
303 arh = (struct ar_hdr *) (elf->e_rawfile + next);
305 if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &sz) == 0) {
306 LIBELF_SET_ERROR(ARCHIVE, 0);
312 arh++; /* skip over archive member header */
314 if ((e = elf_memory((char *) arh, sz)) == NULL)
320 elf->e_u.e_ar.e_nchildren++;
327 _libelf_ar_open(Elf *e)
334 e->e_kind = ELF_K_AR;
335 e->e_u.e_ar.e_nchildren = 0;
336 e->e_u.e_ar.e_next = (off_t) -1;
339 * Look for special members.
342 s = e->e_rawfile + SARMAG;
343 end = e->e_rawfile + e->e_rawsize;
345 assert(e->e_rawsize > 0);
348 * Look for magic names "/ " and "// " in the first two entries
351 for (i = 0; i < 2; i++) {
353 if (s + sizeof(arh) > end) {
354 LIBELF_SET_ERROR(ARCHIVE, 0);
358 (void) memcpy(&arh, s, sizeof(arh));
360 if (arh.ar_fmag[0] != '`' || arh.ar_fmag[1] != '\n') {
361 LIBELF_SET_ERROR(ARCHIVE, 0);
365 if (arh.ar_name[0] != '/') /* not a special symbol */
368 if (_libelf_ar_get_number(arh.ar_size, sizeof(arh.ar_size), 10, &sz) == 0) {
369 LIBELF_SET_ERROR(ARCHIVE, 0);
377 if (arh.ar_name[1] == ' ') { /* "/ " => symbol table */
379 e->e_u.e_ar.e_rawsymtab = s;
380 e->e_u.e_ar.e_rawsymtabsz = sz;
382 } else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') {
384 /* "// " => string table for long file names */
385 e->e_u.e_ar.e_rawstrtab = s;
386 e->e_u.e_ar.e_rawstrtabsz = sz;
389 sz = LIBELF_ADJUST_AR_SIZE(sz);
394 e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile);
400 * An ar(1) symbol table has the following layout:
402 * The first 4 bytes are a binary count of the number of entries in the
403 * symbol table, stored MSB-first.
405 * Then there are 'n' 4-byte binary offsets, also stored MSB first.
407 * Following this, there are 'n' null-terminated strings.
410 #define GET_WORD(P, V) do { \
412 (V) = (P)[0]; (V) <<= 8; \
413 (V) += (P)[1]; (V) <<= 8; \
414 (V) += (P)[2]; (V) <<= 8; \
421 _libelf_ar_process_symtab(Elf *e, size_t *count)
423 size_t n, nentries, off;
424 Elf_Arsym *symtab, *sym;
425 unsigned char *p, *s, *end;
428 assert(count != NULL);
430 if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) {
431 LIBELF_SET_ERROR(ARCHIVE, 0);
435 p = (unsigned char *) e->e_u.e_ar.e_rawsymtab;
436 end = p + e->e_u.e_ar.e_rawsymtabsz;
438 GET_WORD(p, nentries);
441 if (nentries == 0 || p + nentries * INTSZ >= end) {
442 LIBELF_SET_ERROR(ARCHIVE, 0);
446 /* Allocate space for a nentries + a sentinel. */
447 if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
448 LIBELF_SET_ERROR(RESOURCE, 0);
452 s = p + (nentries * INTSZ); /* start of the string table. */
454 for (n = nentries, sym = symtab; n > 0; n--) {
460 sym->as_hash = elf_hash(s);
466 for (; s < end && *s++ != '\0';) /* skip to next string */
469 LIBELF_SET_ERROR(ARCHIVE, 0);
475 /* Fill up the sentinel entry. */
478 sym->as_off = (off_t) 0;
480 *count = e->e_u.e_ar.e_symtabsz = nentries + 1;
481 e->e_u.e_ar.e_symtab = symtab;