rz_cmp.h File Reference

#include <rz_core.h>
#include <rz_util.h>

Go to the source code of this file.

Classes
struct	RzCompareData
struct	rz_core_cmpwatch_t

Typedefs
typedef struct rz_core_cmpwatch_t	RzCoreCmpWatcher

Functions
RZ_API RZ_OWN RzCompareData *	rz_core_cmp_mem_mem (RzCore *core, ut64 addr1, ut64 addr2, ut32 len)
	Compare memory at addr1 with the memory at addr2. More...
RZ_API RZ_OWN RzCompareData *	rz_core_cmp_mem_data (RzCore *core, ut64 addr, RZ_NONNULL const ut8 *data, ut32 len)
	Compare mem at addr with data data. More...
RZ_API int	rz_core_cmp_print (RzCore *core, RZ_NONNULL const RzCompareData *cmp, RzCmdStateOutput *state)
	Print a comparison cmp according to the print mode mode. More...
RZ_API RZ_OWN RzList *	rz_core_cmp_disasm (RzCore *core, ut64 addr1, ut64 addr2, ut32 len)
	Compare the instructions at addr1 and addr2. More...
RZ_API void	rz_core_cmp_free (RzCompareData *cmp)
	Free RzCompareData object. More...
RZ_API bool	rz_core_cmp_disasm_print (RzCore *core, const RzList *compare, bool unified)
	Print the instruction comparison data compare. More...
RZ_API void	rz_core_cmpwatch_free (RzCoreCmpWatcher *w)
RZ_API RzCoreCmpWatcher *	rz_core_cmpwatch_get (RzCore *core, ut64 addr)
	Get the memory watcher at address addr. More...
RZ_API bool	rz_core_cmpwatch_add (RzCore *core, ut64 addr, int size, const char *cmd)
	Add a memory watcher at address addr od size size and command cmd. More...
RZ_API bool	rz_core_cmpwatch_del (RzCore *core, ut64 addr)
	Delete a memory watcher at address addr. More...
RZ_API bool	rz_core_cmpwatch_update (RzCore *core, ut64 addr)
	Update the memory watcher at address addr. More...
RZ_API void	rz_core_cmpwatch_show (RzCore *core, ut64 addr, RzOutputMode mode)
	Show/print the memory watcher present at address addr. More...
RZ_API bool	rz_core_cmpwatch_revert (RzCore *core, ut64 addr)
	Revert/reset a memory watcher at address addr. More...

Typedef Documentation

RzCoreCmpWatcher

typedef struct rz_core_cmpwatch_t RzCoreCmpWatcher

Function Documentation

rz_core_cmp_disasm()

RZ_API RZ_OWN RzList* rz_core_cmp_disasm	(	RzCore *	core,
		ut64	addr1,
		ut64	addr2,
		ut32	len
	)

Compare the instructions at addr1 and addr2.

Parameters

core	Current RzCore instance
addr1	address to read instructions from
addr2	address to read instructions from
len	number of bytes to read instructions from

Returns

RzList<RzCompareData>* List of comparison data

Definition at line 161 of file cmp.c.

                                                                                           {
    rz_return_val_if_fail(core, NULL);
 
    RzList *cmp_list = rz_list_new();
    if (!cmp_list) {
        goto error_goto;
    }
    cmp_list->free = (RzListFree)&rz_core_cmp_free;
    RzAsmOp op, op2;
    int i, j;
    ut8 *buf = calloc(len + 32, 1);
    if (!buf) {
        goto error_goto;
    }
    rz_io_nread_at(core->io, addr2, buf, len + 32);
    RzCompareData *comp;
 
    for (i = j = 0; i < len && j < len;) {
        comp = RZ_NEW0(RzCompareData);
        if (!comp) {
            continue;
        }
 
        // dis A
        rz_asm_set_pc(core->rasm, addr1 + i);
        (void)rz_asm_disassemble(core->rasm, &op,
            core->block + i, len - i);
 
        // dis B
        rz_asm_set_pc(core->rasm, addr2 + i);
        (void)rz_asm_disassemble(core->rasm, &op2,
            buf + j, len - j);
 
        comp->len = UT8_MAX;
        comp->data1 = (ut8 *)strdup(rz_strbuf_get(&op.buf_asm));
        comp->addr1 = addr1 + i;
        comp->data2 = (ut8 *)strdup(rz_strbuf_get(&op2.buf_asm));
        comp->addr2 = addr2 + j;
        comp->same = !strcmp((char *)comp->data1, (char *)comp->data2); // we can assume that instructions can be represented as plain chars
        rz_list_append(cmp_list, comp);
 
        if (op.size < 1) {
            op.size = 1;
        }
        i += op.size;
        if (op2.size < 1) {
            op2.size = 1;
        }
        j += op2.size;
    }
 
    free(buf);
    return cmp_list;
 
error_goto:
    rz_list_free(cmp_list);
    return NULL;
}

