Elf_Data*
gelf_xlatetof(Elf *elf, Elf_Data *dst, const Elf_Data *src, unsigned encode) {
if (elf) {
if (elf->e_kind != ELF_K_ELF) {
seterr(ERROR_NOTELF);
}
else if (elf->e_class == ELFCLASS32) {
return elf32_xlatetof(dst, src, encode);
}
else if (elf->e_class == ELFCLASS64) {
return elf64_xlatetof(dst, src, encode);
}
else if (valid_class(elf->e_class)) {
seterr(ERROR_UNIMPLEMENTED);
}
else {
seterr(ERROR_UNKNOWN_CLASS);
}
}
return NULL;
}
Elf *
elf_from_remote_memory (GElf_Addr ehdr_vma,
GElf_Addr *loadbasep,
ssize_t (*read_memory) (void *arg, void *data,
GElf_Addr address,
size_t minread,
size_t maxread),
void *arg)
{
/* First read in the file header and check its sanity. */
const size_t initial_bufsize = 256;
unsigned char *buffer = malloc (initial_bufsize);
if (buffer == NULL)
{
no_memory:
__libdwfl_seterrno (DWFL_E_NOMEM);
return NULL;
}
ssize_t nread = (*read_memory) (arg, buffer, ehdr_vma,
sizeof (Elf32_Ehdr), initial_bufsize);
if (nread <= 0)
{
read_error:
free (buffer);
__libdwfl_seterrno (nread < 0 ? DWFL_E_ERRNO : DWFL_E_TRUNCATED);
return NULL;
}
if (memcmp (buffer, ELFMAG, SELFMAG) != 0)
{
bad_elf:
__libdwfl_seterrno (DWFL_E_BADELF);
return NULL;
}
/* Extract the information we need from the file header. */
union
{
Elf32_Ehdr e32;
Elf64_Ehdr e64;
} ehdr;
Elf_Data xlatefrom =
{
.d_type = ELF_T_EHDR,
.d_buf = buffer,
.d_version = EV_CURRENT,
};
Elf_Data xlateto =
{
.d_type = ELF_T_EHDR,
.d_buf = &ehdr,
.d_size = sizeof ehdr,
.d_version = EV_CURRENT,
};
GElf_Off phoff;
uint_fast16_t phnum;
uint_fast16_t phentsize;
GElf_Off shdrs_end;
switch (buffer[EI_CLASS])
{
case ELFCLASS32:
xlatefrom.d_size = sizeof (Elf32_Ehdr);
if (elf32_xlatetom (&xlateto, &xlatefrom, buffer[EI_DATA]) == NULL)
{
libelf_error:
__libdwfl_seterrno (DWFL_E_LIBELF);
return NULL;
}
phoff = ehdr.e32.e_phoff;
phnum = ehdr.e32.e_phnum;
phentsize = ehdr.e32.e_phentsize;
if (phentsize != sizeof (Elf32_Phdr) || phnum == 0)
goto bad_elf;
shdrs_end = ehdr.e32.e_shoff + ehdr.e32.e_shnum * ehdr.e32.e_shentsize;
break;
case ELFCLASS64:
xlatefrom.d_size = sizeof (Elf64_Ehdr);
if (elf64_xlatetom (&xlateto, &xlatefrom, buffer[EI_DATA]) == NULL)
goto libelf_error;
phoff = ehdr.e64.e_phoff;
phnum = ehdr.e64.e_phnum;
phentsize = ehdr.e64.e_phentsize;
if (phentsize != sizeof (Elf64_Phdr) || phnum == 0)
goto bad_elf;
shdrs_end = ehdr.e64.e_shoff + ehdr.e64.e_shnum * ehdr.e64.e_shentsize;
break;
default:
goto bad_elf;
}
/* The file header tells where to find the program headers.
These are what we use to actually choose what to read. */
xlatefrom.d_type = xlateto.d_type = ELF_T_PHDR;
xlatefrom.d_size = phnum * phentsize;
if ((size_t) nread >= phoff + phnum * phentsize)
/* We already have all the phdrs from the initial read. */
xlatefrom.d_buf = buffer + phoff;
else
{
/* Read in the program headers. */
if (initial_bufsize < phnum * phentsize)
{
unsigned char *newbuf = realloc (buffer, phnum * phentsize);
if (newbuf == NULL)
{
free (buffer);
goto no_memory;
}
buffer = newbuf;
}
nread = (*read_memory) (arg, buffer, ehdr_vma + phoff,
phnum * phentsize, phnum * phentsize);
if (nread <= 0)
goto read_error;
xlatefrom.d_buf = buffer;
}
union
{
Elf32_Phdr p32[phnum];
Elf64_Phdr p64[phnum];
} phdrs;
xlateto.d_buf = &phdrs;
xlateto.d_size = sizeof phdrs;
/* Scan for PT_LOAD segments to find the total size of the file image. */
size_t contents_size = 0;
GElf_Off segments_end = 0;
GElf_Addr loadbase = ehdr_vma;
bool found_base = false;
switch (ehdr.e32.e_ident[EI_CLASS])
{
inline void handle_segment (GElf_Addr vaddr, GElf_Off offset,
GElf_Xword filesz, GElf_Xword align)
{
GElf_Off segment_end = ((offset + filesz + align - 1) & -align);
if (segment_end > (GElf_Off) contents_size)
contents_size = segment_end;
if (!found_base && (offset & -align) == 0)
{
loadbase = ehdr_vma - (vaddr & -align);
found_base = true;
}
segments_end = offset + filesz;
}
case ELFCLASS32:
if (elf32_xlatetom (&xlateto, &xlatefrom,
ehdr.e32.e_ident[EI_DATA]) == NULL)
goto libelf_error;
for (uint_fast16_t i = 0; i < phnum; ++i)
if (phdrs.p32[i].p_type == PT_LOAD)
handle_segment (phdrs.p32[i].p_vaddr, phdrs.p32[i].p_offset,
phdrs.p32[i].p_filesz, phdrs.p32[i].p_align);
break;
case ELFCLASS64:
if (elf64_xlatetom (&xlateto, &xlatefrom,
ehdr.e64.e_ident[EI_DATA]) == NULL)
goto libelf_error;
for (uint_fast16_t i = 0; i < phnum; ++i)
if (phdrs.p64[i].p_type == PT_LOAD)
handle_segment (phdrs.p64[i].p_vaddr, phdrs.p64[i].p_offset,
phdrs.p64[i].p_filesz, phdrs.p64[i].p_align);
break;
default:
abort ();
break;
}
/* Trim the last segment so we don't bother with zeros in the last page
that are off the end of the file. However, if the extra bit in that
page includes the section headers, keep them. */
if ((GElf_Off) contents_size > segments_end
&& (GElf_Off) contents_size >= shdrs_end)
{
contents_size = segments_end;
if ((GElf_Off) contents_size < shdrs_end)
contents_size = shdrs_end;
}
else
contents_size = segments_end;
free (buffer);
/* Now we know the size of the whole image we want read in. */
buffer = calloc (1, contents_size);
if (buffer == NULL)
goto no_memory;
switch (ehdr.e32.e_ident[EI_CLASS])
{
inline bool handle_segment (GElf_Addr vaddr, GElf_Off offset,
GElf_Xword filesz, GElf_Xword align)
{
GElf_Off start = offset & -align;
GElf_Off end = (offset + filesz + align - 1) & -align;
if (end > (GElf_Off) contents_size)
end = contents_size;
nread = (*read_memory) (arg, buffer + start,
(loadbase + vaddr) & -align,
end - start, end - start);
return nread <= 0;
}
case ELFCLASS32:
for (uint_fast16_t i = 0; i < phnum; ++i)
if (phdrs.p32[i].p_type == PT_LOAD)
if (handle_segment (phdrs.p32[i].p_vaddr, phdrs.p32[i].p_offset,
phdrs.p32[i].p_filesz, phdrs.p32[i].p_align))
goto read_error;
/* If the segments visible in memory didn't include the section
headers, then clear them from the file header. */
if (contents_size < shdrs_end)
{
ehdr.e32.e_shoff = 0;
ehdr.e32.e_shnum = 0;
ehdr.e32.e_shstrndx = 0;
}
/* This will normally have been in the first PT_LOAD segment. But it
conceivably could be missing, and we might have just changed it. */
xlatefrom.d_type = xlateto.d_type = ELF_T_EHDR;
xlatefrom.d_size = xlateto.d_size = sizeof ehdr.e32;
xlatefrom.d_buf = &ehdr.e32;
xlateto.d_buf = buffer;
if (elf32_xlatetof (&xlateto, &xlatefrom,
ehdr.e32.e_ident[EI_DATA]) == NULL)
goto libelf_error;
break;
case ELFCLASS64:
for (uint_fast16_t i = 0; i < phnum; ++i)
if (phdrs.p32[i].p_type == PT_LOAD)
if (handle_segment (phdrs.p64[i].p_vaddr, phdrs.p64[i].p_offset,
phdrs.p64[i].p_filesz, phdrs.p64[i].p_align))
goto read_error;
/* If the segments visible in memory didn't include the section
headers, then clear them from the file header. */
if (contents_size < shdrs_end)
{
ehdr.e64.e_shoff = 0;
ehdr.e64.e_shnum = 0;
ehdr.e64.e_shstrndx = 0;
}
/* This will normally have been in the first PT_LOAD segment. But it
conceivably could be missing, and we might have just changed it. */
xlatefrom.d_type = xlateto.d_type = ELF_T_EHDR;
xlatefrom.d_size = xlateto.d_size = sizeof ehdr.e64;
xlatefrom.d_buf = &ehdr.e64;
xlateto.d_buf = buffer;
if (elf64_xlatetof (&xlateto, &xlatefrom,
ehdr.e64.e_ident[EI_DATA]) == NULL)
goto libelf_error;
break;
default:
abort ();
break;
}
static off_t
_elf64_write(Elf *elf, char *outbuf, size_t len) {
Elf64_Ehdr *ehdr;
Elf64_Shdr *shdr;
Elf_Scn *scn;
Scn_Data *sd;
Elf_Data src;
Elf_Data dst;
unsigned encode;
elf_assert(len);
elf_assert(elf->e_ehdr);
ehdr = (Elf64_Ehdr*)elf->e_ehdr;
encode = ehdr->e_ident[EI_DATA];
src.d_buf = ehdr;
src.d_type = ELF_T_EHDR;
src.d_size = _msize(ELFCLASS64, _elf_version, ELF_T_EHDR);
src.d_version = _elf_version;
dst.d_buf = outbuf;
dst.d_size = ehdr->e_ehsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
if (ehdr->e_phnum) {
src.d_buf = elf->e_phdr;
src.d_type = ELF_T_PHDR;
src.d_size = ehdr->e_phnum * _msize(ELFCLASS64, _elf_version, ELF_T_PHDR);
src.d_version = _elf_version;
dst.d_buf = outbuf + ehdr->e_phoff;
dst.d_size = ehdr->e_phnum * ehdr->e_phentsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
}
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
elf_assert(scn->s_magic == SCN_MAGIC);
elf_assert(scn->s_elf == elf);
src.d_buf = &scn->s_uhdr;
src.d_type = ELF_T_SHDR;
src.d_size = _msize(ELFCLASS64, EV_CURRENT, ELF_T_SHDR);
src.d_version = EV_CURRENT;
dst.d_buf = outbuf + ehdr->e_shoff + scn->s_index * ehdr->e_shentsize;
dst.d_size = ehdr->e_shentsize;
dst.d_version = ehdr->e_version;
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
if (scn->s_index == SHN_UNDEF) {
continue;
}
shdr = &scn->s_shdr64;
if (shdr->sh_type == SHT_NULL || shdr->sh_type == SHT_NOBITS) {
continue;
}
/* XXX: this is probably no longer necessary */
if (scn->s_data_1 && !elf_getdata(scn, NULL)) {
return -1;
}
for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
elf_assert(sd->sd_magic == DATA_MAGIC);
elf_assert(sd->sd_scn == scn);
src = sd->sd_data;
if (!src.d_size) {
continue;
}
if (!src.d_buf) {
seterr(ERROR_NULLBUF);
return -1;
}
dst.d_buf = outbuf + shdr->sh_offset + src.d_off;
dst.d_size = src.d_size;
dst.d_version = ehdr->e_version;
if (valid_type(src.d_type)) {
size_t tmp;
tmp = _elf64_xltsize(&src, dst.d_version, ELFDATA2LSB, 1);
if (tmp == (size_t)-1) {
return -1;
}
dst.d_size = tmp;
}
else {
src.d_type = ELF_T_BYTE;
}
if (!elf64_xlatetof(&dst, &src, encode)) {
return -1;
}
}
}
/* cleanup */
if (elf->e_readable && _elf_update_pointers(elf, outbuf, len)) {
return -1;
}
/* NOTE: ehdr is no longer valid! */
ehdr = (Elf64_Ehdr*)elf->e_ehdr; elf_assert(ehdr);
elf->e_encoding = ehdr->e_ident[EI_DATA];
elf->e_version = ehdr->e_ident[EI_VERSION];
elf->e_elf_flags &= ~ELF_F_DIRTY;
elf->e_ehdr_flags &= ~ELF_F_DIRTY;
elf->e_phdr_flags &= ~ELF_F_DIRTY;
for (scn = elf->e_scn_1; scn; scn = scn->s_link) {
scn->s_scn_flags &= ~ELF_F_DIRTY;
scn->s_shdr_flags &= ~ELF_F_DIRTY;
for (sd = scn->s_data_1; sd; sd = sd->sd_link) {
sd->sd_data_flags &= ~ELF_F_DIRTY;
}
if (elf->e_readable) {
shdr = &scn->s_shdr64;
scn->s_type = shdr->sh_type;
scn->s_size = shdr->sh_size;
scn->s_offset = shdr->sh_offset;
}
}
elf->e_size = len;
return len;
}