yank.c File Reference

#include <rz_core.h>
#include <rz_util.h>
#include <rz_io.h>
#include "core_private.h"

Go to the source code of this file.

Functions
static int	perform_mapped_file_yank (RzCore *core, ut64 offset, ut64 len, const char *filename)
RZ_API bool	rz_core_yank_set (RzCore *core, ut64 addr, RZ_NONNULL const ut8 *buf, ut64 len)
RZ_API bool	rz_core_yank_set_str (RzCore *core, ut64 addr, RZ_NONNULL const char *str)
RZ_API bool	rz_core_yank (RzCore *core, ut64 addr, ut64 len)
RZ_API bool	rz_core_yank_string (RzCore *core, ut64 addr, ut64 maxlen)
RZ_API bool	rz_core_yank_paste (RzCore *core, ut64 addr, ut64 len)
RZ_API bool	rz_core_yank_to (RzCore *core, ut64 len, ut64 addr)
RZ_API RZ_OWN char *	rz_core_yank_as_string (RzCore *core, ut64 pos)
RZ_API bool	rz_core_yank_dump (RzCore *core, ut64 pos, RzCmdStateOutput *state)
RZ_API bool	rz_core_yank_print_hexdump (RzCore *core, ut64 pos)
RZ_API bool	rz_core_yank_print (RzCore *core, ut64 pos)
RZ_API bool	rz_core_yank_print_string (RzCore *core, ut64 pos)
RZ_API bool	rz_core_yank_hud_file (RzCore *core, const char *input)
RZ_API bool	rz_core_yank_hud_path (RzCore *core, const char *input, int dir)
RZ_API bool	rz_core_yank_hexpair (RzCore *core, const char *str)
RZ_API bool	rz_core_yank_file (RzCore *core, ut64 len, ut64 addr, const char *filename)
RZ_API bool	rz_core_yank_file_all (RzCore *core, const char *filename)

Function Documentation

perform_mapped_file_yank()

static int perform_mapped_file_yank ( RzCore *  core, ut64  offset, ut64  len, const char *  filename  )

static

Definition at line 15 of file yank.c.

                                                                                               {
    // grab the current file descriptor, so we can reset core and io state
    // after our io op is done
    RzIODesc *yankdesc = NULL;
    ut64 fd = core->file ? core->file->fd : -1, yank_file_sz = 0, addr = offset;
    int res = false;
 
    if (RZ_STR_ISNOTEMPTY(filename)) {
        ut64 load_align = rz_config_get_i(core->config, "file.loadalign");
        yankdesc = rz_io_open_nomap(core->io, filename, RZ_PERM_R, 0644);
        // map the file in for IO operations.
        if (yankdesc && load_align) {
            yank_file_sz = rz_io_size(core->io);
            ut64 addr = rz_io_map_next_available(core->io, 0, yank_file_sz, load_align);
            RzIOMap *map = rz_io_map_new(core->io, yankdesc->fd, RZ_PERM_R, 0, addr, yank_file_sz);
            if (!map || map->itv.addr == -1) {
                eprintf("Unable to map the opened file: %s", filename);
                rz_io_desc_close(yankdesc);
                yankdesc = NULL;
            }
        }
    }
 
    // if len is -1 then we yank in everything
    if (len == -1) {
        len = yank_file_sz;
    }
 
    // this wont happen if the file failed to open or the file failed to
    // map into the IO layer
    if (yankdesc) {
        ut64 res = rz_io_seek(core->io, addr, RZ_IO_SEEK_SET);
        ut64 actual_len = len <= yank_file_sz ? len : 0;
        ut8 *buf = NULL;
        if (actual_len > 0 && res == addr) {
            buf = malloc(actual_len);
            rz_io_read_at(core->io, addr, buf, actual_len);
            rz_core_yank_set(core, RZ_CORE_FOREIGN_ADDR, buf, len);
        } else if (res != addr) {
            eprintf(
                "ERROR: Unable to yank data from file: (loadaddr (0x%" PFMT64x ") (addr (0x%" PFMT64x ") > file_sz (0x%" PFMT64x ")\n", res, addr,
                yank_file_sz);
        } else if (actual_len == 0) {
            eprintf(
                "ERROR: Unable to yank from file: addr+len (0x%" PFMT64x ") > file_sz (0x%" PFMT64x ")\n", addr + len,
                yank_file_sz);
        }
        rz_io_desc_close(yankdesc);
        free(buf);
    }
    if (fd != -1) {
        rz_io_use_fd(core->io, fd);
        core->switch_file_view = 1;
        rz_core_block_read(core);
    }
    return res;
}