References RzCompareData::addr1, RzCompareData::addr2, rz_core_t::block, rz_asm_op_t::buf_asm, calloc(), RzCompareData::data1, RzCompareData::data2, rz_list_t::free, free(), i, rz_core_t::io, len, RzCompareData::len, NULL, op, rz_core_t::rasm, rz_asm_disassemble(), rz_asm_set_pc(), rz_core_cmp_free(), rz_io_nread_at(), rz_list_append(), rz_list_free(), rz_list_new(), RZ_NEW0, rz_return_val_if_fail, rz_strbuf_get(), RzCompareData::same, rz_asm_op_t::size, strdup(), and UT8_MAX.

Referenced by rz_cmd_cmp_disasm_handler(), and rz_cmd_cmp_unified_disasm_handler().

rz_core_cmp_disasm_print()

RZ_API bool rz_core_cmp_disasm_print	(	RzCore *	core,
		const RzList *	compare,
		bool	unified
	)

Print the instruction comparison data compare.

Parameters

core	Current RzCore instance
compare	list of RzCompareData of instructions
unified	print in unified form

Returns

bool true if successfull

Definition at line 243 of file cmp.c.

                                                                                          {
    rz_return_val_if_fail(core && compare, false);
    char colpad[80];
    int hascolor = rz_config_get_i(core->config, "scr.color");
    int cols = rz_config_get_i(core->config, "hex.cols") * 2;
    RzConsPrintablePalette *pal = &rz_cons_singleton()->context->pal;
    RzListIter *it;
    RzCompareData *cmp;
 
    if (unified) {
        rz_list_foreach (compare, it, cmp) {
            if (cmp->same) {
                rz_cons_printf(" 0x%08" PFMT64x "  %s\n",
                    cmp->addr1, cmp->data1);
            } else {
                if (hascolor) {
                    rz_cons_print(pal->graph_false);
                }
                rz_cons_printf("-0x%08" PFMT64x "  %s\n",
                    cmp->addr1, cmp->data1);
                if (hascolor) {
                    rz_cons_print(pal->graph_true);
                }
                rz_cons_printf("+0x%08" PFMT64x "  %s\n",
                    cmp->addr2, cmp->data2);
                if (hascolor) {
                    rz_cons_print(Color_RESET);
                }
            }
        }
    } else {
        rz_list_foreach (compare, it, cmp) {
            memset(colpad, ' ', sizeof(colpad));
            int pos = strlen((char *)cmp->data1);
            pos = (pos > cols) ? 0 : cols - pos;
            colpad[pos] = 0;
            if (hascolor) {
                rz_cons_print(cmp->same ? pal->graph_true : pal->graph_false);
            }
            rz_cons_printf(" 0x%08" PFMT64x "  %s %s",
                cmp->addr1, cmp->data1, colpad);
            rz_cons_printf("%c 0x%08" PFMT64x "  %s\n",
                cmp->same ? '=' : '!', cmp->addr2, cmp->data2);
            if (hascolor) {
                rz_cons_print(Color_RESET);
            }
        }
    }
 
    return true;
}

References cmp(), Color_RESET, compare(), rz_core_t::config, rz_cons_t::context, rz_cons_printable_palette_t::graph_false, rz_cons_printable_palette_t::graph_true, memset(), rz_cons_context_t::pal, PFMT64x, pos, rz_config_get_i(), rz_cons_printf(), rz_cons_singleton(), and rz_return_val_if_fail.

Referenced by rz_cmd_cmp_disasm_handler(), and rz_cmd_cmp_unified_disasm_handler().

rz_core_cmp_free()

RZ_API void rz_core_cmp_free

(

RzCompareData *

cmp

)

