static void read_sections(void)
{
struct self_sec s[MAX_SECTIONS];
struct elf_phdr p;
u32 i;
u32 j;
u32 n_secs;
u32 self_offset, elf_offset;
memset(s, 0, sizeof s);
for (i = 0, j = 0; i < ehdr.e_phnum; i++) {
read_section(i, &s[j]);
if (s[j].compressed)
j++;
}
n_secs = j;
qsort(s, n_secs, sizeof(*s), qsort_compare);
elf_offset = 0;
self_offset = header_len;
j = 0;
i = 0;
while (elf_offset < filesize) {
if (i == n_secs) {
self_sections[j].offset = self_offset;
self_sections[j].size = filesize - elf_offset;
self_sections[j].compressed = 0;
self_sections[j].size_uncompressed = filesize - elf_offset;
self_sections[j].elf_offset = elf_offset;
elf_offset = filesize;
} else if (self_offset == s[i].offset) {
self_sections[j].offset = self_offset;
self_sections[j].size = s[i].size;
self_sections[j].compressed = 1;
elf_read_phdr(arch64, elf + phdr_offset +
(ehdr.e_phentsize * s[i].idx), &p);
self_sections[j].size_uncompressed = p.p_filesz;
self_sections[j].elf_offset = p.p_off;
elf_offset = p.p_off + p.p_filesz;
self_offset = s[i].next;
i++;
} else {
elf_read_phdr(arch64, elf + phdr_offset +
(ehdr.e_phentsize * s[i].idx), &p);
self_sections[j].offset = self_offset;
self_sections[j].size = p.p_off - elf_offset;
self_sections[j].compressed = 0;
self_sections[j].size_uncompressed = self_sections[j].size;
self_sections[j].elf_offset = elf_offset;
elf_offset += self_sections[j].size;
self_offset += s[i].offset - self_offset;
}
j++;
}
n_sections = j;
}
struct elf_file_t *elf_open(char *path)
{
struct elf_file_t *elf;
/* Create structure */
elf = calloc(1, sizeof(struct elf_file_t));
if (!elf)
fatal("elf_open: out of memory\n");
/// printf("\n length = %d\n",strlen(path));
/// printf("\n tryng to open %s\n",path);
/* Open file */
elf->f = fopen(path, "rb");
/// printf("\n error no is %d",errno);
if (!elf->f)
fatal("%s: cannot open executable file", path);
if (strlen(path) >= sizeof(elf->path))
fatal("%s: executable file path too long", path);
strcpy(elf->path, path);
/* Get file size */
fseek(elf->f, 0, SEEK_END);
elf->size = ftell(elf->f);
fseek(elf->f, 0, SEEK_SET);
/* Read header, section headers, and program headers. */
elf_debug("\n%s: reading ELF file\n", path);
elf_read_ehdr(elf);
elf_read_shdr(elf);
elf_read_phdr(elf);
/* Return elf file structure */
return elf;
}
/**
* elf_read_phdrs - read the program headers from the buffer
*
* This function assumes that the program header table was checked for sanity.
* Use elf_is_ehdr_sane() if it wasn't.
*/
static int elf_read_phdrs(const char *buf, size_t len,
struct elf_info *elf_info)
{
size_t phdr_size, i;
const struct elfhdr *ehdr = elf_info->ehdr;
/*
* e_phnum is at most 65535 so calculating the size of the
* program header cannot overflow.
*/
phdr_size = sizeof(struct elf_phdr) * ehdr->e_phnum;
elf_info->proghdrs = kzalloc(phdr_size, GFP_KERNEL);
if (!elf_info->proghdrs)
return -ENOMEM;
for (i = 0; i < ehdr->e_phnum; i++) {
int ret;
ret = elf_read_phdr(buf, len, elf_info, i);
if (ret) {
kfree(elf_info->proghdrs);
elf_info->proghdrs = NULL;
return ret;
}
}
return 0;
}
static int load_core_header( const char *core_name )
{
int fd;
int result;
result = FALSE;
if( core_info.e_hdr == NULL ) {
core_info.e_hdr = malloc( sizeof( *core_info.e_hdr ) );
if( core_info.e_hdr == NULL )
return( result );
}
fd = open( core_name, O_RDONLY );
if( fd < 0 )
return( result );
core_info.fd = fd;
if( !elf_read_hdr( fd, core_info.e_hdr ) ) {
close( fd );
} else {
if( elf_read_phdr( fd, core_info.e_hdr, &core_info.e_phdr ) ) {
result = TRUE;
}
}
return( result );
}
static void parse_elf(void)
{
u32 i;
arch64 = elf_read_hdr(elf, &ehdr);
for (i = 0; i < ehdr.e_phnum; i++)
elf_read_phdr(arch64, elf + ehdr.e_phoff + i * ehdr.e_phentsize, &phdr[i]);
}
static int load_elf_header( const char *core_name, Elf32_Ehdr *ehdr, Elf32_Phdr **pphdr )
{
int fd;
fd = open( core_name, O_RDONLY | O_BINARY );
if( fd < 0 ) {
return( NO_FILE );
}
if( !elf_read_hdr( fd, ehdr ) ) {
close( fd );
fd = NO_FILE;
} else {
if( !elf_read_phdr( fd, ehdr, pphdr ) ) {
close( fd );
fd = NO_FILE;
}
}
return( fd );
}
