it with FreeBSD's implementation --HG-- extra : convert_revision : ef9c4551b9a6b54b76a89f286ff9804c55790621
481 lines
14 KiB
C
481 lines
14 KiB
C
/*-
|
|
* Copyright (c) 2006 Joseph Koshy
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS `AS IS' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <ar.h>
|
|
#include <assert.h>
|
|
#include <ctype.h>
|
|
#include "libelf.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
#include "_libelf.h"
|
|
|
|
#define LIBELF_NALLOC_SIZE 16
|
|
|
|
/*
|
|
* `ar' archive handling.
|
|
*
|
|
* `ar' archives start with signature `ARMAG'. Each archive member is
|
|
* preceded by a header containing meta-data for the member. This
|
|
* header is described in <ar.h> (struct ar_hdr). The header always
|
|
* starts on an even address. File data is padded with "\n"
|
|
* characters to keep this invariant.
|
|
*
|
|
* Special considerations for `ar' archives:
|
|
*
|
|
* The `ar' header only has space for a 16 character file name. File
|
|
* names are terminated with a '/', so this effectively leaves 15
|
|
* characters for the actual file name. In order to accomodate longer
|
|
* file names, names may be stored in a separate 'string table' and
|
|
* referenced indirectly by a member header. The string table itself
|
|
* appears as an archive member with name "// ". An indirect file name
|
|
* in an `ar' header matches the pattern "/[0-9]*". The digits form a
|
|
* decimal number that corresponds to a byte offset into the string
|
|
* table where the actual file name of the object starts. Strings in
|
|
* the string table are padded to start on even addresses.
|
|
*
|
|
* Archives may also have a symbol table (see ranlib(1)), mapping
|
|
* program symbols to object files inside the archive. A symbol table
|
|
* uses a file name of "/ " in its archive header. The symbol table
|
|
* is structured as:
|
|
* - a 4-byte count of entries stored as a binary value, MSB first
|
|
* - 'n' 4-byte offsets, stored as binary values, MSB first
|
|
* - 'n' NUL-terminated strings, for ELF symbol names, stored unpadded.
|
|
*
|
|
* If the symbol table and string table are is present in an archive
|
|
* they must be the very first objects and in that order.
|
|
*/
|
|
|
|
/*
|
|
* Convert a string bounded by `start' and `start+sz' (exclusive) to a
|
|
* number in the specified base.
|
|
*/
|
|
static int
|
|
_libelf_ar_get_number(char *s, size_t sz, int base, size_t *ret)
|
|
{
|
|
int c, v;
|
|
size_t r;
|
|
char *e;
|
|
|
|
assert(base <= 10);
|
|
|
|
e = s + sz;
|
|
|
|
/* skip leading blanks */
|
|
for (;s < e && (c = *s) == ' '; s++)
|
|
;
|
|
|
|
r = 0L;
|
|
for (;s < e; s++) {
|
|
if ((c = *s) == ' ')
|
|
break;
|
|
if (c < '0' || c > '9')
|
|
return (0);
|
|
v = c - '0';
|
|
if (v >= base) /* Illegal digit. */
|
|
break;
|
|
r *= base;
|
|
r += v;
|
|
}
|
|
|
|
*ret = r;
|
|
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
* Retrieve a string from a name field. If `rawname' is set, leave
|
|
* ar(1) control characters in.
|
|
*/
|
|
static char *
|
|
_libelf_ar_get_string(const char *buf, size_t bufsize, int rawname)
|
|
{
|
|
const char *q;
|
|
char *r;
|
|
size_t sz;
|
|
|
|
if (rawname)
|
|
sz = bufsize + 1;
|
|
else {
|
|
/* Skip back over trailing blanks. */
|
|
for (q = buf + bufsize - 1; q >= buf && *q == ' '; --q)
|
|
;
|
|
|
|
if (q < buf) {
|
|
/*
|
|
* If the input buffer only had blanks in it,
|
|
* return a zero-length string.
|
|
*/
|
|
buf = "";
|
|
sz = 1;
|
|
} else {
|
|
/*
|
|
* Remove the trailing '/' character, but only
|
|
* if the name isn't one of the special names
|
|
* "/" and "//".
|
|
*/
|
|
if (q > buf + 1 ||
|
|
(q == (buf + 1) && *buf != '/'))
|
|
q--;
|
|
|
|
sz = q - buf + 2; /* Space for a trailing NUL. */
|
|
}
|
|
}
|
|
|
|
if ((r = malloc(sz)) == NULL) {
|
|
LIBELF_SET_ERROR(RESOURCE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
(void) strncpy(r, buf, sz);
|
|
r[sz - 1] = '\0';
|
|
|
|
return (r);
|
|
}
|
|
|
|
/*
|
|
* Retrieve the full name of the archive member.
|
|
*/
|
|
static char *
|
|
_libelf_ar_get_name(char *buf, size_t bufsize, Elf *e)
|
|
{
|
|
char c, *q, *r, *s;
|
|
size_t len;
|
|
size_t offset;
|
|
|
|
assert(e->e_kind == ELF_K_AR);
|
|
|
|
if (buf[0] == '/' && (c = buf[1]) >= '0' && c <= '9') {
|
|
/*
|
|
* The value in field ar_name is a decimal offset into
|
|
* the archive string table where the actual name
|
|
* resides.
|
|
*/
|
|
if (_libelf_ar_get_number(buf + 1, bufsize - 1, 10,
|
|
&offset) == 0) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
if (offset > e->e_u.e_ar.e_rawstrtabsz) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
s = q = e->e_u.e_ar.e_rawstrtab + offset;
|
|
r = e->e_u.e_ar.e_rawstrtab + e->e_u.e_ar.e_rawstrtabsz;
|
|
|
|
for (s = q; s < r && *s != '/'; s++)
|
|
;
|
|
len = s - q + 1; /* space for the trailing NUL */
|
|
|
|
if ((s = malloc(len)) == NULL) {
|
|
LIBELF_SET_ERROR(RESOURCE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
(void) strncpy(s, q, len);
|
|
s[len - 1] = '\0';
|
|
|
|
return (s);
|
|
}
|
|
|
|
/*
|
|
* Normal 'name'
|
|
*/
|
|
return (_libelf_ar_get_string(buf, bufsize, 0));
|
|
}
|
|
|
|
|
|
Elf_Arhdr *
|
|
_libelf_ar_gethdr(Elf *e)
|
|
{
|
|
Elf *parent;
|
|
struct ar_hdr *arh;
|
|
Elf_Arhdr *eh;
|
|
size_t n;
|
|
|
|
if ((parent = e->e_parent) == NULL) {
|
|
LIBELF_SET_ERROR(ARGUMENT, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
arh = (struct ar_hdr *) ((uintptr_t) e->e_rawfile - sizeof(struct ar_hdr));
|
|
|
|
assert((uintptr_t) arh >= (uintptr_t) parent->e_rawfile + SARMAG);
|
|
assert((uintptr_t) arh <= (uintptr_t) parent->e_rawfile + parent->e_rawsize -
|
|
sizeof(struct ar_hdr));
|
|
|
|
if ((eh = malloc(sizeof(Elf_Arhdr))) == NULL) {
|
|
LIBELF_SET_ERROR(RESOURCE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
e->e_arhdr = eh;
|
|
eh->ar_name = eh->ar_rawname = NULL;
|
|
|
|
if ((eh->ar_name = _libelf_ar_get_name(arh->ar_name, sizeof(arh->ar_name),
|
|
parent)) == NULL)
|
|
goto error;
|
|
|
|
if (_libelf_ar_get_number(arh->ar_uid, sizeof(arh->ar_uid), 10, &n) == 0)
|
|
goto error;
|
|
eh->ar_uid = (uid_t) n;
|
|
|
|
if (_libelf_ar_get_number(arh->ar_gid, sizeof(arh->ar_gid), 10, &n) == 0)
|
|
goto error;
|
|
eh->ar_gid = (gid_t) n;
|
|
|
|
if (_libelf_ar_get_number(arh->ar_mode, sizeof(arh->ar_mode), 8, &n) == 0)
|
|
goto error;
|
|
eh->ar_mode = (mode_t) n;
|
|
|
|
if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &n) == 0)
|
|
goto error;
|
|
eh->ar_size = n;
|
|
|
|
if ((eh->ar_rawname = _libelf_ar_get_string(arh->ar_name,
|
|
sizeof(arh->ar_name), 1)) == NULL)
|
|
goto error;
|
|
|
|
return (eh);
|
|
|
|
error:
|
|
if (eh) {
|
|
if (eh->ar_name)
|
|
free(eh->ar_name);
|
|
if (eh->ar_rawname)
|
|
free(eh->ar_rawname);
|
|
free(eh);
|
|
}
|
|
e->e_arhdr = NULL;
|
|
|
|
return (NULL);
|
|
}
|
|
|
|
Elf *
|
|
_libelf_ar_open_member(int fd, Elf_Cmd c, Elf *elf)
|
|
{
|
|
Elf *e;
|
|
off_t next;
|
|
struct ar_hdr *arh;
|
|
size_t sz;
|
|
|
|
assert(elf->e_kind == ELF_K_AR);
|
|
|
|
next = elf->e_u.e_ar.e_next;
|
|
|
|
/*
|
|
* `next' is only set to zero by elf_next() when the last
|
|
* member of an archive is processed.
|
|
*/
|
|
if (next == (off_t) 0)
|
|
return (NULL);
|
|
|
|
assert((next & 1) == 0);
|
|
|
|
arh = (struct ar_hdr *) (elf->e_rawfile + next);
|
|
|
|
if (_libelf_ar_get_number(arh->ar_size, sizeof(arh->ar_size), 10, &sz) == 0) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
assert(sz > 0);
|
|
|
|
arh++; /* skip over archive member header */
|
|
|
|
if ((e = elf_memory((char *) arh, sz)) == NULL)
|
|
return (NULL);
|
|
|
|
e->e_fd = fd;
|
|
e->e_cmd = c;
|
|
|
|
elf->e_u.e_ar.e_nchildren++;
|
|
e->e_parent = elf;
|
|
|
|
return (e);
|
|
}
|
|
|
|
Elf *
|
|
_libelf_ar_open(Elf *e)
|
|
{
|
|
int i;
|
|
char *s, *end;
|
|
size_t sz;
|
|
struct ar_hdr arh;
|
|
|
|
e->e_kind = ELF_K_AR;
|
|
e->e_u.e_ar.e_nchildren = 0;
|
|
e->e_u.e_ar.e_next = (off_t) -1;
|
|
|
|
/*
|
|
* Look for special members.
|
|
*/
|
|
|
|
s = e->e_rawfile + SARMAG;
|
|
end = e->e_rawfile + e->e_rawsize;
|
|
|
|
assert(e->e_rawsize > 0);
|
|
|
|
/*
|
|
* Look for magic names "/ " and "// " in the first two entries
|
|
* of the archive.
|
|
*/
|
|
for (i = 0; i < 2; i++) {
|
|
|
|
if (s + sizeof(arh) > end) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
(void) memcpy(&arh, s, sizeof(arh));
|
|
|
|
if (arh.ar_fmag[0] != '`' || arh.ar_fmag[1] != '\n') {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
if (arh.ar_name[0] != '/') /* not a special symbol */
|
|
break;
|
|
|
|
if (_libelf_ar_get_number(arh.ar_size, sizeof(arh.ar_size), 10, &sz) == 0) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
assert(sz > 0);
|
|
|
|
s += sizeof(arh);
|
|
|
|
if (arh.ar_name[1] == ' ') { /* "/ " => symbol table */
|
|
|
|
e->e_u.e_ar.e_rawsymtab = s;
|
|
e->e_u.e_ar.e_rawsymtabsz = sz;
|
|
|
|
} else if (arh.ar_name[1] == '/' && arh.ar_name[2] == ' ') {
|
|
|
|
/* "// " => string table for long file names */
|
|
e->e_u.e_ar.e_rawstrtab = s;
|
|
e->e_u.e_ar.e_rawstrtabsz = sz;
|
|
}
|
|
|
|
sz = LIBELF_ADJUST_AR_SIZE(sz);
|
|
|
|
s += sz;
|
|
}
|
|
|
|
e->e_u.e_ar.e_next = (off_t) (s - e->e_rawfile);
|
|
|
|
return (e);
|
|
}
|
|
|
|
/*
|
|
* An ar(1) symbol table has the following layout:
|
|
*
|
|
* The first 4 bytes are a binary count of the number of entries in the
|
|
* symbol table, stored MSB-first.
|
|
*
|
|
* Then there are 'n' 4-byte binary offsets, also stored MSB first.
|
|
*
|
|
* Following this, there are 'n' null-terminated strings.
|
|
*/
|
|
|
|
#define GET_WORD(P, V) do { \
|
|
(V) = 0; \
|
|
(V) = (P)[0]; (V) <<= 8; \
|
|
(V) += (P)[1]; (V) <<= 8; \
|
|
(V) += (P)[2]; (V) <<= 8; \
|
|
(V) += (P)[3]; \
|
|
} while (0)
|
|
|
|
#define INTSZ 4
|
|
|
|
Elf_Arsym *
|
|
_libelf_ar_process_symtab(Elf *e, size_t *count)
|
|
{
|
|
size_t n, nentries, off;
|
|
Elf_Arsym *symtab, *sym;
|
|
char *p, *s, *end;
|
|
|
|
assert(e != NULL);
|
|
assert(count != NULL);
|
|
|
|
if (e->e_u.e_ar.e_rawsymtabsz < INTSZ) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
p = e->e_u.e_ar.e_rawsymtab;
|
|
end = p + e->e_u.e_ar.e_rawsymtabsz;
|
|
|
|
GET_WORD(p, nentries);
|
|
p += INTSZ;
|
|
|
|
if (nentries == 0 || p + nentries * INTSZ >= end) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
/* Allocate space for a nentries + a sentinel. */
|
|
if ((symtab = malloc(sizeof(Elf_Arsym) * (nentries+1))) == NULL) {
|
|
LIBELF_SET_ERROR(RESOURCE, 0);
|
|
return (NULL);
|
|
}
|
|
|
|
s = p + (nentries * INTSZ); /* start of the string table. */
|
|
|
|
for (n = nentries, sym = symtab; n > 0; n--) {
|
|
off = 0;
|
|
|
|
GET_WORD(p, off);
|
|
|
|
sym->as_off = off;
|
|
sym->as_hash = elf_hash(s);
|
|
sym->as_name = s;
|
|
|
|
p += INTSZ;
|
|
sym++;
|
|
|
|
for (; s < end && *s++ != '\0';) /* skip to next string */
|
|
;
|
|
if (s > end) {
|
|
LIBELF_SET_ERROR(ARCHIVE, 0);
|
|
free(symtab);
|
|
return (NULL);
|
|
}
|
|
}
|
|
|
|
/* Fill up the sentinel entry. */
|
|
sym->as_name = NULL;
|
|
sym->as_hash = ~0UL;
|
|
sym->as_off = (off_t) 0;
|
|
|
|
*count = e->e_u.e_ar.e_symtabsz = nentries + 1;
|
|
e->e_u.e_ar.e_symtab = symtab;
|
|
|
|
return (symtab);
|
|
}
|