Free RzCompareData object.

Parameters

cmp	RzCompareData object to be freed

Returns

void

Definition at line 226 of file cmp.c.

                                                 {
    if (!cmp) {
        return;
    }
    RZ_FREE(cmp->data1);
    RZ_FREE(cmp->data2);
    free(cmp);
}

References cmp(), free(), and RZ_FREE.

Referenced by rz_cmd_cmp_addr_handler(), rz_cmd_cmp_bits_handler(), rz_cmd_cmp_bytes_handler(), rz_cmd_cmp_file_handler(), rz_cmd_cmp_hex_block_hexdiff_handler(), rz_cmd_cmp_hexpair_string_handler(), rz_cmd_cmp_string_handler(), rz_cmd_cmp_unified_handler(), and rz_core_cmp_disasm().

rz_core_cmp_mem_data()

RZ_API RZ_OWN RzCompareData* rz_core_cmp_mem_data	(	RzCore *	core,
		ut64	addr,
		RZ_NONNULL const ut8 *	data,
		ut32	len
	)

Compare mem at addr with data data.

Parameters

core	Current RzCore instance
addr	address to read data from
data	Data to be compared
len	Number of bytes to compare

Returns

RzCompareData* A pointer to RzCompareData comparison (the data1 corresponds to the data at addr (and addr1 = addr) and data2 is the str data (and addr2 = UT32_MAX))

Definition at line 56 of file cmp.c.

                                                                                                                 {
    rz_return_val_if_fail(core && data, NULL);
 
    ut8 *buf1 = malloc(len * sizeof(ut8));
    if (!buf1) {
        RZ_LOG_ERROR("Cannot read at address: 0x%" PFMT64x "\n", addr);
        goto error_goto;
    }
    if (rz_io_nread_at(core->io, addr, buf1, len) != len) {
        RZ_LOG_ERROR("Cannot read %u bytes at provided address: 0x%" PFMT64x "\n", len, addr);
        goto error_goto;
    }
    RzCompareData *cmp = RZ_NEW0(RzCompareData);
    if (!cmp) {
        goto error_goto;
    }
    cmp->len = len;
    cmp->data1 = buf1;
    cmp->addr1 = addr;
    cmp->data2 = rz_mem_dup(data, len);
    cmp->addr2 = UT64_MAX;
    cmp->same = rz_mem_eq(cmp->data1, cmp->data2, len);
    return cmp;
 
error_goto:
    free(buf1);
    return NULL;
}

References addr, cmp(), free(), rz_core_t::io, len, malloc(), NULL, PFMT64x, rz_io_nread_at(), RZ_LOG_ERROR, rz_mem_dup(), rz_mem_eq(), RZ_NEW0, rz_return_val_if_fail, and UT64_MAX.

Referenced by rz_cmd_cmp_bytes_handler(), rz_cmd_cmp_file_handler(), rz_cmd_cmp_hex_block_hexdiff_handler(), rz_cmd_cmp_hexpair_string_handler(), and rz_cmd_cmp_string_handler().

rz_core_cmp_mem_mem()

RZ_API RZ_OWN RzCompareData* rz_core_cmp_mem_mem	(	RzCore *	core,
		ut64	addr1,
		ut64	addr2,
		ut32	len
	)

Compare memory at addr1 with the memory at addr2.

Parameters

core	Current RzCore instance
addr1	address to read data from
addr2	address to read data from
len	Number of bytes to compare

Returns

RzCompareData* A pointer to RzCompareData comparison

Definition at line 17 of file cmp.c.

                                                                                                 {
    rz_return_val_if_fail(core, NULL);
 
    ut8 *buf1 = malloc(len * sizeof(ut8));
    ut8 *buf2 = malloc(len * sizeof(ut8));
    if (!buf1 || !buf2) {
        goto error_goto;
    }
    if (!(rz_io_nread_at(core->io, addr1, buf1, len) == len && rz_io_nread_at(core->io, addr2, buf2, len) == len)) {
        RZ_LOG_ERROR("Cannot read %u bytes at provided addresses: 0x%" PFMT64x " 0x%" PFMT64x "\n", len, addr1, addr2);
        goto error_goto;
    }
    RzCompareData *cmp = RZ_NEW0(RzCompareData);
    if (!cmp) {
        goto error_goto;
    }
    cmp->len = len;
    cmp->data1 = buf1;
    cmp->addr1 = addr1;
    cmp->data2 = buf2;
    cmp->addr2 = addr2;
    cmp->same = rz_mem_eq(cmp->data1, cmp->data2, len);
    return cmp;
 
error_goto:
    free(buf1);
    free(buf2);
    return NULL;
}

