core.c File Reference

#include <rz_core.h>
#include <rz_socket.h>
#include <rz_cmp.h>
#include <config.h>
#include <rz_util.h>
#include "core_private.h"

Go to the source code of this file.

Classes
struct	RzIORap

Macros
#define	DB   core->sdb
#define	rizin_argc   (sizeof(rizin_argv) / sizeof(const char *) - 1)
#define	ADDARG(x)
#define	MINLEN   1

Functions
	RZ_LIB_VERSION (rz_core)
bool	rz_core_is_project (RzCore *core, const char *name)
RZ_API void	rz_core_notify_begin (RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
	Prints a message definining the beginning of a task. More...
RZ_API void	rz_core_notify_done (RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
	Prints a message definining the end of a task which succeeded. More...
RZ_API void	rz_core_notify_error (RZ_NONNULL RzCore *core, RZ_NONNULL const char *format,...)
	Prints a message definining the end of a task which errored. More...
static int	on_fcn_new (RzAnalysis *_analysis, void *_user, RzAnalysisFunction *fcn)
static int	on_fcn_delete (RzAnalysis *_analysis, void *_user, RzAnalysisFunction *fcn)
static int	on_fcn_rename (RzAnalysis *_analysis, void *_user, RzAnalysisFunction *fcn, const char *oname)
static void	rz_core_debug_breakpoint_hit (RzCore *core, RzBreakpointItem *bpi)
static void	rz_core_debug_syscall_hit (RzCore *core)
RZ_API RzBinReloc *	rz_core_getreloc (RzCore *core, ut64 addr, int size)
RZ_API RzBinReloc *	rz_core_get_reloc_to (RzCore *core, ut64 addr)
RZ_API ut64	rz_core_get_asmqjmps (RzCore *core, const char *str)
RZ_API char *	rz_core_add_asmqjmp (RzCore *core, ut64 addr)
RZ_API void	rz_core_set_asmqjmps (RzCore *core, char *str, size_t len, int pos)
static void	setab (RzCore *core, const char *arch, int bits)
static const char *	getName (RzCore *core, ut64 addr)
static char *	getNameDelta (RzCore *core, ut64 addr)
static void	archbits (RzCore *core, ut64 addr)
static ut64	cfggeti (RzCore *core, const char *k)
static const char *	cfgget (RzCore *core, const char *k)
static bool	cfgseti (RzCore *core, const char *k, ut64 v)
static bool	cfgset (RzCore *core, const char *k, const char *v)
static ut64	numget (RzCore *core, const char *k)
static const RzList *	__flagsGet (RzCore *core, ut64 offset)
RZ_API int	rz_core_bind (RzCore *core, RzCoreBind *bnd)
RZ_API RzCore *	rz_core_ncast (ut64 p)
RZ_API RzCore *	rz_core_cast (void *p)
static ut64	getref (RzCore *core, int n, char t, int type)
static ut64	bbInstructions (RzAnalysisFunction *fcn, ut64 addr)
static ut64	bbBegin (RzAnalysisFunction *fcn, ut64 addr)
static ut64	bbJump (RzAnalysisFunction *fcn, ut64 addr)
static ut64	bbFail (RzAnalysisFunction *fcn, ut64 addr)
static ut64	bbSize (RzAnalysisFunction *fcn, ut64 addr)
static const char *	str_callback (RzNum *user, ut64 off, int *ok)
static ut64	num_callback (RzNum *userptr, const char *str, int *ok)
RZ_API RzCore *	rz_core_new (void)
static void	autocomplete_process_path (RzLineCompletion *completion, const char *str, const char *path)
static void	autocompleteFilename (RzLineCompletion *completion, RzLineBuffer *buf, char **extra_paths, int narg)
static void	autocomplete_default (RZ_NULLABLE RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf)
static void	autocomplete_evals (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_minus (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_breakpoints (RzCore *core, RzLineCompletion *completion, const char *str)
static bool	add_argv (RzFlagItem *fi, void *user)
static void	autocomplete_flags (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_sdb (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_flagspaces (RzCore *core, RzLineCompletion *completion, const char *msg)
static void	autocomplete_functions (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_macro (RzCore *core, RzLineCompletion *completion, const char *str)
static void	autocomplete_file (RzLineCompletion *completion, const char *str)
static void	autocomplete_theme (RzCore *core, RzLineCompletion *completion, const char *str)
static bool	find_e_opts (RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf)
static bool	find_autocomplete (RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf)
RZ_API void	rz_core_autocomplete (RZ_NULLABLE RzCore *core, RzLineCompletion *completion, RzLineBuffer *buf, RzLinePromptType prompt_type)
static RzLineNSCompletionResult *	rzshell_autocomplete (RzLineBuffer *buf, RzLinePromptType prompt_type, void *user)
RZ_API int	rz_core_fgets (char *buf, int len, void *user)
static const char *	rz_core_print_offname (void *p, ut64 addr)
static int	rz_core_print_offsize (void *p, ut64 addr)
static int	__disasm (void *_core, ut64 addr)
static void	update_sdb (RzCore *core)
static int	is_string (const ut8 *buf, int size, int *len)
RZ_API char *	rz_core_analysis_hasrefs (RzCore *core, ut64 value, int mode)
static char *	getvalue (ut64 value, int bits)
RZ_API char *	rz_core_analysis_hasrefs_to_depth (RzCore *core, ut64 value, PJ *pj, int depth)
RZ_API char *	rz_core_analysis_get_comments (RzCore *core, ut64 addr)
RZ_API const char *	rz_core_analysis_optype_colorfor (RzCore *core, ut64 addr, bool verbose)
static int	mywrite (const ut8 *buf, int len)
static bool	exists_var (RzPrint *print, ut64 func_addr, char *str)
static bool	rz_core_analysis_read_at (struct rz_analysis_t *analysis, ut64 addr, ut8 *buf, int len)
static void	rz_core_break (RzCore *core)
static void *	rz_core_sleep_begin (RzCore *core)
static void	rz_core_sleep_end (RzCore *core, void *user)
static void	__foreach (RzCore *core, const char **cmds, int type)
static void	__init_autocomplete_default (RzCore *core)
static void	__init_autocomplete (RzCore *core)
static const char *	colorfor_cb (void *user, ut64 addr, bool verbose)
static char *	hasrefs_cb (void *user, ut64 addr, int mode)
static const char *	get_section_name (void *user, ut64 addr)
static char *	get_comments_cb (void *user, ut64 addr)
static RzFlagItem *	core_flg_class_set (RzFlag *f, const char *name, ut64 addr, ut32 size)
static RzFlagItem *	core_flg_class_get (RzFlag *f, const char *name)
static RzFlagItem *	core_flg_fcn_set (RzFlag *f, const char *name, ut64 addr, ut32 size)
RZ_API void	rz_core_autocomplete_reload (RzCore *core)
RZ_API RzFlagItem *	rz_core_flag_get_by_spaces (RzFlag *f, ut64 off)
static bool	bp_is_mapped (ut64 addr, int perm, void *user)
static void	bp_maps_sync (void *user)
static int	bp_bits_at (ut64 addr, void *user)
static void	ev_iowrite_cb (RzEvent *ev, int type, void *user, void *data)
RZ_IPI void	rz_core_file_io_desc_closed (RzCore *core, RzIODesc *desc)
RZ_IPI void	rz_core_file_io_map_deleted (RzCore *core, RzIOMap *map)
RZ_IPI void	rz_core_file_bin_file_deleted (RzCore *core, RzBinFile *bf)
RZ_IPI void	rz_core_vfile_bin_file_deleted (RzCore *core, RzBinFile *bf)
static void	ev_iodescclose_cb (RzEvent *ev, int type, void *user, void *data)
static void	ev_iomapdel_cb (RzEvent *ev, int type, void *user, void *data)
static void	ev_binfiledel_cb (RzEvent *ev, int type, void *user, void *data)
RZ_IPI void	rz_core_task_ctx_switch (RzCoreTask *next, void *user)
RZ_IPI void	rz_core_task_break_cb (RzCoreTask *task, void *user)
RZ_IPI void	rz_core_file_free (RzCoreFile *cf)
RZ_API bool	rz_core_init (RzCore *core)
RZ_API void	__cons_cb_fkey (RzCore *core, int fkey)
RZ_API void	rz_core_bind_cons (RzCore *core)
RZ_API void	rz_core_fini (RzCore *c)
RZ_API void	rz_core_free (RzCore *c)
RZ_API void	rz_core_prompt_loop (RzCore *r)
static bool	prompt_add_file (RzCore *core, RzStrBuf *sb, bool add_sep)
static bool	prompt_add_section (RzCore *core, RzStrBuf *sb, bool add_sep)
static bool	prompt_add_offset (RzCore *core, RzStrBuf *sb, bool add_sep)
static void	set_prompt (RzCore *r)
RZ_API int	rz_core_prompt (RzCore *r, int sync)
RZ_API int	rz_core_prompt_exec (RzCore *r)
RZ_API bool	rz_core_block_size (RzCore *core, ut32 bsize)
RZ_API char *	rz_core_op_str (RzCore *core, ut64 addr)
RZ_API RzAnalysisOp *	rz_core_op_analysis (RzCore *core, ut64 addr, RzAnalysisOpMask mask)
static void	rap_break (void *u)
RZ_API bool	rz_core_serve (RzCore *core, RzIODesc *file)
RZ_API int	rz_core_search_cb (RzCore *core, ut64 from, ut64 to, RzCoreSearchCallback cb)
RZ_API RZ_OWN char *	rz_core_editor (const RzCore *core, RZ_NULLABLE const char *file, RZ_NULLABLE const char *str)
RZ_API RzCons *	rz_core_get_cons (RzCore *core)
RZ_API RzConfig *	rz_core_get_config (RzCore *core)
RZ_API RzBin *	rz_core_get_bin (RzCore *core)
RZ_API RzBuffer *	rz_core_syscallf (RzCore *core, const char *name, const char *fmt,...)
RZ_API RzBuffer *	rz_core_syscall (RzCore *core, const char *name, const char *args)
RZ_API RzCoreAutocomplete *	rz_core_autocomplete_add (RzCoreAutocomplete *parent, const char *cmd, int type, bool lock)
RZ_API void	rz_core_autocomplete_free (RzCoreAutocomplete *obj)
RZ_API RzCoreAutocomplete *	rz_core_autocomplete_find (RzCoreAutocomplete *parent, const char *cmd, bool exact)
RZ_API bool	rz_core_autocomplete_remove (RzCoreAutocomplete *parent, const char *cmd)
RZ_API RzTable *	rz_core_table (RzCore *core)
RZ_API RzCmdStatus	rz_core_core_plugin_print (RzCorePlugin *cp, RzCmdStateOutput *state, const char *license)
RZ_API RzCmdStatus	rz_core_core_plugins_print (RzCore *core, RzCmdStateOutput *state)

Variables
static ut64	letter_divs [RZ_CORE_ASMQJMPS_LEN_LETTERS - 1]
static const char *	rizin_argv []
RZ_IPI RzIOPlugin	rz_core_io_plugin_vfile
	IO Plugin that opens RzBinVirtualFiles supplied by the plugin of an RzBinFile. More...

Macro Definition Documentation

ADDARG

#define ADDARG

(

x

)

Value:

    if (!strncmp(buf->data + chr, x, strlen(buf->data + chr))) { \
        rz_line_completion_push(completion, x); \
    }

Definition at line 1176 of file core.c.

DB

#define DB   core->sdb

Definition at line 14 of file core.c.

MINLEN

#define MINLEN   1

Definition at line 1774 of file core.c.

rizin_argc

#define rizin_argc   (sizeof(rizin_argv) / sizeof(const char *) - 1)

Definition at line 875 of file core.c.

Function Documentation

__cons_cb_fkey()

RZ_API void __cons_cb_fkey	(	RzCore *	core,
		int	fkey
	)

Definition at line 2601 of file core.c.

                                                   {
    char buf[32];
    snprintf(buf, sizeof(buf), "key.f%d", fkey);
    const char *v = rz_config_get(core->config, buf);
    if (v && *v) {
        rz_cons_printf("%s\n", v);
        rz_core_cmd0(core, v);
        rz_cons_flush();
    }
}

References rz_core_t::config, rz_config_get(), rz_cons_flush(), rz_cons_printf(), rz_core_cmd0(), snprintf, and v.

Referenced by rz_core_bind_cons().

__disasm()

static int __disasm ( void *  _core, ut64  addr  )

static

Disassemble one instruction at specified address.

Definition at line 1732 of file core.c.

                                            {
    RzCore *core = _core;
    ut64 prevaddr = core->offset;
 
    rz_core_seek(core, addr, true);
    int len = rz_core_print_disasm_instructions(core, 0, 1);
    rz_core_seek(core, prevaddr, true);
 
    return len;
}

References _core, addr, len, rz_core_t::offset, rz_core_print_disasm_instructions(), rz_core_seek(), and ut64().

Referenced by rz_core_init().

__flagsGet()

static const RzList* __flagsGet ( RzCore *  core, ut64  offset  )

static

Definition at line 365 of file core.c.

                                                           {
    return rz_flag_get_list(core->flags, offset);
}

References rz_core_t::flags, and rz_flag_get_list().

Referenced by rz_core_bind().

__foreach()

static void __foreach ( RzCore *  core, const char **  cmds, int  type  )

static

Definition at line 2170 of file core.c.

                                                                 {
    int i;
    for (i = 0; cmds[i]; i++) {
        rz_core_autocomplete_add(core->autocomplete, cmds[i], type, true);
    }
}

References rz_core_t::autocomplete, i, rz_core_autocomplete_add(), and type.

Referenced by __init_autocomplete_default().

__init_autocomplete()

static void __init_autocomplete ( RzCore *  core )

static

Definition at line 2230 of file core.c.

                                              {
    core->autocomplete = RZ_NEW0(RzCoreAutocomplete);
    if (core->autocomplete_type == AUTOCOMPLETE_DEFAULT) {
        __init_autocomplete_default(core);
    }
}

References __init_autocomplete_default(), rz_core_t::autocomplete, AUTOCOMPLETE_DEFAULT, rz_core_t::autocomplete_type, and RZ_NEW0.

Referenced by rz_core_autocomplete_reload(), and rz_core_init().

__init_autocomplete_default()

static void __init_autocomplete_default ( RzCore *  core )

static

Definition at line 2177 of file core.c.

                                                      {
    const char *fcns[] = {
        "afcf", "afn", NULL
    };
    const char *seeks[] = {
        "s", NULL
    };
    const char *flags[] = {
        "*", "s", "s+", "b", "f", "fg", "?", "?v", "ad", "bf", "c1", "db", "dbw",
        "f-", "fr", "tf", "/a", "/v", "/r", "/re", "aav", "aep", "aef",
        "afc", "axg", "axt", "axf", "dcu", "ag", "agfl", "aecu", "aesu", "aeim", NULL
    };
    const char *evals[] = {
        "e", "ee", "et", "e?", "e!", "ev", "evj", NULL
    };
    const char *breaks[] = {
        "db-", "dbc", "dbC", "dbd", "dbe", "dbs", "dbi", "dbte", "dbtd", "dbts", NULL
    };
    const char *files[] = {
        ".", "..", ".*", "/F", "/m", "!", "!!", "#!c", "#!v", "#!cpipe", "#!vala",
        "#!rust", "#!zig", "#!pipe", "#!python", "aeli", "arp", "arpg", "dmd", "drp", "drpg", "o",
        "idp", "idpi", "L", "obf", "o+", "oc",
        "rizin", "rz-agent", "rz-asm", "rz-ax", "rz-bin", "rz-diff", "rz-find", "rz-gg", "rz-hash", "rz-pm", "rz-run", "rz-sign",
        "cd", "ls", "on", "op", "wf", "rm", "wF", "wp", "Sd", "Sl", "to", "pm",
        "/m", "zos", "zfd", "zfs", "zfz", "cat", "wta", "wtf", "wxf", "dml", "vi",
        "less", "head", "Ps", "Pl", NULL
    };
    __foreach(core, flags, RZ_CORE_AUTOCMPLT_FLAG);
    __foreach(core, seeks, RZ_CORE_AUTOCMPLT_SEEK);
    __foreach(core, fcns, RZ_CORE_AUTOCMPLT_FCN);
    __foreach(core, evals, RZ_CORE_AUTOCMPLT_EVAL);
    __foreach(core, breaks, RZ_CORE_AUTOCMPLT_BRKP);
    __foreach(core, files, RZ_CORE_AUTOCMPLT_FILE);
 
    rz_core_autocomplete_add(core->autocomplete, "-", RZ_CORE_AUTOCMPLT_MINS, true);
    rz_core_autocomplete_add(core->autocomplete, "fs", RZ_CORE_AUTOCMPLT_FLSP, true);
    rz_core_autocomplete_add(
        rz_core_autocomplete_add(core->autocomplete, "ls", RZ_CORE_AUTOCMPLT_DFLT, true),
        "-l", RZ_CORE_AUTOCMPLT_FILE, true);
    rz_core_autocomplete_add(core->autocomplete, "eco", RZ_CORE_AUTOCMPLT_THME, true);
    rz_core_autocomplete_add(core->autocomplete, "k", RZ_CORE_AUTOCMPLT_SDB, true);
    /* macros */
    rz_core_autocomplete_add(core->autocomplete, ".(", RZ_CORE_AUTOCMPLT_MACR, true);
    rz_core_autocomplete_add(core->autocomplete, "(-", RZ_CORE_AUTOCMPLT_MACR, true);
    /* just for hints */
    int i;
    for (i = 0; i < rizin_argc && rizin_argv[i]; i++) {
        if (!rz_core_autocomplete_find(core->autocomplete, rizin_argv[i], true)) {
            rz_core_autocomplete_add(core->autocomplete, rizin_argv[i], RZ_CORE_AUTOCMPLT_DFLT, true);
        }
    }
}

References __foreach(), rz_core_t::autocomplete, files, flags, i, NULL, rizin_argc, rizin_argv, RZ_CORE_AUTOCMPLT_BRKP, RZ_CORE_AUTOCMPLT_DFLT, RZ_CORE_AUTOCMPLT_EVAL, RZ_CORE_AUTOCMPLT_FCN, RZ_CORE_AUTOCMPLT_FILE, RZ_CORE_AUTOCMPLT_FLAG, RZ_CORE_AUTOCMPLT_FLSP, RZ_CORE_AUTOCMPLT_MACR, RZ_CORE_AUTOCMPLT_MINS, RZ_CORE_AUTOCMPLT_SDB, RZ_CORE_AUTOCMPLT_SEEK, RZ_CORE_AUTOCMPLT_THME, rz_core_autocomplete_add(), and rz_core_autocomplete_find().

Referenced by __init_autocomplete().

add_argv()

static bool add_argv ( RzFlagItem *  fi, void *  user  )

static

Definition at line 1247 of file core.c.

                                                 {
    RzLineCompletion *completion = user;
    rz_line_completion_push(completion, fi->name);
    return true;
}

References rz_flag_item_t::name, and rz_line_completion_push().

Referenced by autocomplete_flags(), and rz_core_autocomplete().

archbits()

static void archbits ( RzCore *  core, ut64  addr  )

static

Definition at line 341 of file core.c.

                                              {
    rz_core_seek_arch_bits(core, addr);
}

References addr, and rz_core_seek_arch_bits().

Referenced by rz_core_bind().

autocomplete_breakpoints()

static void autocomplete_breakpoints ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1232 of file core.c.

                                                                                                  {
    rz_return_if_fail(str);
    RzListIter *iter;
    RzBreakpoint *bp = core->dbg->bp;
    RzBreakpointItem *b;
    int n = strlen(str);
    rz_list_foreach (bp->bps, iter, b) {
        char *addr = rz_str_newf("0x%" PFMT64x "", b->addr);
        if (!strncmp(addr, str, n)) {
            rz_line_completion_push(completion, addr);
        }
        free(addr);
    }
}

References addr, b, rz_debug_t::bp, rz_bp_t::bps, rz_core_t::dbg, free(), n, PFMT64x, rz_line_completion_push(), rz_return_if_fail, rz_str_newf(), and cmd_descs_generate::str.

Referenced by find_autocomplete().

autocomplete_default()

static void autocomplete_default ( RZ_NULLABLE RzCore *  core, RzLineCompletion *  completion, RzLineBuffer *  buf  )

static

Definition at line 1181 of file core.c.

                                                                                                            {
    RzCoreAutocomplete *a = core ? core->autocomplete : NULL;
    int i;
    if (a) {
        for (i = 0; i < a->n_subcmds; i++) {
            if (buf->data[0] == 0 || !strncmp(a->subcmds[i]->cmd, buf->data, a->subcmds[i]->length)) {
                rz_line_completion_push(completion, a->subcmds[i]->cmd);
            }
        }
    } else {
        for (i = 0; i < rizin_argc && rizin_argv[i]; i++) {
            int length = strlen(rizin_argv[i]);
            if (!strncmp(rizin_argv[i], buf->data, length)) {
                rz_line_completion_push(completion, rizin_argv[i]);
            }
        }
    }
}

References a, i, length, NULL, rizin_argc, rizin_argv, and rz_line_completion_push().

Referenced by rz_core_autocomplete().

autocomplete_evals()

static void autocomplete_evals ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1200 of file core.c.

                                                                                            {
    rz_return_if_fail(str);
    RzConfigNode *bt;
    RzListIter *iter;
    const char *tmp = strrchr(str, ' ');
    if (tmp) {
        str = tmp + 1;
    }
    size_t n = strlen(str);
    rz_list_foreach (core->config->nodes, iter, bt) {
        if (!strncmp(bt->name, str, n)) {
            rz_line_completion_push(completion, bt->name);
        }
    }
}

References rz_core_t::config, n, rz_config_node_t::name, rz_config_t::nodes, rz_line_completion_push(), rz_return_if_fail, cmd_descs_generate::str, and autogen_x86imm::tmp.

Referenced by find_autocomplete().

autocomplete_file()

static void autocomplete_file ( RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1380 of file core.c.

                                                                             {
    rz_return_if_fail(str);
    char *pipe = strchr(str, '>');
 
    if (pipe) {
        str = rz_str_trim_head_ro(pipe + 1);
    }
    if (str && !*str) {
        autocomplete_process_path(completion, str, "./");
    } else {
        autocomplete_process_path(completion, str, str);
    }
}

References autocomplete_process_path(), pipe, rz_return_if_fail, rz_str_trim_head_ro(), and cmd_descs_generate::str.

Referenced by find_autocomplete(), and rz_core_autocomplete().

autocomplete_flags()

static void autocomplete_flags ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1253 of file core.c.

                                                                                            {
    rz_return_if_fail(str);
    int n = strlen(str);
    rz_flag_foreach_prefix(core->flags, str, n, add_argv, completion);
}

References add_argv(), rz_core_t::flags, n, rz_flag_foreach_prefix(), rz_return_if_fail, and cmd_descs_generate::str.

Referenced by find_autocomplete(), and rz_core_autocomplete().

autocomplete_flagspaces()

static void autocomplete_flagspaces ( RzCore *  core, RzLineCompletion *  completion, const char *  msg  )

static

Definition at line 1332 of file core.c.

                                                                                                 {
    rz_return_if_fail(msg);
    int length = strlen(msg);
    RzFlag *flag = core->flags;
    RzSpaceIter it;
    RzSpace *s;
    rz_flag_space_foreach(flag, it, s) {
        if (!strncmp(msg, s->name, length)) {
            rz_line_completion_push(completion, s->name);
        }
    }
 
    if (strlen(msg) == 0) {
        rz_line_completion_push(completion, "*");
    }
}

References rz_core_t::flags, length, msg, rz_line_completion_push(), rz_return_if_fail, and s.

Referenced by find_autocomplete().

autocomplete_functions()

static void autocomplete_functions ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1349 of file core.c.

                                                                                                {
    rz_return_if_fail(str);
    RzListIter *iter;
    RzAnalysisFunction *fcn;
    int n = strlen(str);
    rz_list_foreach (core->analysis->fcns, iter, fcn) {
        char *name = rz_core_analysis_fcn_name(core, fcn);
        if (!strncmp(name, str, n)) {
            rz_line_completion_push(completion, name);
        }
        free(name);
    }
}

References rz_core_t::analysis, rz_analysis_t::fcns, free(), n, rz_core_analysis_fcn_name(), rz_line_completion_push(), rz_return_if_fail, and cmd_descs_generate::str.

Referenced by find_autocomplete().

autocomplete_macro()

static void autocomplete_macro ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1363 of file core.c.

                                                                                            {
    rz_return_if_fail(core && core->rcmd && completion && str);
    RzCmdMacroItem *item;
    RzListIter *iter;
    size_t n = strlen(str);
    rz_list_foreach (core->rcmd->macro.macros, iter, item) {
        char *p = item->name;
        if (!*str || !strncmp(str, p, n)) {
            char *buf = rz_str_newf("%s%s)", str, p);
            if (buf) {
                rz_line_completion_push(completion, buf);
                free(buf);
            }
        }
    }
}

References free(), rz_cmd_t::macro, rz_cmd_macro_t::macros, n, rz_cmd_macro_item_t::name, p, rz_core_t::rcmd, rz_line_completion_push(), rz_return_if_fail, rz_str_newf(), and cmd_descs_generate::str.

Referenced by find_autocomplete().

autocomplete_minus()

static void autocomplete_minus ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1216 of file core.c.

                                                                                            {
    rz_return_if_fail(str);
    int count;
    int length = strlen(str);
    char **keys = rz_cmd_alias_keys(core->rcmd, &count);
    if (!keys) {
        return;
    }
    int i;
    for (i = 0; i < count; i++) {
        if (!strncmp(keys[i], str, length)) {
            rz_line_completion_push(completion, keys[i]);
        }
    }
}

References count, i, keys, length, rz_core_t::rcmd, rz_cmd_alias_keys(), rz_line_completion_push(), rz_return_if_fail, and cmd_descs_generate::str.

Referenced by find_autocomplete().

autocomplete_process_path()

static void autocomplete_process_path ( RzLineCompletion *  completion, const char *  str, const char *  path  )

static

Definition at line 1052 of file core.c.

                                                                                                       {
    char *lpath = NULL, *dirname = NULL, *basename = NULL;
    char *home = NULL, *filename = NULL, *p = NULL;
    int n = 0;
    RzList *list;
    RzListIter *iter;
 
    if (!path) {
        goto out;
    }
 
    lpath = rz_str_new(path);
#if __WINDOWS__
    rz_str_replace_ch(lpath, '/', '\\', true);
#endif
    p = (char *)rz_str_last(lpath, RZ_SYS_DIR);
    if (p) {
        *p = 0;
        if (p == lpath) { // /xxx
#if __WINDOWS__
            dirname = strdup("\\.\\");
#else
            dirname = rz_str_new(RZ_SYS_DIR);
#endif
        } else if (lpath[0] == '~' && lpath[1]) { // ~/xxx/yyy
            dirname = rz_str_home(lpath + 2);
        } else if (lpath[0] == '~') { // ~/xxx
            if (!(home = rz_str_home(NULL))) {
                goto out;
            }
            dirname = rz_str_newf("%s%s", home, RZ_SYS_DIR);
            free(home);
        } else if (lpath[0] == '.' || lpath[0] == RZ_SYS_DIR[0]) { // ./xxx/yyy || /xxx/yyy
            dirname = rz_str_newf("%s%s", lpath, RZ_SYS_DIR);
        } else { // xxx/yyy
            char *fmt = ".%s%s%s";
#if __WINDOWS__
            if (strchr(path, ':')) {
                fmt = "%.0s%s%s";
            }
#endif
            dirname = rz_str_newf(fmt, RZ_SYS_DIR, lpath, RZ_SYS_DIR);
        }
        basename = rz_str_new(p + 1);
    } else { // xxx
        dirname = rz_str_newf(".%s", RZ_SYS_DIR);
        basename = rz_str_new(lpath);
    }
 
    if (!dirname || !basename) {
        goto out;
    }
 
    list = rz_sys_dir(dirname);
    n = strlen(basename);
    bool chgdir = !strncmp(str, "cd ", 3);
    if (list) {
        rz_list_foreach (list, iter, filename) {
            if (*filename == '.') {
                continue;
            }
            if (!basename[0] || !strncmp(filename, basename, n)) {
                char *tmpstring = rz_str_newf("%s%s", dirname, filename);
                if (rz_file_is_directory(tmpstring)) {
                    char *s = rz_str_newf("%s%s", tmpstring, RZ_SYS_DIR);
                    rz_line_completion_push(completion, s);
                    free(s);
                } else if (!chgdir) {
                    rz_line_completion_push(completion, tmpstring);
                }
                free(tmpstring);
            }
        }
        rz_list_free(list);
    }
out:
    free(lpath);
    free(dirname);
    free(basename);
}

References basename, free(), list(), n, NULL, out, p, path, rz_file_is_directory(), rz_line_completion_push(), rz_list_free(), rz_str_home(), rz_str_last(), rz_str_new(), rz_str_newf(), rz_str_replace_ch(), RZ_SYS_DIR, rz_sys_dir(), s, cmd_descs_generate::str, and strdup().

Referenced by autocomplete_file(), and autocompleteFilename().

autocomplete_sdb()

static void autocomplete_sdb ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1260 of file core.c.

                                                                                          {
    rz_return_if_fail(core && completion && str);
    char *pipe = strchr(str, '>');
    Sdb *sdb = core->sdb;
    char *lpath = NULL, *p1 = NULL, *out = NULL, *p2 = NULL;
    char *cur_pos = NULL, *cur_cmd = NULL, *next_cmd = NULL;
    char *temp_cmd = NULL, *temp_pos = NULL, *key = NULL;
    if (pipe) {
        str = rz_str_trim_head_ro(pipe + 1);
    }
    lpath = rz_str_new(str);
    p1 = strchr(lpath, '/');
    if (p1) {
        *p1 = 0;
        char *ns = p1 + 1;
        p2 = strchr(ns, '/');
        if (!p2) { // analysis/m
            char *tmp = p1 + 1;
            int n = strlen(tmp);
            out = sdb_querys(sdb, NULL, 0, "analysis/**");
            if (!out) {
                return;
            }
            while (*out) {
                cur_pos = strchr(out, '\n');
                if (!cur_pos) {
                    break;
                }
                cur_cmd = rz_str_ndup(out, cur_pos - out);
                if (!strncmp(tmp, cur_cmd, n)) {
                    char *cmplt = rz_str_newf("analysis/%s/", cur_cmd);
                    rz_line_completion_push(completion, cmplt);
                    free(cmplt);
                }
                out += cur_pos - out + 1;
            }
 
        } else { // analysis/meta/*
            char *tmp = p2 + 1;
            int n = strlen(tmp);
            char *spltr = strchr(ns, '/');
            *spltr = 0;
            next_cmd = rz_str_newf("analysis/%s/*", ns);
            out = sdb_querys(sdb, NULL, 0, next_cmd);
            if (!out) {
                free(lpath);
                return;
            }
            while (*out) {
                temp_pos = strchr(out, '\n');
                if (!temp_pos) {
                    break;
                }
                temp_cmd = rz_str_ndup(out, temp_pos - out); // contains the key=value pair
                key = strchr(temp_cmd, '=');
                *key = 0;
                if (!strncmp(tmp, temp_cmd, n)) {
                    char *cmplt = rz_str_newf("analysis/%s/%s", ns, temp_cmd);
                    rz_line_completion_push(completion, cmplt);
                    free(cmplt);
                }
                out += temp_pos - out + 1;
            }
        }
    } else {
        int n = strlen(lpath);
        if (!strncmp(lpath, "analysis", n)) {
            rz_line_completion_push(completion, "analysis/");
        }
    }
}

References free(), key, n, NULL, out, pipe, rz_line_completion_push(), rz_return_if_fail, rz_str_ndup(), rz_str_new(), rz_str_newf(), rz_str_trim_head_ro(), rz_core_t::sdb, sdb_querys(), cmd_descs_generate::str, and autogen_x86imm::tmp.

Referenced by find_autocomplete().

autocomplete_theme()

static void autocomplete_theme ( RzCore *  core, RzLineCompletion *  completion, const char *  str  )

static

Definition at line 1394 of file core.c.

                                                                                            {
    rz_return_if_fail(str);
    int len = strlen(str);
    char *theme;
    RzListIter *iter;
    RzList *themes = rz_core_theme_list(core);
    rz_list_foreach (themes, iter, theme) {
        if (!len || !strncmp(str, theme, len)) {
            rz_line_completion_push(completion, theme);
        }
    }
    rz_list_free(themes);
}

References len, rz_core_theme_list(), rz_line_completion_push(), rz_list_free(), rz_return_if_fail, and cmd_descs_generate::str.

Referenced by find_autocomplete().

autocompleteFilename()

static void autocompleteFilename ( RzLineCompletion *  completion, RzLineBuffer *  buf, char **  extra_paths, int  narg  )

static

Definition at line 1133 of file core.c.

                                                                                                                {
    char *args = NULL, *input = NULL;
    int n = 0, i = 0;
    char *pipe = strchr(buf->data, '>');
    if (pipe) {
        args = rz_str_new(pipe + 1);
    } else {
        args = rz_str_new(buf->data);
    }
    if (!args) {
        goto out;
    }
 
    n = rz_str_word_set0(args);
    if (n < narg) {
        goto out;
    }
 
    input = rz_str_new(rz_str_word_get0(args, narg));
    if (!input) {
        goto out;
    }
    const char *tinput = rz_str_trim_head_ro(input);
 
    autocomplete_process_path(completion, buf->data, tinput);
 
    if (input[0] == '/' || input[0] == '.' || !extra_paths) {
        goto out;
    }
 
    for (i = 0; extra_paths[i]; i++) {
        char *s = rz_str_newf("%s%s%s", extra_paths[i], RZ_SYS_DIR, tinput);
        if (!s) {
            break;
        }
        autocomplete_process_path(completion, buf->data, s);
        free(s);
    }
out:
    free(args);
    free(input);
}

References args, autocomplete_process_path(), free(), i, input(), n, NULL, out, pipe, rz_str_new(), rz_str_newf(), rz_str_trim_head_ro(), rz_str_word_get0(), rz_str_word_set0(), RZ_SYS_DIR, and s.

Referenced by rz_core_autocomplete().

bbBegin()

static ut64 bbBegin ( RzAnalysisFunction *  fcn, ut64  addr  )

static

Definition at line 440 of file core.c.

                                                        {
    RzListIter *iter;
    RzAnalysisBlock *bb;
    rz_list_foreach (fcn->bbs, iter, bb) {
        if (RZ_BETWEEN(bb->addr, addr, bb->addr + bb->size - 1)) {
            return bb->addr;
        }
    }
    return UT64_MAX;
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, RZ_BETWEEN, rz_analysis_bb_t::size, and UT64_MAX.

Referenced by num_callback().

bbFail()

static ut64 bbFail ( RzAnalysisFunction *  fcn, ut64  addr  )

static

Definition at line 462 of file core.c.

                                                       {
    RzListIter *iter;
    RzAnalysisBlock *bb;
    rz_list_foreach (fcn->bbs, iter, bb) {
        if (RZ_BETWEEN(bb->addr, addr, bb->addr + bb->size - 1)) {
            return bb->fail;
        }
    }
    return UT64_MAX;
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, rz_analysis_bb_t::fail, RZ_BETWEEN, rz_analysis_bb_t::size, and UT64_MAX.

Referenced by num_callback().

bbInstructions()

static ut64 bbInstructions ( RzAnalysisFunction *  fcn, ut64  addr  )

static

Definition at line 429 of file core.c.

                                                               {
    RzListIter *iter;
    RzAnalysisBlock *bb;
    rz_list_foreach (fcn->bbs, iter, bb) {
        if (RZ_BETWEEN(bb->addr, addr, bb->addr + bb->size - 1)) {
            return bb->ninstr;
        }
    }
    return UT64_MAX;
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, rz_analysis_bb_t::ninstr, RZ_BETWEEN, rz_analysis_bb_t::size, and UT64_MAX.

Referenced by num_callback().

bbJump()

static ut64 bbJump ( RzAnalysisFunction *  fcn, ut64  addr  )

static

Definition at line 451 of file core.c.

                                                       {
    RzListIter *iter;
    RzAnalysisBlock *bb;
    rz_list_foreach (fcn->bbs, iter, bb) {
        if (RZ_BETWEEN(bb->addr, addr, bb->addr + bb->size - 1)) {
            return bb->jump;
        }
    }
    return UT64_MAX;
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, rz_analysis_bb_t::jump, RZ_BETWEEN, rz_analysis_bb_t::size, and UT64_MAX.

Referenced by num_callback().

bbSize()

static ut64 bbSize ( RzAnalysisFunction *  fcn, ut64  addr  )

static

Definition at line 473 of file core.c.

                                                       {
    RzListIter *iter;
    RzAnalysisBlock *bb;
    rz_list_foreach (fcn->bbs, iter, bb) {
        if (RZ_BETWEEN(bb->addr, addr, bb->addr + bb->size - 1)) {
            return bb->size;
        }
    }
    return 0;
}

References addr, rz_analysis_bb_t::addr, rz_analysis_function_t::bbs, RZ_BETWEEN, and rz_analysis_bb_t::size.

Referenced by num_callback().

bp_bits_at()

static int bp_bits_at ( ut64  addr, void *  user  )

static

Definition at line 2335 of file core.c.

                                             {
    RzCore *core = user;
    int r = 0;
    rz_core_arch_bits_at(core, addr, &r, NULL);
    return r ? r : core->analysis->bits;
}

References addr, rz_core_t::analysis, rz_analysis_t::bits, NULL, r, and rz_core_arch_bits_at().

Referenced by rz_core_init().

bp_is_mapped()

static bool bp_is_mapped ( ut64  addr, int  perm, void *  user  )

static

Definition at line 2307 of file core.c.

                                                          {
    RzCore *core = user;
    if (rz_core_is_debug(core)) {
        // RzList *maps = core->dbg->maps;
        RzDebugMap *map = NULL;
        RzListIter *iter = NULL;
 
        rz_list_foreach (core->dbg->maps, iter, map) {
            if (addr < map->addr || addr >= map->addr_end) {
                continue;
            }
            if (perm <= 0 || (map->perm & perm)) {
                return true;
            }
        }
        return false;
    }
 
    return rz_io_map_is_mapped(core->io, addr);
}

References addr, rz_core_t::dbg, rz_core_t::io, map(), rz_debug_t::maps, NULL, rz_core_is_debug(), and rz_io_map_is_mapped().

Referenced by rz_core_init().

bp_maps_sync()

static void bp_maps_sync ( void *  user )

static

Definition at line 2328 of file core.c.

                                     {
    RzCore *core = user;
    if (rz_core_is_debug(core)) {
        rz_debug_map_sync(core->dbg);
    }
}

References rz_core_t::dbg, rz_core_is_debug(), and rz_debug_map_sync().

Referenced by rz_core_init().

cfgget()

static const char* cfgget ( RzCore *  core, const char *  k  )

static

Definition at line 349 of file core.c.

                                                       {
    return rz_config_get(core->config, k);
}

References rz_core_t::config, k, and rz_config_get().

Referenced by rz_core_bind().

cfggeti()

static ut64 cfggeti ( RzCore *  core, const char *  k  )

static

Definition at line 345 of file core.c.

                                                 {
    return rz_config_get_i(core->config, k);
}

References rz_core_t::config, k, and rz_config_get_i().

Referenced by rz_core_bind().

cfgset()

static bool cfgset ( RzCore *  core, const char *  k, const char *  v  )

static

Definition at line 357 of file core.c.

                                                               {
    return rz_config_set(core->config, k, v);
}

References rz_core_t::config, k, rz_config_set(), and v.

Referenced by rz_core_bind().

cfgseti()

static bool cfgseti ( RzCore *  core, const char *  k, ut64  v  )

static

Definition at line 353 of file core.c.

                                                         {
    return rz_config_set_i(core->config, k, v);
}

References rz_core_t::config, k, rz_config_set_i(), and v.

Referenced by rz_core_bind().

colorfor_cb()

static const char* colorfor_cb ( void *  user, ut64  addr, bool  verbose  )

static

Definition at line 2237 of file core.c.

                                                                    {
    return rz_core_analysis_optype_colorfor((RzCore *)user, addr, verbose);
}

References addr, rz_core_analysis_optype_colorfor(), and verbose.

Referenced by rz_core_init().

core_flg_class_get()

static RzFlagItem* core_flg_class_get ( RzFlag *  f, const char *  name  )

static

Definition at line 2260 of file core.c.

                                                                   {
    rz_flag_space_push(f, RZ_FLAGS_FS_CLASSES);
    RzFlagItem *res = rz_flag_get(f, name);
    rz_flag_space_pop(f);
    return res;
}

References f, rz_flag_get(), and RZ_FLAGS_FS_CLASSES.

Referenced by rz_core_init().

core_flg_class_set()

static RzFlagItem* core_flg_class_set ( RzFlag *  f, const char *  name, ut64  addr, ut32  size  )

static

Definition at line 2253 of file core.c.

                                                                                         {
    rz_flag_space_push(f, RZ_FLAGS_FS_CLASSES);
    RzFlagItem *res = rz_flag_set(f, name, addr, size);
    rz_flag_space_pop(f);
    return res;
}

References addr, f, rz_flag_set(), and RZ_FLAGS_FS_CLASSES.

Referenced by rz_core_init().

core_flg_fcn_set()

static RzFlagItem* core_flg_fcn_set ( RzFlag *  f, const char *  name, ut64  addr, ut32  size  )

static

Definition at line 2267 of file core.c.

                                                                                       {
    rz_flag_space_push(f, RZ_FLAGS_FS_FUNCTIONS);
    RzFlagItem *res = rz_flag_set(f, name, addr, size);
    rz_flag_space_pop(f);
    return res;
}

References addr, f, rz_flag_set(), and RZ_FLAGS_FS_FUNCTIONS.

Referenced by rz_core_init().

ev_binfiledel_cb()

static void ev_binfiledel_cb ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 2369 of file core.c.

                                                                            {
    RzEventBinFileDel *bev = data;
    rz_core_file_bin_file_deleted(user, bev->bf);
    rz_core_vfile_bin_file_deleted(user, bev->bf);
}

References rz_core_file_bin_file_deleted(), and rz_core_vfile_bin_file_deleted().

Referenced by rz_core_init().

ev_iodescclose_cb()

static void ev_iodescclose_cb ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 2359 of file core.c.

                                                                             {
    RzEventIODescClose *ioc = data;
    rz_core_file_io_desc_closed(user, ioc->desc);
}

References rz_event_io_desc_close_t::desc, and rz_core_file_io_desc_closed().

Referenced by rz_core_init().

ev_iomapdel_cb()

static void ev_iomapdel_cb ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 2364 of file core.c.

                                                                          {
    RzEventIOMapDel *iod = data;
    rz_core_file_io_map_deleted(user, iod->map);
}

References rz_event_io_map_del_t::map, and rz_core_file_io_map_deleted().

Referenced by rz_core_init().

ev_iowrite_cb()

static void ev_iowrite_cb ( RzEvent *  ev, int  type, void *  user, void *  data  )

static

Definition at line 2342 of file core.c.

                                                                         {
    RzCore *core = user;
    RzEventIOWrite *iow = data;
    if (rz_config_get_i(core->config, "analysis.detectwrites")) {
        rz_analysis_update_analysis_range(core->analysis, iow->addr, iow->len);
        if (core->cons->event_resize && core->cons->event_data) {
            // Force a reload of the graph
            core->cons->event_resize(core->cons->event_data);
        }
    }
}

References rz_event_io_write_t::addr, rz_core_t::analysis, rz_core_t::config, rz_core_t::cons, rz_cons_t::event_data, rz_cons_t::event_resize, rz_event_io_write_t::len, rz_analysis_update_analysis_range(), and rz_config_get_i().

Referenced by rz_core_init().

exists_var()

static bool exists_var ( RzPrint *  print, ut64  func_addr, char *  str  )

static

Definition at line 2139 of file core.c.

                                                                  {
    RzAnalysis *analysis = ((RzCore *)(print->user))->analysis;
    RzAnalysisFunction *fcn = rz_analysis_get_function_at(analysis, func_addr);
    if (!fcn) {
        return false;
    }
    return !!rz_analysis_function_get_var_byname(fcn, str);
}

References rz_analysis_function_get_var_byname(), rz_analysis_get_function_at(), cmd_descs_generate::str, and rz_print_t::user.

Referenced by rz_core_init().

find_autocomplete()

static bool find_autocomplete ( RzCore *  core, RzLineCompletion *  completion, RzLineBuffer *  buf  )

static

Definition at line 1456 of file core.c.

                                                                                             {
    RzCoreAutocomplete *child = NULL;
    RzCoreAutocomplete *parent = core->autocomplete;
    const char *p = buf->data;
    if (!*p) {
        return false;
    }
    char arg[256];
    arg[0] = 0;
    while (*p) {
        const char *e = rz_str_trim_head_wp(p);
        if (!e || (e - p) >= 256 || e == p) {
            return false;
        }
        memcpy(arg, p, e - p);
        arg[e - p] = 0;
        child = rz_core_autocomplete_find(parent, arg, false);
        if (child && child->length < buf->length && p[child->length] == ' ') {
            // if is spaced then i can provide the
            // next subtree as suggestion..
            p = rz_str_trim_head_ro(p + child->length);
            if (child->type == RZ_CORE_AUTOCMPLT_OPTN) {
                continue;
            }
            parent = child;
        } else {
            break;
        }
    }
    int i;
    /* if something went wrong this will prevent bad behavior */
    rz_line_completion_clear(completion);
    switch (parent->type) {
    case RZ_CORE_AUTOCMPLT_SEEK:
        autocomplete_functions(core, completion, p);
        // fallthrough
    case RZ_CORE_AUTOCMPLT_FLAG:
        autocomplete_flags(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_FLSP:
        autocomplete_flagspaces(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_FCN:
        autocomplete_functions(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_EVAL:
        autocomplete_evals(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_MINS:
        autocomplete_minus(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_BRKP:
        autocomplete_breakpoints(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_MACR:
        autocomplete_macro(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_FILE:
        autocomplete_file(completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_THME:
        autocomplete_theme(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_SDB:
        autocomplete_sdb(core, completion, p);
        break;
    case RZ_CORE_AUTOCMPLT_OPTN:
        // handled before
        break;
    default:
        if (rz_config_get_i(core->config, "cfg.newtab")) {
            RzCmdDescriptor *desc = &core->root_cmd_descriptor;
            for (i = 0; arg[i] && desc; i++) {
                ut8 c = arg[i];
                desc = c < RZ_ARRAY_SIZE(desc->sub) ? desc->sub[c] : NULL;
            }
            if (desc && desc->help_msg) {
                rz_core_cmd_help(core, desc->help_msg);
                rz_cons_flush();
                return true;
            }
            // fallback to command listing
        }
        int length = strlen(arg);
        for (i = 0; i < parent->n_subcmds; i++) {
            if (!strncmp(arg, parent->subcmds[i]->cmd, length)) {
                rz_line_completion_push(completion, parent->subcmds[i]->cmd);
            }
        }
        break;
    }
    return true;
}

References rz_core_t::autocomplete, autocomplete_breakpoints(), autocomplete_evals(), autocomplete_file(), autocomplete_flags(), autocomplete_flagspaces(), autocomplete_functions(), autocomplete_macro(), autocomplete_minus(), autocomplete_sdb(), autocomplete_theme(), c, rz_core_autocomplete_t::cmd, rz_core_t::config, desc, e, i, rz_core_autocomplete_t::length, length, memcpy(), rz_core_autocomplete_t::n_subcmds, NULL, p, rz_core_t::root_cmd_descriptor, RZ_ARRAY_SIZE, rz_config_get_i(), rz_cons_flush(), RZ_CORE_AUTOCMPLT_BRKP, RZ_CORE_AUTOCMPLT_EVAL, RZ_CORE_AUTOCMPLT_FCN, RZ_CORE_AUTOCMPLT_FILE, RZ_CORE_AUTOCMPLT_FLAG, RZ_CORE_AUTOCMPLT_FLSP, RZ_CORE_AUTOCMPLT_MACR, RZ_CORE_AUTOCMPLT_MINS, RZ_CORE_AUTOCMPLT_OPTN, RZ_CORE_AUTOCMPLT_SDB, RZ_CORE_AUTOCMPLT_SEEK, RZ_CORE_AUTOCMPLT_THME, rz_core_autocomplete_find(), rz_core_cmd_help(), rz_line_completion_clear(), rz_line_completion_push(), rz_str_trim_head_ro(), rz_str_trim_head_wp(), rz_core_autocomplete_t::subcmds, and rz_core_autocomplete_t::type.

Referenced by rz_core_autocomplete().

find_e_opts()

static bool find_e_opts ( RzCore *  core, RzLineCompletion *  completion, RzLineBuffer *  buf  )

static

Definition at line 1408 of file core.c.

                                                                                       {
    const char *pattern = "e (.*)=";
    RzRegex *rx = rz_regex_new(pattern, "e");
    const size_t nmatch = 2;
    RzRegexMatch pmatch[2] = { 0 };
    bool ret = false;
 
    if (rz_regex_exec(rx, buf->data, nmatch, pmatch, 1)) {
        goto out;
    }
    int i;
    char *str = NULL, *sp;
    for (i = pmatch[1].rm_so; i < pmatch[1].rm_eo; i++) {
        str = rz_str_appendch(str, buf->data[i]);
    }
    if (!str) {
        goto out;
    }
    if ((sp = strchr(str, ' '))) {
        // if the name contains a space, just null
        *sp = 0;
    }
    RzConfigNode *node = rz_config_node_get(core->config, str);
    if (sp) {
        // if nulled, then restore.
        *sp = ' ';
    }
    if (!node) {
        return false;
    }
    RzListIter *iter;
    char *option;
    char *p = (char *)strchr(buf->data, '=');
    p = rz_str_ichr(p + 1, ' ');
    int n = strlen(p);
    rz_list_foreach (node->options, iter, option) {
        if (!strncmp(option, p, n)) {
            rz_line_completion_push(completion, option);
        }
    }
    completion->opt = true;
    ret = true;
 
out:
    rz_regex_free(rx);
    return ret;
}

References rz_core_t::config, i, n, NULL, rz_line_comp_t::opt, option, rz_config_node_t::options, out, p, rz_regmatch_t::rm_eo, rz_config_node_get(), rz_line_completion_push(), rz_regex_exec(), rz_regex_free(), rz_regex_new(), rz_str_appendch(), rz_str_ichr(), sp, and cmd_descs_generate::str.

Referenced by rz_core_autocomplete().

get_comments_cb()

static char* get_comments_cb ( void *  user, ut64  addr  )

static

Definition at line 2249 of file core.c.

                                                    {
    return rz_core_analysis_get_comments((RzCore *)user, addr);
}

References addr, and rz_core_analysis_get_comments().

Referenced by rz_core_init().

get_section_name()

static const char* get_section_name ( void *  user, ut64  addr  )

static

Definition at line 2245 of file core.c.

                                                           {
    return rz_core_get_section_name((RzCore *)user, addr);
}

References addr, and rz_core_get_section_name().

Referenced by rz_core_init().

getName()

static const char* getName ( RzCore *  core, ut64  addr  )

static

Definition at line 314 of file core.c.

                                                    {
    RzFlagItem *item = rz_flag_get_i(core->flags, addr);
    if (item) {
        if (core->flags->realnames) {
            return item->realname
                ? item->realname
                : item->name;
        }
        return item->name;
    }
    return NULL;
}

References addr, rz_core_t::flags, rz_flag_item_t::name, NULL, rz_flag_item_t::realname, rz_flag_t::realnames, and rz_flag_get_i().

Referenced by rz_core_bind().

getNameDelta()

static char* getNameDelta ( RzCore *  core, ut64  addr  )

static

Definition at line 327 of file core.c.

                                                   {
    RzFlagItem *item = rz_flag_get_at(core->flags, addr, true);
    if (item) {
        if (item->offset != addr) {
            const char *name = core->flags->realnames
                ? item->realname
                : item->name;
            return rz_str_newf("%s+%" PFMT64u, name, addr - item->offset);
        }
        return strdup(item->name);
    }
    return NULL;
}

References addr, rz_core_t::flags, rz_flag_item_t::name, NULL, rz_flag_item_t::offset, PFMT64u, rz_flag_item_t::realname, rz_flag_t::realnames, rz_flag_get_at(), rz_str_newf(), and strdup().

Referenced by rz_core_bind().

getref()

static ut64 getref ( RzCore *  core, int  n, char  t, int  type  )

static

Definition at line 400 of file core.c.

                                                          {
    RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
    RzListIter *iter;
    RzAnalysisXRef *r;
    RzList *list;
    int i = 0;
    if (!fcn) {
        return UT64_MAX;
    }
    if (t == 'r') {
        list = rz_analysis_function_get_xrefs_from(fcn);
    } else {
        list = rz_analysis_function_get_xrefs_to(fcn);
    }
    rz_list_foreach (list, iter, r) {
        if (r->type == type) {
            if (i == n) {
                ut64 addr = t == 'r' ? r->to : r->from;
                rz_list_free(list);
                return addr;
            }
            i++;
        }
    }
    rz_list_free(list);
 
    return UT64_MAX;
}

References addr, rz_core_t::analysis, i, list(), n, rz_core_t::offset, r, rz_analysis_function_get_xrefs_from(), rz_analysis_function_get_xrefs_to(), rz_analysis_get_fcn_in(), rz_list_free(), type, ut64(), and UT64_MAX.

Referenced by num_callback().

getvalue()

static char* getvalue ( ut64  value, int  bits  )

static

Definition at line 1820 of file core.c.

                                            {
    switch (bits) {
    case 16: // umf, not in sync with pxr
    {
        st16 v = (st16)(value & UT16_MAX);
        st16 h = UT16_MAX / 0x100;
        if (v > -h && v < h) {
            return rz_str_newf("%hd", v);
        }
    } break;
    case 32: {
        st32 v = (st32)(value & UT32_MAX);
        st32 h = UT32_MAX / 0x10000;
        if (v > -h && v < h) {
            return rz_str_newf("%d", v);
        }
    } break;
    case 64: {
        st64 v = (st64)(value);
        st64 h = UT64_MAX / 0x1000000;
        if (v > -h && v < h) {
            return rz_str_newf("%" PFMT64d, v);
        }
    } break;
    }
    return NULL;
}

References bits(), h, NULL, PFMT64d, rz_str_newf(), st16, st32, st64, UT16_MAX, UT32_MAX, UT64_MAX, v, and value.

Referenced by rz_core_analysis_hasrefs_to_depth().

hasrefs_cb()

static char* hasrefs_cb ( void *  user, ut64  addr, int  mode  )

static

Definition at line 2241 of file core.c.

                                                         {
    return rz_core_analysis_hasrefs((RzCore *)user, addr, mode);
}

References addr, and rz_core_analysis_hasrefs().

Referenced by rz_core_init().

is_string()

static int is_string ( const ut8 *  buf, int  size, int *  len  )

static

Definition at line 1775 of file core.c.

                                                         {
    int i;
    if (size < 1) {
        return 0;
    }
    if (size > 3 && buf[0] && !buf[1] && buf[2] && !buf[3]) {
        *len = 1; // XXX: TODO: Measure wide string length
        return 2; // is wide
    }
    for (i = 0; i < size; i++) {
        if (!buf[i] && i > MINLEN) {
            *len = i;
            return 1;
        }
        if (buf[i] == 10 || buf[i] == 13 || buf[i] == 9) {
            continue;
        }
        if (buf[i] < 32 || buf[i] > 127) {
            // not ascii text
            return 0;
        }
        if (!IS_PRINTABLE(buf[i])) {
            *len = i;
            return 0;
        }
    }
    *len = i;
    return 1;
}

References i, IS_PRINTABLE, len, and MINLEN.

Referenced by rz_core_analysis_hasrefs_to_depth().

mywrite()

static int mywrite ( const ut8 *  buf, int  len  )

static

Definition at line 2135 of file core.c.

                                            {
    return rz_cons_memcat((const char *)buf, len);
}

References len, and rz_cons_memcat().

Referenced by rz_core_init().

num_callback()

static ut64 num_callback ( RzNum *  userptr, const char *  str, int *  ok  )

static

Definition at line 501 of file core.c.

                                                                   {
    RzCore *core = (RzCore *)userptr; // XXX ?
    RzAnalysisFunction *fcn;
    char *ptr, *bptr, *out = NULL;
    RzFlagItem *flag;
    RzBinSection *s;
    RzAnalysisOp op;
    ut64 ret = 0;
 
    if (ok) {
        *ok = false;
    }
    switch (*str) {
    case '.':
        if (str[1] == '.') {
            if (ok) {
                *ok = true;
            }
            return rz_num_tail(core->num, core->offset, str + 2);
        }
        if (core->num->nc.curr_tok == '+') {
            ut64 off = core->num->nc.number_value.n;
            if (!off) {
                off = core->offset;
            }
            RzAnalysisFunction *fcn = rz_analysis_get_function_at(core->analysis, off);
            if (fcn) {
                if (ok) {
                    *ok = true;
                }
                ut64 dst = rz_analysis_function_get_label(fcn, str + 1);
                if (dst == UT64_MAX) {
                    dst = fcn->addr;
                }
                st64 delta = dst - off;
                if (delta < 0) {
                    core->num->nc.curr_tok = '-';
                    delta = off - dst;
                }
                return delta;
            }
        }
        break;
    case '[': {
        ut64 n = 0LL;
        int refsz = core->rasm->bits / 8;
        const char *p = NULL;
        if (strlen(str) > 5) {
            p = strchr(str + 5, ':');
        }
        if (p) {
            refsz = atoi(str + 1);
            str = p;
        }
        // push state
        if (str[0] && str[1]) {
            const char *q;
            char *o = strdup(str + 1);
            if (o) {
                q = rz_num_calc_index(core->num, NULL);
                if (q) {
                    if (rz_str_replace_char(o, ']', 0) > 0) {
                        n = rz_num_math(core->num, o);
                        if (core->num->nc.errors) {
                            return 0;
                        }
                        rz_num_calc_index(core->num, q);
                    }
                }
                free(o);
            }
        } else {
            return 0;
        }
        // pop state
        if (ok) {
            *ok = 1;
        }
        ut8 buf[sizeof(ut64)] = RZ_EMPTY;
        (void)rz_io_read_at(core->io, n, buf, RZ_MIN(sizeof(buf), refsz));
        switch (refsz) {
        case 8:
            return rz_read_ble64(buf, core->print->big_endian);
        case 4:
            return rz_read_ble32(buf, core->print->big_endian);
        case 2:
            return rz_read_ble16(buf, core->print->big_endian);
        case 1:
            return rz_read_ble8(buf);
        default:
            eprintf("Invalid reference size: %d (%s)\n", refsz, str);
            return 0LL;
        }
    } break;
    case '$':
        if (ok) {
            *ok = 1;
        }
        // TODO: group analop-dependant vars after a char, so i can filter
        rz_analysis_op(core->analysis, &op, core->offset, core->block, core->blocksize, RZ_ANALYSIS_OP_MASK_BASIC);
        rz_analysis_op_fini(&op); // we don't need strings or pointers, just values, which are not nullified in fini
        // XXX the above line is assuming op after fini keeps jump, fail, ptr, val, size and rz_analysis_op_is_eob()
        switch (str[1]) {
        case '.': // can use pc, sp, a0, a1, ...
            return rz_debug_reg_get(core->dbg, str + 2);
        case 'k': // $k{kv}
            if (str[2] != '{') {
                eprintf("Expected '{' after 'k'.\n");
                break;
            }
            bptr = strdup(str + 3);
            ptr = strchr(bptr, '}');
            if (!ptr) {
                // invalid json
                free(bptr);
                break;
            }
            *ptr = '\0';
            ret = 0LL;
            out = sdb_querys(core->sdb, NULL, 0, bptr);
            if (out && *out) {
                if (strstr(out, "$k{")) {
                    eprintf("Recursivity is not permitted here\n");
                } else {
                    ret = rz_num_math(core->num, out);
                }
            }
            free(bptr);
            free(out);
            return ret;
        case '{': // ${ev} eval var
            bptr = strdup(str + 2);
            ptr = strchr(bptr, '}');
            if (ptr) {
                ptr[0] = '\0';
                ut64 ret = rz_config_get_i(core->config, bptr);
                free(bptr);
                return ret;
            }
            // take flag here
            free(bptr);
            break;
        case 'c': // $c console width
            return rz_cons_get_size(NULL);
        case 'r': // $r
            if (str[2] == '{') {
                bptr = strdup(str + 3);
                ptr = strchr(bptr, '}');
                if (!ptr) {
                    free(bptr);
                    break;
                }
                *ptr = 0;
                return rz_core_reg_getv_by_role_or_name(core, bptr);
                free(bptr);
                return 0; // UT64_MAX;
            } else {
                int rows;
                (void)rz_cons_get_size(&rows);
                return rows;
            }
            break;
        case 'e': // $e
            if (str[2] == '{') { // $e{flag} flag off + size
                char *flagName = strdup(str + 3);
                int flagLength = strlen(flagName);
                if (flagLength > 0) {
                    flagName[flagLength - 1] = 0;
                }
                RzFlagItem *flag = rz_flag_get(core->flags, flagName);
                free(flagName);
                if (flag) {
                    return flag->offset + flag->size;
                }
                return UT64_MAX;
            }
            return rz_analysis_op_is_eob(&op);
        case 'j': // $j jump address
            return op.jump;
        case 'p': // $p
            return rz_sys_getpid();
        case 'P': // $P
            return core->dbg->pid > 0 ? core->dbg->pid : 0;
        case 'f': // $f jump fail address
            if (str[2] == 'l') { // $fl flag length
                RzFlagItem *fi = rz_flag_get_i(core->flags, core->offset);
                if (fi) {
                    return fi->size;
                }
                return 0;
            }
            return op.fail;
        case 'm': // $m memref
            return op.ptr;
        case 'B': // $B base address
        case 'M': { // $M map address
            ut64 lower = UT64_MAX;
            ut64 size = 0LL;
            RzIOMap *map = rz_io_map_get(core->io, core->offset);
            if (map) {
                lower = rz_itv_begin(map->itv);
                size = rz_itv_size(map->itv);
            }
 
            if (str[1] == 'B') {
                /* clear lower bits of the lowest map address to define the base address */
                const int clear_bits = 16;
                lower >>= clear_bits;
                lower <<= clear_bits;
            }
            if (str[2] == 'M') {
                return size;
            }
            return (lower == UT64_MAX) ? 0LL : lower;
        } break;
        case 'v': // $v immediate value
            return op.val;
        case 'l': // $l opcode length
            return op.size;
        case 'b': // $b
            return core->blocksize;
        case 's': // $s file size
            if (str[2] == '{') { // $s{flag} flag size
                bptr = strdup(str + 3);
                ptr = strchr(bptr, '}');
                if (!ptr) {
                    // invalid json
                    free(bptr);
                    break;
                }
                *ptr = '\0';
                RzFlagItem *flag = rz_flag_get(core->flags, bptr);
                ret = flag ? flag->size : 0LL; // flag
                free(bptr);
                free(out);
                return ret;
            } else if (core->file) {
                return rz_io_fd_size(core->io, core->file->fd);
            }
            return 0LL;
        case 'w': // $w word size
            return rz_config_get_i(core->config, "asm.bits") / 8;
        case 'S': // $S section offset
        {
            RzBinObject *bo = rz_bin_cur_object(core->bin);
            if (bo && (s = rz_bin_get_section_at(bo, core->offset, true))) {
                return (str[2] == 'S' ? s->size : s->vaddr);
            }
        }
            return 0LL;
        case 'D': // $D
            if (str[2] == 'B') { // $DD
                return rz_debug_get_baddr(core->dbg, NULL);
            } else if (IS_DIGIT(str[2])) {
                return getref(core, atoi(str + 2), 'r', RZ_ANALYSIS_XREF_TYPE_DATA);
            } else {
                RzDebugMap *map;
                RzListIter *iter;
                rz_list_foreach (core->dbg->maps, iter, map) {
                    if (core->offset >= map->addr && core->offset < map->addr_end) {
                        return (str[2] == 'D') ? map->size : map->addr;
                    }
                }
            }
            return 0LL; // maybe // return UT64_MAX;
        case '?': // $?
            return core->num->value; // rc;
        case '$': // $$ offset
            return str[2] == '$' ? core->prompt_offset : core->offset;
        case 'o': { // $o
            RzBinSection *s = rz_bin_get_section_at(rz_bin_cur_object(core->bin), core->offset, true);
            return s ? core->offset - s->vaddr + s->paddr : core->offset;
            break;
        }
        case 'O': // $O
            if (core->print->cur_enabled) {
                return core->offset + core->print->cur;
            }
            return core->offset;
        case 'C': // $C nth call
            return getref(core, atoi(str + 2), 'r', RZ_ANALYSIS_XREF_TYPE_CALL);
        case 'J': // $J nth jump
            return getref(core, atoi(str + 2), 'r', RZ_ANALYSIS_XREF_TYPE_CODE);
        case 'X': // $X nth xref
            return getref(core, atoi(str + 2), 'x', RZ_ANALYSIS_XREF_TYPE_CALL);
        case 'F': // $F function size
            fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
            if (fcn) {
                switch (str[2]) {
                /* function bounds (uppercase) */
                case 'B': return fcn->addr; // begin
                case 'E': return rz_analysis_function_max_addr(fcn); // end
                case 'S': return (str[3] == 'S') ? rz_analysis_function_realsize(fcn) : rz_analysis_function_linear_size(fcn);
                case 'I': return fcn->ninstr;
                /* basic blocks (lowercase) */
                case 'b': return bbBegin(fcn, core->offset);
                case 'e': return bbBegin(fcn, core->offset) + bbSize(fcn, core->offset);
                case 'i': return bbInstructions(fcn, core->offset);
                case 's': return bbSize(fcn, core->offset);
                case 'j': return bbJump(fcn, core->offset); // jump
                case 'f': return bbFail(fcn, core->offset); // fail
                }
                return fcn->addr;
            }
            return 0;
        }
        break;
    default:
        if (*str >= 'A') {
            // NOTE: functions override flags
            RzAnalysisFunction *fcn = rz_analysis_get_function_byname(core->analysis, str);
            if (fcn) {
                if (ok) {
                    *ok = true;
                }
                return fcn->addr;
            }
#if 0
            ut64 addr = rz_analysis_fcn_label_get (core->analysis, core->offset, str);
            if (addr != 0) {
                ret = addr;
            } else {
                ...
            }
#endif
            if ((flag = rz_flag_get(core->flags, str))) {
                ret = flag->offset;
                if (ok) {
                    *ok = true;
                }
                return ret;
            }
 
            // check for reg alias
            RzReg *reg = rz_core_reg_default(core);
            struct rz_reg_item_t *r = rz_reg_get(reg, str, -1);
            if (!r) {
                int role = rz_reg_get_name_idx(str);
                if (role != -1) {
                    const char *alias = rz_reg_get_name(reg, role);
                    if (alias) {
                        r = rz_reg_get(reg, alias, -1);
                        if (r) {
                            if (ok) {
                                *ok = true;
                            }
                            ret = rz_reg_get_value(reg, r);
                            return ret;
                        }
                    }
                }
            } else {
                if (ok) {
                    *ok = true;
                }
                ret = rz_reg_get_value(reg, r);
                return ret;
            }
        }
        break;
    }
 
    return ret;
}

References addr, rz_analysis_function_t::addr, rz_core_t::analysis, bbBegin(), bbFail(), bbInstructions(), bbJump(), bbSize(), rz_print_t::big_endian, rz_core_t::bin, rz_asm_t::bits, rz_core_t::block, rz_core_t::blocksize, rz_core_t::config, rz_print_t::cur, rz_print_t::cur_enabled, rz_num_calc_t::curr_tok, rz_core_t::dbg, delta, dst, eprintf, rz_num_calc_t::errors, rz_core_file_t::fd, rz_core_t::file, rz_core_t::flags, free(), getref(), rz_core_t::io, IS_DIGIT, map(), rz_debug_t::maps, n, RzNumCalcValue::n, rz_num_t::nc, rz_analysis_function_t::ninstr, NULL, rz_core_t::num, rz_num_calc_t::number_value, off, rz_core_t::offset, rz_flag_item_t::offset, ok, op, out, p, rz_debug_t::pid, rz_core_t::print, rz_core_t::prompt_offset, r, rz_core_t::rasm, reg, rz_analysis_function_get_label(), rz_analysis_function_linear_size(), rz_analysis_function_max_addr(), rz_analysis_function_realsize(), rz_analysis_get_fcn_in(), rz_analysis_get_function_at(), rz_analysis_get_function_byname(), rz_analysis_op(), rz_analysis_op_fini(), rz_analysis_op_is_eob(), RZ_ANALYSIS_OP_MASK_BASIC, RZ_ANALYSIS_XREF_TYPE_CALL, RZ_ANALYSIS_XREF_TYPE_CODE, RZ_ANALYSIS_XREF_TYPE_DATA, rz_bin_cur_object(), rz_bin_get_section_at(), rz_config_get_i(), rz_cons_get_size(), rz_core_reg_default(), rz_core_reg_getv_by_role_or_name(), rz_debug_get_baddr(), rz_debug_reg_get(), RZ_EMPTY, rz_flag_get(), rz_flag_get_i(), rz_io_fd_size(), rz_io_map_get(), rz_io_read_at(), rz_itv_begin(), rz_itv_size(), RZ_MIN, rz_num_calc_index(), rz_num_math(), rz_num_tail(), rz_read_ble16(), rz_read_ble32(), rz_read_ble64(), rz_read_ble8(), rz_reg_get(), rz_reg_get_name(), rz_reg_get_name_idx(), rz_reg_get_value(), rz_str_replace_char(), rz_sys_getpid(), s, rz_core_t::sdb, sdb_querys(), rz_flag_item_t::size, st64, cmd_descs_generate::str, strdup(), ut64(), UT64_MAX, and rz_num_t::value.

Referenced by rz_core_init().

numget()

static ut64 numget ( RzCore *  core, const char *  k  )

static

Definition at line 361 of file core.c.

                                                {
    return rz_num_math(core->num, k);
}

References k, rz_core_t::num, and rz_num_math().

Referenced by rz_core_bind().

on_fcn_delete()

static int on_fcn_delete ( RzAnalysis *  _analysis, void *  _user, RzAnalysisFunction *  fcn  )

static

Definition at line 121 of file core.c.

                                                                                      {
    RzCore *core = (RzCore *)_user;
    const char *cmd = rz_config_get(core->config, "cmd.fcn.delete");
    if (cmd && *cmd) {
        ut64 oaddr = core->offset;
        ut64 addr = fcn->addr;
        rz_core_seek(core, addr, true);
        rz_core_cmd0(core, cmd);
        rz_core_seek(core, oaddr, true);
    }
    return 0;
}

References addr, rz_analysis_function_t::addr, cmd, rz_core_t::config, rz_core_t::offset, rz_config_get(), rz_core_cmd0(), rz_core_seek(), and ut64().

Referenced by rz_core_init().

on_fcn_new()

static int on_fcn_new ( RzAnalysis *  _analysis, void *  _user, RzAnalysisFunction *  fcn  )

static

Definition at line 108 of file core.c.

                                                                                   {
    RzCore *core = (RzCore *)_user;
    const char *cmd = rz_config_get(core->config, "cmd.fcn.new");
    if (cmd && *cmd) {
        ut64 oaddr = core->offset;
        ut64 addr = fcn->addr;
        rz_core_seek(core, addr, true);
        rz_core_cmd0(core, cmd);
        rz_core_seek(core, oaddr, true);
    }
    return 0;
}

References addr, rz_analysis_function_t::addr, cmd, rz_core_t::config, rz_core_t::offset, rz_config_get(), rz_core_cmd0(), rz_core_seek(), and ut64().

Referenced by rz_core_init().

on_fcn_rename()

static int on_fcn_rename ( RzAnalysis *  _analysis, void *  _user, RzAnalysisFunction *  fcn, const char *  oname  )

static

Definition at line 134 of file core.c.

                                                                                                         {
    RzCore *core = (RzCore *)_user;
    const char *cmd = rz_config_get(core->config, "cmd.fcn.rename");
    if (cmd && *cmd) {
        // XXX: wat do with old name here?
        ut64 oaddr = core->offset;
        ut64 addr = fcn->addr;
        rz_core_seek(core, addr, true);
        rz_core_cmd0(core, cmd);
        rz_core_seek(core, oaddr, true);
    }
    return 0;
}

References addr, rz_analysis_function_t::addr, cmd, rz_core_t::config, rz_core_t::offset, rz_config_get(), rz_core_cmd0(), rz_core_seek(), and ut64().

Referenced by rz_core_init().

prompt_add_file()

static bool prompt_add_file ( RzCore *  core, RzStrBuf *  sb, bool  add_sep  )

static

Definition at line 2707 of file core.c.

                                                                      {
    if (!rz_config_get_b(core->config, "scr.prompt.file") || !core->io->desc) {
        return add_sep;
    }
    if (add_sep) {
        rz_strbuf_append(sb, ":");
    }
    rz_strbuf_append(sb, rz_file_basename(core->io->desc->name));
    return true;
}

References rz_core_t::config, rz_io_t::desc, rz_core_t::io, rz_io_desc_t::name, rz_config_get_b(), rz_file_basename(), rz_strbuf_append(), and sb.

Referenced by set_prompt().

prompt_add_offset()

static bool prompt_add_offset ( RzCore *  core, RzStrBuf *  sb, bool  add_sep  )

static

Definition at line 2733 of file core.c.

                                                                        {
    if (add_sep) {
        rz_strbuf_append(sb, ":");
    }
    if (rz_config_get_b(core->config, "scr.prompt.flag")) {
        const RzFlagItem *f = rz_flag_get_at(core->flags, core->offset, true);
        if (f) {
            if (f->offset < core->offset) {
                rz_strbuf_appendf(sb, "%s + %" PFMT64u, f->name, core->offset - f->offset);
            } else {
                rz_strbuf_appendf(sb, "%s", f->name);
            }
            if (rz_config_get_b(core->config, "scr.prompt.flag.only")) {
                return true;
            }
 
            rz_strbuf_append(sb, ":");
        }
    }
 
    if (rz_config_get_b(core->config, "asm.segoff")) {
        ut32 a, b;
        unsigned int seggrn = rz_config_get_i(core->config, "asm.seggrn");
 
        a = ((core->offset >> 16) << (16 - seggrn));
        b = (core->offset & 0xffff);
        rz_strbuf_appendf(sb, "%04x:%04x", a, b);
    } else {
        if (core->print->wide_offsets && core->dbg->bits & RZ_SYS_BITS_64) {
            rz_strbuf_appendf(sb, "0x%016" PFMT64x, core->offset);
        } else {
            rz_strbuf_appendf(sb, "0x%08" PFMT64x, core->offset);
        }
    }
    return true;
}

References a, b, rz_debug_t::bits, rz_core_t::config, rz_core_t::dbg, f, rz_core_t::flags, rz_core_t::offset, PFMT64u, PFMT64x, rz_core_t::print, rz_config_get_b(), rz_config_get_i(), rz_flag_get_at(), rz_strbuf_append(), rz_strbuf_appendf(), RZ_SYS_BITS_64, sb, and rz_print_t::wide_offsets.

Referenced by set_prompt().

prompt_add_section()

static bool prompt_add_section ( RzCore *  core, RzStrBuf *  sb, bool  add_sep  )

static

Definition at line 2718 of file core.c.

                                                                         {
    if (!rz_config_get_b(core->config, "scr.prompt.sect")) {
        return add_sep;
    }
    const RzBinSection *sec = rz_bin_get_section_at(rz_bin_cur_object(core->bin), core->offset, true);
    if (!sec) {
        return add_sep;
    }
    if (add_sep) {
        rz_strbuf_append(sb, ":");
    }
    rz_strbuf_append(sb, sec->name);
    return true;
}

References rz_core_t::bin, rz_core_t::config, rz_bin_section_t::name, rz_core_t::offset, rz_bin_cur_object(), rz_bin_get_section_at(), rz_config_get_b(), rz_strbuf_append(), and sb.

Referenced by set_prompt().

rap_break()

static void rap_break ( void *  u )

static

Definition at line 2894 of file core.c.

                               {
    RzIORap *rior = (RzIORap *)u;
    if (u) {
        rz_socket_close(rior->fd);
        rior->fd = NULL;
    }
}

References RzIORap::fd, NULL, and rz_socket_close().

Referenced by rz_core_serve().

rz_core_add_asmqjmp()

RZ_API char* rz_core_add_asmqjmp	(	RzCore *	core,
		ut64	addr
	)

Takes addr and returns already saved shortcut or a new one The returned buffer needs to be freed

Definition at line 238 of file core.c.

                                                          {
    bool found = false;
    if (!core->asmqjmps) {
        return NULL;
    }
    if (core->is_asmqjmps_letter) {
        if (core->asmqjmps_count >= RZ_CORE_ASMQJMPS_MAX_LETTERS) {
            return NULL;
        }
        if (core->asmqjmps_count >= core->asmqjmps_size - 2) {
            core->asmqjmps = realloc(core->asmqjmps, core->asmqjmps_size * 2 * sizeof(ut64));
            if (!core->asmqjmps) {
                return NULL;
            }
            core->asmqjmps_size *= 2;
        }
    }
    if (core->asmqjmps_count < core->asmqjmps_size - 1) {
        int i = 0;
        char t[RZ_CORE_ASMQJMPS_LEN_LETTERS + 1] = { 0 };
        for (i = 0; i < core->asmqjmps_count + 1; i++) {
            if (core->asmqjmps[i] == addr) {
                found = true;
                break;
            }
        }
        if (!found) {
            i = ++core->asmqjmps_count;
            core->asmqjmps[i] = addr;
        }
        // This check makes pos never be <1, thefor not fill 't' with trash
        if (i < 1) {
            return NULL;
        }
        rz_core_set_asmqjmps(core, t, sizeof(t), i);
        return strdup(t);
    }
    return NULL;
}

References addr, rz_core_t::asmqjmps, rz_core_t::asmqjmps_count, rz_core_t::asmqjmps_size, found, i, rz_core_t::is_asmqjmps_letter, NULL, realloc(), RZ_CORE_ASMQJMPS_LEN_LETTERS, RZ_CORE_ASMQJMPS_MAX_LETTERS, rz_core_set_asmqjmps(), strdup(), and ut64().

Referenced by ds_print_shortcut(), get_bbnodes(), and get_bbupdate().

rz_core_analysis_get_comments()

RZ_API char* rz_core_analysis_get_comments	(	RzCore *	core,
		ut64	addr
	)

Definition at line 2091 of file core.c.

                                                                    {
    if (core) {
        const char *type = rz_meta_get_string(core->analysis, RZ_META_TYPE_VARTYPE, addr);
        const char *cmt = rz_meta_get_string(core->analysis, RZ_META_TYPE_COMMENT, addr);
        if (type && cmt) {
            return rz_str_newf("%s %s", type, cmt);
        }
        if (type) {
            return strdup(type);
        }
        if (cmt) {
            return strdup(cmt);
        }
    }
    return NULL;
}

References addr, rz_core_t::analysis, NULL, rz_meta_get_string(), RZ_META_TYPE_COMMENT, RZ_META_TYPE_VARTYPE, rz_str_newf(), strdup(), and type.

Referenced by disasm_strings(), and get_comments_cb().

rz_core_analysis_hasrefs()

RZ_API char* rz_core_analysis_hasrefs	(	RzCore *	core,
		ut64	value,
		int	mode
	)

Definition at line 1805 of file core.c.

                                                                          {
    if (mode) {
        PJ *pj = (mode == 'j') ? pj_new() : NULL;
        const int hex_depth = 1; // r_config_get_i (core->config, "hex.depth");
        char *res = rz_core_analysis_hasrefs_to_depth(core, value, pj, hex_depth);
        if (pj) {
            free(res);
            return pj_drain(pj);
        }
        return res;
    }
    RzFlagItem *fi = rz_flag_get_i(core->flags, value);
    return fi ? strdup(fi->name) : NULL;
}

References rz_core_t::flags, free(), rz_flag_item_t::name, NULL, pj_drain(), pj_new(), rz_core_analysis_hasrefs_to_depth(), rz_flag_get_i(), strdup(), and value.

Referenced by hasrefs_cb(), references_handler(), and rz_regs_show_valgroup().

rz_core_analysis_hasrefs_to_depth()

RZ_API char* rz_core_analysis_hasrefs_to_depth	(	RzCore *	core,
		ut64	value,
		PJ *	pj,
		int	depth
	)

Definition at line 1853 of file core.c.

                                                                                            {
    const int bits = core->rasm->bits;
    rz_return_val_if_fail(core, NULL);
    RzStrBuf *s = rz_strbuf_new(NULL);
    if (pj) {
        pj_o(pj);
        pj_kn(pj, "addr", value);
    }
    if (depth < 1 || value == UT64_MAX) {
        if (pj) {
            pj_end(pj);
        }
        return NULL;
    }
 
    char *val = getvalue(value, bits);
    if (val) {
        if (pj) {
            pj_ks(pj, "value", val);
        } else {
            rz_strbuf_appendf(s, "%s ", val);
        }
        RZ_FREE(val);
    }
 
    if (value && value != UT64_MAX) {
        RzDebugMap *map = rz_debug_map_get(core->dbg, value);
        if (map && map->name && map->name[0]) {
            if (pj) {
                pj_ks(pj, "map", map->name);
            } else {
                rz_strbuf_appendf(s, "%s ", map->name);
            }
        }
    }
    ut64 type = rz_core_analysis_address(core, value);
    RzBinObject *obj = rz_bin_cur_object(core->bin);
    RzBinSection *sect = value && obj ? rz_bin_get_section_at(obj, value, true) : NULL;
    if (!((type & RZ_ANALYSIS_ADDR_TYPE_HEAP) || (type & RZ_ANALYSIS_ADDR_TYPE_STACK))) {
        // Do not repeat "stack" or "heap" words unnecessarily.
        if (sect && sect->name[0]) {
            if (pj) {
                pj_ks(pj, "section", sect->name);
            } else {
                rz_strbuf_appendf(s, "%s ", sect->name);
            }
        }
    }
    if (value != 0 && value != UT64_MAX) {
        if (pj) {
            RzListIter *iter;
            RzFlagItem *f;
            const RzList *flags = rz_flag_get_list(core->flags, value);
            if (flags && !rz_list_empty(flags)) {
                pj_ka(pj, "flags");
                rz_list_foreach (flags, iter, f) {
                    pj_s(pj, f->name);
                }
                pj_end(pj);
            }
        } else {
            char *flags = rz_flag_get_liststr(core->flags, value);
            if (flags) {
                rz_strbuf_appendf(s, "%s ", flags);
                free(flags);
            }
        }
    }
    RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, value, 0);
    if (fcn) {
        if (pj) {
            pj_ks(pj, "fcn", fcn->name);
        } else {
            rz_strbuf_appendf(s, "%s ", fcn->name);
        }
    }
    if (type) {
        const char *c = rz_core_analysis_optype_colorfor(core, value, true);
        const char *cend = (c && *c) ? Color_RESET : "";
        if (!c) {
            c = "";
        }
        if (pj) {
            pj_ka(pj, "attr");
        }
        if (type & RZ_ANALYSIS_ADDR_TYPE_HEAP) {
            if (pj) {
                pj_s(pj, "heap");
            } else {
                rz_strbuf_appendf(s, "%sheap%s ", c, cend);
            }
        } else if (type & RZ_ANALYSIS_ADDR_TYPE_STACK) {
            if (pj) {
                pj_s(pj, "stack");
            } else {
                rz_strbuf_appendf(s, "%sstack%s ", c, cend);
            }
        }
        if (type & RZ_ANALYSIS_ADDR_TYPE_PROGRAM) {
            if (pj) {
                pj_s(pj, "program");
            } else {
                rz_strbuf_appendf(s, "%sprogram%s ", c, cend);
            }
        }
        if (type & RZ_ANALYSIS_ADDR_TYPE_LIBRARY) {
            if (pj) {
                pj_s(pj, "library");
            } else {
                rz_strbuf_appendf(s, "%slibrary%s ", c, cend);
            }
        }
        if (type & RZ_ANALYSIS_ADDR_TYPE_ASCII) {
            if (pj) {
                pj_s(pj, "ascii");
            } else {
                rz_strbuf_appendf(s, "%sascii%s ('%c') ", c, cend, (char)value);
            }
        }
        if (type & RZ_ANALYSIS_ADDR_TYPE_SEQUENCE) {
            if (pj) {
                pj_s(pj, "sequence");
            } else {
                rz_strbuf_appendf(s, "%ssequence%s ", c, cend);
            }
        }
        if (pj) {
            if (type & RZ_ANALYSIS_ADDR_TYPE_READ) {
                pj_s(pj, "R");
            }
            if (type & RZ_ANALYSIS_ADDR_TYPE_WRITE) {
                pj_s(pj, "W");
            }
            if (type & RZ_ANALYSIS_ADDR_TYPE_EXEC) {
                pj_s(pj, "X");
            }
        } else {
            if (type & RZ_ANALYSIS_ADDR_TYPE_READ) {
                rz_strbuf_appendf(s, "%sR%s ", c, cend);
            }
            if (type & RZ_ANALYSIS_ADDR_TYPE_WRITE) {
                rz_strbuf_appendf(s, "%sW%s ", c, cend);
            }
            if (type & RZ_ANALYSIS_ADDR_TYPE_EXEC) {
                RzAsmOp op;
                ut8 buf[32];
                rz_strbuf_appendf(s, "%sX%s ", c, cend);
                /* instruction disassembly */
                rz_io_read_at(core->io, value, buf, sizeof(buf));
                rz_asm_set_pc(core->rasm, value);
                rz_asm_disassemble(core->rasm, &op, buf, sizeof(buf));
                rz_strbuf_appendf(s, "'%s' ", rz_asm_op_get_asm(&op));
                /* get library name */
                { // NOTE: dup for mapname?
                    RzDebugMap *map;
                    RzListIter *iter;
                    rz_list_foreach (core->dbg->maps, iter, map) {
                        if ((value >= map->addr) &&
                            (value < map->addr_end)) {
                            const char *lastslash = rz_str_lchr(map->name, '/');
                            rz_strbuf_appendf(s, "'%s' ", lastslash ? lastslash + 1 : map->name);
                            break;
                        }
                    }
                }
            } else if (type & RZ_ANALYSIS_ADDR_TYPE_READ) {
                ut8 buf[32];
                ut32 *n32 = (ut32 *)buf;
                ut64 *n64 = (ut64 *)buf;
                if (rz_io_read_at(core->io, value, buf, sizeof(buf))) {
                    ut64 n = (bits == 64) ? *n64 : *n32;
                    rz_strbuf_appendf(s, "0x%" PFMT64x " ", n);
                }
            }
        }
        if (pj) {
            pj_end(pj);
        }
    }
    {
        ut8 buf[128], widebuf[256];
        const char *c = rz_config_get_i(core->config, "scr.color") ? core->cons->context->pal.ai_ascii : "";
        const char *cend = (c && *c) ? Color_RESET : "";
        int len, r;
        if (rz_io_read_at(core->io, value, buf, sizeof(buf))) {
            buf[sizeof(buf) - 1] = 0;
            switch (is_string(buf, sizeof(buf), &len)) {
            case 1:
                if (pj) {
                    pj_ks(pj, "string", (const char *)buf);
                } else {
                    rz_strbuf_appendf(s, "%s%s%s ", c, buf, cend);
                }
                break;
            case 2:
                r = rz_utf8_encode_str((const RzRune *)buf, widebuf, sizeof(widebuf) - 1);
                if (r == -1) {
                    eprintf("Something was wrong with refs\n");
                } else {
                    if (pj) {
                        pj_ks(pj, "string", (const char *)widebuf);
                    } else {
                        rz_strbuf_appendf(s, "%s%s%s ", c, widebuf, cend);
                    }
                }
                break;
            }
        }
    }
    if ((type & RZ_ANALYSIS_ADDR_TYPE_READ) && !(type & RZ_ANALYSIS_ADDR_TYPE_EXEC) && depth) {
        // Try to telescope further, but only several levels deep.
        ut8 buf[32];
        ut32 *n32 = (ut32 *)buf;
        ut64 *n64 = (ut64 *)buf;
        if (rz_io_read_at(core->io, value, buf, sizeof(buf))) {
            ut64 n = (bits == 64) ? *n64 : *n32;
            if (n != value) {
                if (pj) {
                    pj_k(pj, "ref");
                }
                char *rrstr = rz_core_analysis_hasrefs_to_depth(core, n, pj, depth - 1);
                if (rrstr) {
                    if (!pj && rrstr[0]) {
                        rz_strbuf_appendf(s, " -> %s", rrstr);
                    }
                    free(rrstr);
                }
            }
        }
    }
    if (pj) {
        pj_end(pj);
    }
    char *res = rz_strbuf_drain(s);
    rz_str_trim_tail(res);
    return res;
}

References rz_cons_printable_palette_t::ai_ascii, rz_core_t::analysis, rz_core_t::bin, rz_asm_t::bits, bits(), buf, c, Color_RESET, rz_core_t::config, rz_core_t::cons, rz_cons_t::context, rz_core_t::dbg, eprintf, f, rz_core_t::flags, flags, free(), getvalue(), rz_core_t::io, is_string(), len, map(), rz_debug_t::maps, n, rz_analysis_function_t::name, rz_bin_section_t::name, NULL, op, rz_cons_context_t::pal, PFMT64x, pj_end(), pj_k(), pj_ka(), pj_kn(), pj_ks(), pj_o(), pj_s(), r, rz_core_t::rasm, RZ_ANALYSIS_ADDR_TYPE_ASCII, RZ_ANALYSIS_ADDR_TYPE_EXEC, RZ_ANALYSIS_ADDR_TYPE_HEAP, RZ_ANALYSIS_ADDR_TYPE_LIBRARY, RZ_ANALYSIS_ADDR_TYPE_PROGRAM, RZ_ANALYSIS_ADDR_TYPE_READ, RZ_ANALYSIS_ADDR_TYPE_SEQUENCE, RZ_ANALYSIS_ADDR_TYPE_STACK, RZ_ANALYSIS_ADDR_TYPE_WRITE, rz_analysis_get_fcn_in(), rz_asm_disassemble(), rz_asm_op_get_asm(), rz_asm_set_pc(), rz_bin_cur_object(), rz_bin_get_section_at(), rz_config_get_i(), rz_core_analysis_address(), rz_core_analysis_optype_colorfor(), rz_debug_map_get(), rz_flag_get_list(), rz_flag_get_liststr(), RZ_FREE, rz_io_read_at(), rz_return_val_if_fail, rz_str_lchr(), rz_str_trim_tail(), rz_strbuf_appendf(), rz_strbuf_drain(), rz_strbuf_new(), rz_utf8_encode_str(), s, type, ut64(), UT64_MAX, val, and value.

Referenced by cmd_pxr(), and rz_core_analysis_hasrefs().

rz_core_analysis_optype_colorfor()

RZ_API const char* rz_core_analysis_optype_colorfor	(	RzCore *	core,
		ut64	addr,
		bool	verbose
	)

Definition at line 2108 of file core.c.

                                                                                           {
    ut64 type;
    if (!(core->print->flags & RZ_PRINT_FLAGS_COLOR)) {
        return NULL;
    }
    if (!rz_config_get_i(core->config, "scr.color")) {
        return NULL;
    }
    type = rz_core_analysis_address(core, addr);
    if (type & RZ_ANALYSIS_ADDR_TYPE_EXEC) {
        return core->cons->context->pal.ai_exec; // Color_RED;
    }
    if (type & RZ_ANALYSIS_ADDR_TYPE_WRITE) {
        return core->cons->context->pal.ai_write; // Color_BLUE;
    }
    if (type & RZ_ANALYSIS_ADDR_TYPE_READ) {
        return core->cons->context->pal.ai_read; // Color_GREEN;
    }
    if (type & RZ_ANALYSIS_ADDR_TYPE_SEQUENCE) {
        return core->cons->context->pal.ai_seq; // Color_MAGENTA;
    }
    if (type & RZ_ANALYSIS_ADDR_TYPE_ASCII) {
        return core->cons->context->pal.ai_ascii; // Color_YELLOW;
    }
    return NULL;
}

References addr, rz_cons_printable_palette_t::ai_ascii, rz_cons_printable_palette_t::ai_exec, rz_cons_printable_palette_t::ai_read, rz_cons_printable_palette_t::ai_seq, rz_cons_printable_palette_t::ai_write, rz_core_t::config, rz_core_t::cons, rz_cons_t::context, rz_print_t::flags, NULL, rz_cons_context_t::pal, rz_core_t::print, RZ_ANALYSIS_ADDR_TYPE_ASCII, RZ_ANALYSIS_ADDR_TYPE_EXEC, RZ_ANALYSIS_ADDR_TYPE_READ, RZ_ANALYSIS_ADDR_TYPE_SEQUENCE, RZ_ANALYSIS_ADDR_TYPE_WRITE, rz_config_get_i(), rz_core_analysis_address(), RZ_PRINT_FLAGS_COLOR, type, and ut64().

Referenced by colorfor_cb(), and rz_core_analysis_hasrefs_to_depth().

rz_core_analysis_read_at()

static bool rz_core_analysis_read_at ( struct rz_analysis_t *  analysis, ut64  addr, ut8 *  buf, int  len  )

static

Definition at line 2148 of file core.c.

                                                                                                   {
    return rz_io_read_at(analysis->iob.io, addr, buf, len);
}

References addr, rz_io_bind_t::io, rz_analysis_t::iob, len, and rz_io_read_at().

Referenced by rz_core_init().

rz_core_autocomplete()

RZ_API void rz_core_autocomplete	(	RZ_NULLABLE RzCore *	core,
		RzLineCompletion *	completion,
		RzLineBuffer *	buf,
		RzLinePromptType	prompt_type
	)

Definition at line 1550 of file core.c.

                                                                                                                                          {
    if (!core) {
        autocomplete_default(core, completion, buf);
        return;
    }
    rz_line_completion_clear(completion);
    char *pipe = strchr(buf->data, '>');
    char *ptr = strchr(buf->data, '@');
    if (pipe && strchr(pipe + 1, ' ') && buf->data + buf->index >= pipe) {
        autocompleteFilename(completion, buf, NULL, 1);
    } else if (ptr && strchr(ptr + 1, ' ') && buf->data + buf->index >= ptr) {
        int sdelta, n;
        ptr = (char *)rz_str_trim_head_ro(ptr + 1);
        n = strlen(ptr); //(buf->data+sdelta);
        sdelta = (int)(size_t)(ptr - buf->data);
        rz_flag_foreach_prefix(core->flags, buf->data + sdelta, n, add_argv, completion);
    } else if (!strncmp(buf->data, "#!pipe ", 7)) {
        if (strchr(buf->data + 7, ' ')) {
            autocompleteFilename(completion, buf, NULL, 2);
        } else {
            int chr = 7;
            ADDARG("node");
            ADDARG("vala");
            ADDARG("ruby");
            ADDARG("newlisp");
            ADDARG("perl");
            ADDARG("python");
        }
    } else if (!strncmp(buf->data, "ec ", 3)) {
        if (strchr(buf->data + 3, ' ')) {
            autocompleteFilename(completion, buf, NULL, 2);
        } else {
            int chr = 3;
            ADDARG("comment")
            ADDARG("usrcmt")
            ADDARG("args")
            ADDARG("fname")
            ADDARG("floc")
            ADDARG("fline")
            ADDARG("flag")
            ADDARG("label")
            ADDARG("help")
            ADDARG("flow")
            ADDARG("prompt")
            ADDARG("offset")
            ADDARG("input")
            ADDARG("invalid")
            ADDARG("other")
            ADDARG("b0x00")
            ADDARG("b0x7f")
            ADDARG("b0xff")
            ADDARG("math")
            ADDARG("bin")
            ADDARG("btext")
            ADDARG("push")
            ADDARG("pop")
            ADDARG("crypto")
            ADDARG("jmp")
            ADDARG("cjmp")
            ADDARG("call")
            ADDARG("nop")
            ADDARG("ret")
            ADDARG("trap")
            ADDARG("swi")
            ADDARG("cmp")
            ADDARG("reg")
            ADDARG("creg")
            ADDARG("num")
            ADDARG("mov")
            ADDARG("func_var")
            ADDARG("func_var_type")
            ADDARG("func_var_addr")
            ADDARG("widget_bg")
            ADDARG("widget_sel")
            ADDARG("ai.read")
            ADDARG("ai.write")
            ADDARG("ai.exec")
            ADDARG("ai.seq")
            ADDARG("ai.ascii")
            ADDARG("ai.unmap")
            ADDARG("graph.box")
            ADDARG("graph.box2")
            ADDARG("graph.box3")
            ADDARG("graph.box4")
            ADDARG("graph.true")
            ADDARG("graph.false")
            ADDARG("graph.ujump")
            ADDARG("graph.current")
            ADDARG("graph.traced")
            ADDARG("gui.cflow")
            ADDARG("gui.dataoffset")
            ADDARG("gui.background")
            ADDARG("gui.alt_background")
            ADDARG("gui.border")
        }
    } else if ((!strncmp(buf->data, "afvn ", 5)) || (!strncmp(buf->data, "afan ", 5))) {
        RzAnalysisFunction *fcn = rz_analysis_get_fcn_in(core->analysis, core->offset, 0);
        RzList *vars;
        if (!strncmp(buf->data, "afvn ", 5)) {
            vars = rz_analysis_var_list(core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_BPV);
        } else {
            vars = rz_list_new(); // TODO rz_analysis_var_list (core->analysis, fcn, RZ_ANALYSIS_VAR_KIND_ARG);
        }
        const char *f_ptr, *l_ptr;
        RzAnalysisVar *var;
        int len = strlen(buf->data);
 
        f_ptr = rz_sub_str_lchr(buf->data, 0, buf->index, ' ');
        f_ptr = f_ptr != NULL ? f_ptr + 1 : buf->data;
        l_ptr = rz_sub_str_rchr(buf->data, buf->index, len, ' ');
        if (!l_ptr) {
            l_ptr = buf->data + len;
        }
        RzListIter *iter;
        rz_list_foreach (vars, iter, var) {
            if (!strncmp(f_ptr, var->name, l_ptr - f_ptr)) {
                rz_line_completion_push(completion, var->name);
            }
        }
        rz_list_free(vars);
    } else if (!strncmp(buf->data, "$", 1)) {
        int i;
        for (i = 0; i < core->rcmd->aliases.count; i++) {
            const char *key = core->rcmd->aliases.keys[i];
            int len = strlen(buf->data);
            if (!len || !strncmp(buf->data, key, len)) {
                rz_line_completion_push(completion, key);
            }
        }
    } else if (find_e_opts(core, completion, buf)) {
        return;
    } else if (prompt_type == RZ_LINE_PROMPT_OFFSET) {
        autocomplete_flags(core, completion, buf->data);
    } else if (prompt_type == RZ_LINE_PROMPT_FILE) {
        autocomplete_file(completion, buf->data);
    } else if (!find_autocomplete(core, completion, buf)) {
        autocomplete_default(core, completion, buf);
    }
}

References add_argv(), ADDARG, autocomplete_default(), autocomplete_file(), autocomplete_flags(), autocompleteFilename(), find_autocomplete(), find_e_opts(), i, int, key, len, n, rz_analysis_var_t::name, NULL, pipe, rz_analysis_get_fcn_in(), RZ_ANALYSIS_VAR_KIND_BPV, rz_analysis_var_list(), rz_flag_foreach_prefix(), rz_line_completion_clear(), rz_line_completion_push(), RZ_LINE_PROMPT_FILE, RZ_LINE_PROMPT_OFFSET, rz_list_free(), rz_list_new(), rz_str_trim_head_ro(), rz_sub_str_lchr(), and rz_sub_str_rchr().

rz_core_autocomplete_add()

RZ_API RzCoreAutocomplete* rz_core_autocomplete_add	(	RzCoreAutocomplete *	parent,
		const char *	cmd,
		int	type,
		bool	lock
	)

Definition at line 3366 of file core.c.

                                                                                                                      {
    if (!parent || !cmd || type < 0 || type >= RZ_CORE_AUTOCMPLT_END) {
        return NULL;
    }
    RzCoreAutocomplete *autocmpl = RZ_NEW0(RzCoreAutocomplete);
    if (!autocmpl) {
        return NULL;
    }
    RzCoreAutocomplete **updated = realloc(parent->subcmds, (parent->n_subcmds + 1) * sizeof(RzCoreAutocomplete *));
    if (!updated) {
        free(autocmpl);
        return NULL;
    }
    parent->subcmds = updated;
    parent->subcmds[parent->n_subcmds] = autocmpl;
    parent->n_subcmds++;
    autocmpl->cmd = strdup(cmd);
    autocmpl->locked = lock;
    autocmpl->type = type;
    autocmpl->length = strlen(cmd);
    return autocmpl;
}

References rz_core_autocomplete_t::cmd, cmd, free(), rz_core_autocomplete_t::length, lock(), rz_core_autocomplete_t::locked, rz_core_autocomplete_t::n_subcmds, NULL, realloc(), RZ_CORE_AUTOCMPLT_END, RZ_NEW0, strdup(), rz_core_autocomplete_t::subcmds, type, and rz_core_autocomplete_t::type.

Referenced by __foreach(), and __init_autocomplete_default().

rz_core_autocomplete_find()

RZ_API RzCoreAutocomplete* rz_core_autocomplete_find	(	RzCoreAutocomplete *	parent,
		const char *	cmd,
		bool	exact
	)

Definition at line 3403 of file core.c.

                                                                                                              {
    if (!parent || !cmd) {
        return false;
    }
    int len = strlen(cmd);
    int i;
    for (i = 0; i < parent->n_subcmds; i++) {
        if (exact && len == parent->subcmds[i]->length && !strncmp(cmd, parent->subcmds[i]->cmd, len)) {
            return parent->subcmds[i];
        } else if (!exact && !strncmp(cmd, parent->subcmds[i]->cmd, len)) {
            return parent->subcmds[i];
        }
    }
    return NULL;
}

References rz_core_autocomplete_t::cmd, cmd, i, len, rz_core_autocomplete_t::length, rz_core_autocomplete_t::n_subcmds, NULL, and rz_core_autocomplete_t::subcmds.

Referenced by __init_autocomplete_default(), and find_autocomplete().

rz_core_autocomplete_free()

RZ_API void rz_core_autocomplete_free

(

RzCoreAutocomplete *

obj

)

Definition at line 3389 of file core.c.

                                                               {
    if (!obj) {
        return;
    }
    int i;
    for (i = 0; i < obj->n_subcmds; i++) {
        rz_core_autocomplete_free(obj->subcmds[i]);
        obj->subcmds[i] = NULL;
    }
    free(obj->subcmds);
    free((char *)obj->cmd);
    free(obj);
}

References rz_core_autocomplete_t::cmd, free(), i, rz_core_autocomplete_t::n_subcmds, NULL, and rz_core_autocomplete_t::subcmds.

Referenced by rz_core_autocomplete_reload(), rz_core_autocomplete_remove(), and rz_core_fini().

rz_core_autocomplete_reload()

RZ_API void rz_core_autocomplete_reload

(

RzCore *

core

)

Definition at line 2274 of file core.c.

                                                      {
    rz_return_if_fail(core);
    rz_core_autocomplete_free(core->autocomplete);
    __init_autocomplete(core);
}

References __init_autocomplete(), rz_core_t::autocomplete, rz_core_autocomplete_free(), and rz_return_if_fail.

rz_core_autocomplete_remove()

RZ_API bool rz_core_autocomplete_remove	(	RzCoreAutocomplete *	parent,
		const char *	cmd
	)

Definition at line 3419 of file core.c.

                                                                                     {
    if (!parent || !cmd) {
        return false;
    }
    int i, j;
    for (i = 0; i < parent->n_subcmds; i++) {
        RzCoreAutocomplete *ac = parent->subcmds[i];
        if (ac->locked) {
            continue;
        }
        // if (!strncmp (parent->subcmds[i]->cmd, cmd, parent->subcmds[i]->length)) {
        if (rz_str_glob(ac->cmd, cmd)) {
            for (j = i + 1; j < parent->n_subcmds; j++) {
                parent->subcmds[j - 1] = parent->subcmds[j];
                parent->subcmds[j] = NULL;
            }
            rz_core_autocomplete_free(ac);
            RzCoreAutocomplete **updated = realloc(parent->subcmds, (parent->n_subcmds - 1) * sizeof(RzCoreAutocomplete *));
            if (!updated && (parent->n_subcmds - 1) > 0) {
                eprintf("Something really bad has happen.. this should never ever happen..\n");
                return false;
            }
            parent->subcmds = updated;
            parent->n_subcmds--;
            i--;
        }
    }
    return false;
}

References rz_core_autocomplete_t::cmd, cmd, eprintf, i, rz_core_autocomplete_t::locked, rz_core_autocomplete_t::n_subcmds, NULL, realloc(), rz_core_autocomplete_free(), rz_str_glob(), and rz_core_autocomplete_t::subcmds.

rz_core_bind()

RZ_API int rz_core_bind	(	RzCore *	core,
		RzCoreBind *	bnd
	)

Definition at line 369 of file core.c.

                                                       {
    bnd->core = core;
    bnd->bphit = (RzCoreDebugBpHit)rz_core_debug_breakpoint_hit;
    bnd->syshit = (RzCoreDebugSyscallHit)rz_core_debug_syscall_hit;
    bnd->cmd = (RzCoreCmd)rz_core_cmd0;
    bnd->cmdf = (RzCoreCmdF)rz_core_cmdf;
    bnd->cmdstr = (RzCoreCmdStr)rz_core_cmd_str;
    bnd->cmdstrf = (RzCoreCmdStrF)rz_core_cmd_strf;
    bnd->puts = (RzCorePuts)rz_cons_strcat;
    bnd->setab = (RzCoreSetArchBits)setab;
    bnd->getName = (RzCoreGetName)getName;
    bnd->getNameDelta = (RzCoreGetNameDelta)getNameDelta;
    bnd->archbits = (RzCoreSeekArchBits)archbits;
    bnd->cfggeti = (RzCoreConfigGetI)cfggeti;
    bnd->cfgGet = (RzCoreConfigGet)cfgget;
    bnd->cfgSetI = (RzCoreConfigSetI)cfgseti;
    bnd->cfgSet = (RzCoreConfigSet)cfgset;
    bnd->numGet = (RzCoreNumGet)numget;
    bnd->flagsGet = (RzCoreFlagsGet)__flagsGet;
    bnd->applyBinInfo = (RzCoreBinApplyInfo)rz_core_bin_apply_info;
    return true;
}

References __flagsGet(), rz_core_bind_t::applyBinInfo, archbits(), rz_core_bind_t::archbits, rz_core_bind_t::bphit, cfgget(), rz_core_bind_t::cfgGet, cfggeti(), rz_core_bind_t::cfggeti, cfgset(), rz_core_bind_t::cfgSet, cfgseti(), rz_core_bind_t::cfgSetI, rz_core_bind_t::cmd, rz_core_bind_t::cmdf, rz_core_bind_t::cmdstr, rz_core_bind_t::cmdstrf, rz_core_bind_t::core, rz_core_bind_t::flagsGet, getName(), rz_core_bind_t::getName, getNameDelta(), rz_core_bind_t::getNameDelta, numget(), rz_core_bind_t::numGet, rz_core_bind_t::puts, rz_cons_strcat(), rz_core_bin_apply_info(), rz_core_cmd0(), rz_core_cmd_str(), rz_core_cmd_strf(), rz_core_cmdf(), rz_core_debug_breakpoint_hit(), rz_core_debug_syscall_hit(), setab(), rz_core_bind_t::setab, and rz_core_bind_t::syshit.

Referenced by rz_core_init().

rz_core_bind_cons()

RZ_API void rz_core_bind_cons

(

RzCore *

core

)

Definition at line 2612 of file core.c.

                                            {
    core->cons->num = core->num;
    core->cons->cb_fkey = (RzConsFunctionKey)__cons_cb_fkey;
    core->cons->cb_editor = (RzConsEditorCallback)rz_core_editor;
    core->cons->cb_break = (RzConsBreakCallback)rz_core_break;
    core->cons->cb_sleep_begin = (RzConsSleepBeginCallback)rz_core_sleep_begin;
    core->cons->cb_sleep_end = (RzConsSleepEndCallback)rz_core_sleep_end;
    core->cons->cb_task_oneshot = (RzConsQueueTaskOneshot)rz_core_task_enqueue_oneshot;
    core->cons->user = (void *)core;
}

References __cons_cb_fkey(), rz_cons_t::cb_break, rz_cons_t::cb_editor, rz_cons_t::cb_fkey, rz_cons_t::cb_sleep_begin, rz_cons_t::cb_sleep_end, rz_cons_t::cb_task_oneshot, rz_core_t::cons, rz_cons_t::num, rz_core_t::num, rz_core_break(), rz_core_editor(), rz_core_sleep_begin(), rz_core_sleep_end(), rz_core_task_enqueue_oneshot(), and rz_cons_t::user.

Referenced by rz_core_init().

rz_core_block_size()

RZ_API bool rz_core_block_size	(	RzCore *	core,
		ut32	bsize
	)

Definition at line 2842 of file core.c.

                                                         {
    ut8 *bump;
    if (bsize == core->blocksize) {
        return true;
    }
    if (bsize > core->blocksize_max) {
        RZ_LOG_ERROR("Block size %d is too big\n", bsize);
        return false;
    }
    if (bsize < 1) {
        bsize = 1;
    } else if (core->blocksize_max && bsize > core->blocksize_max) {
        RZ_LOG_ERROR("block size is bigger than its max (check `bm` command). set to 0x%x\n", core->blocksize_max);
        bsize = core->blocksize_max;
    }
    bump = realloc(core->block, bsize + 1);
    if (!bump) {
        RZ_LOG_ERROR("Oops. cannot allocate that much (%u)\n", bsize);
        return false;
    }
    core->block = bump;
    core->blocksize = bsize;
    memset(core->block, 0xff, core->blocksize);
    rz_core_seek(core, core->offset, true);
    return true;
}

References rz_core_t::block, rz_core_t::blocksize, rz_core_t::blocksize_max, memset(), rz_core_t::offset, realloc(), rz_core_seek(), and RZ_LOG_ERROR.

Referenced by backup_current_addr(), cmd_pCd(), cmd_pCD(), cmd_print_bars(), cmd_print_format(), core_disassembly(), DEFINE_HANDLE_TS_FCN_AND_SYMBOL(), do_iter_offsets(), do_iter_sections(), foreach_pairs(), handle_tmp_desc(), printraw(), restore_current_addr(), rz_analyze_n_ins_esil_handler(), rz_analyze_n_ins_handler(), rz_analyze_n_ins_size_handler(), rz_block_decrease_handler(), rz_block_flag_handler(), rz_block_handler(), rz_block_increase_handler(), rz_cmd_analysis(), rz_cmd_disassembly_all_methods_class_handler(), rz_cmd_disassembly_all_possible_opcodes_handler(), rz_cmd_disassembly_all_possible_opcodes_treeview_handler(), rz_cmd_disassembly_function_handler(), rz_cmd_disassembly_function_summary_handler(), rz_cmd_disassembly_n_instrs_as_text_json_handler(), rz_cmd_print(), rz_cmd_sizes_of_n_instructions_handler(), rz_core_cmd_foreach(), rz_core_cmd_foreach3(), rz_core_cmd_subst_i(), rz_core_handle_backwards_disasm(), rz_core_print_disasm_json(), rz_core_serve(), rz_core_visual(), rz_core_visual_cmd(), rz_core_visual_title(), rz_core_visual_trackflags(), rz_main_rizin(), rz_print_utf16be_handler(), rz_print_utf16le_handler(), rz_print_utf32be_handler(), rz_print_utf32le_handler(), and rz_serialize_core_load().

rz_core_break()

static void rz_core_break ( RzCore *  core )

static

Definition at line 2152 of file core.c.

                                        {
}

Referenced by rz_core_bind_cons().

rz_core_cast()

RZ_API RzCore* rz_core_cast

(

void *

p

)

Definition at line 396 of file core.c.

                                     {
    return (RzCore *)p;
}

References p.

rz_core_core_plugin_print()

RZ_API RzCmdStatus rz_core_core_plugin_print	(	RzCorePlugin *	cp,
		RzCmdStateOutput *	state,
		const char *	license
	)

Definition at line 3457 of file core.c.

                                                                                                             {
    PJ *pj = state->d.pj;
    switch (state->mode) {
    case RZ_OUTPUT_MODE_JSON: {
        pj_o(pj);
        pj_ks(pj, "name", cp->name);
        pj_ks(pj, "description", cp->desc);
        pj_ks(pj, "author", cp->author);
        pj_ks(pj, "version", cp->version);
        pj_ks(pj, "license", license);
        pj_end(pj);
        break;
    }
    case RZ_OUTPUT_MODE_STANDARD: {
        rz_cons_printf("%s: %s (Made by %s, v%s, %s)\n",
            cp->name, cp->desc, cp->author, cp->version, license);
        break;
    }
    default: {
        rz_warn_if_reached();
        return RZ_CMD_STATUS_NONEXISTINGCMD;
    }
    }
    return RZ_CMD_STATUS_OK;
}

References rz_core_plugin_t::author, rz_core_plugin_t::desc, rz_core_plugin_t::name, pj_end(), pj_ks(), pj_o(), RZ_CMD_STATUS_NONEXISTINGCMD, RZ_CMD_STATUS_OK, rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, rz_warn_if_reached, and rz_core_plugin_t::version.

Referenced by rz_core_core_plugins_print().

rz_core_core_plugins_print()

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

Definition at line 3483 of file core.c.

                                                                                     {
    RzListIter *iter;
    RzCorePlugin *cp;
    RzCmdStatus status;
    if (!core) {
        return RZ_CMD_STATUS_ERROR;
    }
    rz_cmd_state_output_array_start(state);
    rz_list_foreach (core->plugins, iter, cp) {
        const char *license = cp->license
            ? cp->license
            : "???";
        status = rz_core_core_plugin_print(cp, state, license);
        if (status != RZ_CMD_STATUS_OK) {
            return status;
        }
    }
    rz_cmd_state_output_array_end(state);
    return RZ_CMD_STATUS_OK;
}

References rz_core_plugin_t::license, rz_core_t::plugins, rz_cmd_state_output_array_end(), rz_cmd_state_output_array_start(), RZ_CMD_STATUS_ERROR, RZ_CMD_STATUS_OK, rz_core_core_plugin_print(), and status.

Referenced by rz_plugins_core_print_handler().

rz_core_debug_breakpoint_hit()

static void rz_core_debug_breakpoint_hit ( RzCore *  core, RzBreakpointItem *  bpi  )

static

Definition at line 148 of file core.c.

                                                                              {
    const char *cmdbp = rz_config_get(core->config, "cmd.bp");
    const bool cmdbp_exists = (cmdbp && *cmdbp);
    const bool bpcmd_exists = (bpi->data && bpi->data[0]);
    const bool may_output = (cmdbp_exists || bpcmd_exists);
    if (may_output) {
        rz_cons_push();
    }
    if (cmdbp_exists) {
        rz_core_cmd0(core, cmdbp);
    }
    if (bpcmd_exists) {
        rz_core_cmd0(core, bpi->data);
    }
    if (may_output) {
        rz_cons_set_flush(true);
        rz_cons_flush();
        rz_cons_pop();
    }
}

References rz_core_t::config, rz_bp_item_t::data, rz_config_get(), rz_cons_flush(), rz_cons_pop(), rz_cons_push(), rz_cons_set_flush(), and rz_core_cmd0().

Referenced by rz_core_bind().

rz_core_debug_syscall_hit()

static void rz_core_debug_syscall_hit ( RzCore *  core )

static

Definition at line 169 of file core.c.

                                                    {
    const char *cmdhit = rz_config_get(core->config, "cmd.onsyscall");
 
    if (cmdhit && cmdhit[0] != 0) {
        rz_core_cmd0(core, cmdhit);
        rz_cons_flush();
    }
}

References rz_core_t::config, rz_config_get(), rz_cons_flush(), and rz_core_cmd0().

Referenced by rz_core_bind().

rz_core_editor()

RZ_API RZ_OWN char* rz_core_editor	(	const RzCore *	core,
		RZ_NULLABLE const char *	file,
		RZ_NULLABLE const char *	str
	)

Definition at line 3214 of file core.c.

                                                                                                                  {
    const bool interactive = rz_cons_is_interactive();
    if (!interactive) {
        return NULL;
    }
 
    const char *editor = rz_config_get(core->config, "cfg.editor");
    if (RZ_STR_ISEMPTY(editor)) {
        RZ_LOG_ERROR("Please set \"cfg.editor\" to run the editor");
        return NULL;
    }
    char *name = NULL, *ret = NULL;
    int fd;
 
    bool readonly = false;
    if (file && *file != '*') {
        name = strdup(file);
        fd = rz_sys_open(file, O_RDWR, 0644);
        if (fd == -1) {
            fd = rz_sys_open(file, O_RDWR | O_CREAT, 0644);
            if (fd == -1) {
                fd = rz_sys_open(file, O_RDONLY, 0644);
                readonly = true;
            }
        }
    } else {
        fd = rz_file_mkstemp(file, &name);
    }
    if (fd == -1) {
        free(name);
        return NULL;
    }
    if (readonly) {
        eprintf("Opening in read-only\n");
    } else {
        if (str) {
            const size_t str_len = strlen(str);
            if (write(fd, str, str_len) != str_len) {
                close(fd);
                free(name);
                return NULL;
            }
        }
    }
    close(fd);
 
    if (name) {
        char *escaped_name = rz_str_escape_sh(name);
        rz_sys_cmdf("%s \"%s\"", editor, escaped_name);
        free(escaped_name);
    }
    size_t len = 0;
    ret = name ? rz_file_slurp(name, &len) : 0;
    if (ret) {
        if (len && ret[len - 1] == '\n') {
            ret[len - 1] = 0; // chop
        }
        if (!file) {
            rz_file_rm(name);
        }
    }
    free(name);
    return ret;
}

References close, rz_core_t::config, eprintf, fd, free(), len, NULL, O_CREAT, O_RDONLY, O_RDWR, rz_config_get(), rz_cons_is_interactive(), rz_file_mkstemp(), rz_file_rm(), rz_file_slurp(), RZ_LOG_ERROR, rz_str_escape_sh(), RZ_STR_ISEMPTY, rz_sys_cmdf(), rz_sys_open(), cmd_descs_generate::str, strdup(), and write.

Referenced by config_visual_hit(), meta_variable_comment_editor(), rz_cmd_alias(), rz_cmd_debug_process_profile_edit_handler(), rz_cmd_panels(), rz_core_analysis_function_signature_editor(), rz_core_bind_cons(), rz_core_init(), rz_core_meta_editor(), rz_core_run_script(), rz_eval_editor_handler(), rz_types_open_editor(), rz_types_open_file(), rz_write_from_file_handler(), rz_write_hex_from_file_handler(), rz_yank_editor_handler(), and visual_comma().

rz_core_fgets()

RZ_API int rz_core_fgets	(	char *	buf,
		int	len,
		void *	user
	)

Definition at line 1694 of file core.c.

                                                         {
    RzCore *core = (RzCore *)user;
    RzCons *cons = rz_cons_singleton();
    RzLine *rzline = cons->line;
    bool prompt = cons->context->is_interactive;
    buf[0] = '\0';
    if (prompt) {
        rzline->ns_completion.run = rzshell_autocomplete;
        rzline->ns_completion.run_user = core;
        rzline->completion.run = NULL;
    } else {
        rzline->history.data = NULL;
        rz_line_completion_set(&rzline->completion, 0, NULL);
        rzline->completion.run = NULL;
        rzline->completion.run_user = NULL;
    }
    const char *ptr = rz_line_readline();
    if (!ptr) {
        return -1;
    }
    return rz_str_ncpy(buf, ptr, len - 1);
}

References rz_line_t::completion, rz_cons_t::context, rz_line_hist_t::data, rz_line_t::history, rz_cons_context_t::is_interactive, len, rz_cons_t::line, rz_line_t::ns_completion, NULL, prompt(), rz_line_comp_t::run, rz_line_ns_completion_t::run, rz_line_comp_t::run_user, rz_line_ns_completion_t::run_user, rz_cons_singleton(), rz_line_completion_set(), rz_line_readline(), rz_str_ncpy(), and rzshell_autocomplete().

Referenced by cb_scrfgets(), and rz_core_init().

rz_core_file_bin_file_deleted()

RZ_IPI void rz_core_file_bin_file_deleted	(	RzCore *	core,
		RzBinFile *	bf
	)

Definition at line 1290 of file cfile.c.

                                                                       {
    // remove all references to the deleted binfile
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->binfiles, bf);
    }
}

References rz_core_file_t::binfiles, rz_core_t::files, and rz_pvector_remove_data().

Referenced by ev_binfiledel_cb().

rz_core_file_free()

RZ_IPI void rz_core_file_free

(

RzCoreFile *

cf

)

Definition at line 26 of file cfile.c.

                                              {
    if (!cf) {
        return;
    }
    rz_pvector_fini(&cf->binfiles);
    rz_pvector_fini(&cf->extra_files);
    rz_pvector_fini(&cf->maps);
    free(cf);
}

References rz_core_file_t::binfiles, rz_core_file_t::extra_files, free(), rz_core_file_t::maps, and rz_pvector_fini().

Referenced by rz_core_init().

rz_core_file_io_desc_closed()

RZ_IPI void rz_core_file_io_desc_closed	(	RzCore *	core,
		RzIODesc *	desc
	)

Definition at line 1271 of file cfile.c.

                                                                      {
    // remove all references to the closed desc
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->extra_files, desc);
    }
}

References desc, rz_core_file_t::extra_files, rz_core_t::files, and rz_pvector_remove_data().

Referenced by ev_iodescclose_cb().

rz_core_file_io_map_deleted()

RZ_IPI void rz_core_file_io_map_deleted	(	RzCore *	core,
		RzIOMap *	map
	)

Definition at line 1280 of file cfile.c.

                                                                    {
    // remove all references to the deleted map
    RzListIter *it;
    RzCoreFile *cf;
    rz_list_foreach (core->files, it, cf) {
        rz_pvector_remove_data(&cf->maps, map);
    }
    rz_core_io_map_info_free(map->user);
}

References rz_core_t::files, map(), rz_core_file_t::maps, rz_core_io_map_info_free(), and rz_pvector_remove_data().

Referenced by ev_iomapdel_cb().

rz_core_fini()

RZ_API void rz_core_fini

(

RzCore *

c

)

Definition at line 2623 of file core.c.

                                    {
    if (!c) {
        return;
    }
    rz_core_plugin_fini(c);
    rz_core_task_break_all(&c->tasks);
    rz_core_task_join(&c->tasks, NULL, -1);
    rz_core_wait(c);
    //  avoid double free
    RZ_FREE_CUSTOM(c->hash, rz_hash_free);
    RZ_FREE_CUSTOM(c->ropchain, rz_list_free);
    RZ_FREE_CUSTOM(c->ev, rz_event_free);
    RZ_FREE(c->cmdlog);
    RZ_FREE(c->lastsearch);
    RZ_FREE(c->cons->pager);
    RZ_FREE(c->cmdqueue);
    RZ_FREE(c->lastcmd);
    RZ_FREE(c->stkcmd);
    RZ_FREE_CUSTOM(c->visual.tabs, rz_list_free);
    RZ_FREE(c->block);
    RZ_FREE_CUSTOM(c->autocomplete, rz_core_autocomplete_free);
 
    RZ_FREE_CUSTOM(c->gadgets, rz_list_free);
    RZ_FREE_CUSTOM(c->num, rz_num_free);
    RZ_FREE(c->table_query);
    RZ_FREE_CUSTOM(c->io, rz_io_free);
    RZ_FREE_CUSTOM(c->files, rz_list_free);
    RZ_FREE_CUSTOM(c->watchers, rz_list_free);
    RZ_FREE_CUSTOM(c->scriptstack, rz_list_free);
    rz_core_task_scheduler_fini(&c->tasks);
    RZ_FREE_CUSTOM(c->rcmd, rz_cmd_free);
    RZ_FREE_CUSTOM(c->cmd_descriptors, rz_list_free);
    RZ_FREE_CUSTOM(c->analysis, rz_analysis_free);
    RZ_FREE_CUSTOM(c->rasm, rz_asm_free);
    RZ_FREE_CUSTOM(c->print, rz_print_free);
    RZ_FREE_CUSTOM(c->bin, rz_bin_free);
    RZ_FREE_CUSTOM(c->lang, rz_lang_free);
    RZ_FREE_CUSTOM(c->dbg, rz_debug_free);
    RZ_FREE_CUSTOM(c->config, rz_config_free);
    /* after rz_config_free, the value of I.teefile is trashed */
    /* rconfig doesnt knows how to deinitialize vars, so we
    should probably need to add a rz_config_free_payload callback */
    rz_cons_free();
    rz_cons_singleton()->teefile = NULL; // HACK
    RZ_FREE_CUSTOM(c->search, rz_search_free);
    RZ_FREE_CUSTOM(c->flags, rz_flag_free);
    RZ_FREE_CUSTOM(c->egg, rz_egg_free);
    RZ_FREE_CUSTOM(c->lib, rz_lib_free);
    RZ_FREE_CUSTOM(c->yank_buf, rz_buf_free);
    RZ_FREE_CUSTOM(c->graph, rz_agraph_free);
    RZ_FREE(c->visual_inputing);
    RZ_FREE(c->asmqjmps);
    RZ_FREE_CUSTOM(c->sdb, sdb_free);
    RZ_FREE_CUSTOM(c->parser, rz_parse_free);
    RZ_FREE(c->times);
    rz_core_seek_free(c);
    RZ_FREE(c->rtr_host);
    RZ_FREE(c->curtheme);
}

References c, NULL, rz_agraph_free(), rz_analysis_free(), rz_asm_free(), rz_bin_free(), rz_buf_free(), rz_cmd_free(), rz_config_free(), rz_cons_free(), rz_cons_singleton(), rz_core_autocomplete_free(), rz_core_plugin_fini(), rz_core_seek_free(), rz_core_task_break_all(), rz_core_task_join(), rz_core_task_scheduler_fini(), rz_core_wait(), rz_debug_free(), rz_egg_free(), rz_event_free(), rz_flag_free(), RZ_FREE, RZ_FREE_CUSTOM, rz_hash_free(), rz_io_free(), rz_lang_free(), rz_lib_free(), rz_list_free(), rz_num_free(), rz_parse_free(), rz_print_free(), rz_search_free(), sdb_free(), and rz_cons_t::teefile.

Referenced by open_core_file(), rz_core_free(), and rz_main_rz_bin().

rz_core_flag_get_by_spaces()

RZ_API RzFlagItem* rz_core_flag_get_by_spaces	(	RzFlag *	f,
		ut64	off
	)

Definition at line 2280 of file core.c.

                                                                   {
    return rz_flag_get_by_spaces(f, off,
        RZ_FLAGS_FS_FUNCTIONS,
        RZ_FLAGS_FS_SIGNS,
        RZ_FLAGS_FS_CLASSES,
        RZ_FLAGS_FS_SYMBOLS,
        RZ_FLAGS_FS_IMPORTS,
        RZ_FLAGS_FS_RELOCS,
        RZ_FLAGS_FS_STRINGS,
        RZ_FLAGS_FS_RESOURCES,
        RZ_FLAGS_FS_SYMBOLS_SECTIONS,
        RZ_FLAGS_FS_SECTIONS,
        RZ_FLAGS_FS_SEGMENTS,
        NULL);
}

References f, NULL, off, rz_flag_get_by_spaces(), RZ_FLAGS_FS_CLASSES, RZ_FLAGS_FS_FUNCTIONS, RZ_FLAGS_FS_IMPORTS, RZ_FLAGS_FS_RELOCS, RZ_FLAGS_FS_RESOURCES, RZ_FLAGS_FS_SECTIONS, RZ_FLAGS_FS_SEGMENTS, RZ_FLAGS_FS_SIGNS, RZ_FLAGS_FS_STRINGS, RZ_FLAGS_FS_SYMBOLS, and RZ_FLAGS_FS_SYMBOLS_SECTIONS.

Referenced by __core_analysis_fcn(), disasm_strings(), ds_print_ptr(), ds_sub_jumps(), getFunctionName(), rz_core_analysis_esil(), rz_core_debug_bp_add(), and rz_core_init().

rz_core_free()

RZ_API void rz_core_free

(

RzCore *

c

)

Definition at line 2683 of file core.c.

                                    {
    rz_core_fini(c);
    free(c);
}

References c, free(), and rz_core_fini().

Referenced by execute_command(), rz_diff_graphs_files(), rz_diff_hex_visual(), rz_diff_load_file_with_core(), rz_main_rizin(), rz_main_rz_asm(), and rz_main_rz_sign().

rz_core_get_asmqjmps()

RZ_API ut64 rz_core_get_asmqjmps	(	RzCore *	core,
		const char *	str
	)

Definition at line 203 of file core.c.

                                                                {
    if (!core->asmqjmps) {
        return UT64_MAX;
    }
    if (core->is_asmqjmps_letter) {
        int i, pos = 0;
        int len = strlen(str);
        for (i = 0; i < len - 1; i++) {
            if (!isupper((ut8)str[i])) {
                return UT64_MAX;
            }
            pos *= RZ_CORE_ASMQJMPS_LETTERS;
            pos += str[i] - 'A' + 1;
        }
        if (!islower((ut8)str[i])) {
            return UT64_MAX;
        }
        pos *= RZ_CORE_ASMQJMPS_LETTERS;
        pos += str[i] - 'a';
        if (pos < core->asmqjmps_count) {
            return core->asmqjmps[pos + 1];
        }
    } else if (str[0] > '0' && str[1] <= '9') {
        int pos = str[0] - '0';
        if (pos <= core->asmqjmps_count) {
            return core->asmqjmps[pos];
        }
    }
    return UT64_MAX;
}

References rz_core_t::asmqjmps, i, rz_core_t::is_asmqjmps_letter, islower, isupper, len, pos, RZ_CORE_ASMQJMPS_LETTERS, cmd_descs_generate::str, and UT64_MAX.

Referenced by goto_asmqjmps(), and rz_core_visual_jump().

rz_core_get_bin()

RZ_API RzBin* rz_core_get_bin

(

RzCore *

core

)

Definition at line 3288 of file core.c.

                                            {
    return core->bin;
}

References rz_core_t::bin.

rz_core_get_config()

RZ_API RzConfig* rz_core_get_config

(

RzCore *

core

)

Definition at line 3284 of file core.c.

                                                  {
    return core->config;
}

References rz_core_t::config.

rz_core_get_cons()

RZ_API RzCons* rz_core_get_cons

(

RzCore *

core

)

Definition at line 3280 of file core.c.

                                              {
    return core->cons;
}

References rz_core_t::cons.

rz_core_get_reloc_to()

RZ_API RzBinReloc* rz_core_get_reloc_to	(	RzCore *	core,
		ut64	addr
	)

Definition at line 189 of file core.c.

                                                                 {
    rz_return_val_if_fail(core, NULL);
    RzBinFile *bf = rz_bin_cur(core->bin);
    if (!bf || !bf->o || !bf->o->relocs) {
        return NULL;
    }
    return rz_bin_reloc_storage_get_reloc_to(bf->o->relocs, addr);
}

References addr, rz_core_t::bin, NULL, rz_bin_file_t::o, rz_bin_object_t::relocs, rz_bin_cur(), rz_bin_reloc_storage_get_reloc_to(), and rz_return_val_if_fail.

Referenced by ds_print_relocs(), and ds_sub_jumps().

rz_core_getreloc()

RZ_API RzBinReloc* rz_core_getreloc	(	RzCore *	core,
		ut64	addr,
		int	size
	)

Definition at line 178 of file core.c.

                                                                       {
    if (size < 1 || addr == UT64_MAX) {
        return NULL;
    }
    RzBinFile *bf = rz_bin_cur(core->bin);
    if (!bf || !bf->o || !bf->o->relocs) {
        return NULL;
    }
    return rz_bin_reloc_storage_get_reloc_in(bf->o->relocs, addr, size);
}

References addr, rz_core_t::bin, NULL, rz_bin_file_t::o, rz_bin_object_t::relocs, rz_bin_cur(), rz_bin_reloc_storage_get_reloc_in(), and UT64_MAX.

Referenced by _analysis_calls(), ds_print_relocs(), ds_sub_jumps(), process_reference_noreturn_cb(), rz_cmd_print(), and rz_core_print_disasm_json().

rz_core_init()

RZ_API bool rz_core_init

(

RzCore *

core

)

XXX shouhld be using coreb

Definition at line 2381 of file core.c.

                                       {
    core->blocksize = RZ_CORE_BLOCKSIZE;
    core->block = (ut8 *)calloc(RZ_CORE_BLOCKSIZE + 1, 1);
    if (!core->block) {
        eprintf("Cannot allocate %d byte(s)\n", RZ_CORE_BLOCKSIZE);
        /* XXX memory leak */
        return false;
    }
    core->ev = rz_event_new(core);
    core->max_cmd_depth = RZ_CONS_CMD_DEPTH + 1;
    core->sdb = sdb_new(NULL, "rzkv.sdb", 0); // XXX: path must be in home?
    rz_core_seek_reset(core);
    core->lastsearch = NULL;
    core->cmdfilter = NULL;
    core->curtheme = strdup("default");
    core->switch_file_view = 0;
    core->cmdremote = 0;
    core->incomment = false;
    core->config = NULL;
    core->http_up = false;
    ZERO_FILL(core->root_cmd_descriptor);
    core->print = rz_print_new();
    core->ropchain = rz_list_newf((RzListFree)free);
    rz_core_bind(core, &(core->print->coreb));
    core->print->user = core;
    core->print->num = core->num;
    core->print->offname = rz_core_print_offname;
    core->print->offsize = rz_core_print_offsize;
    core->print->cb_printf = rz_cons_printf;
    core->visual_is_inputing = false;
    core->visual_inputing = NULL;
#if __WINDOWS__
    core->print->cb_eprintf = win_eprintf;
#endif
    core->print->cb_color = rz_cons_rainbow_get;
    core->print->write = mywrite;
    core->print->exists_var = exists_var;
    core->print->disasm = __disasm;
    core->print->colorfor = colorfor_cb;
    core->print->hasrefs = hasrefs_cb;
    core->print->get_comments = get_comments_cb;
    core->print->get_section_name = get_section_name;
    core->print->use_comments = false;
    rz_core_rtr_init(core);
    core->rtr_n = 0;
    core->blocksize_max = RZ_CORE_BLOCKSIZE_MAX;
    rz_core_task_scheduler_init(&core->tasks, rz_core_task_ctx_switch, NULL, rz_core_task_break_cb, NULL);
    core->watchers = rz_list_new();
    core->watchers->free = (RzListFree)rz_core_cmpwatch_free;
    core->scriptstack = rz_list_new();
    core->scriptstack->free = (RzListFree)free;
    core->times = RZ_NEW0(RzCoreTimes);
    core->vmode = false;
    core->printidx = 0;
    core->lastcmd = NULL;
    core->cmdlog = NULL;
    core->stkcmd = NULL;
    core->cmdqueue = NULL;
    core->cmdrepeat = true;
    core->yank_buf = rz_buf_new_with_bytes(NULL, 0);
    core->num = rz_num_new(&num_callback, &str_callback, core);
    core->egg = rz_egg_new();
    rz_egg_setup(core->egg, RZ_SYS_ARCH, RZ_SYS_BITS, 0, RZ_SYS_OS);
 
    core->fixedarch = false;
    core->fixedbits = false;
 
    /* initialize libraries */
    core->cons = rz_cons_new();
    if (core->cons->refcnt == 1) {
        core->cons = rz_cons_singleton();
        if (core->cons->line) {
            core->cons->line->user = core;
            core->cons->line->cb_editor =
                (RzLineEditorCb)&rz_core_editor;
            core->cons->line->cb_fkey = core->cons->cb_fkey;
        }
#if __EMSCRIPTEN__
        core->cons->user_fgets = NULL;
#else
        core->cons->user_fgets = (void *)rz_core_fgets;
        core->cons->user_fgets_user = core;
#endif
        char *history = rz_path_home_history();
        rz_line_hist_load(history);
        free(history);
    }
    core->print->cons = core->cons;
    rz_cons_bind(&core->print->consbind);
 
    // We save the old num ad user, in order to restore it after free
    core->lang = rz_lang_new();
    core->lang->cmd_str = (char *(*)(void *, const char *))rz_core_cmd_str;
    core->lang->cmdf = (int (*)(void *, const char *, ...))rz_core_cmdf;
    rz_core_bind_cons(core);
    core->lang->cb_printf = rz_cons_printf;
    rz_lang_define(core->lang, "RzCore", "core", core);
    rz_lang_set_user_ptr(core->lang, core);
    core->rasm = rz_asm_new();
    core->rasm->num = core->num;
    core->rasm->core = core;
    core->analysis = rz_analysis_new();
    core->gadgets = rz_list_newf((RzListFree)rz_core_gadget_free);
    core->analysis->ev = core->ev;
    core->analysis->read_at = rz_core_analysis_read_at;
    core->analysis->flag_get = rz_core_flag_get_by_spaces;
    core->analysis->cb.on_fcn_new = on_fcn_new;
    core->analysis->cb.on_fcn_delete = on_fcn_delete;
    core->analysis->cb.on_fcn_rename = on_fcn_rename;
    core->rasm->syscall = rz_syscall_ref(core->analysis->syscall); // BIND syscall analysis/asm
    core->analysis->core = core;
    core->parser = rz_parse_new();
    rz_analysis_bind(core->analysis, &(core->parser->analb));
    core->parser->varlist = rz_analysis_function_get_var_fields;
    rz_parse_set_user_ptr(core->parser, core);
    core->bin = rz_bin_new();
    rz_event_hook(core->bin->event, RZ_EVENT_BIN_FILE_DEL, ev_binfiledel_cb, core);
    rz_cons_bind(&core->bin->consb);
    // XXX we shuold use RzConsBind instead of this hardcoded pointer
    core->bin->cb_printf = (PrintfCallback)rz_cons_printf;
    rz_bin_set_user_ptr(core->bin, core);
    core->io = rz_io_new();
    rz_io_plugin_add(core->io, &rz_core_io_plugin_vfile);
    rz_event_hook(core->io->event, RZ_EVENT_IO_WRITE, ev_iowrite_cb, core);
    rz_event_hook(core->io->event, RZ_EVENT_IO_DESC_CLOSE, ev_iodescclose_cb, core);
    rz_event_hook(core->io->event, RZ_EVENT_IO_MAP_DEL, ev_iomapdel_cb, core);
    core->io->ff = 1;
    core->search = rz_search_new(RZ_SEARCH_KEYWORD);
    core->flags = rz_flag_new();
    core->graph = rz_agraph_new(rz_cons_canvas_new(1, 1));
    core->graph->need_reload_nodes = false;
    core->asmqjmps_size = RZ_CORE_ASMQJMPS_NUM;
    if (sizeof(ut64) * core->asmqjmps_size < core->asmqjmps_size) {
        core->asmqjmps_size = 0;
        core->asmqjmps = NULL;
    } else {
        core->asmqjmps = RZ_NEWS(ut64, core->asmqjmps_size);
    }
    core->hash = rz_hash_new();
 
    rz_bin_bind(core->bin, &(core->rasm->binb));
    rz_bin_bind(core->bin, &(core->analysis->binb));
    rz_bin_bind(core->bin, &(core->analysis->binb));
 
    rz_io_bind(core->io, &(core->search->iob));
    rz_io_bind(core->io, &(core->print->iob));
    rz_io_bind(core->io, &(core->analysis->iob));
    rz_io_bind(core->io, &(core->analysis->typedb->iob));
    rz_io_bind(core->io, &(core->bin->iob));
    rz_flag_bind(core->flags, &(core->analysis->flb));
    core->analysis->flg_class_set = core_flg_class_set;
    core->analysis->flg_class_get = core_flg_class_get;
    core->analysis->flg_fcn_set = core_flg_fcn_set;
    rz_analysis_bind(core->analysis, &(core->parser->analb));
    core->parser->flag_get = rz_core_flag_get_by_spaces;
    core->parser->label_get = rz_analysis_function_get_label_at;
 
    rz_core_bind(core, &(core->analysis->coreb));
 
    core->file = NULL;
    core->files = rz_list_newf((RzListFree)rz_core_file_free);
    core->offset = 0LL;
    core->prompt_offset = 0LL;
    rz_core_cmd_init(core);
    rz_core_plugin_init(core);
 
    RzBreakpointContext bp_ctx = {
        .user = core,
        .is_mapped = bp_is_mapped,
        .maps_sync = bp_maps_sync,
        .bits_at = bp_bits_at
    };
    core->dbg = rz_debug_new(&bp_ctx);
 
    rz_io_bind(core->io, &(core->dbg->iob));
    rz_io_bind(core->io, &(core->dbg->bp->iob));
    rz_core_bind(core, &core->dbg->corebind);
    rz_core_bind(core, &core->io->corebind);
    core->dbg->analysis = core->analysis; // XXX: dupped instance.. can cause lost pointerz
    // rz_debug_use (core->dbg, "native");
    //  XXX pushing uninitialized regstate results in trashed reg values
    //  rz_reg_arena_push (core->dbg->reg); // create a 2 level register state stack
    //  core->dbg->analysis->reg = core->analysis->reg; // XXX: dupped instance.. can cause lost pointerz
    core->io->cb_printf = rz_cons_printf;
    core->dbg->cb_printf = rz_cons_printf;
    core->dbg->bp->cb_printf = rz_cons_printf;
    core->dbg->ev = core->ev;
    // initialize config before any corebind
    rz_core_config_init(core);
 
    rz_core_loadlibs_init(core);
 
    // TODO: get arch from rz_bin or from native arch
    rz_asm_use(core->rasm, RZ_SYS_ARCH);
    rz_analysis_use(core->analysis, RZ_SYS_ARCH);
    if (RZ_SYS_BITS & RZ_SYS_BITS_64) {
        rz_config_set_i(core->config, "asm.bits", 64);
    } else {
        if (RZ_SYS_BITS & RZ_SYS_BITS_32) {
            rz_config_set_i(core->config, "asm.bits", 32);
        }
    }
    rz_config_set(core->config, "asm.arch", RZ_SYS_ARCH);
    rz_bp_use(core->dbg->bp, RZ_SYS_ARCH);
    update_sdb(core);
    {
        char *a = rz_path_system(RZ_FLAGS);
        if (a) {
            char *file = rz_file_path_join(a, "tags.rz");
            (void)rz_core_run_script(core, file);
            free(file);
            free(a);
        }
    }
    rz_core_analysis_type_init(core);
    __init_autocomplete(core);
    return 0;
}

References __disasm(), __init_autocomplete(), a, rz_parse_t::analb, rz_core_t::analysis, rz_debug_t::analysis, rz_core_t::asmqjmps, rz_core_t::asmqjmps_size, rz_core_t::bin, rz_analysis_t::binb, rz_asm_t::binb, rz_core_t::block, rz_core_t::blocksize, rz_core_t::blocksize_max, rz_debug_t::bp, bp_bits_at(), bp_is_mapped(), bp_maps_sync(), calloc(), rz_analysis_t::cb, rz_print_t::cb_color, rz_line_t::cb_editor, rz_print_t::cb_eprintf, rz_cons_t::cb_fkey, rz_line_t::cb_fkey, rz_bin_t::cb_printf, rz_bp_t::cb_printf, rz_debug_t::cb_printf, rz_io_t::cb_printf, rz_lang_t::cb_printf, rz_print_t::cb_printf, rz_lang_t::cmd_str, rz_lang_t::cmdf, rz_core_t::cmdfilter, rz_core_t::cmdlog, rz_core_t::cmdqueue, rz_core_t::cmdremote, rz_core_t::cmdrepeat, rz_print_t::colorfor, colorfor_cb(), rz_core_t::config, rz_core_t::cons, rz_print_t::cons, rz_bin_t::consb, rz_print_t::consbind, rz_analysis_t::core, rz_asm_t::core, core_flg_class_get(), core_flg_class_set(), core_flg_fcn_set(), rz_analysis_t::coreb, rz_print_t::coreb, rz_debug_t::corebind, rz_io_t::corebind, rz_core_t::curtheme, rz_core_t::dbg, rz_print_t::disasm, rz_core_t::egg, eprintf, rz_analysis_t::ev, rz_core_t::ev, rz_debug_t::ev, ev_binfiledel_cb(), ev_iodescclose_cb(), ev_iomapdel_cb(), ev_iowrite_cb(), rz_bin_t::event, rz_io_t::event, exists_var(), rz_print_t::exists_var, rz_io_t::ff, rz_core_t::file, rz_core_t::files, rz_core_t::fixedarch, rz_core_t::fixedbits, rz_analysis_t::flag_get, rz_parse_t::flag_get, rz_core_t::flags, rz_analysis_t::flb, rz_analysis_t::flg_class_get, rz_analysis_t::flg_class_set, rz_analysis_t::flg_fcn_set, rz_list_t::free, free(), rz_core_t::gadgets, rz_print_t::get_comments, get_comments_cb(), get_section_name(), rz_print_t::get_section_name, rz_core_t::graph, rz_core_t::hash, rz_print_t::hasrefs, hasrefs_cb(), rz_core_t::http_up, rz_core_t::incomment, int, rz_core_t::io, rz_analysis_t::iob, rz_bin_t::iob, rz_bp_t::iob, rz_debug_t::iob, rz_search_t::iob, rz_type_db_t::iob, rz_print_t::iob, rz_parse_t::label_get, rz_core_t::lang, rz_core_t::lastcmd, rz_core_t::lastsearch, rz_cons_t::line, rz_core_t::max_cmd_depth, mywrite(), rz_ascii_graph_t::need_reload_nodes, NULL, rz_asm_t::num, rz_core_t::num, rz_print_t::num, num_callback(), rz_print_t::offname, rz_core_t::offset, rz_print_t::offsize, on_fcn_delete(), rz_analysis_callbacks_t::on_fcn_delete, on_fcn_new(), rz_analysis_callbacks_t::on_fcn_new, on_fcn_rename(), rz_analysis_callbacks_t::on_fcn_rename, rz_core_t::parser, rz_core_t::print, rz_core_t::printidx, rz_core_t::prompt_offset, rz_core_t::rasm, rz_analysis_t::read_at, rz_cons_t::refcnt, rz_core_t::root_cmd_descriptor, rz_core_t::ropchain, rz_core_t::rtr_n, rz_agraph_new(), rz_analysis_bind(), rz_analysis_function_get_label_at(), rz_analysis_function_get_var_fields(), rz_analysis_new(), rz_analysis_use(), rz_asm_new(), rz_asm_use(), rz_bin_bind(), rz_bin_new(), rz_bin_set_user_ptr(), rz_bp_use(), rz_buf_new_with_bytes(), rz_config_set(), rz_config_set_i(), rz_cons_bind(), rz_cons_canvas_new(), RZ_CONS_CMD_DEPTH, rz_cons_new(), rz_cons_printf(), rz_cons_rainbow_get(), rz_cons_singleton(), rz_core_analysis_read_at(), rz_core_analysis_type_init(), RZ_CORE_ASMQJMPS_NUM, rz_core_bind(), rz_core_bind_cons(), RZ_CORE_BLOCKSIZE, RZ_CORE_BLOCKSIZE_MAX, rz_core_cmd_init(), rz_core_cmd_str(), rz_core_cmdf(), rz_core_cmpwatch_free(), rz_core_config_init(), rz_core_editor(), rz_core_fgets(), rz_core_file_free(), rz_core_flag_get_by_spaces(), rz_core_gadget_free(), rz_core_io_plugin_vfile, rz_core_loadlibs_init(), rz_core_plugin_init(), rz_core_print_offname(), rz_core_print_offsize(), rz_core_rtr_init(), rz_core_run_script(), rz_core_seek_reset(), rz_core_task_break_cb(), rz_core_task_ctx_switch(), rz_core_task_scheduler_init(), rz_debug_new(), rz_egg_new(), rz_egg_setup(), RZ_EVENT_BIN_FILE_DEL, rz_event_hook(), RZ_EVENT_IO_DESC_CLOSE, RZ_EVENT_IO_MAP_DEL, RZ_EVENT_IO_WRITE, rz_event_new(), rz_file_path_join(), rz_flag_bind(), rz_flag_new(), RZ_FLAGS, rz_hash_new(), rz_io_bind(), rz_io_new(), rz_io_plugin_add(), rz_lang_define(), rz_lang_new(), rz_lang_set_user_ptr(), rz_line_hist_load(), rz_list_new(), rz_list_newf(), RZ_NEW0, RZ_NEWS, rz_num_new(), rz_parse_new(), rz_parse_set_user_ptr(), rz_path_home_history(), rz_path_system(), rz_print_new(), RZ_SEARCH_KEYWORD, rz_search_new(), RZ_SYS_ARCH, RZ_SYS_BITS, RZ_SYS_BITS_32, RZ_SYS_BITS_64, RZ_SYS_OS, rz_syscall_ref(), rz_core_t::scriptstack, rz_core_t::sdb, sdb_new(), rz_core_t::search, rz_core_t::stkcmd, str_callback(), strdup(), rz_core_t::switch_file_view, rz_analysis_t::syscall, rz_asm_t::syscall, rz_core_t::tasks, rz_core_t::times, rz_analysis_t::typedb, update_sdb(), rz_print_t::use_comments, rz_bp_context_t::user, rz_line_t::user, rz_print_t::user, rz_cons_t::user_fgets, rz_cons_t::user_fgets_user, ut64(), rz_parse_t::varlist, rz_core_t::visual_inputing, rz_core_t::visual_is_inputing, rz_core_t::vmode, rz_core_t::watchers, rz_print_t::write, rz_core_t::yank_buf, and ZERO_FILL.

Referenced by open_core_file(), rz_core_new(), and rz_main_rz_bin().

rz_core_is_project()

bool rz_core_is_project	(	RzCore *	core,
		const char *	name
	)

rz_core_ncast()

RZ_API RzCore* rz_core_ncast

(

ut64

p

)

Definition at line 392 of file core.c.

                                     {
    return (RzCore *)(size_t)p;
}

References p.

rz_core_new()

RZ_API RzCore* rz_core_new

(

void

)

Definition at line 866 of file core.c.

                                 {
    RzCore *c = RZ_NEW0(RzCore);
    if (c) {
        rz_core_init(c);
    }
    return c;
}

References c, rz_core_init(), and RZ_NEW0.

Referenced by rz_diff_hex_visual(), rz_diff_load_file_with_core(), rz_main_rizin(), rz_main_rz_asm(), and rz_main_rz_sign().

rz_core_notify_begin()

RZ_API void rz_core_notify_begin	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const char *	format,
			...
	)

Prints a message definining the beginning of a task.

Parameters

core	The RzCore to use
format	The message to notify

Definition at line 33 of file core.c.

                                                                                              {
    rz_return_if_fail(core && format);
    va_list args;
    bool use_color = rz_config_get_i(core->config, "scr.color") > 0;
    bool verbose = rz_config_get_b(core->config, "scr.prompt");
    if (!verbose) {
        return;
    }
    va_start(args, format);
    if (use_color) {
        fprintf(stderr, "[ ] " Color_YELLOW);
        vfprintf(stderr, format, args);
        fprintf(stderr, "\r[" Color_RESET);
    } else {
        fprintf(stderr, "[ ] ");
        vfprintf(stderr, format, args);
        fprintf(stderr, "\r[");
    }
    va_end(args);
}

References args, Color_RESET, Color_YELLOW, rz_config_get_b(), rz_config_get_i(), rz_return_if_fail, and verbose.

Referenced by core_perform_auto_analysis(), objc_analyze(), objc_find_refs(), rz_core_analysis_everything(), rz_core_analysis_recover_golang_functions(), and rz_core_analysis_resolve_golang_strings().

rz_core_notify_done()

RZ_API void rz_core_notify_done	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const char *	format,
			...
	)

Prints a message definining the end of a task which succeeded.

Parameters

core	The RzCore to use
format	The message to notify

Definition at line 60 of file core.c.

                                                                                             {
    rz_return_if_fail(core && format);
    va_list args;
    bool use_color = rz_config_get_i(core->config, "scr.color") > 0;
    bool verbose = rz_config_get_b(core->config, "scr.prompt");
    if (!verbose) {
        return;
    }
    va_start(args, format);
    if (use_color) {
        fprintf(stderr, "\r" Color_GREEN "[x]" Color_RESET " ");
        vfprintf(stderr, format, args);
        fprintf(stderr, "\n");
    } else {
        fprintf(stderr, "\r[x] ");
        vfprintf(stderr, format, args);
        fprintf(stderr, "\n");
    }
    va_end(args);
}

References args, Color_GREEN, Color_RESET, rz_config_get_b(), rz_config_get_i(), rz_return_if_fail, and verbose.

Referenced by core_perform_auto_analysis(), core_recover_golang_functions_go_1_16(), core_recover_golang_functions_go_1_18(), core_recover_golang_functions_go_1_2(), objc_analyze(), objc_find_refs(), rz_core_analysis_everything(), rz_core_analysis_recover_golang_functions(), rz_core_analysis_resolve_golang_strings(), and rz_core_analysis_value_pointers().

rz_core_notify_error()

RZ_API void rz_core_notify_error	(	RZ_NONNULL RzCore *	core,
		RZ_NONNULL const char *	format,
			...
	)

Prints a message definining the end of a task which errored.

Parameters

core	The RzCore to use
format	The message to notify

Definition at line 87 of file core.c.

                                                                                              {
    rz_return_if_fail(core && format);
    va_list args;
    bool use_color = rz_config_get_i(core->config, "scr.color") > 0;
    bool verbose = rz_config_get_b(core->config, "scr.prompt");
    if (!verbose) {
        return;
    }
    va_start(args, format);
    if (use_color) {
        fprintf(stderr, "\r" Color_RED "[!]" Color_RESET " ");
        vfprintf(stderr, format, args);
        fprintf(stderr, "\n");
    } else {
        fprintf(stderr, "\r[!] ");
        vfprintf(stderr, format, args);
        fprintf(stderr, "\n");
    }
    va_end(args);
}

References args, Color_RED, Color_RESET, rz_config_get_b(), rz_config_get_i(), rz_return_if_fail, and verbose.

Referenced by core_recover_golang_functions_go_1_16(), core_recover_golang_functions_go_1_18(), core_recover_golang_functions_go_1_2(), rz_core_analysis_recover_golang_functions(), and rz_core_analysis_resolve_golang_strings().

rz_core_op_analysis()

RZ_API RzAnalysisOp* rz_core_op_analysis	(	RzCore *	core,
		ut64	addr,
		RzAnalysisOpMask	mask
	)

Definition at line 2880 of file core.c.

                                                                                         {
    ut8 buf[64];
    RzAnalysisOp *op = RZ_NEW(RzAnalysisOp);
    rz_io_read_at(core->io, addr, buf, sizeof(buf));
    rz_analysis_op(core->analysis, op, addr, buf, sizeof(buf), mask);
    return op;
}

References addr, rz_core_t::analysis, rz_core_t::io, mask, op, rz_analysis_op(), rz_io_read_at(), and RZ_NEW.

Referenced by analyze_noreturn_function(), is_repeatable_inst(), rz_cmd_debug_trace_add_handler(), and rz_core_analysis_propagate_noreturn().

rz_core_op_str()

RZ_API char* rz_core_op_str	(	RzCore *	core,
		ut64	addr
	)

Definition at line 2869 of file core.c.

                                                     {
    RzAsmOp op = { 0 };
    ut8 buf[64];
    rz_asm_set_pc(core->rasm, addr);
    rz_io_read_at(core->io, addr, buf, sizeof(buf));
    int ret = rz_asm_disassemble(core->rasm, &op, buf, sizeof(buf));
    char *str = (ret > 0) ? strdup(rz_strbuf_get(&op.buf_asm)) : NULL;
    rz_asm_op_fini(&op);
    return str;
}

References addr, rz_core_t::io, NULL, rz_core_t::rasm, rz_asm_disassemble(), rz_asm_op_fini(), rz_asm_set_pc(), rz_io_read_at(), rz_strbuf_get(), cmd_descs_generate::str, and strdup().

Referenced by do_analysis_search().

rz_core_print_offname()

static const char* rz_core_print_offname ( void *  p, ut64  addr  )

static

Definition at line 1717 of file core.c.

                                                             {
    RzCore *c = (RzCore *)p;
    RzFlagItem *item = rz_flag_get_i(c->flags, addr);
    return item ? item->name : NULL;
}

References addr, c, rz_flag_item_t::name, NULL, p, and rz_flag_get_i().

Referenced by rz_core_init().

rz_core_print_offsize()

static int rz_core_print_offsize ( void *  p, ut64  addr  )

static

Definition at line 1723 of file core.c.

                                                     {
    RzCore *c = (RzCore *)p;
    RzFlagItem *item = rz_flag_get_i(c->flags, addr);
    return item ? item->size : -1;
}

References addr, c, p, rz_flag_get_i(), and rz_flag_item_t::size.

Referenced by rz_core_init().

rz_core_prompt()

RZ_API int rz_core_prompt	(	RzCore *	r,
		int	sync
	)

Definition at line 2805 of file core.c.

                                               {
    char line[4096];
 
    int rnv = r->num->value;
    set_prompt(r);
    int ret = rz_cons_fgets(line, sizeof(line), 0, NULL);
    if (ret == -2) {
        return RZ_CORE_CMD_EXIT; // ^D
    }
    if (ret == -1) {
        return false; // FD READ ERROR
    }
    r->num->value = rnv;
    if (sync) {
        return rz_core_prompt_exec(r);
    }
    free(r->cmdqueue);
    r->cmdqueue = strdup(line);
    if (r->scr_gadgets && *line && *line != 'q') {
        rz_core_gadget_print(r);
    }
    r->num->value = r->rc;
    return true;
}

References free(), setup::line, NULL, r, rz_cons_fgets(), RZ_CORE_CMD_EXIT, rz_core_gadget_print(), rz_core_prompt_exec(), set_prompt(), and strdup().

Referenced by rz_core_prompt_loop().

rz_core_prompt_exec()

RZ_API int rz_core_prompt_exec

(

RzCore *

r

)

Definition at line 2830 of file core.c.

                                          {
    int ret = rz_core_cmd(r, r->cmdqueue, true);
    r->rc = r->num->value;
    // int ret = rz_core_cmd (r, r->cmdqueue, true);
    rz_cons_echo(NULL);
    rz_cons_flush();
    if (r->cons && r->cons->line && r->cons->line->zerosep) {
        rz_cons_zero();
    }
    return ret;
}

References NULL, r, rz_cons_echo(), rz_cons_flush(), rz_cons_zero(), and rz_core_cmd().

Referenced by rz_core_prompt(), and rz_core_prompt_loop().

rz_core_prompt_loop()

RZ_API void rz_core_prompt_loop

(

RzCore *

r

)

Definition at line 2688 of file core.c.

                                           {
    int ret;
    do {
        if (rz_config_get_b(r->config, "dbg.status")) {
            rz_core_debug_print_status(r);
        }
        int err = rz_core_prompt(r, false);
        if (err < 1) {
            // handle ^D
            r->num->value = 0; // r.num->value will be read by rz_main_rizin() after calling this fcn
            break;
        }
        /* -1 means invalid command, -2 means quit prompt loop */
        if ((ret = rz_core_prompt_exec(r)) == -2) {
            break;
        }
    } while (ret != RZ_CORE_CMD_EXIT);
}

References err, r, rz_config_get_b(), RZ_CORE_CMD_EXIT, rz_core_debug_print_status(), rz_core_prompt(), and rz_core_prompt_exec().

Referenced by rz_main_rizin().

rz_core_search_cb()

RZ_API int rz_core_search_cb	(	RzCore *	core,
		ut64	from,
		ut64	to,
		RzCoreSearchCallback	cb
	)

Definition at line 3184 of file core.c.

                                                                                        {
    int ret, len = core->blocksize;
    ut8 *buf = malloc(len);
    if (!buf) {
        eprintf("Cannot allocate blocksize\n");
        return false;
    }
    while (from < to) {
        ut64 delta = to - from;
        if (delta < len) {
            len = (int)delta;
        }
        if (!rz_io_read_at(core->io, from, buf, len)) {
            eprintf("Cannot read at 0x%" PFMT64x "\n", from);
            break;
        }
        for (ret = 0; ret < len;) {
            int done = cb(core, from, buf + ret, len - ret);
            if (done < 1) { /* interrupted */
                free(buf);
                return false;
            }
            ret += done;
        }
        from += len;
    }
    free(buf);
    return true;
}

References rz_core_t::blocksize, cb, delta, done, eprintf, free(), from, int, rz_core_t::io, len, malloc(), PFMT64x, rz_io_read_at(), to, and ut64().

rz_core_serve()

RZ_API bool rz_core_serve	(	RzCore *	core,
		RzIODesc *	file
	)

Definition at line 2904 of file core.c.

                                                        {
    // TODO: use rz_socket_rap_server API instead of duplicating the logic
    ut8 cmd, flg, *ptr = NULL, buf[1024];
    int i, pipefd = -1;
    ut64 x;
 
    RzIORap *rior = (RzIORap *)file->data;
    if (!rior || !rior->fd) {
        eprintf("rap: cannot listen.\n");
        return false;
    }
    RzSocket *fd = rior->fd;
    eprintf("RAP Server started (rap.loop=%s)\n",
        rz_config_get(core->config, "rap.loop"));
    rz_cons_break_push(rap_break, rior);
reaccept:
    while (!rz_cons_is_breaked()) {
        RzSocket *c = rz_socket_accept(fd);
        if (!c) {
            break;
        }
        if (rz_cons_is_breaked()) {
            goto out_of_function;
        }
        if (!c) {
            eprintf("rap: cannot accept\n");
            rz_socket_free(c);
            goto out_of_function;
        }
        eprintf("rap: client connected\n");
        for (; !rz_cons_is_breaked();) {
            if (!rz_socket_read_block(c, &cmd, 1)) {
                eprintf("rap: connection closed\n");
                if (rz_config_get_i(core->config, "rap.loop")) {
                    eprintf("rap: waiting for new connection\n");
                    rz_socket_free(c);
                    goto reaccept;
                }
                goto out_of_function;
            }
            switch (cmd) {
            case RAP_PACKET_OPEN:
                rz_socket_read_block(c, &flg, 1); // flags
                eprintf("open (%d): ", cmd);
                rz_socket_read_block(c, &cmd, 1); // len
                pipefd = -1;
                if (UT8_ADD_OVFCHK(cmd, 1)) {
                    goto out_of_function;
                }
                ptr = malloc((size_t)cmd + 1);
                if (!ptr) {
                    eprintf("Cannot malloc in rmt-open len = %d\n", cmd);
                } else {
                    ut64 baddr = rz_config_get_i(core->config, "bin.laddr");
                    rz_socket_read_block(c, ptr, cmd);
                    ptr[cmd] = 0;
                    ut32 perm = RZ_PERM_R;
                    if (flg & RZ_PERM_W) {
                        perm |= RZ_PERM_W;
                    }
                    if (rz_core_file_open(core, (const char *)ptr, perm, 0)) {
                        int fd = rz_io_fd_get_current(core->io);
                        rz_core_bin_load(core, NULL, baddr);
                        rz_io_map_add(core->io, fd, perm, 0, 0, rz_io_fd_size(core->io, fd));
                        if (core->file) {
                            pipefd = fd;
                        } else {
                            pipefd = -1;
                        }
                        eprintf("(flags: %d) len: %d filename: '%s'\n",
                            flg, cmd, ptr); // config.file);
                    } else {
                        eprintf("Cannot open file (%s)\n", ptr);
                        rz_socket_close(c);
                        if (rz_config_get_i(core->config, "rap.loop")) {
                            eprintf("rap: waiting for new connection\n");
                            rz_socket_free(c);
                            goto reaccept;
                        }
                        goto out_of_function; // XXX: Close connection and goto accept
                    }
                }
                buf[0] = RAP_PACKET_OPEN | RAP_PACKET_REPLY;
                rz_write_be32(buf + 1, pipefd);
                rz_socket_write(c, buf, 5);
                rz_socket_flush(c);
                RZ_FREE(ptr);
                break;
            case RAP_PACKET_READ:
                rz_socket_read_block(c, (ut8 *)&buf, 4);
                i = rz_read_be32(buf);
                ptr = (ut8 *)malloc(i + core->blocksize + 5);
                if (ptr) {
                    rz_core_block_read(core);
                    ptr[0] = RAP_PACKET_READ | RAP_PACKET_REPLY;
                    if (i > RAP_PACKET_MAX) {
                        i = RAP_PACKET_MAX;
                    }
                    if (i > core->blocksize) {
                        rz_core_block_size(core, i);
                    }
                    if (i + 128 < core->blocksize) {
                        rz_core_block_size(core, i);
                    }
                    rz_write_be32(ptr + 1, i);
                    memcpy(ptr + 5, core->block, i); // core->blocksize);
                    rz_socket_write(c, ptr, i + 5);
                    rz_socket_flush(c);
                    RZ_FREE(ptr);
                } else {
                    eprintf("Cannot read %d byte(s)\n", i);
                    rz_socket_free(c);
                    // TODO: reply error here
                    goto out_of_function;
                }
                break;
            case RAP_PACKET_CMD: {
                char *cmd = NULL, *cmd_output = NULL;
                char bufr[8], *bufw = NULL;
                ut32 cmd_len = 0;
                int i;
 
                /* read */
                rz_socket_read_block(c, (ut8 *)&bufr, 4);
                i = rz_read_be32(bufr);
                if (i > 0 && i < RAP_PACKET_MAX) {
                    if ((cmd = malloc(i + 1))) {
                        rz_socket_read_block(c, (ut8 *)cmd, i);
                        cmd[i] = '\0';
                        int scr_interactive = rz_config_get_i(core->config, "scr.interactive");
                        rz_config_set_i(core->config, "scr.interactive", 0);
                        cmd_output = rz_core_cmd_str(core, cmd);
                        rz_config_set_i(core->config, "scr.interactive", scr_interactive);
                        free(cmd);
                    } else {
                        eprintf("rap: cannot malloc\n");
                    }
                } else {
                    eprintf("rap: invalid length '%d'\n", i);
                }
                /* write */
                if (cmd_output) {
                    cmd_len = strlen(cmd_output) + 1;
                } else {
                    cmd_output = strdup("");
                    cmd_len = 0;
                }
#if DEMO_SERVER_SENDS_CMD_TO_CLIENT
                static bool once = true;
                /* TODO: server can reply a command request to the client only here */
                if (once) {
                    const char *cmd = "pd 4";
                    int cmd_len = strlen(cmd) + 1;
                    ut8 *b = malloc(cmd_len + 5);
                    b[0] = RAP_PACKET_CMD;
                    rz_write_be32(b + 1, cmd_len);
                    strcpy((char *)b + 5, cmd);
                    rz_socket_write(c, b, 5 + cmd_len);
                    rz_socket_flush(c);
 
                    /* read response */
                    rz_socket_read_block(c, b, 5);
                    if (b[0] == (RAP_PACKET_CMD | RAP_PACKET_REPLY)) {
                        ut32 n = rz_read_be32(b + 1);
                        eprintf("REPLY %d\n", n);
                        if (n > 0) {
                            ut8 *res = calloc(1, n);
                            rz_socket_read_block(c, res, n);
                            eprintf("RESPONSE(%s)\n", (const char *)res);
                            free(res);
                        }
                    }
                    rz_socket_flush(c);
                    free(b);
                    once = false;
                }
#endif
                bufw = malloc(cmd_len + 5);
                bufw[0] = (ut8)(RAP_PACKET_CMD | RAP_PACKET_REPLY);
                rz_write_be32(bufw + 1, cmd_len);
                memcpy(bufw + 5, cmd_output, cmd_len);
                rz_socket_write(c, bufw, cmd_len + 5);
                rz_socket_flush(c);
                free(bufw);
                free(cmd_output);
                break;
            }
            case RAP_PACKET_WRITE:
                rz_socket_read_block(c, buf, 4);
                x = rz_read_at_be32(buf, 0);
                ptr = malloc(x);
                rz_socket_read_block(c, ptr, x);
                int ret = rz_core_write_at(core, core->offset, ptr, x);
                buf[0] = RAP_PACKET_WRITE | RAP_PACKET_REPLY;
                rz_write_be32(buf + 1, ret);
                rz_socket_write(c, buf, 5);
                rz_socket_flush(c);
                RZ_FREE(ptr);
                break;
            case RAP_PACKET_SEEK:
                rz_socket_read_block(c, buf, 9);
                x = rz_read_at_be64(buf, 1);
                if (buf[0] == 2) {
                    if (core->file) {
                        x = rz_io_fd_size(core->io, core->file->fd);
                    } else {
                        x = 0;
                    }
                } else {
                    if (buf[0] == 0) {
                        rz_core_seek(core, x, true); // buf[0]);
                    }
                    x = core->offset;
                }
                buf[0] = RAP_PACKET_SEEK | RAP_PACKET_REPLY;
                rz_write_be64(buf + 1, x);
                rz_socket_write(c, buf, 9);
                rz_socket_flush(c);
                break;
            case RAP_PACKET_CLOSE:
                // XXX : proper shutdown
                rz_socket_read_block(c, buf, 4);
                i = rz_read_be32(buf);
                {
                    // FIXME: Use rz_socket_close
                    int ret = close(i);
                    rz_write_be32(buf + 1, ret);
                    buf[0] = RAP_PACKET_CLOSE | RAP_PACKET_REPLY;
                    rz_socket_write(c, buf, 5);
                    rz_socket_flush(c);
                }
                break;
            default:
                if (cmd == 'G') {
                    // silly http emulation over rap://
                    char line[256] = { 0 };
                    rz_socket_read_block(c, (ut8 *)line, sizeof(line));
                    if (!strncmp(line, "ET /cmd/", 8)) {
                        char *cmd = line + 8;
                        char *http = strstr(cmd, "HTTP");
                        if (http) {
                            *http = 0;
                            http--;
                            if (*http == ' ') {
                                *http = 0;
                            }
                        }
                        rz_str_uri_decode(cmd);
                        char *res = rz_core_cmd_str(core, cmd);
                        if (res) {
                            rz_socket_printf(c, "HTTP/1.0 %d %s\r\n%s"
                                        "Connection: close\r\nContent-Length: %d\r\n\r\n",
                                200, "OK", "", -1); // strlen (res));
                            rz_socket_write(c, res, strlen(res));
                            free(res);
                        }
                        rz_socket_flush(c);
                        rz_socket_close(c);
                    }
                } else {
                    eprintf("[rap] unknown command 0x%02x\n", cmd);
                    rz_socket_close(c);
                    RZ_FREE(ptr);
                }
                if (rz_config_get_i(core->config, "rap.loop")) {
                    eprintf("rap: waiting for new connection\n");
                    rz_socket_free(c);
                    goto reaccept;
                }
                goto out_of_function;
            }
        }
        eprintf("client: disconnected\n");
        rz_socket_free(c);
    }
out_of_function:
    rz_cons_break_pop();
    return false;
}

References b, baddr(), rz_core_t::block, rz_core_t::blocksize, c, calloc(), close, cmd, rz_core_t::config, eprintf, fd, RzIORap::fd, rz_core_file_t::fd, rz_core_t::file, free(), i, if(), rz_core_t::io, setup::line, malloc(), memcpy(), n, NULL, rz_core_t::offset, once, rap_break(), RAP_PACKET_CLOSE, RAP_PACKET_CMD, RAP_PACKET_MAX, RAP_PACKET_OPEN, RAP_PACKET_READ, RAP_PACKET_REPLY, RAP_PACKET_SEEK, RAP_PACKET_WRITE, rz_config_get(), rz_config_get_i(), rz_config_set_i(), rz_cons_break_pop(), rz_cons_break_push(), rz_cons_is_breaked(), rz_core_bin_load(), rz_core_block_read(), rz_core_block_size(), rz_core_cmd_str(), rz_core_file_open(), rz_core_seek(), rz_core_write_at(), RZ_FREE, rz_io_fd_get_current(), rz_io_fd_size(), rz_io_map_add(), RZ_PERM_R, RZ_PERM_W, rz_read_at_be32(), rz_read_at_be64(), rz_read_be32(), rz_socket_accept(), rz_socket_close(), rz_socket_flush(), rz_socket_free(), rz_socket_printf(), rz_socket_read_block(), rz_socket_write(), rz_str_uri_decode(), rz_write_be32(), rz_write_be64(), strdup(), ut64(), ut8, UT8_ADD_OVFCHK, and x.

Referenced by rz_core_file_open(), and rz_core_rtr_rap_run().

rz_core_set_asmqjmps()

RZ_API void rz_core_set_asmqjmps	(	RzCore *	core,
		char *	str,
		size_t	len,
		int	pos
	)

Definition at line 282 of file core.c.

                                                                               {
    if (core->is_asmqjmps_letter) {
        int i, j = 0;
        // if (pos > 0) {
        pos--;
        for (i = 0; i < RZ_CORE_ASMQJMPS_LEN_LETTERS - 1; i++) {
            int div = pos / letter_divs[i];
            pos %= letter_divs[i];
            if (div > 0 && j < len) {
                str[j++] = 'A' + div - 1;
            }
        }
        if (j < len) {
            int div = pos % RZ_CORE_ASMQJMPS_LETTERS;
            str[j++] = 'a' + div;
        }
        str[j] = '\0';
    } else {
        snprintf(str, len, "%d", pos);
    }
}

References i, rz_core_t::is_asmqjmps_letter, len, letter_divs, pos, RZ_CORE_ASMQJMPS_LEN_LETTERS, RZ_CORE_ASMQJMPS_LETTERS, snprintf, and cmd_descs_generate::str.

Referenced by rz_core_add_asmqjmp().

rz_core_sleep_begin()

static void* rz_core_sleep_begin ( RzCore *  core )

static

Definition at line 2155 of file core.c.

                                               {
    RzCoreTask *task = rz_core_task_self(&core->tasks);
    if (task) {
        rz_core_task_sleep_begin(task);
    }
    return task;
}

References rz_core_task_self(), rz_core_task_sleep_begin(), and rz_core_t::tasks.

Referenced by rz_core_bind_cons().

rz_core_sleep_end()

static void rz_core_sleep_end ( RzCore *  core, void *  user  )

static

Definition at line 2163 of file core.c.

                                                        {
    RzCoreTask *task = (RzCoreTask *)user;
    if (task) {
        rz_core_task_sleep_end(task);
    }
}

References rz_core_task_sleep_end().

Referenced by rz_core_bind_cons().

rz_core_syscall()

RZ_API RzBuffer* rz_core_syscall	(	RzCore *	core,
		const char *	name,
		const char *	args
	)

XXX USE trap

Definition at line 3305 of file core.c.

                                                                                   {
    RzBuffer *b = NULL;
    char code[1024];
    int num;
 
    // arch check
    if (strcmp(core->analysis->cur->arch, "x86")) {
        eprintf("architecture not yet supported!\n");
        return 0;
    }
 
    num = rz_syscall_get_num(core->analysis->syscall, name);
 
    // bits check
    switch (core->rasm->bits) {
    case 32:
        if (strcmp(name, "setup") && !num) {
            eprintf("syscall not found!\n");
            return 0;
        }
        break;
    case 64:
        if (strcmp(name, "read") && !num) {
            eprintf("syscall not found!\n");
            return 0;
        }
        break;
    default:
        eprintf("syscall not found!\n");
        return 0;
    }
 
    snprintf(code, sizeof(code),
        "sc@syscall(%d);\n"
        "main@global(0) { sc(%s);\n"
        ":int3\n" 
        "}\n",
        num, args);
    rz_egg_reset(core->egg);
    // TODO: setup arch/bits/os?
    rz_egg_load(core->egg, code, 0);
 
    if (!rz_egg_compile(core->egg)) {
        eprintf("Cannot compile.\n");
    }
    if (!rz_egg_assemble(core->egg)) {
        eprintf("rz_egg_assemble: invalid assembly\n");
    }
    if ((b = rz_egg_get_bin(core->egg))) {
#if 0
        if (b->length > 0) {
            for (i = 0; i < b->length; i++) {
                rz_cons_printf ("%02x", b->buf[i]);
            }
            rz_cons_printf ("\n");
        }
#endif
    }
    return b;
}

References rz_core_t::analysis, rz_analysis_plugin_t::arch, args, b, rz_asm_t::bits, rz_analysis_t::cur, rz_core_t::egg, eprintf, i, NULL, num, rz_core_t::rasm, rz_cons_printf(), rz_egg_assemble(), rz_egg_compile(), rz_egg_get_bin(), rz_egg_load(), rz_egg_reset(), rz_syscall_get_num(), snprintf, and rz_analysis_t::syscall.

Referenced by rz_cmd_debug(), rz_core_syscallf(), and rz_egg_syscall_handler().

rz_core_syscallf()

RZ_API RzBuffer* rz_core_syscallf	(	RzCore *	core,
		const char *	name,
		const char *	fmt,
			...
	)

Definition at line 3292 of file core.c.

                                                                                        {
    char str[1024];
    RzBuffer *buf;
    va_list ap;
    va_start(ap, fmt);
 
    vsnprintf(str, sizeof(str), fmt, ap);
    buf = rz_core_syscall(core, name, str);
 
    va_end(ap);
    return buf;
}

References buf, rz_core_syscall(), cmd_descs_generate::str, and vsnprintf.

Referenced by rz_cmd_debug().

rz_core_table()

RZ_API RzTable* rz_core_table

(

RzCore *

core

)

Definition at line 3449 of file core.c.

                                            {
    RzTable *table = rz_table_new();
    if (table) {
        table->cons = core->cons;
    }
    return table;
}

References rz_core_t::cons, RzTable::cons, and rz_table_new().

Referenced by cmd_print_blocks(), references_handler(), rz_analysis_function_list_ascii_handler(), rz_cmd_info_section_bars_handler(), rz_core_analysis_bbs_asciiart(), rz_open_binary_list_ascii_handler(), and rz_open_maps_list_ascii_handler().

rz_core_task_break_cb()

RZ_IPI void rz_core_task_break_cb	(	RzCoreTask *	task,
		void *	user
	)

Definition at line 738 of file task.c.

                                                                {
    CoreTaskCtx *ctx = task->runner_user;
    rz_cons_context_break(ctx ? ctx->cons_context : NULL);
}

References NULL, and rz_cons_context_break().

Referenced by rz_core_init().

rz_core_task_ctx_switch()

RZ_IPI void rz_core_task_ctx_switch	(	RzCoreTask *	next,
		void *	user
	)

Definition at line 727 of file task.c.

                                                                  {
    if (next->runner_user) {
        CoreTaskCtx *ctx = next->runner_user;
        if (ctx->cons_context) {
            rz_cons_context_load(ctx->cons_context);
            return;
        }
    }
    rz_cons_context_reset();
}

References rz_cons_context_load(), and rz_cons_context_reset().

Referenced by rz_core_init().

rz_core_vfile_bin_file_deleted()

RZ_IPI void rz_core_vfile_bin_file_deleted	(	RzCore *	core,
		RzBinFile *	bf
	)

Definition at line 156 of file cvfile.c.

                                                                        {
    // close all vfile descs that point into the binfile that is about to be closed
    // This is strictly necessary because VFileCtx holds pointers into it!
    RzList *descs = rz_id_storage_list(core->io->files);
    if (!descs) {
        return;
    }
    RzListIter *it;
    RzIODesc *desc;
    rz_list_foreach (descs, it, desc) {
        if (strcmp(desc->plugin->name, rz_core_io_plugin_vfile.name)) {
            continue;
        }
        VFileCtx *ctx = desc->data;
        if (ctx->bf == bf) {
            rz_io_desc_close(desc);
        }
    }
    rz_list_free(descs);
}

References desc, rz_io_t::files, rz_core_t::io, rz_io_plugin_t::name, rz_core_io_plugin_vfile, rz_id_storage_list(), rz_io_desc_close(), and rz_list_free().

Referenced by ev_binfiledel_cb().

RZ_LIB_VERSION()

RZ_LIB_VERSION

(

rz_core

)

rzshell_autocomplete()

static RzLineNSCompletionResult* rzshell_autocomplete ( RzLineBuffer *  buf, RzLinePromptType  prompt_type, void *  user  )

static

Definition at line 1690 of file core.c.

                                                                                                                   {
    return rz_core_autocomplete_rzshell((RzCore *)user, buf, prompt_type);
}

References rz_core_autocomplete_rzshell().

Referenced by rz_core_fgets().

set_prompt()

static void set_prompt ( RzCore *  r )

static

Definition at line 2770 of file core.c.

                                  {
    const char *cmdprompt = rz_config_get(r->config, "cmd.prompt");
    const char *BEGIN = "";
    const char *END = "";
    const char *remote = "";
 
    if (cmdprompt && *cmdprompt) {
        rz_core_cmd(r, cmdprompt, 0);
    }
 
    if (r->cmdremote) {
        char *s = rz_core_cmd_str(r, "s");
        r->offset = rz_num_math(NULL, s);
        free(s);
        remote = "R!";
    }
 
    if (rz_config_get_i(r->config, "scr.color")) {
        BEGIN = r->cons->context->pal.prompt;
        END = r->cons->context->pal.reset;
    }
 
    RzStrBuf prompt_ct;
    rz_strbuf_init(&prompt_ct);
    rz_strbuf_appendf(&prompt_ct, "%s[%s", BEGIN, remote);
    bool added = prompt_add_file(r, &prompt_ct, false);
    added = prompt_add_section(r, &prompt_ct, added);
    added = prompt_add_offset(r, &prompt_ct, added);
    rz_strbuf_appendf(&prompt_ct, "]>%s ", END);
 
    char *prompt = rz_strbuf_drain_nofree(&prompt_ct);
    rz_line_set_prompt(prompt);
    free(prompt);
}

References free(), NULL, prompt(), prompt_add_file(), prompt_add_offset(), prompt_add_section(), r, rz_config_get(), rz_config_get_i(), rz_core_cmd(), rz_core_cmd_str(), rz_line_set_prompt(), rz_num_math(), rz_strbuf_appendf(), rz_strbuf_drain_nofree(), rz_strbuf_init(), and s.

Referenced by rz_core_prompt().

setab()

static void setab ( RzCore *  core, const char *  arch, int  bits  )

static

Definition at line 305 of file core.c.

                                                            {
    if (arch) {
        rz_config_set(core->config, "asm.arch", arch);
    }
    if (bits > 0) {
        rz_config_set_i(core->config, "asm.bits", bits);
    }
}

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

Referenced by rz_core_bind().

str_callback()

static const char* str_callback ( RzNum *  user, ut64  off, int *  ok  )

static

Definition at line 484 of file core.c.

                                                                {
    RzFlag *f = (RzFlag *)user;
    if (ok) {
        *ok = 0;
    }
    if (f) {
        RzFlagItem *item = rz_flag_get_i(f, off);
        if (item) {
            if (ok) {
                *ok = true;
            }
            return item->name;
        }
    }
    return NULL;
}

References f, rz_flag_item_t::name, NULL, off, ok, and rz_flag_get_i().

Referenced by rz_core_init().

update_sdb()

static void update_sdb ( RzCore *  core )

static

Definition at line 1743 of file core.c.

                                     {
    Sdb *d;
    RzBinObject *o;
    if (!core) {
        return;
    }
    // SDB// analysis/
    if (core->analysis && core->analysis->sdb) {
        sdb_ns_set(DB, "analysis", core->analysis->sdb);
    }
    // SDB// bin/
    if (core->bin && core->bin->sdb) {
        sdb_ns_set(DB, "bin", core->bin->sdb);
    }
    // SDB// bin/info
    o = rz_bin_cur_object(core->bin);
    if (o) {
        sdb_ns_set(sdb_ns(DB, "bin", 1), "info", o->kv);
    }
    // sdb_ns_set (core->sdb, "flags", core->flags->sdb);
    // sdb_ns_set (core->sdb, "bin", core->bin->sdb);
    // SDB// syscall/
    if (core->rasm && core->rasm->syscall && core->rasm->syscall->db) {
        sdb_ns_set(DB, "syscall", core->rasm->syscall->db);
    }
    d = sdb_ns(DB, "debug", 1);
    if (core->dbg->sgnls) {
        sdb_ns_set(d, "signals", core->dbg->sgnls);
    }
}

References rz_core_t::analysis, rz_core_t::bin, d, DB, rz_syscall_t::db, rz_core_t::dbg, rz_bin_object_t::kv, rz_core_t::rasm, rz_bin_cur_object(), rz_analysis_t::sdb, rz_bin_t::sdb, sdb_ns(), sdb_ns_set(), rz_debug_t::sgnls, and rz_asm_t::syscall.

Referenced by rz_core_init().

Variable Documentation

letter_divs

ut64 letter_divs[RZ_CORE_ASMQJMPS_LEN_LETTERS - 1]

static

Initial value:

= {
    RZ_CORE_ASMQJMPS_LETTERS * RZ_CORE_ASMQJMPS_LETTERS * RZ_CORE_ASMQJMPS_LETTERS * RZ_CORE_ASMQJMPS_LETTERS,
    RZ_CORE_ASMQJMPS_LETTERS *RZ_CORE_ASMQJMPS_LETTERS *RZ_CORE_ASMQJMPS_LETTERS,
    RZ_CORE_ASMQJMPS_LETTERS *RZ_CORE_ASMQJMPS_LETTERS,
    RZ_CORE_ASMQJMPS_LETTERS
}

Definition at line 18 of file core.c.

Referenced by rz_core_set_asmqjmps().

rizin_argv

const char* rizin_argv[]

static

Definition at line 877 of file core.c.

Referenced by __init_autocomplete_default(), and autocomplete_default().

rz_core_io_plugin_vfile

RZ_IPI RzIOPlugin rz_core_io_plugin_vfile

extern

Initial value:

= {
    .name = "vfile",
    .desc = "Virtual Files provided by RzBin Files",
    .uris = URI_SCHEME,
    .license = "LGPL",
    .open = vf_open,
    .close = vf_close,
    .read = vf_read,
    .check = vf_check,
    .lseek = vf_lseek,
    .write = vf_write,
    .resize = vf_resize
}

IO Plugin that opens RzBinVirtualFiles supplied by the plugin of an RzBinFile.

URIs look like vfile://1/decompressed_data_0 where 1 is the id of a loaded RzBinFile and decompressed_data_0 is the name of the RzBinVirtualFile inside this RzBinFile that provides the data.

Definition at line 134 of file cvfile.c.

Referenced by rz_core_init(), rz_core_vfile_bin_file_deleted(), and vf_open().