cio.c File Reference

#include "rz_core.h"
#include "core_private.h"

Go to the source code of this file.

Functions
RZ_API int	rz_core_setup_debugger (RzCore *r, const char *debugbackend, bool attach)
RZ_API bool	rz_core_dump (RzCore *core, const char *file, ut64 addr, ut64 size, int append)
RZ_API void	rz_core_arch_bits_at (RzCore *core, ut64 addr, RZ_OUT RZ_NULLABLE int *bits, RZ_OUT RZ_BORROW RZ_NULLABLE const char **arch)
RZ_API void	rz_core_seek_arch_bits (RzCore *core, ut64 addr)
RZ_API bool	rz_core_write_at (RzCore *core, ut64 addr, const ut8 *buf, int size)
RZ_API bool	rz_core_extend_at (RzCore *core, ut64 addr, ut64 size)
	Extend the file at current offset by inserting size 0 bytes at addr. More...
RZ_API bool	rz_core_shift_block (RzCore *core, ut64 addr, ut64 b_size, st64 dist)
	Shift a block of data from addr of size b_size left or right based on dist. More...
RZ_API int	rz_core_block_read (RzCore *core)
RZ_API int	rz_core_is_valid_offset (RzCore *core, ut64 offset)
RZ_API int	rz_core_write_hexpair (RzCore *core, ut64 addr, const char *pairs)
RZ_API bool	rz_core_write_block (RzCore *core, ut64 addr, ut8 *data, size_t len)
RZ_API int	rz_core_write_assembly (RzCore *core, ut64 addr, RZ_NONNULL const char *instructions)
	Assembles instructions and writes the resulting data at the given offset. More...
RZ_API int	rz_core_write_assembly_fill (RzCore *core, ut64 addr, RZ_NONNULL const char *instructions)
	Assemble instructions and write the resulting data inside the current instruction. More...
RZ_API RzCmdStatus	rz_core_io_plugin_print (RzIOPlugin *plugin, RzCmdStateOutput *state)
	Print an IO plugin according to state. More...
RZ_API RzCmdStatus	rz_core_io_plugins_print (RzIO *io, RzCmdStateOutput *state)
	Print the registered IO plugins according to state. More...
RZ_API bool	rz_core_write_value_at (RzCore *core, ut64 addr, ut64 value, int sz)
	Write a given value at the specified address, using sz bytes. More...
RZ_API bool	rz_core_write_value_inc_at (RzCore *core, ut64 addr, st64 value, int sz)
	Write at addr the current value + value passed as argument. More...
RZ_API bool	rz_core_write_string_at (RzCore *core, ut64 addr, RZ_NONNULL const char *s)
	Write a given string s at the specified addr. More...
RZ_API bool	rz_core_write_string_wide_at (RzCore *core, ut64 addr, const char *s)
	Write a given string s as a wide string at the specified addr. More...
RZ_API bool	rz_core_write_length_string_at (RzCore *core, ut64 addr, const char *s)
	Write at the specified addr the length of the string in one byte, followed by the given string s. More...
RZ_API bool	rz_core_write_base64_at (RzCore *core, ut64 addr, RZ_NONNULL const char *s)
	Write a given string s at the specified addr encoded as base64. More...
RZ_API bool	rz_core_write_base64d_at (RzCore *core, ut64 addr, RZ_NONNULL const char *s)
	Write a given base64 string s at the specified addr, decoded. More...
RZ_API bool	rz_core_write_random_at (RzCore *core, ut64 addr, size_t len)
	Write len random bytes at address addr. More...
RZ_API RzCmdStatus	rz_core_io_cache_print (RzCore *core, RzCmdStateOutput *state)
RZ_API RzCmdStatus	rz_core_io_pcache_print (RzCore *core, RzIODesc *desc, RzCmdStateOutput *state)
RZ_API bool	rz_core_write_string_zero_at (RzCore *core, ut64 addr, const char *s)
	Write a given string s, followed by the zero terminator, at the specified addr. More...
RZ_API RZ_OWN ut8 *	rz_core_transform_op (RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen, int *buflen)
	Transform a block of data at addr according to the operation op and the hexvalue hex. More...
RZ_API bool	rz_core_write_block_op_at (RzCore *core, ut64 addr, RzCoreWriteOp op, ut8 *hex, int hexlen)
	Write a full block of data according to the operation op and the hexvalue hex. More...
RZ_API bool	rz_core_write_seq_at (RzCore *core, ut64 addr, ut64 from, ut64 to, ut64 step, int value_size)
	Write a full block of data with a sequence. More...
RZ_API bool	rz_core_write_duplicate_at (RzCore *core, ut64 addr, ut64 from, int len)
	Copy len bytes from from to addr. More...

Function Documentation

rz_core_arch_bits_at()

RZ_API void rz_core_arch_bits_at	(	RzCore *	core,
		ut64	addr,
		RZ_OUT RZ_NULLABLE int *	bits,
		RZ_OUT RZ_BORROW RZ_NULLABLE const char **	arch
	)

Definition at line 97 of file cio.c.

                                                                                                                                        {
    int bitsval = 0;
    const char *archval = NULL;
    RzBinObject *o = rz_bin_cur_object(core->bin);
    RzBinSection *s = o ? rz_bin_get_section_at(o, addr, core->io->va) : NULL;
    if (s) {
        if (!core->fixedarch) {
            archval = s->arch;
        }
        if (!core->fixedbits && s->bits) {
            // only enforce if there's one bits set
            switch (s->bits) {
            case RZ_SYS_BITS_16:
            case RZ_SYS_BITS_32:
            case RZ_SYS_BITS_64:
                bitsval = s->bits * 8;
                break;
            }
        }
    }
    // if we found bits related with analysis hints pick it up
    if (bits && !bitsval && !core->fixedbits) {
        bitsval = rz_analysis_hint_bits_at(core->analysis, addr, NULL);
    }
    if (arch && !archval && !core->fixedarch) {
        archval = rz_analysis_hint_arch_at(core->analysis, addr, NULL);
    }
    if (bits && bitsval) {
        *bits = bitsval;
    }
    if (arch && archval) {
        *arch = archval;
    }
}

References addr, rz_core_t::analysis, arch, rz_core_t::bin, bits(), rz_core_t::fixedarch, rz_core_t::fixedbits, rz_core_t::io, NULL, rz_analysis_hint_arch_at(), rz_analysis_hint_bits_at(), rz_bin_cur_object(), rz_bin_get_section_at(), RZ_SYS_BITS_16, RZ_SYS_BITS_32, RZ_SYS_BITS_64, s, and rz_io_t::va.

Referenced by bp_bits_at(), and rz_core_seek_arch_bits().

rz_core_block_read()

RZ_API int rz_core_block_read

(

RzCore *

core

)

Definition at line 243 of file cio.c.

                                            {
    if (core && core->block) {
        return rz_io_read_at(core->io, core->offset, core->block, core->blocksize);
    }
    return -1;
}

References rz_core_t::block, rz_core_t::blocksize, rz_core_t::io, rz_core_t::offset, and rz_io_read_at().