References buf2, cmp(), free(), rz_core_t::io, len, malloc(), NULL, PFMT64x, rz_io_nread_at(), RZ_LOG_ERROR, rz_mem_eq(), RZ_NEW0, and rz_return_val_if_fail.

Referenced by rz_cmd_cmp_addr_handler(), rz_cmd_cmp_bits_handler(), and rz_cmd_cmp_unified_handler().

rz_core_cmp_print()

RZ_API int rz_core_cmp_print	(	RzCore *	core,
		RZ_NONNULL const RzCompareData *	cmp,
		RzCmdStateOutput *	state
	)

Print a comparison cmp according to the print mode mode.

Parameters

core	Current RzCore instance
cmp	RzCompareData instance to be printed
state	RzCmdStateOutput to be used (options: standard, json) (NULL means standard)

Returns

int Number of lines/diffs printed (-1 if failed)

Definition at line 93 of file cmp.c.

                                                                                                         {
    rz_return_val_if_fail(core && cmp, -1);
 
    int i, eq = 0;
    bool data_str = cmp->addr2 == UT64_MAX;
    if (cmp->len == UT8_MAX) {
        return -1;
    }
    RzOutputMode mode = RZ_OUTPUT_MODE_STANDARD;
    PJ *pj = NULL;
    if (state) {
        mode = state->mode;
        pj = state->d.pj;
    }
    if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_o(pj);
        pj_k(pj, "diff_bytes");
        pj_a(pj);
    }
    for (i = 0; i < cmp->len; i++) {
        if (cmp->data1[i] == cmp->data2[i]) {
            eq++;
            continue;
        }
        switch (mode) {
        case RZ_OUTPUT_MODE_STANDARD:
            rz_cons_printf("0x%08" PFMT64x, cmp->addr1 + i);
            if (!data_str) {
                rz_cons_printf("  ->  0x%08" PFMT64x, cmp->addr2 + i);
            }
            rz_cons_printf(" (byte=%.2d)   %02x '%c'  ->  %02x '%c'\n", i + 1,
                cmp->data1[i], (IS_PRINTABLE(cmp->data1[i])) ? cmp->data1[i] : ' ',
                cmp->data2[i], (IS_PRINTABLE(cmp->data2[i])) ? cmp->data2[i] : ' ');
            break;
        case RZ_OUTPUT_MODE_JSON:
            pj_o(pj);
            pj_kn(pj, "offset1", cmp->addr1 + i);
            pj_kn(pj, "offset2", data_str ? i : cmp->addr2 + i);
            pj_ki(pj, "rel_offset", i);
            pj_ki(pj, "value1", (int)cmp->data1[i]);
            pj_ki(pj, "value2", (int)cmp->data2[i]);
            pj_end(pj);
            break;
        default:
            rz_warn_if_reached();
        }
    }
    if (mode == RZ_OUTPUT_MODE_STANDARD) {
        rz_cons_printf("Compare %d/%d equal bytes (%d%%)\n", eq, cmp->len, (int)(100.0 * eq / cmp->len));
    } else if (mode == RZ_OUTPUT_MODE_JSON) {
        pj_end(pj);
        pj_ki(pj, "equal_bytes", eq);
        pj_ki(pj, "total_bytes", cmp->len);
        pj_end(pj); // End array
        pj_end(pj); // End object
    }
    return cmp->len - eq;
}

References cmp(), eq, i, IS_PRINTABLE, NULL, PFMT64x, pj_a(), pj_end(), pj_k(), pj_ki(), pj_kn(), pj_o(), rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_return_val_if_fail, rz_warn_if_reached, UT64_MAX, and UT8_MAX.

Referenced by rz_cmd_cmp_addr_handler(), rz_cmd_cmp_bytes_handler(), rz_cmd_cmp_file_handler(), rz_cmd_cmp_hex_block_hexdiff_handler(), rz_cmd_cmp_hexpair_string_handler(), and rz_cmd_cmp_string_handler().