cfile.c File Reference

#include <rz_core.h>
#include <stdlib.h>
#include <string.h>
#include "core_private.h"
#include "core_private_base.h"

Go to the source code of this file.

Classes
struct	__rebase_struct
struct	RzCoreFileData
struct	RzCoreLinkData

Macros
#define	__is_inside_section(item_addr, section)    (item_addr >= old_base + section->vaddr && item_addr <= old_base + section->vaddr + section->vsize)

Functions
static bool	core_file_do_load_for_debug (RzCore *r, ut64 loadaddr, const char *filenameuri)
static bool	core_file_do_load_for_io_plugin (RzCore *r, ut64 baseaddr, ut64 loadaddr)
static RzCoreFile *	core_file_new (RzCore *core, int fd)
RZ_IPI void	rz_core_file_free (RzCoreFile *cf)
static bool	__isMips (RzAsm *a)
static void	loadGP (RzCore *core)
static RZ_OWN RzList *	__save_old_sections (RzCore *core)
static bool	__rebase_flags (RzFlagItem *flag, void *user)
static bool	__rebase_xrefs_i (void *user, const ut64 k, const void *v)
static bool	__rebase_xrefs (void *user, const ut64 k, const void *v)
static void	__rebase_everything (RzCore *core, RzList *old_sections, ut64 old_base)
RZ_API bool	rz_core_file_open_load (RZ_NONNULL RzCore *core, RZ_NONNULL const char *filepath, ut64 addr, int perms, bool write_mode)
	Tries to open the file, load binary info and make RzIOMap. More...
RZ_API void	rz_core_file_reopen_remote_debug (RzCore *core, const char *uri, ut64 addr)
RZ_API void	rz_core_file_reopen_debug (RzCore *core, const char *args)
RZ_API bool	rz_core_file_reopen (RzCore *core, const char *args, int perm, int loadbin)
static bool	file_resize (RzCore *core, ut64 newsize, st64 delta)
RZ_API bool	rz_core_file_resize (RzCore *core, ut64 newsize)
RZ_API bool	rz_core_file_resize_delta (RzCore *core, st64 delta)
RZ_API void	rz_core_sysenv_end (RzCore *core)
RZ_API void	rz_core_sysenv_begin (RzCore *core)
static ut64	get_base_from_maps (RzCore *core, const char *file)
static bool	try_loadlib (RzCore *core, const char *lib, ut64 addr)
RZ_API bool	rz_core_file_loadlib (RzCore *core, const char *lib, ut64 libaddr)
RZ_API int	rz_core_bin_rebase (RzCore *core, ut64 baddr)
static void	load_scripts_for (RzCore *core, const char *name)
static bool	filecb (void *user, void *data, ut32 id)
static bool	file_is_loaded (RzCore *core, const char *lib)
static bool	resolve_import_cb (RzCoreLinkData *ld, RzIODesc *desc, ut32 id)
static bool	map_multi_dex (RzCore *core, RzIODesc *desc, ut32 id)
RZ_API bool	rz_core_bin_load (RZ_NONNULL RzCore *r, RZ_NULLABLE const char *filenameuri, ut64 baddr)
RZ_API RZ_BORROW RzCoreFile *	rz_core_file_open_many (RZ_NONNULL RzCore *r, RZ_NULLABLE const char *file, int perm, ut64 base_address)
	Open the file as a compilation of files. More...
RZ_API RZ_BORROW RzCoreFile *	rz_core_file_open (RZ_NONNULL RzCore *r, RZ_NONNULL const char *file, int flags, ut64 loadaddr)
	Tries to open the file as is, otherwise tries as is a compilation of files. More...
RZ_IPI void	rz_core_file_io_desc_closed (RzCore *core, RzIODesc *desc)
RZ_IPI void	rz_core_file_io_map_deleted (RzCore *core, RzIOMap *map)
RZ_IPI void	rz_core_file_bin_file_deleted (RzCore *core, RzBinFile *bf)
RZ_API void	rz_core_file_close (RzCoreFile *fh)
RZ_API RzCoreFile *	rz_core_file_get_by_fd (RzCore *core, int fd)
RZ_API bool	rz_core_raw_file_print (RzCore *core)
RZ_API bool	rz_core_file_print (RzCore *core, RzOutputMode mode)
RZ_API bool	rz_core_file_bin_raise (RzCore *core, ut32 bfid)
RZ_API int	rz_core_file_binlist (RzCore *core)
static bool	close_but_cb (void *user, void *data, ut32 id)
RZ_API bool	rz_core_file_close_all_but (RzCore *core)
RZ_API bool	rz_core_file_close_fd (RzCore *core, int fd)
RZ_API RzCoreFile *	rz_core_file_find_by_fd (RzCore *core, ut64 fd)
RZ_API RzCoreFile *	rz_core_file_find_by_name (RzCore *core, const char *name)
RZ_API int	rz_core_file_set_by_fd (RzCore *core, ut64 fd)
RZ_API int	rz_core_file_set_by_name (RzCore *core, const char *name)
RZ_API int	rz_core_file_set_by_file (RzCore *core, RzCoreFile *cf)
RZ_API ut32	rz_core_file_cur_fd (RzCore *core)
RZ_API RzCoreFile *	rz_core_file_cur (RzCore *r)
RZ_API void	rz_core_io_file_open (RZ_NONNULL RzCore *core, int fd)
	Open file use read-only Permission. More...
RZ_API void	rz_core_io_file_reopen (RZ_NONNULL RzCore *core, int fd, int perms)
	Reopen file. More...
RZ_IPI RzCoreIOMapInfo *	rz_core_io_map_info_new (RzCoreFile *cf, int perm_orig)
RZ_IPI void	rz_core_io_map_info_free (RzCoreIOMapInfo *info)

Macro Definition Documentation

__is_inside_section

#define __is_inside_section	(		item_addr,
			section
	)		(item_addr >= old_base + section->vaddr && item_addr <= old_base + section->vaddr + section->vsize)

Definition at line 90 of file cfile.c.

Function Documentation

__isMips()

static bool __isMips ( RzAsm *  a )

static

Definition at line 36 of file cfile.c.

                               {
    return a && a->cur && a->cur->arch && strstr(a->cur->arch, "mips");
}

References a.

Referenced by loadGP().

__rebase_everything()

static void __rebase_everything ( RzCore *  core, RzList *  old_sections, ut64  old_base  )

static

Definition at line 123 of file cfile.c.

                                                                                   {
    RzListIter *it, *itit, *ititit;
    RzAnalysisFunction *fcn;
    ut64 new_base = core->bin->cur->o->baddr_shift;
    RzBinSection *old_section;
    ut64 diff = new_base - old_base;
    if (!diff) {
        return;
    }
    // FUNCTIONS
    rz_list_foreach (core->analysis->fcns, it, fcn) {
        rz_list_foreach (old_sections, itit, old_section) {
            if (!__is_inside_section(fcn->addr, old_section)) {
                continue;
            }
            rz_analysis_function_rebase_vars(core->analysis, fcn);
            rz_analysis_function_relocate(fcn, fcn->addr + diff);
            RzAnalysisBlock *bb;
            ut64 new_sec_addr = new_base + old_section->vaddr;
            rz_list_foreach (fcn->bbs, ititit, bb) {
                if (bb->addr >= new_sec_addr && bb->addr <= new_sec_addr + old_section->vsize) {
                    // Todo: Find better way to check if bb was already rebased
                    continue;
                }
                rz_analysis_block_relocate(bb, bb->addr + diff, bb->size);
                if (bb->jump != UT64_MAX) {
                    bb->jump += diff;
                }
                if (bb->fail != UT64_MAX) {
                    bb->fail += diff;
                }
            }
            break;
        }
    }
 
    // FLAGS
    struct __rebase_struct reb = {
        core,
        old_sections,
        old_base,
        diff
    };
    rz_flag_foreach(core->flags, __rebase_flags, &reb);
 
    // META
    rz_meta_rebase(core->analysis, diff);
 
    // XREFS
    HtUP *xrefs_from = core->analysis->ht_xrefs_from;
    HtUP *xrefs_to = core->analysis->ht_xrefs_to;
    core->analysis->ht_xrefs_from = NULL;
    core->analysis->ht_xrefs_to = NULL;
    rz_analysis_xrefs_init(core->analysis);
    ht_up_foreach(xrefs_from, __rebase_xrefs, &reb);
    ht_up_free(xrefs_from);
    ht_up_free(xrefs_to);
 
    // BREAKPOINTS
    rz_debug_bp_rebase(core->dbg, old_base, new_base);
}

References __is_inside_section, __rebase_flags(), __rebase_xrefs(), rz_analysis_function_t::addr, rz_analysis_bb_t::addr, rz_core_t::analysis, rz_bin_object_t::baddr_shift, rz_analysis_function_t::bbs, rz_core_t::bin, __rebase_struct::core, rz_bin_t::cur, rz_core_t::dbg, __rebase_struct::diff, rz_analysis_bb_t::fail, rz_analysis_t::fcns, rz_core_t::flags, rz_analysis_t::ht_xrefs_from, rz_analysis_t::ht_xrefs_to, rz_analysis_bb_t::jump, NULL, rz_bin_file_t::o, __rebase_struct::old_base, __rebase_struct::old_sections, rz_analysis_block_relocate(), rz_analysis_function_rebase_vars(), rz_analysis_function_relocate(), rz_analysis_xrefs_init(), rz_debug_bp_rebase(), rz_flag_foreach(), rz_meta_rebase(), rz_analysis_bb_t::size, ut64(), UT64_MAX, rz_bin_section_t::vaddr, and rz_bin_section_t::vsize.

Referenced by rz_core_file_reopen_debug(), rz_core_file_reopen_remote_debug(), and rz_core_io_file_open().

__rebase_flags()

static bool __rebase_flags ( RzFlagItem *  flag, void *  user  )

static

Definition at line 93 of file cfile.c.

                                                         {
    struct __rebase_struct *reb = user;
    ut64 old_base = reb->old_base;
    RzListIter *it;
    RzBinSection *sec;
    // Only rebase flags that were in the rebased sections, otherwise it will take too long
    rz_list_foreach (reb->old_sections, it, sec) {
        if (__is_inside_section(flag->offset, sec)) {
            rz_flag_set(reb->core->flags, flag->name, flag->offset + reb->diff, flag->size);
            break;
        }
    }
    return true;
}

References __is_inside_section, __rebase_struct::core, __rebase_struct::diff, rz_core_t::flags, rz_flag_item_t::name, rz_flag_item_t::offset, __rebase_struct::old_base, __rebase_struct::old_sections, rz_flag_set(), rz_flag_item_t::size, and ut64().

Referenced by __rebase_everything().

__rebase_xrefs()

static bool __rebase_xrefs ( void *  user, const ut64  k, const void *  v  )

static

Definition at line 117 of file cfile.c.

                                                                    {
    HtUP *ht = (HtUP *)v;
    ht_up_foreach(ht, __rebase_xrefs_i, user);
    return true;
}

References __rebase_xrefs_i(), and v.

Referenced by __rebase_everything().

__rebase_xrefs_i()

static bool __rebase_xrefs_i ( void *  user, const ut64  k, const void *  v  )

static

Definition at line 108 of file cfile.c.

                                                                      {
    struct __rebase_struct *reb = (void *)user;
    RzAnalysisXRef *xref = (RzAnalysisXRef *)v;
    xref->from += reb->diff;
    xref->to += reb->diff;
    rz_analysis_xrefs_set(reb->core->analysis, xref->from, xref->to, xref->type);
    return true;
}