Referenced by __direction_disassembly_cb(), __print_hexdump_cb(), cb_iova(), cmd_print_bars(), file_resize(), handle_tmp_desc(), ioMemcpy(), open_nobin_file(), perform_mapped_file_yank(), prioritize_file(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_all_possible_opcodes_treeview_handler(), rz_cmd_disassembly_n_instrs_as_text_json_handler(), rz_cmd_print(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_bin_raise(), rz_core_binfiles_delete(), rz_core_cmd_subst_i(), rz_core_extend_at(), rz_core_file_open_load(), rz_core_file_reopen(), rz_core_file_reopen_remote_debug(), rz_core_handle_backwards_disasm(), rz_core_io_file_open(), rz_core_seek(), rz_core_serve(), rz_core_visual_cmd(), rz_core_visual_jump(), rz_core_write_at(), rz_main_rizin(), rz_open_binary_reload_handler(), rz_open_exchange_handler(), rz_open_maps_deprioritize_handler(), rz_open_maps_prioritize_handler(), rz_open_use_handler(), rz_write_cache_commit_all_handler(), rz_write_cache_remove_handler(), rz_write_from_file_handler(), and rz_write_from_io_xchg_handler().

rz_core_dump()

RZ_API bool rz_core_dump	(	RzCore *	core,
		const char *	file,
		ut64	addr,
		ut64	size,
		int	append
	)

Definition at line 50 of file cio.c.

                                                                                           {
    ut64 i;
    ut8 *buf;
    int bs = core->blocksize;
    FILE *fd;
    if (append) {
        fd = rz_sys_fopen(file, "ab");
    } else {
        rz_sys_truncate(file, 0);
        fd = rz_sys_fopen(file, "wb");
    }
    if (!fd) {
        eprintf("Cannot open '%s' for writing\n", file);
        return false;
    }
    /* some io backends seems to be buggy in those cases */
    if (bs > 4096) {
        bs = 4096;
    }
    buf = malloc(bs);
    if (!buf) {
        eprintf("Cannot alloc %d byte(s)\n", bs);
        fclose(fd);
        return false;
    }
    rz_cons_break_push(NULL, NULL);
    for (i = 0; i < size; i += bs) {
        if (rz_cons_is_breaked()) {
            break;
        }
        if ((i + bs) > size) {
            bs = size - i;
        }
        rz_io_read_at(core->io, addr + i, buf, bs);
        if (fwrite(buf, bs, 1, fd) < 1) {
            eprintf("write error\n");
            break;
        }
    }
    rz_cons_break_pop();
    fclose(fd);
    free(buf);
    return true;
}

References addr, append, rz_core_t::blocksize, eprintf, fd, benchmark::FILE, free(), i, rz_core_t::io, malloc(), NULL, rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_io_read_at(), rz_sys_fopen(), rz_sys_truncate(), and ut64().

Referenced by rz_cmd_debug_dmi(), and rz_core_visual_cmd().

rz_core_extend_at()

RZ_API bool rz_core_extend_at	(	RzCore *	core,
		ut64	addr,
		ut64	size
	)

Extend the file at current offset by inserting size 0 bytes at addr.

addr is an physical/virtual address based on the value of eval "io.va". When virtual it is translated to a physical address according to the IO map at the current offset

Parameters

core	Reference to RzCore instance
addr	Address where to insert new 0 bytes.
size	Number of 0 bytes to insert

Returns

true if extend operation was successful, false otherwise

Definition at line 172 of file cio.c.

                                                                  {
    rz_return_val_if_fail(core, false);
 
    int io_va = rz_config_get_i(core->config, "io.va");
    if (io_va) {
        RzIOMap *map = rz_io_map_get(core->io, core->offset);
        if (map) {
            addr = addr - map->itv.addr + map->delta;
        }
    }
    bool ret = rz_io_extend_at(core->io, addr, size);
    rz_core_block_read(core);
    return ret;
}

References addr, rz_core_t::config, rz_core_t::io, map(), rz_core_t::offset, rz_config_get_i(), rz_core_block_read(), rz_io_extend_at(), rz_io_map_get(), and rz_return_val_if_fail.

Referenced by rz_write_extend_hexbytes_handler(), and rz_write_extend_zero_handler().

rz_core_io_cache_print()

RZ_API RzCmdStatus rz_core_io_cache_print	(	RzCore *	core,
		RzCmdStateOutput *	state
	)

Definition at line 797 of file cio.c.

                                                                                 {
    rz_return_val_if_fail(core && core->io, RZ_CMD_STATUS_ERROR);
 
    size_t i, j = 0;
    void **iter;
    RzIOCache *c;
 
    rz_pvector_foreach (&core->io->cache, iter) {
        c = *iter;
        const ut64 dataSize = rz_itv_size(c->itv);
        switch (state->mode) {
        case RZ_OUTPUT_MODE_STANDARD:
            rz_cons_printf("idx=%" PFMTSZu " addr=0x%08" PFMT64x " size=%" PFMT64u " ", j, rz_itv_begin(c->itv), dataSize);
            for (i = 0; i < dataSize; i++) {
                rz_cons_printf("%02x", c->odata[i]);
            }
            rz_cons_printf(" -> ");
            for (i = 0; i < dataSize; i++) {
                rz_cons_printf("%02x", c->data[i]);
            }
            rz_cons_printf(" %s\n", c->written ? "(written)" : "(not written)");
            break;
        case RZ_OUTPUT_MODE_JSON:
            pj_o(state->d.pj);
            pj_kn(state->d.pj, "idx", j);
            pj_kn(state->d.pj, "addr", rz_itv_begin(c->itv));
            pj_kn(state->d.pj, "size", dataSize);
            char *hex = rz_hex_bin2strdup(c->odata, dataSize);
            pj_ks(state->d.pj, "before", hex);
            free(hex);
            hex = rz_hex_bin2strdup(c->data, dataSize);
            pj_ks(state->d.pj, "after", hex);
            free(hex);
            pj_kb(state->d.pj, "written", c->written);
            pj_end(state->d.pj);
            break;
        case RZ_OUTPUT_MODE_RIZIN:
            rz_cons_printf("wx ");
            for (i = 0; i < dataSize; i++) {
                rz_cons_printf("%02x", (ut8)(c->data[i] & 0xff));
            }
            rz_cons_printf(" @ 0x%08" PFMT64x, rz_itv_begin(c->itv));
            rz_cons_printf(" # replaces: ");
            for (i = 0; i < dataSize; i++) {
                rz_cons_printf("%02x", (ut8)(c->odata[i] & 0xff));
            }
            rz_cons_printf("\n");
            break;
        default:
            rz_warn_if_reached();
            break;
        }
        j++;
    }
    return RZ_CMD_STATUS_OK;
}

References c, rz_io_t::cache, free(), hex, i, rz_core_t::io, PFMT64u, PFMT64x, PFMTSZu, pj_end(), pj_kb(), pj_kn(), pj_ks(), pj_o(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_hex_bin2strdup(), rz_itv_begin(), rz_itv_size(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_pvector_foreach, rz_return_val_if_fail, rz_warn_if_reached, and ut64().

Referenced by rz_write_cache_list_handler().

rz_core_io_pcache_print()

RZ_API RzCmdStatus rz_core_io_pcache_print	(	RzCore *	core,
		RzIODesc *	desc,
		RzCmdStateOutput *	state
	)

Definition at line 854 of file cio.c.

                                                                                                  {
    rz_return_val_if_fail(core && core->io, RZ_CMD_STATUS_ERROR);
    rz_return_val_if_fail(desc, RZ_CMD_STATUS_ERROR);
 
    RzList *caches = rz_io_desc_cache_list(desc);
    RzListIter *iter;
    RzIOCache *c;
 
    if (state->mode == RZ_OUTPUT_MODE_RIZIN) {
        rz_cons_printf("e io.va = false\n");
    }
    rz_list_foreach (caches, iter, c) {
        const int cacheSize = rz_itv_size(c->itv);
        int i;
 
        switch (state->mode) {
        case RZ_OUTPUT_MODE_STANDARD:
            rz_cons_printf("0x%08" PFMT64x ": %02x",
                rz_itv_begin(c->itv), c->odata[0]);
            for (i = 1; i < cacheSize; i++) {
                rz_cons_printf("%02x", c->odata[i]);
            }
            rz_cons_printf(" -> %02x", c->data[0]);
            for (i = 1; i < cacheSize; i++) {
                rz_cons_printf("%02x", c->data[i]);
            }
            rz_cons_printf("\n");
            break;
        case RZ_OUTPUT_MODE_RIZIN:
            rz_cons_printf("wx %02x", c->data[0]);
            for (i = 1; i < cacheSize; i++) {
                rz_cons_printf("%02x", c->data[i]);
            }
            rz_cons_printf(" @ 0x%08" PFMT64x " \n", rz_itv_begin(c->itv));
            break;
        default:
            rz_warn_if_reached();
            break;
        }
    }
    rz_list_free(caches);
    return RZ_CMD_STATUS_OK;
}

References c, desc, i, rz_core_t::io, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_io_desc_cache_list(), rz_itv_begin(), rz_itv_size(), rz_list_free(), RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_return_val_if_fail, and rz_warn_if_reached.

Referenced by rz_write_pcache_list_handler().

rz_core_io_plugin_print()

RZ_API RzCmdStatus rz_core_io_plugin_print	(	RzIOPlugin *	plugin,
		RzCmdStateOutput *	state
	)

Print an IO plugin according to state.

Parameters

plugin	Reference to RzIOPlugin
state	Specify how the plugin shall be printed

Definition at line 408 of file cio.c.

                                                                                        {
    char str[4];
    PJ *pj = state->d.pj;
    str[0] = 'r';
    str[1] = plugin->write ? 'w' : '_';
    str[2] = plugin->isdbg ? 'd' : '_';
    str[3] = 0;
    switch (state->mode) {
    case RZ_OUTPUT_MODE_JSON:
        pj_o(pj);
        pj_ks(pj, "permissions", str);
        pj_ks(pj, "name", plugin->name);
        pj_ks(pj, "description", plugin->desc);
        pj_ks(pj, "license", plugin->license);
 
        if (plugin->uris) {
            char *uri;
            char *uris = strdup(plugin->uris);
            RzList *plist = rz_str_split_list(uris, ",", 0);
            RzListIter *piter;
            pj_k(pj, "uris");
            pj_a(pj);
            rz_list_foreach (plist, piter, uri) {
                pj_s(pj, uri);
            }
            pj_end(pj);
            rz_list_free(plist);
            free(uris);
        }
        if (plugin->version) {
            pj_ks(pj, "version", plugin->version);
        }
        if (plugin->author) {
            pj_ks(pj, "author", plugin->author);
        }
        pj_end(pj);
        break;
    case RZ_OUTPUT_MODE_TABLE:
        rz_table_set_columnsf(state->d.t, "sssss", "perm", "license", "name", "uri", "description");
        rz_table_add_rowf(state->d.t, "sssss", str, plugin->license, plugin->name, plugin->uris, plugin->desc);
        break;
    case RZ_OUTPUT_MODE_QUIET:
        rz_cons_printf("%s\n", plugin->name);
        break;
    case RZ_OUTPUT_MODE_STANDARD:
        rz_cons_printf("%s  %-8s %s (%s)",
            str, plugin->name,
            plugin->desc, plugin->license);
        if (plugin->uris) {
            rz_cons_printf(" %s", plugin->uris);
        }
        if (plugin->version) {
            rz_cons_printf(" v%s", plugin->version);
        }
        if (plugin->author) {
            rz_cons_printf(" %s", plugin->author);
        }
        rz_cons_printf("\n");
        break;
    default: {
        rz_warn_if_reached();
        return RZ_CMD_STATUS_NONEXISTINGCMD;
    }
    }
    return RZ_CMD_STATUS_OK;
}

References rz_io_plugin_t::author, rz_io_plugin_t::desc, free(), rz_io_plugin_t::isdbg, rz_io_plugin_t::license, rz_io_plugin_t::name, pj_a(), pj_end(), pj_k(), pj_ks(), pj_o(), pj_s(), RZ_CMD_STATUS_NONEXISTINGCMD, RZ_CMD_STATUS_OK, rz_cons_printf(), rz_list_free(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, rz_str_split_list(), rz_table_add_rowf(), rz_table_set_columnsf(), rz_warn_if_reached, cmd_descs_generate::str, strdup(), rz_io_plugin_t::uris, rz_io_plugin_t::version, and rz_io_plugin_t::write.

Referenced by rz_core_io_plugins_print().

rz_core_io_plugins_print()

RZ_API RzCmdStatus rz_core_io_plugins_print	(	RzIO *	io,
		RzCmdStateOutput *	state
	)

Print the registered IO plugins according to state.

Parameters

io	Reference to RzIO instance
state	Specify how plugins shall be printed

Definition at line 481 of file cio.c.

                                                                               {
    RzIOPlugin *plugin;
    RzListIter *iter;
    if (!io) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cmd_state_output_array_start(state);
    rz_cmd_state_output_set_columnsf(state, "sssss", "perm", "license", "name", "uri", "description");
    rz_list_foreach (io->plugins, iter, plugin) {
        rz_core_io_plugin_print(plugin, state);
    }
    rz_cmd_state_output_array_end(state);
    return RZ_CMD_STATUS_OK;
}

References rz_io_t::plugins, rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), rz_cmd_state_output_set_columnsf(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_io_plugin_print().

Referenced by rz_main_rizin(), and rz_plugins_io_print_handler().

rz_core_is_valid_offset()

RZ_API int rz_core_is_valid_offset	(	RzCore *	core,
		ut64	offset
	)

Definition at line 250 of file cio.c.

                                                              {
    if (!core) {
        eprintf("rz_core_is_valid_offset: core is NULL\n");
        rz_sys_backtrace();
        return -1;
    }
    return rz_io_is_valid_offset(core->io, offset, 0);
}

References eprintf, rz_core_t::io, rz_io_is_valid_offset(), and rz_sys_backtrace().

rz_core_seek_arch_bits()

RZ_API void rz_core_seek_arch_bits	(	RzCore *	core,
		ut64	addr
	)

Definition at line 132 of file cio.c.

                                                            {
    int bits = 0;
    const char *arch = NULL;
    rz_core_arch_bits_at(core, addr, &bits, &arch);
    if (bits) {
        rz_config_set_i(core->config, "asm.bits", bits);
    }
    if (arch) {
        rz_config_set(core->config, "asm.arch", arch);
    }
}

References addr, arch, bits(), rz_core_t::config, NULL, rz_config_set(), rz_config_set_i(), and rz_core_arch_bits_at().

Referenced by archbits(), rz_core_analysis_esil(), rz_core_analysis_fcn(), rz_core_disasm_pde(), rz_core_print_disasm(), and rz_core_print_disasm_instructions_with_buf().

rz_core_setup_debugger()

RZ_API int rz_core_setup_debugger	(	RzCore *	r,
		const char *	debugbackend,
		bool	attach
	)

Definition at line 7 of file cio.c.

                                                                                    {
    int pid, *p = NULL;
    RzIODesc *fd = r->file ? rz_io_desc_get(r->io, r->file->fd) : NULL;
 
    p = fd ? fd->data : NULL;
    rz_config_set_i(r->config, "cfg.debug", 1);
    if (!p) {
        eprintf("Invalid debug io\n");
        return false;
    }
 
    rz_config_set(r->config, "io.ff", "true");
    rz_config_set(r->config, "dbg.backend", debugbackend);
    pid = rz_io_desc_get_pid(fd);
    rz_debug_select(r->dbg, pid, r->dbg->tid);
    r->dbg->main_pid = pid;
    if (attach) {
        rz_core_debug_attach(r, pid);
    }
    // this makes to attach twice showing warnings in the output
    // we get "resource busy" so it seems isn't an issue
    rz_core_reg_update_flags(r);
    /* honor dbg.bep */
    {
        const char *bep = rz_config_get(r->config, "dbg.bep");
        if (bep) {
            ut64 address = 0;
            if (!strcmp(bep, "loader")) {
                /* do nothing here */
            } else if (!strcmp(bep, "entry")) {
                address = rz_num_math(r->num, "entry0");
                rz_core_debug_continue_until(r, address, address);
            } else {
                address = rz_num_math(r->num, bep);
                rz_core_debug_continue_until(r, address, address);
            }
        }
    }
    rz_core_seek_to_register(r, "PC", false);
 
    return true;
}

References eprintf, fd, NULL, p, pid, r, rz_config_get(), rz_config_set(), rz_config_set_i(), rz_core_debug_attach(), rz_core_debug_continue_until(), rz_core_reg_update_flags(), rz_core_seek_to_register(), rz_debug_select(), rz_io_desc_get(), rz_io_desc_get_pid(), rz_num_math(), and ut64().

Referenced by rz_core_file_reopen(), and rz_main_rizin().

rz_core_shift_block()

RZ_API bool rz_core_shift_block	(	RzCore *	core,
		ut64	addr,
		ut64	b_size,
		st64	dist
	)

Shift a block of data from addr of size b_size left or right based on dist.

Parameters

core	Reference to RzCore instance
addr	Address of the block of data to move
b_size	Size of the block of data to move
dist	Where to shift the data, whether backward or forward and how distant from the original position

Returns

true if the shift operation was succesful, false otherwise

Definition at line 197 of file cio.c.

                                                                                 {
    // bstart - block start, fstart file start
    ut64 fend = 0, fstart = 0, bstart = 0, file_sz = 0;
    ut8 *shift_buf = NULL;
    int res = false;
 
    if (!core->io || !core->file) {
        return false;
    }
 
    if (b_size == 0 || b_size == (ut64)-1) {
        rz_io_use_fd(core->io, core->file->fd);
        file_sz = rz_io_size(core->io);
        if (file_sz == UT64_MAX) {
            file_sz = 0;
        }
        bstart = 0;
        fend = file_sz;
        fstart = file_sz - fend;
        b_size = fend > bstart ? fend - bstart : 0;
    }
 
    if ((st64)b_size < 1) {
        return false;
    }
    shift_buf = calloc(b_size, 1);
    if (!shift_buf) {
        eprintf("Cannot allocated %d byte(s)\n", (int)b_size);
        return false;
    }
 
    if (addr + dist < fstart) {
        res = false;
    } else if ((addr) + dist > fend) {
        res = false;
    } else {
        rz_io_use_fd(core->io, core->file->fd);
        rz_io_read_at(core->io, addr, shift_buf, b_size);
        rz_io_write_at(core->io, addr + dist, shift_buf, b_size);
        res = true;
    }
    rz_core_seek(core, addr, true);
    free(shift_buf);
    return res;
}

References addr, calloc(), eprintf, rz_core_file_t::fd, rz_core_t::file, free(), rz_core_t::io, NULL, rz_core_seek(), rz_io_read_at(), rz_io_size(), rz_io_use_fd(), rz_io_write_at(), st64, ut64(), and UT64_MAX.

Referenced by rz_write_extend_shift_handler().

rz_core_transform_op()

RZ_API RZ_OWN ut8* rz_core_transform_op	(	RzCore *	core,
		ut64	addr,
		RzCoreWriteOp	op,
		ut8 *	hex,
		int	hexlen,
		int *	buflen
	)

Transform a block of data at addr according to the operation op and the hexvalue hex.

Parameters

core	Reference to RzCore instance
addr	Where the block of data to modify starts
op	Operation to perform on the block of data
hex	Optional hex string that may be required by the specific operation
hexlen	Optional length of the hex string. Must be present if hex is specified.
buflen	Used to return the length of the returned buffer

Returns

The transformed buffer

Definition at line 934 of file cio.c.

                                                                                                                      {
    rz_return_val_if_fail(core, NULL);
    rz_return_val_if_fail(!hex || hexlen >= 0, NULL);
    rz_return_val_if_fail(buflen, NULL);
 
    switch (op) {
    case RZ_CORE_WRITE_OP_ADD:
    case RZ_CORE_WRITE_OP_SUB:
    case RZ_CORE_WRITE_OP_DIV:
    case RZ_CORE_WRITE_OP_MUL:
    case RZ_CORE_WRITE_OP_AND:
    case RZ_CORE_WRITE_OP_OR:
    case RZ_CORE_WRITE_OP_XOR:
    case RZ_CORE_WRITE_OP_SHIFT_LEFT:
    case RZ_CORE_WRITE_OP_SHIFT_RIGHT:
        rz_return_val_if_fail(hex && hexlen >= 0, NULL);
        break;
    default:
        break;
    }
 
    ut8 *buf = RZ_NEWS(ut8, core->blocksize);
    if (!buf) {
        return NULL;
    }
 
    int len = rz_io_nread_at(core->io, addr, buf, core->blocksize);
    if (len < 0) {
        free(buf);
        return NULL;
    }
 
    for (int i = 0, j = 0; i < len; i++, j = (j + 1) % (hexlen ? hexlen : 1)) {
        ut16 tmp16;
        ut32 tmp32;
        ut64 tmp64;
        switch (op) {
        case RZ_CORE_WRITE_OP_BYTESWAP2:
            if (i + 1 < len) {
                tmp16 = rz_read_le16(buf + i);
                rz_write_be16(buf + i, tmp16);
                i++;
            }
            break;
        case RZ_CORE_WRITE_OP_BYTESWAP4:
            if (i + 3 < len) {
                tmp32 = rz_read_le32(buf + i);
                rz_write_be32(buf + i, tmp32);
                i += 3;
            }
            break;
        case RZ_CORE_WRITE_OP_BYTESWAP8:
            if (i + 7 < len) {
                tmp64 = rz_read_le64(buf + i);
                rz_write_be64(buf + i, tmp64);
                i += 7;
            }
            break;
        case RZ_CORE_WRITE_OP_ADD:
            buf[i] += hex[j];
            break;
        case RZ_CORE_WRITE_OP_SUB:
            buf[i] -= hex[j];
            break;
        case RZ_CORE_WRITE_OP_DIV:
            buf[i] = hex[j] ? buf[i] / hex[j] : 0;
            break;
        case RZ_CORE_WRITE_OP_MUL:
            buf[i] *= hex[j];
            break;
        case RZ_CORE_WRITE_OP_AND:
            buf[i] &= hex[j];
            break;
        case RZ_CORE_WRITE_OP_OR:
            buf[i] |= hex[j];
            break;
        case RZ_CORE_WRITE_OP_XOR:
            buf[i] ^= hex[j];
            break;
        case RZ_CORE_WRITE_OP_SHIFT_LEFT:
            buf[i] <<= hex[j];
            break;
        case RZ_CORE_WRITE_OP_SHIFT_RIGHT:
            buf[i] >>= hex[j];
            break;
        default:
            rz_warn_if_reached();
            break;
        }
    }
    *buflen = len;
    return buf;
}

References addr, rz_core_t::blocksize, buflen, free(), hex, i, rz_core_t::io, len, NULL, RZ_CORE_WRITE_OP_ADD, RZ_CORE_WRITE_OP_AND, RZ_CORE_WRITE_OP_BYTESWAP2, RZ_CORE_WRITE_OP_BYTESWAP4, RZ_CORE_WRITE_OP_BYTESWAP8, RZ_CORE_WRITE_OP_DIV, RZ_CORE_WRITE_OP_MUL, RZ_CORE_WRITE_OP_OR, RZ_CORE_WRITE_OP_SHIFT_LEFT, RZ_CORE_WRITE_OP_SHIFT_RIGHT, RZ_CORE_WRITE_OP_SUB, RZ_CORE_WRITE_OP_XOR, rz_io_nread_at(), RZ_NEWS, rz_read_le16(), rz_read_le32(), rz_read_le64(), rz_return_val_if_fail, rz_warn_if_reached, rz_write_be16(), rz_write_be32(), rz_write_be64(), and ut64().

Referenced by old_transform_op(), and rz_core_write_block_op_at().

rz_core_write_assembly()

RZ_API int rz_core_write_assembly	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	instructions
	)

Assembles instructions and writes the resulting data at the given offset.

Parameters

core	RzCore reference
addr	Address to where to write
instructions	List of instructions to assemble as a string

Returns

Returns the length of the written data or -1 in case of error

Definition at line 327 of file cio.c.

                                                                                                {
    rz_return_val_if_fail(core && instructions, -1);
 
    int ret = -1;
 
    rz_asm_set_pc(core->rasm, core->offset);
    RzAsmCode *acode = rz_asm_massemble(core->rasm, instructions);
    if (!acode) {
        return -1;
    }
    if (acode->len <= 0) {
        ret = 0;
        goto err;
    }
 
    if (!rz_core_write_at(core, core->offset, acode->bytes, acode->len)) {
        RZ_LOG_ERROR("Cannot write %d bytes at 0x%" PFMT64x "address\n", acode->len, core->offset);
        core->num->value = 1;
        goto err;
    }
    ret = acode->len;
err:
    rz_asm_code_free(acode);
    return ret;
}

References rz_asm_code_t::bytes, err, instructions, rz_asm_code_t::len, rz_core_t::num, rz_core_t::offset, PFMT64x, rz_core_t::rasm, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_pc(), rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, and rz_num_t::value.

Referenced by rz_core_hack_arm64(), rz_write_assembly_file_handler(), and rz_write_assembly_handler().

rz_core_write_assembly_fill()

RZ_API int rz_core_write_assembly_fill	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	instructions
	)

Assemble instructions and write the resulting data inside the current instruction.

Assemble one or more instructions and write the resulting data inside the current instruction, if the new instructions fit. Fill the rest of the bytes of the old instruction with NOP

Parameters

core	RzCore reference
addr	Address to where to write
instructions	List of instructions to assemble as a string

Returns

Returns the length of the written data or -1 in case of error (e.g. the new instruction does not fit)

Definition at line 365 of file cio.c.

                                                                                                     {
    rz_return_val_if_fail(core && instructions, -1);
 
    int ret = -1;
 
    rz_asm_set_pc(core->rasm, core->offset);
    RzAsmCode *acode = rz_asm_massemble(core->rasm, instructions);
    if (!acode) {
        return -1;
    }
    if (acode->len <= 0) {
        ret = 0;
        goto err;
    }
 
    RzAnalysisOp op = { 0 };
    if (rz_analysis_op(core->analysis, &op, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC) < 1) {
        RZ_LOG_ERROR("Invalid instruction at %" PFMT64x "\n", core->offset);
        goto err;
    }
    if (op.size < acode->len) {
        RZ_LOG_ERROR("Instructions do not fit at %" PFMT64x "\n", core->offset);
        goto err;
    }
    rz_core_hack(core, "nop");
 
    if (!rz_core_write_at(core, core->offset, acode->bytes, acode->len)) {
        RZ_LOG_ERROR("Cannot write %d bytes at 0x%" PFMT64x "address\n", acode->len, core->offset);
        core->num->value = 1;
        goto err;
    }
    ret = acode->len;
err:
    rz_asm_code_free(acode);
    return ret;
}

References rz_core_t::analysis, rz_core_t::block, rz_core_t::blocksize, rz_asm_code_t::bytes, err, instructions, rz_asm_code_t::len, rz_core_t::num, rz_core_t::offset, PFMT64x, rz_core_t::rasm, rz_analysis_op(), RZ_ANALYSIS_OP_MASK_BASIC, rz_asm_code_free(), rz_asm_massemble(), rz_asm_set_pc(), rz_core_hack(), rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, and rz_num_t::value.

Referenced by rz_write_assembly_inside_handler().

rz_core_write_at()

RZ_API bool rz_core_write_at	(	RzCore *	core,
		ut64	addr,
		const ut8 *	buf,
		int	size
	)

Definition at line 145 of file cio.c.

                                                                                {
    rz_return_val_if_fail(core && buf && addr != UT64_MAX, false);
    if (size < 1) {
        return false;
    }
    bool ret = rz_io_write_at(core->io, addr, buf, size);
    if (addr >= core->offset && addr <= core->offset + core->blocksize - 1) {
        rz_core_block_read(core);
    }
    if (rz_config_get_i(core->config, "cfg.wseek")) {
        rz_core_seek_delta(core, size, true);
    }
    return ret;
}

References addr, rz_core_t::blocksize, rz_core_t::config, rz_core_t::io, rz_core_t::offset, rz_config_get_i(), rz_core_block_read(), rz_core_seek_delta(), rz_io_write_at(), rz_return_val_if_fail, and UT64_MAX.

Referenced by cmd_write_bits(), encrypt_or_decrypt_block(), initialize_stack(), insert_mode_enabled(), rz_core_serve(), rz_core_visual_bit_editor(), rz_core_write_assembly(), rz_core_write_assembly_fill(), rz_core_write_base64_at(), rz_core_write_base64d_at(), rz_core_write_block(), rz_core_write_block_op_at(), rz_core_write_duplicate_at(), rz_core_write_hexpair(), rz_core_write_length_string_at(), rz_core_write_random_at(), rz_core_write_seq_at(), rz_core_write_string_at(), rz_core_write_string_wide_at(), rz_core_write_string_zero_at(), rz_core_write_value_at(), rz_core_write_value_inc_at(), rz_core_yank_paste(), rz_write_extend_hexbytes_handler(), rz_write_unified_patch_handler(), and rz_write_zero_handler().

rz_core_write_base64_at()

RZ_API bool rz_core_write_base64_at	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	s
	)

Write a given string s at the specified addr encoded as base64.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to encode as base64 and then written.

Definition at line 700 of file cio.c.

                                                                                       {
    rz_return_val_if_fail(core && s, false);
 
    bool res = false;
    size_t str_len = strlen(s) + 1;
    ut8 *bin_buf = malloc(str_len);
    if (!bin_buf) {
        return false;
    }
 
    const int bin_len = rz_hex_str2bin(s, bin_buf);
    if (bin_len <= 0) {
        free(bin_buf);
        return false;
    }
 
    ut8 *buf = calloc(str_len + 1, 4);
    if (!buf) {
        free(bin_buf);
        return false;
    }
 
    int len = rz_base64_encode((char *)buf, bin_buf, bin_len);
    free(bin_buf);
    if (len == 0) {
        goto err;
    }
 
    if (!rz_core_write_at(core, addr, buf, len)) {
        RZ_LOG_ERROR("Could not write base64 encoded string '%s' at %" PFMT64x "\n", s, addr);
        goto err;
    }
    res = true;
err:
    free(buf);
    return res;
}

References addr, calloc(), err, free(), len, malloc(), PFMT64x, rz_base64_encode(), rz_core_write_at(), rz_hex_str2bin(), RZ_LOG_ERROR, rz_return_val_if_fail, and s.

Referenced by rz_write_base64_encode_handler().

rz_core_write_base64d_at()

RZ_API bool rz_core_write_base64d_at	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	s
	)

Write a given base64 string s at the specified addr, decoded.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to decode from base64 and then written

Definition at line 745 of file cio.c.

                                                                                        {
    rz_return_val_if_fail(core && s, false);
 
    bool res = false;
    size_t str_len = strlen(s) + 1;
    ut8 *buf = malloc(str_len);
    int len = rz_base64_decode(buf, s, -1);
    if (len < 0) {
        goto err;
    }
 
    if (!rz_core_write_at(core, addr, buf, len)) {
        RZ_LOG_ERROR("Could not write base64 decoded string '%s' at %" PFMT64x "\n", s, addr);
        goto err;
    }
    res = true;
err:
    free(buf);
    return res;
}

References addr, err, free(), len, malloc(), PFMT64x, rz_base64_decode(), rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, and s.

Referenced by rz_write_base64_decode_handler().

rz_core_write_block()

RZ_API bool rz_core_write_block	(	RzCore *	core,
		ut64	addr,
		ut8 *	data,
		size_t	len
	)

Writes the bytes data at address addr cyclically until it fills the whole block

It repeats the data data with length len until it fills an entire block starting at addr.

Parameters

core	RzCore reference
addr	Address to where to write
data	Array of bytes to cyclically write in the block at addr
len	Length of data

Definition at line 299 of file cio.c.

                                                                                {
    rz_return_val_if_fail(core && data, 0);
 
    ut8 *buf = RZ_NEWS(ut8, core->blocksize);
    if (!buf) {
        return false;
    }
 
    bool res = false;
    rz_mem_copyloop(buf, data, core->blocksize, len);
    if (!rz_core_write_at(core, addr, buf, core->blocksize)) {
        RZ_LOG_ERROR("Could not write cyclic data (%d bytes) at %" PFMT64x "\n", core->blocksize, addr);
        goto err;
    }
    res = true;
err:
    free(buf);
    return res;
}

References addr, rz_core_t::blocksize, err, free(), len, PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, rz_mem_copyloop(), RZ_NEWS, and rz_return_val_if_fail.

Referenced by rz_write_block_handler().

rz_core_write_block_op_at()

RZ_API bool rz_core_write_block_op_at	(	RzCore *	core,
		ut64	addr,
		RzCoreWriteOp	op,
		ut8 *	hex,
		int	hexlen
	)

Write a full block of data according to the operation op and the hexvalue hex.

Parameters

core	Reference to RzCore instance
addr	Where the block of data to modify starts
op	Operation to perform on the block of data
hex	Optional hex string that may be required by the specific operation
hexlen	Optional length of the hex string. Must be present if hex is specified.

Returns

true if the write operation succeeds, false otherwise

Definition at line 1038 of file cio.c.

                                                                                                       {
    int buflen;
    ut8 *buf = rz_core_transform_op(core, addr, op, hex, hexlen, &buflen);
    if (!buf) {
        return false;
    }
 
    if (!rz_core_write_at(core, addr, buf, buflen)) {
        RZ_LOG_ERROR("Could not write block operation at %" PFMT64x "\n", addr);
        free(buf);
        return false;
    }
 
    return true;
}

References addr, buflen, free(), hex, PFMT64x, rz_core_transform_op(), rz_core_write_at(), and RZ_LOG_ERROR.

Referenced by rz_write_op_2byteswap_handler(), rz_write_op_4byteswap_handler(), rz_write_op_8byteswap_handler(), and write_op_val().

rz_core_write_duplicate_at()

RZ_API bool rz_core_write_duplicate_at	(	RzCore *	core,
		ut64	addr,
		ut64	from,
		int	len
	)

Copy len bytes from from to addr.

Parameters

core	Reference to RzCore instance
addr	Where the data should be copied to
from	Where the data should be read from
len	Number of bytes to copy, expected to not be negative

Returns

true if the write operation succeeds, false otherwise

Definition at line 1106 of file cio.c.

                                                                                    {
    rz_return_val_if_fail(core, false);
    rz_return_val_if_fail(len >= 0, false);
 
    bool res = false;
    ut8 *data = RZ_NEWS(ut8, len);
    if (!data) {
        return false;
    }
 
    int n = rz_io_nread_at(core->io, from, data, len);
    if (n < 0) {
        RZ_LOG_ERROR("Cannot read data from %" PFMT64x ".\n", from);
        goto err;
    }
    if (!rz_core_write_at(core, addr, data, n)) {
        RZ_LOG_ERROR("Cannot write %d bytes to %" PFMT64x ".\n", n, addr);
        goto err;
    }
    res = true;
err:
    free(data);
    return res;
}

References addr, err, free(), from, rz_core_t::io, len, n, PFMT64x, rz_core_write_at(), rz_io_nread_at(), RZ_LOG_ERROR, RZ_NEWS, and rz_return_val_if_fail.

Referenced by rz_write_duplicate_handler().

rz_core_write_hexpair()

RZ_API int rz_core_write_hexpair	(	RzCore *	core,
		ut64	addr,
		const char *	pairs
	)

Writes the hexadecimal string at the given offset

Returns the length of the written data.

Parameters

core	RzCore reference
addr	Address to where to write
pairs	Data as the hexadecimal string

Definition at line 268 of file cio.c.

                                                                             {
    rz_return_val_if_fail(core && pairs, 0);
    ut8 *buf = malloc(strlen(pairs) + 1);
    if (!buf) {
        return 0;
    }
    int len = rz_hex_str2bin(pairs, buf);
    if (len < 0) {
        RZ_LOG_ERROR("Could not convert hexpair '%s' to bin data\n", pairs);
        goto err;
    }
    if (!rz_core_write_at(core, addr, buf, len)) {
        RZ_LOG_ERROR("Could not write hexpair '%s' at %" PFMT64x "\n", pairs, addr);
        goto err;
    }
err:
    free(buf);
    return len;
}

References addr, err, free(), len, malloc(), PFMT64x, rz_core_write_at(), rz_hex_str2bin(), RZ_LOG_ERROR, and rz_return_val_if_fail.

Referenced by __insert_value(), insert_mode_enabled(), rz_core_hack_arm(), rz_core_hack_arm64(), rz_core_hack_dalvik(), rz_core_hack_x86(), rz_write_hex_from_file_handler(), and rz_write_hex_handler().

rz_core_write_length_string_at()

RZ_API bool rz_core_write_length_string_at	(	RzCore *	core,
		ut64	addr,
		const char *	s
	)

Write at the specified addr the length of the string in one byte, followed by the given string s.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

Definition at line 673 of file cio.c.

                                                                                   {
    rz_return_val_if_fail(core && s, false);
 
    char *str = strdup(s);
    if (!str) {
        return false;
    }
 
    int len = rz_str_unescape(str);
    ut8 ulen = (ut8)len;
    if (!rz_core_write_at(core, addr, &ulen, sizeof(ulen)) ||
        !rz_core_write_at(core, addr + 1, (const ut8 *)str, len)) {
        RZ_LOG_ERROR("Could not write length+'%s' at %" PFMT64x "\n", s, addr);
        free(str);
        return false;
    }
    free(str);
    return true;
}

References addr, free(), len, PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_unescape(), s, cmd_descs_generate::str, strdup(), and ut8.

Referenced by rz_write_length_string_handler().

rz_core_write_random_at()

RZ_API bool rz_core_write_random_at	(	RzCore *	core,
		ut64	addr,
		size_t	len
	)

Write len random bytes at address addr.

Parameters

core	RzCore reference
addr	Address where to write the data
len	Length of the random data to write

Definition at line 773 of file cio.c.

                                                                         {
    rz_return_val_if_fail(core, false);
 
    bool res = false;
    ut8 *buf = malloc(len);
    if (!buf) {
        return false;
    }
 
    rz_num_irand();
    for (int i = 0; i < len; i++) {
        buf[i] = rz_num_rand(256);
    }
 
    if (!rz_core_write_at(core, addr, buf, len)) {
        RZ_LOG_ERROR("Could not write random data of length %zd at %" PFMT64x "\n", len, addr);
        goto err;
    }
    res = true;
err:
    free(buf);
    return res;
}

References addr, err, free(), i, len, malloc(), PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, rz_num_irand(), rz_num_rand(), and rz_return_val_if_fail.

Referenced by rz_write_random_handler().

rz_core_write_seq_at()

RZ_API bool rz_core_write_seq_at	(	RzCore *	core,
		ut64	addr,
		ut64	from,
		ut64	to,
		ut64	step,
		int	value_size
	)

Write a full block of data with a sequence.

Write a full block of data with a sequence of numbers starting from from up to to, with a step of step. The values are written as numbers of value_size bytes.

Parameters

core	Reference to RzCore instance
addr	Where the block of data to modify starts
from	From where to start the sequence of numbers
to	Where to stop in the sequence
step	Difference between two numbers in the sequence
value_size	Size of each number of the sequence, in bytes

Returns

true if the write operation succeeds, false otherwise

Definition at line 1069 of file cio.c.

                                                                                                         {
    rz_return_val_if_fail(core, false);
    rz_return_val_if_fail(value_size == 1 || value_size == 2 || value_size == 4 || value_size == 8, false);
    ut64 max_val = (1ULL << (8 * value_size));
    rz_return_val_if_fail(from < max_val, false);
    rz_return_val_if_fail(to < max_val, false);
 
    ut8 *buf = RZ_NEWS0(ut8, core->blocksize);
    if (!buf) {
        return false;
    }
 
    ut64 diff = to <= from ? max_val : to - from + 1;
    ut64 p = from;
    for (size_t i = 0; i < core->blocksize; i += value_size, p = (from + ((p + step - from) % diff)) % max_val) {
        rz_write_ble(buf + i, p, rz_config_get_b(core->config, "cfg.bigendian"), value_size * 8);
    }
 
    if (!rz_core_write_at(core, addr, buf, core->blocksize)) {
        RZ_LOG_ERROR("Could not write sequence [%" PFMT64d ", %" PFMT64d "] step=%" PFMT64d ",value_size=%d at %" PFMT64x "\n", from, to, step, value_size, addr);
        free(buf);
        return false;
    }
 
    free(buf);
    return true;
}

References addr, rz_core_t::blocksize, rz_core_t::config, free(), from, i, p, PFMT64d, PFMT64x, rz_config_get_b(), rz_core_write_at(), RZ_LOG_ERROR, RZ_NEWS0, rz_return_val_if_fail, rz_write_ble(), step(), to, and ut64().

Referenced by rz_write_op_sequence_handler().

rz_core_write_string_at()

RZ_API bool rz_core_write_string_at	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const char *	s
	)

