int nlist(const char *filename, struct nlist *nl) { int result = -1; unsigned oldver; Elf *elf; int fd; if ((oldver = elf_version(EV_CURRENT)) != EV_NONE) { if ((fd = open(filename, O_RDONLY)) != -1) { if ((elf = elf_begin(fd, ELF_C_READ, NULL))) { result = _elf_nlist(elf, nl); elf_end(elf); } close(fd); } elf_version(oldver); } if (result) { while (nl->n_name && *nl->n_name) { nl->n_value = 0; nl++; } } return result; }
int pkg_analyse_files(struct pkgdb *db, struct pkg *pkg) { struct pkg_file *file = NULL; int ret = EPKG_OK; const char *fpath; bool shlibs = false; bool autodeps = false; bool developer = false; int (*action)(void *, struct pkg *, const char *, const char *, bool); pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs); pkg_config_bool(PKG_CONFIG_AUTODEPS, &autodeps); pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer); if (!autodeps && !shlibs && !developer) return (EPKG_OK); if (elf_version(EV_CURRENT) == EV_NONE) return (EPKG_FATAL); if (autodeps) action = test_depends; else if (shlibs) action = add_shlibs_to_pkg; else action = do_nothing; if (autodeps || shlibs) { shlib_list_init(); ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS); if (ret != EPKG_OK) goto cleanup; } /* Assume no architecture dependence, for contradiction */ if (developer) pkg->flags &= ~(PKG_CONTAINS_ELF_OBJECTS | PKG_CONTAINS_STATIC_LIBS | PKG_CONTAINS_H_OR_LA); while (pkg_files(pkg, &file) == EPKG_OK) { fpath = pkg_file_path(file); ret = analyse_elf(pkg, fpath, action, db); if (developer) { if (ret != EPKG_OK && ret != EPKG_END) goto cleanup; analyse_fpath(pkg, fpath); } } ret = EPKG_OK; cleanup: if (autodeps || shlibs) shlib_list_free(); return (ret); }
static Elf * get_elf (const gchar *file, gint *fd) { Elf *elf; if (elf_version (EV_CURRENT) == EV_NONE ) return NULL; *fd = g_open (file, O_RDONLY, 0); if (*fd < 0) return NULL; elf = elf_begin (*fd, ELF_C_READ, NULL); if (elf == NULL) { g_close (*fd, NULL); *fd = -1; return NULL; } if (elf_kind (elf) != ELF_K_ELF) { g_close (*fd, NULL); *fd = -1; return NULL; } return elf; }
void get_syms(char *filename, mod_info_t *mi) { int fd; Elf *elf; if ((fd = open(filename, O_RDONLY)) == -1) { perror(filename); exit(ERR_SYSCALL); } if (elf_version(EV_CURRENT) == EV_NONE) { (void) fprintf(stderr, "%s: libelf out of date\n", cmdname); exit(ERR_ELF); } if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { (void) fprintf(stderr, "%s: elf_begin failed\n", cmdname); exit(ERR_ELF); } if (gelf_getclass(elf) != ELFCLASS64) { (void) fprintf(stderr, "%s: unsupported mon.out format for " "this class of object\n", cmdname); exit(ERR_ELF); } mi->txt_origin = get_txtorigin(elf, filename); fetch_symtab(elf, filename, mi); }
/* * get_elf_class - get the target executable elf class * i.e. ELFCLASS64 or ELFCLASS32. */ static int get_elf_class(char *filename) { int elfclass = -1; int elffd = get_executable(filename); Elf *elf; size_t size; char *ident; GElf_Ehdr ehdr; if (elffd < 0) return (elfclass); if (elf_version(EV_CURRENT) == EV_NONE) { (void) close(elffd); return (elfclass); } elf = elf_begin(elffd, ELF_C_READ, (Elf *) 0); /* * verify information in file header */ if (gelf_getehdr(elf, &ehdr) == (GElf_Ehdr *) 0) { close(elffd); return (elfclass); } ident = elf_getident(elf, &size); if (ident[EI_CLASS] == ELFCLASS32) elfclass = ELFCLASS32; if (ident[EI_CLASS] == ELFCLASS64) elfclass = ELFCLASS64; close(elffd); return (elfclass); }
/* Below code adapted from libelf tutorial example */ static u32 extract_functions_internal (const char *str, func_entry *func_list) { Elf *e; Elf_Kind ek; Elf_Scn *scn; Elf_Data *edata; u32 fd, i, symbol_count; GElf_Sym sym; GElf_Shdr shdr; u32 func_count = 0; if(elf_version(EV_CURRENT) == EV_NONE) { printf("Error initializing ELF: %s\n", elf_errmsg(-1)); return -1; } if ((fd = open(str, O_RDONLY, 0)) < 0) { printf("Unable to open %s\n", str); return -1; } if ((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL) { printf("elf_begin failed: %s\n", elf_errmsg(-1)); } ek = elf_kind(e); if(ek != ELF_K_ELF) { printf("not an ELF object"); } else { scn = NULL; edata = NULL; while((scn = elf_nextscn(e, scn)) != NULL) { gelf_getshdr(scn, &shdr); if(shdr.sh_type == SHT_SYMTAB) { edata = elf_getdata(scn, edata); symbol_count = shdr.sh_size / shdr.sh_entsize; for(i = 0; i < symbol_count; i++) { gelf_getsym(edata, i, &sym); if(ELF32_ST_TYPE(sym.st_info) != STT_FUNC) { check_for_end_marker(elf_strptr(e, shdr.sh_link, sym.st_name), sym.st_value); continue; } if(sym.st_size == 0) continue; func_list[func_count].offset = sym.st_value; func_list[func_count++].func_name = strdup(elf_strptr(e, shdr.sh_link, sym.st_name)); if(func_count >= MAXFNS) { printf("Func limit (%"PRId32") reached, please increase MAXFNS & rebuild\n", MAXFNS); raise(SIGABRT); } // printf("%08x %08x\t%s\n", sym.st_value, sym.st_size, elf_strptr(e, shdr.sh_link, sym.st_name)); } } } } elf_end(e); close(fd); return func_count; }
int pkg_register_shlibs(struct pkg *pkg) { struct pkg_file *file = NULL; bool shlibs; pkg_config_bool(PKG_CONFIG_SHLIBS, &shlibs); pkg_list_free(pkg, PKG_SHLIBS_REQUIRED); if (!shlibs) return (EPKG_OK); if (elf_version(EV_CURRENT) == EV_NONE) return (EPKG_FATAL); shlib_list_init(); if (shlib_list_from_elf_hints(_PATH_ELF_HINTS) != EPKG_OK) { shlib_list_free(); return (EPKG_FATAL); } while(pkg_files(pkg, &file) == EPKG_OK) analyse_elf(pkg, pkg_file_path(file), add_shlibs_to_pkg, NULL); shlib_list_free(); return (EPKG_OK); }
int exec_open( NAME_LIST *fnames, Elf32_Half machine, int code_size, int data_size ) { if (!fnames) { yyerror("No output file specified"); } else if (fnames->next) { yyerror("Multiple output files specified"); } else if (elf_version(EV_CURRENT) == EV_NONE) { yyerror( "Elf library is out of date" ); } else { outfile_init( fnames->name, machine, TRUE, code_size, data_size ); out_file_machine = machine; out_file_name = strdup( fnames->name ); if ( !fixup_code_map( machine, &fixup_code ) ) { yyerror( "Relocations for this machine type are not supported" ); return FALSE; } return TRUE; } return FALSE; }
bool ElfWriter::initElfHeader() { if (elf_version(EV_CURRENT) == EV_NONE) { logError("ELF library initialization failed"); return false; } m_elf = elf_begin(m_fd, ELF_C_WRITE, 0); if (!m_elf) { logError("Unable to create elf with elf_begin()"); return false; } m_ehdr = elf64_newehdr(m_elf); if (!m_ehdr) { logError("Unable to create elf header with elf64_newehdr()"); return false; } m_ehdr->e_ident[EI_MAG0] = ELFMAG0; m_ehdr->e_ident[EI_MAG1] = ELFMAG1; m_ehdr->e_ident[EI_MAG2] = ELFMAG2; m_ehdr->e_ident[EI_MAG3] = ELFMAG3; m_ehdr->e_ident[EI_CLASS] = ELFCLASS64; m_ehdr->e_ident[EI_DATA] = ELFDATA2LSB; m_ehdr->e_ident[EI_VERSION] = EV_CURRENT; m_ehdr->e_machine = EM_X86_64; m_ehdr->e_type = ET_EXEC; m_ehdr->e_version = EV_CURRENT; return true; }
static struct bpf_object * __bpf_object__open(const char *path, void *obj_buf, size_t obj_buf_sz) { struct bpf_object *obj; int err; if (elf_version(EV_CURRENT) == EV_NONE) { pr_warning("failed to init libelf for %s\n", path); return ERR_PTR(-LIBBPF_ERRNO__LIBELF); } obj = bpf_object__new(path, obj_buf, obj_buf_sz); if (IS_ERR(obj)) return obj; CHECK_ERR(bpf_object__elf_init(obj), err, out); CHECK_ERR(bpf_object__check_endianness(obj), err, out); CHECK_ERR(bpf_object__elf_collect(obj), err, out); CHECK_ERR(bpf_object__collect_reloc(obj), err, out); CHECK_ERR(bpf_object__validate(obj), err, out); bpf_object__elf_finish(obj); return obj; out: bpf_object__close(obj); return ERR_PTR(err); }
static int perf_session__list_build_ids(void) { struct perf_session *session; elf_version(EV_CURRENT); session = perf_session__new(input_name, O_RDONLY, force, false, &build_id__mark_dso_hit_ops); if (session == NULL) return -1; /* * See if this is an ELF file first: */ if (filename__fprintf_build_id(session->filename, stdout)) goto out; if (with_hits) perf_session__process_events(session, &build_id__mark_dso_hit_ops); perf_session__fprintf_dsos_buildid(session, stdout, with_hits); out: perf_session__delete(session); return 0; }
std::string get_embedded_repo() { GElf_Shdr shdr; size_t shstrndx; char *name; Elf_Scn *scn; if (elf_version(EV_CURRENT) == EV_NONE) return ""; int fd = open("/proc/self/exe", O_RDONLY, 0); if (fd < 0) return ""; Elf* e = elf_begin(fd, ELF_C_READ, nullptr); if (!e || elf_kind(e) != ELF_K_ELF || !elf_getshstrndx(e, &shstrndx)) { return ""; } scn = nullptr; while ((scn = elf_nextscn(e, scn)) != nullptr) { if (gelf_getshdr(scn, &shdr) != &shdr || !(name = elf_strptr(e, shstrndx , shdr.sh_name))) { return ""; } if (!strcmp("repo", name)) { GElf_Shdr ghdr; if (gelf_getshdr(scn, &ghdr) != &ghdr) return ""; char buf[512]; sprintf(buf, "/proc/self/exe:%lu:%lu", ghdr.sh_offset, ghdr.sh_size); sqlite3_embedded_initialize(nullptr, true); return buf; } } return ""; }
int binary_diff(int fd1, int fd2, char *sections, int verbose) { Elf *elf1, *elf2; Elf_Kind kind1, kind2; if (elf_version(EV_CURRENT) == EV_NONE) { if (verbose) fprintf(stderr, "elfdiff: ELF Version mismatch\n"); return ED_ELFFAIL; } if ((elf1 = elf_begin(fd1, ELF_C_READ, NULL)) != NULL) { kind1 = elf_kind(elf1); elf_end(elf1); } else { if (verbose) fprintf(stderr, "elfdiff: Error reading ELF information from first input file.\n"); return ED_NOELF1; } if ((elf2 = elf_begin(fd2, ELF_C_READ, NULL)) != NULL) { kind2 = elf_kind(elf2); elf_end(elf2); } else { if (verbose) fprintf(stderr, "elfdiff: Error reading ELF information from second input file.\n"); return ED_NOELF2; } if ((kind1 == ELF_K_ELF) && (kind2 == ELF_K_ELF)){ return elf_diff (fd1, fd2, sections, verbose); } else if ((kind1 == ELF_K_AR) && (kind2 == ELF_K_AR)) { return ar_diff (fd1, fd2, sections, verbose); } else { if (verbose) fprintf(stderr, "elfdiff: The specified files are not of matching/supported types.\n"); return ED_ELFFAIL; } }
int xlate_named_init_fd(int fd, const char *section_name, xlate_table_con * ret_tab_ptr) { Elf *elf; xlate_table_con ltab = 0; int retstatus = XLATE_TB_STATUS_NO_ERROR; if(elf_version(EV_CURRENT) == EV_NONE) { return XLATE_TB_STATUS_ELF_VERSION_BAD; } #ifdef HAVE_ELF_C_READ_MMAP elf = elf_begin(fd,ELF_C_READ_MMAP,NULL); #else elf = elf_begin(fd,ELF_C_READ,NULL); #endif if(elf == NULL) { return XLATE_TB_STATUS_ELF_BEGIN_BAD; } retstatus = xlate_named_init_elf(elf,section_name,<ab); if(retstatus != XLATE_TB_STATUS_NO_ERROR) { (void)elf_end(elf); } else { ltab->xc_did_elf_begin = 1; *ret_tab_ptr = ltab; } return retstatus; }
int ELF_initial(char *input_file){ if(elf_version(EV_CURRENT) == EV_NONE){ fprintf(stderr, "ELF library initialization failed: %s.\n", elf_errmsg(-1)); exit(1); } if((fd = open(input_file, O_RDONLY, 0)) < 0){ fprintf(stderr, "Open \"%s\" failed.\n", input_file); exit(1); } if((e = elf_begin(fd, ELF_C_READ, NULL)) == NULL){ fprintf(stderr, "elf_begin() failed: %s.\n", elf_errmsg(-1)); exit(1); } if(elf_kind(e) != ELF_K_ELF){ fprintf(stderr, "\"%s\" is not an ELF object.\n", input_file); exit(1); } if(gelf_getehdr(e, &ehdr) == NULL){ fprintf(stderr, "getehdr() failed: %s.\n", elf_errmsg(-1)); exit(1); } if(ehdr.e_flags != 2){ fprintf(stderr, "\"%s\" is not an execution file.\n", input_file); exit(1); } phdr_index = 0; // printf("Entry point: 0x%jx\n", ehdr.e_entry); // printf("Flags: %d\n", ehdr.e_flags); return 0; }
int find_symbol(char *fn, struct lsym *lsym, unsigned long baseaddr) { struct lsym *ls; int num = 0; for (ls = lsym; ls->name; ls++) num++; elf_version(EV_CURRENT); int fd = open(fn, O_RDONLY); if (fd < 0) return -1; long ret = -1; Elf *elf = elf_begin(fd, ELF_C_READ, NULL); if (elf == NULL) goto out; GElf_Ehdr header; if (!gelf_getehdr(elf, &header)) goto out_elf; Elf_Scn *section = NULL; int found = 0; while (found < num && (section = elf_nextscn(elf, section)) != 0) { GElf_Shdr shdr, *sh; sh = gelf_getshdr(section, &shdr); if (sh->sh_type == SHT_SYMTAB || sh->sh_type == SHT_DYNSYM) { Elf_Data *data = elf_getdata(section, NULL); GElf_Sym *sym, symbol; int j; unsigned numsym = sh->sh_size / sh->sh_entsize; for (j = 0; j < numsym; j++) { sym = gelf_getsymshndx(data, NULL, j, &symbol, NULL); char *symname = elf_strptr(elf, shdr.sh_link, sym->st_name); for (ls = lsym; ls->name; ls++) { if (!strcmp(symname, ls->name)) { Elf_Scn *oscn = elf_getscn(elf, sym->st_shndx); GElf_Shdr oshdr, *osh; osh = gelf_getshdr(oscn, &oshdr); ls->addr = (sym->st_value - osh->sh_addr) + osh->sh_offset + baseaddr; found++; if (found == num) break; } } } } } if (found == num) ret = 0; out_elf: elf_end(elf); out: close(fd); return ret; }
int main(int argc, char **argv) { Elf *elf; ctf_file_t *ctfp; int errp, fd; if (ctf_version(CTF_VERSION) == -1) errx(1, "mismatched libctf versions\n"); if (elf_version(EV_CURRENT) == EV_NONE) errx(1, "mismatched libelf versions\n"); if (argc != 2) errx(2, "usage: %s <file>\n", __progname); if ((ctfp = ctf_open(argv[1], &errp)) == NULL) errx(1, "failed to ctf_open file: %s: %s\n", argv[1], ctf_errmsg(errp)); if ((fd = open(argv[1], O_RDONLY)) == -1) errx(1, "could not open %s\n", argv[1]); if ((elf = elf_begin(fd, ELF_C_READ, NULL)) == NULL) errx(1, "could not interpret ELF from %s\n", argv[1]); walk_symtab(elf, argv[1], ctfp, check_sym); (void) elf_end(elf); (void) close(fd); return (0); }
static elf_info_s *elf_symbols(int fd) { /* Open Elf */ elf_version(EV_CURRENT); elf_info_s *elf = calloc(1, sizeof (elf_info_s)); elf->elf = elf_begin(fd, ELF_C_READ, NULL); gelf_getehdr(elf->elf, &elf->hdr); /* Iterate through the sections */ Elf_Scn *scn = NULL; while ((scn = elf_nextscn(elf->elf, scn)) != 0) { GElf_Shdr shdr; const char *name; /* get section header */ gelf_getshdr(scn, &shdr); /* get section name */ name = elf_strptr(elf->elf, elf->hdr.e_shstrndx, shdr.sh_name); //LOG(INFO, "Iter on %s", name); if (shdr.sh_type == SHT_DYNSYM) handle_dynsym_section(elf, scn, shdr); else if (shdr.sh_type == SHT_DYNAMIC) handle_dynamic_section(elf, scn, shdr); else if ((shdr.sh_type == SHT_PROGBITS || shdr.sh_type == SHT_NOBITS) && !strcmp(name, ".plt")) handle_plt_section(elf, shdr); else if (!strcmp(name, ".got.plt")) handle_gotplt_section(elf, shdr); } return elf; }
int pkg_register_shlibs(struct pkg *pkg, const char *root) { struct pkg_file *file = NULL; char fpath[MAXPATHLEN]; pkg_list_free(pkg, PKG_SHLIBS_REQUIRED); if (elf_version(EV_CURRENT) == EV_NONE) return (EPKG_FATAL); shlib_list_init(); if (shlib_list_from_elf_hints(_PATH_ELF_HINTS) != EPKG_OK) { shlib_list_free(); return (EPKG_FATAL); } while(pkg_files(pkg, &file) == EPKG_OK) { if (root != NULL) { snprintf(fpath, sizeof(fpath), "%s%s", root, pkg_file_path(file)); analyse_elf(pkg, fpath, add_shlibs_to_pkg, NULL); } else analyse_elf(pkg, pkg_file_path(file), add_shlibs_to_pkg, NULL); } shlib_list_free(); return (EPKG_OK); }
void xelf_init(void) { if (elf_version(EV_CURRENT) == EV_NONE) { eprintf("ELF library initialization failed: %s", elf_errmsg(-1)); exit(EXIT_FAILURE); } }
static void check_libelf_version() { if (elf_version(EV_CURRENT) == EV_NONE) { fprintf(stderr, "elf initialization failed: %s\n", elf_errmsg(elf_errno())); exit(1); } }
gboolean is_elf_file (const char *path, gboolean *is_shared, gboolean *is_stripped) { g_autofree char *filename = g_path_get_basename (path); struct stat stbuf; if (lstat (path, &stbuf) == -1) return FALSE; if (!S_ISREG (stbuf.st_mode)) return FALSE; /* Self-extracting .zip files can be ELF-executables, but shouldn't be treated like them - for example, stripping them breaks their operation */ if (g_str_has_suffix (filename, ".zip")) return FALSE; if ((strstr (filename, ".so.") != NULL || g_str_has_suffix (filename, ".so")) || (stbuf.st_mode & 0111) != 0) { glnx_fd_close int fd = -1; fd = open (path, O_RDONLY | O_NOFOLLOW | O_CLOEXEC); if (fd >= 0) { Elf *elf; GElf_Ehdr ehdr; gboolean res = FALSE; if (elf_version (EV_CURRENT) == EV_NONE ) return FALSE; elf = elf_begin (fd, ELF_C_READ, NULL); if (elf == NULL) return FALSE; if (elf_kind (elf) == ELF_K_ELF && gelf_getehdr (elf, &ehdr)) { if (is_shared) *is_shared = ehdr.e_type == ET_DYN; if (is_stripped) *is_stripped = !elf_has_symtab (elf); res = TRUE; } elf_end (elf); return res; } } return FALSE; }
Dwarf * dwarf_begin (int fd, Dwarf_Cmd cmd) { Elf *elf; Elf_Cmd elfcmd; Dwarf *result = NULL; switch (cmd) { case DWARF_C_READ: elfcmd = ELF_C_READ_MMAP; break; case DWARF_C_WRITE: elfcmd = ELF_C_WRITE; break; case DWARF_C_RDWR: elfcmd = ELF_C_RDWR; break; default: /* No valid mode. */ __libdw_seterrno (DWARF_E_INVALID_CMD); return NULL; } /* We have to call `elf_version' here since the user might have not done it or initialized libelf with a different version. This would break libdwarf since we are using the ELF data structures in a certain way. */ elf_version (EV_CURRENT); /* Get an ELF descriptor. */ elf = elf_begin (fd, elfcmd, NULL); if (elf == NULL) { /* Test why the `elf_begin" call failed. */ struct stat64 st; if (fstat64 (fd, &st) == 0 && ! S_ISREG (st.st_mode)) __libdw_seterrno (DWARF_E_NO_REGFILE); else if (errno == EBADF) __libdw_seterrno (DWARF_E_INVALID_FILE); else __libdw_seterrno (DWARF_E_IO_ERROR); } else { /* Do the real work now that we have an ELF descriptor. */ result = INTUSE(dwarf_begin_elf) (elf, cmd, NULL); /* If this failed, free the resources. */ if (result == NULL) elf_end (elf); else result->free_elf = true; } return result; }
void elfts_init_version(void) { if (elf_version(EV_CURRENT) != EV_CURRENT) { tet_printf("setup: elf_version() failed: %s", elf_errmsg(-1)); elfts_tcinit = TET_UNRESOLVED; } }
int main( int argc, char ** argv ) { int status = 0; int fid = -1; Elf * elfp = NULL; Dwarf_Error error = (Dwarf_Error) NULL; Dwarf_Debug dbg; Dwarf_Cie * cie_data = NULL; Dwarf_Fde * fde_data = NULL; Dwarf_Signed cie_count, fde_count; if( argc != 2 ) { fprintf( stderr, "usage: %s <binary>\n", argv[0] ); return 1; } fid = open( argv[1], O_RDONLY ); if( fid == -1 ) { fprintf( stderr, "failed to open( %s ).\n", argv[1] ); return 4; } if( elf_version( EV_CURRENT ) == EV_NONE ) { fprintf( stderr, "elf version check failed.\n" ); return 6; } #if defined( USE_ELF_POINTER ) elfp = elf_begin( fid, ELF_C_READ, (Elf *)NULL ); if( elfp == NULL ) { fprintf( stderr, "failed to elf_begin().\n" ); return 5; } status = dwarf_elf_init( elfp, DW_DLC_READ, NULL, NULL, & dbg, & error ); if( status != DW_DLV_OK ) { fprintf( stderr, "failed to dwarf_elf_init().\n" ); return 2; } #else status = dwarf_init( fid, DW_DLC_READ, NULL, NULL, & dbg, NULL ); if( status != DW_DLV_OK ) { fprintf( stderr, "failed to dwarf_init().\n" ); return 2; } #endif status = dwarf_get_fde_list_eh( dbg, & cie_data, & cie_count, & fde_data, & fde_count, & error ); if( status != DW_DLV_OK ) { fprintf( stderr, "failed to dwarf_get_fde_list_eh().\n" ); return 3; } return 0; } /* end main() */
static void set_flag(char *ifile, ulong_t flval) { Elf *elf; Elf_Scn *scn; Elf_Data *data; GElf_Shdr shdr; GElf_Dyn dyn; int fd, secidx, nent, i; (void) elf_version(EV_CURRENT); if ((fd = open(ifile, O_RDWR)) < 0) die("Can't open %s", ifile); if ((elf = elf_begin(fd, ELF_C_RDWR, NULL)) == NULL) elfdie("Can't start ELF for %s", ifile); if ((secidx = findelfsecidx(elf, ".dynamic")) == -1) die("Can't find .dynamic section in %s\n", ifile); if ((scn = elf_getscn(elf, secidx)) == NULL) elfdie("elf_getscn (%d)", secidx); if (gelf_getshdr(scn, &shdr) == NULL) elfdie("gelf_shdr"); if ((data = elf_getdata(scn, NULL)) == NULL) elfdie("elf_getdata"); nent = shdr.sh_size / shdr.sh_entsize; for (i = 0; i < nent; i++) { if (gelf_getdyn(data, i, &dyn) == NULL) elfdie("gelf_getdyn"); if (dyn.d_tag == DT_FLAGS_1) { dyn.d_un.d_val |= (Elf64_Xword)flval; if (gelf_update_dyn(data, i, &dyn) == 0) elfdie("gelf_update_dyn"); break; } } if (i == nent) { die("%s's .dynamic section doesn't have a DT_FLAGS_1 " "field\n", ifile); } if (elf_update(elf, ELF_C_WRITE) == -1) elfdie("Couldn't update %s with changes", ifile); (void) elf_end(elf); (void) close(fd); }
ElfData::ElfData() { assert(elf_version(EV_CURRENT) != EV_NONE); assert((fd = open(__progname_full, O_RDONLY, 0)) >= 0); assert((e = elf_begin(fd, ELF_C_READ, NULL)) != NULL); assert(elf_kind(e) == ELF_K_ELF); }
void radeon_elf_read(const char *elf_data, unsigned elf_size, struct radeon_shader_binary *binary, unsigned debug) { char *elf_buffer; Elf *elf; Elf_Scn *section = NULL; size_t section_str_index; /* One of the libelf implementations * (http://www.mr511.de/software/english.htm) requires calling * elf_version() before elf_memory(). */ elf_version(EV_CURRENT); elf_buffer = MALLOC(elf_size); memcpy(elf_buffer, elf_data, elf_size); elf = elf_memory(elf_buffer, elf_size); elf_getshdrstrndx(elf, §ion_str_index); binary->disassembled = 0; while ((section = elf_nextscn(elf, section))) { const char *name; Elf_Data *section_data = NULL; GElf_Shdr section_header; if (gelf_getshdr(section, §ion_header) != §ion_header) { fprintf(stderr, "Failed to read ELF section header\n"); return; } name = elf_strptr(elf, section_str_index, section_header.sh_name); if (!strcmp(name, ".text")) { section_data = elf_getdata(section, section_data); binary->code_size = section_data->d_size; binary->code = MALLOC(binary->code_size * sizeof(unsigned char)); memcpy(binary->code, section_data->d_buf, binary->code_size); } else if (!strcmp(name, ".AMDGPU.config")) { section_data = elf_getdata(section, section_data); binary->config_size = section_data->d_size; binary->config = MALLOC(binary->config_size * sizeof(unsigned char)); memcpy(binary->config, section_data->d_buf, binary->config_size); } else if (debug && !strcmp(name, ".AMDGPU.disasm")) { binary->disassembled = 1; section_data = elf_getdata(section, section_data); fprintf(stderr, "\nShader Disassembly:\n\n"); fprintf(stderr, "%.*s\n", (int)section_data->d_size, (char *)section_data->d_buf); } } if (elf){ elf_end(elf); } FREE(elf_buffer); }
/** * perform checks on the initial ELF binary and create an ELF descriptor * to perform direct manipulations within the file. */ int ElfInject::prepareElfBin() { info("prepare ELF binary: %s", bin.name.c_str()); /* open binary file */ bin.fd = open(bin.name.c_str(), O_RDWR, S_IRWXU); if (bin.fd < 0) { error("cannot open %s", bin.name.c_str()); return -1; } /* fstat binary */ if (fstat(bin.fd, &bin.stats)) { error("cannot fstat %s", bin.name.c_str()); return -1; } /* initialize ELF library */ if(elf_version(EV_CURRENT) == EV_NONE ) { error("ELF library initialization failed"); return -1; } /* create elf descriptor */ if ((bin.elf = elf_begin(bin.fd, ELF_C_RDWR_MMAP, NULL)) == NULL) { error("cannot initialize elf"); return -1; } /* check, whether the file is an ELF-file */ if (elf_kind(bin.elf) != ELF_K_ELF) { error("%s is not an ELF file", bin.name.c_str()); return -1; } debug("° correct ELF type"); if (gelf_getclass(bin.elf) != ELFCLASS32) { error("%s is not a 32-bit binary", bin.name.c_str()); return -1; } debug("° compiled for 32-bit systems"); /* allocate space for binary */ // if ((bin.basePtr = (char*)malloc(bin.stats.st_size)) == NULL) { // error("cannot allocate enough memory" << lend ; // } /* create elf descriptor for mem region */ // if ((bin.elfMem = elf_memory(bin.basePtr, bin.stats.st_size)) == NULL) {; // error("cannot initialize elfMem"); // } return 0; }
int pkg_analyse_files(struct pkgdb *db, struct pkg *pkg, const char *stage) { struct pkg_file *file = NULL; int ret = EPKG_OK; char fpath[MAXPATHLEN]; bool autodeps = false; bool developer = false; int (*action)(void *, struct pkg *, const char *, const char *, bool); pkg_config_bool(PKG_CONFIG_AUTODEPS, &autodeps); pkg_config_bool(PKG_CONFIG_DEVELOPER_MODE, &developer); if (elf_version(EV_CURRENT) == EV_NONE) return (EPKG_FATAL); if (autodeps) action = test_depends; else action = add_shlibs_to_pkg; shlib_list_init(); ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS); if (ret != EPKG_OK) goto cleanup; /* Assume no architecture dependence, for contradiction */ if (developer) pkg->flags &= ~(PKG_CONTAINS_ELF_OBJECTS | PKG_CONTAINS_STATIC_LIBS | PKG_CONTAINS_H_OR_LA); while (pkg_files(pkg, &file) == EPKG_OK) { if (stage != NULL) snprintf(fpath, sizeof(fpath), "%s/%s", stage, pkg_file_path(file)); else strlcpy(fpath, pkg_file_path(file), sizeof(fpath)); ret = analyse_elf(pkg, fpath, action, db); if (developer) { if (ret != EPKG_OK && ret != EPKG_END) goto cleanup; analyse_fpath(pkg, fpath); } } ret = EPKG_OK; cleanup: shlib_list_free(); return (ret); }