R_API RList *r_anal_refs_get (RAnal *anal, ut64 from) { RList *list = r_list_new (); if (!list) { return NULL; } r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_NULL, from); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_CODE, from); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_CALL, from); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_DATA, from); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_STRING, from); if (r_list_empty (list)) { r_list_free (list); list = NULL; } return list; }
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; }
R_API void r_anal_bb_free(RAnalBlock *bb) { if (!bb) return; r_anal_cond_free (bb->cond); free (bb->fingerprint); if (bb->diff) r_anal_diff_free (bb->diff); #if R_ANAL_BB_HAS_OPS if (bb->ops) r_list_free (bb->ops); bb->ops = NULL; bb->diff = NULL; #endif bb->fingerprint = NULL; bb->cond = NULL; free (bb); }
R_API void r_buf_deinit(RBuffer *b) { if (!b) return; if (b->fd != -1) { r_sandbox_close (b->fd); b->fd = -1; return; } if (b->sparse) { r_list_free (b->sparse); b->sparse = NULL; } if (b->mmap) { r_file_mmap_free (b->mmap); b->mmap = NULL; } else R_FREE (b->buf); }
static RList *imports(RBinFile *arch) { RBinWasmObj *bin = NULL; RList *imports = NULL; RBinImport *ptr = NULL; RList *ret = NULL; if (!arch || !arch->o || !arch->o->bin_obj) { return NULL; } bin = arch->o->bin_obj; if (!(ret = r_list_newf (r_bin_import_free))) { return NULL; } if (!(imports = r_bin_wasm_get_imports (bin))) { r_list_free (ret); return NULL; } RBinWasmImportEntry *import = NULL; ut32 i = 0; RListIter *iter; r_list_foreach (imports, iter, import) { if (!(ptr = R_NEW0 (RBinImport))) { break; } 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; }
static void radare2_rc(RCore *r) { char* env_debug = r_sys_getenv ("R_DEBUG"); bool has_debug = false; if (env_debug) { has_debug = true; R_FREE (env_debug); } char *homerc = r_str_home (".radare2rc"); if (homerc && r_file_is_regular (homerc)) { if (has_debug) { eprintf ("USER CONFIG loaded from %s\n", homerc); } r_core_cmd_file (r, homerc); } free (homerc); homerc = r_str_home (".config/radare2/radare2rc"); if (homerc && r_file_is_regular (homerc)) { if (has_debug) { eprintf ("USER CONFIG loaded from %s\n", homerc); } r_core_cmd_file (r, homerc); } free (homerc); homerc = r_str_home (".config/radare2/radare2rc.d"); if (homerc) { if (r_file_is_directory (homerc)) { char *file; RListIter *iter; RList *files = r_sys_dir (homerc); r_list_foreach (files, iter, file) { if (*file != '.') { char *path = r_str_newf ("%s/%s", homerc, file); if (r_file_is_regular (path)) { if (has_debug) { eprintf ("USER CONFIG loaded from %s\n", homerc); } r_core_cmd_file (r, path); } free (path); } } r_list_free (files); } free (homerc); } }
R_API RList *r_anal_xrefs_get_from (RAnal *anal, ut64 to) { RList *list = r_list_new (); if (!list) { return NULL; } list->free = NULL; // XXX r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_NULL, to); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_CODE, to); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_CALL, to); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_DATA, to); r_anal_xrefs_from (anal, list, "ref", R_ANAL_REF_TYPE_STRING, to); if (r_list_length (list)<1) { r_list_free (list); list = NULL; } return list; }
- follow symlinks #endif static char *rtr_dir_files (const char *path) { char *ptr = strdup ("<html><body>\n"); const char *file; RListIter *iter; // list files RList *files = r_sys_dir (path); eprintf ("Listing directory %s\n", path); r_list_foreach (files, iter, file) { if (file[0] == '.') continue; ptr = r_str_concatf (ptr, "<a href=\"%s%s\">%s</a><br />\n", path, file, file); } r_list_free (files); return r_str_concat (ptr, "</body></html>\n"); }
bool test_r_list_sort2(void) { RList* list = r_list_new (); char* test1 = "AAAA"; char* test2 = "BBBB"; char* test3 = "CCCC"; // Put in not sorted order. r_list_append (list, (void*)test3); r_list_append (list, (void*)test2); r_list_append (list, (void*)test1); // Sort. r_list_merge_sort (list, (RListComparator)strcmp); // Check that the list is actually sorted. mu_assert_streq ((char*)list->head->data, "AAAA", "first value in sorted list"); mu_assert_streq ((char*)list->head->n->data, "BBBB", "second value in sorted list"); mu_assert_streq ((char*)list->head->n->n->data, "CCCC", "third value in sorted list"); r_list_free (list); mu_end; }
static RList *r_debug_native_threads (RDebug *dbg, int pid) { RList *list = r_list_new (); if (list == NULL) { eprintf ("No list?\n"); return NULL; } #if __WINDOWS__ && !__CYGWIN__ return w32_thread_list (pid, list); #elif __APPLE__ return xnu_thread_list (dbg, pid, list); #elif __linux__ return linux_thread_list (pid, list); #else eprintf ("TODO: list threads\n"); r_list_free (list); return NULL; #endif }
bool test_r_list_sort3(void) { RList* list = r_list_new (); int test1 = 33508; int test2 = 33480; int test3 = 33964; // Put in not sorted order. r_list_append (list, (void*)&test1); r_list_append (list, (void*)&test3); r_list_append (list, (void*)&test2); // Sort. r_list_merge_sort (list, (RListComparator)cmp_range); // Check that the list is actually sorted. mu_assert_eq (*(int*)list->head->data, 33480, "first value in sorted list"); mu_assert_eq (*(int*)list->head->n->data, 33508, "second value in sorted list"); mu_assert_eq (*(int*)list->head->n->n->data, 33964, "third value in sorted list"); r_list_free (list); mu_end; }
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; }
bool test_r_list_sort5(void) { RList* list = r_list_new (); int i = 0; char *upper[] = {"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q","R","S","T","U","V","W","X","Y","Z"}; char *lower[] = {"a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"}; for (i = 0; i < 26; i++) { r_list_append (list, (void *)lower[i]); } for (i = 0; i < 26; i++) { r_list_append (list, (void *)upper[i]); } //add more than 43 elements to trigger merge sort r_list_sort (list, (RListComparator)strcmp); mu_assert_streq ((char *)list->head->data, upper[0], "First element"); mu_assert_streq ((char *)list->tail->data, lower[25], "Last element"); r_list_free (list); mu_end; }
static RList* entries(RBinFile *arch) { RList* ret = r_list_newf (free); RBinAddr *ptr = NULL; if (ret) { if ((ptr = R_NEW0 (RBinAddr))) { ut64 entry = findEntry (arch->buf, 2); if (!entry) entry = findEntry (arch->buf, 1); if (!entry) entry = findEntry (arch->buf, 0); if (!entry) entry = 4; ptr->paddr = entry; ptr->vaddr = entry; r_list_append (ret, ptr); } else { r_list_free (ret); ret = NULL; } } return ret; }
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; }
/* Compute the len and the starting address * when disassembling `nb` opcodes backward. */ R_API ut32 r_core_asm_bwdis_len (RCore* core, int* instr_len, ut64* start_addr, ut32 nb) { ut32 instr_run = 0; RCoreAsmHit *hit; RListIter *iter = NULL; RList* hits = r_core_asm_bwdisassemble (core, core->offset, nb, core->blocksize); if (instr_len) *instr_len = 0; if (hits && r_list_length (hits) > 0) { hit = r_list_get_bottom (hits); if (start_addr) *start_addr = hit->addr; r_list_foreach (hits, iter, hit) instr_run += hit->len; if (instr_len) *instr_len = instr_run; } r_list_free (hits); return instr_run; }
static void rtti_msvc_print_all(RVTableContext *context, int mode) { r_cons_break_push (NULL, NULL); RList *vtables = r_anal_vtable_search (context); RListIter *vtableIter; RVTableInfo *table; if (vtables) { r_list_foreach (vtables, vtableIter, table) { if (r_cons_is_breaked ()) { break; } r_anal_rtti_msvc_print_at_vtable (context, table->saddr, mode); r_cons_print ("\n"); } } r_list_free (vtables); r_cons_break_pop (); }
static RList *sections(RBinFile *bf) { RList /*<RBinSection>*/ *ret = r_list_new (); if (!ret) { return NULL; } RBinSection *text = R_NEW0 (RBinSection); if (!text) { r_list_free (ret); return NULL; } text->name = strdup ("text"); text->size = r_buf_size (bf->buf) - N64_ROM_START; text->vsize = text->size; text->paddr = N64_ROM_START; text->vaddr = baddr (bf); text->perm = R_PERM_RX; text->add = true; r_list_append (ret, text); return ret; }
R_API int r_anal_var_retype (RAnal *a, ut64 addr, int scope, int delta, char kind, const char *type, int size, const char *name) { char *var_def; if (!kind) kind ='v'; if (!type) type = "int"; if (size==-1) { RAnalFunction *fcn = r_anal_get_fcn_in (a, addr, 0); RList *list = r_anal_var_list (a, fcn, kind); RListIter *iter; RAnalVar *var; r_list_foreach (list, iter, var) { if (delta == -1) { if (!strcmp (var->name, name)) { delta = var->delta; size = var->size; break; } } } r_list_free (list); }
static RList *sections(RBinFile *bf) { RList /*<RBinSection>*/ *ret = r_list_new (); if (!ret) { return NULL; } RBinSection *text = R_NEW0 (RBinSection); if (!text) { r_list_free (ret); return NULL; } strncpy (text->name, "text", R_BIN_SIZEOF_STRINGS); text->size = bf->buf->length - N64_ROM_START; text->vsize = text->size; text->paddr = N64_ROM_START; text->vaddr = baddr (bf); text->perm = R_PERM_RX; text->add = true; r_list_append (ret, text); return ret; }
R_API void r_anal_bb_free(RAnalBlock *bb) { if (!bb) return; r_anal_cond_free (bb->cond); free (bb->fingerprint); if (bb->diff) { r_anal_diff_free (bb->diff); bb->diff = NULL; } free (bb->op_bytes); if (bb->switch_op) r_anal_switch_op_free (bb->switch_op); #if R_ANAL_BB_HAS_OPS r_list_free (bb->ops); bb->ops = NULL; #endif bb->fingerprint = NULL; bb->cond = NULL; free (bb->label); free (bb); }
bool test_r_list_size(void) { // Test that r_list adding and deleting works correctly. int i; RList* list = r_list_new (); intptr_t test = 0x101010; // Add 100 items. for (i = 0; i < 100; ++i) { r_list_append (list, (void*)test); mu_assert_eq (r_list_length (list), i + 1, "r_list_length failed on append"); } // Delete 50 of them. for (i = 0; i < 50; ++i) { (void)r_list_pop (list); mu_assert_eq(99 - i, r_list_length (list), "r_list_length failed on pop"); } // Purge the list. r_list_purge (list); mu_assert_eq(0, r_list_length (list), "r_list_length failed on purged list"); r_list_free (list); mu_end; }
static RList *entries(RBinFile *bf) { RBinWasmObj *bin = bf && bf->o ? bf->o->bin_obj : NULL; // TODO RList *ret; RBinAddr *ptr = NULL; ut64 addr = 0x0; if (!(ret = r_list_newf ((RListFree)free))) { return NULL; } if (!(addr = (ut64) r_bin_wasm_get_entrypoint (bin))) { r_list_free (ret); return NULL; } if ((ptr = R_NEW0 (RBinAddr))) { ptr->paddr = addr; ptr->vaddr = addr; r_list_append (ret, ptr); } return ret; }
static RList *sections(RBinFile *arch) { const char *coffname; 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_new(); if (!ret) return NULL; if (obj && obj->scn_hdrs) for (i = 0; i < obj->hdr.f_nscns; i++) { coffname = r_coff_symbol_name (obj, &obj->scn_hdrs[i]); if (!coffname) { r_list_free (ret); return NULL; } ptr = R_NEW0 (RBinSection); strncpy (ptr->name, coffname, R_BIN_SIZEOF_STRINGS); 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->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); } return ret; }
R_API int r_core_project_list(RCore *core, int mode) { PJ *pj = NULL; RListIter *iter; RList *list; char *foo, *path = r_file_abspath (r_config_get (core->config, "dir.projects")); if (!path) { return 0; } list = r_sys_dir (path); switch (mode) { case 'j': pj = pj_new (); if (!pj) { break; } pj_a (pj); r_list_foreach (list, iter, foo) { // todo. escape string if (r_core_is_project (core, foo)) { pj_s (pj, foo); } } pj_end (pj); r_cons_printf ("%s\n", pj_string (pj)); pj_free (pj); break; default: r_list_foreach (list, iter, foo) { if (r_core_is_project (core, foo)) { r_cons_println (foo); } } break; } r_list_free (list); free (path); return 0; }
R_API char *r_cons_hud_string(const char *s) { int i; char *os, *ret, *o = strdup (s); RList *fl = r_list_new (); if (!fl) { free (o); return NULL; } fl->free = free; for (os=o, i=0; o[i]; i++) { if (o[i]=='\n') { o[i] = 0; if (*os && *os != '#') r_list_append (fl, strdup (os)); os = o + i + 1; } } ret = r_cons_hud (fl, NULL); free (o); r_list_free (fl); return ret; }
/* add a breakpoint with some typical values */ R_API RBreakpointItem *r_debug_bp_add(RDebug *dbg, ut64 addr, int hw, bool watch, int rw, char *module, st64 m_delta) { int bpsz = r_bp_size(dbg->bp); RBreakpointItem *bpi; const char *module_name = module; RListIter *iter; RDebugMap *map; if (!addr && module) { bool detect_module, valid = false; int perm; if (m_delta) { detect_module = false; RList *list = r_debug_modules_list (dbg); r_list_foreach (list, iter, map) { if (strstr (map->file, module)) { addr = map->addr + m_delta; module_name = map->file; break; } } r_list_free (list); } else {
static RList *r_debug_wind_pids (int pid) { RList *ret, *pids; RListIter *it; WindProc *p; ret = r_list_newf (free); if (!ret) return NULL; pids = wind_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); }
R_API int r_core_project_delete(RCore *core, const char *prjfile) { char *path; if (r_sandbox_enable (0)) { eprintf ("Cannot delete project in sandbox mode\n"); return 0; } path = r_core_project_file (core, prjfile); if (!path) { eprintf ("Invalid project name '%s'\n", prjfile); return false; } if (r_core_is_project (core, prjfile)) { // rm project file r_file_rm (path); eprintf ("rm %s\n", path); path = r_str_concat (path, ".d"); if (r_file_is_directory (path)) { char *f; RListIter *iter; RList *files = r_sys_dir (path); r_list_foreach (files, iter, f) { char *filepath = r_str_concat (strdup (path), R_SYS_DIR); filepath =r_str_concat (filepath, f); if (!r_file_is_directory (filepath)) { eprintf ("rm %s\n", filepath); r_file_rm (filepath); } free (filepath); } r_file_rm (path); eprintf ("rm %s\n", path); r_list_free (files); } // TODO: remove .d directory (BEWARE OF ROOT RIMRAFS!) // TODO: r_file_rmrf (path); }
static void map_cpu_memory (RAnal *anal, int entry, ut32 addr, ut32 size, bool force) { RIODesc *desc = mem_map[entry].desc; if (desc && anal->iob.fd_get_name (anal->iob.io, desc->fd)) { if (force || addr != mem_map[entry].addr) { // reallocate mapped memory if address changed anal->iob.fd_remap (anal->iob.io, desc->fd, addr); } } else { // allocate memory for address space char *mstr = r_str_newf ("malloc://%d", size); desc = anal->iob.open_at (anal->iob.io, mstr, R_PERM_RW, 0, addr); free (mstr); // set 8051 address space as name of mapped memory if (desc && anal->iob.fd_get_name (anal->iob.io, desc->fd)) { RList *maps = anal->iob.fd_get_map (anal->iob.io, desc->fd); RIOMap *current_map; RListIter *iter; r_list_foreach (maps, iter, current_map) { char *cmdstr = r_str_newf ("omni %d %s", current_map->id, mem_map[entry].name); anal->coreb.cmd (anal->coreb.core, cmdstr); free (cmdstr); } r_list_free (maps); }