cmd_write.c File Reference

#include <rz_crypto.h>
#include <rz_config.h>
#include <rz_cons.h>
#include <rz_core.h>
#include <rz_io.h>
#include <rz_socket.h>
#include "../core_private.h"

Go to the source code of this file.

Macros
#define	WSEEK(x, y)

Functions
static void	cmd_write_fail (RzCore *core)
static bool	encrypt_or_decrypt_block (RzCore *core, const char *algo, const char *key, int direction, const char *iv)
static void	cmd_write_bits (RzCore *core, int set, ut64 val)
static RzCmdStatus	common_write_value_handler (RzCore *core, const char *valstr, size_t sz)
RZ_IPI RzCmdStatus	rz_write_value_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_value1_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_value2_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_value4_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_value8_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_base64_encode_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_base64_decode_handler (RzCore *core, int argc, const char **argv)
static bool	ioMemcpy (RzCore *core, ut64 dst, ut64 src, int len)
RZ_IPI RzCmdStatus	rz_write_from_io_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_from_io_xchg_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_from_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_from_socket_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_bits_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_unset_bits_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_zero_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	w_incdec_handler (RzCore *core, int argc, const char **argv, int inc_size)
RZ_IPI RzCmdStatus	rz_write_1_inc_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_1_dec_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_2_inc_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_2_dec_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_4_inc_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_4_dec_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_8_inc_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_8_dec_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_unified_patch_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_random_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_zero_string_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_wide_string_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_hex_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_hex_from_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_assembly_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_assembly_inside_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_assembly_file_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_assembly_opcode_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_block_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_mask_set_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_mask_reset_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_duplicate_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_length_string_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_cache_list_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_write_cache_remove_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_cache_remove_all_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_cache_commit_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_cache_commit_all_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_pcache_list_handler (RzCore *core, int argc, const char **argv, RzCmdStateOutput *state)
RZ_IPI RzCmdStatus	rz_write_pcache_commit_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_extend_zero_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_extend_shift_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_extend_hexbytes_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_2byteswap_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_4byteswap_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_8byteswap_handler (RzCore *core, int argc, const char **argv)
static RzCmdStatus	write_op_val (RzCore *core, int argc, const char **argv, RzCoreWriteOp op)
RZ_IPI RzCmdStatus	rz_write_op_add_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_sub_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_mul_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_div_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_xor_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_and_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_or_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_shl_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_shr_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_encrypt_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_decrypt_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_op_sequence_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_debruijn_handler (RzCore *core, int argc, const char **argv)
RZ_IPI RzCmdStatus	rz_write_debruijn_find_handler (RzCore *core, int argc, const char **argv)

Macro Definition Documentation

WSEEK

#define WSEEK	(		x,
			y
	)

Value:

    if (wseek) \
    rz_core_seek_delta(x, y, true)

Definition at line 92 of file cmd_write.c.

Function Documentation

cmd_write_bits()

static void cmd_write_bits ( RzCore *  core, int  set, ut64  val  )

static

Definition at line 78 of file cmd_write.c.

                                                            {
    ut64 ret, orig;
    // used to set/unset bit in current address
    rz_io_read_at(core->io, core->offset, (ut8 *)&orig, sizeof(orig));
    if (set) {
        ret = orig | val;
    } else {
        ret = orig & (~(val));
    }
    if (!rz_core_write_at(core, core->offset, (const ut8 *)&ret, sizeof(ret))) {
        cmd_write_fail(core);
    }
}

References cmd_write_fail(), rz_core_t::io, rz_core_t::offset, rz_core_write_at(), rz_io_read_at(), ut64(), and val.

Referenced by rz_write_bits_handler(), and rz_write_unset_bits_handler().

cmd_write_fail()

static void cmd_write_fail ( RzCore *  core )

static

Definition at line 12 of file cmd_write.c.

                                         {
    eprintf("Failed to write\n");
    core->num->value = 1;
}

References eprintf, rz_core_t::num, and rz_num_t::value.

Referenced by cmd_write_bits().

common_write_value_handler()

static RzCmdStatus common_write_value_handler ( RzCore *  core, const char *  valstr, size_t  sz  )

static