References rz_core_t::analysis, __rebase_struct::core, __rebase_struct::diff, rz_analysis_ref_t::from, rz_analysis_xrefs_set(), rz_analysis_ref_t::to, rz_analysis_ref_t::type, and v.

Referenced by __rebase_xrefs().

__save_old_sections()

static RZ_OWN RzList* __save_old_sections ( RzCore *  core )

static

Definition at line 56 of file cfile.c.

                                                        {
    RzList *sections = rz_bin_get_sections(core->bin);
    RzListIter *it;
    RzBinSection *sec;
    RzList *old_sections = rz_list_new();
 
    // Return an empty list
    if (!sections) {
        RZ_LOG_WARN("No sections found, functions and flags won't be rebased\n");
        return old_sections;
    }
 
    old_sections->free = sections->free;
    rz_list_foreach (sections, it, sec) {
        RzBinSection *old_sec = RZ_NEW0(RzBinSection);
        if (!old_sec) {
            break;
        }
        *old_sec = *sec;
        old_sec->name = strdup(sec->name);
        old_sec->format = NULL;
        rz_list_append(old_sections, old_sec);
    }
    return old_sections;
}

References rz_core_t::bin, rz_bin_section_t::format, rz_list_t::free, rz_bin_section_t::name, NULL, rz_bin_get_sections(), rz_list_append(), rz_list_new(), RZ_LOG_WARN, RZ_NEW0, sections(), and strdup().

Referenced by rz_core_file_reopen_debug(), rz_core_file_reopen_remote_debug(), and rz_core_io_file_open().

close_but_cb()

static bool close_but_cb ( void *  user, void *  data, ut32  id  )

static

Definition at line 1492 of file cfile.c.

                                                          {
    RzCore *core = (RzCore *)user;
    RzIODesc *desc = (RzIODesc *)data;
    if (core && desc && core->file) {
        if (desc->fd != core->file->fd) {
            if (!rz_core_file_close_fd(core, desc->fd)) {
                return false;
            }
        }
    }
    return true;
}

References desc, rz_core_file_t::fd, rz_core_t::file, and rz_core_file_close_fd().

Referenced by rz_core_file_close_all_but().

core_file_do_load_for_debug()

static bool core_file_do_load_for_debug ( RzCore *  r, ut64  loadaddr, const char *  filenameuri  )

static

Definition at line 633 of file cfile.c.

                                                                                           {
    RzCoreFile *cf = rz_core_file_cur(r);
    RzIODesc *desc = cf ? rz_io_desc_get(r->io, cf->fd) : NULL;
    RzBinPlugin *plugin;
    int xtr_idx = 0; // if 0, load all if xtr is used
 
    // TODO : Honor file.path eval var too?
    if (!strncmp("dbg://", filenameuri, 6)) {
        filenameuri += 6;
    }
    if (!desc) {
        return false;
    }
    if (cf) {
        rz_debug_select(r->dbg, rz_io_fd_get_pid(r->io, cf->fd),
            rz_io_fd_get_tid(r->io, cf->fd));
    }
#if !__linux__
#if !__WINDOWS__
    baseaddr = get_base_from_maps(r, filenameuri);
#endif
    if (baseaddr != UT64_MAX) {
        rz_config_set_i(r->config, "bin.baddr", baseaddr);
    } else if (desc) {
        ut64 base;
        if (rz_io_desc_get_base(desc, &base) && base != UT64_MAX) {
            baseaddr = base;
            rz_config_set_i(r->config, "bin.baddr", baseaddr);
        }
    }
#endif
    int fd = cf ? cf->fd : -1;
 
    RzBinOptions opt;
    rz_bin_options_init(&opt, fd, baseaddr, UT64_MAX, false);
    opt.obj_opts.elf_load_sections = rz_config_get_b(r->config, "elf.load.sections");
    opt.obj_opts.elf_checks_sections = rz_config_get_b(r->config, "elf.checks.sections");
    opt.obj_opts.elf_checks_segments = rz_config_get_b(r->config, "elf.checks.segments");
    opt.obj_opts.big_endian = rz_config_get_b(r->config, "cfg.bigendian");
    opt.xtr_idx = xtr_idx;
    RzBinFile *binfile = rz_bin_open(r->bin, filenameuri, &opt);
    if (!binfile) {
        RZ_LOG_ERROR("bin: debug: Cannot open '%s'\n", filenameuri);
        return false;
    }
 
    if (binfile && cf) {
        rz_pvector_push(&cf->binfiles, binfile);
    }
 
    if (*rz_config_get(r->config, "dbg.libs")) {
        rz_core_cmd0(r, ".dmm*");
#if __linux__
        setbpint(r, "dbg.libs", "sym.imp.dlopen");
        setbpint(r, "dbg.libs", "sym.imp.dlmopen");
        setbpint(r, "dbg.unlibs", "sym.imp.dlclose");
#elif __APPLE__
        setbpint(r, "dbg.libs", "sym._dlopen");
        setbpint(r, "dbg.libs", "sym._dlclose");
#endif
    }
    rz_core_bin_apply_all_info(r, binfile);
    rz_debug_reg_profile_sync(r->dbg);
    plugin = rz_bin_file_cur_plugin(binfile);
    if (plugin && !strcmp(plugin->name, "any")) {
        // set use of raw strings
        // rz_config_set_i (r->config, "io.va", false);
        // get bin.minstr
        r->bin->minstrlen = rz_config_get_i(r->config, "bin.minstr");
        r->bin->maxstrbuf = rz_config_get_i(r->config, "bin.maxstrbuf");
    } else if (binfile) {
        RzBinObject *obj = rz_bin_cur_object(r->bin);
        RzBinInfo *info = obj ? obj->info : NULL;
        if (plugin && info) {
            rz_core_bin_set_arch_bits(r, binfile->file, info->arch, info->bits);
        }
    }
 
    return true;
}

References rz_bin_info_t::arch, baseaddr, rz_core_file_t::binfiles, rz_bin_info_t::bits, desc, fd, rz_core_file_t::fd, rz_bin_file_t::file, get_base_from_maps(), info(), rz_bin_object_t::info, rz_bin_plugin_t::name, NULL, r, rz_bin_cur_object(), rz_bin_file_cur_plugin(), rz_bin_open(), rz_bin_options_init(), rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set_i(), rz_core_bin_apply_all_info(), rz_core_bin_set_arch_bits(), rz_core_cmd0(), rz_core_file_cur(), rz_debug_reg_profile_sync(), rz_debug_select(), rz_io_desc_get(), rz_io_desc_get_base(), rz_io_fd_get_pid(), rz_io_fd_get_tid(), RZ_LOG_ERROR, rz_pvector_push(), ut64(), and UT64_MAX.

Referenced by rz_core_bin_load().

core_file_do_load_for_io_plugin()

static bool core_file_do_load_for_io_plugin ( RzCore *  r, ut64  baseaddr, ut64  loadaddr  )

static

Definition at line 714 of file cfile.c.

                                                                                     {
    RzCoreFile *cf = rz_core_file_cur(r);
    int fd = cf ? cf->fd : -1;
    int xtr_idx = 0; // if 0, load all if xtr is used
    RzBinPlugin *plugin;
 
    if (fd < 0) {
        return false;
    }
    rz_io_use_fd(r->io, fd);
    RzBinOptions opt;
    rz_core_bin_options_init(r, &opt, fd, baseaddr, loadaddr);
    opt.xtr_idx = xtr_idx;
    RzBinFile *binfile = rz_bin_open_io(r->bin, &opt);
    if (!binfile) {
        // RZ_LOG_ERROR("Failed to load the bin with an IO Plugin.\n");
        return false;
    }
    if (cf) {
        rz_pvector_push(&cf->binfiles, binfile);
    }
    if (rz_core_bin_apply_all_info(r, binfile)) {
        if (!r->analysis->sdb_cc->path) {
            RZ_LOG_WARN("No calling convention defined for this file, analysis may be inaccurate.\n");
        }
    }
    plugin = rz_bin_file_cur_plugin(binfile);
    if (plugin && !strcmp(plugin->name, "any")) {
        RzBinObject *obj = rz_bin_cur_object(r->bin);
        RzBinInfo *info = obj ? obj->info : NULL;
        if (!info) {
            return false;
        }
        info->bits = r->rasm->bits;
        // set use of raw strings
        rz_core_bin_set_arch_bits(r, binfile->file, info->arch, info->bits);
        // rz_config_set_i (r->config, "io.va", false);
        // get bin.minstr
        r->bin->minstrlen = rz_config_get_i(r->config, "bin.minstr");
        r->bin->maxstrbuf = rz_config_get_i(r->config, "bin.maxstrbuf");
    } else if (binfile) {
        RzBinObject *obj = rz_bin_cur_object(r->bin);
        RzBinInfo *info = obj ? obj->info : NULL;
        if (!info) {
            return false;
        }
        if (plugin && info) {
            rz_core_bin_set_arch_bits(r, binfile->file,
                info->arch, info->bits);
        }
    }
 
    return true;
}

References rz_bin_info_t::arch, baseaddr, rz_core_file_t::binfiles, rz_bin_info_t::bits, fd, rz_core_file_t::fd, rz_bin_file_t::file, info(), rz_bin_object_t::info, rz_bin_plugin_t::name, NULL, r, rz_bin_cur_object(), rz_bin_file_cur_plugin(), rz_bin_open_io(), rz_config_get_i(), rz_core_bin_apply_all_info(), rz_core_bin_options_init(), rz_core_bin_set_arch_bits(), rz_core_file_cur(), rz_io_use_fd(), RZ_LOG_WARN, and rz_pvector_push().

Referenced by rz_core_bin_load().

core_file_new()

static RzCoreFile* core_file_new ( RzCore *  core, int  fd  )

static

Definition at line 13 of file cfile.c.

                                                       {
    RzCoreFile *r = RZ_NEW0(RzCoreFile);
    if (!r) {
        return NULL;
    }
    r->core = core;
    r->fd = fd;
    rz_pvector_init(&r->binfiles, NULL);
    rz_pvector_init(&r->extra_files, NULL);
    rz_pvector_init(&r->maps, NULL);
    return r;
}

References fd, NULL, r, RZ_NEW0, and rz_pvector_init().

Referenced by rz_core_file_open(), and rz_core_file_open_many().

file_is_loaded()

static bool file_is_loaded ( RzCore *  core, const char *  lib  )

static

Definition at line 873 of file cfile.c.

                                                          {
    RzCoreFileData filedata = { lib, false };
    rz_id_storage_foreach(core->io->files, filecb, &filedata);
    return filedata.found;
}

References filecb(), rz_io_t::files, RzCoreFileData::found, rz_core_t::io, and rz_id_storage_foreach().

Referenced by rz_core_bin_load().

file_resize()

static bool file_resize ( RzCore *  core, ut64  newsize, st64  delta  )

static

Definition at line 488 of file cfile.c.

                                                                {
    int ret;
    ut64 oldsize = (core->file) ? rz_io_fd_size(core->io, core->file->fd) : 0;
    if (delta) {
        newsize = oldsize + delta;
    }
    bool grow = (newsize > oldsize);
    if (grow) {
        ret = rz_io_resize(core->io, newsize);
        if (ret < 1) {
            RZ_LOG_ERROR("rz_io_resize: cannot resize\n");
            return false;
        }
    }
    if (delta && core->offset < newsize) {
        rz_io_shift(core->io, core->offset, grow ? newsize : oldsize, delta);
    }
    if (!grow) {
        ret = rz_io_resize(core->io, newsize);
        if (ret < 1) {
            RZ_LOG_ERROR("rz_io_resize: cannot resize\n");
            return false;
        }
    }
    if (newsize < core->offset + core->blocksize || oldsize < core->offset + core->blocksize) {
        rz_core_block_read(core);
    }
    return true;
}

