// SPDX-FileCopyrightText: 2009-2021 pancake // SPDX-License-Identifier: LGPL-3.0-only #ifndef RZ_CORE_H #define RZ_CORE_H #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #ifdef __cplusplus extern "C" { #endif RZ_LIB_VERSION_HEADER(rz_core); #define RZ_CORE_CMD_OK 0 #define RZ_CORE_CMD_INVALID -1 #define RZ_CORE_CMD_EXIT -2 #define RZ_CORE_BLOCKSIZE 0x100 #define RZ_CORE_BLOCKSIZE_MAX 0x3200000 /* 32MB */ #define RZ_FLAGS_FS_CLASSES "classes" #define RZ_FLAGS_FS_FUNCTIONS "functions" #define RZ_FLAGS_FS_IMPORTS "imports" #define RZ_FLAGS_FS_RELOCS "relocs" #define RZ_FLAGS_FS_REGISTERS "registers" #define RZ_FLAGS_FS_RESOURCES "resources" #define RZ_FLAGS_FS_SECTIONS "sections" #define RZ_FLAGS_FS_SEGMENTS "segments" #define RZ_FLAGS_FS_SIGNS "sign" #define RZ_FLAGS_FS_STRINGS "strings" #define RZ_FLAGS_FS_SYMBOLS "symbols" #define RZ_FLAGS_FS_SYMBOLS_SECTIONS "symbols.sections" #define RZ_FLAGS_FS_SYSCALLS "syscalls" #define RZ_FLAGS_FS_MMIO_REGISTERS "registers.mmio" #define RZ_FLAGS_FS_MMIO_REGISTERS_EXTENDED "registers.extended" #define RZ_FLAGS_FS_PLATFORM_PORTS "platform.ports" #define RZ_FLAGS_FS_GLOBALS "globals" #define RZ_FLAGS_FS_DEBUG_MAPS "maps" #define RZ_FLAGS_FS_POINTERS "pointers" /// #define RZ_CONS_COLOR_DEF(x, def) ((core->cons && core->cons->context->pal.x) ? core->cons->context->pal.x : def) #define RZ_CONS_COLOR(x) RZ_CONS_COLOR_DEF(x, "") /* rtr */ #define RTR_PROTOCOL_RAP 0 #define RTR_PROTOCOL_TCP 1 #define RTR_PROTOCOL_UDP 2 #define RTR_PROTOCOL_HTTP 3 #define RTR_PROTOCOL_UNIX 4 #define RTR_MAX_HOSTS 255 typedef enum { RZ_CORE_WRITE_OP_BYTESWAP2, ///< Swap the endianess of 2-bytes values RZ_CORE_WRITE_OP_BYTESWAP4, ///< Swap the endianess of 4-bytes values RZ_CORE_WRITE_OP_BYTESWAP8, ///< Swap the endianess of 8-bytes values RZ_CORE_WRITE_OP_ADD, ///< Write the addition of existing byte and argument value RZ_CORE_WRITE_OP_SUB, ///< Write the subtraction of existing byte and argument value RZ_CORE_WRITE_OP_DIV, ///< Write the division of existing byte and argument value RZ_CORE_WRITE_OP_MUL, ///< Write the multiplication of existing byte and argument value RZ_CORE_WRITE_OP_AND, ///< Write the bitwise-and of existing byte and argument value RZ_CORE_WRITE_OP_OR, ///< Write the bitwise-or of existing byte and argument value RZ_CORE_WRITE_OP_XOR, ///< Write the bitwise-xor of existing byte and argument value RZ_CORE_WRITE_OP_SHIFT_LEFT, ///< Write the shift left of existing byte by argument value RZ_CORE_WRITE_OP_SHIFT_RIGHT, ///< Write the shift right of existing byte and argument value } RzCoreWriteOp; typedef bool (*RzCorePluginInitCallback)(RzCore *core, RZ_OUT void **user); typedef bool (*RzCorePluginCallback)(RzCore *core, RZ_NULLABLE void *user); typedef struct rz_core_plugin_t { const char *name; const char *desc; const char *license; const char *author; const char *version; RzCorePluginInitCallback init; ///< Is called when the plugin is loaded by rizin. Stores per-core plugin state in user. RzCorePluginCallback fini; ///< Is called when the plugin is unloaded by rizin with the per-core plugin state. RzCorePluginCallback analysis; ///< Is called when automatic analysis is performed with the per-core plugin state. } RzCorePlugin; typedef struct rz_core_rtr_host_t RzCoreRtrHost; typedef enum { AUTOCOMPLETE_DEFAULT, AUTOCOMPLETE_MS } RAutocompleteType; /** * Represent an entry in the seek history. * This is the "full state" of that point in time. */ typedef struct rz_core_seek_undo_t { ut64 offset; ///< Value of core->offset at the given time in history int cursor; ///< Position of the cursor at the given time in history bool is_current; ///< True if this is the current seek value int idx; ///< Position of the item relative to the current seek item (0 current seek, < 0 for undos, > 0 for redos) } RzCoreSeekItem; typedef struct rz_core_file_t { struct rz_core_t *core; int dbg; int fd; RzPVector /**/ binfiles; ///< all bin files that have been created for this core file RzPVector /**/ extra_files; ///< additional files opened during mapping, for example for zeroed maps RzPVector /**/ maps; ///< all maps that have been created as a result of loading this file } RzCoreFile; /** * Data to be stored inside RzIOMap.user to track back to its origin */ typedef struct rz_core_io_map_info_t { RzCoreFile *cf; /** * Original perms as specified for example by the RzBinMap. * * This may be different from the RzIOMap's perms because io will disable writing if the * file has been opened read-only. If one needs the info whether a e.g. the segment causing * this map is writeable, this is the place to look for. * Used by rz-ghidra for example. */ int perm_orig; } RzCoreIOMapInfo; typedef struct rz_core_times_t { ut64 loadlibs_init_time; ut64 loadlibs_time; ut64 file_open_time; } RzCoreTimes; #define RZ_CORE_ASMQJMPS_NUM 10 #define RZ_CORE_ASMQJMPS_LETTERS 26 #define RZ_CORE_ASMQJMPS_MAX_LETTERS (26 * 26 * 26 * 26 * 26) #define RZ_CORE_ASMQJMPS_LEN_LETTERS 5 typedef enum rz_core_autocomplete_types_t { RZ_CORE_AUTOCMPLT_DFLT = 0, RZ_CORE_AUTOCMPLT_FLAG, RZ_CORE_AUTOCMPLT_FLSP, RZ_CORE_AUTOCMPLT_SEEK, RZ_CORE_AUTOCMPLT_FCN, RZ_CORE_AUTOCMPLT_EVAL, RZ_CORE_AUTOCMPLT_MINS, RZ_CORE_AUTOCMPLT_BRKP, RZ_CORE_AUTOCMPLT_MACR, RZ_CORE_AUTOCMPLT_FILE, RZ_CORE_AUTOCMPLT_THME, RZ_CORE_AUTOCMPLT_OPTN, RZ_CORE_AUTOCMPLT_MS, RZ_CORE_AUTOCMPLT_SDB, // --- left as last always RZ_CORE_AUTOCMPLT_END, } RzCoreAutocompleteType; typedef struct rz_core_autocomplete_t { const char *cmd; int length; int n_subcmds; bool locked; int type; struct rz_core_autocomplete_t **subcmds; } RzCoreAutocomplete; typedef struct { int x; int y; int w; int h; char *cmd; } RzCoreGadget; /** * \brief Options for controlling address description output. * * This structure contains flags that control how addresses are described * and formatted. It can be passed to rz_core_addr_describe() and related * functions to customize the output. */ typedef struct rz_core_addr_options_t { bool show_offset; ///< Show the address offset if no name is found bool prefer_function; ///< Prefer function names over flag names bool show_flag; ///< Include flag names in the description bool use_decimal; ///< Use decimal instead of hexadecimal for offsets bool show_color; ///< Include color codes in the output bool show_source_info; ///< Include source file/line information bool use_realnames; ///< Use realnames for flags instead of names st64 max_flag_delta; ///< Maximum delta from flag offset to show (0 = unlimited, negative = use default 8192) bool use_spaces_around_delta; ///< Use spaces around +/- in delta format (e.g., "sym + 10" vs "sym+10") } RzCoreAddrOptions; /** * \brief Description of an address with human-readable information * * This structure contains comprehensive information about an address, * including its relation to functions, flags, and source code. */ typedef struct rz_core_addr_t { ut64 addr; ///< The address being described char *name; ///< Combined name (deprecated, use fcn_name or flag_name) char *fcn_name; ///< Name of the function containing the address ut64 fcn_addr; ///< Address of the function st64 fcn_delta; ///< Delta from function start (addr - fcn_addr) char *flag_name; ///< Name of the flag at or before the address ut64 flag_offset; ///< Offset of the flag st64 flag_delta; ///< Delta from flag (addr - flag_offset) char *source_file; ///< Source file name (if debug info available) ut32 source_line; ///< Source line number (0 if unknown) ut32 source_column; ///< Source column number (0 if unknown) } RzCoreAddr; typedef struct rz_core_task_t RzCoreTask; /** * Scheduler-wide callback to switch any necessary context from cur to next. */ typedef void (*RzCoreTaskContextSwitch)(RzCoreTask *next, void *user); /** * Scheduler-wide callback for breaking a task. */ typedef void (*RzCoreTaskBreak)(RzCoreTask *task, void *user); typedef struct rz_core_tasks_t { RzCoreTaskContextSwitch ctx_switch; void *ctx_switch_user; RzCoreTaskBreak break_cb; void *break_cb_user; int task_id_next; RzList /**/ *tasks; RzList /**/ *tasks_queue; RzList /**/ *oneshot_queue; int oneshots_enqueued; struct rz_core_task_t *current_task; struct rz_core_task_t *main_task; RzThreadLock *lock; int tasks_running; bool oneshot_running; } RzCoreTaskScheduler; /** * Keep track of the seek history, by allowing undo/redo behaviour. Each seek * is saved in the undos stack (unless cfg.seek.silent is set), so you can go * back to where you previously were. Once an undo is done, the previously set * address is put in the redos stack, so it is possible to go back and forth. * Once a new seek is performed, all redos are lost. */ typedef struct rz_core_seek_history_t { RzVector /**/ undos; ///< Stack of RzCoreSeekItems, allowing to "go back in time" RzVector /**/ redos; ///< Stack of RzCoreSeekItems, allowing to re-do an action that was undone. bool saved_set; ///< When true, the \p saved field is set RzCoreSeekItem saved_item; ///< Position to save in history } RzCoreSeekHistory; struct rz_core_t { RzAsm *rasm; ut8 ptr_alignment_I; RzAnalysis *analysis; ut8 ptr_alignment_II; RzBin *bin; ut8 ptr_alignment_III; // NOTE: Do not change the order of fields above! // They are used in pointer passing hacks in rz_types.h. RzIO *io; HtSP /**/ *plugins; ///< List of registered core plugins HtSP /**/ *plugin_contexts; ///< Per-core plugin state RzConfig *config; HtSP /**/ *plugin_configs; ///< Pointers to plugin configurations. Indexed by plugin name ut64 offset; // current seek ut64 prompt_offset; // temporarily set to offset to have $$ in expressions always stay the same during temp seeks ut32 blocksize; ut32 blocksize_max; ut8 *block; RzBuffer *yank_buf; ut64 yank_addr; bool tmpseek; bool vmode; int interrupted; // XXX IS THIS DUPPED SOMEWHERE? /* files */ RzCons *cons; RzCoreFile *file; RzList /**/ *files; RzNum *num; ut64 rc; // command's return code .. related to num->value; RzLib *lib; RzCmd *rcmd; RzCmdDescriptor root_cmd_descriptor; RzList /**/ *cmd_descriptors; /* ^^ */ RzCoreTimes *times; RzParse *parser; RzPrint *print; RzLang *lang; RzDebug *dbg; RzFlag *flags; RzMark *marks; char *lastsearch; ///< Legacy search. Will be removed RzSearch *search; ///< Legacy search. Will be removed RzEgg *egg; RzCrypto *crypto; RzAGraph *graph; char *cmdqueue; char *lastcmd; bool is_lastcmd; bool is_pipe; char *cmdlog; int cmdrepeat; // cmd.repeat const char *cmdtimes; // cmd.times RZ_DEPRECATE bool cmd_in_backticks; // whether currently executing a cmd out of backticks int rtr_n; RzCoreRtrHost *rtr_host; // array of RzCoreRtrHost ut64 *asmqjmps; int asmqjmps_count; int asmqjmps_size; bool is_asmqjmps_letter; bool keep_asmqjmps; /* TODO: Remove this from RzCore */ void *visual; /* RzCoreVisual */ int http_up; int gdbserver_up; char *stkcmd; bool in_search; RzList /**/ *watchers; RzList /**/ *scriptstack; RzCoreTaskScheduler tasks; int max_cmd_depth; ut8 switch_file_view; Sdb *sdb; int incomment; /* TODO: Move this to RzCoreVisual instead */ int curtab; // current tab int seltab; // selected tab char *cmdremote; char *cmdfilter; char *curtheme; bool break_loop; bool binat; bool fixedbits; // will be true when using @b: bool fixedarch; // will be true when using @a: bool fixedblock; char *table_query; struct rz_core_t *c2; RzCoreAutocomplete *autocomplete; int autocomplete_type; int maxtab; RzEvent *ev; RzList /**/ *gadgets; bool scr_gadgets; bool log_events; // core.c:cb_event_handler : log actions from events if cfg.log.events is set RzList /**/ *ropchain; RzCoreSeekHistory seek_history; RzHash *hash; RzList /**/ *warnings_after; RzPath *sys_path; ///< pointer to RzPath, contains path prefix of the system bool vmarks_init; ut64 vmarks[UT8_MAX + 1]; RzMainCallback rz_main_rizin; // int (*rz_main_rizin)(int argc, char **argv); int (*rz_main_rz_find)(int argc, const char **argv); int (*rz_main_rz_diff)(int argc, const char **argv); int (*rz_main_rz_bin)(int argc, const char **argv); int (*rz_main_rz_run)(int argc, const char **argv); int (*rz_main_rz_gg)(int argc, const char **argv); int (*rz_main_rz_asm)(int argc, const char **argv); int (*rz_main_rz_ax)(int argc, const char **argv); }; // maybe move into RzAnalysis typedef struct rz_core_item_t { const char *type; ut64 addr; ut64 next; ut64 prev; int size; int perm; char *data; char *comment; char *sectname; char *fcnname; } RzCoreItem; typedef int (*RzCoreSearchCallback)(RzCore *core, ut64 from, ut8 *buf, int len); /** * \brief Store some display name from RzBinSymbol * \see rz_core_sym_name_init * \see rz_core_sym_name_fini */ typedef struct rz_bin_sym_names_t { const char *pfx; ///< prefix for flags char *name; ///< raw symbol name char *symbolname; ///< display symbol name char *libname; ///< name of the lib this symbol is specific to, if any char *nameflag; ///< flag name for symbol char *demname; ///< demangled raw symbol name char *demflag; ///< flag name for demangled symbol char *classname; ///< classname char *classflag; ///< flag for classname char *methname; ///< methods [class]::[method] char *methflag; ///< methods flag sym.[class].[method] } RzBinSymNames; /** * \brief Message for `pdJ` */ typedef struct rz_analysis_disasm_text_t { ut64 offset; ut64 arrow; ///< In general, arrow = UT64_MAX, if there is a jump(jmp, ...), arrow = dst offset char *text; } RzAnalysisDisasmText; #ifdef RZ_API RZ_API int rz_core_bind(RzCore *core, RzCoreBind *bnd); RZ_API void rz_core_notify_begin(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3); RZ_API void rz_core_notify_done(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3); RZ_API void rz_core_notify_error(RZ_NONNULL RzCore *core, RZ_NONNULL const char *format, ...) RZ_PRINTF_CHECK(2, 3); RZ_API void rz_core_notify_begin_str(RZ_NONNULL RzCore *core, RZ_NONNULL const char *text); RZ_API void rz_core_notify_done_str(RZ_NONNULL RzCore *core, RZ_NONNULL const char *text); RZ_API void rz_core_notify_error_str(RZ_NONNULL RzCore *core, RZ_NONNULL const char *text); RZ_API void rz_core_log_after(RZ_NONNULL RzCore *core, const char *funcname, const char *filename, ut32 lineno, RzLogLevel level, const char *fmtstr, ...) RZ_PRINTF_CHECK(6, 7); #define RZ_LOG_WARN_AFTER(core, fmtstr, ...) rz_core_log_after(core, MACRO_LOG_FUNC, __FILE__, \ __LINE__, RZ_LOGLVL_WARN, fmtstr, ##__VA_ARGS__); RZ_API bool rz_core_plugin_init(RzCore *core); RZ_API bool rz_core_plugin_add(RzCore *core, RZ_NONNULL RzCorePlugin *plugin); RZ_API bool rz_core_plugin_del(RzCore *core, RZ_NONNULL RzCorePlugin *plugin); RZ_API bool rz_core_plugin_fini(RzCore *core); RZ_API void *rz_core_plugin_context_get(RZ_NONNULL RzCore *core, RZ_NONNULL RzCorePlugin *plugin); RZ_API RzCmdDesc *rz_core_plugin_cmd_desc_argv_new(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, RZ_NONNULL RzCmdArgvCb cb, RZ_NONNULL const RzCmdDescHelp *help); RZ_API RzCmdDesc *rz_core_plugin_cmd_desc_group_new(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, RZ_NULLABLE RzCmdArgvCb cb, RZ_NULLABLE const RzCmdDescHelp *help, RZ_NONNULL const RzCmdDescHelp *group_help); RZ_API bool rz_core_plugin_cmd_desc_remove(RZ_NONNULL RzCore *core, RZ_NULLABLE RzCmdDesc *desc); // #define rz_core_ncast(x) (RzCore*)(size_t)(x) RZ_API RZ_OWN RzPVector /**/ *rz_core_get_themes(RZ_NONNULL RzCore *core); RZ_API char *rz_core_theme_get(RzCore *core); RZ_API bool rz_core_theme_load(RzCore *core, const char *name); RZ_API void rz_core_theme_nextpal(RzCore *core, RzConsPalSeekMode mode); RZ_API RZ_OWN char *rz_core_get_section_name(RzCore *core, ut64 addr); RZ_API RzCons *rz_core_get_cons(RzCore *core); RZ_API RzBin *rz_core_get_bin(RzCore *core); RZ_API RzConfig *rz_core_get_config(RzCore *core); RZ_API bool rz_core_init(RzCore *core); RZ_API void rz_core_bind_cons(RzCore *core); // to restore pointers in cons RZ_API RzCore *rz_core_new(void); RZ_API void rz_core_free(RzCore *core); RZ_API void rz_core_fini(RzCore *c); RZ_API void rz_core_wait(RzCore *core); RZ_API RzCore *rz_core_ncast(ut64 p); RZ_API RzCore *rz_core_cast(void *p); RZ_API bool rz_core_bin_load_structs(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file); RZ_API int rz_core_config_init(RzCore *core); RZ_API void rz_core_config_print_all(RzConfig *cfg, const char *str, RzCmdStateOutput *state); RZ_API void rz_core_parse_rizinrc(RzCore *r); RZ_API RZ_OWN RzList /**/ *rz_core_config_in_space(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *space); RZ_API int rz_core_prompt(RzCore *core, int sync); RZ_API int rz_core_prompt_exec(RzCore *core); RZ_API void rz_core_prompt_loop(RzCore *core); RZ_API ut64 rz_core_pava(RzCore *core, ut64 addr); RZ_API int rz_core_cmd(RzCore *core, const char *cmd, int log); RZ_API RzCmdStatus rz_core_cmd_rzshell(RzCore *core, const char *cmd, int log); RZ_API RZ_OWN char *rz_core_editor(const RzCore *core, RZ_NULLABLE const char *file, RZ_NULLABLE const char *str); RZ_API int rz_core_fgets(char *buf, int len, void *user); RZ_API RzFlagItem *rz_core_flag_get_by_spaces(RzFlag *f, ut64 off); RZ_API int rz_core_flush(RzCore *core, const char *cmd); RZ_API void rz_core_cmd_init(RzCore *core); RZ_API char *rz_core_cmd_str(RzCore *core, const char *cmd); RZ_API ut8 *rz_core_cmd_raw(RzCore *core, const char *cmd, int *length); RZ_API char *rz_core_cmd_strf(RzCore *core, const char *fmt, ...) RZ_PRINTF_CHECK(2, 3); RZ_API char *rz_core_cmd_str_pipe(RzCore *core, const char *cmd); RZ_API int rz_core_cmd_file(RzCore *core, const char *file); RZ_API int rz_core_cmd_lines(RzCore *core, const char *lines); RZ_API RzCmdStatus rz_core_cmd_lines_rzshell(RzCore *core, const char *lines); RZ_API int rz_core_cmd_command(RzCore *core, const char *command); RZ_API bool rz_core_run_script(RzCore *core, RZ_NONNULL const char *file); RZ_API void rz_core_seek_item_free(RzCoreSeekItem *item); RZ_API bool rz_core_seek(RzCore *core, ut64 addr, bool rb); RZ_API bool rz_core_seek_and_save(RzCore *core, ut64 addr, bool rb); RZ_API bool rz_core_seek_opt(RzCore *core, ut64 addr, bool read_block, bool save); RZ_API bool rz_core_seek_mark(RzCore *core); RZ_API bool rz_core_seek_save(RzCore *core); RZ_API bool rz_core_seek_undo(RzCore *core); RZ_API bool rz_core_seek_redo(RzCore *core); RZ_API void rz_core_seek_reset(RzCore *core); RZ_API void rz_core_seek_free(RzCore *core); RZ_API RzList /**/ *rz_core_seek_list(RzCore *core); RZ_API RzCoreSeekItem *rz_core_seek_peek(RzCore *core, int idx); RZ_API int rz_core_seek_base(RzCore *core, const char *hex, bool save); RZ_API bool rz_core_seek_prev(RzCore *core, const char *type, bool save); RZ_API bool rz_core_seek_next(RzCore *core, const char *type, bool save); RZ_API bool rz_core_seek_align(RzCore *core, ut64 align, bool save); RZ_API bool rz_core_seek_delta(RzCore *core, st64 delta, bool save); RZ_API bool rz_core_seek_analysis_bb(RzCore *core, ut64 addr, bool save); RZ_API void rz_core_arch_bits_at(RzCore *core, ut64 addr, RZ_OUT RZ_NULLABLE int *bits, RZ_OUT RZ_BORROW RZ_NULLABLE const char **arch); RZ_API void rz_core_seek_arch_bits(RzCore *core, ut64 addr); RZ_API int rz_core_block_read(RzCore *core); RZ_API bool rz_core_block_size(RzCore *core, ut32 bsize); RZ_API int rz_core_is_valid_offset(RZ_NONNULL RzCore *core, ut64 offset); RZ_API int rz_core_write_hexpair(RzCore *core, ut64 addr, const char *pairs); RZ_API int rz_core_write_assembly(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions); RZ_API int rz_core_write_assembly_fill(RzCore *core, ut64 addr, RZ_NONNULL const char *instructions); RZ_API bool rz_core_write_block(RzCore *core, ut64 addr, ut8 *data, size_t len); RZ_API bool rz_core_write_seq_at(RzCore *core, ut64 addr, ut64 from, ut64 to, ut64 step, int value_size); RZ_API bool rz_core_shift_block(RzCore *core, ut64 addr, ut64 b_size, st64 dist); RZ_API RzLineNSCompletionResult *rz_core_autocomplete_rzshell(RzCore *core, RzLineBuffer *buf, RzLinePromptType prompt_type); RZ_DEPRECATE RZ_API void rz_core_help_vars_print(RzCore *core); RZ_API bool rz_core_prevop_addr(RzCore *core, ut64 start_addr, int numinstrs, RZ_OUT RZ_BORROW RZ_NONNULL ut64 *prev_addr); RZ_API ut64 rz_core_prevop_addr_force(RzCore *core, ut64 start_addr, int numinstrs); 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 void rz_core_set_asmqjmps(RzCore *core, char *str, size_t len, int i); RZ_API char *rz_core_add_asmqjmp(RzCore *core, ut64 addr); RZ_API void rz_core_analysis_type_init(RzCore *core); RZ_API char *rz_core_analysis_hasrefs_to_depth(RzCore *core, ut64 value, PJ *pj, int depth); RZ_API void rz_core_global_vars_propagate_types(RzCore *core, RzAnalysisFunction *fcn); RZ_API bool rz_core_analysis_objc_refs(RzCore *core, bool auto_analysis); RZ_API void rz_core_analysis_objc_stubs(RzCore *core); RZ_API void rz_core_analysis_cc_init_by_path(RzCore *core, RZ_NULLABLE const char *path, RZ_NULLABLE const char *homepath); RZ_API void rz_core_analysis_cc_init(RzCore *core); RZ_API void rz_core_analysis_paths(RzCore *core, ut64 from, ut64 to, bool followCalls, int followDepth, bool is_json); RZ_API RZ_OWN char *rz_core_types_as_c(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, bool multiline); RZ_API RZ_OWN char *rz_core_types_as_c_all(RZ_NONNULL RzCore *core, bool multiline); RZ_API bool rz_core_types_rename(RZ_NONNULL RzCore *core, RZ_NONNULL const char *from, RZ_NONNULL const char *to); RZ_API bool rz_core_analysis_esil_trace_start(RzCore *core); RZ_API bool rz_core_analysis_esil_trace_stop(RzCore *core); RZ_API int rz_core_search_cb(RzCore *core, ut64 from, ut64 to, RzCoreSearchCallback cb); RZ_API bool rz_core_file_reopen(RzCore *core, const char *args, int perm, int binload); RZ_API void rz_core_file_reopen_in_malloc(RzCore *core); RZ_API void rz_core_file_reopen_debug(RzCore *core, const char *args); RZ_API void rz_core_file_reopen_remote_debug(RzCore *core, const char *uri, ut64 addr); RZ_API bool rz_core_file_resize(RzCore *core, ut64 newsize); RZ_API bool rz_core_file_resize_delta(RzCore *core, st64 delta); RZ_API RzCoreFile *rz_core_file_find_by_fd(RzCore *core, ut64 fd); RZ_API RzCoreFile *rz_core_file_find_by_name(RzCore *core, const char *name); RZ_API RzCoreFile *rz_core_file_cur(RzCore *r); RZ_API int rz_core_file_set_by_fd(RzCore *core, ut64 fd); RZ_API int rz_core_file_set_by_name(RzCore *core, const char *name); RZ_API int rz_core_file_set_by_file(RzCore *core, RzCoreFile *cf); RZ_API int rz_core_setup_debugger(RzCore *r, const char *debugbackend, bool attach); RZ_API bool rz_core_file_open_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filepath, ut64 addr, int perms, bool write_mode); RZ_API RZ_BORROW RzCoreFile *rz_core_file_open(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file, int flags, ut64 loadaddr); RZ_API RZ_BORROW RzCoreFile *rz_core_file_open_many(RZ_NONNULL RzCore *r, RZ_NULLABLE const char *file, int perm, ut64 loadaddr); RZ_API bool rz_core_file_malloc_copy_chunk(RzCore *core, size_t len, ut64 offset); RZ_API RzCoreFile *rz_core_file_get_by_fd(RzCore *core, int fd); RZ_API void rz_core_file_close(RzCoreFile *fh); RZ_API bool rz_core_file_close_fd(RzCore *core, int fd); RZ_API bool rz_core_file_close_all_but(RzCore *core); RZ_API bool rz_core_raw_file_print(RzCore *core); RZ_API bool rz_core_file_print(RzCore *core, RzOutputMode mode); RZ_API int rz_core_file_binlist(RzCore *core); RZ_API bool rz_core_file_bin_raise(RzCore *core, ut32 num); RZ_API void rz_core_io_file_open(RZ_NONNULL RzCore *core, int fd); RZ_API void rz_core_io_file_reopen(RZ_NONNULL RzCore *core, int fd, int perms); RZ_API bool rz_core_extend_at(RzCore *core, ut64 addr, ut64 size); RZ_API bool rz_core_write_at(RzCore *core, ut64 addr, const ut8 *buf, int size); RZ_API bool rz_core_write_value_at(RzCore *core, ut64 addr, ut64 value, int sz); RZ_API bool rz_core_write_value_inc_at(RzCore *core, ut64 addr, st64 value, int sz); RZ_API bool rz_core_write_string_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s); RZ_API bool rz_core_write_string_zero_at(RzCore *core, ut64 addr, const char *s); RZ_API bool rz_core_write_string_wide_at(RzCore *core, ut64 addr, const char *s); RZ_API bool rz_core_write_length_string_at(RzCore *core, ut64 addr, const char *s); RZ_API bool rz_core_write_base64d_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s); RZ_API bool rz_core_write_base64_at(RzCore *core, ut64 addr, RZ_NONNULL const char *s); RZ_API bool rz_core_write_random_at(RzCore *core, ut64 addr, size_t len); RZ_API bool rz_core_write_block_op_at(RzCore *core, ut64 addr, RzCoreWriteOp op, RZ_NULLABLE ut8 *hex, size_t hexlen); RZ_API bool rz_core_write_duplicate_at(RzCore *core, ut64 addr, ut64 from, int len); RZ_API RZ_OWN ut8 *rz_core_transform_op(RzCore *core, ut64 addr, RzCoreWriteOp op, RZ_NULLABLE ut8 *hex, size_t hexlen, size_t *buflen); RZ_API ut32 rz_core_file_cur_fd(RzCore *core); RZ_API RzCmdStatus rz_core_io_cache_print(RzCore *core, RzCmdStateOutput *state); RZ_API RzCmdStatus rz_core_io_pcache_print(RzCore *core, RzIODesc *desc, RzCmdStateOutput *state); /* creg.c */ RZ_API RzReg *rz_core_reg_default(RzCore *core); RZ_API ut64 rz_core_reg_getv_by_role_or_name(RzCore *core, const char *name); RZ_API bool rz_core_reg_set_by_role_or_name(RzCore *core, const char *name, ut64 num); RZ_API void rz_core_reg_update_flags(RzCore *core); /* cdebug.c */ RZ_API bool rz_core_is_debug(RzCore *core); RZ_API bool rz_core_debug_step_one(RzCore *core, int times); RZ_API bool rz_core_debug_continue_until(RzCore *core, ut64 addr); RZ_API void rz_core_debug_bp_add_noreturn_func(RzCore *core); RZ_API void rz_core_debug_breakpoint_toggle(RZ_NONNULL RzCore *core, ut64 addr); RZ_API void rz_core_debug_set_register_flags(RzCore *core); RZ_API void rz_core_debug_clear_register_flags(RzCore *core); RZ_API bool rz_core_debug_process_close(RzCore *core); RZ_API bool rz_core_debug_process_detach(RzCore *core); RZ_API bool rz_core_debug_step_until_frame(RzCore *core); RZ_API bool rz_core_debug_step_back(RzCore *core, int steps); RZ_API bool rz_core_debug_step_over(RzCore *core, int steps); RZ_API bool rz_core_debug_step_skip(RzCore *core, int times); RZ_API void rz_core_dbg_follow_seek_register(RzCore *core); RZ_API RZ_OWN RzList /**/ *rz_core_debug_backtraces(RzCore *core); RZ_API void rz_backtrace_free(RZ_NULLABLE RzBacktrace *bt); RZ_API RzCmdStatus rz_core_debug_plugins_print(RZ_NONNULL RZ_BORROW RzCore *core, RZ_OUT RzCmdStateOutput *state); RZ_API void rz_core_debug_map_update_flags(RzCore *core); RZ_API void rz_core_debug_map_print(RzCore *core, ut64 addr, RzCmdStateOutput *state); /** * \defgroup caddr Address Description API * \brief Unified API for describing addresses in human-readable formats * * This API provides functions to generate human-readable descriptions of memory * addresses, combining information from flags, functions, and debug symbols. * It supports various output formats including name+offset notation (e.g., "main+0x10"), * source file information, and JSON output. * * Example usage: * \code * char *desc = rz_core_addr_get_name_delta(core, 0x401010); * // Returns "main+16" or "0x401010" if no symbol found * rz_cons_printf("Address: %s\n", desc); * free(desc); * \endcode * */ RZ_API RZ_OWN RzCoreAddrOptions *rz_core_addr_options_new(void); RZ_API void rz_core_addr_options_free(RZ_NULLABLE RzCoreAddrOptions *opts); RZ_API void rz_core_addr_free(RZ_NULLABLE RzCoreAddr *desc); RZ_API RZ_OWN RzCoreAddr *rz_core_addr_describe(RZ_NONNULL RzCore *core, ut64 addr, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API RZ_OWN char *rz_core_addr_to_string(RZ_NONNULL const RzCoreAddr *desc, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API RZ_OWN char *rz_core_addr_describe_string(RZ_NONNULL RzCore *core, ut64 addr, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API RZ_OWN char *rz_core_addr_get_name_delta(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzCoreAddr *rz_core_addr_describe_with_function(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzCoreAddr *rz_core_addr_describe_with_source(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN char *rz_core_addr_format_for_display(RZ_NULLABLE RzPrint *print, ut64 addr, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API void rz_core_addr_to_pj(RZ_NONNULL PJ *pj, RZ_NONNULL const RzCoreAddr *desc, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API void rz_core_addr_describe_pj(RZ_NONNULL RzCore *core, RZ_NONNULL PJ *pj, ut64 addr, RZ_NULLABLE const RzCoreAddrOptions *opts); RZ_API bool rz_core_addr_get_reloff_info(RZ_NONNULL RzCore *core, ut64 addr, bool prefer_function, bool use_flags, RZ_OUT RZ_NULLABLE char **out_name, RZ_OUT RZ_NULLABLE st64 *out_delta); RZ_API RZ_OWN char *rz_core_addr_get_function_offset(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN char *rz_core_addr_get_flag_offset(RZ_NONNULL RzFlag *flags, ut64 addr); RZ_API RZ_OWN char *rz_core_addr_get_flag_offset_prompt(RZ_NONNULL RzFlag *flags, ut64 addr); /* chash.c */ RZ_API RzCmdStatus rz_core_hash_plugins_print(RZ_NONNULL RZ_BORROW RzHash *hash, RZ_OUT RzCmdStateOutput *state); /* ccrypto.c */ RZ_API RzCmdStatus rz_core_crypto_plugins_print(RzCrypto *cry, RzCmdStateOutput *state); /* cio.c */ RZ_API RzCmdStatus rz_core_io_plugins_print(RZ_NONNULL RZ_BORROW RzIO *io, RzCmdStateOutput *state); /* cio.c */ RZ_API RzCmdStatus rz_core_parser_plugins_print(RzParse *parser, RzCmdStateOutput *state); /* fortune */ RZ_API void rz_core_fortune_list_types(void); RZ_API void rz_core_fortune_list(RzCore *core); RZ_API RZ_OWN char *rz_core_fortune_get_random(RzCore *core); RZ_API void rz_core_fortune_print_random(RzCore *core); #define RZ_CORE_FOREIGN_ADDR -1 RZ_API RZ_OWN char *rz_core_yank_as_string(RzCore *core, ut64 pos); RZ_API bool rz_core_yank(RzCore *core, ut64 addr, ut64 len); RZ_API bool rz_core_yank_string(RzCore *core, ut64 addr, ut64 maxlen); RZ_API bool rz_core_yank_hexpair(RzCore *core, const char *str); RZ_API bool rz_core_yank_paste(RzCore *core, ut64 addr, ut64 len); RZ_API bool rz_core_yank_set(RzCore *core, ut64 addr, RZ_NONNULL const ut8 *buf, ut64 len); RZ_API bool rz_core_yank_set_str(RzCore *core, ut64 addr, RZ_NONNULL const char *str); RZ_API bool rz_core_yank_to(RzCore *core, ut64 len, ut64 addr); RZ_API bool rz_core_yank_dump(RzCore *core, ut64 pos, RzCmdStateOutput *state); RZ_API bool rz_core_yank_print_hexdump(RzCore *core, ut64 pos); RZ_API bool rz_core_yank_print(RzCore *core, ut64 pos); RZ_API bool rz_core_yank_print_string(RzCore *core, ut64 pos); RZ_API bool rz_core_yank_hud_file(RzCore *core, const char *input); RZ_API bool rz_core_yank_hud_path(RzCore *core, const char *input, int dir); RZ_API bool rz_core_yank_file(RzCore *core, ut64 len, ut64 addr, const char *filename); RZ_API bool rz_core_yank_file_all(RzCore *core, const char *filename); #define RZ_CORE_LOADLIBS_ENV (1 << 0) #define RZ_CORE_LOADLIBS_HOME (1 << 1) #define RZ_CORE_LOADLIBS_SYSTEM (1 << 2) #define RZ_CORE_LOADLIBS_CONFIG (1 << 3) #define RZ_CORE_LOADLIBS_EXTRA (1 << 4) #define RZ_CORE_LOADLIBS_ALL UT32_MAX RZ_API void rz_core_loadlibs_init(RzCore *core); RZ_API int rz_core_loadlibs(RzCore *core, int where); RZ_API RzCmd *rz_core_cmd_new(RzCore *core, bool has_cons); RZ_API int rz_core_cmd_buffer(RzCore *core, const char *buf); RZ_API int rz_core_cmdf(RzCore *core, const char *fmt, ...) RZ_PRINTF_CHECK(2, 3); RZ_API int rz_core_cmd0(RzCore *core, const char *cmd); RZ_API RzCmdStatus rz_core_cmd0_rzshell(RzCore *core, const char *cmd); RZ_API char *rz_core_op_str(RzCore *core, ut64 addr); RZ_API RzAnalysisOp *rz_core_op_analysis(RzCore *core, ut64 addr, RzAnalysisOpMask mask); RZ_API char *rz_core_disassemble_instr(RzCore *core, ut64 addr, int l); RZ_API char *rz_core_disassemble_bytes(RzCore *core, ut64 addr, int b); /* carg.c */ RZ_DEPRECATE RZ_API ut64 rz_core_arg_get(RzCore *core, const char *cc, int num); RZ_API RZ_OWN RzList /**/ *rz_core_get_func_args(RzCore *core, const char *func_name); RZ_API void rz_core_print_func_args(RzCore *core); /* clang.c */ RZ_API RzCmdStatus rz_core_lang_plugins_print(RzLang *lang, RzCmdStateOutput *state); /* ccore.c */ RZ_API RzCmdStatus rz_core_core_plugins_print(RzCore *core, RzCmdStateOutput *state); RZ_API void rz_core_analysis_esil(RzCore *core, ut64 addr, ut64 size, RZ_NULLABLE RzAnalysisFunction *fcn); RZ_API bool rz_core_esil_cmd(RzAnalysisEsil *esil, const char *cmd, ut64 a1, ut64 a2); RZ_API int rz_core_esil_step(RzCore *core, ut64 until_addr, const char *until_expr, ut64 *prev_addr, bool stepOver); RZ_API int rz_core_esil_step_back(RzCore *core); RZ_API bool rz_core_esil_dumpstack(RzAnalysisEsil *esil); RZ_API bool rz_core_esil_continue_back(RZ_NONNULL RzCore *core); RZ_API void rz_core_analysis_esil_step_over(RZ_NONNULL RzCore *core); RZ_API void rz_core_analysis_esil_reinit(RZ_NONNULL RzCore *core); RZ_API void rz_core_analysis_esil_deinit(RZ_NONNULL RzCore *core); RZ_API void rz_core_analysis_esil_init_mem(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size); RZ_API void rz_core_analysis_esil_init_mem_del(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *name, ut64 addr, ut32 size); RZ_API void rz_core_analysis_esil_init_regs(RZ_NONNULL RzCore *core); RZ_API void rz_core_analysis_il_reinit(RZ_NONNULL RzCore *core); RZ_API bool rz_core_il_step(RZ_NONNULL RzCore *core, ut64 n); RZ_API bool rz_core_il_step_until(RZ_NONNULL RzCore *core, ut64 until); RZ_API bool rz_core_il_step_until_with_events(RZ_NONNULL RzCore *core, ut64 until); /* canalysis.c */ typedef enum rz_core_analysis_name_type { RZ_CORE_ANALYSIS_NAME_TYPE_VAR = 0, RZ_CORE_ANALYSIS_NAME_TYPE_FUNCTION, RZ_CORE_ANALYSIS_NAME_TYPE_FLAG, RZ_CORE_ANALYSIS_NAME_TYPE_ADDRESS, } RzCoreAnalysisNameType; typedef struct rz_core_analysis_name_t { char *name; char *realname; RzCoreAnalysisNameType type; ut64 offset; } RzCoreAnalysisName; /** * Defines the level of analysis performed by * `rz_core_perform_auto_analysis` * */ typedef enum { RZ_CORE_ANALYSIS_SIMPLE, ///< aa RZ_CORE_ANALYSIS_DEEP, ///< aaa RZ_CORE_ANALYSIS_EXPERIMENTAL, ///< aaaa } RzCoreAnalysisType; RZ_DEPRECATE RZ_API bool rz_core_set_endianness(RZ_NONNULL RzCore *core, bool big_endian); RZ_DEPRECATE RZ_API bool rz_core_arch_configure(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *arch, int bits, RZ_NULLABLE const char *cpu, RZ_NULLABLE const char *os, RZ_NULLABLE const char *platform); RZ_API RzAnalysisOp *rz_core_analysis_op(RzCore *core, ut64 addr, int mask); RZ_API void rz_core_analysis_fcn_merge(RzCore *core, ut64 addr, ut64 addr2); RZ_API const char *rz_core_analysis_optype_colorfor(RzCore *core, ut64 addr, bool verbose); RZ_API ut64 rz_core_analysis_address(RzCore *core, ut64 addr); RZ_API void rz_core_analysis_undefine(RzCore *core, ut64 off); RZ_API void rz_core_analysis_hint_print(RzAnalysis *a, ut64 addr, RzCmdStateOutput *state); RZ_API void rz_core_analysis_hint_list_print(RzAnalysis *a, RzCmdStateOutput *state); RZ_API int rz_core_analysis_search(RzCore *core, ut64 from, ut64 to, ut64 ref, int mode); RZ_API int rz_core_analysis_search_xrefs(RZ_NONNULL RzCore *core, ut64 from, ut64 to); RZ_API void rz_core_analysis_data(RZ_NONNULL RzCore *core, ut64 addr, ut32 count, ut32 depth, ut32 wordsize); RZ_API void rz_core_analysis_resolve_jumps(RZ_NONNULL RzCore *core); RZ_API bool rz_core_analysis_refs(RZ_NONNULL RzCore *core, size_t nbytes); RZ_API void rz_core_analysis_flag_every_function(RzCore *core); RZ_API bool rz_core_analysis_function_rename(RzCore *core, ut64 addr, const char *_name); RZ_API bool rz_core_analysis_function_add(RzCore *core, const char *name, ut64 addr, bool analyze_recursively); RZ_API int rz_core_analysis_fcn(RzCore *core, ut64 at, ut64 from, int reftype, int depth); RZ_API RZ_OWN char *rz_core_analysis_function_autoname(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn); RZ_API void rz_core_analysis_function_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn, RZ_NULLABLE PJ *pj); RZ_API void rz_core_analysis_autoname_all_fcns(RzCore *core); RZ_API bool rz_core_analysis_recover_golang_functions(RzCore *core); RZ_API void rz_core_analysis_resolve_golang_strings(RzCore *core); RZ_API int rz_core_analysis_fcn_clean(RzCore *core, ut64 addr); RZ_API RzList /**/ *rz_core_analysis_graph_to(RzCore *core, ut64 addr, int n); RZ_API int rz_core_analysis_all(RzCore *core); RZ_API bool rz_core_analysis_everything(RzCore *core, bool experimental, char *dh_orig); RZ_API RZ_OWN RzList /**/ *rz_core_analysis_sigdb_list(RZ_NONNULL RzCore *core, bool with_details); RZ_API bool rz_core_analysis_sigdb_apply(RZ_NONNULL RzCore *core, RZ_NULLABLE int *n_applied, RZ_NULLABLE const char *filter); RZ_API void rz_core_analysis_sigdb_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTable *table); RZ_API RzList /**/ *rz_core_analysis_cycles(RzCore *core, int ccl); RZ_API RZ_OWN RzList /**/ *rz_core_analysis_fcn_get_calls(RzCore *core, RzAnalysisFunction *fcn); // get all calls from a function RZ_API void rz_core_analysis_calls(RZ_NONNULL RzCore *core, bool imports_only); RZ_API int rz_core_get_stacksz(RzCore *core, ut64 from, ut64 to); RZ_API bool rz_core_analysis_hint_set_offset(RZ_NONNULL RzCore *core, RZ_NONNULL const char *struct_member); RZ_API bool rz_core_analysis_continue_until_syscall(RZ_NONNULL RzCore *core); RZ_API bool rz_core_analysis_continue_until_call(RZ_NONNULL RzCore *core); RZ_API bool rz_core_is_debugging(RZ_NONNULL RzCore *core); RZ_API void rz_core_perform_auto_analysis(RZ_NONNULL RzCore *core, RzCoreAnalysisType type); RZ_API size_t rz_core_analysis_coverage_count(RZ_NONNULL RzCore *core); RZ_API size_t rz_core_analysis_code_count(RZ_NONNULL RzCore *core); RZ_API size_t rz_core_analysis_calls_count(RZ_NONNULL RzCore *core); RZ_API RZ_BORROW const char *rz_core_analysis_name_type_to_str(RzCoreAnalysisNameType typ); RZ_API void rz_core_analysis_name_free(RZ_NULLABLE RzCoreAnalysisName *p); RZ_API RZ_OWN RzCoreAnalysisName *rz_core_analysis_name(RZ_NONNULL RzCore *core, ut64 addr); RZ_API bool rz_core_analysis_rename(RZ_NONNULL RzCore *core, RZ_NONNULL const char *name, ut64 addr); /** * Save useful infomation when analyze and disassemble bytes * \see rz_core_analysis_bytes */ typedef struct rz_core_decoded_bytes_t { RzAnalysisOp an_op; RzAsmOp as_op; RzAnalysisHint *hint; char *opcode; char *disasm; char *pseudo; char *mnemonic; char *description; char *mask; char *bytes; int oplen; } RzCoreDecodedBytes; RZ_API RZ_OWN RzIterator *rz_core_analysis_bytes(RZ_NONNULL RzCore *core, ut64 start_addr, RZ_NONNULL const ut8 *buf, ut64 n_bytes, ut64 max_ops); RZ_API RZ_OWN RzIterator *rz_core_analysis_op_chunk_iter(RZ_NONNULL RzCore *core, ut64 start_addr, ut64 n_bytes, ut64 max_ops, RzAnalysisOpMask mask); RZ_API RZ_OWN RzIterator *rz_core_analysis_op_function_iter(RZ_NONNULL RzCore *core, RZ_NONNULL RZ_BORROW RzAnalysisFunction *fcn, RzAnalysisOpMask mask); RZ_API ut64 rz_core_analysis_ops_size(RZ_NONNULL RzCore *core, ut64 start_addr, RZ_NONNULL const ut8 *buf, ut64 len, ut64 nops); /* cgraph.c */ /** * \brief RzGraph format for print/convert */ typedef enum { RZ_CORE_GRAPH_FORMAT_VISUAL = 0, RZ_CORE_GRAPH_FORMAT_SDB, RZ_CORE_GRAPH_FORMAT_GML, RZ_CORE_GRAPH_FORMAT_DOT, RZ_CORE_GRAPH_FORMAT_JSON, RZ_CORE_GRAPH_FORMAT_JSON_DISASM, RZ_CORE_GRAPH_FORMAT_CMD, RZ_CORE_GRAPH_FORMAT_ASCII_ART, RZ_CORE_GRAPH_FORMAT_UNK, } RzCoreGraphFormat; /** * \brief RzGraph type */ typedef enum { RZ_CORE_GRAPH_TYPE_DATAREF = 0, ///< Data reference graph RZ_CORE_GRAPH_TYPE_FUNCALL, ///< Function callgraph RZ_CORE_GRAPH_TYPE_DIFF, ///< Diff graph RZ_CORE_GRAPH_TYPE_BLOCK_FUN, ///< Basic blocks function graph RZ_CORE_GRAPH_TYPE_IMPORT, ///< Imports graph RZ_CORE_GRAPH_TYPE_REF, ///< References graph RZ_CORE_GRAPH_TYPE_LINE, ///< Line graph RZ_CORE_GRAPH_TYPE_XREF, ///< Cross-references graph RZ_CORE_GRAPH_TYPE_CUSTOM, ///< Custom graph RZ_CORE_GRAPH_TYPE_NORMAL, ///< Normal graph RZ_CORE_GRAPH_TYPE_IL, ///< RzIL graph RZ_CORE_GRAPH_TYPE_ICFG, ///< Inter-procedual control flow graph RZ_CORE_GRAPH_TYPE_CFG, ///< control flow graph (without calls) RZ_CORE_GRAPH_TYPE_UNK ///< Unknown graph } RzCoreGraphType; RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_datarefs(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_coderefs(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_codexrefs(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_importxrefs(RZ_NONNULL RzCore *core); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_callgraph(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_function(RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_line(RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_il(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph(RzCore *core, RzCoreGraphType type, ut64 addr); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_icfg(RZ_NONNULL RzCore *core); RZ_API RZ_OWN RzGraph /**/ *rz_core_graph_cfg(RZ_NONNULL RzCore *core, ut64 addr); RZ_API RzCoreGraphFormat rz_core_graph_format_from_string(RZ_NULLABLE const char *x); RZ_API RzCoreGraphType rz_core_graph_type_from_string(RZ_NULLABLE const char *x); RZ_API bool rz_core_graph_write_graph(RZ_NONNULL RzCore *core, RZ_NONNULL RzGraph /**/ *graph, RZ_NONNULL const char *filename); RZ_API bool rz_core_graph_write(RZ_NONNULL RzCore *core, ut64 addr, RzCoreGraphType type, RZ_NONNULL const char *path); RZ_API RZ_OWN char *rz_core_graph_to_dot_str(RZ_NONNULL RzCore *core, RZ_NONNULL RzGraph /**/ *graph); RZ_API RZ_OWN char *rz_core_graph_to_sdb_str(RZ_NONNULL RzCore *core, RZ_NONNULL RzGraph /**/ *graph); /*tp.c*/ RZ_API void rz_core_analysis_type_match(RzCore *core, RzAnalysisFunction *fcn, HtUU *addr_loop_table); /* cil.c */ /** * \brief Options for printing RzIL instructions. */ typedef struct rz_core_il_print_options { bool cbytes; ///< If false, ignore the \p len byte limit and print exactly \p n_lines instructions in rz_core_print_disasm(). bool pretty; ///< If true, use delimiter(\n). bool colorize; ///< If false, disable colorized output. bool unicode; ///< If true, print RzIL using unicode formatting. RzPVector /**/ *vec; ///< Output vector; } RzCoreILPrintOptions; /* asm.c */ #define RZ_MIDFLAGS_HIDE 0 #define RZ_MIDFLAGS_SHOW 1 #define RZ_MIDFLAGS_REALIGN 2 #define RZ_MIDFLAGS_SYMALIGN 3 typedef struct rz_core_asm_hit { ut64 addr; char *code; int len; ut8 valid; } RzCoreAsmHit; /** * \brief Disassemble Options, just for rz_core_print_disasm */ typedef struct rz_core_disasm_options { int invbreak; int cbytes; ///< set false to ignore the constraint of \p len and print \p nlines instructions in rz_core_print_disasm RzAnalysisFunction *function; ///< Disassemble a function RzPVector /**/ *vec; ///< Not print, but append as RzPVector } RzCoreDisasmOptions; #define RZ_CORE_MAX_DISASM (1024 * 1024 * 8) RZ_API RzBuffer *rz_core_syscall(RzCore *core, const char *name, const char *args); RZ_API RzBuffer *rz_core_syscallf(RzCore *core, const char *name, const char *fmt, ...) RZ_PRINTF_CHECK(3, 4); RZ_API RzCoreAsmHit *rz_core_asm_hit_new(void); RZ_API RzList /**/ *rz_core_asm_hit_list_new(void); RZ_API void rz_core_asm_hit_free(void *_hit); RZ_API char *rz_core_asm_search(RzCore *core, const char *input); RZ_API RzCmdStatus rz_core_asm_plugins_print(RZ_NONNULL RZ_BORROW RzCore *core, RZ_OUT RzCmdStateOutput *state, RZ_NULLABLE const char *flags); RZ_API RzCmdStatus rz_core_asm_cpu_plugin_print(RZ_NONNULL RZ_BORROW RzCore *core, RZ_OUT RzCmdStateOutput *state, RZ_NULLABLE const char *arch_name); RZ_API RzCmdStatus rz_core_cpu_descs_print(RZ_NONNULL RzCore *core, RZ_NONNULL const char *plugin); RZ_API RzList /**/ *rz_core_asm_strsearch(RzCore *core, const char *input, ut64 from, ut64 to, int maxhits, int regexp, int everyByte, int mode); RZ_API RzList /**/ *rz_core_asm_bwdisassemble(RzCore *core, ut64 addr, int n, int len); RZ_API RzList /**/ *rz_core_asm_back_disassemble_instr(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding); RZ_API RzList /**/ *rz_core_asm_back_disassemble_byte(RzCore *core, ut64 addr, int len, ut32 hit_count, ut32 extra_padding); RZ_API ut32 rz_core_asm_bwdis_len(RzCore *core, int *len, ut64 *start_addr, ut32 l); RZ_API int rz_core_il_print_rzil(RZ_NONNULL RzCore *core, ut64 addr, RZ_NONNULL ut8 *buf, size_t len, size_t n_lines, RZ_NULLABLE RzCoreILPrintOptions *options); RZ_API int rz_core_print_disasm(RZ_NONNULL RzCore *core, ut64 addr, RZ_NONNULL ut8 *buf, int len, int nlines, RZ_NULLABLE RzCmdStateOutput *state, RZ_NULLABLE RzCoreDisasmOptions *options); RZ_API int rz_core_print_disasm_json(RzCore *core, ut64 addr, ut8 *buf, int len, int lines, PJ *pj); RZ_API int rz_core_print_disasm_instructions_with_buf(RzCore *core, ut64 address, ut8 *buf, int nb_bytes, int nb_opcodes); RZ_API int rz_core_print_disasm_instructions(RzCore *core, int nb_bytes, int nb_opcodes); RZ_API int rz_core_disasm_pdi_with_buf(RzCore *core, ut64 address, ut8 *buf, ut32 nb_opcodes, ut32 nb_bytes, int fmt); RZ_API int rz_core_disasm_pdi(RzCore *core, int nb_opcodes, int nb_bytes, int fmt); RZ_API int rz_core_disasm_pde(RzCore *core, int nb_opcodes, RzCmdStateOutput *state); RZ_API RZ_OWN char *rz_core_disasm_instruction(RzCore *core, ut64 addr, ut64 reladdr, RZ_NULLABLE RzAnalysisFunction *fcn, bool color); RZ_API bool rz_core_print_function_disasm_json(RzCore *core, RzAnalysisFunction *fcn, PJ *pj); RZ_API int rz_core_flag_in_middle(RzCore *core, ut64 at, int oplen, int *midflags); RZ_API int rz_core_bb_starts_in_middle(RzCore *core, ut64 at, int oplen); RZ_API void rz_analysis_disasm_text_free(RzAnalysisDisasmText *t); RZ_API RZ_OWN char *rz_core_get_xref_comment(RZ_NONNULL RzCore *core, ut64 addr); /** * \brief Use RzAsmOp if it is sufficient */ typedef struct { ut64 offset; ut64 size; char *hex; char *assembly; char *assembly_colored; } RzCoreDisasmOp; RZ_API void rz_core_disasm_op_free(RzCoreDisasmOp *x); RZ_API RZ_OWN RzPVector /**/ *rz_core_disasm_all_possible_opcodes(RZ_NONNULL RzCore *core, RZ_NONNULL ut8 *buffer, ut64 addr, ut64 n_bytes); /* cbin.c */ RZ_API bool rz_core_bin_raise(RzCore *core, ut32 bfid); RZ_API bool rz_core_bin_set_cur(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *binfile); RZ_API RZ_BORROW const char *rz_core_bin_get_compile_time(RZ_NONNULL RzBinFile *bf); RZ_API void rz_core_bin_options_init(RzCore *core, RZ_OUT RzBinOptions *opts, int fd, ut64 baseaddr, ut64 loadaddr); RZ_API bool rz_core_bin_apply_strings(RzCore *r, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_config(RzCore *r, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_maps(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_main(RzCore *r, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_dwarf(RzCore *core, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_stabs(RzCore *core, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_entry(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_sections(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_relocs(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_imports(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_symbols(RzCore *core, RzBinFile *binfile, bool va); RZ_API bool rz_core_bin_apply_classes(RzCore *core, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_resources(RzCore *core, RzBinFile *binfile); RZ_API bool rz_core_bin_apply_info(RzCore *r, RzBinFile *binfile, ut32 mask); RZ_API bool rz_core_bin_apply_all_info(RzCore *r, RzBinFile *binfile); RZ_API int rz_core_bin_set_by_fd(RzCore *core, ut64 bin_fd); RZ_API int rz_core_bin_set_by_name(RzCore *core, const char *name); RZ_API bool rz_core_bin_load(RZ_NONNULL RzCore *core, RZ_NULLABLE const char *file_uri, ut64 base_addr); RZ_API void rz_core_bin_set_export_info(RZ_NONNULL RzCore *core); RZ_API bool rz_core_binfiles_print(RzCore *core, RzCmdStateOutput *state); RZ_API bool rz_core_binfiles_delete(RzCore *core, RzBinFile *bf); RZ_API RZ_OWN HtSS *rz_core_bin_create_digests(RzCore *core, ut64 paddr, ut64 size, RzList /**/ *digests); RZ_API void rz_core_bin_print_source_line_sample(RzCore *core, const RzBinSourceLineSample *s, RzCmdStateOutput *state); RZ_API void rz_core_bin_print_source_line_info(RzCore *core, const RzBinSourceLineInfo *li, RzCmdStateOutput *state); RZ_API bool rz_core_sym_is_export(RZ_NONNULL RzBinSymbol *s); RZ_API void rz_core_sysenv_begin(RzCore *core); RZ_API void rz_core_sysenv_end(RzCore *core); RZ_API void rz_core_recover_vars(RzCore *core, RzAnalysisFunction *fcn, bool argonly); // XXX dupe from rz_bin.h /* bin.c */ #define RZ_CORE_BIN_ACC_STRINGS 0x001 #define RZ_CORE_BIN_ACC_INFO 0x002 #define RZ_CORE_BIN_ACC_MAIN 0x004 #define RZ_CORE_BIN_ACC_ENTRIES 0x008 #define RZ_CORE_BIN_ACC_RELOCS 0x010 #define RZ_CORE_BIN_ACC_IMPORTS 0x020 #define RZ_CORE_BIN_ACC_SYMBOLS 0x040 #define RZ_CORE_BIN_ACC_SECTIONS 0x080 #define RZ_CORE_BIN_ACC_FIELDS 0x100 #define RZ_CORE_BIN_ACC_LIBS 0x200 #define RZ_CORE_BIN_ACC_CLASSES 0x400 #define RZ_CORE_BIN_ACC_DWARF 0x800 #define RZ_CORE_BIN_ACC_OMF_DEBUG 0x900 #define RZ_CORE_BIN_ACC_SIZE 0x1000 #define RZ_CORE_BIN_ACC_PDB 0x2000 #define RZ_CORE_BIN_ACC_MEM 0x4000 #define RZ_CORE_BIN_ACC_EXPORTS 0x8000 #define RZ_CORE_BIN_ACC_VERSIONINFO 0x10000 #define RZ_CORE_BIN_ACC_SIGNATURE 0x20000 #define RZ_CORE_BIN_ACC_RAW_STRINGS 0x40000 #define RZ_CORE_BIN_ACC_HEADER 0x80000 #define RZ_CORE_BIN_ACC_RESOURCES 0x100000 #define RZ_CORE_BIN_ACC_INITFINI 0x200000 #define RZ_CORE_BIN_ACC_SEGMENTS 0x400000 #define RZ_CORE_BIN_ACC_BASEFIND 0x800000 #define RZ_CORE_BIN_ACC_LUAC_DEBUG 0x1000000 #define RZ_CORE_BIN_ACC_TRYCATCH 0x20000000 #define RZ_CORE_BIN_ACC_SECTIONS_MAPPING 0x40000000 #define RZ_CORE_BIN_ACC_MAPS 0x80000000 #define RZ_CORE_BIN_ACC_ALL 0x81504FFF #define RZ_CORE_PRJ_FLAGS 0x0001 #define RZ_CORE_PRJ_EVAL 0x0002 #define RZ_CORE_PRJ_IO_MAPS 0x0004 #define RZ_CORE_PRJ_SECTIONS 0x0008 #define RZ_CORE_PRJ_META 0x0010 #define RZ_CORE_PRJ_XREFS 0x0020 #define RZ_CORE_PRJ_FCNS 0x0040 #define RZ_CORE_PRJ_ANALYSIS_HINTS 0x0080 #define RZ_CORE_PRJ_ANALYSIS_TYPES 0x0100 #define RZ_CORE_PRJ_ANALYSIS_MACROS 0x0200 #define RZ_CORE_PRJ_ANALYSIS_SEEK 0x0400 #define RZ_CORE_PRJ_DBG_BREAK 0x0800 #define RZ_CORE_PRJ_ALL 0xFFFF typedef struct rz_core_bin_filter_t { ut64 offset; const char *name; } RzCoreBinFilter; RZ_API bool rz_core_bin_set_arch_bits(RZ_NONNULL RzCore *r, RZ_NULLABLE const char *filename, RZ_NULLABLE const char *arch, ut16 bits); RZ_API int rz_core_bin_update_arch_bits(RzCore *r); RZ_API RZ_OWN char *rz_core_bin_class_build_flag_name(RZ_NONNULL RzBinClass *cls); RZ_API RZ_OWN char *rz_core_bin_super_build_flag_name(RZ_NONNULL RzBinClass *cls); RZ_API RZ_OWN char *rz_core_bin_method_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinSymbol *meth); RZ_API RZ_OWN char *rz_core_bin_field_build_flag_name(RZ_NONNULL RzBinClass *cls, RZ_NONNULL RzBinClassField *field); RZ_API char *rz_core_bin_method_flags_str(ut64 flags, RzOutputMode mode); RZ_API RZ_OWN char *rz_core_bin_pdb_get_filename(RZ_NONNULL RzCore *core); RZ_API bool rz_core_bin_pdb_load(RZ_NONNULL RzCore *core, RZ_NONNULL const char *filename); RZ_API RzPdb *rz_core_pdb_load_info(RZ_NONNULL RzCore *core, RZ_NONNULL const char *file); RZ_API void rz_core_pdb_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzTypeDB *db, RZ_NONNULL RzPdb *pdb, RZ_NONNULL RzCmdStateOutput *state); RZ_API char *rz_core_bin_pdb_gvars_as_string(RZ_NONNULL RzPdb *pdb, const ut64 img_base, RzCmdStateOutput *state); RZ_API RzCmdStatus rz_core_bin_plugins_print(RzBin *bin, RzCmdStateOutput *state); RZ_API bool rz_core_bin_archs_print(RZ_NONNULL RzBin *bin, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_entries_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_initfini_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_exports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter); RZ_API bool rz_core_bin_cur_export_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_symbols_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter); RZ_API bool rz_core_bin_cur_symbol_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_imports_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter); RZ_API bool rz_core_bin_libs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_main_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_relocs_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_sections_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList /**/ *hashes); RZ_API bool rz_core_bin_cur_section_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList /**/ *hashes); RZ_API bool rz_core_bin_cur_segment_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzList /**/ *hashes); RZ_API bool rz_core_bin_segments_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RzCoreBinFilter *filter, RzList /**/ *hashes); RZ_API bool rz_core_bin_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API RZ_OWN RzPVector /**/ *rz_core_bin_whole_strings(RZ_NONNULL RzCore *core, RZ_NULLABLE RzBinFile *bf); RZ_API bool rz_core_bin_whole_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_xrefs_strings_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_file_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_info_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_classes_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_class_as_source_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, const char *class_name); RZ_API bool rz_core_bin_class_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name); RZ_API bool rz_core_bin_class_methods_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, const char *class_name); RZ_API RzCmdStatus rz_core_bin_class_apply_print(RZ_NONNULL RzCore *core, RZ_NONNULL const char *classname, ut64 addr); RZ_API bool rz_core_bin_classes_to_struct(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf); RZ_API bool rz_core_bin_signatures_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_fields_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_dwarf_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_memory_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_resources_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state, RZ_NULLABLE RzList /**/ *hashes); RZ_API bool rz_core_bin_versions_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_trycatch_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_size_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_sections_mapping_print(RZ_NONNULL RzCore *core, RZ_NONNULL RzBinFile *bf, RZ_NONNULL RzCmdStateOutput *state); RZ_API bool rz_core_bin_print(RzCore *core, RZ_NONNULL RzBinFile *bf, ut32 mask, RzCoreBinFilter *filter, RzCmdStateOutput *state, RzList /**/ *hashes); RZ_API bool rz_core_bin_basefind_print(RzCore *core, ut32 pointer_size, RzCmdStateOutput *state); // cmeta.c RZ_API bool rz_core_meta_string_add(RzCore *core, ut64 addr, ut64 size, RzStrEnc encoding, RZ_NULLABLE const char *name); RZ_API bool rz_core_meta_pascal_string_add(RzCore *core, ut64 addr, RzStrEnc encoding, RZ_NULLABLE const char *name); // cprint.c typedef enum { RZ_CORE_PRINT_FORMAT_TYPE_OCTAL = 0, RZ_CORE_PRINT_FORMAT_TYPE_INTEGER, RZ_CORE_PRINT_FORMAT_TYPE_HEXADECIMAL, RZ_CORE_PRINT_FORMAT_TYPE_INVALID, } RzCorePrintFormatType; RZ_API RZ_OWN char *rz_core_print_string_c_cpp(RzCore *core); RZ_API RZ_OWN char *rz_core_hex_of_assembly(RzCore *core, const char *assembly); RZ_API RZ_OWN char *rz_core_esil_of_assembly(RzCore *core, const char *assembly); RZ_API RZ_OWN char *rz_core_assembly_of_hex(RzCore *core, ut8 *hex, int len); RZ_API RZ_OWN char *rz_core_esil_of_hex(RzCore *core, ut8 *hex, int len); RZ_API RZ_OWN char *rz_core_print_hexdump_diff_str(RZ_NONNULL RzCore *core, ut64 aa, ut64 ba, ut64 len); RZ_API RZ_OWN char *rz_core_print_dump_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, ut8 n, int len, RzCorePrintFormatType format); RZ_API RZ_OWN char *rz_core_print_hexdump_or_hexdiff_str(RZ_NONNULL RzCore *core, RzOutputMode mode, ut64 addr, int len, bool use_comment); RZ_API RZ_OWN char *rz_core_print_hexdump_byline_str(RZ_NONNULL RzCore *core, bool hex_offset, ut64 addr, int len, ut8 size); RZ_API RZ_OWN char *rz_core_print_bytes_with_inst(RZ_NONNULL RzCore *core, RZ_NONNULL const ut8 *buf, ut64 addr, int len); typedef enum { RZ_CORE_DISASM_STRINGS_MODE_BYTES = 0, RZ_CORE_DISASM_STRINGS_MODE_INST, RZ_CORE_DISASM_STRINGS_MODE_BLOCK, RZ_CORE_DISASM_STRINGS_MODE_FUNCTION, } RzCorePrintDisasmStringsMode; RZ_API RZ_OWN char *rz_core_print_disasm_strings(RZ_NONNULL RzCore *core, RzCorePrintDisasmStringsMode mode, ut64 n_bytes, RZ_NULLABLE RzAnalysisFunction *fcn); /* rtr */ RZ_API bool rz_core_rtr_init(RZ_NONNULL RzCore *core); RZ_API void rz_core_rtr_cmds(RzCore *core, const char *port); RZ_API char *rz_core_rtr_cmds_query(RzCore *core, const char *host, const char *port, const char *cmd); RZ_API void rz_core_rtr_pushout(RzCore *core, const char *input); RZ_API void rz_core_rtr_list(RzCore *core); RZ_API void rz_core_rtr_add(RzCore *core, const char *input); RZ_API void rz_core_rtr_remove(RzCore *core, const char *input); RZ_API void rz_core_rtr_session(RzCore *core, const char *input); RZ_API void rz_core_rtr_cmd(RzCore *core, const char *input); RZ_API bool rz_core_rtr_http(RzCore *core, bool open_browser); RZ_API bool rz_core_rtr_gdb(RzCore *core, ut32 port, const char *file_path, RZ_NULLABLE const char *gdb_args, bool debug_msg); /// Legacy search RZ_API int rz_core_search_preludes(RzCore *core, bool log); RZ_API int rz_core_search_prelude(RzCore *core, ut64 from, ut64 to, const ut8 *buf, int blen, const ut8 *mask, int mlen); #define RZ_CORE_BOUNDARIES_PERMS_ANY 0 #define RZ_CORE_BOUNDARIES_MASK_NONE 0 RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_raw(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_block(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_current_function(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_current_function_bb(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_current_io_map(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_current_bin_section(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_current_bin_segment(RZ_NONNULL RzCore *core, const RzInterval interval); #define rz_core_get_boundaries_range rz_core_get_boundaries_all_io_maps #define rz_core_get_boundaries_all_io_maps(core, interval) \ rz_core_get_boundaries_io_maps(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE) RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_io_maps(RZ_NONNULL RzCore *core, const RzInterval interval, int perms, int perms_mask); #define rz_core_get_boundaries_all_io_skyline(core, interval) \ rz_core_get_boundaries_io_skyline(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE) RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_io_skyline(RZ_NONNULL RzCore *core, const RzInterval interval, int perms, int perms_mask); #define rz_core_get_boundaries_all_bin_segments(core, interval) \ rz_core_get_boundaries_bin_segments(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE) RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_bin_segments(RZ_NONNULL RzCore *core, const RzInterval interval, int perms, int perms_mask); #define rz_core_get_boundaries_all_bin_sections(core, interval) \ rz_core_get_boundaries_bin_sections(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE) RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_bin_sections(RZ_NONNULL RzCore *core, const RzInterval interval, int perms, int perms_mask); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_code_only(RZ_NONNULL RzCore *core, const RzInterval interval); #define rz_core_get_boundaries_current_debug_map(core, interval) \ rz_core_get_boundaries_debug_maps(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE, true) #define rz_core_get_boundaries_all_debug_maps(core, interval) \ rz_core_get_boundaries_debug_maps(core, interval, RZ_CORE_BOUNDARIES_PERMS_ANY, RZ_CORE_BOUNDARIES_MASK_NONE, false) RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_debug_maps(RZ_NONNULL RzCore *core, const RzInterval interval, int perms, int perms_mask, bool current); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_debug_heap(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_debug_stack(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_debug_program(RZ_NONNULL RzCore *core, const RzInterval interval); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries_select(RZ_NONNULL RzCore *core, RZ_NONNULL const char *from_key, RZ_NONNULL const char *to_key, RZ_NONNULL const char *in_key); RZ_API RZ_OWN RzList /**/ *rz_core_get_boundaries(RZ_NONNULL RzCore *core, RzInterval interval, const char *region); RZ_API bool rz_core_hack(RzCore *core, const char *op); RZ_API bool rz_core_dump(RzCore *core, const char *file, ut64 addr, ut64 size, int append); RZ_API RZ_OWN char *rz_core_clippy(RZ_NONNULL RzCore *core, RZ_NONNULL const char *msg); // TODO MOVE SOMEWHERE ELSE typedef char *(*PrintItemCallback)(void *user, void *p, bool selected); RZ_API char *rz_str_widget_list(void *user, RzList /**/ *list, int rows, int cur, PrintItemCallback cb); /* help */ RZ_API void rz_core_cmd_help(const RzCore *core, const char *help[]); RZ_DEPRECATE RZ_API const char **rz_core_help_vars_get(RzCore *core); /* analysis stats */ /** * Single sub-range of statistics as part of an entire RzCoreAnalysisStats. * * The range that this covers is given by rz_core_analysis_stats_get_block_from()/to(). */ typedef struct { ut32 youarehere; ut32 flags; ut32 comments; ut32 functions; ut32 blocks; ut32 in_functions; ut32 symbols; ut32 strings; ut32 signatures; ut32 imports; ut32 perm; } RzCoreAnalysisStatsItem; /** * Statistics for a range of memory, split up into smaller blocks. */ typedef struct { ut64 from; ut64 to; ut64 step; RzVector /**/ blocks; } RzCoreAnalysisStats; RZ_API char *rz_core_analysis_hasrefs(RzCore *core, ut64 value, RzOutputMode mode); RZ_API char *rz_core_analysis_get_comments(RzCore *core, ut64 addr); RZ_API RZ_OWN RzCoreAnalysisStats *rz_core_analysis_get_stats(RZ_NONNULL RzCore *a, ut64 from, ut64 to, ut64 step); RZ_API void rz_core_analysis_stats_free(RzCoreAnalysisStats *s); RZ_API ut64 rz_core_analysis_stats_get_block_from(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i); RZ_API ut64 rz_core_analysis_stats_get_block_to(RZ_NONNULL const RzCoreAnalysisStats *s, size_t i); RZ_API RZ_OWN char *rz_core_syscall_as_string(RzCore *core, st64 num, ut64 addr); /* tasks */ typedef enum { RZ_CORE_TASK_STATE_BEFORE_START, RZ_CORE_TASK_STATE_RUNNING, RZ_CORE_TASK_STATE_SLEEPING, RZ_CORE_TASK_STATE_DONE } RzTaskState; typedef enum { RZ_CORE_TASK_JOIN_ERR_SUCCESS = 0, ///< Join success! RZ_CORE_TASK_JOIN_ERR_CURRENT, ///< Join on current task RZ_CORE_TASK_JOIN_ERR_NO_TASK, ///< No task has given id RZ_CORE_TASK_JOIN_ERR_ONE_NO_SEM, ///< No join semaphore when joining on one task RZ_CORE_TASK_JOIN_ERR_ALL_NO_SEM ///< No join semaphore when joining on all tasks } RzCoreTaskJoinErr; /** * Main payload of a task, the function that should be executed asynchronously. */ typedef void (*RzCoreTaskRunner)(RzCoreTaskScheduler *sched, void *user); /** * Task-specific callback to free/cleanup any runner-specific data. */ typedef void (*RzCoreTaskRunnerFree)(void *user); struct rz_core_task_t { RzCoreTaskScheduler *sched; int id; RzTaskState state; bool transient; // delete when finished int refcount; RzThreadSemaphore *running_sem; bool dispatched; RzThreadCond *dispatch_cond; RzThreadLock *dispatch_lock; RzThread *thread; bool breaked; RzCoreTaskRunner runner; // will be NULL for main task RzCoreTaskRunnerFree runner_free; void *runner_user; }; typedef void (*RzCoreTaskOneShot)(void *); RZ_API RzTable *rz_core_table(RzCore *core); RZ_API void rz_core_task_scheduler_init(RzCoreTaskScheduler *sched, RzCoreTaskContextSwitch ctx_switch, void *ctx_switch_user, RzCoreTaskBreak break_cb, void *break_cb_user); RZ_API void rz_core_task_scheduler_fini(RzCoreTaskScheduler *tasks); RZ_API RzCoreTask *rz_core_task_get_incref(RzCoreTaskScheduler *scheduler, int id); RZ_API int rz_core_task_running_tasks_count(RzCoreTaskScheduler *scheduler); RZ_API RzCoreTask *rz_core_task_new(RzCoreTaskScheduler *sched, RzCoreTaskRunner runner, RzCoreTaskRunnerFree runner_free, void *runner_user); RZ_API void rz_core_task_incref(RzCoreTask *task); RZ_API void rz_core_task_decref(RzCoreTask *task); RZ_API void rz_core_task_enqueue(RzCoreTaskScheduler *scheduler, RzCoreTask *task); RZ_API void rz_core_task_enqueue_oneshot(RzCoreTaskScheduler *scheduler, RzCoreTaskOneShot func, void *user); RZ_API int rz_core_task_run_sync(RzCoreTaskScheduler *scheduler, RzCoreTask *task); RZ_API void rz_core_task_sync_begin(RzCoreTaskScheduler *scheduler); RZ_API void rz_core_task_sync_end(RzCoreTaskScheduler *scheduler); RZ_API void rz_core_task_yield(RzCoreTaskScheduler *scheduler); RZ_API void rz_core_task_sleep_begin(RzCoreTask *task); RZ_API void rz_core_task_sleep_end(RzCoreTask *task); RZ_API void rz_core_task_break(RzCoreTaskScheduler *scheduler, int id); RZ_API void rz_core_task_break_all(RzCoreTaskScheduler *scheduler); RZ_API int rz_core_task_del(RzCoreTaskScheduler *scheduler, int id); RZ_API RzCoreTask *rz_core_task_self(RzCoreTaskScheduler *scheduler); RZ_API RzCoreTaskJoinErr rz_core_task_join(RzCoreTaskScheduler *scheduler, RzCoreTask *current, int id); typedef void (*inRangeCb)(RzCore *core, ut64 from, ut64 to, int vsize, void *cb_user); RZ_API int rz_core_search_value_in_range(RzCore *core, RzInterval search_itv, ut64 vmin, ut64 vmax, int vsize, inRangeCb cb, void *cb_user); // core-specific tasks typedef void (*RzCoreCmdTaskFinished)(const char *res, void *user); RZ_API RzCoreTask *rz_core_cmd_task_new(RzCore *core, const char *cmd, RzCoreCmdTaskFinished finished_cb, void *finished_cb_user); RZ_API const char *rz_core_cmd_task_get_result(RzCoreTask *task); typedef void *(*RzCoreTaskFunction)(RzCore *core, void *user); RZ_API RzCoreTask *rz_core_function_task_new(RzCore *core, RzCoreTaskFunction fcn, void *fcn_user); RZ_API void *rz_core_function_task_get_result(RzCoreTask *task); RZ_API const char *rz_core_task_status(RzCoreTask *task); RZ_API bool rz_core_task_is_cmd(RzCore *core, int id); RZ_API void rz_core_task_del_all_done(RzCore *core); RZ_API void rz_core_analysis_propagate_noreturn(RzCore *core, ut64 addr); RZ_API bool rz_core_flirt_dump_file(RZ_NONNULL const char *flirt_file); RZ_API bool rz_core_flirt_create_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *output_file, RZ_NULLABLE ut32 *written_nodes); RZ_API bool rz_core_flirt_convert_file(RZ_NONNULL RzCore *core, RZ_NONNULL const char *input_file, RZ_NONNULL const char *ouput_file); RZ_API const char *rz_core_flirt_arch_from_id(ut8 arch); RZ_API ut8 rz_core_flirt_arch_from_name(RZ_NONNULL const char *arch); RZ_API ut32 rz_core_flirt_file_from_option_list(RZ_NONNULL const char *file_list); RZ_API ut16 rz_core_flirt_os_from_option_list(RZ_NONNULL const char *os_list); RZ_API ut16 rz_core_flirt_app_from_option_list(RZ_NONNULL const char *app_list); /* DECOMPILER PRINTING FUNCTIONS */ /** * @brief Prints the data contained in the specified RzAnnotatedCode in JSON format. * * The function will print the output in console using the function rz_cons_printf(); * * @param code Pointer to a RzAnnotatedCode. */ RZ_API void rz_core_annotated_code_print_json(RzAnnotatedCode *code); /** * @brief Prints the decompiled code from the specified RzAnnotatedCode. * * This function is used for printing the output of commands pdg and pdgo. * It can print the decompiled code with or without offsets. If line_offsets is a null pointer, * the output will be printed without offsets (pdg), otherwise, the output will be * printed with offsets. * This function will print the output in console using the function rz_cons_printf(); * * @param code Pointer to a RzAnnotatedCode. * @param line_offsets Pointer to a @ref RzVector that contains offsets for the decompiled code. */ RZ_API void rz_core_annotated_code_print(RzAnnotatedCode *code, RzVector /**/ *line_offsets); /** * @brief Prints the decompiled code as comments * * This function is used for the output of command pdg* * Output will be printed in console using the function rz_cons_printf(); * * @param code Pointer to a RzAnnotatedCode. */ RZ_API void rz_core_annotated_code_print_comment_cmds(RzAnnotatedCode *code); /* serialize */ /** * @param prj_file filename of the project that db will be saved to later. This is only used to re-locate the loaded RIO descs, the project file itself is not touched by this function. */ RZ_API void rz_serialize_core_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE const char *prj_file); /** * @param load_bin_io whether to also load the underlying RIO and RBin state from the project. If false, the current state will be kept and the project loaded on top. * @param prj_file filename of the project that db comes from. This is only used to re-locate the loaded RIO descs, the project file itself is not touched by this function. */ RZ_API bool rz_serialize_core_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, bool load_bin_io, RZ_NULLABLE const char *prj_file, RZ_NULLABLE RzSerializeResultInfo *res); RZ_API void rz_serialize_core_seek_save(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core); RZ_API bool rz_serialize_core_seek_load(RZ_NONNULL Sdb *db, RZ_NONNULL RzCore *core, RZ_NULLABLE RzSerializeResultInfo *res); /** * \brief Load a project and print info and errors */ RZ_API bool rz_core_project_load_for_cli(RzCore *core, const char *file, bool load_bin_io); RZ_API bool rz_platform_index_add_flags_comments(RzCore *core); /* regs */ /// Callback for synchronizing register state in commands (only relevant for debug, not for analysis) typedef bool (*RzCmdRegSync)(RzCore *core, RzRegisterType type, bool write); RZ_API bool rz_core_reg_assign_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NONNULL const char *name, ut64 val); RZ_API RZ_OWN RzList /**/ *rz_core_reg_filter_items_sync(RZ_NONNULL RzCore *core, RZ_NONNULL RzReg *reg, RzCmdRegSync sync_cb, RZ_NULLABLE const char *filter); RZ_API void rz_core_rtr_enable(RZ_NONNULL RzCore *core, const char *cmdremote); RZ_API RZ_OWN char *rz_core_analysis_var_to_string(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisVar *var); RZ_API RZ_OWN char *rz_core_analysis_var_display(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisVar *var, bool add_name); RZ_API ut64 rz_core_analysis_var_addr(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisVar *var); RZ_API RZ_BORROW const RzBinSourceLineSample *rz_analysis_function_sourceline_information(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisFunction *fcn); RZ_API RZ_BORROW const RzBinSourceLineSample *rz_analysis_var_global_sourceline_information(RZ_NONNULL RzCore *core, RZ_NONNULL RzAnalysisVarGlobal *glb); RZ_API void rz_core_sym_name_init(RZ_NONNULL RZ_OUT RzBinSymNames *names, RZ_NONNULL RzBinSymbol *symbol, bool demangle); RZ_API void rz_core_sym_name_fini(RZ_NULLABLE RzBinSymNames *names); RZ_API void rz_core_analysis_bytes_il(RZ_NONNULL RzCore *core, ut64 len, ut64 num_ops, bool pretty, bool unicode); RZ_API bool rz_core_disasm_until_ret(RZ_NONNULL RzCore *core, ut64 addr, int limit, RzOutputMode mode, bool ret_val, RZ_NULLABLE RZ_OUT RzStrBuf *buf); RZ_API RZ_OWN RzList /**/ *rz_core_setup_io_search_parameters(RzCore *core, RZ_NULLABLE RZ_OUT RzSearchOpt *search_opts); RZ_API RZ_OWN RzSearchFindOpt *rz_core_setup_default_search_find_opts(RzCore *core); RZ_API RZ_OWN RzList /**/ *rz_core_search_bytes(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, RZ_NONNULL RZ_OWN RzSearchBytesPattern *pattern); RZ_API RZ_OWN RzList /**/ *rz_core_search_values(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, RZ_NONNULL RZ_OWN RzVector /**/ *vranges); RZ_API RZ_OWN RzList /**/ *rz_core_search_string(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NONNULL RzSearchOpt *user_opts, RZ_NONNULL const char *string, size_t string_len, RzRegexFlags flags, RzStrEnc expected); RZ_API RZ_OWN RzList /**/ *rz_core_search_cryptographic_material(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, RzSearchCollectionCryptographicType type); RZ_API RZ_OWN RzList /**/ *rz_core_search_hash(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, RZ_NONNULL const char *algo_name, RZ_NONNULL const char *expected_digits, ut64 block_size); RZ_API RZ_OWN RzList /**/ *rz_core_search_entropy(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, bool fractional, double min_inclusive_limit, double max_inclusive_limit, ut64 block_size); RZ_API RZ_OWN RzList /**/ *rz_core_search_magic(RZ_NONNULL RzCore *core, RZ_BORROW RZ_NULLABLE RzSearchOpt *user_opts, RZ_NULLABLE const char *magic_dir); #endif #ifdef __cplusplus } #endif #endif