Definition at line 96 of file cmd_write.c.

                                                                                           {
    ut64 value = rz_num_math(core->num, valstr);
    if (core->num->nc.errors) {
        RZ_LOG_ERROR("Could not convert argument to number");
        return RZ_CMD_STATUS_ERROR;
    }
 
    return rz_core_write_value_at(core, core->offset, value, sz) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References rz_num_calc_t::errors, rz_num_t::nc, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_value_at(), RZ_LOG_ERROR, rz_num_math(), ut64(), and value.

Referenced by rz_write_value1_handler(), rz_write_value2_handler(), rz_write_value4_handler(), rz_write_value8_handler(), and rz_write_value_handler().

encrypt_or_decrypt_block()

static bool encrypt_or_decrypt_block ( RzCore *  core, const char *  algo, const char *  key, int  direction, const char *  iv  )

static

Definition at line 17 of file cmd_write.c.

                                                                                                                     {
    // TODO: generalise no_key_mode for all non key encoding/decoding.
    int keylen = 0;
    bool no_key_mode = !strcmp("base64", algo) || !strcmp("base91", algo) || !strcmp("punycode", algo);
    ut8 *binkey = NULL;
    if (!strncmp(key, "s:", 2)) {
        binkey = (ut8 *)strdup(key + 2);
        keylen = strlen(key + 2);
    } else {
        binkey = (ut8 *)strdup(key);
        keylen = rz_hex_str2bin(key, binkey);
    }
    if (!no_key_mode && keylen < 1) {
        eprintf("%s key not defined. Use -S [key]\n", ((!direction) ? "Encryption" : "Decryption"));
        free(binkey);
        return false;
    }
    RzCrypto *cry = rz_crypto_new();
    if (rz_crypto_use(cry, algo)) {
        if (!binkey) {
            eprintf("Cannot allocate %d byte(s)\n", keylen);
            rz_crypto_free(cry);
            return false;
        }
        if (rz_crypto_set_key(cry, binkey, keylen, 0, direction)) {
            if (iv) {
                ut8 *biniv = malloc(strlen(iv) + 1);
                int ivlen = rz_hex_str2bin(iv, biniv);
                if (ivlen < 1) {
                    ivlen = strlen(iv);
                    strcpy((char *)biniv, iv);
                }
                if (!rz_crypto_set_iv(cry, biniv, ivlen)) {
                    eprintf("Invalid IV.\n");
                    return 0;
                }
            }
            rz_crypto_update(cry, (const ut8 *)core->block, core->blocksize);
            rz_crypto_final(cry, NULL, 0);
 
            int result_size = 0;
            const ut8 *result = rz_crypto_get_output(cry, &result_size);
            if (result) {
                if (!rz_core_write_at(core, core->offset, result, result_size)) {
                    eprintf("rz_core_write_at failed at 0x%08" PFMT64x "\n", core->offset);
                }
                eprintf("Written %d byte(s)\n", result_size);
            }
        } else {
            eprintf("Invalid key\n");
        }
        free(binkey);
        rz_crypto_free(cry);
        return 0;
    } else {
        eprintf("Unknown %s algorithm '%s'\n", ((!direction) ? "encryption" : "decryption"), algo);
    }
    rz_crypto_free(cry);
    return 1;
}

References rz_core_t::block, rz_core_t::blocksize, eprintf, free(), key, malloc(), NULL, rz_core_t::offset, PFMT64x, rz_core_write_at(), rz_crypto_final(), rz_crypto_free(), rz_crypto_get_output(), rz_crypto_new(), rz_crypto_set_iv(), rz_crypto_set_key(), rz_crypto_update(), rz_crypto_use(), rz_hex_str2bin(), and strdup().

Referenced by rz_write_op_decrypt_handler(), and rz_write_op_encrypt_handler().

ioMemcpy()

static bool ioMemcpy ( RzCore *  core, ut64  dst, ut64  src, int  len  )

static

Definition at line 134 of file cmd_write.c.

                                                                {
    bool ret = false;
    if (len > 0) {
        ut8 *buf = calloc(1, len);
        if (buf) {
            if (rz_io_read_at(core->io, src, buf, len)) {
                if (rz_io_write_at(core->io, dst, buf, len)) {
                    rz_core_block_read(core);
                    ret = true;
                } else {
                    eprintf("rz_io_write_at failed at 0x%08" PFMT64x "\n", dst);
                }
            } else {
                eprintf("rz_io_read_at failed at 0x%08" PFMT64x "\n", src);
            }
            free(buf);
        }
    }
    return ret;
}

References calloc(), dst, eprintf, free(), rz_core_t::io, len, PFMT64x, rz_core_block_read(), rz_io_read_at(), rz_io_write_at(), and src.

Referenced by rz_write_from_io_handler(), and rz_write_from_io_xchg_handler().

rz_write_1_dec_handler()

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

Definition at line 333 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 1);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_1_inc_handler()

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

Definition at line 330 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 1);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_2_dec_handler()

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

Definition at line 340 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 2);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_2_inc_handler()

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

Definition at line 337 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 2);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_4_dec_handler()

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

Definition at line 347 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 4);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_4_inc_handler()

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

Definition at line 344 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 4);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_8_dec_handler()

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

Definition at line 354 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 8);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_8_inc_handler()

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

Definition at line 351 of file cmd_write.c.

                                                                                     {
    return w_incdec_handler(core, argc, argv, 8);
}

References argv, and w_incdec_handler().

Referenced by rzshell_cmddescs_init().

rz_write_assembly_file_handler()

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