References rz_core_t::blocksize, __rebase_struct::core, delta, rz_core_file_t::fd, rz_core_t::file, rz_core_t::io, rz_core_t::offset, rz_core_block_read(), rz_io_fd_size(), rz_io_resize(), rz_io_shift(), RZ_LOG_ERROR, and ut64().

Referenced by rz_core_file_resize(), and rz_core_file_resize_delta().

filecb()

static bool filecb ( void *  user, void *  data, ut32  id  )

static

Definition at line 864 of file cfile.c.

                                                    {
    RzCoreFileData *filedata = user;
    RzIODesc *desc = (RzIODesc *)data;
    if (!strcmp(desc->name, filedata->name)) {
        filedata->found = true;
    }
    return true;
}

References desc, RzCoreFileData::found, and RzCoreFileData::name.

Referenced by file_is_loaded().

get_base_from_maps()

static ut64 get_base_from_maps ( RzCore *  core, const char *  file  )

static

Definition at line 576 of file cfile.c.

                                                               {
    RzDebugMap *map;
    RzListIter *iter;
    ut64 b = 0LL;
 
    rz_debug_map_sync(core->dbg); // update process memory maps
    rz_list_foreach (core->dbg->maps, iter, map) {
        if ((map->perm & 5) == 5) {
            // TODO: make this more flexible
            // XXX - why "copy/" here?
            if (map->name && strstr(map->name, "copy/")) {
                return map->addr;
            }
            if (map->file && !strcmp(map->file, file)) {
                return map->addr;
            }
            if (map->name && !strcmp(map->name, file)) {
                return map->addr;
            }
            // XXX - Commented out, as this could unexpected results
            // b = map->addr;
        }
    }
    // fallback resolution copied from cmd_debug.c:rz_debug_get_baddr
    rz_list_foreach (core->dbg->maps, iter, map) {
        if (map->perm == 5) { // r-x
            return map->addr;
        }
    }
 
    return b;
}

References b, __rebase_struct::core, rz_core_t::dbg, map(), rz_debug_t::maps, rz_debug_map_sync(), and ut64().

Referenced by core_file_do_load_for_debug().

load_scripts_for()

static void load_scripts_for ( RzCore *  core, const char *  name  )

static

Definition at line 836 of file cfile.c.

                                                             {
    char *file;
    RzListIter *iter;
    char *binrc = rz_path_home_prefix(RZ_BINRC);
    char tmp[50];
    char *hdir = rz_file_path_join(binrc, rz_strf(tmp, "bin-%s", name));
    free(binrc);
    RzList *files = rz_sys_dir(hdir);
    if (!rz_list_empty(files)) {
        RZ_LOG_INFO("[binrc] path: '%s'\n", hdir);
    }
    rz_list_foreach (files, iter, file) {
        if (*file && *file != '.') {
            RZ_LOG_INFO("[binrc] loading '%s'\n", file);
            char *fullpath = rz_file_path_join(hdir, file);
            rz_core_run_script(core, fullpath);
            free(fullpath);
        }
    }
    rz_list_free(files);
    free(hdir);
}

References __rebase_struct::core, file, files, free(), RZ_BINRC, rz_core_run_script(), rz_file_path_join(), rz_list_free(), RZ_LOG_INFO, rz_path_home_prefix(), rz_strf, rz_sys_dir(), and autogen_x86imm::tmp.

Referenced by rz_core_bin_load().

loadGP()

static void loadGP ( RzCore *  core )

static

Definition at line 40 of file cfile.c.

                                 {
    if (__isMips(core->rasm)) {
        ut64 gp = rz_num_math(core->num, "loc._gp");
        if (!gp || gp == UT64_MAX) {
            rz_config_set(core->config, "analysis.roregs", "zero");
            ut64 addr = rz_num_math(core->num, "entry");
            rz_core_seek_opt(core, addr, true, false);
            rz_core_debug_step_one(core, 10);
            rz_config_set(core->config, "analysis.roregs", "zero,gp");
            gp = rz_reg_getv(core->analysis->reg, "gp");
        }
        // RZ_LOG_DEBUG("[mips] gp: 0x%08"PFMT64x"\n", gp);
        rz_config_set_i(core->config, "analysis.gp", gp);
    }
}

References __isMips(), addr, rz_core_t::analysis, rz_core_t::config, rz_core_t::num, rz_core_t::rasm, rz_analysis_t::reg, rz_config_set(), rz_config_set_i(), rz_core_debug_step_one(), rz_core_seek_opt(), rz_num_math(), rz_reg_getv(), ut64(), and UT64_MAX.

Referenced by rz_core_bin_load(), and rz_core_file_reopen().

map_multi_dex()

static bool map_multi_dex ( RzCore *  core, RzIODesc *  desc, ut32  id  )

static

Definition at line 903 of file cfile.c.

                                                                 {
    rz_return_val_if_fail(core && desc, false);
    if (!rz_str_endswith(desc->name, ".dex")) {
        return true;
    }
    RzCoreFile *cf = rz_core_file_cur(core);
 
    // adds the current size and aligns next address
    ut64 base_address = RZ_CORE_BASE_ADDRESS_DEX;
    RzBinFile *cur = rz_pvector_empty(&cf->binfiles) ? NULL : rz_pvector_tail(&cf->binfiles);
    if (cur) {
        RzIODesc *iod = rz_io_desc_get(core->io, cur->fd);
        if (iod) {
            base_address = cur->loadaddr;
            base_address += rz_io_desc_size(iod);
            rz_core_align_base_address(base_address);
        }
    }
 
    ut64 size = rz_io_desc_size(desc);
    RZ_LOG_INFO("Mapping at 0x%08" PFMT64x " with size 0x08%" PFMT64x " %s\n", base_address, size, desc->name);
 
    rz_io_use_fd(core->io, desc->fd);
    RzBinOptions opt;
    rz_core_bin_options_init(core, &opt, desc->fd, base_address, 0);
    opt.xtr_idx = 0;
    RzBinFile *binfile = rz_bin_open_io(core->bin, &opt);
    if (!binfile) {
        RZ_LOG_ERROR("Cannot load bin file %s.\n", desc->name);
        return true;
    }
    binfile->loadaddr = base_address;
 
    rz_pvector_push(&cf->binfiles, binfile);
    rz_core_bin_apply_all_info(core, binfile);
 
    return true;
}

References rz_core_t::bin, rz_core_file_t::binfiles, desc, rz_bin_file_t::fd, rz_core_t::io, rz_bin_file_t::loadaddr, NULL, PFMT64x, rz_bin_open_io(), rz_core_align_base_address, RZ_CORE_BASE_ADDRESS_DEX, rz_core_bin_apply_all_info(), rz_core_bin_options_init(), rz_core_file_cur(), rz_io_desc_get(), rz_io_desc_size(), rz_io_use_fd(), RZ_LOG_ERROR, RZ_LOG_INFO, rz_pvector_empty(), rz_pvector_push(), rz_pvector_tail(), rz_return_val_if_fail, rz_str_endswith(), and ut64().

Referenced by rz_core_bin_load().

resolve_import_cb()

static bool resolve_import_cb ( RzCoreLinkData *  ld, RzIODesc *  desc, ut32  id  )

static

Definition at line 885 of file cfile.c.

                                                                           {
    rz_return_val_if_fail(ld && desc, false);
    RzBinFile *bf = rz_bin_file_find_by_fd(ld->bin, desc->fd);
    if (!bf) {
        return true;
    }
    RzListIter *iter;
    RzBinSymbol *sym;
    RzList *symbols = rz_bin_file_get_symbols(bf);
    rz_list_foreach (symbols, iter, sym) {
        if (!strcmp(sym->name, ld->name)) {
            ld->addr = sym->vaddr;
            return false;
        }
    }
    return true;
}

References RzCoreLinkData::addr, RzCoreLinkData::bin, desc, RzCoreLinkData::name, rz_bin_symbol_t::name, rz_bin_file_find_by_fd(), rz_bin_file_get_symbols(), rz_return_val_if_fail, symbols(), and rz_bin_symbol_t::vaddr.

Referenced by rz_core_bin_load().

rz_core_bin_load()

RZ_API bool rz_core_bin_load	(	RZ_NONNULL RzCore *	r,
		RZ_NULLABLE const char *	filenameuri,
		ut64	baddr
	)

