cmd_open.c File Reference

#include <rz_bin.h>
#include <rz_debug.h>
#include <rz_core.h>
#include <rz_io.h>
#include "../core_private.h"

Go to the source code of this file.

Classes
struct	open_list_ascii_data_t

Functions
static bool	core_bin_reload (RzCore *r, const char *file, ut64 baseaddr)
static bool	reopen_in_malloc_cb (void *user, void *data, ut32 id)
RZ_API void	rz_core_file_reopen_in_malloc (RzCore *core)
static bool	init_desc_list_visual_cb (void *user, void *data, ut32 id)
static bool	desc_list_visual_cb (void *user, void *data, ut32 id)
static bool	desc_list_quiet_cb (void *user, void *data, ut32 id)
static bool	desc_list_cb (void *user, void *data, ut32 id)
static bool	desc_list_json_cb (void *user, void *data, ut32 id)
static bool	desc_list_table_cb (void *user, void *data, ut32 id)
RZ_IPI RzCmdStatus	rz_open_close_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_close_all_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_list_ascii_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_arch_bits_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_use_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	prioritize_file (RzCore *core, int fd)
RZ_IPI RzCmdStatus	rz_open_prioritize_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_prioritize_next_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_prioritize_prev_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_prioritize_next_rotate_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_remove_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_remove_all_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_list_ascii_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_all_fd_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_relocate_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_relocate_current_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_resize_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_prioritize_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_prioritize_binid_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_deprioritize_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_prioritize_fd_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_name_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_name_del_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_name_id_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_name_id_del_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_map_fd_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_flags_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_flags_global_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_maps_map_handler (RzCore *core, int argc, const char **argv)
static void	open_maps_show (RzCore *core, RzCmdStateOutput *state, RzIOMap *map, bool seek_inside)
static void	open_maps_list (RzCore *core, RzCmdStateOutput *state, int fd)
RZ_IPI RzCmdStatus	rz_open_maps_list_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_open_maps_list_cur_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_open_binary_select_id_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_select_fd_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_del_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_del_all_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_list_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_open_binary_show_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_list_ascii_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_add_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_rebase_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_binary_reload_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_write_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_list_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_open_show_current_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_open_exchange_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	open_core_file (RzCore *core, const char *filename)
RZ_IPI RzCmdStatus	rz_open_core_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_malloc_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	open_nobin_file (RzCore *core, const char *uri, ut64 addr, int perms)
RZ_IPI RzCmdStatus	rz_open_nobin_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_open_nobin_write_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_write_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_binary_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_core_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_debug_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_debug_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_debug_rzrun_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_malloc_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_nobin_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_nobin_write_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	reopen_nobin_headers (RzCore *core, int add_perms)
RZ_IPI RzCmdStatus	rz_reopen_nobin_headers_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_reopen_nobin_write_headers_handler (RzCore *core, int argc, const char **argv)

Function Documentation

core_bin_reload()

static bool core_bin_reload ( RzCore *  r, const char *  file, ut64  baseaddr  )

static

Definition at line 15 of file cmd_open.c.

                                                                        {
    RzCoreFile *cf = rz_core_file_cur(r);
    if (!cf) {
        return false;
    }
    RzBinFile *obf = rz_bin_file_find_by_fd(r->bin, cf->fd);
    if (!obf) {
        return false;
    }
    RzBinFile *nbf = rz_bin_reload(r->bin, obf, baseaddr);
    if (!nbf) {
        return false;
    }
    rz_core_bin_apply_all_info(r, nbf);
    return true;
}

References baseaddr, rz_core_file_t::fd, r, rz_bin_file_find_by_fd(), rz_bin_reload(), rz_core_bin_apply_all_info(), and rz_core_file_cur().

Referenced by rz_open_binary_reload_handler().

desc_list_cb()

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

static

Definition at line 112 of file cmd_open.c.

                                                          {
    RzPrint *p = (RzPrint *)user;
    RzIODesc *desc = (RzIODesc *)data;
    p->cb_printf("%2d %c %s 0x%08" PFMT64x " %s\n", desc->fd,
        (desc->io && (desc->io->desc == desc)) ? '*' : '-',
        rz_str_rwx_i(desc->perm), rz_io_desc_size(desc), desc->uri);
    return true;
}

References desc, p, PFMT64x, rz_io_desc_size(), and rz_str_rwx_i().

Referenced by rz_open_list_handler(), and rz_open_show_current_handler().

desc_list_json_cb()

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

static

Definition at line 121 of file cmd_open.c.

                                                               {
    PJ *pj = (PJ *)user;
    RzIODesc *desc = (RzIODesc *)data;
    // TODO: from is always 0? See librz/core/file.c:945
    ut64 from = 0LL;
    pj_o(pj);
    pj_kb(pj, "raised", desc->io && (desc->io->desc == desc));
    pj_kN(pj, "fd", desc->fd);
    pj_ks(pj, "uri", desc->uri);
    pj_kn(pj, "from", from);
    pj_kb(pj, "writable", desc->perm & RZ_PERM_W);
    pj_kN(pj, "size", rz_io_desc_size(desc));
    pj_end(pj);
    return true;
}

References desc, from, pj_end(), pj_kb(), pj_kN(), pj_kn(), pj_ks(), pj_o(), rz_io_desc_size(), RZ_PERM_W, and ut64().

Referenced by rz_open_list_handler(), and rz_open_show_current_handler().

desc_list_quiet_cb()

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

static

Definition at line 105 of file cmd_open.c.

                                                                {
    RzPrint *p = (RzPrint *)user;
    RzIODesc *desc = (RzIODesc *)data;
    p->cb_printf("%d\n", desc->fd);
    return true;
}

References desc, and p.

Referenced by rz_open_list_handler(), and rz_open_show_current_handler().

desc_list_table_cb()

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

static

Definition at line 137 of file cmd_open.c.

                                                                {
    RzTable *t = (RzTable *)user;
    RzIODesc *desc = (RzIODesc *)data;
    rz_table_add_rowf(t, "dbsXs", desc->fd, desc->io && (desc->io->desc == desc),
        rz_str_rwx_i(desc->perm), rz_io_desc_size(desc), desc->uri);
    return true;
}

References desc, rz_io_desc_size(), rz_str_rwx_i(), and rz_table_add_rowf().

Referenced by rz_open_list_handler(), and rz_open_show_current_handler().

desc_list_visual_cb()

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

static

Definition at line 90 of file cmd_open.c.

                                                                 {
    struct open_list_ascii_data_t *u = (struct open_list_ascii_data_t *)user;
    RzPrint *p = u->p;
    RzIODesc *desc = (RzIODesc *)data;
    ut64 sz = rz_io_desc_size(desc);
    rz_cons_printf("%2d %c %s 0x%08" PFMT64x " ", desc->fd,
        (desc->io && (desc->io->desc == desc)) ? '*' : '-', rz_str_rwx_i(desc->perm), sz);
    int flags = p->flags;
    p->flags &= ~RZ_PRINT_FLAGS_HEADER;
    rz_print_progressbar(p, sz * 100 / u->fdsz, rz_cons_get_size(NULL) - 40);
    p->flags = flags;
    rz_cons_printf(" %s\n", desc->uri);
    return true;
}

References desc, open_list_ascii_data_t::fdsz, flags, NULL, open_list_ascii_data_t::p, p, PFMT64x, rz_cons_get_size(), rz_cons_printf(), rz_io_desc_size(), RZ_PRINT_FLAGS_HEADER, rz_print_progressbar(), rz_str_rwx_i(), and ut64().

Referenced by rz_open_list_ascii_handler().

init_desc_list_visual_cb()

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

static

Definition at line 80 of file cmd_open.c.

                                                                      {
    struct open_list_ascii_data_t *u = (struct open_list_ascii_data_t *)user;
    RzIODesc *desc = (RzIODesc *)data;
    ut64 sz = rz_io_desc_size(desc);
    if (sz > u->fdsz) {
        u->fdsz = sz;
    }
    return true;
}

References desc, open_list_ascii_data_t::fdsz, rz_io_desc_size(), and ut64().

Referenced by rz_open_list_ascii_handler().

open_core_file()

