Memory watcher functions API

Functions
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 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_update (RzCore *core, ut64 addr)
	Update the memory watcher at address addr. More...
RZ_API bool	rz_core_cmpwatch_revert (RzCore *core, ut64 addr)
	Revert/reset a memory watcher at address addr. More...

Detailed Description

API for memory watcher functions

Function Documentation

rz_core_cmpwatch_add()

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.

Parameters

core	Current RzCore instance
addr	Address where to add the new memory watcher
size	Size of the memory watcher to be addded
cmd	Command to be associated with the memory watcher

Returns

bool true if successful, false otherwise

Definition at line 337 of file cmp.c.

                                                                                     {
    rz_return_val_if_fail(core, false);
    RzCoreCmpWatcher *cmpw;
    bool to_add = false;
    if (size < 1) {
        return false;
    }
    cmpw = rz_core_cmpwatch_get(core, addr);
    if (!cmpw) {
        to_add = true;
        cmpw = RZ_NEW(RzCoreCmpWatcher);
        if (!cmpw) {
            return false;
        }
        cmpw->addr = addr;
    }
    cmpw->size = size;
    snprintf(cmpw->cmd, sizeof(cmpw->cmd), "%s", cmd);
    cmpw->odata = NULL;
    cmpw->ndata = malloc(size);
    if (!cmpw->ndata) {
        free(cmpw);
        return false;
    }
    rz_io_nread_at(core->io, addr, cmpw->ndata, size);
    if (to_add) {
        rz_list_append(core->watchers, cmpw);
    }
    return true;
}

References addr, cmd, free(), rz_core_t::io, malloc(), NULL, rz_core_cmpwatch_get(), rz_io_nread_at(), rz_list_append(), RZ_NEW, rz_return_val_if_fail, snprintf, and rz_core_t::watchers.

Referenced by rz_cmd_cmp_add_memory_watcher_handler().

rz_core_cmpwatch_del()

RZ_API bool rz_core_cmpwatch_del	(	RzCore *	core,
		ut64	addr
	)

Delete a memory watcher at address addr.

Parameters

core	Current RzCore instance
addr	Address of the memory watcher to be deleted (if UT64_MAX, then all memory watchers will be deleted)

Returns

bool true if found and deleted; false otherwise

Definition at line 375 of file cmp.c.

                                                          {
    rz_return_val_if_fail(core, false);
    int ret = false;
    RzCoreCmpWatcher *w;
    RzListIter *iter, *iter2;
    rz_list_foreach_safe (core->watchers, iter, iter2, w) {
        if (w->addr == addr || addr == UT64_MAX) {
            rz_list_delete(core->watchers, iter);
            ret = true;
        }
    }
    return ret;
}

References addr, rz_list_delete(), rz_return_val_if_fail, UT64_MAX, w, and rz_core_t::watchers.

Referenced by rz_cmd_cmp_remove_watcher_handler().

rz_core_cmpwatch_free()

RZ_API void rz_core_cmpwatch_free

(

RzCoreCmpWatcher *

w

)

Definition at line 300 of file cmp.c.

                                                       {
    if (!w) {
        return;
    }
    free(w->ndata);
    free(w->odata);
    free(w);
}

References free(), and w.

Referenced by rz_core_init().

rz_core_cmpwatch_get()

RZ_API RzCoreCmpWatcher* rz_core_cmpwatch_get	(	RzCore *	core,
		ut64	addr
	)

Get the memory watcher at address addr.

Parameters

core	Current RzCore instance
addr	Expected address for the memory watcher to be found

Returns

RzCoreCmpWatcher* Pointer to the found memory watcher; NULL if not found

Definition at line 316 of file cmp.c.

                                                                       {
    rz_return_val_if_fail(core, NULL);
    RzListIter *iter;
    RzCoreCmpWatcher *w;
    rz_list_foreach (core->watchers, iter, w) {
        if (addr == w->addr) {
            return w;
        }
    }
    return NULL;
}

References addr, NULL, rz_return_val_if_fail, w, and rz_core_t::watchers.

Referenced by rz_core_cmpwatch_add().

rz_core_cmpwatch_revert()

