ext/libelf/libelf_ar.c - amd/gem5 - Git at Google

 /*-
  * 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);
 }
	/*-
	* 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);
	}