References addr, rz_core_t::config, eprintf, fd, rz_core_file_t::fd, rz_io_desc_t::fd, rz_core_t::file, free(), rz_core_t::io, len, malloc(), map(), NULL, PFMT64x, rz_config_get_i(), rz_core_block_read(), rz_core_yank_set(), rz_io_desc_close(), rz_io_map_new(), rz_io_map_next_available(), rz_io_open_nomap(), rz_io_read_at(), rz_io_seek(), RZ_IO_SEEK_SET, rz_io_size(), rz_io_use_fd(), RZ_PERM_R, RZ_STR_ISNOTEMPTY, rz_core_t::switch_file_view, and ut64().

Referenced by rz_core_yank_file(), and rz_core_yank_file_all().

rz_core_yank()

RZ_API bool rz_core_yank	(	RzCore *	core,
		ut64	addr,
		ut64	len
	)

Definition at line 118 of file yank.c.

                                                            {
    if (len == 0) {
        len = core->blocksize;
    }
    ut64 curseek = core->offset;
    ut8 *buf = malloc(len);
    if (!buf) {
        return false;
    }
    if (addr != core->offset) {
        rz_core_seek(core, addr, true);
    }
    rz_io_read_at(core->io, addr, buf, len);
    rz_core_yank_set(core, addr, buf, len);
    if (curseek != addr) {
        rz_core_seek(core, curseek, true);
    }
    free(buf);
    return true;
}

References addr, rz_core_t::blocksize, free(), rz_core_t::io, len, malloc(), rz_core_t::offset, rz_core_seek(), rz_core_yank_set(), rz_io_read_at(), and ut64().

Referenced by rz_core_visual_cmd(), rz_core_yank_to(), and rz_yank_handler().

rz_core_yank_as_string()

RZ_API RZ_OWN char* rz_core_yank_as_string	(	RzCore *	core,
		ut64	pos
	)

Definition at line 203 of file yank.c.

                                                                   {
    int i = 0;
    RzStrBuf *buf = rz_strbuf_new("");
    for (i = pos; i < rz_buf_size(core->yank_buf); i++) {
        ut8 tmp;
        if (!rz_buf_read8_at(core->yank_buf, i, &tmp)) {
            rz_strbuf_free(buf);
            return NULL;
        }
        rz_strbuf_appendf(buf, "%02x", tmp);
    }
    return rz_strbuf_drain(buf);
}