Definition at line 497 of file cmd_write.c.

                                                                                             {
    char *instructions = rz_file_slurp(argv[1], NULL);
    if (!instructions) {
        RZ_LOG_ERROR("Cannot read file '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    int res = rz_core_write_assembly(core, core->offset, instructions);
    free(instructions);
    return res >= 0 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, free(), instructions, NULL, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_assembly(), rz_file_slurp(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

rz_write_assembly_handler()

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

Definition at line 477 of file cmd_write.c.

                                                                                        {
    char *instructions = rz_str_array_join(argv + 1, argc - 1, "\n");
    if (!instructions) {
        return RZ_CMD_STATUS_ERROR;
    }
    int res = rz_core_write_assembly(core, core->offset, instructions);
    free(instructions);
    return res >= 0 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, free(), instructions, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_assembly(), and rz_str_array_join().

Referenced by rzshell_cmddescs_init().

rz_write_assembly_inside_handler()

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

Definition at line 487 of file cmd_write.c.

                                                                                               {
    char *instructions = rz_str_array_join(argv + 1, argc - 1, "\n");
    if (!instructions) {
        return RZ_CMD_STATUS_ERROR;
    }
    int res = rz_core_write_assembly_fill(core, core->offset, instructions);
    free(instructions);
    return res >= 0 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, free(), instructions, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_assembly_fill(), and rz_str_array_join().

Referenced by rzshell_cmddescs_init().

rz_write_assembly_opcode_handler()

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

Definition at line 508 of file cmd_write.c.

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

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

Referenced by rzshell_cmddescs_init().

rz_write_base64_decode_handler()

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

Definition at line 130 of file cmd_write.c.

                                                                                             {
    return rz_core_write_base64d_at(core, core->offset, argv[1]) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_write_base64d_at().

Referenced by rzshell_cmddescs_init().

rz_write_base64_encode_handler()

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

Definition at line 126 of file cmd_write.c.

                                                                                             {
    return rz_core_write_base64_at(core, core->offset, argv[1]) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_write_base64_at().

Referenced by rzshell_cmddescs_init().

rz_write_bits_handler()

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

Definition at line 297 of file cmd_write.c.

                                                                                    {
    cmd_write_bits(core, 1, rz_num_math(core->num, argv[1]));
    return RZ_CMD_STATUS_OK;
}

References argv, cmd_write_bits(), rz_core_t::num, RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_block_handler()

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

Definition at line 512 of file cmd_write.c.

                                                                                     {
    ut8 *hex = RZ_NEWS0(ut8, (strlen(argv[1]) + 1) / 2);
    if (!hex) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    int len = rz_hex_str2bin(argv[1], hex);
    if (len <= 0) {
        free(hex);
        RZ_LOG_ERROR("Cannot convert '%s' to hex data.\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
 
    return bool2status(rz_core_write_block(core, core->offset, hex, len));
}

References argv, bool2status(), free(), hex, len, rz_core_t::offset, RZ_CMD_STATUS_ERROR, rz_core_write_block(), rz_hex_str2bin(), RZ_LOG_ERROR, and RZ_NEWS0.

Referenced by rzshell_cmddescs_init().

rz_write_cache_commit_all_handler()

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

Definition at line 582 of file cmd_write.c.

                                                                                                {
    rz_io_cache_commit(core->io, 0, UT64_MAX);
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References rz_core_t::io, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_cache_commit(), and UT64_MAX.

Referenced by rzshell_cmddescs_init().

rz_write_cache_commit_handler()

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

Definition at line 575 of file cmd_write.c.

                                                                                            {
    ut64 from = argc > 1 ? rz_num_math(core->num, argv[1]) : core->offset;
    ut64 to = argc > 2 ? rz_num_math(core->num, argv[2]) : from + core->blocksize;
    rz_io_cache_commit(core->io, from, to);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, from, rz_core_t::io, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_io_cache_commit(), rz_num_math(), to, and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_cache_list_handler()

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

Definition at line 557 of file cmd_write.c.

                                                                                                                   {
    return rz_core_io_cache_print(core, state);
}

References rz_core_io_cache_print().

Referenced by rzshell_cmddescs_init().

rz_write_cache_remove_all_handler()

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

Definition at line 570 of file cmd_write.c.

                                                                                                {
    rz_io_cache_reset(core->io, core->io->cached);
    return RZ_CMD_STATUS_OK;
}

References rz_io_t::cached, rz_core_t::io, RZ_CMD_STATUS_OK, and rz_io_cache_reset().

Referenced by rzshell_cmddescs_init().

rz_write_cache_remove_handler()

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

Definition at line 561 of file cmd_write.c.

                                                                                            {
    ut64 from = argc > 1 ? rz_num_math(core->num, argv[1]) : core->offset;
    ut64 to = argc > 2 ? rz_num_math(core->num, argv[2]) : from + core->blocksize;
    int ninvalid = rz_io_cache_invalidate(core->io, from, to);
    RZ_LOG_INFO("Invalidated %d cache(s)\n", ninvalid);
    rz_core_block_read(core);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::blocksize, from, rz_core_t::io, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_cache_invalidate(), RZ_LOG_INFO, rz_num_math(), to, and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_debruijn_find_handler()

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

Definition at line 785 of file cmd_write.c.

                                                                                             {
    ut64 value = rz_num_math(core->num, argv[1]);
    int offset = rz_debruijn_offset(0, NULL, value, rz_config_get_b(core->config, "cfg.bigendian"));
    if (offset < 0) {
        RZ_LOG_ERROR("Could not find value %" PFMT64x " in Debruijn sequence.\n", value);
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cons_printf("%d\n", offset);
    return RZ_CMD_STATUS_OK;
}

References argv, rz_core_t::config, NULL, rz_core_t::num, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_config_get_b(), rz_cons_printf(), rz_debruijn_offset(), RZ_LOG_ERROR, rz_num_math(), ut64(), and value.

Referenced by rzshell_cmddescs_init().

rz_write_debruijn_handler()

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

Definition at line 769 of file cmd_write.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;
    }
    char *p = rz_debruijn_pattern(len, 0, NULL);
    if (!p) {
        RZ_LOG_ERROR("Cannot create Debrujn sequence of length %d\n", len);
        return RZ_CMD_STATUS_ERROR;
    }
    bool res = rz_core_write_string_at(core, core->offset, p);
    free(p);
    return bool2status(res);
}

References argv, bool2status(), free(), int, len, NULL, rz_core_t::num, rz_core_t::offset, p, RZ_CMD_STATUS_ERROR, rz_core_write_string_at(), rz_debruijn_pattern(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_duplicate_handler()

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

Definition at line 543 of file cmd_write.c.

                                                                                         {
    ut64 src = rz_num_math(core->num, argv[1]);
    int len = (int)rz_num_math(core->num, argv[2]);
    if (len < 0) {
        RZ_LOG_ERROR("Negative length is not valid.\n");
        return RZ_CMD_STATUS_ERROR;
    }
    return bool2status(rz_core_write_duplicate_at(core, core->offset, src, len));
}

References argv, bool2status(), int, len, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, rz_core_write_duplicate_at(), RZ_LOG_ERROR, rz_num_math(), src, and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_extend_hexbytes_handler()

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

Definition at line 642 of file cmd_write.c.

                                                                                               {
    ut8 *bytes = RZ_NEWS(ut8, (strlen(argv[1]) + 1) / 2);
    if (!bytes) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    int len = rz_hex_str2bin(argv[1], bytes);
    if (len <= 0) {
        RZ_LOG_ERROR("Cannot convert '%s' to bytes values.\n", argv[1]);
        free(bytes);
        return RZ_CMD_STATUS_ERROR;
    }
 
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : core->offset;
    bool res = rz_core_extend_at(core, addr, len);
    if (!res) {
        RZ_LOG_ERROR("Cannot extend the file.\n");
        free(bytes);
        return RZ_CMD_STATUS_ERROR;
    }
    bool result = rz_core_write_at(core, addr, bytes, len);
    free(bytes);
    return bool2status(result);
}

References addr, argv, bool2status(), bytes, free(), len, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, rz_core_extend_at(), rz_core_write_at(), rz_hex_str2bin(), RZ_LOG_ERROR, RZ_NEWS, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_extend_shift_handler()

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

Definition at line 632 of file cmd_write.c.

                                                                                            {
    ut64 dist = rz_num_math(core->num, argv[1]);
    ut64 block_size = argc > 2 ? rz_num_math(core->num, argv[2]) : 0;
    if (dist == 0) {
        RZ_LOG_ERROR("Cannot use '%s' as a distance.\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    return bool2status(rz_core_shift_block(core, core->offset, block_size, dist));
}

References argv, bool2status(), rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, rz_core_shift_block(), RZ_LOG_ERROR, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_extend_zero_handler()

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

Definition at line 626 of file cmd_write.c.

                                                                                           {
    ut64 len = rz_num_math(core->num, argv[1]);
    ut64 addr = argc > 2 ? rz_num_math(core->num, argv[2]) : core->offset;
    return bool2status(rz_core_extend_at(core, addr, len));
}

References addr, argv, bool2status(), len, rz_core_t::num, rz_core_t::offset, rz_core_extend_at(), rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_from_file_handler()

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

Definition at line 194 of file cmd_write.c.

                                                                                         {
    int wseek = rz_config_get_i(core->config, "cfg.wseek");
    ut64 user_size = argc > 2 ? rz_num_math(core->num, argv[2]) : UT64_MAX;
    ut64 offset = argc > 3 ? rz_num_math(core->num, argv[3]) : 0;
    const char *filename = argv[1];
 
    RzCmdStatus res = RZ_CMD_STATUS_ERROR;
    char *data = NULL;
    size_t size, w_size;
    if (!strcmp(filename, "-")) {
        data = rz_core_editor(core, NULL, NULL);
        if (!data) {
            eprintf("No data from editor\n");
            return RZ_CMD_STATUS_ERROR;
        }
        size = strlen(data);
    } else {
        data = rz_file_slurp(filename, &size);
        if (!data) {
            eprintf("Cannot open file '%s'\n", filename);
            return RZ_CMD_STATUS_ERROR;
        }
    }
 
    w_size = RZ_MIN(size, user_size);
    if (offset > size) {
        eprintf("Invalid offset provided\n");
        goto err;
    }
    if (UT64_ADD_OVFCHK(offset, w_size) || offset + w_size > size) {
        eprintf("Invalid offset/size provided\n");
        goto err;
    }
 
    rz_io_use_fd(core->io, core->file->fd);
    if (!rz_io_write_at(core->io, core->offset, (ut8 *)data + offset, w_size)) {
        eprintf("rz_io_write_at failed at 0x%08" PFMT64x "\n", core->offset);
        goto err;
    }
    WSEEK(core, w_size);
    rz_core_block_read(core);
    res = RZ_CMD_STATUS_OK;
 
err:
    free(data);
    return res;
}

References argv, rz_core_t::config, eprintf, err, rz_core_file_t::fd, rz_core_t::file, free(), rz_core_t::io, NULL, rz_core_t::num, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_config_get_i(), rz_core_block_read(), rz_core_editor(), rz_file_slurp(), rz_io_use_fd(), rz_io_write_at(), RZ_MIN, rz_num_math(), ut64(), UT64_ADD_OVFCHK, UT64_MAX, and WSEEK.

Referenced by rzshell_cmddescs_init().

rz_write_from_io_handler()

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

Definition at line 155 of file cmd_write.c.

                                                                                       {
    ut64 addr = rz_num_math(core->num, argv[1]);
    ut64 len = rz_num_math(core->num, argv[2]);
    bool res = ioMemcpy(core, core->offset, addr, len);
    return res ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References addr, argv, ioMemcpy(), len, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_from_io_xchg_handler()

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

Definition at line 162 of file cmd_write.c.

                                                                                            {
    ut64 dst = core->offset;
    ut64 src = rz_num_math(core->num, argv[1]);
    ut64 len = rz_num_math(core->num, argv[2]);
    if (len < 0) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    ut8 *buf = RZ_NEWS0(ut8, len);
    if (!buf) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    RzCmdStatus res = RZ_CMD_STATUS_ERROR;
    if (!rz_io_read_at(core->io, dst, buf, len)) {
        eprintf("cmd_wfx: failed to read at 0x%08" PFMT64x "\n", dst);
        goto err;
    }
 
    ioMemcpy(core, core->offset, src, len);
    if (!rz_io_write_at(core->io, src, buf, len)) {
        eprintf("Failed to write at 0x%08" PFMT64x "\n", src);
        goto err;
    }
 
    rz_core_block_read(core);
    res = RZ_CMD_STATUS_OK;
err:
    free(buf);
    return res;
}

References argv, dst, eprintf, err, free(), rz_core_t::io, ioMemcpy(), len, rz_core_t::num, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_block_read(), rz_io_read_at(), rz_io_write_at(), RZ_NEWS0, rz_num_math(), src, and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_from_socket_handler()

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

Definition at line 242 of file cmd_write.c.

                                                                                           {
    RzCmdStatus res = RZ_CMD_STATUS_ERROR;
    char *address = strdup(argv[1]);
    ut64 sz = argc > 2 ? rz_num_math(core->num, argv[2]) : core->blocksize;
 
    size_t n_split = rz_str_split(address, ':');
    if (n_split != 2) {
        eprintf("Wrong format for <host:port>\n");
        goto err;
    }
    char *host = address;
    char *port = host + strlen(host) + 1;
 
    ut8 *buf = RZ_NEWS0(ut8, sz);
    if (!buf) {
        goto err;
    }
 
    RzSocket *s = rz_socket_new(false);
    if (!rz_socket_listen(s, port, NULL)) {
        eprintf("Cannot listen on port %s\n", port);
        goto socket_err;
    }
    int done = 0;
    RzSocket *c = rz_socket_accept(s);
    if (!c) {
        eprintf("Failing to accept socket\n");
        goto socket_err;
    }
 
    eprintf("Receiving data from client...\n");
    while (done < sz) {
        int rc = rz_socket_read(c, buf + done, sz - done);
        if (rc < 0) {
            eprintf("Failing to read data from socket: %d\n", rc);
            goto socket_err;
        } else if (rc == 0) {
            break;
        }
        done += rc;
    }
    if (!rz_io_write_at(core->io, core->offset, buf, done)) {
        eprintf("Cannot write\n");
        goto socket_err;
    }
    eprintf("Written %d bytes\n", done);
    res = RZ_CMD_STATUS_OK;
 
socket_err:
    rz_socket_free(s);
err:
    free(address);
    return res;
}

References argv, rz_core_t::blocksize, c, done, eprintf, err, free(), rz_core_t::io, NULL, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_io_write_at(), RZ_NEWS0, rz_num_math(), rz_socket_accept(), rz_socket_free(), rz_socket_listen(), rz_socket_new(), rz_socket_read(), rz_str_split(), s, strdup(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_handler()

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

Definition at line 431 of file cmd_write.c.

                                                                               {
    return bool2status(rz_core_write_string_at(core, core->offset, argv[1]));
}

References argv, bool2status(), rz_core_t::offset, and rz_core_write_string_at().

Referenced by rzshell_cmddescs_init().

rz_write_hex_from_file_handler()

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

Definition at line 447 of file cmd_write.c.

                                                                                             {
    char *buf;
    if (!strcmp(argv[1], "-")) {
        buf = rz_core_editor(core, NULL, NULL);
        if (!buf) {
            RZ_LOG_ERROR("Could not get anything from editor\n");
            return RZ_CMD_STATUS_ERROR;
        }
    } else {
        if (!rz_file_exists(argv[1])) {
            RZ_LOG_ERROR("File '%s' does not exist\n", argv[1]);
            return RZ_CMD_STATUS_ERROR;
        }
 
        buf = rz_file_slurp(argv[1], NULL);
        if (!buf) {
            RZ_LOG_ERROR("Cannot open file '%s'\n", argv[1]);
            return RZ_CMD_STATUS_ERROR;
        }
    }
 
    int res = rz_core_write_hexpair(core, core->offset, buf);
    free(buf);
    if (res < 0) {
        RZ_LOG_ERROR("Could not write hexpairs to 0x%" PFMT64x "\n", core->offset);
        return RZ_CMD_STATUS_ERROR;
    }
    return RZ_CMD_STATUS_OK;
}

References argv, free(), NULL, rz_core_t::offset, PFMT64x, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_editor(), rz_core_write_hexpair(), rz_file_exists(), rz_file_slurp(), and RZ_LOG_ERROR.

Referenced by rzshell_cmddescs_init().

rz_write_hex_handler()

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

Definition at line 443 of file cmd_write.c.

                                                                                   {
    return rz_core_write_hexpair(core, core->offset, argv[1]) > 0 ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_write_hexpair().

Referenced by rzshell_cmddescs_init().

rz_write_length_string_handler()

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

Definition at line 553 of file cmd_write.c.

                                                                                             {
    return rz_core_write_length_string_at(core, core->offset, argv[1]) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, and rz_core_write_length_string_at().

Referenced by rzshell_cmddescs_init().

rz_write_mask_reset_handler()

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

Definition at line 539 of file cmd_write.c.

                                                                                          {
    return bool2status(rz_io_set_write_mask(core->io, NULL, 0));
}

References bool2status(), rz_core_t::io, NULL, and rz_io_set_write_mask().

Referenced by rzshell_cmddescs_init().

rz_write_mask_set_handler()

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

Definition at line 528 of file cmd_write.c.

                                                                                        {
    ut8 *buf = RZ_NEWS(ut8, strlen(argv[1]) / 2);
    if (!buf) {
        return RZ_CMD_STATUS_ERROR;
    }
    int size = rz_hex_str2bin(argv[1], buf);
    bool result = rz_io_set_write_mask(core->io, buf, size);
    free(buf);
    return bool2status(result);
}

References argv, bool2status(), free(), rz_core_t::io, RZ_CMD_STATUS_ERROR, rz_hex_str2bin(), rz_io_set_write_mask(), and RZ_NEWS.

Referenced by rzshell_cmddescs_init().

rz_write_op_2byteswap_handler()

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

Definition at line 667 of file cmd_write.c.

                                                                                            {
    return bool2status(rz_core_write_block_op_at(core, core->offset, RZ_CORE_WRITE_OP_BYTESWAP2, NULL, 0));
}

References bool2status(), NULL, rz_core_t::offset, rz_core_write_block_op_at(), and RZ_CORE_WRITE_OP_BYTESWAP2.

Referenced by rzshell_cmddescs_init().

rz_write_op_4byteswap_handler()

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

Definition at line 671 of file cmd_write.c.

                                                                                            {
    return bool2status(rz_core_write_block_op_at(core, core->offset, RZ_CORE_WRITE_OP_BYTESWAP4, NULL, 0));
}

References bool2status(), NULL, rz_core_t::offset, rz_core_write_block_op_at(), and RZ_CORE_WRITE_OP_BYTESWAP4.

Referenced by rzshell_cmddescs_init().

rz_write_op_8byteswap_handler()

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

Definition at line 675 of file cmd_write.c.

                                                                                            {
    return bool2status(rz_core_write_block_op_at(core, core->offset, RZ_CORE_WRITE_OP_BYTESWAP8, NULL, 0));
}

References bool2status(), NULL, rz_core_t::offset, rz_core_write_block_op_at(), and RZ_CORE_WRITE_OP_BYTESWAP8.

Referenced by rzshell_cmddescs_init().

rz_write_op_add_handler()

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

Definition at line 693 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_ADD);
}

References argv, RZ_CORE_WRITE_OP_ADD, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_and_handler()

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

Definition at line 713 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_AND);
}

References argv, RZ_CORE_WRITE_OP_AND, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_decrypt_handler()

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

Definition at line 736 of file cmd_write.c.

                                                                                          {
    const char *algo = argv[1];
    const char *key = argv[2];
    const char *iv = argv[3];
    return bool2status(encrypt_or_decrypt_block(core, algo, key, 1, iv));
}

References argv, bool2status(), encrypt_or_decrypt_block(), and key.

Referenced by rzshell_cmddescs_init().

rz_write_op_div_handler()

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

Definition at line 705 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_DIV);
}

References argv, RZ_CORE_WRITE_OP_DIV, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_encrypt_handler()

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

Definition at line 729 of file cmd_write.c.

                                                                                          {
    const char *algo = argv[1];
    const char *key = argv[2];
    const char *iv = argv[3];
    return bool2status(encrypt_or_decrypt_block(core, algo, key, 0, iv));
}

References argv, bool2status(), encrypt_or_decrypt_block(), and key.

Referenced by rzshell_cmddescs_init().

rz_write_op_mul_handler()

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

Definition at line 701 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_MUL);
}

References argv, RZ_CORE_WRITE_OP_MUL, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_or_handler()

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

Definition at line 717 of file cmd_write.c.

                                                                                     {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_OR);
}

References argv, RZ_CORE_WRITE_OP_OR, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_sequence_handler()

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

Definition at line 743 of file cmd_write.c.

                                                                                           {
    ut64 from = rz_num_math(NULL, argv[1]);
    ut64 to = rz_num_math(NULL, argv[2]);
    ut64 step = rz_num_math(NULL, argv[3]);
    int value_size = (int)rz_num_math(NULL, argv[4]);
    if (step < 1) {
        RZ_LOG_ERROR("Invalid <step> value: %" PFMT64d "\n", step);
        return RZ_CMD_STATUS_ERROR;
    }
    if (value_size != 1 && value_size != 2 && value_size != 4 && value_size != 8) {
        RZ_LOG_ERROR("Invalid <value_size> value: %d\n", value_size);
        return RZ_CMD_STATUS_ERROR;
    }
    ut64 max_val = (1ULL << (8 * value_size));
    if (from >= max_val) {
        RZ_LOG_ERROR("Invalid <from> value: %" PFMT64d "\n", from);
        return RZ_CMD_STATUS_ERROR;
    }
    if (to >= max_val) {
        RZ_LOG_ERROR("Invalid <to> value: %" PFMT64d "\n", to);
        return RZ_CMD_STATUS_ERROR;
    }
 
    return bool2status(rz_core_write_seq_at(core, core->offset, from, to, step, value_size));
}

References argv, bool2status(), from, int, NULL, rz_core_t::offset, PFMT64d, RZ_CMD_STATUS_ERROR, rz_core_write_seq_at(), RZ_LOG_ERROR, rz_num_math(), step(), to, and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_op_shl_handler()

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

Definition at line 721 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_SHIFT_LEFT);
}

References argv, RZ_CORE_WRITE_OP_SHIFT_LEFT, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_shr_handler()

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

Definition at line 725 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_SHIFT_RIGHT);
}

References argv, RZ_CORE_WRITE_OP_SHIFT_RIGHT, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_sub_handler()

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

Definition at line 697 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_SUB);
}

References argv, RZ_CORE_WRITE_OP_SUB, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_op_xor_handler()

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

Definition at line 709 of file cmd_write.c.

                                                                                      {
    return write_op_val(core, argc, argv, RZ_CORE_WRITE_OP_XOR);
}

References argv, RZ_CORE_WRITE_OP_XOR, and write_op_val().

Referenced by rzshell_cmddescs_init().

rz_write_pcache_commit_handler()

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

Definition at line 607 of file cmd_write.c.

                                                                                             {
    RzIODesc *desc = NULL;
    if (argc > 1) {
        int fd = (int)rz_num_math(core->num, argv[1]);
        if (fd < 0) {
            RZ_LOG_ERROR("Invalid fd argument %d.\n", fd);
            return RZ_CMD_STATUS_ERROR;
        }
        desc = rz_io_desc_get(core->io, fd);
    } else {
        desc = core->io->desc;
    }
    if (!desc) {
        RZ_LOG_ERROR("Cannot retrieve valid file.\n");
        return RZ_CMD_STATUS_ERROR;
    }
    return bool2status(rz_io_desc_cache_commit(desc));
}

References argv, bool2status(), desc, rz_io_t::desc, fd, int, rz_core_t::io, NULL, rz_core_t::num, RZ_CMD_STATUS_ERROR, rz_io_desc_cache_commit(), rz_io_desc_get(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_pcache_list_handler()

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

Definition at line 588 of file cmd_write.c.

                                                                                                                    {
    RzIODesc *desc = NULL;
    if (argc > 1) {
        int fd = (int)rz_num_math(core->num, argv[1]);
        if (fd < 0) {
            RZ_LOG_ERROR("Invalid fd argument %d.\n", fd);
            return RZ_CMD_STATUS_ERROR;
        }
        desc = rz_io_desc_get(core->io, fd);
    } else {
        desc = core->io->desc;
    }
    if (!desc) {
        RZ_LOG_ERROR("Cannot retrieve valid file.\n");
        return RZ_CMD_STATUS_ERROR;
    }
    return rz_core_io_pcache_print(core, desc, state);
}

References argv, desc, rz_io_t::desc, fd, int, rz_core_t::io, NULL, rz_core_t::num, RZ_CMD_STATUS_ERROR, rz_core_io_pcache_print(), rz_io_desc_get(), RZ_LOG_ERROR, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_random_handler()

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

Definition at line 422 of file cmd_write.c.

                                                                                      {
    if (!rz_num_is_valid_input(core->num, argv[1])) {
        RZ_LOG_ERROR("Invalid length '%s'\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    size_t length = rz_num_math(core->num, argv[1]);
    return rz_core_write_random_at(core, core->offset, length) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, length, rz_core_t::num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_random_at(), RZ_LOG_ERROR, rz_num_is_valid_input(), and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_unified_patch_handler()

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

Definition at line 358 of file cmd_write.c.

                                                                                             {
    // TODO: implement it in an API RzCore.write_unified_hexpatch() is ETOOLONG
    char *data = rz_file_slurp(argv[1], NULL);
    if (!data) {
        RZ_LOG_ERROR("Cannot read data from %s.\n", argv[1]);
        return RZ_CMD_STATUS_ERROR;
    }
    int i;
    char sign = ' ';
    int line = 0, offs = 0, hexa = 0;
    int newline = 1;
    for (i = 0; data[i]; i++) {
        switch (data[i]) {
        case '+':
            if (newline)
                sign = 1;
            break;
        case '-':
            if (newline) {
                sign = 0;
                offs = i + ((data[i + 1] == ' ') ? 2 : 1);
            }
            break;
        case ' ':
            data[i] = 0;
            if (sign) {
                if (!line)
                    line = i + 1;
                else if (!hexa)
                    hexa = i + 1;
            }
            break;
        case '\r':
            break;
        case '\n':
            newline = 1;
            if (sign == ' ') {
                offs = 0;
                line = 0;
                hexa = 0;
            } else if (sign) {
                if (offs && hexa) {
                    ut64 dst = rz_num_math(core->num, data + offs);
                    ut8 *buf = RZ_NEWS(ut8, strlen(data + hexa));
                    if (buf) {
                        int len = rz_hex_str2bin(data + hexa, buf);
                        rz_core_write_at(core, dst, buf, len);
                    }
                } else {
                    eprintf("food\n");
                }
                offs = 0;
                line = 0;
            } else
                hexa = 0;
            sign = -1;
            continue;
        }
        newline = 0;
    }
    free(data);
    return 0;
}

References argv, dst, eprintf, free(), i, len, setup::line, NULL, rz_core_t::num, RZ_CMD_STATUS_ERROR, rz_core_write_at(), rz_file_slurp(), rz_hex_str2bin(), RZ_LOG_ERROR, RZ_NEWS, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_unset_bits_handler()

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

Definition at line 302 of file cmd_write.c.

                                                                                          {
    cmd_write_bits(core, 0, rz_num_math(core->num, argv[1]));
    return RZ_CMD_STATUS_OK;
}

References argv, cmd_write_bits(), rz_core_t::num, RZ_CMD_STATUS_OK, and rz_num_math().

Referenced by rzshell_cmddescs_init().

rz_write_value1_handler()

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

Definition at line 110 of file cmd_write.c.

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

References argv, and common_write_value_handler().

Referenced by rzshell_cmddescs_init().

rz_write_value2_handler()

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

Definition at line 114 of file cmd_write.c.

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

References argv, and common_write_value_handler().

Referenced by rzshell_cmddescs_init().

rz_write_value4_handler()

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

Definition at line 118 of file cmd_write.c.

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

References argv, and common_write_value_handler().

Referenced by rzshell_cmddescs_init().

rz_write_value8_handler()

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

Definition at line 122 of file cmd_write.c.

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

References argv, and common_write_value_handler().

Referenced by rzshell_cmddescs_init().

rz_write_value_handler()

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

Definition at line 106 of file cmd_write.c.

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

References argv, and common_write_value_handler().

Referenced by rzshell_cmddescs_init().

rz_write_wide_string_handler()

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

Definition at line 439 of file cmd_write.c.

                                                                                           {
    return bool2status(rz_core_write_string_wide_at(core, core->offset, argv[1]));
}

References argv, bool2status(), rz_core_t::offset, and rz_core_write_string_wide_at().

Referenced by rzshell_cmddescs_init().

rz_write_zero_handler()

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

Definition at line 307 of file cmd_write.c.

                                                                                    {
    ut64 len = rz_num_math(core->num, argv[1]);
    ut8 *buf = RZ_NEWS0(ut8, len);
    if (!buf) {
        RZ_LOG_ERROR("Cannot allocate %" PFMT64d " bytes", len);
        return RZ_CMD_STATUS_ERROR;
    }
 
    bool res = rz_core_write_at(core, core->offset, buf, len);
    free(buf);
 
    return res ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, free(), len, rz_core_t::num, rz_core_t::offset, PFMT64d, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_at(), RZ_LOG_ERROR, RZ_NEWS0, rz_num_math(), and ut64().

Referenced by rzshell_cmddescs_init().

rz_write_zero_string_handler()

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

Definition at line 435 of file cmd_write.c.

                                                                                           {
    return bool2status(rz_core_write_string_zero_at(core, core->offset, argv[1]));
}

References argv, bool2status(), rz_core_t::offset, and rz_core_write_string_zero_at().

Referenced by rzshell_cmddescs_init().

w_incdec_handler()

static RzCmdStatus w_incdec_handler ( RzCore *  core, int  argc, const char **  argv, int  inc_size  )

static

Definition at line 321 of file cmd_write.c.

                                                                                             {
    st64 num = argc > 1 ? rz_num_math(core->num, argv[1]) : 1;
    const char *command = argv[0];
    if (command[strlen(command) - 1] == '-') {
        num *= -1;
    }
    return rz_core_write_value_inc_at(core, core->offset, num, inc_size) ? RZ_CMD_STATUS_OK : RZ_CMD_STATUS_ERROR;
}

References argv, command, rz_core_t::num, num, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_write_value_inc_at(), rz_num_math(), and st64.

Referenced by rz_write_1_dec_handler(), rz_write_1_inc_handler(), rz_write_2_dec_handler(), rz_write_2_inc_handler(), rz_write_4_dec_handler(), rz_write_4_inc_handler(), rz_write_8_dec_handler(), and rz_write_8_inc_handler().

write_op_val()

static RzCmdStatus write_op_val ( RzCore *  core, int  argc, const char **  argv, RzCoreWriteOp  op  )

static

Definition at line 679 of file cmd_write.c.

                                                                                             {
    rz_return_val_if_fail(argc > 1, RZ_CMD_STATUS_WRONG_ARGS);
 
    ut8 *hex = RZ_NEWS(ut8, (strlen(argv[1]) + 1) / 2);
    if (!hex) {
        return RZ_CMD_STATUS_ERROR;
    }
 
    int hexlen = rz_hex_str2bin(argv[1], hex);
    RzCmdStatus res = bool2status(rz_core_write_block_op_at(core, core->offset, op, hex, hexlen));
    free(hex);
    return res;
}

References argv, bool2status(), free(), hex, rz_core_t::offset, RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_WRONG_ARGS, rz_core_write_block_op_at(), rz_hex_str2bin(), RZ_NEWS, and rz_return_val_if_fail.

Referenced by rz_write_op_add_handler(), rz_write_op_and_handler(), rz_write_op_div_handler(), rz_write_op_mul_handler(), rz_write_op_or_handler(), rz_write_op_shl_handler(), rz_write_op_shr_handler(), rz_write_op_sub_handler(), and rz_write_op_xor_handler().