Write a given string s at the specified addr.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

Definition at line 605 of file cio.c.

                                                                                       {
    rz_return_val_if_fail(core && s, false);
 
    char *str = strdup(s);
    if (!str) {
        return false;
    }
 
    int len = rz_str_unescape(str);
    if (!rz_core_write_at(core, addr, (const ut8 *)str, len)) {
        RZ_LOG_ERROR("Could not write '%s' at %" PFMT64x "\n", s, addr);
        free(str);
        return false;
    }
    free(str);
    return true;
}

References addr, free(), len, PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_unescape(), s, cmd_descs_generate::str, and strdup().

Referenced by rz_write_debruijn_handler(), and rz_write_handler().

rz_core_write_string_wide_at()

RZ_API bool rz_core_write_string_wide_at	(	RzCore *	core,
		ut64	addr,
		const char *	s
	)

Write a given string s as a wide string at the specified addr.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

Definition at line 630 of file cio.c.

                                                                                 {
    rz_return_val_if_fail(core && s, false);
 
    bool res = false;
    char *str = strdup(s);
    if (!str) {
        return false;
    }
 
    int len = rz_str_unescape(str);
    if (len < 1) {
        goto str_err;
    }
 
    len++; // Consider for the terminator char
    char *tmp = RZ_NEWS(char, len * 2);
    if (!tmp) {
        goto str_err;
    }
 
    for (int i = 0; i < len; i++) {
        tmp[i * 2] = str[i];
        tmp[i * 2 + 1] = 0;
    }
 
    if (!rz_core_write_at(core, addr, (const ut8 *)tmp, len * 2)) {
        RZ_LOG_ERROR("Could not write wide string '%s' at %" PFMT64x "\n", s, addr);
        free(str);
        return false;
    }
    res = true;
str_err:
    free(str);
    return res;
}