References i, NULL, pos, rz_buf_read8_at(), rz_buf_size(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_free(), rz_strbuf_new(), autogen_x86imm::tmp, and rz_core_t::yank_buf.

Referenced by rz_core_yank_dump(), and rz_yank_editor_handler().

rz_core_yank_dump()

RZ_API bool rz_core_yank_dump	(	RzCore *	core,
		ut64	pos,
		RzCmdStateOutput *	state
	)

Definition at line 219 of file yank.c.

                                                                               {
    RzOutputMode mode = state->mode;
    PJ *pj = state->d.pj;
    int ybl = rz_buf_size(core->yank_buf);
    if (ybl <= 0) {
        RZ_LOG_ERROR("No buffer yanked already\n");
        return false;
    }
    if (pos >= ybl) {
        RZ_LOG_ERROR("Position exceeds buffer length.\n");
        return false;
    }
    char *str = rz_core_yank_as_string(core, pos);
    if (!str) {
        return false;
    }
 
    switch (mode) {
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_println(str);
        break;
    case RZ_OUTPUT_MODE_JSON: {
        pj_o(pj);
        pj_kn(pj, "addr", core->yank_addr);
        pj_ks(pj, "bytes", str);
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_RIZIN:
        rz_cons_printf("wx %s", str);
        rz_cons_newline();
        break;
    case RZ_OUTPUT_MODE_STANDARD:
        rz_cons_printf("0x%08" PFMT64x " %" PFMT64d " ",
            core->yank_addr + pos,
            rz_buf_size(core->yank_buf) - pos);
        rz_cons_println(str);
        break;
    default:
        rz_warn_if_reached();
        break;
    }
    free(str);
    return true;
}

References free(), PFMT64d, PFMT64x, pj_end(), pj_kn(), pj_ks(), pj_o(), pos, rz_buf_size(), rz_cons_newline(), rz_cons_printf(), rz_cons_println(), rz_core_yank_as_string(), RZ_LOG_ERROR, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_warn_if_reached, cmd_descs_generate::str, rz_core_t::yank_addr, and rz_core_t::yank_buf.

Referenced by rz_yank_handler().

rz_core_yank_file()

RZ_API bool rz_core_yank_file	(	RzCore *	core,
		ut64	len,
		ut64	addr,
		const char *	filename
	)

Definition at line 384 of file yank.c.

                                                                                       {
    if (RZ_STR_ISEMPTY(filename)) {
        return false;
    }
    return perform_mapped_file_yank(core, addr, len, filename);
}

References addr, len, perform_mapped_file_yank(), and RZ_STR_ISEMPTY.

Referenced by rz_yank_file_handler().

rz_core_yank_file_all()

RZ_API bool rz_core_yank_file_all	(	RzCore *	core,
		const char *	filename
	)

Definition at line 398 of file yank.c.

                                                                      {
    if (RZ_STR_ISEMPTY(filename)) {
        return false;
    }
    return perform_mapped_file_yank(core, 0, -1, filename);
}

References perform_mapped_file_yank(), and RZ_STR_ISEMPTY.

Referenced by rz_yank_whole_file_handler().

rz_core_yank_hexpair()

RZ_API bool rz_core_yank_hexpair	(	RzCore *	core,
		const char *	str
	)

Definition at line 362 of file yank.c.

                                                                {
    if (RZ_STR_ISEMPTY(str)) {
        return false;
    }
    char *out = strdup(str);
    int len = rz_hex_str2bin(str, (ut8 *)str);
    if (len > 0) {
        rz_core_yank_set(core, core->offset, (ut8 *)out, len);
    }
    free(out);
    return true;
}

References free(), len, rz_core_t::offset, out, rz_core_yank_set(), rz_hex_str2bin(), RZ_STR_ISEMPTY, cmd_descs_generate::str, and strdup().

Referenced by rz_core_visual_view_rop(), rz_yank_editor_handler(), and rz_yank_hexpairs_handler().

rz_core_yank_hud_file()

RZ_API bool rz_core_yank_hud_file	(	RzCore *	core,
		const char *	input
	)

Definition at line 333 of file yank.c.

                                                                   {
    if (RZ_STR_ISEMPTY(input)) {
        return false;
    }
    char *buf = rz_cons_hud_file(input);
    if (RZ_STR_ISEMPTY(buf)) {
        return false;
    }
    bool res = rz_core_yank_set_str(core, RZ_CORE_FOREIGN_ADDR, buf);
    free(buf);
    return res;
}

References free(), input(), rz_cons_hud_file(), rz_core_yank_set_str(), and RZ_STR_ISEMPTY.

Referenced by rz_cmd_help().

rz_core_yank_hud_path()

RZ_API bool rz_core_yank_hud_path	(	RzCore *	core,
		const char *	input,
		int	dir
	)

Definition at line 346 of file yank.c.

                                                                            {
    if (RZ_STR_ISEMPTY(input)) {
        return false;
    }
    char *buf = rz_cons_hud_path(input, dir);
    if (RZ_STR_ISEMPTY(buf)) {
        free(buf);
        return false;
    }
    bool res = rz_core_yank_set_str(core, RZ_CORE_FOREIGN_ADDR, buf);
    free(buf);
    return res;
}

References free(), input(), rz_cons_hud_path(), rz_core_yank_set_str(), and RZ_STR_ISEMPTY.

Referenced by rz_cmd_help().

rz_core_yank_paste()

RZ_API bool rz_core_yank_paste	(	RzCore *	core,
		ut64	addr,
		ut64	len
	)

Definition at line 174 of file yank.c.

                                                                  {
    if (len == 0 || len >= rz_buf_size(core->yank_buf)) {
        len = rz_buf_size(core->yank_buf);
    }
    ut8 *buf = RZ_NEWS(ut8, len);
    if (!buf) {
        return false;
    }
    rz_buf_read_at(core->yank_buf, 0, buf, len);
    bool res = rz_core_write_at(core, addr, buf, len);
    free(buf);
    return res;
}

References addr, free(), len, rz_buf_read_at(), rz_buf_size(), rz_core_write_at(), RZ_NEWS, and rz_core_t::yank_buf.

Referenced by __paste_cb(), rz_core_visual_cmd(), rz_core_yank_to(), and rz_yank_paste_handler().

rz_core_yank_print()

RZ_API bool rz_core_yank_print	(	RzCore *	core,
		ut64	pos
	)

Definition at line 288 of file yank.c.

                                                       {
    int ybl = rz_buf_size(core->yank_buf);
    if (ybl <= 0) {
        RZ_LOG_ERROR("No buffer yanked already\n");
        return false;
    }
    if (pos >= ybl) {
        RZ_LOG_ERROR("Position exceeds buffer length.\n");
        return false;
    }
    ut64 sz = ybl - pos;
    char *buf = RZ_NEWS(char, sz);
    if (!buf) {
        return false;
    }
    rz_buf_read_at(core->yank_buf, pos, (ut8 *)buf, sz);
    rz_cons_memcat(buf, sz);
    rz_cons_newline();
    return true;
}

References pos, rz_buf_read_at(), rz_buf_size(), rz_cons_memcat(), rz_cons_newline(), RZ_LOG_ERROR, RZ_NEWS, ut64(), and rz_core_t::yank_buf.

Referenced by rz_yank_print_handler().

rz_core_yank_print_hexdump()

RZ_API bool rz_core_yank_print_hexdump	(	RzCore *	core,
		ut64	pos
	)

Definition at line 267 of file yank.c.

                                                               {
    int ybl = rz_buf_size(core->yank_buf);
    if (ybl <= 0) {
        RZ_LOG_ERROR("No buffer yanked already\n");
        return false;
    }
    if (pos >= ybl) {
        RZ_LOG_ERROR("Position exceeds buffer length.\n");
        return false;
    }
    ut8 *buf = RZ_NEWS(ut8, ybl - pos);
    if (!buf) {
        return false;
    }
    rz_buf_read_at(core->yank_buf, pos, buf, ybl - pos);
    rz_core_print_hexdump(core, pos, buf, ybl - pos, 16, 1, 1);
    return true;
}

References pos, rz_buf_read_at(), rz_buf_size(), rz_core_print_hexdump(), RZ_LOG_ERROR, RZ_NEWS, and rz_core_t::yank_buf.

Referenced by rz_yank_hex_print_handler().

rz_core_yank_print_string()

RZ_API bool rz_core_yank_print_string	(	RzCore *	core,
		ut64	pos
	)

Definition at line 311 of file yank.c.

                                                              {
    int ybl = rz_buf_size(core->yank_buf);
    if (ybl <= 0) {
        RZ_LOG_ERROR("No buffer yanked already\n");
        return false;
    }
    if (pos >= ybl) {
        RZ_LOG_ERROR("Position exceeds buffer length.\n");
        return false;
    }
    size_t sz = ybl - pos;
    char *buf = RZ_NEWS(char, sz);
    if (!buf) {
        return false;
    }
    rz_buf_read_at(core->yank_buf, pos, (ut8 *)buf, sz);
    int len = rz_str_nlen(buf, sz);
    rz_cons_memcat(buf, len);
    rz_cons_newline();
    return true;
}

References len, pos, rz_buf_read_at(), rz_buf_size(), rz_cons_memcat(), rz_cons_newline(), RZ_LOG_ERROR, RZ_NEWS, rz_str_nlen(), and rz_core_t::yank_buf.

Referenced by rz_yank_string_print_handler().

rz_core_yank_set()

RZ_API bool rz_core_yank_set	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const ut8 *	buf,
		ut64	len
	)

Definition at line 82 of file yank.c.

                                                                                           {
    rz_return_val_if_fail(buf, false);
    if (!len) {
        return false;
    }
    rz_buf_set_bytes(core->yank_buf, buf, len);
    core->yank_addr = addr;
    return true;
}

References addr, len, rz_buf_set_bytes(), rz_return_val_if_fail, rz_core_t::yank_addr, and rz_core_t::yank_buf.

Referenced by perform_mapped_file_yank(), rz_core_yank(), rz_core_yank_hexpair(), rz_core_yank_set_str(), and rz_core_yank_string().

rz_core_yank_set_str()

RZ_API bool rz_core_yank_set_str	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	str
	)