Definition at line 942 of file cfile.c.

                                                                                                    {
    rz_return_val_if_fail(r, false);
 
    RzCoreFile *cf = rz_core_file_cur(r);
    RzIODesc *desc = cf ? rz_io_desc_get(r->io, cf->fd) : NULL;
    ut64 laddr = rz_config_get_i(r->config, "bin.laddr");
    RzBinFile *binfile = NULL;
    RzBinPlugin *plugin = NULL;
    bool is_io_load = false;
    const char *cmd_load;
    if (!cf) {
        return false;
    }
 
    is_io_load = desc && desc->plugin;
    if (desc && RZ_STR_ISEMPTY(filenameuri)) {
        filenameuri = desc->name;
    }
 
    if (RZ_STR_ISEMPTY(filenameuri)) {
        RZ_LOG_ERROR("rz_core_bin_load: no file specified\n");
        return false;
    }
 
    r->bin->minstrlen = rz_config_get_i(r->config, "bin.minstr");
    r->bin->maxstrbuf = rz_config_get_i(r->config, "bin.maxstrbuf");
    if (is_io_load) {
        // TODO? necessary to restore the desc back?
        // Fix to select pid before trying to load the binary
        if ((desc->plugin && desc->plugin->isdbg) || rz_config_get_b(r->config, "cfg.debug")) {
            core_file_do_load_for_debug(r, baddr, filenameuri);
        } else {
            core_file_do_load_for_io_plugin(r, baddr, 0LL);
            if (!strncmp(filenameuri, "apk://", 6) && r->io->files->size > 1) {
                RZ_LOG_INFO("Found multidex APK, mapping extra files\n");
                rz_id_storage_foreach(r->io->files, (RzIDStorageForeachCb)map_multi_dex, r);
                // forbid loading libraries even when set.
                rz_config_set_b(r->config, "bin.libs", false);
            }
        }
        // Restore original desc
        rz_io_use_fd(r->io, desc->fd);
    }
    binfile = rz_bin_cur(r->bin);
    if (cf && binfile && desc) {
        binfile->fd = desc->fd;
    }
    // rz_core_bin_apply_all_info (r, binfile);
    plugin = rz_bin_file_cur_plugin(binfile);
    if (plugin) {
        if (plugin->strfilter) {
            char msg[2];
            msg[0] = plugin->strfilter;
            msg[1] = 0;
            rz_config_set(r->config, "bin.str.filter", msg);
        }
        if (plugin->name) {
            load_scripts_for(r, plugin->name);
        }
    }
 
    cmd_load = rz_config_get(r->config, "cmd.load");
    if (cmd_load && *cmd_load) {
        rz_core_cmd(r, cmd_load, 0);
    }
 
    if (plugin && plugin->name) {
        if (!strcmp(plugin->name, "any")) {
            if (rz_str_startswith(desc->name, "rap") && strstr(desc->name, "://")) {
                rz_io_map_new(r->io, desc->fd, desc->perm, 0, laddr, UT64_MAX);
            } else {
                rz_io_map_new(r->io, desc->fd, desc->perm, 0, laddr, rz_io_desc_size(desc));
            }
            // set use of raw strings
            // rz_config_set_i (r->config, "io.va", false);
            // get bin.minstr
            r->bin->minstrlen = rz_config_get_i(r->config, "bin.minstr");
            r->bin->maxstrbuf = rz_config_get_i(r->config, "bin.maxstrbuf");
        } else if (binfile) {
            RzBinObject *obj = rz_bin_cur_object(r->bin);
            if (obj) {
                bool va = obj->info ? obj->info->has_va : 0;
                if (!va) {
                    rz_config_set_i(r->config, "io.va", 0);
                }
                // workaround to map correctly malloc:// and raw binaries
                if (rz_io_desc_is_dbg(desc) || (!obj->maps || !va)) {
                    rz_io_map_new(r->io, desc->fd, desc->perm, 0, laddr, rz_io_desc_size(desc));
                }
                RzBinInfo *info = obj->info;
                if (info) {
                    rz_core_bin_set_arch_bits(r, binfile->file, info->arch, info->bits);
                } else {
                    rz_core_bin_set_arch_bits(r, binfile->file,
                        rz_config_get(r->config, "asm.arch"),
                        rz_config_get_i(r->config, "asm.bits"));
                }
            }
        }
    } else {
        if (desc) {
            rz_io_map_new(r->io, desc->fd, desc->perm, 0, laddr, rz_io_desc_size(desc));
        }
        if (binfile) {
            ut16 bits = rz_config_get_i(r->config, "asm.bits");
            const char *arch = rz_config_get(r->config, "asm.arch");
            rz_core_bin_set_arch_bits(r, binfile->file, arch, bits);
        }
    }
    if (desc && rz_config_get_i(r->config, "io.exec")) {
        desc->perm |= RZ_PERM_X;
    }
    if (!rz_config_get_b(r->config, "cfg.debug")) {
        loadGP(r);
    }
    if (rz_config_get_b(r->config, "bin.libs")) {
        const char *lib;
        RzListIter *iter;
        RzList *libs = rz_bin_get_libs(r->bin);
        rz_list_foreach (libs, iter, lib) {
            if (file_is_loaded(r, lib)) {
                continue;
            }
            RZ_LOG_INFO("Opening library %s\n", lib);
            ut64 baddr = rz_io_map_location(r->io, 0x200000);
            if (baddr != UT64_MAX) {
                rz_core_file_loadlib(r, lib, baddr);
            }
        }
 
        rz_core_bin_raise(r, 0);
        ut64 ocurr = r->offset;
        ut64 entry0addr = rz_num_math(r->num, "entry0");
        rz_core_seek(r, entry0addr, true);
 
        rz_config_set_b(r->config, "bin.at", true);
        RZ_LOG_INFO("Linking imports...\n");
        RzBinImport *imp;
        RzList *imports = rz_bin_get_imports(r->bin);
        rz_list_foreach (imports, iter, imp) {
            char *name = rz_str_newf("sym.imp.%s", imp->name);
            rz_name_filter(name + 8, strlen(name + 8) + 1, true);
 
            RzFlagItem *flag = rz_flag_get(r->flags, name);
            if (!flag) {
                // RZ_LOG_DEBUG("Cannot find flag %s\n", name);
                free(name);
                continue;
            }
            ut64 imp_addr = flag->offset;
            RzCoreLinkData linkdata = { imp->name, UT64_MAX, r->bin };
            rz_id_storage_foreach(r->io->files, (RzIDStorageForeachCb)resolve_import_cb, &linkdata);
            if (linkdata.addr != UT64_MAX) {
                RZ_LOG_INFO("Resolved %s with address 0x%08" PFMT64x "\n", name, linkdata.addr);
                ut64 a = linkdata.addr;
                ut64 b = imp_addr;
                rz_analysis_xrefs_set(r->analysis, b, a, RZ_ANALYSIS_XREF_TYPE_NULL);
            } else {
                RZ_LOG_ERROR("Cannot resolve %s\n", name);
            }
            free(name);
        }
        rz_core_seek(r, ocurr, true);
    }
 
    // If type == RZ_BIN_TYPE_CORE, we need to create all the maps
    if (plugin && binfile && plugin->file_type && plugin->file_type(binfile) == RZ_BIN_TYPE_CORE) {
        // Setting the right arch and bits, so regstate will be shown correctly
        if (plugin->info) {
            RzBinInfo *inf = plugin->info(binfile);
            RZ_LOG_INFO("Setting up coredump arch-bits to: %s-%d\n", inf->arch, inf->bits);
            rz_config_set(r->config, "asm.arch", inf->arch);
            rz_config_set_i(r->config, "asm.bits", inf->bits);
            rz_bin_info_free(inf);
        }
        if (binfile->o->regstate) {
            if (rz_reg_arena_set_bytes(r->analysis->reg, binfile->o->regstate)) {
                RZ_LOG_WARN("Setting up coredump: Problem while setting the registers\n");
            } else {
                RZ_LOG_INFO("Setting up coredump: Registers have been set\n");
            }
        }
    }
    return true;
}

References a, RzCoreLinkData::addr, rz_bin_info_t::arch, arch, b, baddr(), rz_bin_info_t::bits, bits(), core_file_do_load_for_debug(), core_file_do_load_for_io_plugin(), desc, rz_bin_file_t::fd, rz_core_file_t::fd, rz_bin_file_t::file, file_is_loaded(), rz_bin_plugin_t::file_type, free(), rz_bin_info_t::has_va, imports(), inf(), info(), rz_bin_object_t::info, rz_bin_plugin_t::info, libs(), load_scripts_for(), loadGP(), map_multi_dex(), rz_bin_object_t::maps, msg, rz_bin_plugin_t::name, rz_bin_import_t::name, NULL, rz_bin_file_t::o, rz_flag_item_t::offset, PFMT64x, r, rz_bin_object_t::regstate, resolve_import_cb(), RZ_ANALYSIS_XREF_TYPE_NULL, rz_analysis_xrefs_set(), rz_bin_cur(), rz_bin_cur_object(), rz_bin_file_cur_plugin(), rz_bin_get_imports(), rz_bin_get_libs(), rz_bin_info_free(), RZ_BIN_TYPE_CORE, rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set(), rz_config_set_b(), rz_config_set_i(), rz_core_bin_raise(), rz_core_bin_set_arch_bits(), rz_core_cmd(), rz_core_file_cur(), rz_core_file_loadlib(), rz_core_seek(), rz_flag_get(), rz_id_storage_foreach(), rz_io_desc_get(), rz_io_desc_is_dbg(), rz_io_desc_size(), rz_io_map_location(), rz_io_map_new(), rz_io_use_fd(), RZ_LOG_ERROR, RZ_LOG_INFO, RZ_LOG_WARN, rz_name_filter(), rz_num_math(), RZ_PERM_X, rz_reg_arena_set_bytes(), rz_return_val_if_fail, RZ_STR_ISEMPTY, rz_str_newf(), rz_str_startswith(), rz_bin_plugin_t::strfilter, ut64(), and UT64_MAX.

Referenced by open_core_file(), rz_core_file_open_load(), rz_core_file_open_many(), rz_core_file_reopen(), rz_core_file_reopen_remote_debug(), rz_core_io_file_open(), rz_core_rtr_gdb_run(), rz_core_serve(), rz_diff_load_file_with_core(), rz_main_rizin(), rz_main_rz_sign(), rz_open_malloc_handler(), try_load_file(), and try_loadlib().

rz_core_bin_rebase()

RZ_API int rz_core_bin_rebase	(	RzCore *	core,
		ut64	baddr
	)

Definition at line 822 of file cfile.c.

                                                        {
    if (!core || !core->bin || !core->bin->cur) {
        return 0;
    }
    if (baddr == UT64_MAX) {
        return 0;
    }
    RzBinFile *bf = core->bin->cur;
    bf->o->opts.baseaddr = baddr;
    bf->o->opts.loadaddr = baddr;
    rz_bin_object_set_items(bf, bf->o);
    return 1;
}

References baddr(), rz_bin_file_load_options_t::baseaddr, rz_core_t::bin, __rebase_struct::core, rz_bin_t::cur, rz_bin_file_load_options_t::loadaddr, rz_bin_file_t::o, rz_bin_object_t::opts, rz_bin_object_set_items(), and UT64_MAX.

Referenced by rz_open_binary_rebase_handler().

rz_core_file_bin_file_deleted()

RZ_IPI void rz_core_file_bin_file_deleted	(	RzCore *	core,
		RzBinFile *	bf
	)

Definition at line 1290 of file cfile.c.

                                                                       {
    // remove all references to the deleted binfile
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->binfiles, bf);
    }
}

References rz_core_file_t::binfiles, rz_core_t::files, and rz_pvector_remove_data().

Referenced by ev_binfiledel_cb().

rz_core_file_bin_raise()

RZ_API bool rz_core_file_bin_raise	(	RzCore *	core,
		ut32	bfid
	)

Definition at line 1451 of file cfile.c.

                                                            {
    RzBin *bin = core->bin;
    RzBinFile *bf = rz_list_get_n(bin->binfiles, bfid);
    bool res = false;
    if (bf) {
        res = rz_bin_file_set_cur_binfile(bin, bf);
        if (res) {
            rz_io_use_fd(core->io, bf->fd);
        }
        res = res ? rz_core_file_set_by_fd(core, bf->fd) : res;
    }
    return res;
}

References rz_core_t::bin, rz_bin_file_t::fd, rz_core_t::io, rz_bin_file_set_cur_binfile(), rz_core_file_set_by_fd(), rz_io_use_fd(), and rz_list_get_n().

rz_core_file_binlist()

RZ_API int rz_core_file_binlist

(

RzCore *

core

)

Definition at line 1465 of file cfile.c.

                                              {
    int count = 0;
    RzListIter *iter;
    RzCoreFile *cur_cf = core->file, *cf = NULL;
    RzBinFile *binfile = NULL;
    RzIODesc *desc;
    RzBin *bin = core->bin;
    const RzList *binfiles = bin ? bin->binfiles : NULL;
 
    if (!binfiles) {
        return false;
    }
    rz_list_foreach (binfiles, iter, binfile) {
        int fd = binfile->fd;
        cf = rz_core_file_get_by_fd(core, fd);
        desc = rz_io_desc_get(core->io, fd);
        if (cf) {
            rz_cons_printf("%c %d %s ; %s\n",
                core->io->desc == desc ? '*' : '-',
                fd, desc->uri, desc->perm & RZ_PERM_W ? "rw" : "r");
        }
    }
    rz_core_file_set_by_file(core, cur_cf);
    // rz_core_bin_bind (core, cur_bf);
    return count;
}

References rz_core_t::bin, count, desc, rz_io_t::desc, fd, rz_bin_file_t::fd, rz_core_t::file, rz_core_t::io, NULL, rz_cons_printf(), rz_core_file_get_by_fd(), rz_core_file_set_by_file(), rz_io_desc_get(), and RZ_PERM_W.

rz_core_file_close()

RZ_API void rz_core_file_close

(

RzCoreFile *

fh

)

Definition at line 1299 of file cfile.c.

                                               {
    rz_return_if_fail(fh && fh->core);
    RzCore *r = fh->core;
    RzListIter *fh_it = rz_list_find_ptr(r->files, fh);
    rz_return_if_fail(fh_it);
    RzIODesc *desc = rz_io_desc_get(r->io, fh->fd);
    if (desc) {
        rz_io_desc_close(desc);
    }
    while (!rz_pvector_empty(&fh->maps)) {
        // The element will automatically be removed from the vector through events
        // always delete the last to avoid unnecessary copies
        RzIOMap *map = rz_pvector_at(&fh->maps, rz_pvector_len(&fh->maps) - 1);
        rz_io_map_del(r->io, map->id);
    }
    while (!rz_pvector_empty(&fh->extra_files)) {
        // same as for maps above
        rz_io_desc_close(rz_pvector_at(&fh->extra_files, rz_pvector_len(&fh->extra_files) - 1));
    }
    while (!rz_pvector_empty(&fh->binfiles)) {
        // same as for maps above
        rz_bin_file_delete(r->bin, rz_pvector_at(&fh->binfiles, rz_pvector_len(&fh->binfiles) - 1));
    }
    if (r->file == fh) {
        r->file = NULL;
    }
    rz_list_delete(r->files, fh_it);
}