static RzCmdStatus open_core_file ( RzCore *  core, const char *  filename  )

static

Definition at line 885 of file cmd_open.c.

                                                                      {
    if (core->tasks.current_task != core->tasks.main_task) {
        RZ_LOG_ERROR("This command can only be executed on the main task!\n");
        return RZ_CMD_STATUS_ERROR;
    }
    rz_core_task_sync_end(&core->tasks);
    rz_core_fini(core);
    rz_core_init(core);
    rz_core_task_sync_begin(&core->tasks);
    if (!rz_core_file_open(core, filename, RZ_PERM_R, 0)) {
        RZ_LOG_ERROR("Cannot open file '%s'\n", filename);
        return RZ_CMD_STATUS_ERROR;
    }
    ut64 baddr = rz_config_get_i(core->config, "bin.baddr");
    return bool2status(rz_core_bin_load(core, NULL, baddr));
}

References baddr(), bool2status(), rz_core_t::config, rz_core_tasks_t::current_task, rz_core_tasks_t::main_task, NULL, RZ_CMD_STATUS_ERROR, rz_config_get_i(), rz_core_bin_load(), rz_core_file_open(), rz_core_fini(), rz_core_init(), rz_core_task_sync_begin(), rz_core_task_sync_end(), RZ_LOG_ERROR, RZ_PERM_R, rz_core_t::tasks, and ut64().

Referenced by rz_open_core_file_handler(), and rz_reopen_core_handler().

open_maps_list()

static void open_maps_list ( RzCore *  core, RzCmdStateOutput *  state, int  fd  )

static

Definition at line 608 of file cmd_open.c.

                                                                          {
    RzPVector *maps = rz_io_maps(core->io);
    void **it;
 
    rz_cmd_state_output_array_start(state);
    rz_cmd_state_output_set_columnsf(state, "ddxxxxxss", "id", "fd", "pa", "pa_end", "size", "va", "va_end", "perm", "name");
    if (state->mode == RZ_OUTPUT_MODE_TABLE) {
        state->d.t->showFancy = true;
    }
    RzIOMap *at_seek = NULL;
    if (state->mode == RZ_OUTPUT_MODE_STANDARD) {
        at_seek = rz_io_map_get(core->io, core->offset);
    }
    rz_pvector_foreach (maps, it) {
        RzIOMap *map = *it;
        if (fd >= 0 && map->fd != fd) {
            continue;
        }
        open_maps_show(core, state, map, map == at_seek);
    }
    rz_cmd_state_output_array_end(state);
}

References fd, rz_core_t::io, map(), maps(), NULL, rz_core_t::offset, open_maps_show(), rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_cmd_state_output_set_columnsf(), rz_io_map_get(), rz_io_maps(), RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, and rz_pvector_foreach.

Referenced by rz_open_maps_list_handler().

open_maps_show()

static void open_maps_show ( RzCore *  core, RzCmdStateOutput *  state, RzIOMap *  map, bool  seek_inside  )

static

Definition at line 575 of file cmd_open.c.

                                                                                                  {
    switch (state->mode) {
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_printf("%d %d\n", map->fd, map->id);
        break;
    case RZ_OUTPUT_MODE_QUIETEST:
        rz_cons_printf("0x%08" PFMT64x "\n", rz_io_map_get_from(map));
        break;
    case RZ_OUTPUT_MODE_JSON:
        pj_o(state->d.pj);
        pj_ki(state->d.pj, "map", map->id);
        pj_ki(state->d.pj, "fd", map->fd);
        pj_kn(state->d.pj, "delta", map->delta);
        pj_kn(state->d.pj, "from", rz_io_map_get_from(map));
        pj_kn(state->d.pj, "to", rz_itv_end(map->itv));
        pj_ks(state->d.pj, "perm", rz_str_rwx_i(map->perm));
        pj_ks(state->d.pj, "name", rz_str_get(map->name));
        pj_end(state->d.pj);
        break;
    case RZ_OUTPUT_MODE_TABLE:
        rz_table_add_rowf(state->d.t, "ddxxxxxss",
            map->id, map->fd, map->delta, map->delta + rz_itv_size(map->itv), rz_itv_size(map->itv),
            rz_io_map_get_from(map), rz_itv_end(map->itv), rz_str_rwx_i(map->perm), rz_str_get(map->name));
        break;
    default:
        rz_cons_printf("%2d fd: %i +0x%08" PFMT64x " 0x%08" PFMT64x " %c 0x%08" PFMT64x " %s %s\n",
            map->id, map->fd,
            map->delta, rz_io_map_get_from(map), seek_inside ? '*' : '-', rz_io_map_get_to(map),
            rz_str_rwx_i(map->perm), rz_str_get(map->name));
        break;
    }
}