Definition at line 101 of file yank.c.

                                                                                      {
    rz_return_val_if_fail(str, false);
    size_t len = strlen(str) + 1;
    bool res = rz_core_yank_set(core, addr, (ut8 *)str, len);
    if (res == true) {
        ut8 zero = 0;
        rz_buf_write_at(core->yank_buf, len - 1, &zero, sizeof(zero));
    }
    return res;
}

References addr, len, rz_buf_write_at(), rz_core_yank_set(), rz_return_val_if_fail, cmd_descs_generate::str, and rz_core_t::yank_buf.

Referenced by rz_cmd_help(), rz_core_yank_hud_file(), and rz_core_yank_hud_path().

rz_core_yank_string()

RZ_API bool rz_core_yank_string	(	RzCore *	core,
		ut64	addr,
		ut64	maxlen
	)

Definition at line 147 of file yank.c.

                                                                      {
    ut64 curseek = core->offset;
    if (addr != core->offset) {
        rz_core_seek(core, addr, true);
    }
    /* Ensure space and safe termination for largest possible string allowed */
    ut8 *buf = calloc(1, core->blocksize + 1);
    if (!buf) {
        return false;
    }
    buf[core->blocksize] = 0;
    rz_io_read_at(core->io, addr, buf, core->blocksize);
    if (maxlen == 0) {
        maxlen = rz_str_nlen((const char *)buf, core->blocksize);
    } else if (maxlen > core->blocksize) {
        maxlen = core->blocksize;
    }
    rz_core_yank_set(core, addr, buf, maxlen);
    if (curseek != addr) {
        rz_core_seek(core, curseek, true);
    }
    free(buf);
    return true;
}

References addr, rz_core_t::blocksize, calloc(), free(), rz_core_t::io, maxlen, rz_core_t::offset, rz_core_seek(), rz_core_yank_set(), rz_io_read_at(), rz_str_nlen(), and ut64().

Referenced by rz_yank_string_handler().

rz_core_yank_to()

RZ_API bool rz_core_yank_to	(	RzCore *	core,
		ut64	len,
		ut64	addr
	)

Definition at line 193 of file yank.c.

                                                               {
    bool res = false;
    if (rz_core_yank(core, core->offset, len) == true) {
        res = rz_core_yank_paste(core, addr, len);
    }
    return res;
}

References addr, len, rz_core_t::offset, rz_core_yank(), and rz_core_yank_paste().

Referenced by rz_yank_to_handler().