static void *load_bytes(RBinFile *bf, const ut8 *buf, ut64 sz, ut64 loadaddr, Sdb *sdb) { RBinNROObj *bin = R_NEW0 (RBinNROObj); if (!bin) { return NULL; } ut64 ba = baddr (bf); bin->methods_list = r_list_newf ((RListFree)free); bin->imports_list = r_list_newf ((RListFree)free); bin->classes_list = r_list_newf ((RListFree)free); ut32 mod0 = readLE32 (bf->buf, NRO_OFFSET_MODMEMOFF); parseMod (bf, bin, mod0, ba); return (void *) bin;//(size_t) check_bytes (buf, sz); }
static bool load_bytes(RBinFile *bf, void **bin_obj, const ut8 *buf, ut64 sz, ut64 loadaddr, Sdb *sdb) { RBinNXOObj *bin = R_NEW0 (RBinNXOObj); if (!bin) { return false; } ut64 ba = baddr (bf); bin->methods_list = r_list_newf ((RListFree)free); bin->imports_list = r_list_newf ((RListFree)free); bin->classes_list = r_list_newf ((RListFree)free); ut32 mod0 = readLE32 (bf->buf, NRO_OFFSET_MODMEMOFF); parseMod (bf->buf, bin, mod0, ba); *bin_obj = bin; return true; }
static RList *r_debug_windbg_pids(RDebug *dbg, int pid) { RListIter *it; WindProc *p; RList *ret = r_list_newf (free); if (!ret) { return NULL; } RList *pids = windbg_list_process(wctx); if (!pids) { return ret; } r_list_foreach (pids, it, p) { RDebugPid *newpid = R_NEW0 (RDebugPid); if (!newpid) { r_list_free (ret); return NULL; } newpid->path = strdup (p->name); newpid->pid = p->uniqueid; newpid->status = 's'; newpid->runnable = true; r_list_append (ret, newpid); }
static RList * relocs(RBinFile *bf) { RList *ret = NULL; RBinReloc *rel = NULL; const struct r_bin_mz_reloc_t *relocs = NULL; int i; if (!bf || !bf->o || !bf->o->bin_obj) { return NULL; } if (!(ret = r_list_newf (free))) { return NULL; } if (!(relocs = r_bin_mz_get_relocs (bf->o->bin_obj))) { return ret; } for (i = 0; !relocs[i].last; i++) { if (!(rel = R_NEW0 (RBinReloc))) { free ((void *)relocs); r_list_free (ret); return NULL; } rel->type = R_BIN_RELOC_16; rel->vaddr = relocs[i].paddr; rel->paddr = relocs[i].paddr; r_list_append (ret, rel); } free ((void *)relocs); return ret; }
static RList *sections(RBinFile *arch) { RBinWasmObj *bin = arch && arch->o ? arch->o->bin_obj : NULL; RList *ret = NULL; RList *secs = NULL; RBinSection *ptr = NULL; RBinWasmSection *sec; if (!(ret = r_list_newf ((RListFree)free))) { return NULL; } if (!(secs = r_bin_wasm_get_sections (bin))) { r_list_free (ret); return NULL; } RListIter *iter; r_list_foreach (secs, iter, sec) { if (!(ptr = R_NEW0 (RBinSection))) { break; } strncpy (ptr->name, (char*)sec->name, R_BIN_SIZEOF_STRINGS); if (sec->id == R_BIN_WASM_SECTION_DATA || sec->id == R_BIN_WASM_SECTION_MEMORY) { ptr->is_data = true; } ptr->size = sec->payload_len; ptr->vsize = sec->payload_len; ptr->vaddr = sec->offset; ptr->paddr = sec->offset; ptr->add = true; // TODO permissions ptr->srwx = 0; r_list_append (ret, ptr); } return ret; }
static RList *parseSegments(RBuffer *buf, int off, int count) { ut8 *b = calloc (count, 32); (void)r_buf_read_at (buf, off, b, count * 32); int x = off; int X = 0; int i; RList *segments = r_list_newf ((RListFree)r_bin_section_free); if (!segments) { return NULL; } // eprintf ("Segments: %d\n", count); for (i = 0; i < count; i++) { int A = r_read_le32 (b + X + 16); int B = r_read_le32 (b + X + 16 + 8); // eprintf ("0x%08x segment 0x%08x 0x%08x %s\n", // x, A, A + B, b + X); const char *cname = (const char *)(b + X); char *name = r_str_ndup (cname, r_str_nlen (cname, 16)); RBinSection *section = newSection (name, A, A + B, true); free (name); r_list_append (segments, section); x += 32; X += 32; } return segments; }
static bool spaces_unset_single(RSpaces *sp, const char *name) { RSpace *space = r_spaces_get (sp, name); if (!space) { return false; } RSpaceEvent ev = { .data.unset.space = space }; r_event_send (sp->event, R_SPACE_EVENT_UNSET, &ev); return r_rbtree_delete (&sp->spaces, (void *)name, name_space_cmp, space_node_free); } R_API bool r_spaces_unset(RSpaces *sp, const char *name) { if (name) { return spaces_unset_single (sp, name); } RList *names = r_list_newf ((RListFree)free); if (!names) { return false; } RBIter it; RSpace *s; r_spaces_foreach (sp, it, s) { r_list_append (names, strdup (s->name)); } RListIter *lit; const char *n; bool res = false; r_list_foreach (names, lit, n) { res |= spaces_unset_single (sp, n); }
static RList * build_str_list_from_iterable (RList *the_list) { RList * res = r_list_newf (free); DsoJsonObj *json_obj; RListIter *iter; r_list_foreach (the_list, iter, json_obj) { char *str = dso_json_obj_to_str (json_obj); r_list_append (res, str); }
R_API RBuffer *r_buf_new_sparse() { RBuffer *b = r_buf_new (); if (!b) { return NULL; } b->sparse = r_list_newf ((RListFree)free); return b; }
static RList *r_debug_native_modules_get (RDebug *dbg) { char *lastname = NULL; RDebugMap *map; RListIter *iter, *iter2; RList *list, *last; int must_delete; #if __APPLE__ list = xnu_dbg_maps (dbg, 1); if (list && !r_list_empty (list)) { return list; } #endif #if __WINDOWS__ list = w32_dbg_modules (dbg); if (list && !r_list_empty (list)) { return list; } #endif list = r_debug_native_map_get (dbg); if (!list) { return NULL; } last = r_list_newf ((RListFree)r_debug_map_free); if (!last) { r_list_free (list); return NULL; } r_list_foreach_safe (list, iter, iter2, map) { const char *file = map->file; if (!map->file) { file = map->file = strdup (map->name); } must_delete = 1; if (file && *file) { if (file[0] == '/') { if (lastname) { if (strcmp (lastname, file)) { must_delete = 0; } } else { must_delete = 0; } } } if (must_delete) { r_list_delete (list, iter); } else { r_list_append (last, map); free (lastname); lastname = strdup (file); } } list->free = NULL; free (lastname); r_list_free (list); return last; }
static RList* entries(RBinFile *arch) { RBinAddr *ptr = NULL; RList* ret = r_list_newf (free); if (!ret) return NULL; if ((ptr = R_NEW0 (RBinAddr))) { r_list_append (ret, ptr); } return ret; }
R_API RList *r_syscall_list(RSyscall *s) { RList *list; if (!s || !s->db) { return NULL; } // show list of syscalls to stdout list = r_list_newf ((RListFree)r_syscall_item_free); sdb_foreach (s->db, callback_list, list); return list; }
static RList* sections(RBinFile *arch) { RList *ret = NULL; RBinSection *ptr = NULL; ut64 textsize, datasize, symssize, spszsize, pcszsize; ut64 entry0 = findEntry (arch->buf, 0); ut64 entry1 = findEntry (arch->buf, 1); ut64 entry2 = findEntry (arch->buf, 2); if (!(ret = r_list_newf (free))) { return NULL; } // add text segment textsize = r_mem_get_num (arch->buf->buf + 4, 4); if (!(ptr = R_NEW0 (RBinSection))) { return ret; } if (!entry1) { entry1 = arch->buf->length; } strncpy (ptr->name, "init", R_BIN_SIZEOF_STRINGS); ptr->size = entry1-entry0; ptr->vsize = entry1-entry0; ptr->paddr = entry0 + 4; ptr->vaddr = entry0; ptr->srwx = R_BIN_SCN_READABLE | R_BIN_SCN_EXECUTABLE | R_BIN_SCN_MAP; // r-x r_list_append (ret, ptr); if (entry1) { if (entry2) { if (!(ptr = R_NEW0 (RBinSection))) return ret; strncpy (ptr->name, "fini", R_BIN_SIZEOF_STRINGS); ptr->size = entry2-entry1; ptr->vsize = entry2-entry1; ptr->paddr = entry1 + 4; ptr->vaddr = entry1; ptr->srwx = R_BIN_SCN_READABLE | R_BIN_SCN_EXECUTABLE | R_BIN_SCN_MAP; // r-x r_list_append (ret, ptr); } else { entry2 = entry1; } } if (entry2) { if (!(ptr = R_NEW0 (RBinSection))) return ret; strncpy (ptr->name, "text", R_BIN_SIZEOF_STRINGS); ptr->size = arch->buf->length - entry2; ptr->vsize = arch->buf->length - entry2; ptr->paddr = entry2 + 4; ptr->vaddr = entry2; ptr->srwx = R_BIN_SCN_READABLE | R_BIN_SCN_EXECUTABLE | R_BIN_SCN_MAP; // r-x r_list_append (ret, ptr); } return ret; }
static RList *entries(RBinFile *arch) { struct r_bin_coff_obj *obj = (struct r_bin_coff_obj*)arch->o->bin_obj; RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_newf (free))) { return NULL; } ptr = r_coff_get_entry(obj); r_list_append(ret, ptr); return ret; }
static RList *sections(RBinFile *arch) { char *tmp, *coffname = NULL; size_t i; RList *ret = NULL; RBinSection *ptr = NULL; struct r_bin_coff_obj *obj = (struct r_bin_coff_obj*)arch->o->bin_obj; ret = r_list_newf (free); if (!ret) { return NULL; } if (obj && obj->scn_hdrs) { for (i = 0; i < obj->hdr.f_nscns; i++) { free (coffname); tmp = r_coff_symbol_name (obj, &obj->scn_hdrs[i]); if (!tmp) { r_list_free (ret); return NULL; } //IO does not like sections with the same name append idx //since it will update it coffname = r_str_newf ("%s-%d", tmp, i); free (tmp); ptr = R_NEW0 (RBinSection); if (!ptr) { free (coffname); return ret; } strncpy (ptr->name, coffname, R_BIN_SIZEOF_STRINGS); if (strstr (ptr->name, "data")) { ptr->is_data = true; } ptr->size = obj->scn_hdrs[i].s_size; ptr->vsize = obj->scn_hdrs[i].s_size; ptr->paddr = obj->scn_hdrs[i].s_scnptr; ptr->add = true; ptr->srwx = R_BIN_SCN_MAP; if (obj->scn_hdrs[i].s_flags & COFF_SCN_MEM_READ) { ptr->srwx |= R_BIN_SCN_READABLE; } if (obj->scn_hdrs[i].s_flags & COFF_SCN_MEM_WRITE) { ptr->srwx |= R_BIN_SCN_WRITABLE; } if (obj->scn_hdrs[i].s_flags & COFF_SCN_MEM_EXECUTE) { ptr->srwx |= R_BIN_SCN_EXECUTABLE; } r_list_append (ret, ptr); } } free (coffname); return ret; }
static RList *parseStrings(RBuffer *buf, int string_section, int string_section_end) { int sss = string_section_end + string_section; if (sss < 1) { return NULL; } char *b = calloc (1, sss); if (!b) { return NULL; } int o = 0; char *s = b; char *os = s; int nstrings = 0; int available = r_buf_read_at (buf, string_section, (ut8 *)b, sss); if (available != sss) { sss = available; } if (sss < 1) { eprintf ("Cannot read strings at 0x%08" PFMT64x "\n", (ut64)string_section); free (b); return NULL; } RList *res = r_list_newf ((RListFree)r_bin_string_free); int i; char *s_end = s + sss; for (i = 0; true; i++) { o = s - os; if (string_section + o + 8 > string_section_end) { break; } if (s + 4 > s_end) { break; } nstrings++; // eprintf ("0x%08x 0x%08x %s\n", o + string_section, o, s); RBinString *bs = R_NEW0 (RBinString); if (!bs) { break; } bs->string = strdup (s); // eprintf ("%s\n", s); bs->vaddr = o + string_section; bs->paddr = o + string_section; bs->ordinal = i; bs->length = strlen (s); r_list_append (res, bs); s += bs->length + 1; } free (b); return res; }
static RList *entries(RBinFile *bf) { RList /*<RBinAddr>*/ *ret = r_list_newf (free); if (!ret) { return NULL; } RBinAddr *ptr = R_NEW0 (RBinAddr); if (ptr) { ptr->paddr = N64_ROM_START; ptr->vaddr = baddr (bf); r_list_append (ret, ptr); } return ret; }
static RList *entries(RBinFile *bf) { RList *ret; RBinAddr *ptr = NULL; if (!(ret = r_list_newf (free))) { return NULL; } if (!(ptr = R_NEW0 (RBinAddr))) { return ret; } ptr->paddr = ptr->vaddr = 0; r_list_append (ret, ptr); return ret; }
static RList *imports(RBinFile *bf) { RBinWasmObj *bin = NULL; RList *imports = NULL; RBinImport *ptr = NULL; RList *ret = NULL; if (!bf || !bf->o || !bf->o->bin_obj) { return NULL; } bin = bf->o->bin_obj; if (!(ret = r_list_newf (r_bin_import_free))) { return NULL; } if (!(imports = r_bin_wasm_get_imports (bin))) { goto bad_alloc; } RBinWasmImportEntry *import = NULL; ut32 i = 0; RListIter *iter; r_list_foreach (imports, iter, import) { if (!(ptr = R_NEW0 (RBinImport))) { goto bad_alloc; } ptr->name = strdup (import->field_str); ptr->classname = strdup (import->module_str); ptr->ordinal = i; ptr->bind = r_str_const ("NONE"); switch(import->kind) { case R_BIN_WASM_EXTERNALKIND_Function: ptr->type = r_str_const ("FUNC"); break; case R_BIN_WASM_EXTERNALKIND_Table: ptr->type = r_str_const ("TABLE"); break; case R_BIN_WASM_EXTERNALKIND_Memory: ptr->type = r_str_const ("MEM"); break; case R_BIN_WASM_EXTERNALKIND_Global: ptr->type = r_str_const ("GLOBAL"); break; } r_list_append (ret, ptr); } return ret; bad_alloc: r_list_free (imports); r_list_free (ret); return NULL; }
static RList *r_debug_native_map_get(RDebug *dbg) { RIOBdescbg *o = dbg->iob.io->desc->data; BfvmCPU *c = o->bfvm; RList *list = r_list_newf ((RListFree)r_debug_map_free); if (!list) return NULL; r_list_append (list, r_debug_map_new ( "code", 0, 4096, 6, 0)); r_list_append (list, r_debug_map_new ( "memory", c->base, c->base+c->size, 6, 0)); r_list_append (list, r_debug_map_new ( "screen", c->screen, c->screen+c->screen_size, 6, 0)); r_list_append (list, r_debug_map_new ( "input", c->input, c->input+c->input_size, 6, 0)); return list; }
static RList * entries(RBinFile *bf) { RBinAddr *ptr = NULL; RList *res = NULL; if (!(res = r_list_newf (free))) { return NULL; } int entry = r_bin_mz_get_entrypoint (bf->o->bin_obj); if (entry >= 0) { if ((ptr = R_NEW0 (RBinAddr))) { ptr->paddr = (ut64) entry; ptr->vaddr = (ut64) entry; r_list_append (res, ptr); } } return res; }
static RList *entries(RBinFile *bf) { struct r_bin_bflt_obj *obj = (struct r_bin_bflt_obj *) bf->o->bin_obj; RList *ret; RBinAddr *ptr; if (!(ret = r_list_newf (free))) { return NULL; } ptr = r_bflt_get_entry (obj); if (!ptr) { r_list_free (ret); return NULL; } r_list_append (ret, ptr); return ret; }
static RList *entries(RBinFile *arch) { RList *ret = r_list_newf (free); RBinAddr *ptr = NULL; if (arch && arch->buf) { if (!ret) { return NULL; } if (!(ptr = R_NEW0 (RBinAddr))) { return ret; } ptr->paddr = ptr->vaddr = 0x8000000; r_list_append (ret, ptr); } return ret; }
static RList* lines(RBinFile *arch) { char *file = arch->file ? strdup (arch->file) : strdup (""); RList *list = r_list_newf (free); file = r_str_replace (file, ".class", ".java", 0); /* int i; RBinJavaObj *b = arch->o->bin_obj; for (i=0; i<b->lines.count; i++) { RBinDwarfRow *row = R_NEW0(RBinDwarfRow); r_bin_dwarf_line_new (row, b->lines.addr[i], file, b->lines.line[i]); r_list_append (list, row); }*/ free (file); return list; }
static RList * oneshotall(RBin *bin, const ut8 *buf, ut64 size) { RList *res = NULL; int narch, i = 0; RBinXtrData *data = oneshot (bin, buf, size, i); if (!data) return res; // XXX - how do we validate a valid narch? narch = data->file_count; res = r_list_newf (r_bin_xtrdata_free); r_list_append (res, data); for (i = 1; data && i < narch; i++) { data = NULL; data = oneshot (bin, buf, size, i); r_list_append (res, data); } return res; }
static RList* entries(RBinFile *bf) { RList* ret = r_list_newf (free); RBinAddr *ptr = NULL; if (ret) { if ((ptr = R_NEW0 (RBinAddr))) { ut64 entry = (ut64)readLE32(bf->buf, 0x80); ut64 size = (ut64)readLE32(bf->buf, 0x84); // eprintf ("0x%x 0x%x\n", entry, size); ptr->paddr = entry; ptr->vaddr = entry; r_list_append (ret, ptr); } else { r_list_free (ret); ret = NULL; } } return ret; }
R_API RList *r_core_list_themes(RCore *core) { RList *list = r_list_newf (free); getNext = false; char *path = r_str_home (R2_HOME_THEMES R_SYS_DIR); if (path) { list_themes_in_path (list, path); R_FREE (path); } path = r_str_r2_prefix (R2_THEMES R_SYS_DIR); if (path) { list_themes_in_path (list, path); R_FREE (path); } return list; }
static RList *r_debug_bochs_map_get(RDebug* dbg) { //TODO //eprintf("bochs_map_getdebug:\n"); RDebugMap *mr; RList *list = r_list_newf ((RListFree)map_free); if (!list) return NULL; mr = R_NEW0 (RDebugMap); if (!mr) { r_list_free (list); return NULL; } mr->name = strdup ("fake"); mr->addr = 0; mr->addr_end = UT32_MAX; mr->size = UT32_MAX; mr->perm = 0; mr->user = 0; r_list_append (list, mr); return list; }
static RList *lines(RBinFile *bf) { return NULL; #if 0 char *file = bf->file? strdup (bf->file): strdup (""); RList *list = r_list_newf (free); // XXX the owner of this list should be the plugin, so we are leaking here file = r_str_replace (file, ".class", ".java", 0); /* int i; RBinJavaObj *b = bf->o->bin_obj; for (i=0; i<b->lines.count; i++) { RBinDwarfRow *row = R_NEW0(RBinDwarfRow); r_bin_dwarf_line_new (row, b->lines.addr[i], file, b->lines.line[i]); r_list_append (list, row); }*/ free (file); return list; #endif }
static RList * extractall(RBin *bin) { RList *res = NULL; int narch, i = 0; RBinXtrData *data = NULL; data = extract (bin, i); if (!data) return res; // XXX - how do we validate a valid narch? narch = data->file_count; res = r_list_newf (r_bin_xtrdata_free); r_list_append (res, data); for (i = 1; data && i < narch; i++) { data = NULL; data = extract (bin, i); r_list_append (res, data); } return res; }