777 lines
30 KiB
C
777 lines
30 KiB
C
#include <stdio.h>
|
|
#include <common.h>
|
|
#include <debug.h>
|
|
#include <libelf.h>
|
|
#include <libebl.h>
|
|
#include <elf.h>
|
|
#include <gelf.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <hash.h>
|
|
#include <lsd.h>
|
|
|
|
extern int verbose_flag;
|
|
|
|
typedef struct source_t source_t;
|
|
|
|
typedef struct {
|
|
Elf_Scn *scn;
|
|
GElf_Shdr shdr;
|
|
Elf_Data *data;
|
|
} section_info_t;
|
|
|
|
typedef struct next_export_t {
|
|
source_t *source;
|
|
int next_idx;
|
|
} next_export_t;
|
|
|
|
struct source_t {
|
|
source_t *next;
|
|
int visited;
|
|
|
|
char *name; /* full path name of this executable file */
|
|
/* ELF-related information: */
|
|
Elf *elf;
|
|
int elf_fd;
|
|
GElf_Ehdr elf_hdr;
|
|
size_t shstrndx;
|
|
int shnum; /* number of sections */
|
|
|
|
section_info_t symtab;
|
|
section_info_t strtab;
|
|
section_info_t dynamic;
|
|
section_info_t hash;
|
|
|
|
section_info_t *relocations;
|
|
int num_relocations; /* number of relocs (<= relocations_size) */
|
|
int relocations_size; /* sice of array -- NOT number of relocs! */
|
|
|
|
/* satisfied_execs: array containing pointers to the libraries or
|
|
executables that this executable satisfies symbol references for. */
|
|
source_t **satisfied_execs;
|
|
int num_satisfied_execs;
|
|
int satisfied_execs_size;
|
|
|
|
/* satisfied: array is parallel to symbol table; for each undefined symbol
|
|
in that array, we maintain a flag stating whether that symbol has been
|
|
satisfied, and if so, by which library. This applies both to executable
|
|
files and libraries.
|
|
*/
|
|
source_t **satisfied;
|
|
|
|
/* exports: array is parallel to symbol table; for each global symbol
|
|
in that array, we maintain a flag stating whether that symbol satisfies
|
|
a dependency in some other file. num_syms is the length of the exports
|
|
array, as well as the satisfied array. This applied to libraries only.
|
|
|
|
next_exports: this is a bit tricky. We use this field to maintain a
|
|
linked list of source_t for each global symbol of a shared library.
|
|
For a shared library's global symbol at index N has the property that
|
|
exports[N] is the head of a linked list (threaded through next_export)
|
|
of all source_t that this symbol resolves a reference to. For example,
|
|
if symbol printf has index 1000 in libc.so, and an executable A and
|
|
library L use printf, then the source_t entry corresponding to libc.so
|
|
will have exports[1000] be a linked list that contains the nodes for
|
|
application A and library L.
|
|
*/
|
|
|
|
next_export_t *exports;
|
|
/* num_exported is the number of symbols in this file actually used by
|
|
somebody else; it's not the size of the exports array. */
|
|
int num_exported;
|
|
next_export_t *next_export;
|
|
int num_next_export;
|
|
int next_export_size;
|
|
|
|
int num_syms; /* number of symbols in symbol table. This is the length of
|
|
both exports[] and satisfied[] arrays. */
|
|
|
|
/* This is an array that contains one element for each library dependency
|
|
listed in the executable or shared library. */
|
|
source_t **lib_deps; /* list of library dependencies */
|
|
int num_lib_deps; /* actual number of library dependencies */
|
|
int lib_deps_size; /* size of lib_deps array--NOT actual number of deps! */
|
|
|
|
};
|
|
|
|
static source_t *sources = NULL;
|
|
|
|
static char * find_file(const char *libname,
|
|
char **lib_lookup_dirs,
|
|
int num_lib_lookup_dirs);
|
|
|
|
static inline source_t* find_source(const char *name,
|
|
char **lib_lookup_dirs,
|
|
int num_lib_lookup_dirs) {
|
|
source_t *trav = sources;
|
|
char *full = find_file(name, lib_lookup_dirs, num_lib_lookup_dirs);
|
|
FAILIF(full == NULL, "Cannot construct full path for file [%s]!\n", name);
|
|
while (trav) {
|
|
if (!strcmp(trav->name, full))
|
|
break;
|
|
trav = trav->next;
|
|
}
|
|
free(full);
|
|
return trav;
|
|
}
|
|
|
|
static inline void add_to_sources(source_t *src) {
|
|
src->next = sources;
|
|
sources = src;
|
|
}
|
|
|
|
static source_t* init_source(char *full_path) {
|
|
source_t *source = (source_t *)CALLOC(1, sizeof(source_t));
|
|
|
|
ASSERT(full_path);
|
|
source->name = full_path;
|
|
source->elf_fd = -1;
|
|
|
|
INFO("Opening %s...\n", full_path);
|
|
source->elf_fd = open(full_path, O_RDONLY);
|
|
FAILIF(source->elf_fd < 0, "open(%s): %s (%d)\n",
|
|
full_path,
|
|
strerror(errno),
|
|
errno);
|
|
INFO("Calling elf_begin(%s)...\n", full_path);
|
|
source->elf = elf_begin(source->elf_fd, ELF_C_READ, NULL);
|
|
FAILIF_LIBELF(source->elf == NULL, elf_begin);
|
|
|
|
/* libelf can recognize COFF and A.OUT formats, but we handle only ELF. */
|
|
if (elf_kind(source->elf) != ELF_K_ELF) {
|
|
ERROR("Input file %s is not in ELF format!\n", full_path);
|
|
return NULL;
|
|
}
|
|
|
|
/* Make sure this is a shared library or an executable. */
|
|
{
|
|
INFO("Making sure %s is a shared library or an executable...\n",
|
|
full_path);
|
|
FAILIF_LIBELF(0 == gelf_getehdr(source->elf, &source->elf_hdr), gelf_getehdr);
|
|
FAILIF(source->elf_hdr.e_type != ET_DYN &&
|
|
source->elf_hdr.e_type != ET_EXEC,
|
|
"%s must be a shared library (elf type is %d, expecting %d).\n",
|
|
full_path,
|
|
source->elf_hdr.e_type,
|
|
ET_DYN);
|
|
}
|
|
|
|
/* Get the index of the section-header-strings-table section. */
|
|
FAILIF_LIBELF(elf_getshstrndx (source->elf, &source->shstrndx) < 0,
|
|
elf_getshstrndx);
|
|
|
|
FAILIF_LIBELF(elf_getshnum (source->elf, &source->shnum) < 0, elf_getshnum);
|
|
|
|
/* Find various sections. */
|
|
size_t scnidx;
|
|
Elf_Scn *scn;
|
|
GElf_Shdr *shdr, shdr_mem;
|
|
INFO("Locating %d sections in %s...\n", source->shnum, full_path);
|
|
for (scnidx = 1; scnidx < source->shnum; scnidx++) {
|
|
scn = elf_getscn(source->elf, scnidx);
|
|
FAILIF_LIBELF(NULL == scn, elf_getscn);
|
|
shdr = gelf_getshdr(scn, &shdr_mem);
|
|
FAILIF_LIBELF(NULL == shdr, gelf_getshdr);
|
|
INFO("\tfound section [%s]...\n", elf_strptr(source->elf, source->shstrndx, shdr->sh_name));
|
|
if (shdr->sh_type == SHT_DYNSYM) {
|
|
source->symtab.scn = scn;
|
|
source->symtab.data = elf_getdata(scn, NULL);
|
|
FAILIF_LIBELF(NULL == source->symtab.data, elf_getdata);
|
|
memcpy(&source->symtab.shdr, shdr, sizeof(GElf_Shdr));
|
|
|
|
/* The sh_link field of the section header of the symbol table
|
|
contains the index of the associated strings table. */
|
|
source->strtab.scn = elf_getscn(source->elf,
|
|
source->symtab.shdr.sh_link);
|
|
FAILIF_LIBELF(NULL == source->strtab.scn, elf_getscn);
|
|
FAILIF_LIBELF(NULL == gelf_getshdr(scn, &source->strtab.shdr),
|
|
gelf_getshdr);
|
|
source->strtab.data = elf_getdata(source->strtab.scn, NULL);
|
|
FAILIF_LIBELF(NULL == source->strtab.data, elf_getdata);
|
|
}
|
|
else if (shdr->sh_type == SHT_DYNAMIC) {
|
|
source->dynamic.scn = scn;
|
|
source->dynamic.data = elf_getdata(scn, NULL);
|
|
FAILIF_LIBELF(NULL == source->symtab.data, elf_getdata);
|
|
memcpy(&source->dynamic.shdr, shdr, sizeof(GElf_Shdr));
|
|
}
|
|
else if (shdr->sh_type == SHT_HASH) {
|
|
source->hash.scn = scn;
|
|
source->hash.data = elf_getdata(scn, NULL);
|
|
FAILIF_LIBELF(NULL == source->hash.data, elf_getdata);
|
|
memcpy(&source->hash.shdr, shdr, sizeof(GElf_Shdr));
|
|
}
|
|
else if (shdr->sh_type == SHT_REL || shdr->sh_type == SHT_RELA) {
|
|
if (source->num_relocations == source->relocations_size) {
|
|
source->relocations_size += 5;
|
|
source->relocations =
|
|
(section_info_t *)REALLOC(source->relocations,
|
|
source->relocations_size *
|
|
sizeof(section_info_t));
|
|
}
|
|
section_info_t *reloc =
|
|
source->relocations + source->num_relocations;
|
|
reloc->scn = scn;
|
|
reloc->data = elf_getdata(scn, NULL);
|
|
FAILIF_LIBELF(NULL == reloc->data, elf_getdata);
|
|
memcpy(&reloc->shdr, shdr, sizeof(GElf_Shdr));
|
|
source->num_relocations++;
|
|
}
|
|
}
|
|
|
|
if (source->dynamic.scn == NULL) {
|
|
INFO("File [%s] does not have a dynamic section!\n", full_path);
|
|
return 0;
|
|
}
|
|
|
|
FAILIF(source->symtab.scn == NULL,
|
|
"File [%s] does not have a dynamic symbol table!\n",
|
|
full_path);
|
|
|
|
FAILIF(source->hash.scn == NULL,
|
|
"File [%s] does not have a hash table!\n",
|
|
full_path);
|
|
FAILIF(source->hash.shdr.sh_link != elf_ndxscn(source->symtab.scn),
|
|
"Hash points to section %d, not to %d as expected!\n",
|
|
source->hash.shdr.sh_link,
|
|
elf_ndxscn(scn));
|
|
|
|
/* Now, find out how many symbols we have and allocate the array of
|
|
satisfied symbols.
|
|
|
|
NOTE: We don't count the number of undefined symbols here; we will
|
|
iterate over the symbol table later, and count them then, when it is
|
|
more convenient.
|
|
*/
|
|
size_t symsize = gelf_fsize (source->elf,
|
|
ELF_T_SYM,
|
|
1, source->elf_hdr.e_version);
|
|
ASSERT(symsize);
|
|
|
|
source->num_syms = source->symtab.data->d_size / symsize;
|
|
source->satisfied = (source_t **)CALLOC(source->num_syms,
|
|
sizeof(source_t *));
|
|
source->exports = (source_t **)CALLOC(source->num_syms,
|
|
sizeof(next_export_t));
|
|
|
|
source->num_exported = 0;
|
|
source->satisfied_execs = NULL;
|
|
source->num_satisfied_execs = 0;
|
|
source->satisfied_execs_size = 0;
|
|
|
|
add_to_sources(source);
|
|
return source;
|
|
}
|
|
|
|
static void destroy_source(source_t *source) {
|
|
FREE(source->satisfied_execs);
|
|
FREE(source->satisfied);
|
|
FREE(source->exports);
|
|
FREE(source->next_export);
|
|
FREE(source->lib_deps); /* list of library dependencies */
|
|
FAILIF_LIBELF(elf_end(source->elf), elf_end);
|
|
FAILIF(close(source->elf_fd) < 0, "Could not close file %s: %s (%d)!\n",
|
|
source->name, strerror(errno), errno);
|
|
FREE(source->name);
|
|
FREE(source);
|
|
}
|
|
|
|
static void print_needed_libs(source_t *source)
|
|
{
|
|
size_t idx;
|
|
for (idx = 0; idx < source->num_lib_deps; idx++) {
|
|
PRINT("%s:%s\n",
|
|
source->name,
|
|
source->lib_deps[idx]->name);
|
|
}
|
|
}
|
|
|
|
static int is_symbol_imported(source_t *source,
|
|
GElf_Sym *sym,
|
|
size_t symidx)
|
|
{
|
|
const char *symname = elf_strptr(source->elf,
|
|
elf_ndxscn(source->strtab.scn),
|
|
sym->st_name);
|
|
|
|
/* A symbol is imported by an executable or a library if it is undefined
|
|
and is either global or weak. There is an additional case for
|
|
executables that we will check below. */
|
|
if (sym->st_shndx == SHN_UNDEF &&
|
|
(GELF_ST_BIND(sym->st_info) == STB_GLOBAL ||
|
|
GELF_ST_BIND(sym->st_info) == STB_WEAK)) {
|
|
INFO("*** symbol [%s:%s] is imported (UNDEFIEND).\n",
|
|
source->name,
|
|
symname);
|
|
return 1;
|
|
}
|
|
|
|
#ifdef ARM_SPECIFIC_HACKS
|
|
/* A symbol is imported by an executable if is marked as an undefined
|
|
symbol--this is standard to all ELF formats. Alternatively, according
|
|
to the ARM specifications, a symbol in a BSS section that is also marked
|
|
by an R_ARM_COPY relocation is also imported. */
|
|
|
|
if (source->elf_hdr.e_type != ET_EXEC) {
|
|
INFO("is_symbol_imported(): [%s] is a library, "
|
|
"no further checks.\n", source->name);
|
|
return 0;
|
|
}
|
|
|
|
/* Is the symbol in the BSS section, and is there a COPY relocation on
|
|
that symbol? */
|
|
INFO("*** [%s:%s] checking further to see if symbol is imported.\n",
|
|
source->name, symname);
|
|
if (sym->st_shndx < source->shnum) {
|
|
/* Is it the .bss section? */
|
|
Elf_Scn *scn = elf_getscn(source->elf, sym->st_shndx);
|
|
FAILIF_LIBELF(NULL == scn, elf_getscn);
|
|
GElf_Shdr *shdr, shdr_mem;
|
|
shdr = gelf_getshdr(scn, &shdr_mem);
|
|
FAILIF_LIBELF(NULL == shdr, gelf_getshdr);
|
|
if (!strcmp(".bss", elf_strptr(source->elf,
|
|
source->shstrndx,
|
|
shdr->sh_name)))
|
|
{
|
|
/* Is there an R_ARM_COPY relocation on this symbol? Iterate
|
|
over the list of relocation sections and scan each section for
|
|
an entry that matches the symbol. */
|
|
size_t idx;
|
|
for (idx = 0; idx < source->num_relocations; idx++) {
|
|
section_info_t *reloc = source->relocations + idx;
|
|
/* Does the relocation section refer to the symbol table in
|
|
which this symbol resides, and does it relocate the .bss
|
|
section? */
|
|
if (reloc->shdr.sh_link == elf_ndxscn(source->symtab.scn) &&
|
|
reloc->shdr.sh_info == sym->st_shndx)
|
|
{
|
|
/* Go over the relocations and see if any of them matches
|
|
our symbol. */
|
|
size_t nrels = reloc->shdr.sh_size / reloc->shdr.sh_entsize;
|
|
size_t relidx, newidx;
|
|
if (reloc->shdr.sh_type == SHT_REL) {
|
|
for (newidx = relidx = 0; relidx < nrels; ++relidx) {
|
|
GElf_Rel rel_mem;
|
|
FAILIF_LIBELF(gelf_getrel (reloc->data,
|
|
relidx,
|
|
&rel_mem) == NULL,
|
|
gelf_getrel);
|
|
if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_COPY &&
|
|
GELF_R_SYM (rel_mem.r_info) == symidx)
|
|
{
|
|
INFO("*** symbol [%s:%s] is imported "
|
|
"(DEFINED, REL-COPY-RELOCATED).\n",
|
|
source->name,
|
|
symname);
|
|
return 1;
|
|
}
|
|
} /* for each rel entry... */
|
|
} else {
|
|
for (newidx = relidx = 0; relidx < nrels; ++relidx) {
|
|
GElf_Rela rel_mem;
|
|
FAILIF_LIBELF(gelf_getrela (reloc->data,
|
|
relidx,
|
|
&rel_mem) == NULL,
|
|
gelf_getrela);
|
|
if (GELF_R_TYPE(rel_mem.r_info) == R_ARM_COPY &&
|
|
GELF_R_SYM (rel_mem.r_info) == symidx)
|
|
{
|
|
INFO("*** symbol [%s:%s] is imported "
|
|
"(DEFINED, RELA-COPY-RELOCATED).\n",
|
|
source->name,
|
|
symname);
|
|
return 1;
|
|
}
|
|
} /* for each rela entry... */
|
|
} /* if rel else rela */
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif/*ARM_SPECIFIC_HACKS*/
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void resolve(source_t *source) {
|
|
/* Iterate the symbol table. For each undefined symbol, scan the
|
|
list of dependencies till we find a global symbol in one of them that
|
|
satisfies the undefined reference. At this point, we update both the
|
|
satisfied[] array of the sources entry, as well as the exports array of
|
|
the dependency where we found the match.
|
|
*/
|
|
|
|
GElf_Sym *sym, sym_mem;
|
|
size_t symidx;
|
|
for (symidx = 0; symidx < source->num_syms; symidx++) {
|
|
sym = gelf_getsymshndx(source->symtab.data,
|
|
NULL,
|
|
symidx,
|
|
&sym_mem,
|
|
NULL);
|
|
FAILIF_LIBELF(NULL == sym, gelf_getsymshndx);
|
|
if (is_symbol_imported(source, sym, symidx))
|
|
{
|
|
/* This is an undefined symbol. Go over the list of libraries
|
|
and look it up. */
|
|
size_t libidx;
|
|
int found = 0;
|
|
source_t *last_found = NULL;
|
|
const char *symname = elf_strptr(source->elf,
|
|
elf_ndxscn(source->strtab.scn),
|
|
sym->st_name);
|
|
for (libidx = 0; libidx < source->num_lib_deps; libidx++) {
|
|
source_t *lib = source->lib_deps[libidx];
|
|
int lib_symidx = hash_lookup(lib->elf,
|
|
lib->hash.data,
|
|
lib->symtab.data,
|
|
lib->strtab.data,
|
|
symname);
|
|
if (STN_UNDEF != lib_symidx)
|
|
{
|
|
/* We found the symbol--now check to see if it is global
|
|
or weak. If this is the case, then the symbol satisfies
|
|
the dependency. */
|
|
GElf_Sym *lib_sym, lib_sym_mem;
|
|
lib_sym = gelf_getsymshndx(lib->symtab.data,
|
|
NULL,
|
|
lib_symidx,
|
|
&lib_sym_mem,
|
|
NULL);
|
|
FAILIF_LIBELF(NULL == lib_sym, gelf_getsymshndx);
|
|
|
|
if(lib_sym->st_shndx != STN_UNDEF &&
|
|
(GELF_ST_BIND(lib_sym->st_info) == STB_GLOBAL ||
|
|
GELF_ST_BIND(lib_sym->st_info) == STB_WEAK))
|
|
{
|
|
/* We found the symbol! Update the satisfied array at this
|
|
index location. */
|
|
source->satisfied[symidx] = lib;
|
|
/* Now, link this structure into the linked list
|
|
corresponding to the found symbol in the library's
|
|
global array. */
|
|
if (source->num_next_export == source->next_export_size) {
|
|
source->next_export_size += 30;
|
|
source->next_export =
|
|
(source_t **)REALLOC(source->next_export,
|
|
source->next_export_size *
|
|
sizeof(struct next_export_t));
|
|
}
|
|
source->next_export[source->num_next_export] = lib->exports[lib_symidx];
|
|
lib->exports[lib_symidx].source = source;
|
|
lib->exports[lib_symidx].next_idx = source->num_next_export;
|
|
|
|
source->num_next_export++;
|
|
lib->num_exported++;
|
|
|
|
INFO("[%s:%s (index %d)] satisfied by [%s] (index %d)\n",
|
|
source->name,
|
|
symname,
|
|
symidx,
|
|
lib->name,
|
|
lib_symidx);
|
|
if (found) {
|
|
if (found == 1) {
|
|
found++;
|
|
ERROR("ERROR: multiple definitions found for [%s:%s]!\n",
|
|
source->name, symname);
|
|
ERROR("\tthis definition [%s]\n", lib->name);
|
|
}
|
|
ERROR("\tprevious definition [%s]\n", last_found->name);
|
|
}
|
|
|
|
last_found = lib;
|
|
if (!found) found = 1;
|
|
}
|
|
}
|
|
}
|
|
if(found == 0) {
|
|
ERROR("ERROR: could not find match for %s:%s.\n",
|
|
source->name,
|
|
symname);
|
|
}
|
|
} /* if we found the symbol... */
|
|
} /* for each symbol... */
|
|
} /* resolve() */
|
|
|
|
static void print_used_symbols(source_t *source) {
|
|
|
|
int name_len = strlen(source->name);
|
|
static const char ext[] = ".syms";
|
|
char *filter = (char *)MALLOC(name_len + sizeof(ext));
|
|
strcpy(filter, source->name);
|
|
strcpy(filter + name_len, ext);
|
|
|
|
FILE *fp = fopen(filter, "w+");
|
|
FAILIF(NULL == fp,
|
|
"Can't open %s: %s (%d)\n",
|
|
filter,
|
|
strerror(errno), errno);
|
|
|
|
/* Is anybody using the symbols defined in source? */
|
|
|
|
if (source->num_exported > 0) {
|
|
INFO("[%s] exports %d symbols to %d libraries and executables.\n",
|
|
source->name,
|
|
source->num_exported,
|
|
source->num_satisfied_execs);
|
|
size_t symidx;
|
|
for (symidx = 0; symidx < source->num_syms; symidx++) {
|
|
if (source->exports[symidx].source != NULL) {
|
|
GElf_Sym *sym, sym_mem;
|
|
sym = gelf_getsymshndx(source->symtab.data,
|
|
NULL,
|
|
symidx,
|
|
&sym_mem,
|
|
NULL);
|
|
FAILIF_LIBELF(NULL == sym, gelf_getsymshndx);
|
|
fprintf(fp, "%s\n", elf_strptr(source->elf,
|
|
elf_ndxscn(source->strtab.scn),
|
|
sym->st_name));
|
|
}
|
|
}
|
|
}
|
|
else if (source->num_satisfied_execs > 0) {
|
|
|
|
/* Is the source listed as a depenency on anyone? If so, then the source exports no symbols
|
|
to anyone, but someone lists it as a dependency, which is unnecessary, so we print a warning.
|
|
*/
|
|
|
|
ERROR("WARNING: [%s] is listed as a dependency in: ", source->name);
|
|
int i;
|
|
for (i = 0; i < source->num_satisfied_execs; i++) {
|
|
ERROR(" [%s],", source->satisfied_execs[i]->name);
|
|
}
|
|
ERROR(" but none of its symbols are used!.\n");
|
|
}
|
|
#if 0 /* This is not really an error--a library's symbols may not be used anyone as specified in the ELF file,
|
|
but someone may still open a library via dlopen().
|
|
*/
|
|
else {
|
|
ERROR("WARNING: None of [%s]'s symbols are used by any library or executable!\n", source->name);
|
|
}
|
|
#endif
|
|
|
|
fclose(fp);
|
|
FREE(filter);
|
|
}
|
|
|
|
static void print_symbol_references(source_t *source) {
|
|
|
|
int name_len = strlen(source->name);
|
|
static const char ext[] = ".info";
|
|
char *filter = (char *)MALLOC(name_len + sizeof(ext));
|
|
strcpy(filter, source->name);
|
|
strcpy(filter + name_len, ext);
|
|
|
|
FILE *fp = fopen(filter, "w+");
|
|
FAILIF(NULL == fp,
|
|
"Can't open %s: %s (%d)\n",
|
|
filter,
|
|
strerror(errno), errno);
|
|
|
|
if (source->num_exported > 0) {
|
|
size_t symidx;
|
|
for (symidx = 0; symidx < source->num_syms; symidx++) {
|
|
if (source->exports[symidx].source != NULL) {
|
|
const char *symname;
|
|
GElf_Sym *sym, sym_mem;
|
|
sym = gelf_getsymshndx(source->symtab.data,
|
|
NULL,
|
|
symidx,
|
|
&sym_mem,
|
|
NULL);
|
|
FAILIF_LIBELF(NULL == sym, gelf_getsymshndx);
|
|
symname = elf_strptr(source->elf,
|
|
elf_ndxscn(source->strtab.scn),
|
|
sym->st_name);
|
|
fprintf(fp, "%s\n", symname);
|
|
next_export_t *export = &source->exports[symidx];
|
|
while (export->source != NULL) {
|
|
//fprintf(stderr, "%s:%s\n", symname, export->source->name);
|
|
fprintf(fp, "\t%s\n", export->source->name);
|
|
export = &export->source->next_export[export->next_idx];
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fclose(fp);
|
|
FREE(filter);
|
|
}
|
|
|
|
static char * find_file(const char *libname,
|
|
char **lib_lookup_dirs,
|
|
int num_lib_lookup_dirs) {
|
|
if (libname[0] == '/') {
|
|
/* This is an absolute path name--just return it. */
|
|
INFO("ABSOLUTE PATH: [%s].\n", libname);
|
|
return strdup(libname);
|
|
} else {
|
|
/* First try the working directory. */
|
|
int fd;
|
|
if ((fd = open(libname, O_RDONLY)) > 0) {
|
|
close(fd);
|
|
INFO("FOUND IN CURRENT DIR: [%s].\n", libname);
|
|
return strdup(libname);
|
|
} else {
|
|
/* Iterate over all library paths. For each path, append the file
|
|
name and see if there is a file at that place. If that fails,
|
|
bail out. */
|
|
|
|
char *name;
|
|
while (num_lib_lookup_dirs--) {
|
|
size_t lib_len = strlen(*lib_lookup_dirs);
|
|
/* one extra character for the slash, and another for the
|
|
terminating NULL. */
|
|
name = (char *)MALLOC(lib_len + strlen(libname) + 2);
|
|
strcpy(name, *lib_lookup_dirs);
|
|
name[lib_len] = '/';
|
|
strcpy(name + lib_len + 1, libname);
|
|
if ((fd = open(name, O_RDONLY)) > 0) {
|
|
close(fd);
|
|
INFO("FOUND: [%s] in [%s].\n", libname, name);
|
|
return name;
|
|
}
|
|
INFO("NOT FOUND: [%s] in [%s].\n", libname, name);
|
|
free(name);
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static source_t* process_library(const char *libname,
|
|
char **lib_lookup_dirs,
|
|
int num_lib_lookup_dirs) {
|
|
source_t *source = find_source(libname, lib_lookup_dirs, num_lib_lookup_dirs);
|
|
if (NULL == source) {
|
|
INFO("Processing [%s].\n", libname);
|
|
char *full = find_file(libname, lib_lookup_dirs, num_lib_lookup_dirs);
|
|
FAILIF(NULL == full,
|
|
"Could not find [%s] in the current directory or in any of "
|
|
"the search paths!\n", libname);
|
|
source = init_source(full);
|
|
if (source) {
|
|
GElf_Dyn *dyn, dyn_mem;
|
|
size_t dynidx;
|
|
size_t numdyn =
|
|
source->dynamic.shdr.sh_size /
|
|
source->dynamic.shdr.sh_entsize;
|
|
|
|
for (dynidx = 0; dynidx < numdyn; dynidx++) {
|
|
dyn = gelf_getdyn (source->dynamic.data,
|
|
dynidx,
|
|
&dyn_mem);
|
|
FAILIF_LIBELF(NULL == dyn, gelf_getdyn);
|
|
if (dyn->d_tag == DT_NEEDED) {
|
|
/* Process the needed library recursively. */
|
|
const char *dep_lib =
|
|
elf_strptr (source->elf,
|
|
source->dynamic.shdr.sh_link,
|
|
dyn->d_un.d_val);
|
|
INFO("[%s] depends on [%s].\n", libname, dep_lib);
|
|
source_t *dep = process_library(dep_lib,
|
|
lib_lookup_dirs,
|
|
num_lib_lookup_dirs);
|
|
|
|
/* Tell dep that source depends on it. */
|
|
if (dep->num_satisfied_execs == dep->satisfied_execs_size) {
|
|
dep->satisfied_execs_size += 10;
|
|
dep->satisfied_execs =
|
|
REALLOC(dep->satisfied_execs,
|
|
dep->satisfied_execs_size *
|
|
sizeof(source_t *));
|
|
}
|
|
dep->satisfied_execs[dep->num_satisfied_execs++] = source;
|
|
|
|
/* Add the library to the dependency list. */
|
|
if (source->num_lib_deps == source->lib_deps_size) {
|
|
source->lib_deps_size += 10;
|
|
source->lib_deps = REALLOC(source->lib_deps,
|
|
source->lib_deps_size *
|
|
sizeof(source_t *));
|
|
}
|
|
source->lib_deps[source->num_lib_deps++] = dep;
|
|
}
|
|
} /* for each dynamic entry... */
|
|
}
|
|
} else INFO("[%s] has been processed already.\n", libname);
|
|
|
|
return source;
|
|
}
|
|
|
|
void lsd(char **execs, int num_execs,
|
|
int list_needed_libs,
|
|
int print_info,
|
|
char **lib_lookup_dirs, int num_lib_lookup_dirs) {
|
|
|
|
source_t *source; /* for general usage */
|
|
int input_idx;
|
|
|
|
for (input_idx = 0; input_idx < num_execs; input_idx++) {
|
|
INFO("executable: [%s]\n", execs[input_idx]);
|
|
/* Here process library is actually processing the top-level executable
|
|
files. */
|
|
process_library(execs[input_idx], lib_lookup_dirs, num_lib_lookup_dirs);
|
|
/* if source is NULL, then the respective executable is static */
|
|
/* Mark the source as an executable */
|
|
} /* for each input executable... */
|
|
|
|
if (list_needed_libs) {
|
|
source = sources;
|
|
while (source) {
|
|
print_needed_libs(source);
|
|
source = source->next;
|
|
}
|
|
}
|
|
|
|
/* Now, for each entry in the sources array, iterate its symbol table. For
|
|
each undefined symbol, scan the list of dependencies till we find a
|
|
global symbol in one of them that satisfies the undefined reference.
|
|
At this point, we update both the satisfied[] array of the sources entry,
|
|
as well as the exports array of the dependency where we found the match.
|
|
*/
|
|
|
|
source = sources;
|
|
while (source) {
|
|
resolve(source);
|
|
source = source->next;
|
|
}
|
|
|
|
/* We are done! Since the end result of our calculations is a set of
|
|
symbols for each library that other libraries or executables link
|
|
against, we iterate over the set of libraries one last time, and for
|
|
each symbol that is marked as satisfying some dependence, we emit
|
|
a line with the symbol's name to a text file derived from the library's
|
|
name by appending the suffix .syms to it. */
|
|
|
|
source = sources;
|
|
while (source) {
|
|
/* If it's a library, print the results. */
|
|
if (source->elf_hdr.e_type == ET_DYN) {
|
|
print_used_symbols(source);
|
|
if (print_info)
|
|
print_symbol_references(source);
|
|
}
|
|
source = source->next;
|
|
}
|
|
|
|
/* Free the resources--you can't do it in the loop above because function
|
|
print_symbol_references() accesses nodes other than the one being
|
|
iterated over.
|
|
*/
|
|
source = sources;
|
|
while (source) {
|
|
source_t *old = source;
|
|
source = source->next;
|
|
/* Destroy the evidence. */
|
|
destroy_source(old);
|
|
}
|
|
}
|
|
|