static int read_shdr(struct elf32_info *info, FILE *in)
{
Elf_Scn *scn;
int i;
if (info->file_ehdr.e_shnum > MAX_SHDRS) {
printc_err("elf32: too many section headers: %d\n",
info->file_ehdr.e_shnum);
return -1;
}
i = 0;
scn = NULL;
while ((scn = elf_nextscn(info->elf, scn)) != NULL) {
GElf_Shdr *shdr = &info->file_shdrs[i];
if (gelf_getshdr(scn, shdr) != shdr) {
printc_err("elf32: can't read shdr %d: %s\n",
i, elf_errmsg(elf_errno()));
}
i++;
}
return 0;
}
static int syms_load_strings(struct elf32_info *info, FILE *in, GElf_Shdr *s)
{
Elf_Scn *scn = NULL;
while ((scn = elf_nextscn(info->elf, scn)) != NULL) {
GElf_Shdr shdr_;
GElf_Shdr *shdr;
if ((shdr = gelf_getshdr(scn, &shdr_)) != NULL) {
if (shdr->sh_type == SHT_SYMTAB) {
info->string_data = elf_getdata(scn, NULL);
if (info->string_data == NULL) {
printc_err("elf32: error from elf_getdata: %s\n",
elf_errmsg(elf_errno()));
return -1;
}
if (info->string_data->d_size == 0) {
printc_err("elf32: symbol table is empty\n");
return -1;
}
return 0;
}
}
}
return 0;
}
/* Adds a string and returns the offset in the section. */
static size_t
add_string (Elf_Scn *scn, char *str)
{
size_t lastidx = stridx;
size_t size = strlen (str) + 1;
Elf_Data *data = elf_newdata (scn);
if (data == NULL)
{
printf ("cannot create data SHSTRTAB section: %s\n", elf_errmsg (-1));
exit (1);
}
data->d_buf = str;
data->d_type = ELF_T_BYTE;
data->d_size = size;
data->d_align = 1;
data->d_version = EV_CURRENT;
stridx += size;
printf ("add_string: '%s', stridx: %zd, lastidx: %zd\n",
str, stridx, lastidx);
return lastidx;
}
/*
* size utility using elf(3) and gelf(3) API to list section sizes and
* total in elf files. Supports only elf files (core dumps in elf
* included) that can be opened by libelf, other formats are not supported.
*/
int
main(int argc, char **argv)
{
int ch, r, rc;
const char **files, *fn;
rc = RETURN_OK;
if (elf_version(EV_CURRENT) == EV_NONE)
errx(EXIT_FAILURE, "ELF library initialization failed: %s",
elf_errmsg(-1));
while ((ch = getopt_long(argc, argv, "ABVdhotx", size_longopts,
NULL)) != -1)
switch((char)ch) {
case 'A':
style = STYLE_SYSV;
break;
case 'B':
style = STYLE_BERKELEY;
break;
case 'V':
show_version();
break;
case 'd':
radix = RADIX_DECIMAL;
break;
case 'o':
radix = RADIX_OCTAL;
break;
case 't':
show_totals = 1;
break;
case 'x':
radix = RADIX_HEX;
break;
case 0:
switch (size_option) {
case OPT_FORMAT:
if (*optarg == 's' || *optarg == 'S')
style = STYLE_SYSV;
else if (*optarg == 'b' || *optarg == 'B')
style = STYLE_BERKELEY;
else {
warnx("unrecognized format \"%s\".",
optarg);
usage();
}
break;
case OPT_RADIX:
r = strtol(optarg, NULL, 10);
if (r == 8)
radix = RADIX_OCTAL;
else if (r == 10)
radix = RADIX_DECIMAL;
else if (r == 16)
radix = RADIX_HEX;
else {
warnx("unsupported radix \"%s\".",
optarg);
usage();
}
break;
default:
err(EXIT_FAILURE, "Error in option handling.");
/*NOTREACHED*/
}
break;
case 'h':
case '?':
default:
usage();
/* NOTREACHED */
}
argc -= optind;
argv += optind;
files = (argc == 0) ? default_args : (void *) argv;
while ((fn = *files) != NULL) {
rc = handle_elf(fn);
if (rc != RETURN_OK)
warnx(rc == RETURN_NOINPUT ?
"'%s': No such file" :
"%s: File format not recognized", fn);
files++;
}
if (style == STYLE_BERKELEY) {
if (show_totals)
berkeley_totals();
tbl_flush();
}
return (rc);
}
int
pkg_get_myarch(char *dest, size_t sz)
{
Elf *elf = NULL;
GElf_Ehdr elfhdr;
GElf_Shdr shdr;
Elf_Data *data;
Elf_Note note;
Elf_Scn *scn = NULL;
int fd;
char *src = NULL;
char *osname;
uint32_t version = 0;
int ret = EPKG_OK;
int i;
const char *arch, *abi, *endian_corres_str, *wordsize_corres_str, *fpu;
if (elf_version(EV_CURRENT) == EV_NONE) {
pkg_emit_error("ELF library initialization failed: %s",
elf_errmsg(-1));
return (EPKG_FATAL);
}
if ((fd = open(_PATH_BSHELL, O_RDONLY)) < 0) {
pkg_emit_errno("open", _PATH_BSHELL);
snprintf(dest, sz, "%s", "unknown");
return (EPKG_FATAL);
}
if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("elf_begin() failed: %s.", elf_errmsg(-1));
goto cleanup;
}
if (gelf_getehdr(elf, &elfhdr) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("getehdr() failed: %s.", elf_errmsg(-1));
goto cleanup;
}
while ((scn = elf_nextscn(elf, scn)) != NULL) {
if (gelf_getshdr(scn, &shdr) != &shdr) {
ret = EPKG_FATAL;
pkg_emit_error("getshdr() failed: %s.", elf_errmsg(-1));
goto cleanup;
}
if (shdr.sh_type == SHT_NOTE)
break;
}
if (scn == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("failed to get the note section");
goto cleanup;
}
data = elf_getdata(scn, NULL);
src = data->d_buf;
while ((uintptr_t)src < ((uintptr_t)data->d_buf + data->d_size)) {
memcpy(¬e, src, sizeof(Elf_Note));
src += sizeof(Elf_Note);
if (note.n_type == NT_VERSION)
break;
src += note.n_namesz + note.n_descsz;
}
if ((uintptr_t)src >= ((uintptr_t)data->d_buf + data->d_size)) {
ret = EPKG_FATAL;
pkg_emit_error("failed to find the version elf note");
goto cleanup;
}
osname = src;
src += roundup2(note.n_namesz, 4);
if (elfhdr.e_ident[EI_DATA] == ELFDATA2MSB)
version = be32dec(src);
else
version = le32dec(src);
for (i = 0; osname[i] != '\0'; i++)
osname[i] = (char)tolower(osname[i]);
wordsize_corres_str = elf_corres_to_string(wordsize_corres,
(int)elfhdr.e_ident[EI_CLASS]);
arch = elf_corres_to_string(mach_corres, (int) elfhdr.e_machine);
#if defined(__DragonFly__)
snprintf(dest, sz, "%s:%d.%d",
osname, version / 100000, (((version / 100 % 1000)+1)/2)*2);
#else
snprintf(dest, sz, "%s:%d", osname, version / 100000);
#endif
switch (elfhdr.e_machine) {
case EM_ARM:
endian_corres_str = elf_corres_to_string(endian_corres,
(int)elfhdr.e_ident[EI_DATA]);
/* FreeBSD doesn't support the hard-float ABI yet */
fpu = "softfp";
if ((elfhdr.e_flags & 0xFF000000) != 0) {
const char *sh_name = NULL;
size_t shstrndx;
/* This is an EABI file, the conformance level is set */
abi = "eabi";
/* Find which TARGET_ARCH we are building for. */
elf_getshdrstrndx(elf, &shstrndx);
while ((scn = elf_nextscn(elf, scn)) != NULL) {
sh_name = NULL;
if (gelf_getshdr(scn, &shdr) != &shdr) {
scn = NULL;
break;
}
sh_name = elf_strptr(elf, shstrndx,
shdr.sh_name);
if (sh_name == NULL)
continue;
if (strcmp(".ARM.attributes", sh_name) == 0)
break;
}
if (scn != NULL && sh_name != NULL) {
data = elf_getdata(scn, NULL);
/*
* Prior to FreeBSD 10.0 libelf would return
* NULL from elf_getdata on the .ARM.attributes
* section. As this was the first release to
* get armv6 support assume a NULL value means
* arm.
*
* This assumption can be removed when 9.x
* is unsupported.
*/
if (data != NULL) {
arch = aeabi_parse_arm_attributes(
data->d_buf, data->d_size);
if (arch == NULL) {
ret = EPKG_FATAL;
pkg_emit_error(
"unknown ARM ARCH");
goto cleanup;
}
}
} else {
ret = EPKG_FATAL;
pkg_emit_error("Unable to find the "
".ARM.attributes section");
goto cleanup;
}
} else if (elfhdr.e_ident[EI_OSABI] != ELFOSABI_NONE) {
/*
* EABI executables all have this field set to
* ELFOSABI_NONE, therefore it must be an oabi file.
*/
abi = "oabi";
} else {
/*
* We may have failed to positively detect the ABI,
* set the ABI to unknown. If we end up here one of
* the above cases should be fixed for the binary.
*/
ret = EPKG_FATAL;
pkg_emit_error("unknown ARM ABI");
goto cleanup;
}
snprintf(dest + strlen(dest), sz - strlen(dest),
":%s:%s:%s:%s:%s", arch, wordsize_corres_str,
endian_corres_str, abi, fpu);
break;
case EM_MIPS:
/*
* this is taken from binutils sources:
* include/elf/mips.h
* mapping is figured out from binutils:
* gas/config/tc-mips.c
*/
switch (elfhdr.e_flags & EF_MIPS_ABI) {
case E_MIPS_ABI_O32:
abi = "o32";
break;
case E_MIPS_ABI_N32:
abi = "n32";
break;
default:
if (elfhdr.e_ident[EI_DATA] == ELFCLASS32)
abi = "o32";
else if (elfhdr.e_ident[EI_DATA] == ELFCLASS64)
abi = "n64";
else
abi = "unknown";
break;
}
endian_corres_str = elf_corres_to_string(endian_corres,
(int)elfhdr.e_ident[EI_DATA]);
snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s:%s:%s",
arch, wordsize_corres_str, endian_corres_str, abi);
break;
default:
snprintf(dest + strlen(dest), sz - strlen(dest), ":%s:%s",
arch, wordsize_corres_str);
break;
}
cleanup:
if (elf != NULL)
elf_end(elf);
close(fd);
return (ret);
}
DSO *
fdopen_dso (int fd, const char *name)
{
Elf *elf = NULL;
GElf_Ehdr ehdr;
GElf_Addr last_off;
int i, j, k, last, *sections, *invsections;
DSO *dso = NULL;
struct PLArch *plarch;
extern struct PLArch __start_pl_arch[], __stop_pl_arch[];
elf = elf_begin (fd, ELF_C_READ, NULL);
if (elf == NULL)
{
error (0, 0, "cannot open ELF file: %s", elf_errmsg (-1));
goto error_out;
}
if (elf_kind (elf) != ELF_K_ELF)
{
error (0, 0, "\"%s\" is not an ELF file", name);
goto error_out;
}
if (gelf_getehdr (elf, &ehdr) == NULL)
{
error (0, 0, "cannot get the ELF header: %s",
elf_errmsg (-1));
goto error_out;
}
if (ehdr.e_type != ET_DYN && ehdr.e_type != ET_EXEC)
{
error (0, 0, "\"%s\" is not a shared library", name);
goto error_out;
}
if (ehdr.e_shnum == 0)
{
GElf_Phdr phdr;
/* Check for UPX compressed executables. */
if (ehdr.e_type == ET_EXEC
&& ehdr.e_phnum > 0
&& (gelf_getphdr (elf, 0, &phdr), phdr.p_type == PT_LOAD)
&& phdr.p_filesz >= 256
&& phdr.p_filesz <= 4096
&& phdr.p_offset == 0
&& ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize < phdr.p_filesz)
{
char *buf = alloca (phdr.p_filesz);
size_t start = ehdr.e_phoff + ehdr.e_phnum * ehdr.e_phentsize;
if (pread (fd, buf, phdr.p_filesz, 0) == phdr.p_filesz
&& memmem (buf + start, phdr.p_filesz - start,
"UPX!", 4) != NULL)
{
error (0, 0, "\"%s\" is UPX compressed executable", name);
goto error_out;
}
}
error (0, 0, "\"%s\" has no section headers", name);
goto error_out;
}
/* Allocate DSO structure. Leave place for additional 20 new section
headers. */
dso = (DSO *)
malloc (sizeof(DSO) + (ehdr.e_shnum + 20) * sizeof(GElf_Shdr)
+ (ehdr.e_phnum + 1) * sizeof(GElf_Phdr)
+ (ehdr.e_shnum + 20) * sizeof(Elf_Scn *));
if (!dso)
{
error (0, ENOMEM, "Could not open DSO");
goto error_out;
}
elf_flagelf (elf, ELF_C_SET, ELF_F_LAYOUT | ELF_F_PERMISSIVE);
memset (dso, 0, sizeof(DSO));
dso->elf = elf;
dso->ehdr = ehdr;
dso->phdr = (GElf_Phdr *) &dso->shdr[ehdr.e_shnum + 20];
dso->scn = (Elf_Scn **) &dso->phdr[ehdr.e_phnum + 1];
switch (ehdr.e_ident[EI_CLASS])
{
case ELFCLASS32:
dso->mask = 0xffffffff; break;
case ELFCLASS64:
dso->mask = 0xffffffffffffffffULL; break;
}
for (i = 0; i < ehdr.e_phnum; ++i)
gelf_getphdr (elf, i, dso->phdr + i);
dso->fd = fd;
for (i = 0, j = 0; i < ehdr.e_shnum; ++i)
{
dso->scn[i] = elf_getscn (elf, i);
gelfx_getshdr (elf, dso->scn[i], dso->shdr + i);
if ((dso->shdr[i].sh_flags & SHF_ALLOC) && dso->shdr[i].sh_type != SHT_NOBITS)
j = 1;
}
if (j == 0)
{
/* If all ALLOC sections are SHT_NOBITS, then this is a
stripped-to-file debuginfo. Skip it silently. */
goto error_out;
}
sections = (int *) alloca (dso->ehdr.e_shnum * sizeof (int) * 2);
sections[0] = 0;
for (i = 1, j = 1, k = dso->ehdr.e_shnum, last = -1;
i < dso->ehdr.e_shnum; ++i)
if (RELOCATE_SCN (dso->shdr[i].sh_flags))
{
last = i;
sections[j++] = i;
}
else
sections[--k] = i;
assert (j == k);
section_cmp_dso = dso;
qsort (sections + k, dso->ehdr.e_shnum - k, sizeof (*sections), section_cmp);
invsections = sections + dso->ehdr.e_shnum;
invsections[0] = 0;
for (i = 1, j = 0; i < ehdr.e_shnum; ++i)
{
if (i != sections[i])
{
j = 1;
dso->scn[i] = elf_getscn (elf, sections[i]);
gelfx_getshdr (elf, dso->scn[i], dso->shdr + i);
}
invsections[sections[i]] = i;
}
if (j)
{
dso->move = init_section_move (dso);
if (dso->move == NULL)
goto error_out;
memcpy (dso->move->old_to_new, invsections, dso->ehdr.e_shnum * sizeof (int));
memcpy (dso->move->new_to_old, sections, dso->ehdr.e_shnum * sizeof (int));
}
last_off = 0;
for (i = 1; i < ehdr.e_shnum; ++i)
{
if (dso->shdr[i].sh_link >= ehdr.e_shnum)
{
error (0, 0, "%s: bogus sh_link value %d", name,
dso->shdr[i].sh_link);
goto error_out;
}
dso->shdr[i].sh_link = invsections[dso->shdr[i].sh_link];
if (dso->shdr[i].sh_type == SHT_REL
|| dso->shdr[i].sh_type == SHT_RELA
|| (dso->shdr[i].sh_flags & SHF_INFO_LINK))
{
if (dso->shdr[i].sh_info >= ehdr.e_shnum)
{
error (0, 0, "%s: bogus sh_info value %d", name,
dso->shdr[i].sh_info);
goto error_out;
}
dso->shdr[i].sh_info = invsections[dso->shdr[i].sh_info];
}
/* Some linkers mess up sh_offset fields for empty or nobits
sections. */
if (RELOCATE_SCN (dso->shdr[i].sh_flags)
&& (dso->shdr[i].sh_size == 0
|| dso->shdr[i].sh_type == SHT_NOBITS))
{
for (j = i + 1; j < ehdr.e_shnum; ++j)
if (! RELOCATE_SCN (dso->shdr[j].sh_flags))
break;
else if (dso->shdr[j].sh_size != 0
&& dso->shdr[j].sh_type != SHT_NOBITS)
break;
dso->shdr[i].sh_offset = (last_off + dso->shdr[i].sh_addralign - 1)
& ~(dso->shdr[i].sh_addralign - 1);
if (j < ehdr.e_shnum
&& dso->shdr[i].sh_offset > dso->shdr[j].sh_offset)
{
GElf_Addr k;
for (k = dso->shdr[i].sh_addralign - 1; k; )
{
k >>= 1;
dso->shdr[i].sh_offset = (last_off + k) & ~k;
if (dso->shdr[i].sh_offset <= dso->shdr[j].sh_offset)
break;
}
}
last_off = dso->shdr[i].sh_offset;
}
else
static void log_elf_error(const char *function, const char *filename)
{
log("%s failed for %s: %s", function, filename, elf_errmsg(-1));
}
dt_module_update(dtrace_hdl_t *dtp, struct kld_file_stat *k_stat)
#endif
{
char fname[MAXPATHLEN];
struct stat64 st;
int fd, err, bits;
dt_module_t *dmp;
const char *s;
size_t shstrs;
GElf_Shdr sh;
Elf_Data *dp;
Elf_Scn *sp;
#if defined(sun)
(void) snprintf(fname, sizeof (fname),
"%s/%s/object", OBJFS_ROOT, name);
#else
GElf_Ehdr ehdr;
GElf_Phdr ph;
char name[MAXPATHLEN];
uintptr_t mapbase, alignmask;
int i = 0;
int is_elf_obj;
(void) strlcpy(name, k_stat->name, sizeof(name));
(void) strlcpy(fname, k_stat->pathname, sizeof(fname));
#endif
if ((fd = open(fname, O_RDONLY)) == -1 || fstat64(fd, &st) == -1 ||
(dmp = dt_module_create(dtp, name)) == NULL) {
dt_dprintf("failed to open %s: %s\n", fname, strerror(errno));
(void) close(fd);
return;
}
/*
* Since the module can unload out from under us (and /system/object
* will return ENOENT), tell libelf to cook the entire file now and
* then close the underlying file descriptor immediately. If this
* succeeds, we know that we can continue safely using dmp->dm_elf.
*/
dmp->dm_elf = elf_begin(fd, ELF_C_READ, NULL);
err = elf_cntl(dmp->dm_elf, ELF_C_FDREAD);
(void) close(fd);
if (dmp->dm_elf == NULL || err == -1 ||
elf_getshdrstrndx(dmp->dm_elf, &shstrs) == -1) {
dt_dprintf("failed to load %s: %s\n",
fname, elf_errmsg(elf_errno()));
dt_module_destroy(dtp, dmp);
return;
}
switch (gelf_getclass(dmp->dm_elf)) {
case ELFCLASS32:
dmp->dm_ops = &dt_modops_32;
bits = 32;
break;
case ELFCLASS64:
dmp->dm_ops = &dt_modops_64;
bits = 64;
break;
default:
dt_dprintf("failed to load %s: unknown ELF class\n", fname);
dt_module_destroy(dtp, dmp);
return;
}
#if defined(__FreeBSD__)
mapbase = (uintptr_t)k_stat->address;
gelf_getehdr(dmp->dm_elf, &ehdr);
is_elf_obj = (ehdr.e_type == ET_REL);
if (is_elf_obj) {
dmp->dm_sec_offsets =
malloc(ehdr.e_shnum * sizeof(*dmp->dm_sec_offsets));
if (dmp->dm_sec_offsets == NULL) {
dt_dprintf("failed to allocate memory\n");
dt_module_destroy(dtp, dmp);
return;
}
}
#endif
/*
* Iterate over the section headers locating various sections of
* interest and use their attributes to flesh out the dt_module_t.
*/
for (sp = NULL; (sp = elf_nextscn(dmp->dm_elf, sp)) != NULL; ) {
if (gelf_getshdr(sp, &sh) == NULL || sh.sh_type == SHT_NULL ||
(s = elf_strptr(dmp->dm_elf, shstrs, sh.sh_name)) == NULL)
continue; /* skip any malformed sections */
#if defined(__FreeBSD__)
if (sh.sh_size == 0)
continue;
if (sh.sh_type == SHT_PROGBITS || sh.sh_type == SHT_NOBITS) {
alignmask = sh.sh_addralign - 1;
mapbase += alignmask;
mapbase &= ~alignmask;
sh.sh_addr = mapbase;
if (is_elf_obj)
dmp->dm_sec_offsets[elf_ndxscn(sp)] = sh.sh_addr;
mapbase += sh.sh_size;
}
#endif
if (strcmp(s, ".text") == 0) {
dmp->dm_text_size = sh.sh_size;
dmp->dm_text_va = sh.sh_addr;
} else if (strcmp(s, ".data") == 0) {
dmp->dm_data_size = sh.sh_size;
dmp->dm_data_va = sh.sh_addr;
} else if (strcmp(s, ".bss") == 0) {
dmp->dm_bss_size = sh.sh_size;
dmp->dm_bss_va = sh.sh_addr;
} else if (strcmp(s, ".info") == 0 &&
(dp = elf_getdata(sp, NULL)) != NULL) {
bcopy(dp->d_buf, &dmp->dm_info,
MIN(sh.sh_size, sizeof (dmp->dm_info)));
} else if (strcmp(s, ".filename") == 0 &&
(dp = elf_getdata(sp, NULL)) != NULL) {
(void) strlcpy(dmp->dm_file,
dp->d_buf, sizeof (dmp->dm_file));
}
}
dmp->dm_flags |= DT_DM_KERNEL;
#if defined(sun)
dmp->dm_modid = (int)OBJFS_MODID(st.st_ino);
#else
/*
* Include .rodata and special sections into .text.
* This depends on default section layout produced by GNU ld
* for ELF objects and libraries:
* [Text][R/O data][R/W data][Dynamic][BSS][Non loadable]
*/
dmp->dm_text_size = dmp->dm_data_va - dmp->dm_text_va;
#if defined(__i386__)
/*
* Find the first load section and figure out the relocation
* offset for the symbols. The kernel module will not need
* relocation, but the kernel linker modules will.
*/
for (i = 0; gelf_getphdr(dmp->dm_elf, i, &ph) != NULL; i++) {
if (ph.p_type == PT_LOAD) {
dmp->dm_reloc_offset = k_stat->address - ph.p_vaddr;
break;
}
}
#endif
#endif
if (dmp->dm_info.objfs_info_primary)
dmp->dm_flags |= DT_DM_PRIMARY;
dt_dprintf("opened %d-bit module %s (%s) [%d]\n",
bits, dmp->dm_name, dmp->dm_file, dmp->dm_modid);
}
int
proc_iter_symbyaddr(struct proc_handle *p, const char *object, int which,
int mask, proc_sym_f *func, void *cd)
{
Elf *e;
int i, fd;
prmap_t *map;
Elf_Scn *scn, *foundscn = NULL;
Elf_Data *data;
GElf_Ehdr ehdr;
GElf_Shdr shdr;
GElf_Sym sym;
unsigned long stridx = -1;
char *s;
int error = -1;
if ((map = proc_name2map(p, object)) == NULL)
return (-1);
if ((fd = find_dbg_obj(map->pr_mapname)) < 0) {
DPRINTF("ERROR: open %s failed", map->pr_mapname);
goto err0;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
goto err1;
}
if (gelf_getehdr(e, &ehdr) == NULL) {
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
goto err2;
}
/*
* Find the section we are looking for.
*/
scn = NULL;
while ((scn = elf_nextscn(e, scn)) != NULL) {
gelf_getshdr(scn, &shdr);
if (which == PR_SYMTAB &&
shdr.sh_type == SHT_SYMTAB) {
foundscn = scn;
break;
} else if (which == PR_DYNSYM &&
shdr.sh_type == SHT_DYNSYM) {
foundscn = scn;
break;
}
}
if (!foundscn)
return (-1);
stridx = shdr.sh_link;
if ((data = elf_getdata(foundscn, NULL)) == NULL) {
DPRINTFX("ERROR: elf_getdata() failed: %s", elf_errmsg(-1));
goto err2;
}
for (i = 0; gelf_getsym(data, i, &sym) != NULL; i++) {
if (GELF_ST_BIND(sym.st_info) == STB_LOCAL &&
(mask & BIND_LOCAL) == 0)
continue;
if (GELF_ST_BIND(sym.st_info) == STB_GLOBAL &&
(mask & BIND_GLOBAL) == 0)
continue;
if (GELF_ST_BIND(sym.st_info) == STB_WEAK &&
(mask & BIND_WEAK) == 0)
continue;
if (GELF_ST_TYPE(sym.st_info) == STT_NOTYPE &&
(mask & TYPE_NOTYPE) == 0)
continue;
if (GELF_ST_TYPE(sym.st_info) == STT_OBJECT &&
(mask & TYPE_OBJECT) == 0)
continue;
if (GELF_ST_TYPE(sym.st_info) == STT_FUNC &&
(mask & TYPE_FUNC) == 0)
continue;
if (GELF_ST_TYPE(sym.st_info) == STT_SECTION &&
(mask & TYPE_SECTION) == 0)
continue;
if (GELF_ST_TYPE(sym.st_info) == STT_FILE &&
(mask & TYPE_FILE) == 0)
continue;
s = elf_strptr(e, stridx, sym.st_name);
if (ehdr.e_type != ET_EXEC)
sym.st_value += map->pr_vaddr;
if ((error = (*func)(cd, &sym, s)) != 0)
goto err2;
}
error = 0;
err2:
elf_end(e);
err1:
close(fd);
err0:
free(map);
return (error);
}
int
each_file(char *cur_file, Cmd_Info *cmd_info)
{
Elf *elf = 0;
Elf_Cmd cmd;
Elf *arf = 0;
Elf_Arhdr *mem_header;
char *cur_filenm = NULL;
int code = 0;
int error = 0, err = 0;
int ar_file = 0;
int fdartmp;
int fd;
int oflag;
if (cmd_info->flags & MIGHT_CHG)
oflag = O_RDWR;
else
oflag = O_RDONLY;
if ((fd = open(cur_file, oflag)) == -1) {
error_message(OPEN_ERROR,
SYSTEM_ERROR, strerror(errno), prog, cur_file);
return (FAILURE);
}
/*
* Note, elf_begin requires ELF_C_READ even if MIGHT_CHK is in effect.
* libelf does not allow elf_begin() with ELF_C_RDWR when processing
* archive file members. Because we are limited to ELF_C_READ use, any
* ELF data modification must be provided by updating a copy of
* the data, rather than updating the original file data.
*/
cmd = ELF_C_READ;
if ((arf = elf_begin(fd, cmd, (Elf *)0)) == 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
(void) elf_end(arf);
(void) close(fd); /* done processing this file */
return (FAILURE);
}
if ((elf_kind(arf) == ELF_K_AR)) {
ar_file = 1;
if (CHK_OPT(cmd_info, MIGHT_CHG)) {
artmpfile = tempnam(TMPDIR, "mcs2");
if ((fdartmp = open(artmpfile,
O_WRONLY | O_APPEND | O_CREAT,
(mode_t)0666)) == NULL) {
error_message(OPEN_TEMP_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, artmpfile);
(void) elf_end(arf);
(void) close(fd);
exit(FAILURE);
}
/* write magic string to artmpfile */
if ((write(fdartmp, ARMAG, SARMAG)) != SARMAG) {
error_message(WRITE_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, artmpfile, cur_file);
mcs_exit(FAILURE);
}
}
} else {
ar_file = 0;
cur_filenm = cur_file;
}
/*
* Holds temporary file;
* if archive, holds the current member file if it has an ehdr,
* and there were no errors in
* processing the object file.
*/
elftmpfile = tempnam(TMPDIR, "mcs1");
while ((elf = elf_begin(fd, cmd, arf)) != 0) {
if (ar_file) /* get header info */ {
size_t len;
if ((mem_header = elf_getarhdr(elf)) == NULL) {
error_message(GETARHDR_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, cur_file, elf_getbase(elf));
(void) elf_end(elf);
(void) elf_end(arf);
(void) close(fd);
(void) unlink(artmpfile);
return (FAILURE);
}
if (cur_filenm != NULL)
free(cur_filenm);
len = (strlen(cur_file) + 3 +
strlen(mem_header->ar_name));
if ((cur_filenm = malloc(len)) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
(void) snprintf(cur_filenm, len, "%s[%s]",
cur_file, mem_header->ar_name);
}
if (elf_kind(elf) == ELF_K_ELF) {
if ((code = process_file(elf, cur_filenm, cmd_info)) ==
FAILURE) {
if (!ar_file) {
(void) elf_end(arf);
(void) elf_end(elf);
(void) close(fd);
return (FAILURE);
} else {
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
error++;
}
} else if (ar_file && CHK_OPT(cmd_info, MIGHT_CHG)) {
if (code == DONT_BUILD)
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
else
copy_elf_file_to_temp_ar_file(
fdartmp, mem_header, cur_file);
}
} else {
/*
* decide what to do with non-ELF file
*/
if (!ar_file) {
error_message(FILE_TYPE_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_filenm);
(void) close(fd);
return (FAILURE);
} else {
if (CHK_OPT(cmd_info, MIGHT_CHG))
copy_non_elf_to_temp_ar(
fd, elf, fdartmp, mem_header,
cur_file, cmd_info);
}
}
cmd = elf_next(elf);
(void) elf_end(elf);
}
err = elf_errno();
if (err != 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(err), prog);
error_message(NOT_MANIPULATED_ERROR,
PLAIN_ERROR, (char *)0,
prog, cur_file);
return (FAILURE);
}
(void) elf_end(arf);
if (ar_file && CHK_OPT(cmd_info, MIGHT_CHG)) {
(void) close(fdartmp); /* done writing to ar_temp_file */
/* copy ar_temp_file to FILE */
copy_file(fd, cur_file, artmpfile);
} else if (code != DONT_BUILD && CHK_OPT(cmd_info, MIGHT_CHG))
copy_file(fd, cur_file, elftmpfile);
(void) close(fd); /* done processing this file */
return (error);
}
static int
build_file(Elf *src_elf, GElf_Ehdr *src_ehdr, Cmd_Info *cmd_info)
{
Elf_Scn *src_scn;
Elf_Scn *dst_scn;
int new_sh_name = 0; /* to hold the offset for the new */
/* section's name */
Elf *dst_elf = 0;
Elf_Data *elf_data;
Elf_Data *data;
int64_t scn_no, x;
size_t no_of_symbols = 0;
section_info_table *info;
unsigned int c = 0;
int fdtmp;
GElf_Shdr src_shdr;
GElf_Shdr dst_shdr;
GElf_Ehdr dst_ehdr;
GElf_Off new_offset = 0, r;
size_t shnum, shstrndx;
if (elf_getshnum(src_elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(src_elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((fdtmp = open(elftmpfile, O_RDWR |
O_TRUNC | O_CREAT, (mode_t)0666)) == -1) {
error_message(OPEN_TEMP_ERROR,
SYSTEM_ERROR, strerror(errno),
prog, elftmpfile);
return (FAILURE);
}
if ((dst_elf = elf_begin(fdtmp, ELF_C_WRITE, (Elf *) 0)) == NULL) {
error_message(READ_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, elftmpfile);
(void) close(fdtmp);
return (FAILURE);
}
if (gelf_newehdr(dst_elf, gelf_getclass(src_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
/* initialize dst_ehdr */
(void) gelf_getehdr(dst_elf, &dst_ehdr);
dst_ehdr = *src_ehdr;
/*
* flush the changes to the ehdr so the
* ident array is filled in.
*/
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (src_ehdr->e_phnum != 0) {
(void) elf_flagelf(dst_elf, ELF_C_SET, ELF_F_LAYOUT);
if (gelf_newphdr(dst_elf, src_ehdr->e_phnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
for (x = 0; x < src_ehdr->e_phnum; ++x) {
GElf_Phdr dst;
GElf_Phdr src;
/* LINTED */
(void) gelf_getphdr(src_elf, (int)x, &src);
/* LINTED */
(void) gelf_getphdr(dst_elf, (int)x, &dst);
(void) memcpy(&dst, &src, sizeof (GElf_Phdr));
/* LINTED */
(void) gelf_update_phdr(dst_elf, (int)x, &dst);
}
x = location(dst_ehdr.e_phoff, 0, src_elf);
if (x == AFTER)
new_offset = (GElf_Off)src_ehdr->e_ehsize;
}
scn_no = 1;
while ((src_scn = sec_table[scn_no].scn) != (Elf_Scn *) -1) {
info = &sec_table[scn_no];
/* If section should be copied to new file NOW */
if ((info->secno != (GElf_Word)DELETED) &&
info->secno <= scn_no) {
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
(void) gelf_getshdr(info->scn, &src_shdr);
(void) memcpy(&dst_shdr, &src_shdr, sizeof (GElf_Shdr));
/*
* Update link and info fields
* The sh_link field may have special values so
* check them first.
*/
if ((src_shdr.sh_link >= shnum) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else if ((int)sec_table[src_shdr.sh_link].secno < 0)
dst_shdr.sh_link = 0;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].secno;
if ((src_shdr.sh_type == SHT_REL) ||
(src_shdr.sh_type == SHT_RELA)) {
if ((src_shdr.sh_info >= shnum) ||
((int)sec_table[src_shdr.
sh_info].secno < 0))
dst_shdr.sh_info = 0;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].secno;
}
data = sec_table[scn_no].data;
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
*elf_data = *data;
/* SHT_{DYNSYM, SYMTAB} might need some change */
if (((src_shdr.sh_type == SHT_SYMTAB) ||
(src_shdr.sh_type == SHT_DYNSYM)) &&
src_shdr.sh_entsize != 0 &&
(cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0)) {
char *new_sym;
no_of_symbols = src_shdr.sh_size /
src_shdr.sh_entsize;
new_sym = malloc(no_of_symbols *
src_shdr.sh_entsize);
if (new_sym == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* CSTYLED */
elf_data->d_buf = (void *) new_sym;
for (c = 0; c < no_of_symbols; c++) {
GElf_Sym csym;
(void) gelf_getsym(data, c, &csym);
if ((csym.st_shndx < SHN_LORESERVE) &&
(csym.st_shndx != SHN_UNDEF)) {
section_info_table *i;
i = &sec_table[csym.st_shndx];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
csym.st_shndx =
i->secno;
else {
if (src_shdr.sh_type ==
SHT_SYMTAB)
/*
* The section which
* this * symbol relates
* to is removed.
* There is no way to
* specify this fact,
* just change the shndx
* to 1.
*/
csym.st_shndx = 1;
else {
/*
* If this is in a
* .dynsym, NULL it out.
*/
csym.st_shndx = 0;
csym.st_name = 0;
csym.st_value = 0;
csym.st_size = 0;
csym.st_info = 0;
csym.st_other = 0;
csym.st_shndx = 0;
}
}
}
(void) gelf_update_sym(elf_data, c,
&csym);
}
}
/* update SHT_SYMTAB_SHNDX */
if ((src_shdr.sh_type == SHT_SYMTAB_SHNDX) &&
(src_shdr.sh_entsize != 0) &&
((cmd_info->no_of_delete != 0) ||
(cmd_info->no_of_nulled != 0))) {
GElf_Word *oldshndx;
GElf_Word *newshndx;
uint_t entcnt;
entcnt = src_shdr.sh_size /
src_shdr.sh_entsize;
oldshndx = data->d_buf;
newshndx = malloc(entcnt *
src_shdr.sh_entsize);
if (newshndx == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
elf_data->d_buf = (void *)newshndx;
for (c = 0; c < entcnt; c++) {
if (oldshndx[c] != SHN_UNDEF) {
section_info_table *i;
i = &sec_table[oldshndx[c]];
if (((int)i->secno !=
DELETED) &&
((int)i->secno != NULLED))
newshndx[c] = i->secno;
else
newshndx[c] =
oldshndx[c];
} else
newshndx[c] =
oldshndx[c];
}
}
/*
* If the section is to be updated,
* do so.
*/
if (ISCANDIDATE(info->flags)) {
if ((GET_LOC(info->flags) == PRIOR) &&
(((int)info->secno == NULLED) ||
((int)info->secno == EXPANDED) ||
((int)info->secno == SHRUNK))) {
/*
* The section is updated,
* but the position is not too
* good. Need to NULL this out.
*/
dst_shdr.sh_name = 0;
dst_shdr.sh_type = SHT_PROGBITS;
if ((int)info->secno != NULLED) {
(cmd_info->no_of_moved)++;
SET_MOVING(info->flags);
}
} else {
/*
* The section is positioned AFTER,
* or there are no segments.
* It is safe to update this section.
*/
data = sec_table[scn_no].mdata;
*elf_data = *data;
dst_shdr.sh_size = elf_data->d_size;
}
}
/* add new section name to shstrtab? */
else if (!Sect_exists &&
(new_sec_string != NULL) &&
(scn_no == shstrndx) &&
(dst_shdr.sh_type == SHT_STRTAB) &&
((src_ehdr->e_phnum == 0) ||
((x = scn_location(dst_scn, dst_elf)) != IN) ||
(x != PRIOR))) {
size_t sect_len;
sect_len = strlen(SECT_NAME);
if ((elf_data->d_buf =
malloc((dst_shdr.sh_size +
sect_len + 1))) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
/* put original data plus new data in section */
(void) memcpy(elf_data->d_buf,
data->d_buf, data->d_size);
(void) memcpy(&((char *)elf_data->d_buf)
[data->d_size],
SECT_NAME,
sect_len + 1);
/* LINTED */
new_sh_name = (int)dst_shdr.sh_size;
dst_shdr.sh_size += sect_len + 1;
elf_data->d_size += sect_len + 1;
}
/*
* Compute offsets.
*/
if (src_ehdr->e_phnum != 0) {
/*
* Compute section offset.
*/
if (off_table[scn_no] == 0) {
if (dst_shdr.sh_addralign != 0) {
r = new_offset %
dst_shdr.sh_addralign;
if (r)
new_offset +=
dst_shdr.sh_addralign - r;
}
dst_shdr.sh_offset = new_offset;
elf_data->d_off = 0;
} else {
if (nobits_table[scn_no] == 0)
new_offset = off_table[scn_no];
}
if (nobits_table[scn_no] == 0)
new_offset += dst_shdr.sh_size;
}
}
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
scn_no++;
}
/*
* This is the real new section.
*/
if (!Sect_exists && new_sec_string != NULL) {
size_t string_size;
string_size = strlen(new_sec_string) + 1;
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(dst_scn, &dst_shdr);
dst_shdr.sh_name = new_sh_name;
dst_shdr.sh_type = SHT_PROGBITS;
dst_shdr.sh_flags = 0;
dst_shdr.sh_addr = 0;
if (src_ehdr->e_phnum != NULL)
dst_shdr.sh_offset = new_offset;
else
dst_shdr.sh_offset = 0;
dst_shdr.sh_size = string_size + 1;
dst_shdr.sh_link = 0;
dst_shdr.sh_info = 0;
dst_shdr.sh_addralign = 1;
dst_shdr.sh_entsize = 0;
(void) gelf_update_shdr(dst_scn, &dst_shdr); /* flush changes */
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
elf_data->d_size = string_size + 1;
if ((elf_data->d_buf = (char *)
calloc(1, string_size + 1)) == NULL) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0,
prog);
mcs_exit(FAILURE);
}
(void) memcpy(&((char *)elf_data->d_buf)[1],
new_sec_string, string_size);
elf_data->d_align = 1;
new_offset += string_size + 1;
}
/*
* If there are sections which needed to be moved,
* then do it here.
*/
if (cmd_info->no_of_moved != 0) {
int cnt;
info = &sec_table[0];
for (cnt = 0; cnt < shnum; cnt++, info++) {
if ((GET_MOVING(info->flags)) == 0)
continue;
if ((src_scn = elf_getscn(src_elf, info->osecno)) ==
NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(src_scn, &src_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if ((dst_scn = elf_newscn(dst_elf)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (gelf_getshdr(dst_scn, &dst_shdr) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
dst_shdr = src_shdr;
data = info->mdata;
dst_shdr.sh_offset = new_offset; /* UPDATE fields */
dst_shdr.sh_size = data->d_size;
if ((shnum >= src_shdr.sh_link) ||
(src_shdr.sh_link == 0))
dst_shdr.sh_link = src_shdr.sh_link;
else
dst_shdr.sh_link =
sec_table[src_shdr.sh_link].osecno;
if ((shnum >= src_shdr.sh_info) ||
(src_shdr.sh_info == 0))
dst_shdr.sh_info = src_shdr.sh_info;
else
dst_shdr.sh_info =
sec_table[src_shdr.sh_info].osecno;
(void) gelf_update_shdr(dst_scn, &dst_shdr);
if ((elf_data = elf_newdata(dst_scn)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) memcpy(elf_data, data, sizeof (Elf_Data));
new_offset += data->d_size;
}
}
/*
* In the event that the position of the sting table has changed,
* as a result of deleted sections, update the ehdr->e_shstrndx.
*/
if ((shstrndx > 0) && (shnum > 0) &&
(sec_table[shstrndx].secno < shnum)) {
if (sec_table[shstrndx].secno < SHN_LORESERVE) {
dst_ehdr.e_shstrndx =
sec_table[dst_ehdr.e_shstrndx].secno;
} else {
Elf_Scn *_scn;
GElf_Shdr shdr0;
/*
* If shstrndx requires 'Extended ELF Sections'
* then it is stored in shdr[0].sh_link
*/
dst_ehdr.e_shstrndx = SHN_XINDEX;
if ((_scn = elf_getscn(dst_elf, 0)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) gelf_getshdr(_scn, &shdr0);
shdr0.sh_link = sec_table[shstrndx].secno;
(void) gelf_update_shdr(_scn, &shdr0);
}
}
if (src_ehdr->e_phnum != 0) {
size_t align = gelf_fsize(dst_elf, ELF_T_ADDR, 1, EV_CURRENT);
/* UPDATE location of program header table */
if (location(dst_ehdr.e_phoff, 0, dst_elf) == AFTER) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_phoff = new_offset;
new_offset += dst_ehdr.e_phnum
* dst_ehdr.e_phentsize;
}
/* UPDATE location of section header table */
if ((location(dst_ehdr.e_shoff, 0, src_elf) == AFTER) ||
((location(dst_ehdr.e_shoff, 0, src_elf) == PRIOR) &&
(!Sect_exists && new_sec_string != NULL))) {
r = new_offset % align;
if (r)
new_offset += align - r;
dst_ehdr.e_shoff = new_offset;
}
free(b_e_seg_table);
/*
* The NOTE segment is the one segment whos
* sections might get moved by mcs processing.
* Make sure that the NOTE segments offset points
* to the .note section.
*/
if ((notesegndx != -1) && (notesctndx != -1) &&
(sec_table[notesctndx].secno)) {
Elf_Scn * notescn;
GElf_Shdr nshdr;
notescn = elf_getscn(dst_elf,
sec_table[notesctndx].secno);
(void) gelf_getshdr(notescn, &nshdr);
if (gelf_getclass(dst_elf) == ELFCLASS32) {
Elf32_Phdr * ph = elf32_getphdr(dst_elf) +
notesegndx;
/* LINTED */
ph->p_offset = (Elf32_Off)nshdr.sh_offset;
} else {
Elf64_Phdr * ph = elf64_getphdr(dst_elf) +
notesegndx;
ph->p_offset = (Elf64_Off)nshdr.sh_offset;
}
}
}
/* copy ehdr changes back into real ehdr */
(void) gelf_update_ehdr(dst_elf, &dst_ehdr);
if (elf_update(dst_elf, ELF_C_WRITE) < 0) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
(void) elf_end(dst_elf);
(void) close(fdtmp);
return (SUCCESS);
}
static int
traverse_file(Elf *elf, GElf_Ehdr * ehdr, char *cur_file, Cmd_Info *cmd_info)
{
Elf_Scn * scn;
Elf_Scn * temp_scn;
Elf_Data * data;
GElf_Shdr * shdr;
char *temp_name;
section_info_table * sinfo;
GElf_Xword x;
int ret = 0, SYM = 0; /* used by strip command */
int phnum = ehdr->e_phnum;
unsigned int i, scn_index;
size_t shstrndx, shnum;
Sect_exists = 0;
if (elf_getshnum(elf, &shnum) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
if (elf_getshstrndx(elf, &shstrndx) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
scn = 0;
scn_index = 1;
sinfo = &sec_table[scn_index];
while ((scn = elf_nextscn(elf, scn)) != 0) {
char *name;
shdr = &(sinfo->shdr);
if (gelf_getshdr(scn, shdr) == NULL) {
error_message(NO_SECT_TABLE_ERROR,
LIBelf_ERROR, elf_errmsg(-1),
prog, cur_file);
return (FAILURE);
} else {
name = elf_strptr(elf, shstrndx,
(size_t)shdr->sh_name);
if (name == NULL)
name = "_@@@###";
}
sinfo->scn = scn;
sinfo->secno = scn_index;
sinfo->osecno = scn_index;
SET_ACTION(sinfo->flags, ACT_NOP);
sinfo->name = name;
if (ehdr->e_phnum == 0)
SET_LOC(sinfo->flags, NOSEG);
else
SET_LOC(sinfo->flags, scn_location(scn, elf));
if (shdr->sh_type == SHT_GROUP) {
if (list_appendc(&cmd_info->sh_groups, sinfo) == 0) {
error_message(MALLOC_ERROR,
PLAIN_ERROR, (char *)0, prog);
mcs_exit(FAILURE);
}
}
/*
* If the target section is pointed by a section
* holding relocation infomation, then the
* pointing section would be useless if the
* target section is removed.
*/
if ((shdr->sh_type == SHT_REL ||
shdr->sh_type == SHT_RELA) &&
(shdr->sh_info != SHN_UNDEF &&
(temp_scn = elf_getscn(elf, shdr->sh_info)) != 0)) {
GElf_Shdr tmp_shdr;
if (gelf_getshdr(temp_scn, &tmp_shdr) != NULL) {
temp_name = elf_strptr(elf, shstrndx,
(size_t)tmp_shdr.sh_name);
sinfo->rel_name = temp_name;
sinfo->rel_scn_index =
shdr->sh_info;
if (phnum == 0)
sinfo->rel_loc = NOSEG;
else
sinfo->rel_loc =
scn_location(temp_scn, elf);
}
}
data = 0;
if ((data = elf_getdata(scn, data)) == NULL) {
error_message(LIBELF_ERROR,
LIBelf_ERROR, elf_errmsg(-1), prog);
return (FAILURE);
}
sinfo->data = data;
/*
* Check if this section is a candidate for
* action to be processes.
*/
if (sectcmp(name) == 0) {
SET_CANDIDATE(sinfo->flags);
/*
* This flag just shows that there was a
* candidate.
*/
Sect_exists++;
}
/*
* Any of the following section types should
* also be removed (if possible) if invoked via
* the 'strip' command.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
((shdr->sh_type == SHT_SUNW_DEBUG) ||
(shdr->sh_type == SHT_SUNW_DEBUGSTR))) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
/*
* Zap this file ?
*/
if ((cmd_info->flags & zFLAG) &&
(shdr->sh_type == SHT_PROGBITS)) {
SET_CANDIDATE(sinfo->flags);
Sect_exists++;
}
x = GET_LOC(sinfo->flags);
/*
* Remeber the note sections index so that we can
* reset the NOTE segments offset to point to it.
*
* It may have been assigned a new location in the
* resulting output elf image.
*/
if (shdr->sh_type == SHT_NOTE)
notesctndx = scn_index;
if (x == IN || x == PRIOR)
off_table[scn_index] =
shdr->sh_offset;
if (shdr->sh_type == SHT_NOBITS)
nobits_table[scn_index] = 1;
/*
* If this section satisfies the condition,
* apply the actions specified.
*/
if (ISCANDIDATE(sinfo->flags)) {
ret += apply_action(sinfo, cur_file, cmd_info);
}
/*
* If I am strip command, determine if symtab can go or not.
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) &&
(CHK_OPT(cmd_info, xFLAG) == 0) &&
(CHK_OPT(cmd_info, lFLAG) == 0)) {
if (shdr->sh_type == SHT_SYMTAB &&
GET_LOC(sinfo->flags) == AFTER) {
SYM = scn_index;
}
}
scn_index++;
sinfo++;
}
sinfo->scn = (Elf_Scn *) -1;
/*
* If there were any errors traversing the file,
* just return error.
*/
if (ret != 0)
return (FAILURE);
/*
* Remove symbol table if possible
*/
if (CHK_OPT(cmd_info, I_AM_STRIP) && SYM != 0) {
GElf_Shdr tmp_shdr;
(void) gelf_getshdr(sec_table[SYM].scn, &tmp_shdr);
sec_table[SYM].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[SYM].flags, ACT_DELETE);
off_table[SYM] = 0;
/*
* Can I remove section header
* string table ?
*/
if ((tmp_shdr.sh_link < shnum) &&
(tmp_shdr.sh_link != SHN_UNDEF) &&
(tmp_shdr.sh_link != shstrndx) &&
(GET_LOC(sec_table[tmp_shdr.sh_link].flags) == AFTER)) {
sec_table[tmp_shdr.sh_link].secno = (GElf_Word)DELETED;
++(cmd_info->no_of_nulled);
if (Sect_exists == 0)
++Sect_exists;
SET_ACTION(sec_table[tmp_shdr.sh_link].flags,\
ACT_DELETE);
off_table[tmp_shdr.sh_link] = 0;
}
}
/*
* If I only printed the contents, then
* just report so.
*/
if (CHK_OPT(cmd_info, pFLAG) && !CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD); /* don't bother creating a new file */
/* since the file has not changed */
/*
* I might need to add a new section. Check it.
*/
if (Sect_exists == 0 && CHK_OPT(cmd_info, aFLAG)) {
int act = 0;
new_sec_string = calloc(1, cmd_info->str_size + 1);
if (new_sec_string == NULL)
return (FAILURE);
for (act = 0; act < actmax; act++) {
if (Action[act].a_action == ACT_APPEND) {
(void) strcat(new_sec_string,
Action[act].a_string);
(void) strcat(new_sec_string, "\n");
cmd_info->no_of_append = 1;
}
}
}
/*
* If I did not append any new sections, and I did not
* modify/delete any sections, then just report so.
*/
if ((Sect_exists == 0 && cmd_info->no_of_append == 0) ||
!CHK_OPT(cmd_info, MIGHT_CHG))
return (DONT_BUILD);
/*
* Found at least one section which was processed.
* Deleted or Appended or Compressed.
*/
if (Sect_exists) {
/*
* First, handle the deleted sections.
*/
if (cmd_info->no_of_delete != 0 ||
cmd_info->no_of_nulled != 0) {
int acc = 0;
int rel_idx;
/*
* Handle relocation/target
* sections.
*/
sinfo = &(sec_table[0]);
for (i = 1; i < shnum; i++) {
sinfo++;
rel_idx = sinfo->rel_scn_index;
if (rel_idx == 0)
continue;
/*
* If I am removed, then remove my
* target section.
*/
if (((sinfo->secno ==
(GElf_Word)DELETED) ||
(sinfo->secno ==
(GElf_Word)NULLED)) &&
sinfo->rel_loc != IN) {
if (GET_LOC(sec_table[rel_idx].flags) ==
PRIOR)
sec_table[rel_idx].secno =
(GElf_Word)NULLED;
else
sec_table[rel_idx].secno =
(GElf_Word)DELETED;
SET_ACTION(sec_table[rel_idx].flags,\
ACT_DELETE);
}
/*
* I am not removed. Check if my target is
* removed or nulled. If so, let me try to
* remove my self.
*/
if (((sec_table[rel_idx].secno ==
(GElf_Word)DELETED) ||
(sec_table[rel_idx].secno ==
(GElf_Word)NULLED)) &&
(GET_LOC(sinfo->flags) != IN)) {
if (GET_LOC(sinfo->flags) ==
PRIOR)
sinfo->secno =
(GElf_Word)NULLED;
else
sinfo->secno =
(GElf_Word)DELETED;
SET_ACTION(sinfo->flags,\
ACT_DELETE);
}
}
/*
* Now, take care of DELETED sections
*/
sinfo = &(sec_table[1]);
for (i = 1; i < shnum; i++) {
shdr = &(sinfo->shdr);
if (sinfo->secno == (GElf_Word)DELETED) {
acc++;
/*
* The SHT_GROUP section which this section
* is a member may be able to be removed.
* See post_process().
*/
if (shdr->sh_flags & SHF_GROUP)
cmd_info->flags |= SHF_GROUP_DEL;
} else {
/*
* The data buffer of SHT_GROUP this section
* is a member needs to be updated.
* See post_process().
*/
sinfo->secno -= acc;
if ((shdr->sh_flags &
SHF_GROUP) && (acc != 0))
cmd_info->flags |= SHF_GROUP_MOVE;
}
sinfo++;
}
}
}
/*
* I know that the file has been modified.
* A new file need to be created.
*/
return (SUCCESS);
}
int
main (int argc, char *argv[])
{
int result = 0;
int cnt;
elf_version (EV_CURRENT);
for (cnt = 1; cnt < argc; ++cnt)
{
int fd = open (argv[cnt], O_RDONLY);
Elf *elf = elf_begin (fd, ELF_C_READ, NULL);
if (elf == NULL)
{
printf ("%s not usable %s\n", argv[cnt], elf_errmsg (-1));
result = 1;
close (fd);
continue;
}
size_t shdrstrndx;
if (elf_getshdrstrndx (elf, &shdrstrndx) == -1)
{
printf ("elf_getshdrstrnd failed %s\n", elf_errmsg (-1));
result = 1;
close (fd);
continue;
}
Elf_Scn *scn = NULL;
while ((scn = elf_nextscn (elf, scn)) != NULL)
{
int idx = elf_ndxscn (scn);
GElf_Shdr shdr;
if (gelf_getshdr (scn, &shdr) == NULL)
{
printf ("gelf_getshdr failed: %s\n", elf_errmsg (-1));
result = 1;
break;
}
const char *sname = elf_strptr (elf, shdrstrndx, shdr.sh_name);
if (sname == NULL)
{
printf ("couldn't get section name: %s\n", elf_errmsg (-1));
result = 1;
break;
}
if (strncmp(".zdebug", sname, strlen (".zdebug")) == 0)
{
ssize_t size;
if ((size = dwelf_scn_gnu_compressed_size (scn)) == -1)
{
printf ("dwelf_scn_gnu_compressed_size failed: %s\n",
elf_errmsg (-1));
result = 1;
break;
}
printf ("section %d: GNU Compressed size: %zx\n", idx, size);
}
}
elf_end (elf);
close (fd);
}
return result;
}
void *NWMovies_lookup_symbol(char *filename, char *function)
{
Elf *elf_ptr;
int fd;
Elf32_Ehdr *ehdr;
Elf_Scn *section;
Elf32_Shdr *section_header;
Elf32_Sym *symtab_start, *symtab_current;
int symtab_count, i;
char *strtab;
int strtab_type;
char *symstrtab;
void *return_val;
/* Initialize the elves. */
if (elf_version(EV_CURRENT) == EV_NONE) {
fprintf(stderr, "ERROR: NWMovies: libelf version mismatch.\n");
abort();
}
/* open shared library */
fd = open(filename, O_RDONLY);
if( fd < 0 ) {
fprintf(stderr, "ERROR: NWMovies: Unable to open shared library: %s (%d)\n", filename, errno);
abort();
}
elf_ptr = elf_begin(fd, ELF_C_READ, (Elf *)0);
if( elf_ptr == NULL) {
fprintf(stderr, "ERROR: NWMovies: elf_begin failed: %s.\n", elf_errmsg(elf_errno()));
abort();
}
/* Get the Header */
if ( (ehdr = elf32_getehdr(elf_ptr)) == NULL) {
fprintf(stderr, "ERROR: NWMovies: Unable to get Elf header: %s\n", elf_errmsg(elf_errno()) );
abort();
}
/* Find the section string table */
section = elf_getscn(elf_ptr, ehdr->e_shstrndx);
symstrtab = elf_getdata(section, NULL)->d_buf;
section = 0;
symtab_start = NULL;
strtab = NULL;
strtab_type = -1;
while( (section = elf_nextscn( elf_ptr, section )) ) {
section_header = elf32_getshdr(section);
/* DYNSYM is better than nothing */
if( symtab_start == NULL && section_header->sh_type == SHT_DYNSYM ) {
symtab_start = elf_getdata(section, NULL)->d_buf;
symtab_count = section_header->sh_size / section_header->sh_entsize;
strtab_type = 0;
}
/* However, we prefer SYMTAB */
if( section_header->sh_type == SHT_SYMTAB ) {
symtab_start = elf_getdata(section, NULL)->d_buf;
symtab_count = section_header->sh_size / section_header->sh_entsize;
strtab_type = 1;
}
}
if( strtab_type == -1 ) {
fprintf(stderr, "ERROR: NWMovies: didn't find any symbol tables. Positively won't work.\n");
fprintf(stderr, "ERROR: NWMovies: Try a different %s library\n", filename);
abort();
}
section = 0;
while((section = elf_nextscn(elf_ptr, section))) {
section_header = elf32_getshdr(section);
if( section_header->sh_type == SHT_STRTAB ) {
if( strtab_type == 0 && strcmp(section_header->sh_name + symstrtab, ".dynstr") == 0 ) {
strtab = elf_getdata(section, NULL)->d_buf;
break;
}
if( strtab_type == 1 && strcmp(section_header->sh_name + symstrtab, ".strtab") == 0 ) {
strtab = elf_getdata(section, NULL)->d_buf;
break;
}
}
}
symtab_current = symtab_start;
for(i=0; i<symtab_count; i++) {
// fprintf(stderr, "DEBUG: INDEX: %d: %d\n", i, symtab_current->st_name);
if( symtab_current->st_name != 0 ) {
// fprintf(stderr, "DEBUG: Testing: %s\n", symtab_current->st_name + strtab);
if( ! strcmp(symtab_current->st_name+strtab,function) ) {
break;
}
}
symtab_current++;
}
if( i >= symtab_count ) {
elf_end(elf_ptr);
close(fd);
return(NULL);
} else {
return_val = (void *)symtab_current->st_value;
elf_end(elf_ptr);
close(fd);
return(return_val);
}
}
int
proc_name2sym(struct proc_handle *p, const char *object, const char *symbol,
GElf_Sym *symcopy)
{
Elf *e;
Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
Elf_Data *data;
GElf_Shdr shdr;
GElf_Sym sym;
GElf_Ehdr ehdr;
int fd, error = -1;
size_t i;
prmap_t *map;
char *s;
unsigned long symtabstridx = 0, dynsymstridx = 0;
if ((map = proc_name2map(p, object)) == NULL) {
DPRINTFX("ERROR: couldn't find object %s", object);
goto err0;
}
if ((fd = open(map->pr_mapname, O_RDONLY, 0)) < 0) {
DPRINTF("ERROR: open %s failed", map->pr_mapname);
goto err0;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
goto err1;
}
if (gelf_getehdr(e, &ehdr) == NULL) {
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
goto err2;
}
/*
* Find the index of the STRTAB and SYMTAB sections to locate
* symbol names.
*/
scn = NULL;
while ((scn = elf_nextscn(e, scn)) != NULL) {
gelf_getshdr(scn, &shdr);
switch (shdr.sh_type) {
case SHT_SYMTAB:
symtabscn = scn;
symtabstridx = shdr.sh_link;
break;
case SHT_DYNSYM:
dynsymscn = scn;
dynsymstridx = shdr.sh_link;
break;
default:
break;
}
}
/*
* Iterate over the Dynamic Symbols table to find the symbol.
* Then look up the string name in STRTAB (.dynstr)
*/
if ((data = elf_getdata(dynsymscn, NULL))) {
i = 0;
while (gelf_getsym(data, i++, &sym) != NULL) {
s = elf_strptr(e, dynsymstridx, sym.st_name);
if (s && strcmp(s, symbol) == 0) {
memcpy(symcopy, &sym, sizeof(sym));
if (ehdr.e_type != ET_EXEC)
symcopy->st_value += map->pr_vaddr;
error = 0;
goto out;
}
}
}
/*
* Iterate over the Symbols Table to find the symbol.
* Then look up the string name in STRTAB (.dynstr)
*/
if ((data = elf_getdata(symtabscn, NULL))) {
i = 0;
while (gelf_getsym(data, i++, &sym) != NULL) {
s = elf_strptr(e, symtabstridx, sym.st_name);
if (s && strcmp(s, symbol) == 0) {
memcpy(symcopy, &sym, sizeof(sym));
if (ehdr.e_type != ET_EXEC)
symcopy->st_value += map->pr_vaddr;
error = 0;
goto out;
}
}
}
out:
DPRINTFX("found addr 0x%lx for %s", symcopy->st_value, symbol);
err2:
elf_end(e);
err1:
close(fd);
err0:
free(map);
return (error);
}
int
proc_addr2sym(struct proc_handle *p, uintptr_t addr, char *name,
size_t namesz, GElf_Sym *symcopy)
{
GElf_Ehdr ehdr;
GElf_Shdr shdr;
Elf *e;
Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
prmap_t *map;
const char *s;
uintptr_t off;
u_long symtabstridx = 0, dynsymstridx = 0;
int fd, error = -1;
if ((map = proc_addr2map(p, addr)) == NULL)
return (-1);
if ((fd = find_dbg_obj(map->pr_mapname)) < 0) {
DPRINTF("ERROR: open %s failed", map->pr_mapname);
goto err0;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
goto err1;
}
if (gelf_getehdr(e, &ehdr) == NULL) {
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
goto err2;
}
/*
* Find the index of the STRTAB and SYMTAB sections to locate
* symbol names.
*/
scn = NULL;
while ((scn = elf_nextscn(e, scn)) != NULL) {
gelf_getshdr(scn, &shdr);
switch (shdr.sh_type) {
case SHT_SYMTAB:
symtabscn = scn;
symtabstridx = shdr.sh_link;
break;
case SHT_DYNSYM:
dynsymscn = scn;
dynsymstridx = shdr.sh_link;
break;
}
}
off = ehdr.e_type == ET_EXEC ? 0 : map->pr_vaddr;
/*
* First look up the symbol in the dynsymtab, and fall back to the
* symtab if the lookup fails.
*/
error = lookup_addr(e, dynsymscn, dynsymstridx, off, addr, &s, symcopy);
if (error == 0)
goto out;
error = lookup_addr(e, symtabscn, symtabstridx, off, addr, &s, symcopy);
if (error != 0)
goto err2;
out:
demangle(s, name, namesz);
err2:
elf_end(e);
err1:
close(fd);
err0:
free(map);
return (error);
}
int
proc_name2sym(struct proc_handle *p, const char *object, const char *symbol,
GElf_Sym *symcopy, prsyminfo_t *si)
{
Elf *e;
Elf_Scn *scn, *dynsymscn = NULL, *symtabscn = NULL;
GElf_Shdr shdr;
GElf_Ehdr ehdr;
prmap_t *map;
uintptr_t off;
u_long symtabstridx = 0, dynsymstridx = 0;
int fd, error = -1;
if ((map = proc_name2map(p, object)) == NULL) {
DPRINTFX("ERROR: couldn't find object %s", object);
goto err0;
}
if ((fd = find_dbg_obj(map->pr_mapname)) < 0) {
DPRINTF("ERROR: open %s failed", map->pr_mapname);
goto err0;
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
DPRINTFX("ERROR: elf_begin() failed: %s", elf_errmsg(-1));
goto err1;
}
if (gelf_getehdr(e, &ehdr) == NULL) {
DPRINTFX("ERROR: gelf_getehdr() failed: %s", elf_errmsg(-1));
goto err2;
}
/*
* Find the index of the STRTAB and SYMTAB sections to locate
* symbol names.
*/
scn = NULL;
while ((scn = elf_nextscn(e, scn)) != NULL) {
gelf_getshdr(scn, &shdr);
switch (shdr.sh_type) {
case SHT_SYMTAB:
symtabscn = scn;
symtabstridx = shdr.sh_link;
break;
case SHT_DYNSYM:
dynsymscn = scn;
dynsymstridx = shdr.sh_link;
break;
}
}
/*
* First look up the symbol in the dynsymtab, and fall back to the
* symtab if the lookup fails.
*/
error = lookup_name(e, dynsymscn, dynsymstridx, symbol, symcopy, si);
if (error == 0)
goto out;
error = lookup_name(e, symtabscn, symtabstridx, symbol, symcopy, si);
if (error == 0)
goto out;
out:
off = ehdr.e_type == ET_EXEC ? 0 : map->pr_vaddr;
symcopy->st_value += off;
err2:
elf_end(e);
err1:
close(fd);
err0:
free(map);
return (error);
}
struct sr_elf_plt_entry *
sr_elf_get_procedure_linkage_table(const char *filename,
char **error_message)
{
#ifdef WITH_ELFUTILS
/* Open the input file. */
int fd = open(filename, O_RDONLY);
if (fd < 0)
{
*error_message = sr_asprintf("Failed to open file %s: %s",
filename,
strerror(errno));
return NULL;
}
/* Initialize libelf on the opened file. */
Elf *elf = elf_begin(fd, ELF_C_READ, NULL);
if (!elf)
{
*error_message = sr_asprintf("Failed to run elf_begin on file %s: %s",
filename,
elf_errmsg(-1));
close(fd);
return NULL;
}
/* Find the .plt section. */
GElf_Shdr shdr;
Elf_Data *plt_data;
char *find_section_error_message;
size_t plt_section_index = find_elf_section_by_name(elf,
".plt",
&plt_data,
&shdr,
&find_section_error_message);
if (0 == plt_section_index)
{
*error_message = sr_asprintf("Failed to find .plt section for %s: %s",
filename,
find_section_error_message);
free(find_section_error_message);
elf_end(elf);
close(fd);
return NULL;
}
/* Find the relocation section for .plt (typically .rela.plt), together
* with its symbol and string table
*/
uint64_t plt_base = shdr.sh_addr;
Elf_Data *rela_plt_data = NULL;
Elf_Data *plt_symbols = NULL;
size_t stringtable = 0;
Elf_Scn *section = NULL;
while ((section = elf_nextscn(elf, section)) != NULL)
{
if (gelf_getshdr(section, &shdr) != &shdr)
{
*error_message = sr_asprintf("gelf_getshdr failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
if (shdr.sh_type == SHT_RELA &&
shdr.sh_info == plt_section_index)
{
rela_plt_data = elf_getdata(section, NULL);
if (!rela_plt_data)
{
*error_message = sr_asprintf("elf_getdata failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
/* Get symbol section for .rela.plt */
Elf_Scn *symbol_section = elf_getscn(elf, shdr.sh_link);
if (!symbol_section)
{
*error_message = sr_asprintf("elf_getscn failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
plt_symbols = elf_getdata(symbol_section, NULL);
if (!plt_symbols)
{
*error_message = sr_asprintf("elf_getdata failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
/* Get string table for the symbol table. */
if (gelf_getshdr(symbol_section, &shdr) != &shdr)
{
*error_message = sr_asprintf("gelf_getshdr failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
stringtable = shdr.sh_link;
break;
}
}
if (0 == stringtable)
{
*error_message = sr_asprintf("Unable to read symbol table for .plt for file %s",
filename);
elf_end(elf);
close(fd);
return NULL;
}
/* PLT looks like this (see also AMD64 ABI, page 78):
*
* Disassembly of section .plt:
*
* 0000003463e01010 <attr_removef@plt-0x10>:
* 3463e01010: ff 35 2a 2c 20 00 pushq 0x202c2a(%rip) <-- here is plt_base
* 3463e01016: ff 25 2c 2c 20 00 jmpq *0x202c2c(%rip) each "slot" is 16B wide
* 3463e0101c: 0f 1f 40 00 nopl 0x0(%rax) 0-th slot is skipped
*
* 0000003463e01020 <attr_removef@plt>:
* 3463e01020: ff 25 2a 2c 20 00 jmpq *0x202c2a(%rip)
* 3463e01026: 68 00 00 00 00 pushq $0x0 <-- this is the number we want
* 3463e0102b: e9 e0 ff ff ff jmpq 3463e01010 <_init+0x18>
*
* 0000003463e01030 <fgetxattr@plt>:
* 3463e01030: ff 25 22 2c 20 00 jmpq *0x202c22(%rip)
* 3463e01036: 68 01 00 00 00 pushq $0x1
* 3463e0103b: e9 d0 ff ff ff jmpq 3463e01010 <_init+0x18>
*/
struct sr_elf_plt_entry *result = NULL, *last = NULL;
for (unsigned plt_offset = 16; plt_offset < plt_data->d_size; plt_offset += 16)
{
uint32_t *plt_index = (uint32_t*)(plt_data->d_buf + plt_offset + 7);
GElf_Rela rela;
if (gelf_getrela(rela_plt_data, *plt_index, &rela) != &rela)
{
*error_message = sr_asprintf("gelf_getrela failed for %s: %s",
filename,
elf_errmsg(-1));
sr_elf_procedure_linkage_table_free(result);
elf_end(elf);
close(fd);
return NULL;
}
GElf_Sym symb;
if (gelf_getsym(plt_symbols, GELF_R_SYM(rela.r_info), &symb) != &symb)
{
*error_message = sr_asprintf("gelf_getsym failed for %s: %s",
filename,
elf_errmsg(-1));
sr_elf_procedure_linkage_table_free(result);
elf_end(elf);
close(fd);
return NULL;
}
struct sr_elf_plt_entry *entry = sr_malloc(sizeof(struct sr_elf_plt_entry));
entry->symbol_name = sr_strdup(elf_strptr(elf, stringtable,
symb.st_name));
entry->address = (uint64_t)(plt_base + plt_offset);
entry->next = NULL;
if (result)
{
last->next = entry;
last = entry;
}
else
result = last = entry;
}
elf_end(elf);
close(fd);
return result;
#else /* WITH_ELFUTILS */
*error_message = sr_asprintf("satyr compiled without elfutils");
return NULL;
#endif /* WITH_ELFUTILS */
}
int elfu_eCheck(Elf *e)
{
int elfclass;
GElf_Ehdr ehdr;
GElf_Phdr *phdrs = NULL;
GElf_Shdr *shdrs = NULL;
size_t i, j, numPhdr, numShdr;
int retval = 0;
assert(e);
elfclass = gelf_getclass(e);
if (elfclass == ELFCLASSNONE) {
ELFU_WARNELF("getclass");
goto ERROR;
}
if (!gelf_getehdr(e, &ehdr)) {
ELFU_WARNELF("gelf_getehdr");
goto ERROR;
}
if (ehdr.e_machine != EM_386 && ehdr.e_machine != EM_X86_64) {
ELFU_WARN("Sorry, only x86-32 and x86-64 ELF files are supported at the moment.\n");
goto ERROR;
}
if (elf_getphdrnum(e, &numPhdr)) {
ELFU_WARNELF("elf_getphdrnum");
goto ERROR;
}
if (elf_getshdrnum(e, &numShdr)) {
ELFU_WARNELF("elf_getshdrnum");
goto ERROR;
}
if (numPhdr > 0) {
phdrs = malloc(numPhdr * sizeof(GElf_Phdr));
if (!phdrs) {
ELFU_WARN("elfu_eCheck: malloc() failed for phdrs.\n");
goto ERROR;
}
/* Attempt to load all PHDRs at once to catch any errors early */
for (i = 0; i < numPhdr; i++) {
GElf_Phdr phdr;
if (gelf_getphdr(e, i, &phdr) != &phdr) {
ELFU_WARN("gelf_getphdr() failed for #%d: %s\n", i, elf_errmsg(-1));
goto ERROR;
}
phdrs[i] = phdr;
}
/* Check that LOAD PHDR memory ranges do not overlap, and that others
* are either fully contained in a LOAD range, or not at all. */
for (i = 0; i < numPhdr; i++) {
if (phdrs[i].p_type != PT_LOAD) {
continue;
}
for (j = 0; j < numPhdr; j++) {
if (j == i || phdrs[j].p_type != PT_LOAD) {
continue;
}
if (OVERLAPPING(phdrs[i].p_vaddr, phdrs[i].p_memsz,
phdrs[j].p_vaddr, phdrs[j].p_memsz)) {
if (phdrs[j].p_type == PT_LOAD) {
ELFU_WARN("elfu_eCheck: Found LOAD PHDRs that overlap in memory.\n");
goto ERROR;
} else if (!FULLY_OVERLAPPING(phdrs[i].p_vaddr, phdrs[i].p_memsz,
phdrs[j].p_vaddr, phdrs[j].p_memsz)) {
ELFU_WARN("elfu_eCheck: PHDRs %d and %d partially overlap in memory.\n", i, j);
goto ERROR;
}
}
}
}
}
if (numShdr > 1) {
/* SHDRs should not overlap with PHDRs. */
if (OVERLAPPING(ehdr.e_shoff, numShdr * ehdr.e_shentsize,
ehdr.e_phoff, numPhdr * ehdr.e_phentsize)) {
ELFU_WARN("elfu_eCheck: SHDRs overlap with PHDRs.\n");
goto ERROR;
}
shdrs = malloc(numShdr * sizeof(GElf_Shdr));
if (!shdrs) {
ELFU_WARN("elfu_eCheck: malloc() failed for shdrs.\n");
goto ERROR;
}
/* Attempt to load all SHDRs at once to catch any errors early */
for (i = 1; i < numShdr; i++) {
Elf_Scn *scn;
GElf_Shdr shdr;
scn = elf_getscn(e, i);
if (!scn) {
ELFU_WARN("elf_getscn() failed for #%d: %s\n", i, elf_errmsg(-1));
}
if (gelf_getshdr(scn, &shdr) != &shdr) {
ELFU_WARNELF("gelf_getshdr");
goto ERROR;
}
shdrs[i] = shdr;
}
/* Check that Section memory ranges do not overlap.
* NB: Section 0 is reserved and thus ignored. */
for (i = 1; i < numShdr; i++) {
/* Section should not overlap with EHDR. */
if (shdrs[i].sh_offset == 0) {
ELFU_WARN("elfu_eCheck: Section %d overlaps with EHDR.\n", i);
goto ERROR;
}
/* Section should not overlap with PHDRs. */
if (OVERLAPPING(shdrs[i].sh_offset, SCNFILESIZE(&shdrs[i]),
ehdr.e_phoff, numPhdr * ehdr.e_phentsize)) {
ELFU_WARN("elfu_eCheck: Section %d overlaps with PHDR.\n", i);
goto ERROR;
}
/* Section should not overlap with SHDRs. */
if (OVERLAPPING(shdrs[i].sh_offset, SCNFILESIZE(&shdrs[i]),
ehdr.e_shoff, numShdr * ehdr.e_shentsize)) {
ELFU_WARN("elfu_eCheck: Section %d overlaps with SHDRs.\n", i);
goto ERROR;
}
for (j = 1; j < numShdr; j++) {
if (j == i) {
continue;
}
/* Sections must not overlap in memory. */
if (shdrs[i].sh_addr != 0
&& shdrs[j].sh_addr != 0
&& OVERLAPPING(shdrs[i].sh_addr, shdrs[i].sh_size,
shdrs[j].sh_addr, shdrs[j].sh_size)) {
ELFU_WARN("elfu_eCheck: Sections %d and %d overlap in memory.\n", i, j);
goto ERROR;
}
/* Sections must not overlap in file. */
if (OVERLAPPING(shdrs[i].sh_offset, SCNFILESIZE(&shdrs[i]),
shdrs[j].sh_offset, SCNFILESIZE(&shdrs[j]))) {
ELFU_WARN("elfu_eCheck: Sections %d and %d overlap in file.\n", i, j);
goto ERROR;
}
/* We may not have more than one symbol table */
if (shdrs[i].sh_type == SHT_SYMTAB && shdrs[j].sh_type == SHT_SYMTAB) {
ELFU_WARN("elfu_eCheck: Found more than one SYMTAB section.\n");
goto ERROR;
}
/* We may not have more than one dynamic symbol table */
if (shdrs[i].sh_type == SHT_DYNSYM && shdrs[j].sh_type == SHT_DYNSYM) {
ELFU_WARN("elfu_eCheck: Found more than one DYNSYM section.\n");
goto ERROR;
}
}
/* Section addr/offset should match parent PHDR.
* Find parent PHDR: */
for (j = 0; j < numPhdr; j++) {
if (PHDR_CONTAINS_SCN_IN_MEMORY(&phdrs[j], &shdrs[i])) {
GElf_Off shoff = phdrs[j].p_offset + (shdrs[i].sh_addr - phdrs[j].p_vaddr);
if ((shdrs[i].sh_offset != shoff && shdrs[i].sh_type != SHT_NOBITS)
|| !PHDR_CONTAINS_SCN_IN_FILE(&phdrs[j], &shdrs[i])) {
ELFU_WARN("elfu_eCheck: SHDR %d and PHDR %d report conflicting file/memory regions.\n", i, j);
goto ERROR;
}
}
}
/* sh_link members should not point to sections out of range. */
if (shdrs[i].sh_link >= numShdr) {
ELFU_WARN("elfu_eCheck: Bogus sh_link in SHDR %d.\n", i);
}
}
}
DONE:
if (phdrs) {
free(phdrs);
}
if (shdrs) {
free(shdrs);
}
return retval;
ERROR:
ELFU_WARN("elfu_eCheck: Errors found.\n");
retval = -1;
goto DONE;
}
struct sr_elf_fde *
sr_elf_get_eh_frame(const char *filename,
char **error_message)
{
#ifdef WITH_ELFUTILS
/* Open the input file. */
int fd = open(filename, O_RDONLY);
if (fd < 0)
{
*error_message = sr_asprintf("Failed to open file %s: %s",
filename,
strerror(errno));
return NULL;
}
/* Initialize libelf on the opened file. */
Elf *elf = elf_begin(fd, ELF_C_READ, NULL);
if (!elf)
{
*error_message = sr_asprintf("Failed to run elf_begin on file %s: %s",
filename,
elf_errmsg(-1));
close(fd);
return NULL;
}
unsigned char *e_ident = (unsigned char *)elf_getident(elf, NULL);
if (!e_ident)
{
*error_message = sr_asprintf("elf_getident failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
/* Look up the .eh_frame section */
GElf_Shdr shdr;
Elf_Data *section_data;
char *find_section_error_message;
if (!find_elf_section_by_name(elf,
".eh_frame",
§ion_data,
&shdr,
&find_section_error_message))
{
*error_message = sr_asprintf("Failed to find .eh_frame section for %s: %s",
filename,
find_section_error_message);
free(find_section_error_message);
elf_end(elf);
close(fd);
return NULL;
}
/* Get the address at which the executable segment is loaded. If
* the .eh_frame addresses are absolute, this is used to convert
* them to relative to the beginning of executable segment. We
* are looking for the first LOAD segment that is executable, I
* hope this is sufficient.
*/
size_t phnum;
if (elf_getphdrnum(elf, &phnum) != 0)
{
*error_message = sr_asprintf("elf_getphdrnum failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
uint64_t exec_base = -1;
int i;
for (i = 0; i < phnum; i++)
{
GElf_Phdr phdr;
if (gelf_getphdr(elf, i, &phdr) != &phdr)
{
*error_message = sr_asprintf("gelf_getphdr failed for %s: %s",
filename,
elf_errmsg(-1));
elf_end(elf);
close(fd);
return NULL;
}
if (phdr.p_type == PT_LOAD && phdr.p_flags & PF_X)
{
exec_base = phdr.p_vaddr;
break;
}
}
if (-1 == exec_base)
{
*error_message = sr_asprintf("Can't determine executable base for %s",
filename);
elf_end(elf);
close(fd);
return NULL;
}
/* We now have a handle to .eh_frame data. We'll use
* dwarf_next_cfi to iterate through all FDEs looking for those
* matching the addresses we have.
*
* Some info on .eh_frame can be found at
* http://www.airs.com/blog/archives/460 and in DWARF
* documentation for .debug_frame. The initial_location and
* address_range decoding is 'inspired' by elfutils source.
*
* @todo If this linear scan is too slow, we can do binary search
* on .eh_frame_hdr -- see http://www.airs.com/blog/archives/462
*/
struct sr_elf_fde *result = NULL, *last = NULL;
struct cie *cie_list = NULL, *cie_list_last = NULL;
Dwarf_Off cfi_offset_next = 0;
while (true)
{
Dwarf_CFI_Entry cfi;
Dwarf_Off cfi_offset = cfi_offset_next;
int ret = dwarf_next_cfi(e_ident,
section_data,
1,
cfi_offset,
&cfi_offset_next,
&cfi);
if (ret > 0)
{
/* We're at the end. */
break;
}
if (ret < 0)
{
/* Error. If cfi_offset_next was updated, we may skip the
* erroneous cfi. */
if (cfi_offset_next > cfi_offset)
continue;
*error_message = sr_asprintf("dwarf_next_cfi failed for %s: %s",
filename,
dwarf_errmsg(-1));
cie_free(cie_list);
sr_elf_eh_frame_free(result);
elf_end(elf);
close(fd);
return NULL;
}
if (dwarf_cfi_cie_p(&cfi))
{
/* Current CFI is a CIE. We store its offset and FDE encoding
* attributes to be used when reading FDEs.
*/
/* Default FDE encoding (i.e. no R in augmentation string) is
* DW_EH_PE_absptr.
*/
char *cie_error_message;
struct cie *cie = read_cie(&cfi,
cfi_offset,
e_ident,
&cie_error_message);
if (!cie)
{
*error_message = sr_asprintf("CIE reading failed for %s: %s",
filename,
cie_error_message);
free(cie_error_message);
cie_free(cie_list);
sr_elf_eh_frame_free(result);
elf_end(elf);
close(fd);
return NULL;
}
/* Append the newly parsed CIE to our list of CIEs. */
if (cie_list)
{
cie_list_last->next = cie;
cie_list_last = cie;
}
else
cie_list = cie_list_last = cie;
}
else
{
/* Current CFI is an FDE.
*/
struct cie *cie = cie_list;
/* Find the CIE data that we should have saved earlier. */
while (cie)
{
/* In .eh_frame, CIE_pointer is relative, but libdw converts it
* to absolute offset. */
if (cfi.fde.CIE_pointer == cie->cie_offset)
break; /* Found. */
cie = cie->next;
}
if (!cie)
{
*error_message = sr_asprintf("CIE not found for FDE %jx in %s",
(uintmax_t)cfi_offset,
filename);
cie_free(cie_list);
sr_elf_eh_frame_free(result);
elf_end(elf);
close(fd);
return NULL;
}
/* Read the two numbers we need and if they are PC-relative,
* compute the offset from VMA base
*/
uint64_t initial_location = fde_read_address(cfi.fde.start,
cie->ptr_len);
uint64_t address_range = fde_read_address(cfi.fde.start + cie->ptr_len,
cie->ptr_len);
if (cie->pcrel)
{
/* We need to determine how long is the 'length' (and
* consequently CIE id) field of this FDE -- it can be
* either 4 or 12 bytes long. */
uint64_t length = fde_read_address(section_data->d_buf + cfi_offset, 4);
uint64_t skip = (length == 0xffffffffUL ? 12 : 4);
uint64_t mask = (cie->ptr_len == 4 ? 0xffffffffUL : 0xffffffffffffffffUL);
initial_location += shdr.sh_offset + cfi_offset + 2 * skip;
initial_location &= mask;
}
else
{
/* Assuming that not pcrel means absolute address
* (what if the file is a library?). Convert to
* text-section-start-relative.
*/
initial_location -= exec_base;
}
struct sr_elf_fde *fde = sr_malloc(sizeof(struct sr_elf_fde));
fde->exec_base = exec_base;
fde->start_address = initial_location;
fde->length = address_range;
fde->next = NULL;
/* Append the newly parsed Frame Description Entry to our
* list of FDEs.
*/
if (result)
{
last->next = fde;
last = fde;
}
else
result = last = fde;
}
}
cie_free(cie_list);
elf_end(elf);
close(fd);
return result;
#else /* WITH_ELFUTILS */
*error_message = sr_asprintf("satyr compiled without elfutils");
return NULL;
#endif /* WITH_ELFUTILS */
}
int
main (void)
{
AsmCtx_t *ctx;
AsmScn_t *scn;
int result = 0;
int fd;
Elf *elf;
GElf_Ehdr ehdr_mem;
GElf_Ehdr *ehdr;
size_t cnt;
elf_version (EV_CURRENT);
ctx = asm_begin (fname, false, EM_386, ELFCLASS32, ELFDATA2LSB);
if (ctx == NULL)
{
printf ("cannot create assembler context: %s\n", asm_errmsg (-1));
return 1;
}
/* Create two sections. */
scn = asm_newscn (ctx, ".data", SHT_PROGBITS, SHF_ALLOC | SHF_WRITE);
if (scn == NULL)
{
printf ("cannot create section in output file: %s\n", asm_errmsg (-1));
asm_abort (ctx);
return 1;
}
/* Special alignment for the .text section. */
if (asm_align (scn, 16) != 0)
{
printf ("cannot align .text section: %s\n", asm_errmsg (-1));
result = 1;
}
/* Add a few ULEB128 and SLEB128 numbers. */
for (cnt = 0; cnt < ninput; ++cnt)
{
if (asm_adduleb128 (scn, input[cnt]) != 0)
{
printf ("cannot insert uleb %" PRIu32 ": %s\n",
(uint32_t) input[cnt], asm_errmsg (-1));
result = 1;
}
if (asm_addsleb128 (scn, input[cnt]) != 0)
{
printf ("cannot insert sleb %" PRId32 ": %s\n",
input[cnt], asm_errmsg (-1));
result = 1;
}
if (asm_adduleb128 (scn, -input[cnt]) != 0)
{
printf ("cannot insert uleb %" PRIu32 ": %s\n",
(uint32_t) -input[cnt], asm_errmsg (-1));
result = 1;
}
if (asm_addsleb128 (scn, -input[cnt]) != 0)
{
printf ("cannot insert sleb %" PRId32 ": %s\n",
-input[cnt], asm_errmsg (-1));
result = 1;
}
}
/* Create the output file. */
if (asm_end (ctx) != 0)
{
printf ("cannot create output file: %s\n", asm_errmsg (-1));
asm_abort (ctx);
return 1;
}
/* Check the file. */
fd = open (fname, O_RDONLY);
if (fd == -1)
{
printf ("cannot open generated file: %m\n");
result = 1;
goto out;
}
elf = elf_begin (fd, ELF_C_READ, NULL);
if (elf == NULL)
{
printf ("cannot create ELF descriptor: %s\n", elf_errmsg (-1));
result = 1;
goto out_close;
}
if (elf_kind (elf) != ELF_K_ELF)
{
puts ("not a valid ELF file");
result = 1;
goto out_close2;
}
ehdr = gelf_getehdr (elf, &ehdr_mem);
if (ehdr == NULL)
{
printf ("cannot get ELF header: %s\n", elf_errmsg (-1));
result = 1;
goto out_close2;
}
if (memcmp (ehdr, &expected_ehdr, sizeof (GElf_Ehdr)) != 0)
{
puts ("ELF header does not match");
result = 1;
goto out_close2;
}
for (cnt = 1; cnt < 3; ++cnt)
{
Elf_Scn *scn;
GElf_Shdr shdr_mem;
GElf_Shdr *shdr;
scn = elf_getscn (elf, cnt);
if (scn == NULL)
{
printf ("cannot get section %Zd: %s\n", cnt, elf_errmsg (-1));
result = 1;
continue;
}
shdr = gelf_getshdr (scn, &shdr_mem);
if (shdr == NULL)
{
printf ("cannot get section header for section %Zd: %s\n",
cnt, elf_errmsg (-1));
result = 1;
continue;
}
if (strcmp (elf_strptr (elf, ehdr->e_shstrndx, shdr->sh_name),
scnnames[cnt]) != 0)
{
printf ("section %Zd's name differs: %s vs %s\n", cnt,
elf_strptr (elf, ehdr->e_shstrndx, shdr->sh_name),
scnnames[cnt]);
result = 1;
}
if (shdr->sh_type != (cnt == 2 ? SHT_STRTAB : SHT_PROGBITS))
{
printf ("section %Zd's type differs\n", cnt);
result = 1;
}
if ((cnt == 1 && shdr->sh_flags != (SHF_ALLOC | SHF_WRITE))
|| (cnt == 2 && shdr->sh_flags != 0))
{
printf ("section %Zd's flags differs\n", cnt);
result = 1;
}
if (shdr->sh_addr != 0)
{
printf ("section %Zd's address differs\n", cnt);
result = 1;
}
if ((cnt == 1 && shdr->sh_offset != ((sizeof (Elf32_Ehdr) + 15) & ~15))
|| (cnt == 2
&& shdr->sh_offset != (((sizeof (Elf32_Ehdr) + 15) & ~15)
+ sizeof (expecteddata))))
{
printf ("section %Zd's offset differs\n", cnt);
result = 1;
}
if ((cnt == 1 && shdr->sh_size != sizeof (expecteddata))
|| (cnt == 2 && shdr->sh_size != 17))
{
printf ("section %Zd's size differs\n", cnt);
result = 1;
}
if (shdr->sh_link != 0)
{
printf ("section %Zd's link differs\n", cnt);
result = 1;
}
if (shdr->sh_info != 0)
{
printf ("section %Zd's info differs\n", cnt);
result = 1;
}
if ((cnt == 1 && shdr->sh_addralign != 16)
|| (cnt != 1 && shdr->sh_addralign != 1))
{
printf ("section %Zd's addralign differs\n", cnt);
result = 1;
}
if (shdr->sh_entsize != 0)
{
printf ("section %Zd's entsize differs\n", cnt);
result = 1;
}
if (cnt == 1)
{
Elf_Data *data = elf_getdata (scn, NULL);
if (data == NULL)
{
printf ("cannot get data of section %Zd\n", cnt);
result = 1;
}
else
{
if (data->d_size != sizeof (expecteddata))
{
printf ("data block size of section %Zd wrong: got %Zd, "
"expected 96\n", cnt, data->d_size);
result = 1;
}
if (memcmp (data->d_buf, expecteddata, sizeof (expecteddata))
!= 0)
{
printf ("data block content of section %Zd wrong\n", cnt);
result = 1;
}
}
}
}
out_close2:
elf_end (elf);
out_close:
close (fd);
out:
/* We don't need the file anymore. */
unlink (fname);
return result;
}
int init(char* fname)
{
char *id, bytes[5];
if (elf_version (EV_CURRENT) == EV_NONE) {
errx (EXIT_FAILURE, " ELF library initialization "
" failed : %s", elf_errmsg (-1));
return -1;
}
int fd;
if ((fd = open (fname, O_RDONLY, 0)) < 0) {
err (EXIT_FAILURE, " open \"%s\" failed ", fname);
return -1;
}
g.fd = fd;
Elf *e;
if ((e = elf_begin (fd, ELF_C_READ, NULL)) == NULL) {
errx (EXIT_FAILURE, " elf_begin () failed : %s.",
elf_errmsg (-1));
return -1;
}
if (elf_kind (e) != ELF_K_ELF) {
errx (EXIT_FAILURE, " \"%s\" is not an ELF object .",
fname);
return -1;
}
g.e = e;
GElf_Ehdr ehdr;
if (gelf_getehdr (e, &ehdr) == NULL) {
errx (EXIT_FAILURE, " getehdr () failed : %s.",
elf_errmsg (-1));
return -1;
}
g.ehdr = ehdr;
int i;
if ((i = gelf_getclass (e)) == ELFCLASSNONE) {
errx (EXIT_FAILURE, " getclass () failed : %s.",
elf_errmsg (-1));
return -1;
}
if ((id = elf_getident (e, NULL)) == NULL) {
errx (EXIT_FAILURE, " getident () failed : %s.",
elf_errmsg (-1));
return -1;
}
size_t n;
if (elf_getshdrnum (e, &n) != 0) {
errx (EXIT_FAILURE, " getshdrnum () failed : %s.",
elf_errmsg (-1));
return -1;
}
g.shdrnum = n;
if (elf_getshdrstrndx (e, &n) != 0) {
errx (EXIT_FAILURE, " getshdrstrndx () failed : %s.",
elf_errmsg (-1));
return -1;
}
g.shstrndx = n;
if (elf_getphdrnum (e, &n) != 0) {
errx (EXIT_FAILURE, " getphdrnum () failed : %s.",
elf_errmsg (-1));
return -1;
}
g.phdrnum = n;
init_scns();
init_phdrs();
return 0;
}
int
main (void)
{
int result = 0;
size_t cnt;
AsmCtx_t *ctx;
Elf *elf;
int fd;
elf_version (EV_CURRENT);
Ebl *ebl = ebl_openbackend_machine (EM_386);
if (ebl == NULL)
{
puts ("cannot open backend library");
return 1;
}
ctx = asm_begin (fname, ebl, false);
if (ctx == NULL)
{
printf ("cannot create assembler context: %s\n", asm_errmsg (-1));
return 1;
}
if (asm_newcomsym (ctx, "commsym", 4, 16) == NULL)
{
printf ("cannot create common symbol: %s\n", asm_errmsg (-1));
asm_abort (ctx);
return 1;
}
/* Create the output file. */
if (asm_end (ctx) != 0)
{
printf ("cannot create output file: %s\n", asm_errmsg (-1));
asm_abort (ctx);
return 1;
}
/* Check the file. */
fd = open (fname, O_RDONLY);
if (fd == -1)
{
printf ("cannot open generated file: %m\n");
result = 1;
goto out;
}
elf = elf_begin (fd, ELF_C_READ, NULL);
if (elf == NULL)
{
printf ("cannot create ELF descriptor: %s\n", elf_errmsg (-1));
result = 1;
goto out_close;
}
if (elf_kind (elf) != ELF_K_ELF)
{
puts ("not a valid ELF file");
result = 1;
goto out_close2;
}
for (cnt = 1; 1; ++cnt)
{
Elf_Scn *scn;
GElf_Shdr shdr_mem;
GElf_Shdr *shdr;
scn = elf_getscn (elf, cnt);
if (scn == NULL)
{
printf ("cannot get section %Zd: %s\n", cnt, elf_errmsg (-1));
result = 1;
continue;
}
shdr = gelf_getshdr (scn, &shdr_mem);
if (shdr == NULL)
{
printf ("cannot get section header for section %Zd: %s\n",
cnt, elf_errmsg (-1));
result = 1;
continue;
}
/* We are looking for the symbol table. */
if (shdr->sh_type != SHT_SYMTAB)
continue;
for (cnt = 1; cnt< (shdr->sh_size
/ gelf_fsize (elf, ELF_T_SYM, 1, EV_CURRENT));
++cnt)
{
GElf_Sym sym_mem;
GElf_Sym *sym;
if (cnt > 1)
{
puts ("too many symbol");
result = 1;
break;
}
sym = gelf_getsym (elf_getdata (scn, NULL), cnt, &sym_mem);
if (sym == NULL)
{
printf ("cannot get symbol %zu: %s\n", cnt, elf_errmsg (-1));
result = 1;
}
else
{
if (sym->st_shndx != SHN_COMMON)
{
printf ("expected common symbol, got section %u\n",
(unsigned int) sym->st_shndx);
result = 1;
}
if (sym->st_value != 16)
{
printf ("requested alignment 16, is %" PRIuMAX "\n",
(uintmax_t) sym->st_value);
result = 1;
}
if (sym->st_size != 4)
{
printf ("requested size 4, is %" PRIuMAX "\n",
(uintmax_t) sym->st_value);
result = 1;
}
}
}
break;
}
out_close2:
elf_end (elf);
out_close:
close (fd);
out:
/* We don't need the file anymore. */
unlink (fname);
ebl_closebackend (ebl);
return result;
}
// Extract the strings associated with the provided `DynamicTag`
// from the DYNAMIC section of the ELF binary.
Try<std::vector<std::string>> GetDynamicStrings(DynamicTag tag) const
{
if (sections.count(SectionType::DYNAMIC) == 0) {
return Error("No DYNAMIC sections found in ELF");
}
if (sections.count(SectionType::DYNAMIC) != 1) {
return Error("Multiple DYNAMIC sections found in ELF");
}
Elf_Scn* dynamic_section = sections.at(SectionType::DYNAMIC)[0];
// Walk through the entries in the dynamic section and look for
// entries with the provided tag. These entries contain offsets to
// strings in the dynamic section's string table. Consequently, we
// also have to look for an entry containing a pointer to the
// dynamic section's string table so we can resolve the strings
// associated with the provided tag later on.
Elf_Data* dynamic_data = elf_getdata(dynamic_section, NULL);
if (dynamic_data == NULL) {
return Error("elf_getdata() failed: " + stringify(elf_errmsg(-1)));
}
Option<uintptr_t> strtab_pointer = None();
std::vector<uintptr_t> strtab_offsets;
for (size_t i = 0; i < dynamic_data->d_size / sizeof(GElf_Dyn); i++) {
GElf_Dyn entry;
if (gelf_getdyn(dynamic_data, i, &entry) == NULL) {
return Error("gelf_getdyn() failed: " + stringify(elf_errmsg(-1)));
}
if ((DynamicTag)entry.d_tag == DynamicTag::STRTAB) {
strtab_pointer = entry.d_un.d_ptr;
}
if ((DynamicTag)entry.d_tag == tag) {
strtab_offsets.push_back(entry.d_un.d_ptr);
}
}
if (strtab_offsets.empty()) {
return std::vector<std::string>();
}
if (strtab_pointer.isNone()) {
return Error("Failed to find string table");
}
// Get a reference to the actual string table so we can index into it.
Elf_Scn* string_table_section = gelf_offscn(elf, strtab_pointer.get());
if (string_table_section == NULL) {
return Error("gelf_offscn() failed: " + stringify(elf_errmsg(-1)));
}
size_t strtab_index = elf_ndxscn(string_table_section);
if (strtab_index == SHN_UNDEF) {
return Error("elf_ndxscn() failed: " + stringify(elf_errmsg(-1)));
}
// Find the strings in the string table from their offsets and return them.
std::vector<std::string> strings;
foreach (uintptr_t offset, strtab_offsets) {
char* string = elf_strptr(elf, strtab_index, offset);
if (string == NULL) {
return Error("elf_strptr() failed: " + stringify(elf_errmsg(-1)));
}
strings.push_back(string);
}
static int
analyse_elf(struct pkg *pkg, const char *fpath,
int (action)(void *, struct pkg *, const char *, const char *, bool),
void *actdata)
{
Elf *e = NULL;
GElf_Ehdr elfhdr;
Elf_Scn *scn = NULL;
Elf_Scn *note = NULL;
Elf_Scn *dynamic = NULL;
GElf_Shdr shdr;
Elf_Data *data;
GElf_Dyn *dyn, dyn_mem;
struct stat sb;
int ret = EPKG_OK;
size_t numdyn = 0;
size_t sh_link = 0;
size_t dynidx;
const char *osname;
const char *shlib;
bool developer = false;
bool is_shlib = false;
pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer);
int fd;
if (lstat(fpath, &sb) != 0)
pkg_emit_errno("fstat() failed for", fpath);
/* ignore empty files and non regular files */
if (sb.st_size == 0 || !S_ISREG(sb.st_mode))
return (EPKG_END); /* Empty file or sym-link: no results */
if ((fd = open(fpath, O_RDONLY, 0)) < 0) {
return (EPKG_FATAL);
}
if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("elf_begin() for %s failed: %s", fpath,
elf_errmsg(-1));
goto cleanup;
}
if (elf_kind(e) != ELF_K_ELF) {
/* Not an elf file: no results */
ret = EPKG_END;
goto cleanup;
}
if (developer)
pkg->flags |= PKG_CONTAINS_ELF_OBJECTS;
if (gelf_getehdr(e, &elfhdr) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("getehdr() failed: %s.", elf_errmsg(-1));
goto cleanup;
}
while ((scn = elf_nextscn(e, scn)) != NULL) {
if (gelf_getshdr(scn, &shdr) != &shdr) {
ret = EPKG_FATAL;
pkg_emit_error("getshdr() for %s failed: %s", fpath,
elf_errmsg(-1));
goto cleanup;
}
switch (shdr.sh_type) {
case SHT_NOTE:
note = scn;
break;
case SHT_DYNAMIC:
dynamic = scn;
sh_link = shdr.sh_link;
numdyn = shdr.sh_size / shdr.sh_entsize;
break;
}
if (note != NULL && dynamic != NULL)
break;
}
/*
* note == NULL usually means a shared object for use with dlopen(3)
* dynamic == NULL means not a dynamically linked elf
*/
if (dynamic == NULL) {
ret = EPKG_END;
goto cleanup; /* not a dynamically linked elf: no results */
}
if (note != NULL) {
if ((data = elf_getdata(note, NULL)) == NULL) {
ret = EPKG_END; /* Some error occurred, ignore this file */
goto cleanup;
}
if (data->d_buf == NULL) {
ret = EPKG_END; /* No osname available */
goto cleanup;
}
osname = (const char *) data->d_buf + sizeof(Elf_Note);
if (strncasecmp(osname, "freebsd", sizeof("freebsd")) != 0 &&
strncasecmp(osname, "dragonfly", sizeof("dragonfly")) != 0) {
ret = EPKG_END; /* Foreign (probably linux) ELF object */
goto cleanup;
}
} else {
if (elfhdr.e_ident[EI_OSABI] != ELFOSABI_FREEBSD) {
ret = EPKG_END;
goto cleanup;
}
}
if ((data = elf_getdata(dynamic, NULL)) == NULL) {
ret = EPKG_END; /* Some error occurred, ignore this file */
goto cleanup;
}
/* First, scan through the data from the .dynamic section to
find any RPATH or RUNPATH settings. These are colon
separated paths to prepend to the ld.so search paths from
the ELF hints file. These always seem to come right after
the NEEDED shared library entries.
NEEDED entries should resolve to a filename for installed
executables, but need not resolve for installed shared
libraries -- additional info from the apps that link
against them would be required. Shared libraries are
distinguished by a DT_SONAME tag */
rpath_list_init();
for (dynidx = 0; dynidx < numdyn; dynidx++) {
if ((dyn = gelf_getdyn(data, dynidx, &dyn_mem)) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("getdyn() failed for %s: %s", fpath,
elf_errmsg(-1));
goto cleanup;
}
if (dyn->d_tag == DT_SONAME) {
is_shlib = true;
/* The file being scanned is a shared library
*provided* by the package. Record this if
appropriate */
pkg_addshlib_provided(pkg, basename(fpath));
}
if (dyn->d_tag != DT_RPATH && dyn->d_tag != DT_RUNPATH)
continue;
shlib_list_from_rpath(elf_strptr(e, sh_link, dyn->d_un.d_val),
dirname(fpath));
break;
}
/* Now find all of the NEEDED shared libraries. */
for (dynidx = 0; dynidx < numdyn; dynidx++) {
if ((dyn = gelf_getdyn(data, dynidx, &dyn_mem)) == NULL) {
ret = EPKG_FATAL;
pkg_emit_error("getdyn() failed for %s: %s", fpath,
elf_errmsg(-1));
goto cleanup;
}
if (dyn->d_tag != DT_NEEDED)
continue;
shlib = elf_strptr(e, sh_link, dyn->d_un.d_val);
action(actdata, pkg, fpath, shlib, is_shlib);
}
cleanup:
rpath_list_free();
if (e != NULL)
elf_end(e);
close(fd);
return (ret);
}
void c_mem_load_elf (char *elf_filename,
const char *start_symbol,
const char *exit_symbol)
{
int fd;
// int n_initialized = 0;
Elf *e;
// Default start and exit symbols
if (start_symbol == NULL)
start_symbol = "_start";
if (exit_symbol == NULL)
exit_symbol = "exit";
// Verify the elf library version
if (elf_version (EV_CURRENT) == EV_NONE) {
fprintf (stderr, "ERROR: c_mem_load_elf: Failed to initialize the libelfg library!\n");
exit (1);
}
// Open the file for reading
fd = open (elf_filename, O_RDONLY, 0);
if (fd < 0) {
fprintf (stderr, "ERROR: c_mem_load_elf: could not open elf input file: %s\n", elf_filename);
exit (1);
}
// Initialize the Elf pointer with the open file
e = elf_begin (fd, ELF_C_READ, NULL);
if (e == NULL) {
fprintf (stderr, "ERROR: c_mem_load_elf: elf_begin() initialization failed!\n");
exit (1);
}
// Verify that the file is an ELF file
if (elf_kind (e) != ELF_K_ELF) {
elf_end (e);
fprintf (stderr, "ERROR: c_mem_load_elf: specified file '%s' is not an ELF file!\n", elf_filename);
exit (1);
}
// Get the ELF header
GElf_Ehdr ehdr;
if (gelf_getehdr (e, & ehdr) == NULL) {
elf_end (e);
fprintf (stderr, "ERROR: c_mem_load_elf: get_getehdr() failed: %s\n", elf_errmsg(-1));
exit (1);
}
// Is this a 32b or 64 ELF?
if (gelf_getclass (e) == ELFCLASS32) {
fprintf (stdout, "c_mem_load_elf: %s is a 32-bit ELF file\n", elf_filename);
bitwidth = 32;
}
else if (gelf_getclass (e) == ELFCLASS64) {
fprintf (stdout, "c_mem_load_elf: %s is a 64-bit ELF file\n", elf_filename);
bitwidth = 64;
}
else {
fprintf (stderr, "ERROR: c_mem_load_elf: ELF file '%s' is not 32b or 64b\n", elf_filename);
elf_end (e);
exit (1);
}
// Verify we are dealing with a RISC-V ELF
if (ehdr.e_machine != 243) { // EM_RISCV is not defined, but this returns 243 when used with a valid elf file.
elf_end (e);
fprintf (stderr, "ERROR: c_mem_load_elf: %s is not a RISC-V ELF file\n", elf_filename);
exit (1);
}
// Verify we are dealing with a little endian ELF
if (ehdr.e_ident[EI_DATA] != ELFDATA2LSB) {
elf_end (e);
fprintf (stderr,
"ERROR: c_mem_load_elf: %s is a big-endian 64-bit RISC-V executable which is not supported\n",
elf_filename);
exit (1);
}
// Grab the string section index
size_t shstrndx;
shstrndx = ehdr.e_shstrndx;
// Iterate through each of the sections looking for code that should be loaded
Elf_Scn *scn = 0;
GElf_Shdr shdr;
min_addr = 0xFFFFFFFFFFFFFFFFllu;
max_addr = 0x0000000000000000llu;
pc_start = 0xFFFFFFFFFFFFFFFFllu;
pc_exit = 0xFFFFFFFFFFFFFFFFllu;
while ((scn = elf_nextscn (e,scn)) != NULL) {
// get the header information for this section
gelf_getshdr (scn, & shdr);
char *sec_name = elf_strptr (e, shstrndx, shdr.sh_name);
fprintf (stdout, "Section %-16s: ", sec_name);
Elf_Data *data = 0;
// If we find a code/data section, load it into the model
if ( ((shdr.sh_type == SHT_PROGBITS)
|| (shdr.sh_type == SHT_INIT_ARRAY)
|| (shdr.sh_type == SHT_FINI_ARRAY))
&& ((shdr.sh_flags & SHF_WRITE)
|| (shdr.sh_flags & SHF_ALLOC)
|| (shdr.sh_flags & SHF_EXECINSTR))) {
data = elf_getdata (scn, data);
// n_initialized += data->d_size;
if (shdr.sh_addr < min_addr)
min_addr = shdr.sh_addr;
if (max_addr < (shdr.sh_addr + data->d_size - 1)) // shdr.sh_size + 4))
max_addr = shdr.sh_addr + data->d_size - 1; // shdr.sh_size + 4;
if (max_addr >= MAX_MEM_SIZE) {
fprintf (stdout, "INTERNAL ERROR: max_addr (0x%0" PRIx64 ") > buffer size (0x%0" PRIx64 ")\n",
max_addr, MAX_MEM_SIZE);
fprintf (stdout, " Please increase the #define in this program, recompile, and run again\n");
fprintf (stdout, " Abandoning this run\n");
exit (1);
}
memcpy (& (mem_buf [shdr.sh_addr]), data->d_buf, data->d_size);
fprintf (stdout, "addr %16" PRIx64 " to addr %16" PRIx64 "; size 0x%8lx (= %0ld) bytes\n",
shdr.sh_addr, shdr.sh_addr + data->d_size, data->d_size, data->d_size);
}
// If we find the symbol table, search for the start address location
else if (shdr.sh_type == SHT_SYMTAB) {
fprintf (stdout, "Searching for addresses of '%s' and '%s' symbols\n", start_symbol, exit_symbol);
// Get the section data
data = elf_getdata (scn, data);
// Get the number of symbols in this section
int symbols = shdr.sh_size / shdr.sh_entsize;
// search for the uart_default symbols we need to potentially modify.
GElf_Sym sym;
int i;
for (i = 0; i < symbols; ++i) {
// get the symbol data
gelf_getsym (data, i, &sym);
// get the name of the symbol
char *name = elf_strptr (e, shdr.sh_link, sym.st_name);
// Look for, and remember PC of the start symbol
if (strcmp (name, start_symbol) == 0) {
pc_start = sym.st_value;
}
// Look for, and remember PC of the exit symbol
else if (strcmp (name, exit_symbol) == 0) {
pc_exit = sym.st_value;
}
}
if (pc_start == -1)
fprintf (stdout, " No '_start' label found\n");
else
fprintf (stdout, " '_start' label addr: %16" PRIx64 " (hex)\n", pc_start);
if (pc_exit == -1)
fprintf (stdout, " No 'exit' label found\n");
else
fprintf (stdout, " 'exit' label addr: %16" PRIx64 " (hex)\n", pc_exit);
}
else {
fprintf (stdout, "Ignored\n");
}
}
elf_end (e);
fprintf (stdout, "Min addr: %16" PRIx64 " (hex)\n", min_addr);
fprintf (stdout, "Max addr: %16" PRIx64 " (hex)\n", max_addr);
}
int
main (int argc, char *argv[])
{
Elf *elf;
int fd;
GElf_Ehdr ehdr;
int cnt;
fd = open (argv[1], O_RDONLY);
if (fd == -1)
{
printf ("cannot open \"%s\": %s\n", argv[1], strerror (errno));
exit (1);
}
elf_version (EV_CURRENT);
elf = elf_begin (fd, ELF_C_READ, NULL);
if (elf == NULL)
{
printf ("cannot open ELF file: %s\n", elf_errmsg (-1));
exit (1);
}
if (elf_kind (elf) != ELF_K_ELF)
{
printf ("\"%s\" is not an ELF file\n", argv[1]);
exit (1);
}
if (gelf_getehdr (elf, &ehdr) == NULL)
{
printf ("cannot get the ELF header: %s\n", elf_errmsg (-1));
exit (1);
}
printf ("idx type %*s %*s %*s %*s %*s align flags\n",
gelf_getclass (elf) == ELFCLASS32 ? 9 : 17, "offset",
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18, "vaddr",
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18, "paddr",
gelf_getclass (elf) == ELFCLASS32 ? 9 : 12, "filesz",
gelf_getclass (elf) == ELFCLASS32 ? 9 : 12, "memsz");
for (cnt = 0; cnt < ehdr.e_phnum; ++cnt)
{
static const char *typenames[] =
{
[PT_NULL] = "NULL",
[PT_LOAD] = "LOAD",
[PT_DYNAMIC] = "DYNAMIC",
[PT_INTERP] = "INTERP",
[PT_NOTE] = "NOTE",
[PT_SHLIB] = "SHLIB",
[PT_PHDR] = "PHDR"
};
GElf_Phdr mem;
GElf_Phdr *phdr = gelf_getphdr (elf, cnt, &mem);
char buf[19];
const char *p_type = typenames[phdr->p_type];
/* If we don't know the name of the type we use the number value. */
if (phdr->p_type >= PT_NUM)
{
snprintf (buf, sizeof (buf), "%x", phdr->p_type);
p_type = buf;
}
printf ("%3d %-7s %#0*llx %#0*llx %#0*llx %#0*llx %#0*llx %#6llx ",
cnt, p_type,
gelf_getclass (elf) == ELFCLASS32 ? 9 : 17,
(unsigned long long int) phdr->p_offset,
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18,
(unsigned long long int) phdr->p_vaddr,
gelf_getclass (elf) == ELFCLASS32 ? 10 : 18,
(unsigned long long int) phdr->p_paddr,
gelf_getclass (elf) == ELFCLASS32 ? 9 : 12,
(unsigned long long int) phdr->p_filesz,
gelf_getclass (elf) == ELFCLASS32 ? 9 : 12,
(unsigned long long int) phdr->p_memsz,
(unsigned long long int) phdr->p_align);
putc_unlocked ((phdr->p_flags & PF_X) ? 'X' : ' ', stdout);
putc_unlocked ((phdr->p_flags & PF_W) ? 'W' : ' ', stdout);
putc_unlocked ((phdr->p_flags & PF_R) ? 'R' : ' ', stdout);
putc_unlocked ('\n', stdout);
if (phdr->p_type == PT_INTERP)
{
/* We can show the user the name of the interpreter. */
size_t maxsize;
char *filedata = elf_rawfile (elf, &maxsize);
if (filedata != NULL && phdr->p_offset < maxsize)
printf ("\t[Requesting program interpreter: %s]\n",
filedata + phdr->p_offset);
}
}
if (elf_end (elf) != 0)
{
printf ("error while freeing ELF descriptor: %s\n", elf_errmsg (-1));
exit (1);
}
return 0;
}
/* Add symbols from ELF with value OFFSET to the symbol table SYMTAB. */
void
arlib_add_symbols (Elf *elf, const char *arfname, const char *membername,
off_t off)
{
if (sizeof (off) > sizeof (uint32_t) && off > ~((uint32_t) 0))
/* The archive is too big. */
error (EXIT_FAILURE, 0, gettext ("the archive '%s' is too large"),
arfname);
/* We only add symbol tables for ELF files. It makes not much sense
to add symbols from executables but we do so for compatibility.
For DSOs and executables we use the dynamic symbol table, for
relocatable files all the DT_SYMTAB tables. */
if (elf_kind (elf) != ELF_K_ELF)
return;
GElf_Ehdr ehdr_mem;
GElf_Ehdr *ehdr = gelf_getehdr (elf, &ehdr_mem);
if (ehdr == NULL)
error (EXIT_FAILURE, 0, gettext ("cannot read ELF header of %s(%s): %s"),
arfname, membername, elf_errmsg (-1));
GElf_Word symtype;
if (ehdr->e_type == ET_REL)
symtype = SHT_SYMTAB;
else if (ehdr->e_type == ET_EXEC || ehdr->e_type == ET_DYN)
symtype = SHT_DYNSYM;
else
/* We do not handle that type. */
return;
/* Iterate over all sections. */
Elf_Scn *scn = NULL;
while ((scn = elf_nextscn (elf, scn)) != NULL)
{
/* Get the section header. */
GElf_Shdr shdr_mem;
GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem);
if (shdr == NULL)
continue;
if (shdr->sh_type != symtype)
continue;
Elf_Data *data = elf_getdata (scn, NULL);
if (data == NULL)
continue;
int nsyms = shdr->sh_size / shdr->sh_entsize;
for (int ndx = shdr->sh_info; ndx < nsyms; ++ndx)
{
GElf_Sym sym_mem;
GElf_Sym *sym = gelf_getsym (data, ndx, &sym_mem);
if (sym == NULL)
continue;
/* Ignore undefined symbols. */
if (sym->st_shndx == SHN_UNDEF)
continue;
/* Use this symbol. */
const char *symname = elf_strptr (elf, shdr->sh_link, sym->st_name);
if (symname != NULL)
arlib_add_symref (symname, off);
}
/* Only relocatable files can have more than one symbol table. */
if (ehdr->e_type != ET_REL)
break;
}
}
static inline void tm_elf_err(const char *msg)
{
telem_log(LOG_ERR, "%s: %s\n", msg, elf_errmsg(-1));
}
/* Given Elf header, Elf_Scn, and Elf32_Shdr
* print out the symbol table
*/
void *GetSymbolAdress(const char *filename, const char *symbol) {
#ifdef PLATFORM_POSIX
int fd;
Elf *elf;
GElf_Ehdr elfhdr;
if (elf_version(EV_CURRENT) == EV_NONE) {
META_CONPRINTF("ELF library is out of date, Quitting\n");
}
fd = open(filename, O_RDONLY);
if (fd < 0) {
META_CONPRINTF("[Masterhook] Unable to open \"%s\"\n", filename);
}
elf = elf_begin(fd, ELF_C_READ, NULL);
if (gelf_getehdr(elf, &elfhdr) == 0) {
META_CONPRINTF("Cannot read elf header. This usually means that %s is not a valid elf file\n", filename);
}
Elf_Scn* section = 0;
Elf32_Shdr *shdr = NULL;
bool symtabFound = false;
while ((section = elf_nextscn(elf, section)) != 0) {
if ((shdr = elf32_getshdr (section)) != 0) {
if (shdr->sh_type == SHT_SYMTAB) {
symtabFound = true;
break;
}
}
}
if (shdr == NULL || !symtabFound) {
return NULL;
}
Elf_Scn *scn = section;
Elf_Data *data;
char *name;
data = 0;
int number = 0;
if ((data = elf_getdata(scn, data)) == 0 || data->d_size == 0){
META_CONPRINTF("Section had no data!\n");
return NULL;
}
Elf32_Sym *esym = (Elf32_Sym*) data->d_buf;
Elf32_Sym *lastsym = (Elf32_Sym*) ((char*) data->d_buf + data->d_size);
for (; esym < lastsym; esym++) {
if ((esym->st_value == 0) || (ELF32_ST_BIND(esym->st_info) == STB_WEAK) || (ELF32_ST_BIND(esym->st_info) == STB_NUM) || (ELF32_ST_TYPE(esym->st_info) != STT_FUNC)) {
continue;
}
name = elf_strptr(elf, shdr->sh_link , (size_t)esym->st_name);
if(!name){
META_CONPRINTF("%s\n", elf_errmsg(elf_errno()));
return NULL;
}
char *name_demangled = 0;
int* status;
name_demangled = abi::__cxa_demangle(name, 0, 0, status);
#ifdef DEBUG
META_CONPRINTF("%d: Name: %s == %s Address: 0x%x\n", number++, name_demangled, symbol, esym->st_value);
#endif
if (name_demangled != NULL) {
if (strstr(name_demangled, symbol)) {
return (void*)esym->st_value;
}
}
//free(name_demangled);
}
#endif
return NULL;
}