References desc, fh, map(), NULL, r, rz_bin_file_delete(), rz_io_desc_close(), rz_io_desc_get(), rz_io_map_del(), rz_list_delete(), rz_list_find_ptr(), rz_pvector_at(), rz_pvector_empty(), rz_pvector_len(), and rz_return_if_fail.

Referenced by rz_core_file_close_fd(), rz_core_file_reopen(), and rz_main_rz_bin().

rz_core_file_close_all_but()

RZ_API bool rz_core_file_close_all_but

(

RzCore *

core

)

Definition at line 1505 of file cfile.c.

                                                     {
    rz_id_storage_foreach(core->io->files, close_but_cb, core);
    return true;
}

References close_but_cb(), rz_io_t::files, rz_core_t::io, and rz_id_storage_foreach().

Referenced by rz_core_file_reopen().

rz_core_file_close_fd()

RZ_API bool rz_core_file_close_fd	(	RzCore *	core,
		int	fd
	)

Definition at line 1510 of file cfile.c.

                                                        {
    RzCoreFile *file;
    RzListIter *iter;
    if (fd == -1) {
        while (!rz_list_empty(core->files)) {
            rz_core_file_close(rz_list_first(core->files));
        }
        return true;
    }
    rz_list_foreach (core->files, iter, file) {
        if (file->fd == fd) {
            rz_core_file_close(file);
            return true;
        }
    }
    return rz_io_fd_close(core->io, fd);
}

References fd, file::fd, file, rz_core_t::files, rz_core_t::io, rz_core_file_close(), rz_io_fd_close(), and rz_list_first().

Referenced by __close_file_cb(), close_but_cb(), file_load(), rz_open_close_all_handler(), and rz_open_close_handler().

rz_core_file_cur()

RZ_API RzCoreFile* rz_core_file_cur

(

RzCore *

r

)

Definition at line 1591 of file cfile.c.

                                               {
    // Add any locks here
    return r->file;
}

References r.

Referenced by core_bin_reload(), core_file_do_load_for_debug(), core_file_do_load_for_io_plugin(), map_multi_dex(), and rz_core_bin_load().

rz_core_file_cur_fd()

RZ_API ut32 rz_core_file_cur_fd

(

RzCore *

core

)

Definition at line 1584 of file cfile.c.

                                              {
    if (core && core->file) {
        return core->file->fd;
    }
    return UT32_MAX;
}

References rz_core_file_t::fd, rz_core_t::file, and UT32_MAX.

Referenced by rz_core_bin_set_cur().

rz_core_file_find_by_fd()

RZ_API RzCoreFile* rz_core_file_find_by_fd	(	RzCore *	core,
		ut64	fd
	)

Definition at line 1528 of file cfile.c.

                                                                  {
    RzListIter *iter;
    RzCoreFile *cf = NULL;
    rz_list_foreach (core->files, iter, cf) {
        if (cf && cf->fd == fd) {
            break;
        }
        cf = NULL;
    }
    return cf;
}

References fd, rz_core_file_t::fd, rz_core_t::files, and NULL.

Referenced by rz_core_bin_apply_maps().

rz_core_file_find_by_name()

RZ_API RzCoreFile* rz_core_file_find_by_name	(	RzCore *	core,
		const char *	name
	)

Definition at line 1540 of file cfile.c.

                                                                             {
    RzListIter *iter;
    RzCoreFile *cf = NULL;
    RzIODesc *desc;
 
    if (!core) {
        return NULL;
    }
 
    rz_list_foreach (core->files, iter, cf) {
        desc = rz_io_desc_get(core->io, cf->fd);
        if (desc && !strcmp(desc->name, name)) {
            break;
        }
        cf = NULL;
    }
    return cf;
}

References desc, rz_core_file_t::fd, rz_core_t::files, rz_core_t::io, NULL, and rz_io_desc_get().

Referenced by rz_core_file_set_by_name().

rz_core_file_free()

RZ_IPI void rz_core_file_free

(

RzCoreFile *

cf

)

Definition at line 26 of file cfile.c.

                                              {
    if (!cf) {
        return;
    }
    rz_pvector_fini(&cf->binfiles);
    rz_pvector_fini(&cf->extra_files);
    rz_pvector_fini(&cf->maps);
    free(cf);
}

References rz_core_file_t::binfiles, rz_core_file_t::extra_files, free(), rz_core_file_t::maps, and rz_pvector_fini().

Referenced by rz_core_init().

rz_core_file_get_by_fd()

RZ_API RzCoreFile* rz_core_file_get_by_fd	(	RzCore *	core,
		int	fd
	)

Definition at line 1328 of file cfile.c.

                                                                {
    RzCoreFile *file;
    RzListIter *iter;
    rz_list_foreach (core->files, iter, file) {
        if (file->fd == fd) {
            return file;
        }
    }
    return NULL;
}

References fd, file::fd, file, rz_core_t::files, and NULL.

Referenced by rz_core_file_binlist().

rz_core_file_io_desc_closed()

RZ_IPI void rz_core_file_io_desc_closed	(	RzCore *	core,
		RzIODesc *	desc
	)

Definition at line 1271 of file cfile.c.

                                                                      {
    // remove all references to the closed desc
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->extra_files, desc);
    }
}

References desc, rz_core_file_t::extra_files, rz_core_t::files, and rz_pvector_remove_data().

Referenced by ev_iodescclose_cb().

rz_core_file_io_map_deleted()

RZ_IPI void rz_core_file_io_map_deleted	(	RzCore *	core,
		RzIOMap *	map
	)

Definition at line 1280 of file cfile.c.

                                                                    {
    // remove all references to the deleted map
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->maps, map);
    }
    rz_core_io_map_info_free(map->user);
}

References rz_core_t::files, map(), rz_core_file_t::maps, rz_core_io_map_info_free(), and rz_pvector_remove_data().

Referenced by ev_iomapdel_cb().

rz_core_file_loadlib()

RZ_API bool rz_core_file_loadlib	(	RzCore *	core,
		const char *	lib,
		ut64	libaddr
	)

Definition at line 777 of file cfile.c.

                                                                              {
    const char *dirlibs = rz_config_get(core->config, "dir.libs");
    char *libdir = rz_path_libdir();
    if (!dirlibs || !*dirlibs) {
        dirlibs = "." RZ_SYS_DIR;
    }
    const char *ldlibrarypath[] = {
        dirlibs,
        libdir,
#ifndef __WINDOWS__
        "/usr/local/lib",
        "/usr/lib",
        "/lib",
#endif
        "." RZ_SYS_DIR,
        NULL
    };
    const char **libpath = (const char **)&ldlibrarypath;
 
    bool ret = false;
#ifdef __WINDOWS__
    if (strlen(lib) >= 3 && lib[1] == ':' && lib[2] == '\\') {
#else
    if (*lib == '/') {
#endif
        if (try_loadlib(core, lib, libaddr)) {
            ret = true;
        }
    } else {
        while (*libpath) {
            char *s = rz_str_newf("%s" RZ_SYS_DIR "%s", *libpath, lib);
            if (try_loadlib(core, s, libaddr)) {
                ret = true;
            }
            free(s);
            if (ret) {
                break;
            }
            libpath++;
        }
    }
    free(libdir);
    return ret;
}

References rz_core_t::config, __rebase_struct::core, free(), NULL, rz_config_get(), rz_path_libdir(), rz_str_newf(), RZ_SYS_DIR, s, and try_loadlib().

Referenced by rz_core_bin_load().

rz_core_file_open()

RZ_API RZ_BORROW RzCoreFile* rz_core_file_open	(	RZ_NONNULL RzCore *	r,
		RZ_NONNULL const char *	file,
		int	flags,
		ut64	loadaddr
	)

Tries to open the file as is, otherwise tries as is a compilation of files.

Calls rz_io_open_nomap but if it fails, then tries with rz_core_file_open_many; Also, loadaddr is rizin -m (mapaddr)

Definition at line 1182 of file cfile.c.

                                                                                                                            {
    rz_return_val_if_fail(r && file, NULL);
    ut64 prev = rz_time_now_mono();
    const bool openmany = rz_config_get_i(r->config, "file.openmany");
    RzCoreFile *fh = NULL;
 
    if (!strcmp(file, "=")) {
        file = "malloc://512";
    }
    // if not flags was passed open it with -r--
    if (!flags) {
        flags = RZ_PERM_R;
    }
    r->io->bits = r->rasm->bits; // TODO: we need an api for this
    RzIODesc *fd = rz_io_open_nomap(r->io, file, flags, 0644);
    if (rz_cons_is_breaked()) {
        goto beach;
    }
    if (!fd && openmany) {
        if (!(fh = rz_core_file_open_many(r, file, flags, loadaddr))) {
            goto beach;
        }
        fd = rz_io_desc_get(r->io, fh->fd);
    }
    if (!fd) {
        if (flags & RZ_PERM_W) {
            //  flags |= RZ_IO_CREAT;
            if (!(fd = rz_io_open_nomap(r->io, file, flags, 0644))) {
                goto beach;
            }
        } else {
            goto beach;
        }
    }
    if (rz_io_is_listener(r->io)) {
        rz_core_serve(r, fd);
        rz_io_desc_free(fd);
        goto beach;
    }
 
    if (!fh) {
        fh = core_file_new(r, fd->fd);
        if (!fh) {
            RZ_LOG_ERROR("rz_core_file_open: failed to allocate RzCoreFile.\n");
            goto beach;
        }
    }
    {
        const char *cp = rz_config_get(r->config, "cmd.open");
        if (cp && *cp) {
            rz_core_cmd(r, cp, 0);
        }
        char *absfile = rz_file_abspath(file);
        rz_config_set(r->config, "file.path", absfile);
        free(absfile);
    }
 
    r->file = fh;
    rz_io_use_fd(r->io, fd->fd);
 
    if (!rz_list_find_ptr(r->files, fh)) {
        rz_list_append(r->files, fh);
    }
    if (rz_config_get_b(r->config, "cfg.debug")) {
        bool swstep = true;
        if (r->dbg->cur && r->dbg->cur->canstep) {
            swstep = false;
        }
        rz_config_set_i(r->config, "dbg.swstep", swstep);
        // Set the correct debug handle
        if (fd->plugin && fd->plugin->isdbg) {
            char *dh = rz_str_ndup(file, (strstr(file, "://") - file));
            if (dh) {
                rz_debug_use(r->dbg, dh);
                free(dh);
            }
        }
    }
    // used by rz_core_bin_load otherwise won't load correctly
    // this should be argument of rz_core_bin_load <shrug>
    if (loadaddr != UT64_MAX) {
        rz_config_set_i(r->config, "bin.laddr", loadaddr);
    }
    rz_core_cmd0(r, "R!");
beach:
    r->times->file_open_time = rz_time_now_mono() - prev;
    return fh;
}

References core_file_new(), fd, fh, flags, free(), NULL, r, rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set(), rz_config_set_i(), rz_cons_is_breaked(), rz_core_cmd(), rz_core_cmd0(), rz_core_file_open_many(), rz_core_serve(), rz_debug_use(), rz_file_abspath(), rz_io_desc_free(), rz_io_desc_get(), rz_io_is_listener(), rz_io_open_nomap(), rz_io_use_fd(), rz_list_append(), rz_list_find_ptr(), RZ_LOG_ERROR, RZ_PERM_R, RZ_PERM_W, rz_return_val_if_fail, rz_str_ndup(), rz_time_now_mono(), ut64(), and UT64_MAX.

Referenced by open_core_file(), rz_core_file_open_load(), rz_core_file_reopen(), rz_core_file_reopen_remote_debug(), rz_core_io_file_open(), rz_core_rtr_gdb_run(), rz_core_serve(), rz_diff_load_file_with_core(), rz_main_rizin(), rz_main_rz_bin(), rz_main_rz_sign(), rz_open_malloc_handler(), try_load_file(), and try_loadlib().

rz_core_file_open_load()

RZ_API bool rz_core_file_open_load	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const char *	filepath,
		ut64	addr,
		int	perms,
		bool	write_mode
	)