References addr, free(), i, len, PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, RZ_NEWS, rz_return_val_if_fail, rz_str_unescape(), s, cmd_descs_generate::str, strdup(), and autogen_x86imm::tmp.

Referenced by rz_write_wide_string_handler().

rz_core_write_string_zero_at()

RZ_API bool rz_core_write_string_zero_at	(	RzCore *	core,
		ut64	addr,
		const char *	s
	)

Write a given string s, followed by the zero terminator, at the specified addr.

Parameters

core	RzCore reference
addr	Address where to write the string
s	String to write. The string is unescaped, meaning that if there is \n it becomes 0x0a

Definition at line 905 of file cio.c.

                                                                                 {
    rz_return_val_if_fail(core && s, false);
 
    char *str = strdup(s);
    if (!str) {
        return false;
    }
 
    int len = rz_str_unescape(str);
    if (!rz_core_write_at(core, addr, (const ut8 *)str, len + 1)) {
        RZ_LOG_ERROR("Could not write '%s' at %" PFMT64x "\n", s, addr);
        free(str);
        return false;
    }
    free(str);
    return true;
}

References addr, free(), len, PFMT64x, rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_str_unescape(), s, cmd_descs_generate::str, and strdup().

Referenced by rz_write_zero_string_handler().

rz_core_write_value_at()

