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