Tries to open the file, load binary info and make RzIOMap.

Returns

Success?

Definition at line 189 of file cfile.c.

                                                                                                                                    {
    rz_return_val_if_fail(core && filepath, false);
    RzCoreFile *cfile = rz_core_file_open(core, filepath, perms, addr);
    if (!cfile) {
        RZ_LOG_ERROR("Cannot open file '%s'\n", filepath);
        return false;
    }
 
    core->num->value = cfile->fd;
    if (addr == 0) { // if no baddr defined, use the one provided by the file
        addr = UT64_MAX;
    }
    if (!rz_core_bin_load(core, filepath, addr)) {
        RZ_LOG_ERROR("Cannot load binary info of '%s'.\n", filepath);
        return false;
    }
    if (write_mode) {
        RzIODesc *desc = rz_io_desc_get(core->io, cfile->fd);
        if (!desc || !(desc->perm & RZ_PERM_W)) {
            RZ_LOG_WARN("Cannot make maps for %s writable.\n", filepath);
            return false;
        }
        void **it;
        rz_pvector_foreach (&cfile->maps, it) {
            RzIOMap *map = *it;
            map->perm |= RZ_PERM_WX;
        }
    }
 
    rz_core_block_read(core);
    return true;
}

References addr, benchmark::cfile, __rebase_struct::core, desc, rz_core_t::io, map(), rz_core_t::num, rz_core_bin_load(), rz_core_block_read(), rz_core_file_open(), rz_io_desc_get(), RZ_LOG_ERROR, RZ_LOG_WARN, RZ_PERM_W, RZ_PERM_WX, rz_pvector_foreach, rz_return_val_if_fail, UT64_MAX, and rz_num_t::value.

Referenced by rz_open_handler(), and rz_open_write_handler().

rz_core_file_open_many()

RZ_API RZ_BORROW RzCoreFile* rz_core_file_open_many	(	RZ_NONNULL RzCore *	r,
		RZ_NULLABLE const char *	file,
		int	perm,
		ut64	base_address
	)

Open the file as a compilation of files.

Calls rz_io_open_many and maps all the file descriptors to an RzCoreFile

Definition at line 1133 of file cfile.c.

                                                                                                                                     {
    RzList *list_fds = rz_io_open_many(r->io, file, perm, 0644);
 
    if (rz_list_empty(list_fds)) {
        rz_list_free(list_fds);
        return NULL;
    }
 
    if (!base_address) {
        base_address = RZ_CORE_BASE_ADDRESS_DEFAULT;
    }
 
    RzListIter *it = NULL;
    RzIODesc *desc = NULL;
    RzIODesc *first = NULL;
    rz_list_foreach (list_fds, it, desc) {
        if (!rz_io_desc_add(r->io, desc)) {
            rz_io_desc_free(desc);
            continue;
        } else if (!first) {
            first = desc;
        }
 
        RzCoreFile *fh = core_file_new(r, desc->fd);
        if (!fh) {
            continue;
        }
        r->file = fh;
        rz_list_append(r->files, fh);
        ut64 size = rz_io_desc_size(desc);
        RZ_LOG_INFO("Mapping at 0x%08" PFMT64x " with size 0x08%" PFMT64x " %s\n", base_address, size, desc->name);
        if (!rz_core_bin_load(r, desc->name, base_address)) {
            RZ_LOG_ERROR("failed to load %s\n", desc->name);
        }
        // adds the current size and aligns next address
        base_address += size;
        rz_core_align_base_address(base_address);
    }
 
    rz_list_free(list_fds);
    return rz_list_first(r->files);
}

References core_file_new(), desc, fh, NULL, PFMT64x, r, rz_core_align_base_address, RZ_CORE_BASE_ADDRESS_DEFAULT, rz_core_bin_load(), rz_io_desc_add(), rz_io_desc_free(), rz_io_desc_size(), rz_io_open_many(), rz_list_append(), rz_list_first(), rz_list_free(), RZ_LOG_ERROR, RZ_LOG_INFO, and ut64().

Referenced by rz_core_file_open().

rz_core_file_print()

RZ_API bool rz_core_file_print	(	RzCore *	core,
		RzOutputMode	mode
	)

Definition at line 1372 of file cfile.c.

                                                                {
    int count = 0;
    RzCoreFile *f;
    RzIODesc *desc;
    ut64 from;
    RzListIter *it;
    RzBinFile *bf;
    RzListIter *iter;
    PJ *pj = NULL;
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj = pj_new();
        if (!pj) {
            return false;
        }
        pj_a(pj);
    }
    rz_list_foreach (core->files, iter, f) {
        desc = rz_io_desc_get(core->io, f->fd);
        if (!desc) {
            // cannot find desc for this fd, RzCoreFile inconsistency!!!1
            continue;
        }
        from = 0LL;
        switch (mode) {
        case RZ_OUTPUT_MODE_JSON: { // "oij"
            pj_o(pj);
            pj_kb(pj, "raised", core->io->desc->fd == f->fd);
            pj_ki(pj, "fd", f->fd);
            pj_ks(pj, "uri", desc->uri);
            pj_kn(pj, "from", (ut64)from);
            pj_kb(pj, "writable", desc->perm & RZ_PERM_W);
            pj_ki(pj, "size", (int)rz_io_desc_size(desc));
            pj_end(pj);
            break;
        }
        case RZ_OUTPUT_MODE_RIZIN:
            // TODO: use a getter
            {
                bool fileHaveBin = false;
                char *absfile = rz_file_abspath(desc->uri);
                rz_list_foreach (core->bin->binfiles, it, bf) {
                    if (bf->fd == f->fd) {
                        rz_cons_printf("o %s 0x%" PFMT64x "\n", absfile, (ut64)from);
                        fileHaveBin = true;
                    }
                }
                if (!fileHaveBin && !strstr(absfile, "://")) {
                    rz_cons_printf("o %s 0x%" PFMT64x "\n", absfile, (ut64)from);
                }
                free(absfile);
            }
            break;
        default: {
            ut64 sz = rz_io_desc_size(desc);
            const char *fmt;
            if (sz == UT64_MAX) {
                fmt = "%c %d %d %s @ 0x%" PFMT64x " ; %s size=%" PFMT64d "\n";
            } else {
                fmt = "%c %d %d %s @ 0x%" PFMT64x " ; %s size=%" PFMT64u "\n";
            }
            rz_cons_printf(fmt,
                core->io->desc->fd == f->fd ? '*' : '-',
                count,
                (int)f->fd, desc->uri, (ut64)from,
                desc->perm & RZ_PERM_W ? "rw" : "r",
                rz_io_desc_size(desc));
        } break;
        }
        count++;
    }
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        rz_cons_println(pj_string(pj));
        pj_free(pj);
    }
    return true;
}

