int
__elf_fdnlist(int fd, struct nlist *list)
{
struct nlist *p;
caddr_t strtab;
Elf_Off symoff = 0, symstroff = 0;
Elf_Word symsize = 0, symstrsize = 0;
Elf_Sword nent, cc, i;
Elf_Sym sbuf[1024];
Elf_Sym *s;
Elf_Ehdr ehdr;
Elf_Shdr *shdr = NULL;
Elf_Word shdr_size;
struct stat st;
int usemalloc = 0;
/* Make sure obj is OK */
if (pread(fd, &ehdr, sizeof(Elf_Ehdr), (off_t)0) != sizeof(Elf_Ehdr) ||
!__elf_is_okay__(&ehdr) || fstat(fd, &st) < 0)
return (-1);
/* calculate section header table size */
shdr_size = ehdr.e_shentsize * ehdr.e_shnum;
/* Make sure it's not too big to mmap */
if (shdr_size > SIZE_T_MAX) {
errno = EFBIG;
return (-1);
}
/* mmap section header table */
shdr = (Elf_Shdr *)mmap(NULL, (size_t)shdr_size, PROT_READ,
MAP_SHARED|MAP_FILE, fd, (off_t) ehdr.e_shoff);
if (shdr == MAP_FAILED) {
usemalloc = 1;
if ((shdr = malloc(shdr_size)) == NULL)
return (-1);
if (pread(fd, shdr, shdr_size, (off_t)ehdr.e_shoff) != shdr_size) {
free(shdr);
return (-1);
}
}
/*
* Find the symbol table entry and its corresponding
* string table entry. Version 1.1 of the ABI states
* that there is only one symbol table but that this
* could change in the future.
*/
for (i = 0; i < ehdr.e_shnum; i++) {
if (shdr[i].sh_type == SHT_SYMTAB) {
symoff = shdr[i].sh_offset;
symsize = shdr[i].sh_size;
symstroff = shdr[shdr[i].sh_link].sh_offset;
symstrsize = shdr[shdr[i].sh_link].sh_size;
break;
}
}
/* Flush the section header table */
if (usemalloc)
free(shdr);
else
munmap((caddr_t)shdr, shdr_size);
/* Check for files too large to mmap. */
/* XXX is this really possible? */
if (symstrsize > SIZE_T_MAX) {
errno = EFBIG;
return (-1);
}
/*
* Map string table into our address space. This gives us
* an easy way to randomly access all the strings, without
* making the memory allocation permanent as with malloc/free
* (i.e., munmap will return it to the system).
*/
if (usemalloc) {
if ((strtab = malloc(symstrsize)) == NULL)
return (-1);
if (pread(fd, strtab, symstrsize, (off_t)symstroff) != symstrsize) {
free(strtab);
return (-1);
}
} else {
strtab = mmap(NULL, (size_t)symstrsize, PROT_READ,
MAP_SHARED|MAP_FILE, fd, (off_t) symstroff);
if (strtab == MAP_FAILED)
return (-1);
}
/*
* clean out any left-over information for all valid entries.
* Type and value defined to be 0 if not found; historical
* versions cleared other and desc as well. Also figure out
* the largest string length so don't read any more of the
* string table than we have to.
*
* XXX clearing anything other than n_type and n_value violates
* the semantics given in the man page.
*/
nent = 0;
for (p = list; !ISLAST(p); ++p) {
p->n_type = 0;
p->n_other = 0;
p->n_desc = 0;
p->n_value = 0;
++nent;
}
/* Don't process any further if object is stripped. */
/* ELFism - dunno if stripped by looking at header */
if (symoff == 0)
goto elf_done;
while (symsize > 0) {
cc = MIN(symsize, sizeof(sbuf));
if (pread(fd, sbuf, cc, (off_t)symoff) != cc)
break;
symsize -= cc;
symoff += cc;
for (s = sbuf; cc > 0; ++s, cc -= sizeof(*s)) {
int soff = s->st_name;
if (soff == 0)
continue;
for (p = list; !ISLAST(p); p++) {
char *sym;
/*
* First we check for the symbol as it was
* provided by the user. If that fails
* and the first char is an '_', skip over
* the '_' and try again.
* XXX - What do we do when the user really
* wants '_foo' and the are symbols
* for both 'foo' and '_foo' in the
* table and 'foo' is first?
*/
sym = p->n_un.n_name;
if (strcmp(&strtab[soff], sym) != 0 &&
(sym[0] != '_' ||
strcmp(&strtab[soff], sym + 1) != 0))
continue;
p->n_value = s->st_value;
/* XXX - type conversion */
/* is pretty rude. */
switch(ELF_ST_TYPE(s->st_info)) {
case STT_NOTYPE:
switch (s->st_shndx) {
case SHN_UNDEF:
p->n_type = N_UNDF;
break;
case SHN_ABS:
p->n_type = N_ABS;
break;
case SHN_COMMON:
p->n_type = N_COMM;
break;
default:
p->n_type = N_COMM | N_EXT;
break;
}
break;
case STT_OBJECT:
p->n_type = N_DATA;
break;
case STT_FUNC:
p->n_type = N_TEXT;
break;
case STT_FILE:
p->n_type = N_FN;
break;
}
if (ELF_ST_BIND(s->st_info) ==
STB_LOCAL)
p->n_type = N_EXT;
p->n_desc = 0;
p->n_other = 0;
if (--nent <= 0)
break;
}
}
}
elf_done:
if (usemalloc)
free(strtab);
else
munmap(strtab, symstrsize);
return (nent);
}
int
__elf_fdnlist(int fd, struct nlist *list)
{
struct nlist *p;
Elf_Off symoff = 0, symstroff = 0;
Elf_Size symsize = 0, symstrsize = 0;
Elf_Ssize cc, i;
int nent = -1;
int errsave;
Elf_Sym sbuf[1024];
Elf_Sym *s;
Elf_Ehdr ehdr;
char *strtab = NULL;
Elf_Shdr *shdr = NULL;
Elf_Size shdr_size;
void *base;
struct stat st;
/* Make sure obj is OK */
if (lseek(fd, (off_t)0, SEEK_SET) == -1 ||
_read(fd, &ehdr, sizeof(Elf_Ehdr)) != sizeof(Elf_Ehdr) ||
!__elf_is_okay__(&ehdr) ||
_fstat(fd, &st) < 0)
return (-1);
/* calculate section header table size */
shdr_size = ehdr.e_shentsize * ehdr.e_shnum;
/* Make sure it's not too big to mmap */
if (shdr_size > SIZE_T_MAX) {
errno = EFBIG;
return (-1);
}
/* mmap section header table */
base = mmap(NULL, (size_t)shdr_size, PROT_READ, MAP_PRIVATE, fd,
(off_t)ehdr.e_shoff);
if (base == MAP_FAILED)
return (-1);
shdr = (Elf_Shdr *)base;
/*
* Find the symbol table entry and it's corresponding
* string table entry. Version 1.1 of the ABI states
* that there is only one symbol table but that this
* could change in the future.
*/
for (i = 0; i < ehdr.e_shnum; i++) {
if (shdr[i].sh_type == SHT_SYMTAB) {
symoff = shdr[i].sh_offset;
symsize = shdr[i].sh_size;
symstroff = shdr[shdr[i].sh_link].sh_offset;
symstrsize = shdr[shdr[i].sh_link].sh_size;
break;
}
}
/* Check for files too large to mmap. */
if (symstrsize > SIZE_T_MAX) {
errno = EFBIG;
goto done;
}
/*
* Map string table into our address space. This gives us
* an easy way to randomly access all the strings, without
* making the memory allocation permanent as with malloc/free
* (i.e., munmap will return it to the system).
*/
base = mmap(NULL, (size_t)symstrsize, PROT_READ, MAP_PRIVATE, fd,
(off_t)symstroff);
if (base == MAP_FAILED)
goto done;
strtab = (char *)base;
/*
* clean out any left-over information for all valid entries.
* Type and value defined to be 0 if not found; historical
* versions cleared other and desc as well. Also figure out
* the largest string length so don't read any more of the
* string table than we have to.
*
* XXX clearing anything other than n_type and n_value violates
* the semantics given in the man page.
*/
nent = 0;
for (p = list; !ISLAST(p); ++p) {
p->n_type = 0;
p->n_other = 0;
p->n_desc = 0;
p->n_value = 0;
++nent;
}
/* Don't process any further if object is stripped. */
if (symoff == 0)
goto done;
if (lseek(fd, (off_t) symoff, SEEK_SET) == -1) {
nent = -1;
goto done;
}
while (symsize > 0 && nent > 0) {
cc = MIN(symsize, sizeof(sbuf));
if (_read(fd, sbuf, cc) != cc)
break;
symsize -= cc;
for (s = sbuf; cc > 0 && nent > 0; ++s, cc -= sizeof(*s)) {
char *name;
struct nlist *p;
name = strtab + s->st_name;
if (name[0] == '\0')
continue;
for (p = list; !ISLAST(p); p++) {
if ((p->n_un.n_name[0] == '_' &&
strcmp(name, p->n_un.n_name+1) == 0)
|| strcmp(name, p->n_un.n_name) == 0) {
elf_sym_to_nlist(p, s, shdr,
ehdr.e_shnum);
if (--nent <= 0)
break;
}
}
}
}
done:
errsave = errno;
if (strtab != NULL)
munmap(strtab, symstrsize);
if (shdr != NULL)
munmap(shdr, shdr_size);
errno = errsave;
return (nent);
}