RZ_API bool rz_core_write_value_at	(	RzCore *	core,
		ut64	addr,
		ut64	value,
		int	sz
	)

Write a given value at the specified address, using sz bytes.

Parameters

core	RzCore reference
addr	Address where to write the value
value	Value to write
sz	Number of bytes to write. Can be 1, 2, 4, 8 or the special value 0 if you want the function to choose based on value (4 if value is <4GB, 8 otherwise)

Definition at line 506 of file cio.c.

                                                                                {
    rz_return_val_if_fail(sz == 0 || sz == 1 || sz == 2 || sz == 4 || sz == 8, false);
    ut8 buf[sizeof(ut64)];
    bool be = rz_config_get_i(core->config, "cfg.bigendian");
 
    core->num->value = 0;
    if (sz == 0) {
        sz = value & UT64_32U ? 8 : 4;
    }
 
    switch (sz) {
    case 1:
        rz_write_ble8(buf, (ut8)(value & UT8_MAX));
        break;
    case 2:
        rz_write_ble16(buf, (ut16)(value & UT16_MAX), be);
        break;
    case 4:
        rz_write_ble32(buf, (ut32)(value & UT32_MAX), be);
        break;
    case 8:
        rz_write_ble64(buf, value, be);
        break;
    default:
        return false;
    }
 
    if (!rz_core_write_at(core, addr, buf, sz)) {
        RZ_LOG_ERROR("Could not write %d bytes at %" PFMT64x "\n", sz, addr);
        core->num->value = 1;
        return false;
    }
    return true;
}