References rz_core_t::bin, rz_bin_t::binfiles, count, desc, rz_io_t::desc, f, rz_bin_file_t::fd, rz_io_desc_t::fd, rz_core_t::files, free(), from, rz_core_t::io, NULL, PFMT64d, PFMT64u, PFMT64x, pj_a(), pj_end(), pj_free(), pj_kb(), pj_ki(), pj_kn(), pj_ks(), pj_new(), pj_o(), pj_string(), rz_cons_printf(), rz_cons_println(), rz_file_abspath(), rz_io_desc_get(), rz_io_desc_size(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_RIZIN, RZ_PERM_W, ut64(), and UT64_MAX.

rz_core_file_reopen()

RZ_API bool rz_core_file_reopen	(	RzCore *	core,
		const char *	args,
		int	perm,
		int	loadbin
	)

Definition at line 322 of file cfile.c.

                                                                                       {
    int isdebug = rz_config_get_b(core->config, "cfg.debug");
    char *path;
    ut64 laddr = rz_config_get_i(core->config, "bin.laddr");
    RzCoreFile *file = NULL;
    RzCoreFile *ofile = core->file;
    RzBinFile *bf = ofile ? rz_bin_file_find_by_fd(core->bin, ofile->fd)
                  : NULL;
    RzIODesc *odesc = (core->io && ofile) ? rz_io_desc_get(core->io, ofile->fd) : NULL;
    char *ofilepath = NULL, *obinfilepath = (bf && bf->file) ? strdup(bf->file) : NULL;
    int ret = false;
    ut64 origoff = core->offset;
    if (odesc) {
        if (odesc->referer) {
            ofilepath = odesc->referer;
        } else if (odesc->uri) {
            ofilepath = odesc->uri;
        }
    }
 
    ut64 new_baddr = UT64_MAX;
    if (args) {
        new_baddr = rz_num_math(core->num, args);
        if (new_baddr && new_baddr != UT64_MAX) {
            rz_config_set_i(core->config, "bin.baddr", new_baddr);
        } else {
            new_baddr = UT64_MAX;
        }
    }
    if (new_baddr == UT64_MAX) {
        new_baddr = rz_config_get_i(core->config, "bin.baddr");
    }
 
    if (!core->file) {
        RZ_LOG_ERROR("No file opened to reopen\n");
        free(ofilepath);
        free(obinfilepath);
        return false;
    }
    int newpid = odesc ? odesc->fd : -1;
 
    if (isdebug) {
        rz_debug_kill(core->dbg, core->dbg->pid, core->dbg->tid, 9); // SIGKILL
        do {
            rz_debug_continue(core->dbg);
        } while (!rz_debug_is_dead(core->dbg));
        rz_debug_detach(core->dbg, core->dbg->pid);
        perm = 7;
    } else {
        if (!perm) {
            perm = 4; // RZ_PERM_R;
        }
    }
    if (!ofilepath) {
        RZ_LOG_ERROR("Unknown file path");
        free(obinfilepath);
        return false;
    }
 
    // HACK: move last mapped address to higher place
    // XXX - why does this hack work?
    // when the new memory maps are created.
    path = strdup(ofilepath);
    free(obinfilepath);
    obinfilepath = strdup(ofilepath);
 
    // rz_str_trim (path);
    file = rz_core_file_open(core, path, perm, laddr);
 
    if (isdebug) {
        int newtid = newpid;
        // XXX - select the right backend
        if (core->file) {
            newpid = rz_io_fd_get_pid(core->io, core->file->fd);
#if __linux__
            core->dbg->main_pid = newpid;
            newtid = newpid;
#else
            newtid = rz_io_fd_get_tid(core->io, core->file->fd);
#endif
        }
 
        // Reset previous pid and tid
        core->dbg->pid = -1;
        core->dbg->tid = -1;
        core->dbg->recoil_mode = RZ_DBG_RECOIL_NONE;
        memset(&core->dbg->reason, 0, sizeof(core->dbg->reason));
        // Reopen and attach
        rz_core_setup_debugger(core, "native", true);
        rz_debug_select(core->dbg, newpid, newtid);
    }
 
    if (file) {
        bool had_rbin_info = false;
 
        if (ofile && bf) {
            if (rz_bin_file_delete(core->bin, bf)) {
                had_rbin_info = true;
            }
        }
        rz_core_file_close(ofile);
        rz_core_file_set_by_file(core, file);
        ofile = NULL;
        odesc = NULL;
        //  core->file = file;
        RZ_LOG_ERROR("File %s reopened in %s mode\n", path,
            (perm & RZ_PERM_W) ? "read-write" : "read-only");
 
        if (loadbin && (loadbin == 2 || had_rbin_info)) {
            ut64 baddr;
            if (isdebug) {
                baddr = rz_debug_get_baddr(core->dbg, path);
            } else if (new_baddr != UT64_MAX) {
                baddr = new_baddr;
            } else {
                baddr = rz_config_get_i(core->config, "bin.baddr");
            }
            ret = rz_core_bin_load(core, obinfilepath, baddr);
            rz_core_bin_update_arch_bits(core);
            if (!ret) {
                RZ_LOG_ERROR("Error: Failed to reload rbin for: '%s'", path);
            }
            origoff = rz_num_math(core->num, "entry0");
        }
 
        if (core->bin->cur && core->io && rz_io_desc_get(core->io, file->fd) && !loadbin) {
            // force here NULL because is causing uaf look this better in future XXX @alvarofe
            core->bin->cur = NULL;
        }
        // close old file
    } else if (ofile) {
        RZ_LOG_ERROR("rz_core_file_reopen: Cannot reopen file: '%s' with perms 0x%x,"
                 " attempting to open read-only.\n",
            path, perm);
        // lower it down back
        // ofile = rz_core_file_open (core, path, RZ_PERM_R, addr);
        rz_core_file_set_by_file(core, ofile);
    } else {
        RZ_LOG_ERROR("Cannot reopen '%s'\n", path);
    }
    if (core->file) {
        rz_io_use_fd(core->io, core->file->fd);
        rz_core_block_read(core);
    }
    rz_core_seek(core, origoff, true);
    if (isdebug) {
        rz_core_debug_map_update_flags(core);
        rz_core_reg_update_flags(core);
        rz_core_seek_to_register(core, "PC", false);
    } else {
        loadGP(core);
    }
    // update analysis io bind
    rz_io_bind(core->io, &(core->analysis->iob));
    if (core->file && core->file->fd >= 0) {
        rz_core_file_close_all_but(core);
    }
    rz_core_file_close_all_but(core);
    // This is done to ensure that the file is correctly
    // loaded into the view
    free(obinfilepath);
    // free (ofilepath);
    free(path);
    return ret;
}

References rz_core_t::analysis, args, baddr(), rz_core_t::bin, rz_core_t::config, __rebase_struct::core, rz_bin_t::cur, rz_core_t::dbg, rz_core_file_t::fd, rz_io_desc_t::fd, file::fd, rz_bin_file_t::file, rz_core_t::file, free(), rz_core_t::io, rz_analysis_t::iob, loadGP(), rz_debug_t::main_pid, memset(), NULL, rz_core_t::num, rz_core_t::offset, ofile, path, rz_debug_t::pid, rz_debug_t::reason, rz_debug_t::recoil_mode, rz_io_desc_t::referer, rz_bin_file_delete(), rz_bin_file_find_by_fd(), rz_config_get_b(), rz_config_get_i(), rz_config_set_i(), rz_core_bin_load(), rz_core_bin_update_arch_bits(), rz_core_block_read(), rz_core_debug_map_update_flags(), rz_core_file_close(), rz_core_file_close_all_but(), rz_core_file_open(), rz_core_file_set_by_file(), rz_core_reg_update_flags(), rz_core_seek(), rz_core_seek_to_register(), rz_core_setup_debugger(), RZ_DBG_RECOIL_NONE, rz_debug_continue(), rz_debug_detach(), rz_debug_get_baddr(), rz_debug_is_dead(), rz_debug_kill(), rz_debug_select(), rz_io_bind(), rz_io_desc_get(), rz_io_fd_get_pid(), rz_io_fd_get_tid(), rz_io_use_fd(), RZ_LOG_ERROR, rz_num_math(), RZ_PERM_W, strdup(), rz_debug_t::tid, rz_io_desc_t::uri, ut64(), and UT64_MAX.

Referenced by reopen_nobin_headers(), rz_core_file_reopen_debug(), rz_reopen_binary_handler(), rz_reopen_nobin_handler(), and rz_reopen_nobin_write_handler().

rz_core_file_reopen_debug()

RZ_API void rz_core_file_reopen_debug	(	RzCore *	core,
		const char *	args
	)

Definition at line 269 of file cfile.c.

                                                                      {
    RzCoreFile *ofile = core->file;
    RzIODesc *desc;
 
    if (!ofile || !(desc = rz_io_desc_get(core->io, ofile->fd)) || !desc->uri) {
        RZ_LOG_ERROR("No file open?\n");
        return;
    }
 
    // Reopen the original file as read only since we can't open native debug while the
    // file is open with write permissions
    if (!(desc->plugin && desc->plugin->isdbg) && (desc->perm & RZ_PERM_W)) {
        RZ_LOG_ERROR("Cannot debug file (%s) with permissions set to 0x%x.\n"
                 "Reopening the original file in read-only mode.\n",
            desc->name, desc->perm);
        rz_io_reopen(core->io, ofile->fd, RZ_PERM_R, 644);
        desc = rz_io_desc_get(core->io, ofile->fd);
    }
 
    RzBinFile *bf = rz_bin_file_find_by_fd(core->bin, ofile->fd);
    char *binpath = (bf && bf->file) ? strdup(bf->file) : NULL;
    if (!binpath) {
        if (rz_file_exists(desc->name)) {
            binpath = strdup(desc->name);
        }
    }
    if (!binpath) {
        /* fallback to oo */
        rz_core_io_file_open(core, core->io->desc->fd);
        return;
    }
    core->dbg->main_arena_resolved = false;
    RzList *old_sections = __save_old_sections(core);
    ut64 old_base = core->bin->cur->o->baddr_shift;
    int bits = core->rasm->bits;
    char *bin_abspath = rz_file_abspath(binpath);
    char *escaped_path = rz_str_arg_escape(bin_abspath);
    char *newfile = rz_str_newf("dbg://%s %s", escaped_path, args);
    desc->uri = newfile;
    desc->referer = NULL;
    rz_config_set_i(core->config, "asm.bits", bits);
    rz_config_set_b(core->config, "cfg.debug", true);
    rz_core_file_reopen(core, newfile, 0, 2);
    if (rz_config_get_i(core->config, "dbg.rebase")) {
        __rebase_everything(core, old_sections, old_base);
    }
    rz_list_free(old_sections);
    rz_core_seek_to_register(core, "PC", false);
    free(bin_abspath);
    free(escaped_path);
    free(binpath);
}

References __rebase_everything(), __save_old_sections(), args, rz_bin_object_t::baddr_shift, rz_core_t::bin, rz_asm_t::bits, bits(), rz_core_t::config, __rebase_struct::core, rz_bin_t::cur, rz_core_t::dbg, desc, rz_io_t::desc, rz_io_desc_t::fd, rz_bin_file_t::file, rz_core_t::file, free(), rz_core_t::io, rz_debug_t::main_arena_resolved, NULL, rz_bin_file_t::o, ofile, __rebase_struct::old_base, __rebase_struct::old_sections, rz_core_t::rasm, rz_bin_file_find_by_fd(), rz_config_get_i(), rz_config_set_b(), rz_config_set_i(), rz_core_file_reopen(), rz_core_io_file_open(), rz_core_seek_to_register(), rz_file_abspath(), rz_file_exists(), rz_io_desc_get(), rz_io_reopen(), rz_list_free(), RZ_LOG_ERROR, RZ_PERM_R, RZ_PERM_W, rz_str_arg_escape(), rz_str_newf(), strdup(), and ut64().

Referenced by __reload_cb(), rz_core_rtr_gdb_run(), rz_reopen_debug_handler(), and rz_reopen_debug_rzrun_handler().

rz_core_file_reopen_remote_debug()

RZ_API void rz_core_file_reopen_remote_debug	(	RzCore *	core,
		const char *	uri,
		ut64	addr
	)

Definition at line 222 of file cfile.c.

                                                                                       {
    RzCoreFile *ofile = core->file;
    RzIODesc *desc;
    RzCoreFile *file;
    int fd;
 
    if (!ofile || !(desc = rz_io_desc_get(core->io, ofile->fd)) || !desc->uri) {
        RZ_LOG_ERROR("No file open?\n");
        return;
    }
 
    core->dbg->main_arena_resolved = false;
    RzList *old_sections = __save_old_sections(core);
    ut64 old_base = core->bin->cur->o->baddr_shift;
    int bits = core->rasm->bits;
    rz_config_set_i(core->config, "asm.bits", bits);
    rz_config_set_b(core->config, "cfg.debug", true);
    // Set referer as the original uri so we could return to it with `oo`
    desc->referer = desc->uri;
    desc->uri = strdup(uri);
 
    if ((file = rz_core_file_open(core, uri, RZ_PERM_R | RZ_PERM_W, addr))) {
        fd = file->fd;
        core->num->value = fd;
        // if no baddr is defined, use the one provided by the file
        if (addr == 0) {
            desc = rz_io_desc_get(core->io, file->fd);
            if (desc->plugin->isdbg) {
                addr = rz_debug_get_baddr(core->dbg, desc->name);
            } else {
                addr = rz_bin_get_baddr(core->bin);
            }
        }
        rz_core_bin_load(core, uri, addr);
    } else {
        RZ_LOG_ERROR("Cannot open file '%s'\n", uri);
        rz_list_free(old_sections);
        return;
    }
    rz_core_block_read(core);
    if (rz_config_get_i(core->config, "dbg.rebase")) {
        __rebase_everything(core, old_sections, old_base);
    }
    rz_list_free(old_sections);
    rz_core_seek_to_register(core, "PC", false);
}

References __rebase_everything(), __save_old_sections(), addr, rz_bin_object_t::baddr_shift, rz_core_t::bin, rz_asm_t::bits, bits(), rz_core_t::config, __rebase_struct::core, rz_bin_t::cur, rz_core_t::dbg, desc, fd, file::fd, file, rz_core_t::file, rz_core_t::io, rz_debug_t::main_arena_resolved, rz_core_t::num, rz_bin_file_t::o, ofile, __rebase_struct::old_base, __rebase_struct::old_sections, rz_core_t::rasm, rz_bin_get_baddr(), rz_config_get_i(), rz_config_set_b(), rz_config_set_i(), rz_core_bin_load(), rz_core_block_read(), rz_core_file_open(), rz_core_seek_to_register(), rz_debug_get_baddr(), rz_io_desc_get(), rz_list_free(), RZ_LOG_ERROR, RZ_PERM_R, RZ_PERM_W, strdup(), ut64(), and rz_num_t::value.

Referenced by rz_reopen_debug_file_handler().

rz_core_file_resize()

RZ_API bool rz_core_file_resize	(	RzCore *	core,
		ut64	newsize
	)

Definition at line 518 of file cfile.c.

                                                            {
    return file_resize(core, newsize, 0);
}

References __rebase_struct::core, and file_resize().

Referenced by rz_resize_handler().

rz_core_file_resize_delta()

RZ_API bool rz_core_file_resize_delta	(	RzCore *	core,
		st64	delta
	)

Definition at line 522 of file cfile.c.

                                                                {
    return file_resize(core, 0, delta);
}

References __rebase_struct::core, delta, and file_resize().

Referenced by insert_mode_enabled(), and resize_helper().

rz_core_file_set_by_fd()

RZ_API int rz_core_file_set_by_fd	(	RzCore *	core,
		ut64	fd
	)

Definition at line 1559 of file cfile.c.

                                                         {
    if (core) {
        rz_io_use_fd(core->io, fd);
        rz_core_bin_set_by_fd(core, fd);
        return true;
    }
    return false;
}

References fd, rz_core_t::io, rz_core_bin_set_by_fd(), and rz_io_use_fd().

Referenced by rz_core_file_bin_raise(), and rz_core_file_set_by_file().

rz_core_file_set_by_file()

RZ_API int rz_core_file_set_by_file	(	RzCore *	core,
		RzCoreFile *	cf
	)

Definition at line 1573 of file cfile.c.

                                                                  {
    if (core && cf) {
        if (!rz_core_file_set_by_fd(core, cf->fd)) {
            return false;
        }
        core->file = cf;
        return true;
    }
    return false;
}

References rz_core_file_t::fd, rz_core_t::file, and rz_core_file_set_by_fd().

Referenced by rz_core_file_binlist(), rz_core_file_reopen(), and rz_core_file_set_by_name().

rz_core_file_set_by_name()

RZ_API int rz_core_file_set_by_name	(	RzCore *	core,
		const char *	name
	)

Definition at line 1568 of file cfile.c.

                                                                    {
    RzCoreFile *cf = rz_core_file_find_by_name(core, name);
    return rz_core_file_set_by_file(core, cf);
}

References rz_core_file_find_by_name(), and rz_core_file_set_by_file().

rz_core_io_file_open()

RZ_API void rz_core_io_file_open	(	RZ_NONNULL RzCore *	core,
		int	fd
	)

Open file use read-only Permission.

Parameters

core	RzCore instance
fd	File descriptor

Definition at line 1601 of file cfile.c.

                                                                  {
    rz_return_if_fail(core && fd >= 0);
    if (!rz_config_get_b(core->config, "cfg.debug")) {
        rz_io_reopen(core->io, fd, RZ_PERM_R, 644);
        return;
    }
    RzBinFile *bf = rz_bin_cur(core->bin);
    if (!(bf && rz_file_exists(bf->file))) {
        RZ_LOG_WARN("Cannot open current RzBinFile.\n");
        return;
    }
 
    // Escape spaces so that o's argv parse will detect the path properly
    char *file = rz_str_path_escape(bf->file);
    // Backup the baddr and sections that were already rebased to
    // revert the rebase after the debug session is closed
    ut64 orig_baddr = core->bin->cur->o->baddr_shift;
    RzList *orig_sections = __save_old_sections(core);
 
    rz_bin_file_delete_all(core->bin);
    rz_io_close_all(core->io);
    rz_config_set_b(core->config, "cfg.debug", false);
 
    RzCoreFile *cfile = rz_core_file_open(core, file, RZ_PERM_R, 0);
    if (!cfile) {
        rz_list_free(orig_sections);
        RZ_LOG_ERROR("Cannot open file '%s'\n", file);
        return;
    }
    core->num->value = cfile->fd;
    // If no baddr defined, use the one provided by the file
    if (!rz_core_bin_load(core, file, UT64_MAX)) {
        rz_list_free(orig_sections);
        RZ_LOG_ERROR("Cannot load binary info of '%s'.\n", file);
        return;
    }
    rz_core_block_read(core);
 
    __rebase_everything(core, orig_sections, orig_baddr);
    rz_list_free(orig_sections);
    free(file);
}

References __rebase_everything(), __save_old_sections(), benchmark::cfile, fd, rz_bin_file_t::file, free(), rz_bin_cur(), rz_bin_file_delete_all(), rz_config_get_b(), rz_config_set_b(), rz_core_bin_load(), rz_core_block_read(), rz_core_file_open(), rz_file_exists(), rz_io_close_all(), rz_io_reopen(), rz_list_free(), RZ_LOG_ERROR, RZ_LOG_WARN, RZ_PERM_R, rz_return_if_fail, rz_str_path_escape(), ut64(), and UT64_MAX.

Referenced by __debugger_cb(), rz_core_debug_process_close(), rz_core_file_reopen_debug(), and rz_reopen_handler().

rz_core_io_file_reopen()

RZ_API void rz_core_io_file_reopen	(	RZ_NONNULL RzCore *	core,
		int	fd,
		int	perms
	)

Reopen file.

Parameters

core	RzCore instance
fd	File descriptor
perms	Permission \s RZ_PERM_R

Definition at line 1650 of file cfile.c.

                                                                               {
    rz_return_if_fail(core && fd >= 0);
    if (rz_io_reopen(core->io, fd, perms, 644)) {
        void **it;
        RzPVector *maps = rz_io_maps(core->io);
        if (!maps) {
            return;
        }
        rz_pvector_foreach_prev(maps, it) {
            RzIOMap *map = *it;
            if (map->fd == fd) {
                map->perm |= RZ_PERM_WX;
            }
        }
    }
}

References fd, map(), maps(), rz_io_maps(), rz_io_reopen(), RZ_PERM_WX, rz_pvector_foreach_prev, and rz_return_if_fail.

Referenced by __rw_cb(), and rz_reopen_write_handler().

rz_core_io_map_info_free()

RZ_IPI void rz_core_io_map_info_free

(

RzCoreIOMapInfo *

info

)

Definition at line 1679 of file cfile.c.

                                                            {
    free(info);
}

References free(), and info().

Referenced by rz_core_file_io_map_deleted().

rz_core_io_map_info_new()

RZ_IPI RzCoreIOMapInfo* rz_core_io_map_info_new	(	RzCoreFile *	cf,
		int	perm_orig
	)

Definition at line 1669 of file cfile.c.

                                                                               {
    RzCoreIOMapInfo *info = RZ_NEW(RzCoreIOMapInfo);
    if (!info) {
        return NULL;
    }
    info->cf = cf;
    info->perm_orig = perm_orig;
    return info;
}

References info(), NULL, and RZ_NEW.

Referenced by add_map(), and io_create_mem_map().

rz_core_raw_file_print()

RZ_API bool rz_core_raw_file_print

(

RzCore *

core

)

Definition at line 1339 of file cfile.c.

                                                 {
    RzCoreFile *f;
    RzIODesc *desc;
    RzBinFile *bf;
    RzListIter *it1, *it2, *it3;
    rz_list_foreach (core->files, it1, f) {
        desc = rz_io_desc_get(core->io, f->fd);
        if (!desc) {
            continue;
        }
        bool header_loaded = false;
        rz_list_foreach (core->bin->binfiles, it2, bf) {
            if (bf->fd == f->fd) {
                header_loaded = true;
                break;
            }
        }
        if (!header_loaded) {
            RzList *maps = rz_io_map_get_for_fd(core->io, f->fd);
            RzIOMap *current_map;
            char *absfile = rz_file_abspath(desc->uri);
            rz_list_foreach (maps, it3, current_map) {
                if (current_map) {
                    rz_cons_printf("on %s 0x%" PFMT64x "\n", absfile, current_map->itv.addr);
                }
            }
            rz_list_free(maps);
            free(absfile);
        }
    }
    return true;
}

References rz_interval_t::addr, rz_core_t::bin, rz_bin_t::binfiles, desc, f, rz_bin_file_t::fd, rz_core_t::files, free(), rz_core_t::io, rz_io_map_t::itv, maps(), PFMT64x, rz_cons_printf(), rz_file_abspath(), rz_io_desc_get(), rz_io_map_get_for_fd(), and rz_list_free().

rz_core_sysenv_begin()

RZ_API void rz_core_sysenv_begin

(

RzCore *

core

)

Definition at line 540 of file cfile.c.

                                               {
    // This will be deprecated when moving the . commands to newshell
    RzIODesc *desc = core->file ? rz_io_desc_get(core->io, core->file->fd) : NULL;
    rz_sys_setenv("RZ_BIN_PDBSERVER", rz_config_get(core->config, "pdb.server"));
    if (desc && desc->name) {
        rz_sys_setenv("RZ_FILE", desc->name);
        rz_sys_setenv("RZ_SIZE", sdb_fmt("%" PFMT64d, rz_io_desc_size(desc)));
    }
    rz_sys_setenv("RZ_OFFSET", sdb_fmt("%" PFMT64d, core->offset));
    rz_sys_setenv("RZ_XOFFSET", sdb_fmt("0x%08" PFMT64x, core->offset));
    rz_sys_setenv("RZ_ENDIAN", core->rasm->big_endian ? "big" : "little");
    rz_sys_setenv("RZ_BSIZE", sdb_fmt("%d", core->blocksize));
 
    // dump current config file so other r2 tools can use the same options
    char *config_sdb_path = NULL;
    int config_sdb_fd = rz_file_mkstemp(NULL, &config_sdb_path);
    if (config_sdb_fd >= 0) {
        close(config_sdb_fd);
    }
 
    Sdb *config_sdb = sdb_new(NULL, config_sdb_path, 0);
    rz_config_serialize(core->config, config_sdb);
    sdb_sync(config_sdb);
    sdb_free(config_sdb);
    rz_sys_setenv("RZ_CONFIG", config_sdb_path);
    rz_sys_setenv("RZ_BIN_LANG", rz_config_get(core->config, "bin.lang"));
    rz_sys_setenv("RZ_BIN_DEMANGLE", rz_config_get(core->config, "bin.demangle"));
    rz_sys_setenv("RZ_ARCH", rz_config_get(core->config, "asm.arch"));
    rz_sys_setenv("RZ_BITS", rz_config_get(core->config, "asm.bits"));
    rz_sys_setenv("RZ_COLOR", rz_config_get_i(core->config, "scr.color") ? "1" : "0");
    rz_sys_setenv("RZ_DEBUG", rz_config_get_b(core->config, "cfg.debug") ? "1" : "0");
    rz_sys_setenv("RZ_IOVA", rz_config_get_i(core->config, "io.va") ? "1" : "0");
    free(config_sdb_path);
}

References rz_asm_t::big_endian, rz_core_t::blocksize, close, rz_core_t::config, __rebase_struct::core, desc, rz_core_file_t::fd, rz_core_t::file, free(), rz_core_t::io, NULL, rz_core_t::offset, PFMT64d, PFMT64x, rz_core_t::rasm, rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_serialize(), rz_file_mkstemp(), rz_io_desc_get(), rz_io_desc_size(), rz_sys_setenv(), sdb_fmt(), sdb_free(), sdb_new(), and sdb_sync().

Referenced by lang_run_file(), and rz_core_cmd_command().

rz_core_sysenv_end()

RZ_API void rz_core_sysenv_end

(

RzCore *

core

)

Definition at line 526 of file cfile.c.

                                             {
    // This will be deprecated when moving the . commands to newshell
    rz_sys_setenv("RZ_FILE", NULL);
    rz_sys_setenv("RZ_OFFSET", NULL);
 
    // remove temporary RZ_CONFIG file
    char *rz_config = rz_sys_getenv("RZ_CONFIG");
    if (rz_config) {
        rz_file_rm(rz_config);
        rz_sys_setenv("RZ_CONFIG", NULL);
        free(rz_config);
    }
}

References free(), NULL, rz_file_rm(), rz_sys_getenv(), and rz_sys_setenv().

Referenced by rz_core_cmd_command().

try_loadlib()

static bool try_loadlib ( RzCore *  core, const char *  lib, ut64  addr  )

static

Definition at line 769 of file cfile.c.

                                                                  {
    if (rz_core_file_open(core, lib, 0, addr) != NULL) {
        rz_core_bin_load(core, lib, addr);
        return true;
    }
    return false;
}

References addr, __rebase_struct::core, NULL, rz_core_bin_load(), and rz_core_file_open().

Referenced by rz_core_file_loadlib().