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 ); }