References map(), PFMT64x, pj_end(), pj_ki(), pj_kn(), pj_ks(), pj_o(), rz_cons_printf(), rz_io_map_get_from, rz_io_map_get_to, rz_itv_end(), rz_itv_size(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_QUIETEST, RZ_OUTPUT_MODE_TABLE, rz_str_get(), rz_str_rwx_i(), and rz_table_add_rowf().

Referenced by open_maps_list(), and rz_open_maps_list_cur_handler().

open_nobin_file()

static RzCmdStatus open_nobin_file ( RzCore *  core, const char *  uri, ut64  addr, int  perms  )

static

Definition at line 946 of file cmd_open.c.

                                                                                        {
    if (!strcmp(uri, "=")) {
        uri = "malloc://512";
    }
 
    RzIODesc *desc = rz_io_open_at(core->io, uri, perms, 0644, addr, NULL);
    if (!desc || desc->fd == -1) {
        RZ_LOG_ERROR("Cannot open '%s' at %" PFMT64x ".\n", uri, addr);
        return RZ_CMD_STATUS_ERROR;
    }
 
    core->num->value = desc->fd;
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References addr, desc, rz_core_t::io, NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_open_at(), RZ_LOG_ERROR, and rz_num_t::value.

Referenced by rz_open_nobin_handler(), and rz_open_nobin_write_handler().

prioritize_file()

static RzCmdStatus prioritize_file ( RzCore *  core, int  fd  )

static

Definition at line 212 of file cmd_open.c.

                                                         {
    if (fd <= 0) {
        RZ_LOG_ERROR("Wrong file descriptor %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    int curfd = rz_io_fd_get_current(core->io);
    if (fd == curfd) {
        return RZ_CMD_STATUS_OK;
    }
 
    if (!rz_io_use_fd(core->io, fd)) {
        RZ_LOG_ERROR("Could not use IO fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_core_block_read(core);
    RzBinFile *bf = rz_bin_file_find_by_fd(core->bin, fd);
    if (bf && !rz_core_bin_raise(core, bf->id)) {
        RZ_LOG_ERROR("Could not use bin id %d\n", bf->id);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::bin, fd, rz_bin_file_t::id, rz_core_t::io, rz_bin_file_find_by_fd(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_raise(), rz_core_block_read(), rz_io_fd_get_current(), rz_io_use_fd(), and RZ_LOG_ERROR.

Referenced by rz_open_prioritize_handler(), rz_open_prioritize_next_handler(), rz_open_prioritize_next_rotate_handler(), and rz_open_prioritize_prev_handler().

reopen_in_malloc_cb()

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

static

Definition at line 32 of file cmd_open.c.

                                                                 {
    RzIO *io = (RzIO *)user;
    RzIODesc *desc = (RzIODesc *)data;
 
    if (rz_io_desc_is_blockdevice(desc) || rz_io_desc_is_dbg(desc)) {
        return true;
    }
 
    if (strstr(desc->uri, "://")) {
        return true;
    }
 
    ut64 size = rz_io_desc_size(desc);
 
    char *uri = rz_str_newf("malloc://%" PFMT64u, size);
    if (!uri) {
        return false;
    }
 
    ut8 *buf = malloc(size);
    // if malloc fails, we can just abort the loop by returning false
    if (!buf) {
        free(uri);
        return false;
    }
 
    RzIODesc *ndesc = rz_io_open_nomap(io, uri, RZ_PERM_RW, 0);
    free(uri);
    if (!ndesc) {
        free(buf);
        return false;
    }
 
    rz_io_desc_read_at(desc, 0LL, buf, (int)size); // that cast o_O
    rz_io_desc_write_at(ndesc, 0LL, buf, (int)size);
    free(buf);
    rz_io_desc_exchange(io, desc->fd, ndesc->fd);
 
    rz_io_desc_close(desc);
    return true;
}

References desc, rz_io_desc_t::fd, free(), malloc(), PFMT64u, rz_io_desc_close(), rz_io_desc_exchange(), rz_io_desc_is_blockdevice(), rz_io_desc_is_dbg(), rz_io_desc_read_at(), rz_io_desc_size(), rz_io_desc_write_at(), rz_io_open_nomap(), RZ_PERM_RW, rz_str_newf(), and ut64().

Referenced by rz_core_file_reopen_in_malloc().

reopen_nobin_headers()

static RzCmdStatus reopen_nobin_headers ( RzCore *  core, int  add_perms  )

static

Definition at line 1081 of file cmd_open.c.

                                                                     {
    RzIODesc *desc = rz_io_desc_get(core->io, core->file->fd);
    if (!desc) {
        RZ_LOG_ERROR("Could not find current file.\n");
        return RZ_CMD_STATUS_ERROR;
    }
    int perms = core->io->desc->perm | add_perms;
    char *fname = strdup(desc->name);
    if (!fname) {
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_core_bin_load_structs(core, fname)) {
        RZ_LOG_WARN("Could not load file format information for '%s'.\n", fname);
    }
    bool res = rz_core_file_reopen(core, fname, perms, 0);
    free(fname);
    return bool2status(res);
}

References bool2status(), desc, rz_io_t::desc, rz_core_file_t::fd, rz_core_t::file, create_tags_rz::fname, free(), rz_core_t::io, rz_io_desc_t::perm, RZ_CMD_STATUS_ERROR, rz_core_bin_load_structs(), rz_core_file_reopen(), rz_io_desc_get(), RZ_LOG_ERROR, RZ_LOG_WARN, and strdup().

Referenced by rz_reopen_nobin_headers_handler(), and rz_reopen_nobin_write_headers_handler().

rz_core_file_reopen_in_malloc()

RZ_API void rz_core_file_reopen_in_malloc

(

RzCore *

core

)

Definition at line 74 of file cmd_open.c.

                                                        {
    if (core && core->io && core->io->files) {
        rz_id_storage_foreach(core->io->files, reopen_in_malloc_cb, core->io);
    }
}

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

Referenced by rz_reopen_malloc_handler().

rz_open_arch_bits_handler()

RZ_IPI RzCmdStatus rz_open_arch_bits_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 179 of file cmd_open.c.

                                                                                        {
    const char *filename = argc > 3 ? argv[3] : NULL;
    ut16 bits = rz_num_math(core->num, argv[2]);
    const char *arch = argv[1];
 
    int res = rz_core_bin_set_arch_bits(core, filename, arch, bits);
    return res ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References arch, argv, bits(), NULL, rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_set_arch_bits(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_add_handler()

RZ_IPI RzCmdStatus rz_open_binary_add_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 737 of file cmd_open.c.

                                                                                         {
    ut64 loadaddr = rz_num_math(core->num, argv[1]);
    int fd = rz_io_fd_get_current(core->io);
    RzIODesc *desc = rz_io_desc_get(core->io, fd);
    if (!desc) {
        RZ_LOG_ERROR("Could not determine any opened file with fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    RzBinOptions opt;
    opt.sz = 1024 * 1024 * 1;
    rz_core_bin_options_init(core, &opt, desc->fd, core->offset, loadaddr);
    RzBinFile *bf = rz_bin_open_io(core->bin, &opt);
    rz_core_bin_apply_all_info(core, bf);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, desc, fd, rz_core_t::io, rz_core_t::num, rz_core_t::offset, rz_bin_open_io(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_apply_all_info(), rz_core_bin_options_init(), rz_io_desc_get(), rz_io_fd_get_current(), RZ_LOG_ERROR, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_binary_del_all_handler()

RZ_IPI RzCmdStatus rz_open_binary_del_all_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 688 of file cmd_open.c.

                                                                                             {
    rz_bin_file_delete_all(core->bin);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::bin, rz_bin_file_delete_all(), and RZ_CMD_STATUS_OK.

Referenced by rzshell_cmddescs_init().

rz_open_binary_del_handler()

RZ_IPI RzCmdStatus rz_open_binary_del_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 674 of file cmd_open.c.

                                                                                         {
    ut32 id = (ut32)rz_num_math(NULL, argv[1]);
    RzBinFile *bf = rz_bin_file_find_by_id(core->bin, id);
    if (!bf) {
        RZ_LOG_ERROR("Could not find any binary file with id %d.\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_core_binfiles_delete(core, bf)) {
        RZ_LOG_ERROR("Could not delete binary file with id %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, NULL, rz_bin_file_find_by_id(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_binfiles_delete(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_file_handler()

RZ_IPI RzCmdStatus rz_open_binary_file_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 753 of file cmd_open.c.

                                                                                          {
    int saved_fd = rz_io_fd_get_current(core->io);
    RzList *files = rz_list_newf(NULL);
    RzListIter *iter;
 
    RzIODesc *desc = NULL;
    if (argc > 1) {
        desc = rz_io_open(core->io, argv[1], RZ_PERM_R, 0);
        if (!desc) {
            RZ_LOG_ERROR("Could not open file %s\n", argv[1]);
            rz_list_free(files);
            return RZ_CMD_STATUS_ERROR;
        }
        rz_list_append(files, (void *)(size_t)desc->fd);
    } else {
        RzList *ofiles = rz_id_storage_list(core->io->files);
        RzIODesc *desc;
        rz_list_foreach (ofiles, iter, desc) {
            rz_list_append(files, (void *)(size_t)desc->fd);
        }
    }
 
    void *_fd;
    rz_list_foreach (files, iter, _fd) {
        RzBinOptions opt;
        int fd = (size_t)_fd;
        rz_core_bin_options_init(core, &opt, fd, core->offset, 0);
        RzBinFile *bf = rz_bin_open_io(core->bin, &opt);
        rz_core_bin_apply_all_info(core, bf);
    }
    rz_list_free(files);
 
    rz_io_desc_close(desc);
    rz_io_use_fd(core->io, saved_fd);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, desc, fd, rz_io_t::files, files, rz_core_t::io, NULL, rz_core_t::offset, rz_bin_open_io(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_apply_all_info(), rz_core_bin_options_init(), rz_id_storage_list(), rz_io_desc_close(), rz_io_fd_get_current(), rz_io_open(), rz_io_use_fd(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, and RZ_PERM_R.

Referenced by rzshell_cmddescs_init().

rz_open_binary_list_ascii_handler()

RZ_IPI RzCmdStatus rz_open_binary_list_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 706 of file cmd_open.c.

                                                                                                {
    RzBin *bin = core->bin;
    if (!bin) {
        return RZ_CMD_STATUS_ERROR;
    }
    RzList *list = rz_list_newf((RzListFree)rz_listinfo_free);
    if (!list) {
        return RZ_CMD_STATUS_ERROR;
    }
    RzListIter *iter;
    RzBinFile *bf = NULL;
    rz_list_foreach (bin->binfiles, iter, bf) {
        char temp[64];
        RzInterval inter = (RzInterval){ bf->o->opts.baseaddr, bf->o->size };
        RzListInfo *info = rz_listinfo_new(bf->file, inter, inter, -1, sdb_itoa(bf->fd, temp, 10));
        if (!info) {
            break;
        }
        rz_list_append(list, info);
    }
    RzTable *table = rz_core_table(core);
    rz_table_visual_list(table, list, core->offset, core->blocksize,
        rz_cons_get_size(NULL), rz_config_get_i(core->config, "scr.color"));
    char *table_text = rz_table_tostring(table);
    rz_cons_printf("\n%s\n", table_text);
    rz_free(table_text);
    rz_table_free(table);
    rz_list_free(list);
    return RZ_CMD_STATUS_OK;
}

References rz_bin_file_load_options_t::baseaddr, rz_core_t::bin, rz_core_t::blocksize, rz_core_t::config, rz_bin_file_t::fd, rz_bin_file_t::file, info(), list(), NULL, rz_bin_file_t::o, rz_core_t::offset, rz_bin_object_t::opts, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_config_get_i(), rz_cons_get_size(), rz_cons_printf(), rz_core_table(), rz_free, rz_list_append(), rz_list_free(), rz_list_newf(), rz_listinfo_free(), rz_listinfo_new(), rz_table_free(), rz_table_tostring(), rz_table_visual_list(), sdb_itoa(), and rz_bin_object_t::size.

Referenced by rzshell_cmddescs_init().

rz_open_binary_list_handler()

RZ_IPI RzCmdStatus rz_open_binary_list_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 693 of file cmd_open.c.

                                                                                                                   {
    rz_core_binfiles_print(core, state);
    return RZ_CMD_STATUS_OK;
}

References RZ_CMD_STATUS_OK, and rz_core_binfiles_print().

Referenced by rzshell_cmddescs_init().

rz_open_binary_rebase_handler()

RZ_IPI RzCmdStatus rz_open_binary_rebase_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 790 of file cmd_open.c.

                                                                                            {
    rz_core_bin_rebase(core, rz_num_math(core->num, argv[1]));
    rz_core_bin_apply_all_info(core, rz_bin_cur(core->bin));
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, rz_core_t::num, rz_bin_cur(), RZ_CMD_STATUS_OK, rz_core_bin_apply_all_info(), rz_core_bin_rebase(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_reload_handler()

RZ_IPI RzCmdStatus rz_open_binary_reload_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 796 of file cmd_open.c.

                                                                                            {
    // XXX: this will reload the bin using the buffer.
    // An assumption is made that assumes there is an underlying
    // plugin that will be used to load the bin (e.g. malloc://)
    // TODO: Might be nice to reload a bin at a specified offset?
    core_bin_reload(core, NULL, rz_num_math(core->num, argv[1]));
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References argv, core_bin_reload(), NULL, rz_core_t::num, RZ_CMD_STATUS_OK, rz_core_block_read(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_select_fd_handler()

RZ_IPI RzCmdStatus rz_open_binary_select_fd_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 660 of file cmd_open.c.

                                                                                               {
    ut32 fd = rz_num_math(NULL, argv[1]);
    RzBinFile *bf = rz_bin_file_find_by_fd(core->bin, fd);
    if (!bf) {
        RZ_LOG_ERROR("Could not find any binary file for fd %d.\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_core_bin_raise(core, bf->id)) {
        eprintf("Could not select the binary file for fd %d.\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, eprintf, fd, rz_bin_file_t::id, NULL, rz_bin_file_find_by_fd(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_raise(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_select_id_handler()

RZ_IPI RzCmdStatus rz_open_binary_select_id_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 651 of file cmd_open.c.

                                                                                               {
    ut32 id = (ut32)rz_num_math(NULL, argv[1]);
    if (!rz_core_bin_raise(core, id)) {
        RZ_LOG_ERROR("Could not select binary file with id %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_raise(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_binary_show_handler()

RZ_IPI RzCmdStatus rz_open_binary_show_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 698 of file cmd_open.c.

                                                                                          {
    RzBinFile *bf = rz_bin_file_at(core->bin, core->offset);
    if (bf) {
        rz_cons_printf("%d\n", bf->id);
    }
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::bin, rz_bin_file_t::id, rz_core_t::offset, rz_bin_file_at(), RZ_CMD_STATUS_OK, and rz_cons_printf().

Referenced by rzshell_cmddescs_init().

rz_open_close_all_handler()

RZ_IPI RzCmdStatus rz_open_close_all_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 158 of file cmd_open.c.

                                                                                        {
    rz_core_file_close_fd(core, -1);
    rz_io_close_all(core->io);
    rz_bin_file_delete_all(core->bin);
 
    // TODO: Move to a-- ?
    rz_analysis_purge(core->analysis);
    // TODO: Move to f-- ?
    rz_flag_unset_all(core->flags);
    RZ_LOG_INFO("Close all files\n");
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::analysis, rz_core_t::bin, rz_core_t::flags, rz_core_t::io, rz_analysis_purge(), rz_bin_file_delete_all(), RZ_CMD_STATUS_OK, rz_core_file_close_fd(), rz_flag_unset_all(), rz_io_close_all(), and RZ_LOG_INFO.

Referenced by rzshell_cmddescs_init().

rz_open_close_handler()

RZ_IPI RzCmdStatus rz_open_close_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 145 of file cmd_open.c.

                                                                                    {
    if (!rz_num_is_valid_input(NULL, argv[1])) {
        RZ_LOG_ERROR("Invalid fd: %s\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    int fd = (int)rz_num_math(NULL, argv[1]);
    if (!rz_core_file_close_fd(core, fd)) {
        RZ_LOG_ERROR("Unable to find file descriptor %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, fd, int, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_file_close_fd(), RZ_LOG_ERROR, rz_num_is_valid_input(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_core_file_handler()

RZ_IPI RzCmdStatus rz_open_core_file_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 902 of file cmd_open.c.

                                                                                        {
    return open_core_file(core, argv[1]);
}

References argv, and open_core_file().

Referenced by rzshell_cmddescs_init().

rz_open_exchange_handler()

RZ_IPI RzCmdStatus rz_open_exchange_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 873 of file cmd_open.c.

                                                                                       {
    int fd = (int)rz_num_math(NULL, argv[1]);
    int fdx = (int)rz_num_math(NULL, argv[2]);
    if ((fdx == -1) || (fd == -1) || (fdx == fd)) {
        RZ_LOG_ERROR("Could not exchange file descriptor %d and %d.\n", fd, fdx);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_desc_exchange(core->io, fd, fdx);
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References argv, fd, int, rz_core_t::io, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_desc_exchange(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_handler()

RZ_IPI RzCmdStatus rz_open_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 806 of file cmd_open.c.

                                                                              {
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    int perms = argc > 3 ? rz_str_rwx(argv[3]) : RZ_PERM_R;
    return bool2status(rz_core_file_open_load(core, argv[1], addr, perms, false));
}

References addr, argv, bool2status(), rz_core_t::num, rz_core_file_open_load(), rz_num_math(), RZ_PERM_R, rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_list_ascii_handler()

RZ_IPI RzCmdStatus rz_open_list_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 170 of file cmd_open.c.

                                                                                         {
    struct open_list_ascii_data_t data = { 0 };
    data.p = core->print;
    data.fdsz = 0;
    rz_id_storage_foreach(core->io->files, init_desc_list_visual_cb, &data);
    rz_id_storage_foreach(core->io->files, desc_list_visual_cb, &data);
    return RZ_CMD_STATUS_OK;
}

References desc_list_visual_cb(), open_list_ascii_data_t::fdsz, rz_io_t::files, init_desc_list_visual_cb(), rz_core_t::io, open_list_ascii_data_t::p, rz_core_t::print, RZ_CMD_STATUS_OK, and rz_id_storage_foreach().

Referenced by rzshell_cmddescs_init().

rz_open_list_handler()

RZ_IPI RzCmdStatus rz_open_list_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 818 of file cmd_open.c.

                                                                                                            {
    rz_cmd_state_output_array_start(state);
    rz_cmd_state_output_set_columnsf(state, "dbsXs", "fd", "raised", "perm", "size", "uri");
    switch (state->mode) {
    case RZ_OUTPUT_MODE_STANDARD:
        rz_id_storage_foreach(core->io->files, desc_list_cb, core->print);
        break;
    case RZ_OUTPUT_MODE_JSON:
        rz_id_storage_foreach(core->io->files, desc_list_json_cb, state->d.pj);
        break;
    case RZ_OUTPUT_MODE_TABLE:
        rz_id_storage_foreach(core->io->files, desc_list_table_cb, state->d.t);
        break;
    case RZ_OUTPUT_MODE_QUIET:
        rz_id_storage_foreach(core->io->files, desc_list_quiet_cb, core->print);
        break;
    default:
        break;
    }
    rz_cmd_state_output_array_end(state);
    return RZ_CMD_STATUS_OK;
}

References desc_list_cb(), desc_list_json_cb(), desc_list_quiet_cb(), desc_list_table_cb(), rz_io_t::files, rz_core_t::io, rz_core_t::print, rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_cmd_state_output_set_columnsf(), RZ_CMD_STATUS_OK, rz_id_storage_foreach(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, and RZ_OUTPUT_MODE_TABLE.

Referenced by rzshell_cmddescs_init().

rz_open_malloc_handler()

RZ_IPI RzCmdStatus rz_open_malloc_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 906 of file cmd_open.c.

                                                                                     {
    int len = (int)rz_num_math(core->num, argv[1]);
    if (len < 0) {
        RZ_LOG_ERROR("Invalid length %d.\n", len);
        return RZ_CMD_STATUS_ERROR;
    }
 
    RzCmdStatus res = RZ_CMD_STATUS_ERROR;
    ut8 *data = RZ_NEWS(ut8, len);
    if (!data) {
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_io_read_at(core->io, core->offset, data, len)) {
        RZ_LOG_ERROR("Cannot read %d bytes from current offset.\n", len);
        goto err;
    }
 
    char uri[100];
    rz_strf(uri, "malloc://%d", len);
    RzCoreFile *cfile = rz_core_file_open(core, uri, RZ_PERM_RWX, 0);
    if (!cfile) {
        RZ_LOG_ERROR("Cannot open '%s'.\n", uri);
        goto err;
    }
 
    if (!rz_core_bin_load(core, uri, 0)) {
        RZ_LOG_ERROR("Cannot load binary info of '%s'.\n", uri);
        goto err;
    }
 
    RzIODesc *desc = rz_io_desc_get(core->io, cfile->fd);
    rz_warn_if_fail(desc);
    rz_io_desc_write_at(desc, 0, data, len);
    res = RZ_CMD_STATUS_OK;
 
err:
    free(data);
    return res;
}

References argv, benchmark::cfile, desc, err, free(), int, rz_core_t::io, len, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_load(), rz_core_file_open(), rz_io_desc_get(), rz_io_desc_write_at(), rz_io_read_at(), RZ_LOG_ERROR, RZ_NEWS, rz_num_math(), RZ_PERM_RWX, rz_strf, and rz_warn_if_fail.

Referenced by rzshell_cmddescs_init().

rz_open_maps_all_fd_handler()

RZ_IPI RzCmdStatus rz_open_maps_all_fd_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 304 of file cmd_open.c.

                                                                                          {
    ut32 fd = argc > 1 ? rz_num_math(NULL, argv[1]) : rz_io_fd_get_current(core->io);
    RzIODesc *desc = rz_io_desc_get(core->io, fd);
    if (!desc) {
        RZ_LOG_ERROR("Could not find any file descriptor with fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    RzIOMap *map = rz_io_map_add(core->io, fd, desc->perm, 0, 0, UT64_MAX);
    if (!map) {
        RZ_LOG_ERROR("Could not create a IO map for file descriptor %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_set_name(map, desc->name);
    return RZ_CMD_STATUS_OK;
}

References argv, desc, fd, rz_core_t::io, map(), NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_desc_get(), rz_io_fd_get_current(), rz_io_map_add(), rz_io_map_set_name(), RZ_LOG_ERROR, rz_num_math(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

rz_open_maps_deprioritize_handler()

RZ_IPI RzCmdStatus rz_open_maps_deprioritize_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 409 of file cmd_open.c.

                                                                                                {
    ut32 id = (ut32)rz_num_math(core->num, argv[1]);
    if (!rz_io_map_exists_for_id(core->io, id)) {
        RZ_LOG_ERROR("Cannot find any map with mapid %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_depriorize(core->io, id);
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_map_depriorize(), rz_io_map_exists_for_id(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_flags_global_handler()

RZ_IPI RzCmdStatus rz_open_maps_flags_global_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 510 of file cmd_open.c.

                                                                                                {
    const char *arg = argv[1];
    enum mode {
        ADD,
        DEL,
        SET,
    } mode = SET;
    if (arg[0] == '+') {
        mode = ADD;
        arg++;
    } else if (arg[0] == '-') {
        mode = DEL;
        arg++;
    }
    int perm = rz_str_rwx(arg);
    RzPVector *maps = rz_io_maps(core->io);
    void **it;
    rz_pvector_foreach (maps, it) {
        RzIOMap *map = *it;
        switch (mode) {
        case ADD:
            map->perm |= perm;
            break;
        case DEL:
            map->perm &= ~perm;
            break;
        case SET:
            map->perm = perm;
            break;
        }
    }
    return RZ_CMD_STATUS_OK;
}

References ADD, argv, DEL, rz_core_t::io, map(), maps(), RZ_CMD_STATUS_OK, rz_io_maps(), rz_pvector_foreach, and rz_str_rwx().

Referenced by rzshell_cmddescs_init().

rz_open_maps_flags_handler()

RZ_IPI RzCmdStatus rz_open_maps_flags_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 488 of file cmd_open.c.

                                                                                         {
    int perm = rz_str_rwx(argv[1]);
    RzIOMap *map = NULL;
    if (argc > 2) {
        ut32 id = rz_num_math(NULL, argv[2]);
        map = rz_io_map_resolve(core->io, id);
        if (!map) {
            RZ_LOG_ERROR("Cannot find any map with id %d\n", id);
            return RZ_CMD_STATUS_ERROR;
        }
    } else {
        map = rz_io_map_get(core->io, core->offset);
        if (!map) {
            RZ_LOG_ERROR("Cannot find any map at the current address %" PFMT64x "\n", core->offset);
            return RZ_CMD_STATUS_ERROR;
        }
    }
 
    map->perm = perm;
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, map(), NULL, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_get(), rz_io_map_resolve(), RZ_LOG_ERROR, rz_num_math(), and rz_str_rwx().

Referenced by rzshell_cmddescs_init().

rz_open_maps_list_ascii_handler()

RZ_IPI RzCmdStatus rz_open_maps_list_ascii_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 276 of file cmd_open.c.

                                                                                              {
    RzList *list = rz_list_newf((RzListFree)rz_listinfo_free);
    if (!list) {
        return RZ_CMD_STATUS_ERROR;
    }
    void **it;
    RzPVector *maps = rz_io_maps(core->io);
    rz_pvector_foreach_prev(maps, it) {
        RzIOMap *map = *it;
        char temp[32];
        rz_strf(temp, "%d", map->fd);
        RzListInfo *info = rz_listinfo_new(map->name, map->itv, map->itv, map->perm, temp);
        if (!info) {
            break;
        }
        rz_list_append(list, info);
    }
    RzTable *table = rz_core_table(core);
    rz_table_visual_list(table, list, core->offset, core->blocksize,
        rz_cons_get_size(NULL), rz_config_get_i(core->config, "scr.color"));
    char *tablestr = rz_table_tostring(table);
    rz_cons_printf("%s", tablestr);
    rz_table_free(table);
    rz_list_free(list);
    free(tablestr);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::blocksize, rz_core_t::config, free(), info(), rz_core_t::io, list(), map(), maps(), NULL, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_config_get_i(), rz_cons_get_size(), rz_cons_printf(), rz_core_table(), rz_io_maps(), rz_list_append(), rz_list_free(), rz_list_newf(), rz_listinfo_free(), rz_listinfo_new(), rz_pvector_foreach_prev, rz_strf, rz_table_free(), rz_table_tostring(), and rz_table_visual_list().

Referenced by rzshell_cmddescs_init().

rz_open_maps_list_cur_handler()

RZ_IPI RzCmdStatus rz_open_maps_list_cur_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 637 of file cmd_open.c.

                                                                                                                     {
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    if (!map) {
        RZ_LOG_ERROR("Cannot find any map at the current address %" PFMT64x "\n", core->offset);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cmd_state_output_set_columnsf(state, "ddxxxxxss", "id", "fd", "pa", "pa_end", "va", "va_end", "perm", "name");
    if (state->mode == RZ_OUTPUT_MODE_TABLE) {
        state->d.t->showFancy = true;
    }
    open_maps_show(core, state, map, false);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::io, map(), rz_core_t::offset, open_maps_show(), PFMT64x, rz_cmd_state_output_set_columnsf(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_get(), RZ_LOG_ERROR, and RZ_OUTPUT_MODE_TABLE.

Referenced by rzshell_cmddescs_init().

rz_open_maps_list_handler()

RZ_IPI RzCmdStatus rz_open_maps_list_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 631 of file cmd_open.c.

                                                                                                                 {
    int fd = argc > 1 ? rz_num_math(NULL, argv[1]) : -1;
    open_maps_list(core, state, fd);
    return RZ_CMD_STATUS_OK;
}

References argv, fd, NULL, open_maps_list(), RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_map_fd_handler()

RZ_IPI RzCmdStatus rz_open_maps_map_fd_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 471 of file cmd_open.c.

                                                                                          {
    ut32 fd = argc > 1 ? rz_num_math(NULL, argv[1]) : rz_io_fd_get_current(core->io);
    RzIODesc *desc = rz_io_desc_get(core->io, fd);
    if (!desc) {
        RZ_LOG_ERROR("Cannot find any descriptor with fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    ut64 size = rz_io_desc_size(desc);
    RzIOMap *map = rz_io_map_add(core->io, fd, desc->perm, 0, 0, size);
    if (!map) {
        RZ_LOG_ERROR("Cannot create new map for fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_set_name(map, desc->name);
    return RZ_CMD_STATUS_OK;
}

References argv, desc, fd, rz_core_t::io, map(), NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_desc_get(), rz_io_desc_size(), rz_io_fd_get_current(), rz_io_map_add(), rz_io_map_set_name(), RZ_LOG_ERROR, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_maps_map_handler()

RZ_IPI RzCmdStatus rz_open_maps_map_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 544 of file cmd_open.c.

                                                                                       {
    int fd = (int)rz_num_math(NULL, argv[1]);
    if (fd < 3) {
        RZ_LOG_ERROR("Wrong fd, it must be greather than 3\n");
        return RZ_CMD_STATUS_ERROR;
    }
 
    ut64 vaddr = rz_num_math(core->num, argv[2]);
    ut64 size = argc > 3 ? rz_num_math(core->num, argv[3]) : rz_io_fd_size(core->io, fd);
    ut64 paddr = argc > 4 ? rz_num_math(core->num, argv[4]) : 0;
    int rwx = argc > 5 ? rz_str_rwx(argv[5]) : 0;
    const char *name = argc > 6 ? argv[6] : "";
 
    if (argc <= 5) {
        RzIODesc *desc = rz_io_desc_get(core->io, fd);
        if (!desc) {
            RZ_LOG_ERROR("Could not determine any opened file with fd %d\n", fd);
            return RZ_CMD_STATUS_ERROR;
        }
 
        rwx = desc->perm;
    }
    RzIOMap *map = rz_io_map_add(core->io, fd, rwx, paddr, vaddr, size);
    if (!map) {
        RZ_LOG_ERROR("Could not create new map for fd %d at vaddr %" PFMT64x "\n", fd, vaddr);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_set_name(map, name);
    return RZ_CMD_STATUS_OK;
}

References argv, desc, fd, int, rz_core_t::io, map(), NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_desc_get(), rz_io_fd_size(), rz_io_map_add(), rz_io_map_set_name(), RZ_LOG_ERROR, rz_num_math(), rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_maps_name_del_handler()

RZ_IPI RzCmdStatus rz_open_maps_name_del_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 439 of file cmd_open.c.

                                                                                            {
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    if (!map) {
        RZ_LOG_ERROR("Cannot find any map at address %" PFMT64x "\n", core->offset);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_del_name(map);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::io, map(), rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_del_name(), rz_io_map_get(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

rz_open_maps_name_handler()

RZ_IPI RzCmdStatus rz_open_maps_name_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 429 of file cmd_open.c.

                                                                                        {
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    if (!map) {
        RZ_LOG_ERROR("Cannot find any map at address %" PFMT64x "d\n", core->offset);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_set_name(map, argv[1]);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, map(), rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_get(), rz_io_map_set_name(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

rz_open_maps_name_id_del_handler()

RZ_IPI RzCmdStatus rz_open_maps_name_id_del_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 460 of file cmd_open.c.

                                                                                               {
    ut32 id = rz_num_math(core->num, argv[1]);
    RzIOMap *map = rz_io_map_resolve(core->io, id);
    if (!map) {
        RZ_LOG_ERROR("Cannot find any map with id %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_del_name(map);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, map(), rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_del_name(), rz_io_map_resolve(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_name_id_handler()

RZ_IPI RzCmdStatus rz_open_maps_name_id_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 449 of file cmd_open.c.

                                                                                           {
    ut32 id = rz_num_math(core->num, argv[1]);
    RzIOMap *map = rz_io_map_resolve(core->io, id);
    if (!map) {
        RZ_LOG_ERROR("Cannot find any map with id %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_set_name(map, argv[2]);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, map(), rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_resolve(), rz_io_map_set_name(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_prioritize_binid_handler()

RZ_IPI RzCmdStatus rz_open_maps_prioritize_binid_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 385 of file cmd_open.c.

                                                                                                    {
    ut32 id = (ut32)rz_num_math(core->num, argv[1]);
    if (!rz_bin_file_set_cur_by_id(core->bin, id)) {
        RZ_LOG_ERROR("Cannot prioritize bin with fd %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    RzListIter *it;
    RzCoreFile *file = NULL;
    rz_list_foreach (core->files, it, file) {
        void **binfile;
        rz_pvector_foreach (&file->binfiles, binfile) {
            RzBinFile *bf = *binfile;
            if (bf->id == id) {
                void **map;
                rz_pvector_foreach (&file->maps, map) {
                    RzIOMap *m = *map;
                    rz_io_map_priorize(core->io, m->id);
                }
            }
        }
    }
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::bin, rz_core_t::files, rz_bin_file_t::id, rz_core_t::io, regress::m, map(), NULL, rz_core_t::num, rz_bin_file_set_cur_by_id(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_priorize(), RZ_LOG_ERROR, rz_num_math(), and rz_pvector_foreach.

Referenced by rzshell_cmddescs_init().

rz_open_maps_prioritize_fd_handler()

RZ_IPI RzCmdStatus rz_open_maps_prioritize_fd_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 420 of file cmd_open.c.

                                                                                                 {
    int fd = (int)rz_num_math(core->num, argv[1]);
    if (!rz_io_map_priorize_for_fd(core->io, fd)) {
        RZ_LOG_ERROR("Cannot prioritize any map for fd %d\n", fd);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, fd, int, rz_core_t::io, rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_priorize_for_fd(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_prioritize_handler()

RZ_IPI RzCmdStatus rz_open_maps_prioritize_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 374 of file cmd_open.c.

                                                                                              {
    ut32 id = (ut32)rz_num_math(core->num, argv[1]);
    if (!rz_io_map_exists_for_id(core->io, id)) {
        RZ_LOG_ERROR("Cannot find any map with mapid %d\n", id);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_io_map_priorize(core->io, id);
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, rz_core_t::num, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_map_exists_for_id(), rz_io_map_priorize(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_relocate_current_handler()

RZ_IPI RzCmdStatus rz_open_maps_relocate_current_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 338 of file cmd_open.c.

                                                                                                    {
    if (!rz_num_is_valid_input(core->num, argv[1])) {
        RZ_LOG_ERROR("Invalid address '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    if (!map) {
        RZ_LOG_ERROR("Could not find any IO map at current offset\n");
        return RZ_CMD_STATUS_ERROR;
    }
    ut64 addr = rz_num_math(core->num, argv[1]);
    if (!rz_io_map_remap(core->io, map->id, addr)) {
        RZ_LOG_ERROR("Could not relocate map with id %d to %" PFMT64x "\n", map->id, addr);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References addr, argv, rz_core_t::io, map(), rz_core_t::num, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_get(), rz_io_map_remap(), RZ_LOG_ERROR, rz_num_is_valid_input(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_maps_relocate_handler()

RZ_IPI RzCmdStatus rz_open_maps_relocate_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 320 of file cmd_open.c.

                                                                                            {
    if (!rz_num_is_valid_input(NULL, argv[1])) {
        RZ_LOG_ERROR("Invalid map id '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_num_is_valid_input(core->num, argv[2])) {
        RZ_LOG_ERROR("Invalid address '%s'\n", argv[2]);
        return RZ_CMD_STATUS_ERROR;
    }
    ut32 map_id = (ut32)rz_num_math(NULL, argv[1]);
    ut64 addr = rz_num_math(core->num, argv[2]);
    if (!rz_io_map_remap(core->io, map_id, addr)) {
        RZ_LOG_ERROR("Could not relocate map with id %d to %" PFMT64x "\n", map_id, addr);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References addr, argv, rz_core_t::io, NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_remap(), RZ_LOG_ERROR, rz_num_is_valid_input(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_maps_remove_all_handler()

RZ_IPI RzCmdStatus rz_open_maps_remove_all_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 271 of file cmd_open.c.

                                                                                              {
    rz_io_map_reset(core->io);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::io, RZ_CMD_STATUS_OK, and rz_io_map_reset().

Referenced by rzshell_cmddescs_init().

rz_open_maps_remove_handler()

RZ_IPI RzCmdStatus rz_open_maps_remove_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 258 of file cmd_open.c.

                                                                                          {
    if (!rz_num_is_valid_input(NULL, argv[1])) {
        RZ_LOG_ERROR("Invalid map id '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    ut32 map_id = rz_num_math(NULL, argv[1]);
    if (!rz_io_map_del(core->io, map_id)) {
        RZ_LOG_ERROR("Could not delete IO map %d\n", map_id);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_del(), RZ_LOG_ERROR, rz_num_is_valid_input(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_maps_resize_handler()

RZ_IPI RzCmdStatus rz_open_maps_resize_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 356 of file cmd_open.c.

                                                                                          {
    if (!rz_num_is_valid_input(NULL, argv[1])) {
        RZ_LOG_ERROR("Invalid map id '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    if (!rz_num_is_valid_input(core->num, argv[2])) {
        RZ_LOG_ERROR("Invalid size '%s'\n", argv[2]);
        return RZ_CMD_STATUS_ERROR;
    }
    ut32 map_id = (ut32)rz_num_math(NULL, argv[1]);
    ut64 size = rz_num_math(core->num, argv[2]);
    if (!rz_io_map_resize(core->io, map_id, size)) {
        RZ_LOG_ERROR("Could not resize map with id %d to %" PFMT64x "\n", map_id, size);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::io, NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_map_resize(), RZ_LOG_ERROR, rz_num_is_valid_input(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_nobin_handler()

RZ_IPI RzCmdStatus rz_open_nobin_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 962 of file cmd_open.c.

                                                                                    {
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    int perms = argc > 3 ? rz_str_rwx(argv[3]) : RZ_PERM_R;
    return open_nobin_file(core, argv[1], addr, perms);
}

References addr, argv, rz_core_t::num, open_nobin_file(), rz_num_math(), RZ_PERM_R, rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_nobin_write_handler()

RZ_IPI RzCmdStatus rz_open_nobin_write_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 968 of file cmd_open.c.

                                                                                          {
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    int perms = argc > 3 ? rz_str_rwx(argv[3]) : RZ_PERM_RW;
    return open_nobin_file(core, argv[1], addr, perms);
}

References addr, argv, rz_core_t::num, open_nobin_file(), rz_num_math(), RZ_PERM_RW, rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_open_prioritize_handler()

RZ_IPI RzCmdStatus rz_open_prioritize_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 235 of file cmd_open.c.

                                                                                         {
    int fd = atoi(argv[1]);
    return prioritize_file(core, fd);
}

References argv, fd, and prioritize_file().

Referenced by rzshell_cmddescs_init().

rz_open_prioritize_next_handler()

RZ_IPI RzCmdStatus rz_open_prioritize_next_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 240 of file cmd_open.c.

                                                                                              {
    int fd = rz_io_fd_get_next(core->io, rz_io_fd_get_current(core->io));
    return prioritize_file(core, fd);
}

References fd, rz_core_t::io, prioritize_file(), rz_io_fd_get_current(), and rz_io_fd_get_next().

Referenced by rzshell_cmddescs_init().

rz_open_prioritize_next_rotate_handler()

RZ_IPI RzCmdStatus rz_open_prioritize_next_rotate_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 250 of file cmd_open.c.

                                                                                                     {
    int fd = rz_io_fd_get_next(core->io, rz_io_fd_get_current(core->io));
    if (fd == -1) {
        fd = rz_io_fd_get_lowest(core->io);
    }
    return prioritize_file(core, fd) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References fd, rz_core_t::io, prioritize_file(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_fd_get_current(), rz_io_fd_get_lowest(), and rz_io_fd_get_next().

Referenced by rzshell_cmddescs_init().

rz_open_prioritize_prev_handler()

RZ_IPI RzCmdStatus rz_open_prioritize_prev_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 245 of file cmd_open.c.

                                                                                              {
    int fd = rz_io_fd_get_prev(core->io, rz_io_fd_get_current(core->io));
    return prioritize_file(core, fd);
}

References fd, rz_core_t::io, prioritize_file(), rz_io_fd_get_current(), and rz_io_fd_get_prev().

Referenced by rzshell_cmddescs_init().

rz_open_show_current_handler()

RZ_IPI RzCmdStatus rz_open_show_current_handler	(	RzCore *	core,
		int	argc,
		const char **	argv,
		RzCmdStateOutput *	state
	)

Definition at line 841 of file cmd_open.c.

                                                                                                                    {
    RzIOMap *map = rz_io_map_get(core->io, core->offset);
    if (!map) {
        RZ_LOG_ERROR("Could not find any map at current address %" PFMT64x ".\n", core->offset);
        return RZ_CMD_STATUS_ERROR;
    }
    RzIODesc *desc = rz_io_desc_get(core->io, map->fd);
    if (!desc) {
        RZ_LOG_ERROR("Could not find file for map fd %d.\n", map->fd);
        return RZ_CMD_STATUS_ERROR;
    }
 
    rz_cmd_state_output_set_columnsf(state, "dbsXs", "fd", "raised", "perm", "size", "uri");
    switch (state->mode) {
    case RZ_OUTPUT_MODE_STANDARD:
        desc_list_cb(core->print, desc, 0);
        break;
    case RZ_OUTPUT_MODE_JSON:
        desc_list_json_cb(state->d.pj, desc, 0);
        break;
    case RZ_OUTPUT_MODE_TABLE:
        desc_list_table_cb(state->d.t, desc, 0);
        break;
    case RZ_OUTPUT_MODE_QUIET:
        desc_list_quiet_cb(core->print, desc, 0);
        break;
    default:
        break;
    }
    return RZ_CMD_STATUS_OK;
}

References desc, desc_list_cb(), desc_list_json_cb(), desc_list_quiet_cb(), desc_list_table_cb(), rz_core_t::io, map(), rz_core_t::offset, PFMT64x, rz_core_t::print, rz_cmd_state_output_set_columnsf(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_desc_get(), rz_io_map_get(), RZ_LOG_ERROR, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, and RZ_OUTPUT_MODE_TABLE.

Referenced by rzshell_cmddescs_init().

rz_open_use_handler()

RZ_IPI RzCmdStatus rz_open_use_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 188 of file cmd_open.c.

                                                                                  {
    RzListIter *iter = NULL;
    RzCoreFile *f;
 
    int fdnum = rz_num_math(NULL, argv[1]);
    rz_list_foreach (core->files, iter, f) {
        if (f->fd == fdnum) {
            core->file = f;
            rz_io_use_fd(core->io, fdnum);
            RzBinFile *bf = rz_bin_file_find_by_fd(core->bin, fdnum);
            if (!bf) {
                RZ_LOG_ERROR("Could not find binfile with fd %d\n", fdnum);
                return RZ_CMD_STATUS_ERROR;
            }
            rz_core_bin_raise(core, bf->id);
            rz_core_block_read(core);
            RZ_LOG_INFO("Switched to fd %d (%s)\n", fdnum, bf->file);
            return RZ_CMD_STATUS_OK;
        }
    }
    RZ_LOG_ERROR("Could not find any opened file with fd %d\n", fdnum);
    return RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::bin, f, rz_bin_file_t::file, rz_core_t::file, rz_core_t::files, rz_bin_file_t::id, rz_core_t::io, NULL, rz_bin_file_find_by_fd(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_bin_raise(), rz_core_block_read(), rz_io_use_fd(), RZ_LOG_ERROR, RZ_LOG_INFO, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_open_write_handler()

RZ_IPI RzCmdStatus rz_open_write_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 812 of file cmd_open.c.

                                                                                    {
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    int perms = argc > 3 ? rz_str_rwx(argv[3]) : RZ_PERM_RW;
    return bool2status(rz_core_file_open_load(core, argv[1], addr, perms, true));
}

References addr, argv, bool2status(), rz_core_t::num, rz_core_file_open_load(), rz_num_math(), RZ_PERM_RW, rz_str_rwx(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_reopen_binary_handler()

RZ_IPI RzCmdStatus rz_reopen_binary_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1014 of file cmd_open.c.

                                                                                       {
    return bool2status(rz_core_file_reopen(core, argv[1], 0, 2));
}

References argv, bool2status(), and rz_core_file_reopen().

Referenced by rzshell_cmddescs_init().

rz_reopen_core_handler()

RZ_IPI RzCmdStatus rz_reopen_core_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1018 of file cmd_open.c.

                                                                                     {
    if (!core->io || !core->io->desc) {
        RZ_LOG_ERROR("Could not find current file\n");
        return RZ_CMD_STATUS_ERROR;
    }
 
    return open_core_file(core, core->io->desc->uri);
}

References rz_io_t::desc, rz_core_t::io, open_core_file(), RZ_CMD_STATUS_ERROR, RZ_LOG_ERROR, and rz_io_desc_t::uri.

Referenced by rzshell_cmddescs_init().

rz_reopen_debug_file_handler()

RZ_IPI RzCmdStatus rz_reopen_debug_file_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1048 of file cmd_open.c.

                                                                                           {
    const char *uri = argv[1];
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    rz_core_file_reopen_remote_debug(core, uri, addr);
    return RZ_CMD_STATUS_OK;
}

References addr, argv, rz_core_t::num, RZ_CMD_STATUS_OK, rz_core_file_reopen_remote_debug(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_reopen_debug_handler()

RZ_IPI RzCmdStatus rz_reopen_debug_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1027 of file cmd_open.c.

                                                                                      {
    // TODO: this is bad as we force ourselves to convert arguments to strings.
    //       There should be an API to reopen a file in debug mode and directly
    //       pass args to it.
    char **args = RZ_NEWS(char *, argc - 1);
    int i;
    for (i = 1; i < argc; i++) {
        char *t = rz_cmd_escape_arg(argv[i], RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG);
        args[i - 1] = rz_str_newf("\"%s\"", t);
        free(t);
    }
    char *args_str = rz_str_array_join((const char **)args, argc - 1, " ");
    for (i = 0; i < argc - 1; i++) {
        free(args[i]);
    }
    free(args);
    rz_core_file_reopen_debug(core, args_str);
    free(args_str);
    return RZ_CMD_STATUS_OK;
}

References args, argv, free(), i, rz_cmd_escape_arg(), RZ_CMD_ESCAPE_DOUBLE_QUOTED_ARG, RZ_CMD_STATUS_OK, rz_core_file_reopen_debug(), RZ_NEWS, rz_str_array_join(), and rz_str_newf().

Referenced by rzshell_cmddescs_init().

rz_reopen_debug_rzrun_handler()

RZ_IPI RzCmdStatus rz_reopen_debug_rzrun_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1055 of file cmd_open.c.

                                                                                            {
    char *file = rz_file_temp("rz-run");
    char *s = strdup(argv[1]);
    rz_config_set(core->config, "dbg.profile", file);
    rz_str_replace_char(s, ',', '\n');
    rz_file_dump(file, (const ut8 *)s, strlen(s), 0);
    rz_file_dump(file, (const ut8 *)"\n", 1, 1);
    free(s);
    free(file);
    rz_core_file_reopen_debug(core, "");
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::config, free(), RZ_CMD_STATUS_OK, rz_config_set(), rz_core_file_reopen_debug(), rz_file_dump(), rz_file_temp(), rz_str_replace_char(), s, and strdup().

Referenced by rzshell_cmddescs_init().

rz_reopen_handler()

RZ_IPI RzCmdStatus rz_reopen_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 974 of file cmd_open.c.

                                                                                {
    int fd;
    if (argc > 1) {
        fd = (int)rz_num_math(NULL, argv[1]);
        if (fd < 0) {
            RZ_LOG_ERROR("Invalid negative fd %d\n", fd);
            return RZ_CMD_STATUS_ERROR;
        }
    } else {
        if (!core->io || !core->io->desc) {
            RZ_LOG_ERROR("Cannot find current file.\n");
            return RZ_CMD_STATUS_ERROR;
        }
        fd = core->io->desc->fd;
    }
    rz_core_io_file_open(core, fd);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_io_t::desc, fd, rz_io_desc_t::fd, int, rz_core_t::io, NULL, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_io_file_open(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_reopen_malloc_handler()

RZ_IPI RzCmdStatus rz_reopen_malloc_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1068 of file cmd_open.c.

                                                                                       {
    rz_core_file_reopen_in_malloc(core);
    return RZ_CMD_STATUS_OK;
}

References RZ_CMD_STATUS_OK, and rz_core_file_reopen_in_malloc().

Referenced by rzshell_cmddescs_init().

rz_reopen_nobin_handler()

RZ_IPI RzCmdStatus rz_reopen_nobin_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1073 of file cmd_open.c.

                                                                                      {
    return bool2status(rz_core_file_reopen(core, NULL, 0, 0));
}

References bool2status(), NULL, and rz_core_file_reopen().

Referenced by rzshell_cmddescs_init().

rz_reopen_nobin_headers_handler()

RZ_IPI RzCmdStatus rz_reopen_nobin_headers_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1100 of file cmd_open.c.

                                                                                              {
    return reopen_nobin_headers(core, 0);
}

References reopen_nobin_headers().

Referenced by rzshell_cmddescs_init().

rz_reopen_nobin_write_handler()

RZ_IPI RzCmdStatus rz_reopen_nobin_write_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1077 of file cmd_open.c.

                                                                                            {
    return bool2status(rz_core_file_reopen(core, NULL, RZ_PERM_RW, 0));
}

References bool2status(), NULL, rz_core_file_reopen(), and RZ_PERM_RW.

Referenced by rzshell_cmddescs_init().

rz_reopen_nobin_write_headers_handler()

RZ_IPI RzCmdStatus rz_reopen_nobin_write_headers_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 1104 of file cmd_open.c.

                                                                                                    {
    return reopen_nobin_headers(core, RZ_PERM_RW);
}

References reopen_nobin_headers(), and RZ_PERM_RW.

Referenced by rzshell_cmddescs_init().

rz_reopen_write_handler()

RZ_IPI RzCmdStatus rz_reopen_write_handler	(	RzCore *	core,
		int	argc,
		const char **	argv
	)

Definition at line 993 of file cmd_open.c.

                                                                                      {
    int fd;
    int perms = RZ_PERM_RW;
    if (argc > 1) {
        fd = (int)rz_num_math(NULL, argv[1]);
        if (fd < 0) {
            RZ_LOG_ERROR("Invalid negative fd %d\n", fd);
            return RZ_CMD_STATUS_ERROR;
        }
    } else {
        if (!core->io || !core->io->desc) {
            RZ_LOG_ERROR("Cannot find current file.\n");
            return RZ_CMD_STATUS_ERROR;
        }
        fd = core->io->desc->fd;
        perms |= core->io->desc->perm;
    }
    rz_core_io_file_reopen(core, fd, perms);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_io_t::desc, fd, rz_io_desc_t::fd, int, rz_core_t::io, NULL, rz_io_desc_t::perm, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_io_file_reopen(), RZ_LOG_ERROR, rz_num_math(), and RZ_PERM_RW.

Referenced by rzshell_cmddescs_init().