References addr, rz_core_t::config, rz_core_t::num, PFMT64x, rz_config_get_i(), rz_core_write_at(), RZ_LOG_ERROR, rz_return_val_if_fail, rz_write_ble16(), rz_write_ble32(), rz_write_ble64(), rz_write_ble8(), UT16_MAX, UT32_MAX, ut64(), UT64_32U, UT8_MAX, value, and rz_num_t::value.

Referenced by common_write_value_handler().

rz_core_write_value_inc_at()

RZ_API bool rz_core_write_value_inc_at	(	RzCore *	core,
		ut64	addr,
		st64	value,
		int	sz
	)

Write at addr the current value + value passed as argument.

The values read/written are considered as integers of sz bytes.

Parameters

core	RzCore reference
addr	Address where to overwrite the value
value	Value to sum to the existing value in addr
sz	Size of the values, in bytes, to consider. Can be 1, 2, 4, 8.

Definition at line 551 of file cio.c.

                                                                                    {
    rz_return_val_if_fail(sz == 1 || sz == 2 || sz == 4 || sz == 8, false);
 
    ut8 buf[sizeof(ut64)];
    bool be = rz_config_get_i(core->config, "cfg.bigendian");
 
    if (!rz_io_read_at_mapped(core->io, addr, buf, sz)) {
        return false;
    }
 
    switch (sz) {
    case 1: {
        ut8 cur = rz_read_ble8(buf);
        cur += value;
        rz_write_ble8(buf, cur);
        break;
    }
    case 2: {
        ut16 cur = rz_read_ble16(buf, be);
        cur += value;
        rz_write_ble16(buf, cur, be);
        break;
    }
    case 4: {
        ut32 cur = rz_read_ble32(buf, be);
        cur += value;
        rz_write_ble32(buf, cur, be);
        break;
    }
    case 8: {
        ut64 cur = rz_read_ble64(buf, be);
        cur += value;
        rz_write_ble64(buf, cur, be);
        break;
    }
    default:
        rz_warn_if_reached();
        break;
    }
 
    if (!rz_core_write_at(core, addr, buf, sz)) {
        RZ_LOG_ERROR("Could not write %d bytes at %" PFMT64x "\n", sz, addr);
        return false;
    }
    return true;
}

References addr, rz_core_t::config, rz_core_t::io, PFMT64x, rz_config_get_i(), rz_core_write_at(), rz_io_read_at_mapped(), RZ_LOG_ERROR, rz_read_ble16(), rz_read_ble32(), rz_read_ble64(), rz_read_ble8(), rz_return_val_if_fail, rz_warn_if_reached, rz_write_ble16(), rz_write_ble32(), rz_write_ble64(), rz_write_ble8(), ut64(), and value.

Referenced by w_incdec_handler().