RZ_API bool rz_core_cmpwatch_revert	(	RzCore *	core,
		ut64	addr
	)

Revert/reset a memory watcher at address addr.

Parameters

core	Current RzCore instance
addr	Address of the memory watcher to be reset (if UT64_MAX, then all memory watchers will be reset)

Returns

bool true if the memory watcher was resetted; false otherwise

Definition at line 458 of file cmp.c.

                                                             {
    rz_return_val_if_fail(core, false);
    RzCoreCmpWatcher *w;
    int ret = false;
    RzListIter *iter;
    rz_list_foreach (core->watchers, iter, w) {
        if (w->addr == addr || addr == UT64_MAX) {
            if (w->odata) {
                free(w->ndata);
                w->ndata = w->odata;
                w->odata = NULL;
                ret = true;
            }
        }
    }
    return ret;
}

References addr, free(), NULL, rz_return_val_if_fail, UT64_MAX, w, and rz_core_t::watchers.

Referenced by rz_cmd_cmp_reset_watcher_handler().

rz_core_cmpwatch_show()

RZ_API void rz_core_cmpwatch_show	(	RzCore *	core,
		ut64	addr,
		RzOutputMode	mode
	)

Show/print the memory watcher present at address addr.

Parameters

core	Current RzCore instance
addr	Address of the memory watcher to be printed (if UT64_MAX, then all memory watchers will be printed)
mode	Output mode

Returns

void Print nothing if no memory watcher found at addr

Definition at line 397 of file cmp.c.

                                                                              {
    rz_return_if_fail(core);
    char cmd[128];
    RzListIter *iter;
    RzCoreCmpWatcher *w;
    rz_list_foreach (core->watchers, iter, w) {
        if (addr != UT64_MAX && w->addr != addr) {
            continue;
        }
        int is_diff = w->odata ? memcmp(w->odata, w->ndata, w->size) : 0;
        switch (mode) {
        case RZ_OUTPUT_MODE_RIZIN:
            rz_cons_printf("cw %d '%s' @  0x%08" PFMT64x "%s\n",
                w->size, w->cmd, w->addr, is_diff ? " # differs" : "");
            break;
        case RZ_OUTPUT_MODE_STANDARD:
            rz_cons_printf("0x%08" PFMT64x "%s\n", w->addr, is_diff ? " modified" : "");
            snprintf(cmd, sizeof(cmd), "%s @ %" PFMT64d " @!%d", w->cmd, w->addr, w->size);
            rz_core_cmd0(core, cmd);
            break;
        default:
            rz_warn_if_reached();
        }
    }
}

References addr, cmd, PFMT64d, PFMT64x, rz_cons_printf(), rz_core_cmd0(), RZ_OUTPUT_MODE_RIZIN, RZ_OUTPUT_MODE_STANDARD, rz_return_if_fail, rz_warn_if_reached, snprintf, UT64_MAX, w, and rz_core_t::watchers.

Referenced by rz_cmd_cmp_list_compare_watchers_handler().

rz_core_cmpwatch_update()

RZ_API bool rz_core_cmpwatch_update	(	RzCore *	core,
		ut64	addr
	)

Update the memory watcher at address addr.

Parameters

core	Current RzCore instance
addr	Address of the memory watcher to be updated (if UT64_MAX, then all memory watchers will be updated)

Returns

bool true if any memory watcher was updated; false otherwise

Definition at line 430 of file cmp.c.

                                                             {
    rz_return_val_if_fail(core, false);
    RzCoreCmpWatcher *w;
    RzListIter *iter;
    bool ret = false;
    rz_list_foreach (core->watchers, iter, w) {
        if (addr != UT64_MAX && w->addr != addr) {
            continue;
        }
        free(w->odata);
        w->odata = w->ndata;
        w->ndata = malloc(w->size);
        if (!w->ndata) {
            return false;
        }
        rz_io_nread_at(core->io, w->addr, w->ndata, w->size);
        ret = true;
    }
    return ret;
}

References addr, free(), rz_core_t::io, malloc(), rz_io_nread_at(), rz_return_val_if_fail, UT64_MAX, w, and rz_core_t::watchers.

Referenced by rz_cmd_cmp_update_watcher_handler().