rz_main.h File Reference

#include <rz_types.h>
#include <rz_getopt.h>

Go to the source code of this file.

Classes
struct	rz_main_t

Macros
#define	MAIN_NAME   main
#define	ARGV_TYPE   char
#define	ARGV_TYPE_TO_UTF8(argc, argv)   (char **)argv
#define	FREE_UTF8_ARGV(argc, utf8_argv)

Typedefs
typedef struct rz_main_t	RzMain
typedef int(*	RzMainCallback) (int argc, const char **argv)

Functions
	RZ_LIB_VERSION_HEADER (rz_main)
RZ_API RzMain *	rz_main_new (const char *name)
RZ_API void	rz_main_free (RzMain *m)
RZ_API int	rz_main_run (RzMain *m, int argc, const char **argv)
RZ_API int	rz_main_version_print (const char *program)
RZ_API int	rz_main_rz_ax (int argc, const char **argv)
RZ_API int	rz_main_rz_run (int argc, const char **argv)
RZ_API int	rz_main_rz_hash (int argc, const char **argv)
RZ_API int	rz_main_rz_bin (int argc, const char **argv)
RZ_API int	rz_main_rizin (int argc, const char **argv)
RZ_API int	rz_main_rz_asm (int argc, const char **argv)
RZ_API int	rz_main_rz_agent (int argc, const char **argv)
RZ_API int	rz_main_rz_find (int argc, const char **argv)
RZ_API int	rz_main_rz_diff (int argc, const char **argv)
RZ_API int	rz_main_rz_gg (int argc, const char **argv)
RZ_API int	rz_main_rz_sign (int argc, const char **argv)

Macro Definition Documentation

ARGV_TYPE

#define ARGV_TYPE   char

Definition at line 29 of file rz_main.h.

ARGV_TYPE_TO_UTF8

#define ARGV_TYPE_TO_UTF8	(		argc,
			argv
	)		(char **)argv

Definition at line 30 of file rz_main.h.

FREE_UTF8_ARGV

#define FREE_UTF8_ARGV	(		argc,
			utf8_argv
	)

Definition at line 31 of file rz_main.h.

MAIN_NAME

#define MAIN_NAME   main

Definition at line 28 of file rz_main.h.

Typedef Documentation

RzMain

typedef struct rz_main_t RzMain

RzMainCallback

typedef int(* RzMainCallback) (int argc, const char **argv)

Definition at line 34 of file rz_main.h.

Function Documentation

RZ_LIB_VERSION_HEADER()

RZ_LIB_VERSION_HEADER

(

rz_main

)

rz_main_free()

RZ_API void rz_main_free

(

RzMain *

m

)

Definition at line 40 of file main.c.

                                    {
    free(m);
}

References free(), and regress::m.

Referenced by MAIN_NAME().

rz_main_new()

RZ_API RzMain* rz_main_new

(

const char *

name

)

Definition at line 24 of file main.c.

                                             {
    int i = 0;
    while (foo[i].name) {
        if (!strcmp(name, foo[i].name)) {
            RzMain *m = RZ_NEW0(RzMain);
            if (m) {
                m->name = strdup(foo[i].name);
                m->main = foo[i].main;
            }
            return m;
        }
        i++;
    }
    return NULL;
}

References foo, i, regress::m, rz_main_t::main, NULL, RZ_NEW0, and strdup().

Referenced by MAIN_NAME().

rz_main_rizin()

RZ_API int rz_main_rizin	(	int	argc,
		const char **	argv
	)

Definition at line 370 of file rizin.c.

                                                      {
    RzCore *r;
    bool forcequit = false;
    bool haveRarunProfile = false;
    RzListIter *iter;
    int do_analysis = 0;
    char *cmdn, *tmp;
    RzCoreFile *fh = NULL;
    RzIODesc *iod = NULL;
    const char *prj = NULL;
    int debug = 0;
    int zflag = 0;
    bool do_connect = false;
    bool fullfile = false;
    bool zerosep = false;
    int help = 0;
    enum { LOAD_BIN_ALL,
        LOAD_BIN_NOTHING,
        LOAD_BIN_STRUCTURES_ONLY } load_bin = LOAD_BIN_ALL;
    bool run_rc = true;
    int ret, c, perms = RZ_PERM_RX;
    ut64 baddr = UT64_MAX;
    ut64 seek = UT64_MAX;
    bool do_list_io_plugins = false;
    char *file = NULL;
    char *pfile = NULL;
    const char *asmarch = NULL;
    const char *asmos = NULL;
    const char *forcebin = NULL;
    const char *asmbits = NULL;
    char *customRarunProfile = NULL;
    ut64 mapaddr = 0LL;
    bool quiet = false;
    bool quietLeak = false;
    int is_gdb = false;
    const char *s_seek = NULL;
    bool compute_hashes = true;
    RzList *cmds = rz_list_new();
    RzList *evals = rz_list_new();
    RzList *files = rz_list_new();
    RzList *prefiles = rz_list_new();
    RzCmdStateOutput state = { 0 };
 
#define LISTS_FREE() \
    { \
        rz_list_free(cmds); \
        rz_list_free(evals); \
        rz_list_free(files); \
        rz_list_free(prefiles); \
    }
 
    bool noStderr = false;
 
#ifdef __UNIX
    sigset_t sigBlockMask;
    sigemptyset(&sigBlockMask);
    sigaddset(&sigBlockMask, SIGWINCH);
    rz_signal_sigmask(SIG_BLOCK, &sigBlockMask, NULL);
#endif
 
    rz_sys_env_init();
    // Create rz-run profile with startup environ
    char **env = rz_sys_get_environ();
    char *envprofile = rz_run_get_environ_profile(env);
 
    if (rz_sys_getenv_asbool("RZ_DEBUG")) {
        char *sysdbg = rz_sys_getenv("RZ_DEBUG_TOOL");
        char *fmt = (sysdbg && *sysdbg)
            ? rz_str_newf("%s %%d", sysdbg)
#if __APPLE__
            : rz_str_newf("lldb -p %%d");
#else
            : rz_str_newf("gdb --pid %%d");
#endif
        rz_sys_crash_handler(fmt);
        free(fmt);
        free(sysdbg);
    }
 
    r = rz_core_new();
    if (!r) {
        RZ_LOG_ERROR("Cannot initialize RzCore\n");
        LISTS_FREE();
        free(envprofile);
        return 1;
    }
    r->rz_main_rizin = rz_main_rizin;
    r->rz_main_rz_diff = rz_main_rz_diff;
    r->rz_main_rz_find = rz_main_rz_find;
    r->rz_main_rz_bin = rz_main_rz_bin;
    r->rz_main_rz_gg = rz_main_rz_gg;
    r->rz_main_rz_asm = rz_main_rz_asm;
    r->rz_main_rz_ax = rz_main_rz_ax;
 
    r->io->envprofile = envprofile;
 
    rz_core_task_sync_begin(&r->tasks);
    // HACK TO PERMIT '#!/usr/bin/rz - -i' hashbangs
    if (argc > 2 && !strcmp(argv[1], "-") && !strcmp(argv[2], "-i")) {
        argv[1] = argv[0];
        argc--;
        argv++;
    }
 
    // -H option without argument
    if (argc == 2 && !strcmp(argv[1], "-H")) {
        main_print_var(NULL);
        LISTS_FREE();
        return 0;
    }
 
    set_color_default(r);
    bool load_l = true;
    char *debugbackend = strdup("native");
 
    RzGetopt opt;
    rz_getopt_init(&opt, argc, argv, "=02AMCwxfF:H:hm:e:nk:NdqQs:p:b:B:a:Lui:I:l:R:r:c:D:vVSTzuXt");
    while (argc >= 2 && (c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case '-':
            RZ_LOG_ERROR("%c: invalid combinations of argument flags - %s\n", opt.opt, opt.argv[2]);
            ret = 1;
            goto beach;
            break;
        case '=':
            RZ_FREE(r->cmdremote);
            r->cmdremote = strdup("");
            break;
        case '2':
            noStderr = true;
            break;
        case '0':
            zerosep = true;
            /* implicit -q */
            rz_config_set(r->config, "scr.interactive", "false");
            rz_config_set(r->config, "scr.prompt", "false");
            rz_config_set_i(r->config, "scr.color", COLOR_MODE_DISABLED);
            quiet = true;
            break;
        case 'u':
            rz_config_set(r->config, "bin.filter", "false");
            break;
        case 'a':
            asmarch = opt.arg;
            break;
        case 'z':
            zflag++;
            break;
        case 'A':
            do_analysis += do_analysis ? 1 : 2;
            break;
        case 'b':
            asmbits = opt.arg;
            break;
        case 'B':
            baddr = rz_num_math(r->num, opt.arg);
            break;
        case 'X':
            rz_config_set(r->config, "bin.usextr", "false");
            break;
        case 'c':
            rz_list_append(cmds, (void *)opt.arg);
            break;
        case 'C':
            do_connect = true;
            break;
#if DEBUGGER
        case 'd': debug = 1; break;
#else
        case 'd':
            RZ_LOG_ERROR("Sorry. No debugger backend available.\n");
            return 1;
#endif
        case 'D': {
            debug = 2;
            free(debugbackend);
            debugbackend = strdup(opt.arg);
            RzCmdStateOutput state = { 0 };
            rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_QUIET);
            if (!strcmp(opt.arg, "?")) {
                rz_core_debug_plugins_print(r, &state);
                rz_cmd_state_output_print(&state);
                rz_cmd_state_output_fini(&state);
                rz_cons_flush();
                LISTS_FREE();
                return 0;
            }
            break;
        }
        case 'e':
            if (!strcmp(opt.arg, "q")) {
                rz_core_cmd0(r, "eq");
            } else {
                rz_config_eval(r->config, opt.arg);
                rz_list_append(evals, (void *)opt.arg);
            }
            break;
        case 'f':
            fullfile = true;
            break;
        case 'F':
            forcebin = opt.arg;
            break;
        case 'h':
            help++;
            break;
        case 'H':
            main_print_var(opt.arg);
            LISTS_FREE();
            return 0;
        case 'i':
            if (RZ_STR_ISEMPTY(opt.arg)) {
                RZ_LOG_ERROR("Cannot open empty script path\n");
                ret = 1;
                goto beach;
            }
            rz_list_append(files, (void *)opt.arg);
            break;
        case 'I':
            if (RZ_STR_ISEMPTY(opt.arg)) {
                RZ_LOG_ERROR("Cannot open empty script path\n");
                ret = 1;
                goto beach;
            }
            rz_list_append(prefiles, (void *)opt.arg);
            break;
        case 'k':
            asmos = opt.arg;
            break;
        case 'l':
            rz_lib_open(r->lib, opt.arg);
            break;
        case 'L':
            do_list_io_plugins = true;
            break;
        case 'm':
            mapaddr = rz_num_math(r->num, opt.arg);
            s_seek = opt.arg;
            rz_config_set_i(r->config, "file.offset", mapaddr);
            break;
        case 'M':
            rz_config_set(r->config, "bin.demangle", "false");
            rz_config_set(r->config, "asm.demangle", "false");
            break;
        case 'n':
            if (load_bin == LOAD_BIN_ALL) { // "-n"
                load_bin = LOAD_BIN_NOTHING;
            } else if (load_bin == LOAD_BIN_NOTHING) { // second n => "-nn"
                load_bin = LOAD_BIN_STRUCTURES_ONLY;
            }
            rz_config_set(r->config, "file.info", "false");
            break;
        case 'N':
            if (run_rc) {
                run_rc = false;
            } else {
                load_l = false;
            }
            break;
        case 'p':
            prj = *opt.arg ? opt.arg : NULL;
            break;
        case 'Q':
            quiet = true;
            quietLeak = true;
            break;
        case 'q':
            rz_config_set(r->config, "scr.interactive", "false");
            rz_config_set(r->config, "scr.prompt", "false");
            rz_config_set(r->config, "cfg.fortunes", "false");
            if (quiet) {
                forcequit = true;
            }
            quiet = true;
            break;
        case 'r':
            if (RZ_STR_ISEMPTY(opt.arg)) {
                RZ_LOG_ERROR("Cannot open empty rz-run profile path\n");
                ret = 1;
                goto beach;
            }
            haveRarunProfile = true;
            rz_config_set(r->config, "dbg.profile", opt.arg);
            break;
        case 'R':
            customRarunProfile = rz_str_appendf(customRarunProfile, "%s\n", opt.arg);
            break;
        case 's':
            s_seek = opt.arg;
            break;
#if USE_THREADS
        case 't':
#if ALLOW_THREADED
            threaded = true;
#else
            eprintf("WARNING: -t is temporarily disabled!\n");
#endif
            break;
#endif
        case 'T':
            compute_hashes = false;
            break;
        case 'v':
            if (quiet) {
                printf("%s\n", RZ_VERSION);
                LISTS_FREE();
                RZ_FREE(debugbackend);
                free(customRarunProfile);
                return 0;
            } else {
                rz_main_version_verify(0);
                LISTS_FREE();
                RZ_FREE(debugbackend);
                free(customRarunProfile);
                return rz_main_version_print("rizin");
            }
        case 'V':
            return rz_main_version_verify(1);
        case 'w':
            perms |= RZ_PERM_W;
            break;
        case 'x':
            perms &= ~RZ_PERM_X;
            rz_config_set(r->config, "io.exec", "false");
            break;
        default:
            help++;
        }
    }
    if (noStderr) {
        if (-1 == close(2)) {
            RZ_LOG_ERROR("Failed to close stderr");
            LISTS_FREE();
            RZ_FREE(debugbackend);
            return 1;
        }
        const char nul[] = RZ_SYS_DEVNULL;
        int new_stderr = open(nul, O_RDWR);
        if (-1 == new_stderr) {
            RZ_LOG_ERROR("Failed to open %s", nul);
            LISTS_FREE();
            RZ_FREE(debugbackend);
            return 1;
        }
        if (2 != new_stderr) {
            if (-1 == dup2(new_stderr, 2)) {
                RZ_LOG_ERROR("Failed to dup2 stderr");
                LISTS_FREE();
                RZ_FREE(debugbackend);
                return 1;
            }
            if (-1 == close(new_stderr)) {
                RZ_LOG_ERROR("Failed to close %s", nul);
                LISTS_FREE();
                RZ_FREE(debugbackend);
                return 1;
            }
        }
    }
    {
        const char *dbg_profile = rz_config_get(r->config, "dbg.profile");
        if (dbg_profile && *dbg_profile) {
            char *msg = rz_file_slurp(dbg_profile, NULL);
            if (msg) {
                char *program = strstr(msg, "program=");
                if (program) {
                    program += 8;
                    char *p = 0;
                    p = strstr(program, "\r\n");
                    if (!p) {
                        p = strchr(program, '\n');
                    }
                    if (p) {
                        *p = 0;
                        pfile = strdup(program);
                    }
                }
                free(msg);
            } else {
                eprintf("Cannot read dbg.profile '%s'\n", dbg_profile);
                pfile = NULL; // strdup ("");
            }
        } else {
            pfile = argv[opt.ind] ? strdup(argv[opt.ind]) : NULL;
        }
    }
 
    if (pfile && !*pfile) {
        RZ_LOG_ERROR("Cannot open empty path\n");
        ret = 1;
        goto beach;
    }
 
    if (do_list_io_plugins) {
        if (rz_config_get_i(r->config, "cfg.plugins")) {
            rz_core_loadlibs(r, RZ_CORE_LOADLIBS_ALL);
        }
        run_commands(r, NULL, prefiles, false, do_analysis);
        run_commands(r, cmds, files, quiet, do_analysis);
        if (quietLeak) {
            exit(0);
        }
        rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD);
        rz_core_io_plugins_print(r->io, &state);
        rz_cmd_state_output_print(&state);
        rz_cmd_state_output_fini(&state);
        rz_cons_flush();
        LISTS_FREE();
        free(pfile);
        RZ_FREE(debugbackend);
        return 0;
    }
 
    if (help > 0) {
        LISTS_FREE();
        free(pfile);
        RZ_FREE(debugbackend);
        return main_help(help > 1 ? 2 : 0);
    }
    if (customRarunProfile) {
        char *tfn = rz_file_temp(".rz-run");
        if (!rz_file_dump(tfn, (const ut8 *)customRarunProfile, strlen(customRarunProfile), 0)) {
            eprintf("Cannot create %s\n", tfn);
        } else {
            haveRarunProfile = true;
            rz_config_set(r->config, "dbg.profile", tfn);
        }
        free(tfn);
    }
    if (debug == 1) {
        if (opt.ind >= argc && !haveRarunProfile) {
            RZ_LOG_ERROR("Missing argument for -d\n");
            LISTS_FREE();
            RZ_FREE(debugbackend);
            return 1;
        }
        const char *src = haveRarunProfile ? pfile : argv[opt.ind];
        if (src && *src) {
            char *uri = strdup(src);
            if (uri) {
                char *p = strstr(uri, "://");
                if (p) {
                    *p = 0;
                    // TODO: this must be specified by the io plugin, not hardcoded here
                    if (!strcmp(uri, "winedbg")) {
                        debugbackend = strdup("io");
                    } else {
                        debugbackend = uri;
                        uri = NULL;
                    }
                    debug = 2;
                }
                free(uri);
            }
        }
    }
 
    tmp = NULL;
    if (!load_l || (tmp = rz_sys_getenv("RZ_NOPLUGINS"))) {
        rz_config_set_i(r->config, "cfg.plugins", 0);
        free(tmp);
    }
    if (rz_config_get_i(r->config, "cfg.plugins")) {
        rz_core_loadlibs(r, RZ_CORE_LOADLIBS_ALL);
    }
    run_commands(r, NULL, prefiles, false, do_analysis);
    rz_list_free(prefiles);
    prefiles = NULL;
 
    rz_bin_force_plugin(r->bin, forcebin);
 
    if (prj) {
        rz_core_project_load_for_cli(r, prj, !pfile);
    }
 
    if (do_connect) {
        const char *uri = argv[opt.ind];
        if (opt.ind >= argc) {
            RZ_LOG_ERROR("Missing URI for -C\n");
            LISTS_FREE();
            RZ_FREE(debugbackend);
            return 1;
        }
        if (strstr(uri, "://")) {
            rz_core_cmdf(r, "R+ %s", uri);
        } else {
            argv[opt.ind] = rz_str_newf("http://%s/cmd/", argv[opt.ind]);
            rz_core_cmdf(r, "R+ %s", argv[opt.ind]);
        }
        rz_core_cmd0(r, "R!=");
        argv[opt.ind] = "-";
    }
 
    switch (zflag) {
    case 1:
        rz_config_set(r->config, "bin.strings", "false");
        break;
    default:
        break;
    }
    if (zflag > 3) {
        eprintf("Sleeping now...\n");
        rz_sys_sleep(zflag);
    }
 
    if (run_rc) {
        rz_core_parse_rizinrc(r);
    } else {
        rz_config_set(r->config, "scr.utf8", "false");
    }
 
    if (pfile && rz_file_is_directory(pfile)) {
        if (debug) {
            RZ_LOG_ERROR("Error: Cannot debug directories, yet.\n");
            LISTS_FREE();
            free(pfile);
            RZ_FREE(debugbackend);
            return 1;
        }
        if (rz_sys_chdir(argv[opt.ind])) {
            RZ_LOG_ERROR("[d] Cannot open directory\n");
            LISTS_FREE();
            free(pfile);
            RZ_FREE(debugbackend);
            return 1;
        }
    } else if (argv[opt.ind] && !strcmp(argv[opt.ind], "-")) {
        int sz;
#if __WINDOWS__
        int result = _setmode(_fileno(stdin), _O_BINARY);
        if (result == -1) {
            RZ_LOG_ERROR("Cannot set stdin to binary mode");
            return 1;
        }
#endif
        /* stdin/batch mode */
        char *buf = rz_stdin_slurp(&sz);
        eprintf("^D\n");
#if __WINDOWS__
        const char *con_dev = "CON";
#else
        const char *con_dev = "/dev/tty";
#endif
        ut64 scr_color = rz_config_get_i(r->config, "scr.color");
        const char *scr_interactive = rz_config_get(r->config, "scr.interactive");
        while (rz_cons_free())
            ;
        rz_xfreopen(con_dev, "r", stdin);
        rz_cons_new();
        rz_config_set_i(r->config, "scr.color", scr_color);
        rz_config_set(r->config, "scr.interactive", scr_interactive);
        if (buf && sz > 0) {
            char *path = rz_str_newf("malloc://%d", sz);
            fh = rz_core_file_open(r, path, perms, mapaddr);
            if (!fh) {
                rz_cons_flush();
                free(buf);
                RZ_LOG_ERROR("[=] Cannot open '%s'\n", path);
                LISTS_FREE();
                free(path);
                return 1;
            }
            rz_io_map_new(r->io, fh->fd, 7, 0LL, mapaddr,
                rz_io_fd_size(r->io, fh->fd));
            rz_io_write_at(r->io, mapaddr, (const ut8 *)buf, sz);
            rz_core_block_read(r);
            free(buf);
            free(path);
            // TODO: load rbin thing
        } else {
            RZ_LOG_ERROR("Cannot slurp from stdin\n");
            free(buf);
            LISTS_FREE();
            return 1;
        }
    } else if (has_file_arg(argc, argv, &opt)) {
        if (debug) {
            if (asmbits) {
                rz_config_set(r->config, "asm.bits", asmbits);
            }
            rz_config_set(r->config, "search.in", "dbg.map"); // implicit?
            rz_config_set(r->config, "cfg.debug", "true");
            perms = RZ_PERM_RWX;
            if (opt.ind >= argc) {
                RZ_LOG_ERROR("No program given to -d\n");
                LISTS_FREE();
                RZ_FREE(debugbackend);
                return 1;
            }
            if (debug == 2) {
                // autodetect backend with -D
                if (strcmp(debugbackend, "dmp")) {
                    rz_config_set(r->config, "dbg.backend", debugbackend);
                }
                if (strcmp(debugbackend, "native")) {
                    if (!haveRarunProfile) {
                        pfile = strdup(argv[opt.ind++]);
                    }
                    // If plugin is winkd we should keep RWX permission to be able to write to the fd
                    if (strcmp(debugbackend, "winkd")) {
                        perms = RZ_PERM_RX; // XXX. should work with rw too
                    }
                    if (!strstr(pfile, "://")) {
                        opt.ind--; // take filename
                    }
                    fh = rz_core_file_open(r, pfile, perms, mapaddr);
                    iod = (r->io && fh) ? rz_io_desc_get(r->io, fh->fd) : NULL;
                    if (!strcmp(debugbackend, "gdb") || !strcmp(debugbackend, "dmp")) {
                        const char *filepath = rz_config_get(r->config, "dbg.exe.path");
                        ut64 addr = baddr;
                        if (addr == UINT64_MAX) {
                            addr = rz_config_get_i(r->config, "bin.baddr");
                        }
                        if (RZ_STR_ISNOTEMPTY(filepath) && rz_file_exists(filepath) && !rz_file_is_directory(filepath)) {
                            char *newpath = rz_file_abspath(filepath);
                            if (newpath) {
                                if (iod) {
                                    free(iod->name);
                                    iod->name = newpath;
                                }
                                if (addr == UINT64_MAX) {
                                    addr = rz_debug_get_baddr(r->dbg, newpath);
                                }
                                rz_core_bin_load(r, NULL, addr);
                            }
                        } else if (is_valid_gdb_file(fh) || is_valid_dmp_file(fh)) {
                            filepath = iod->name;
                            if (RZ_STR_ISNOTEMPTY(filepath) && rz_file_exists(filepath) && !rz_file_is_directory(filepath)) {
                                if (addr == UINT64_MAX) {
                                    addr = rz_debug_get_baddr(r->dbg, filepath);
                                }
                                rz_core_bin_load(r, filepath, addr);
                            } else if ((filepath = get_file_in_cur_dir(filepath))) {
                                // Present in local directory
                                if (iod) {
                                    free(iod->name);
                                    iod->name = (char *)filepath;
                                }
                                if (addr == UINT64_MAX) {
                                    addr = rz_debug_get_baddr(r->dbg, filepath);
                                }
                                rz_core_bin_load(r, NULL, addr);
                            }
                        }
                    }
                }
            } else {
                const char *f = (haveRarunProfile && pfile) ? pfile : argv[opt.ind];
                is_gdb = (!memcmp(f, "gdb://", RZ_MIN(f ? strlen(f) : 0, 6)));
                if (!is_gdb) {
                    pfile = strdup("dbg://");
                }
#if __UNIX__
                /* implicit ./ to make unix behave like windows */
                if (f) {
                    char *path, *escaped_path;
                    if (strchr(f, '/')) {
                        // f is a path
                        path = strdup(f);
                    } else {
                        // f is a filename
                        if (rz_file_exists(f)) {
                            path = rz_str_prepend(strdup(f), "./");
                        } else {
                            path = rz_file_path(f);
                        }
                    }
                    escaped_path = rz_str_arg_escape(path);
                    pfile = rz_str_append(pfile, escaped_path);
                    file = pfile; // probably leaks
                    RZ_FREE(escaped_path);
                    RZ_FREE(path);
                }
#else
                if (f) {
                    char *escaped_path = rz_str_arg_escape(f);
                    pfile = rz_str_append(pfile, escaped_path);
                    free(escaped_path);
                    file = pfile; // rz_str_append (file, escaped_path);
                }
#endif
                opt.ind++;
                while (opt.ind < argc) {
                    char *escaped_arg = rz_str_arg_escape(argv[opt.ind]);
                    file = rz_str_append(file, " ");
                    file = rz_str_append(file, escaped_arg);
                    free(escaped_arg);
                    opt.ind++;
                }
                pfile = file;
            }
        }
        if (asmarch) {
            rz_config_set(r->config, "asm.arch", asmarch);
        }
        if (asmbits) {
            rz_config_set(r->config, "asm.bits", asmbits);
        }
        if (asmos) {
            rz_config_set(r->config, "asm.os", asmos);
        }
 
        if (!debug || debug == 2) {
            const char *dbg_profile = rz_config_get(r->config, "dbg.profile");
            if (opt.ind == argc && dbg_profile && *dbg_profile) {
                if (RZ_STR_ISEMPTY(pfile)) {
                    RZ_LOG_ERROR("Missing file to open\n");
                    ret = 1;
                    RZ_FREE(debugbackend);
                    goto beach;
                }
                fh = rz_core_file_open(r, pfile, perms, mapaddr);
                if (fh) {
                    rz_core_bin_load(r, pfile, baddr);
                }
            }
            if (opt.ind < argc) {
                RZ_FREE(pfile);
                while (opt.ind < argc) {
                    pfile = strdup(argv[opt.ind++]);
                    fh = rz_core_file_open(r, pfile, perms, mapaddr);
                    if (!fh && perms & RZ_PERM_W) {
                        perms |= RZ_PERM_CREAT;
                        fh = rz_core_file_open(r, pfile, perms, mapaddr);
                    }
                    if (perms & RZ_PERM_CREAT) {
                        if (fh) {
                            rz_config_set_i(r->config, "io.va", false);
                        } else {
                            eprintf("rz_io_create: Permission denied.\n");
                        }
                    }
                    if (fh) {
                        iod = r->io ? rz_io_desc_get(r->io, fh->fd) : NULL;
                        if (iod && perms & RZ_PERM_X) {
                            iod->perm |= RZ_PERM_X;
                        }
                        if (load_bin == LOAD_BIN_ALL) {
                            const char *filepath = NULL;
                            if (debug) {
                                // XXX: incorrect for PIE binaries
                                filepath = file ? strstr(file, "://") : NULL;
                                filepath = filepath ? filepath + 3 : pfile;
                            }
                            if (r->file && iod && (iod->fd == r->file->fd) && iod->name) {
                                filepath = iod->name;
                            }
                            /* Load rbin info from rz dbg:// or rz /bin/ls */
                            /* the baddr should be set manually here */
                            (void)rz_core_bin_load(r, filepath, baddr);
                            // check if bin info is loaded and complain if -B was used
                            RzBinFile *bi = rz_bin_cur(r->bin);
                            bool haveBinInfo = bi && bi->o && bi->o->info && bi->o->info->type;
                            if (!haveBinInfo && baddr != UT64_MAX) {
                                eprintf("Warning: Don't use -B on unknown files. Consider using -m.\n");
                            }
                        } else {
                            rz_io_map_new(r->io, iod->fd, perms, 0LL, mapaddr, rz_io_desc_size(iod));
                            if (load_bin == LOAD_BIN_STRUCTURES_ONLY) {
                                rz_core_bin_load_structs(r, iod->name);
                            }
                        }
                    }
                }
            } else {
                if (fh) {
                    iod = r->io ? rz_io_desc_get(r->io, fh->fd) : NULL;
                    if (iod) {
                        perms = iod->perm;
                        rz_io_map_new(r->io, iod->fd, perms, 0LL, 0LL, rz_io_desc_size(iod));
                    }
                }
            }
            if (mapaddr) {
                if (rz_config_get_i(r->config, "file.info")) {
                    int fd = rz_io_fd_get_current(r->io);
                    RzIODesc *desc = rz_io_desc_get(r->io, fd);
                    if (desc) {
                        RzBinOptions opt;
                        opt.sz = 1024 * 1024 * 1;
                        rz_core_bin_options_init(r, &opt, desc->fd, mapaddr, 0);
                        RzBinFile *bf = rz_bin_open_io(r->bin, &opt);
                        rz_core_bin_apply_all_info(r, bf);
                    }
                }
            }
        } else {
            RzCoreFile *f = rz_core_file_open(r, pfile, perms, mapaddr);
            if (f) {
                fh = f;
            }
            if (fh) {
                rz_debug_use(r->dbg, is_gdb ? "gdb" : debugbackend);
            }
            /* load symbols when doing rz -d ls */
            // NOTE: the baddr is redefined to support PIE/ASLR
            baddr = rz_debug_get_baddr(r->dbg, pfile);
 
            if (baddr != UT64_MAX && baddr != 0 && r->dbg->verbose) {
                eprintf("bin.baddr 0x%08" PFMT64x "\n", baddr);
            }
            if (load_bin == LOAD_BIN_ALL) {
                if (baddr && baddr != UT64_MAX && r->dbg->verbose) {
                    eprintf("Using 0x%" PFMT64x "\n", baddr);
                }
                if (rz_core_bin_load(r, pfile, baddr)) {
                    RzBinObject *obj = rz_bin_cur_object(r->bin);
                    if (obj && obj->info) {
                        if (r->dbg->verbose) {
                            eprintf("asm.bits %d\n", obj->info->bits);
                        }
#if __linux__ && __GNU_LIBRARY__ && __GLIBC__ && __GLIBC_MINOR__ && __x86_64__
                        ut64 bitness = rz_config_get_i(r->config, "asm.bits");
                        if (bitness == 32) {
                            eprintf("glibc.fc_offset = 0x00148\n");
                            rz_config_set_i(r->config, "dbg.glibc.fc_offset", 0x00148);
                        }
#endif
                    }
                }
            }
            rz_core_debug_map_update_flags(r);
            // Set Thumb Mode if necessary
            RzRegItem *thumb_reg = rz_reg_get(r->dbg->reg, "thumb", RZ_REG_TYPE_ANY);
            if (thumb_reg && rz_reg_get_value(r->dbg->reg, thumb_reg)) {
                rz_config_set_i(r->config, "asm.bits", 16);
            }
            rz_cons_reset();
        }
        if (!pfile) {
            pfile = file;
        }
        if (!fh && !prj) {
            if (pfile && *pfile) {
                rz_cons_flush();
                if (perms & RZ_PERM_W) {
                    RZ_LOG_ERROR("[w] Cannot open '%s' for writing.\n", pfile);
                } else {
                    RZ_LOG_ERROR("[r] Cannot open '%s'\n", pfile);
                }
            } else {
                RZ_LOG_ERROR("Missing file to open\n");
            }
            ret = 1;
            goto beach;
        }
        if (!r->file) { // no given file
            ret = 1;
            goto beach;
        }
        if (r->bin->cur && r->bin->cur->o && r->bin->cur->o->info && r->bin->cur->o->info->rclass && !strcmp("fs", r->bin->cur->o->info->rclass)) {
            const char *fstype = r->bin->cur->o->info->bclass;
            rz_core_cmdf(r, "m /root %s @ 0", fstype);
        }
        rz_core_cmd0(r, "R!"); // initalize io subsystem
        iod = r->io && fh ? rz_io_desc_get(r->io, fh->fd) : NULL;
        if (mapaddr) {
            rz_core_seek(r, mapaddr, true);
        }
        rz_list_foreach (evals, iter, cmdn) {
            rz_config_eval(r->config, cmdn);
            rz_cons_flush();
        }
        if (asmarch) {
            rz_config_set(r->config, "asm.arch", asmarch);
        }
        if (asmbits) {
            rz_config_set(r->config, "asm.bits", asmbits);
        }
        if (asmos) {
            rz_config_set(r->config, "asm.os", asmos);
        }
 
        debug = r->file && iod && (r->file->fd == iod->fd) && iod->plugin &&
            (iod->plugin->isdbg || (debug == 2 && !strcmp(iod->plugin->name, "dmp")));
        if (debug) {
            rz_core_setup_debugger(r, debugbackend, baddr == UT64_MAX);
        }
        RZ_FREE(debugbackend);
        RzBinObject *o = rz_bin_cur_object(r->bin);
        if (!debug && o && !o->regstate) {
            RzFlagItem *fi = rz_flag_get(r->flags, "entry0");
            if (fi) {
                rz_core_seek(r, fi->offset, true);
            } else {
                if (o) {
                    RzList *sections = rz_bin_get_sections(r->bin);
                    RzListIter *iter;
                    RzBinSection *s;
                    rz_list_foreach (sections, iter, s) {
                        if (s->perm & RZ_PERM_X) {
                            ut64 addr = s->vaddr ? s->vaddr : s->paddr;
                            rz_core_seek(r, addr, true);
                            break;
                        }
                    }
                }
            }
        }
        if (o && o->info && compute_hashes) {
            // TODO: recall with limit=0 ?
            ut64 limit = rz_config_get_i(r->config, "bin.hashlimit");
            RzBinFile *bf = r->bin->cur;
            if (bf) {
                RzList *old_hashes = rz_bin_file_set_hashes(r->bin, rz_bin_file_compute_hashes(r->bin, bf, limit));
                rz_list_free(old_hashes);
            }
        }
        if (s_seek) {
            seek = rz_num_math(r->num, s_seek);
            if (seek != UT64_MAX) {
                rz_core_seek(r, seek, true);
            }
        }
 
        if (fullfile) {
            rz_core_block_size(r, rz_io_desc_size(iod));
        }
 
        rz_core_seek(r, r->offset, true); // read current block
 
        /* check if file.path has changed */
        if (iod && !strstr(iod->uri, "://")) {
            const char *npath;
            char *path = strdup(rz_config_get(r->config, "file.path"));
            iod = r->io ? rz_io_desc_get(r->io, fh->fd) : NULL;
            npath = rz_config_get(r->config, "file.path");
            if (!quiet && path && *path && npath && strcmp(path, npath)) {
                eprintf("WARNING: file.path change: %s => %s\n", path, npath);
            }
            free(path);
        }
 
        rz_list_foreach (evals, iter, cmdn) {
            rz_config_eval(r->config, cmdn);
            rz_cons_flush();
        }
 
        // no flagspace selected by default the beginning
        rz_flag_space_set(r->flags, NULL);
        /* load <file>.rz */
        {
            char *f = rz_str_newf("%s.rz", pfile);
            const char *uri_splitter = strstr(f, "://");
            const char *path = uri_splitter ? uri_splitter + 3 : f;
            if (rz_file_exists(path)) {
                // TODO: should 'q' unset the interactive bit?
                bool isInteractive = rz_cons_is_interactive();
                if (isInteractive && rz_cons_yesno('n', "Do you want to run the '%s' script? (y/N) ", path)) {
                    rz_core_cmd_file(r, path);
                }
            }
            free(f);
        }
    } else {
        rz_core_block_read(r);
 
        rz_list_foreach (evals, iter, cmdn) {
            rz_config_eval(r->config, cmdn);
            rz_cons_flush();
        }
        if (asmarch) {
            rz_config_set(r->config, "asm.arch", asmarch);
        }
        if (asmbits) {
            rz_config_set(r->config, "asm.bits", asmbits);
        }
        if (asmos) {
            rz_config_set(r->config, "asm.os", asmos);
        }
    }
    {
        char *global_rc = rz_path_system_rc();
        if (rz_file_exists(global_rc)) {
            (void)rz_core_run_script(r, global_rc);
        }
        free(global_rc);
    }
 
    if (do_analysis > 0) {
        switch (do_analysis) {
        case 1: rz_core_cmd0(r, "aa"); break;
        case 2: rz_core_cmd0(r, "aaa"); break;
        case 3: rz_core_cmd0(r, "aaaa"); break;
        default: rz_core_cmd0(r, "aaaaa"); break;
        }
        rz_cons_flush();
    }
#if UNCOLORIZE_NONTTY
#if __UNIX__
    if (!rz_cons_isatty()) {
        rz_config_set_i(r->config, "scr.color", COLOR_MODE_DISABLED);
    }
#endif
#endif
    if (fullfile) {
        rz_core_block_size(r, rz_io_desc_size(iod));
    }
    if (perms & RZ_PERM_W) {
        RzPVector *maps = rz_io_maps(r->io);
        void **it;
        rz_pvector_foreach (maps, it) {
            RzIOMap *map = *it;
            map->perm |= RZ_PERM_W;
        }
    }
    ret = run_commands(r, cmds, files, quiet, do_analysis);
    rz_list_free(cmds);
    rz_list_free(evals);
    rz_list_free(files);
    cmds = evals = files = NULL;
    if (forcequit) {
        ret = 1;
    }
    if (ret) {
        ret = 0;
        goto beach;
    }
    if (rz_config_get_i(r->config, "scr.prompt")) {
        if (run_rc && rz_config_get_i(r->config, "cfg.fortunes")) {
            rz_core_fortune_print_random(r);
            rz_cons_flush();
        }
    }
    if (quiet) {
        rz_config_set(r->config, "scr.wheel", "false");
        rz_config_set(r->config, "scr.interactive", "false");
        rz_config_set(r->config, "scr.prompt", "false");
    }
    r->num->value = 0;
    if (zerosep) {
        rz_cons_zero();
    }
    if (seek != UT64_MAX) {
        rz_core_seek(r, seek, true);
    }
 
    // no flagspace selected by default the beginning
    rz_flag_space_set(r->flags, NULL);
    for (;;) {
        rz_core_prompt_loop(r);
        ret = r->num->value;
        debug = rz_config_get_i(r->config, "cfg.debug");
        if (ret != -1 && rz_cons_is_interactive()) {
            char *question;
            bool no_question_debug = ret & 1;
            bool no_question_save = (ret & 2) >> 1;
            bool y_kill_debug = (ret & 4) >> 2;
            bool y_save_project = (ret & 8) >> 3;
 
            if (rz_core_task_running_tasks_count(&r->tasks) > 0) {
                if (rz_cons_yesno('y', "There are running background tasks. Do you want to kill them? (Y/n)")) {
                    rz_core_task_break_all(&r->tasks);
                    rz_core_task_join(&r->tasks, r->tasks.main_task, -1);
                } else {
                    continue;
                }
            }
 
            if (debug) {
                if (no_question_debug) {
                    if (rz_config_get_i(r->config, "dbg.exitkills") && y_kill_debug) {
                        rz_debug_kill(r->dbg, r->dbg->pid, r->dbg->tid, 9); // KILL
                    }
                } else {
                    if (rz_cons_yesno('y', "Do you want to quit? (Y/n)")) {
                        if (rz_config_get_i(r->config, "dbg.exitkills") &&
                            rz_debug_can_kill(r->dbg) &&
                            rz_cons_yesno('y', "Do you want to kill the process? (Y/n)")) {
                            rz_debug_kill(r->dbg, r->dbg->pid, r->dbg->tid, 9); // KILL
                        }
                        // Even if killed above, we must still detach, otherwise
                        // there will be a zombie on macOS!
                        rz_debug_detach(r->dbg, r->dbg->pid);
                    } else {
                        continue;
                    }
                }
            }
 
            prj = rz_config_get(r->config, "prj.file");
            bool compress = rz_config_get_b(r->config, "prj.compress");
            RzProjectErr prj_err = RZ_PROJECT_ERR_SUCCESS;
            if (no_question_save) {
                if (prj && *prj && y_save_project) {
                    prj_err = rz_project_save_file(r, prj, compress);
                }
            } else {
                question = rz_str_newf("Do you want to save the '%s' project? (Y/n)", prj);
                if (prj && *prj && rz_cons_yesno('y', "%s", question)) {
                    prj_err = rz_project_save_file(r, prj, compress);
                }
                free(question);
            }
            if (prj_err != RZ_PROJECT_ERR_SUCCESS) {
                RZ_LOG_ERROR("Failed to save project: %s\n", rz_project_err_message(prj_err));
                continue;
            }
 
            if (rz_config_get_i(r->config, "scr.confirmquit")) {
                if (!rz_cons_yesno('n', "Do you want to quit? (Y/n)")) {
                    continue;
                }
            }
        } else {
            // rz_core_project_save (r, prj);
            if (debug && rz_config_get_i(r->config, "dbg.exitkills")) {
                rz_debug_kill(r->dbg, 0, false, 9); // KILL
            }
        }
        break;
    }
 
    if (mustSaveHistory(r->config)) {
        char *history = rz_path_home_history();
        rz_line_hist_save(history);
        free(history);
    }
 
    /* capture return value */
    ret = r->num->value;
beach:
    if (quietLeak) {
        exit(ret);
        return ret;
    }
 
    rz_core_task_sync_end(&r->tasks);
 
    // not really needed, cause rz_core_fini will close the file
    // and this fh may be come stale during the command
    // execution.
    // rz_core_file_close (r, fh);
    rz_core_free(r);
    rz_cons_set_raw(0);
    rz_cons_free();
    LISTS_FREE();
    free(debugbackend);
    RZ_FREE(pfile);
    return ret;
}

References addr, rz_getopt_t::arg, rz_getopt_t::argv, argv, baddr(), rz_bin_info_t::bits, c, close, COLOR_MODE_DISABLED, compress(), debug, desc, dup2, env, eprintf, test-lz4-list::exit, f, fd, rz_io_desc_t::fd, fh, file, files, free(), get_file_in_cur_dir(), has_file_arg(), cmd_descs_generate::help, rz_getopt_t::ind, rz_bin_object_t::info, is_valid_dmp_file(), is_valid_gdb_file(), rz_io_plugin_t::isdbg, limit, LISTS_FREE, main_help(), main_print_var(), map(), maps(), msg, mustSaveHistory(), rz_io_desc_t::name, rz_io_plugin_t::name, NULL, rz_bin_file_t::o, O_RDWR, rz_flag_item_t::offset, rz_getopt_t::opt, p, path, rz_io_desc_t::perm, PFMT64x, rz_io_desc_t::plugin, printf(), r, rz_bin_object_t::regstate, run_commands(), rz_bin_cur(), rz_bin_cur_object(), rz_bin_file_compute_hashes(), rz_bin_file_set_hashes(), rz_bin_force_plugin(), rz_bin_get_sections(), rz_bin_open_io(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), rz_config_eval(), rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set(), rz_config_set_i(), rz_cons_flush(), rz_cons_free(), rz_cons_is_interactive(), rz_cons_isatty(), rz_cons_new(), rz_cons_reset(), rz_cons_set_raw(), rz_cons_yesno(), rz_cons_zero(), rz_core_bin_apply_all_info(), rz_core_bin_load(), rz_core_bin_load_structs(), rz_core_bin_options_init(), rz_core_block_read(), rz_core_block_size(), rz_core_cmd0(), rz_core_cmd_file(), rz_core_cmdf(), rz_core_debug_map_update_flags(), rz_core_debug_plugins_print(), rz_core_file_open(), rz_core_fortune_print_random(), rz_core_free(), rz_core_io_plugins_print(), rz_core_loadlibs(), rz_core_new(), rz_core_parse_rizinrc(), rz_core_project_load_for_cli(), rz_core_prompt_loop(), rz_core_run_script(), rz_core_seek(), rz_core_setup_debugger(), rz_core_task_break_all(), rz_core_task_join(), rz_core_task_running_tasks_count(), rz_core_task_sync_begin(), rz_core_task_sync_end(), rz_debug_can_kill(), rz_debug_detach(), rz_debug_get_baddr(), rz_debug_kill(), rz_debug_use(), rz_file_abspath(), rz_file_dump(), rz_file_exists(), rz_file_is_directory(), rz_file_path(), rz_file_slurp(), rz_file_temp(), rz_flag_get(), RZ_FREE, rz_getopt_init(), rz_getopt_next(), rz_io_desc_get(), rz_io_desc_size(), rz_io_fd_get_current(), rz_io_fd_size(), rz_io_map_new(), rz_io_maps(), rz_io_write_at(), rz_lib_open(), rz_line_hist_save(), rz_list_append(), rz_list_free(), rz_list_new(), RZ_LOG_ERROR, rz_main_rizin(), rz_main_rz_asm(), rz_main_rz_ax(), rz_main_rz_bin(), rz_main_rz_diff(), rz_main_rz_find(), rz_main_rz_gg(), rz_main_version_print(), rz_main_version_verify(), RZ_MIN, rz_num_math(), RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_STANDARD, rz_path_home_history(), rz_path_system_rc(), RZ_PERM_CREAT, RZ_PERM_RWX, RZ_PERM_RX, RZ_PERM_W, RZ_PERM_X, rz_project_err_message(), RZ_PROJECT_ERR_SUCCESS, rz_project_save_file(), rz_pvector_foreach, rz_reg_get(), rz_reg_get_value(), RZ_REG_TYPE_ANY, rz_run_get_environ_profile(), rz_stdin_slurp(), rz_str_append(), rz_str_appendf(), rz_str_arg_escape(), RZ_STR_ISEMPTY, RZ_STR_ISNOTEMPTY, rz_str_newf(), rz_str_prepend(), rz_sys_chdir(), rz_sys_crash_handler(), RZ_SYS_DEVNULL, rz_sys_env_init(), rz_sys_get_environ(), rz_sys_getenv(), rz_sys_getenv_asbool(), rz_sys_sleep(), RZ_VERSION, rz_xfreopen, s, sections(), seek(), set_color_default(), SIGWINCH, src, strdup(), autogen_x86imm::tmp, rz_bin_info_t::type, UINT64_MAX, rz_io_desc_t::uri, ut64(), and UT64_MAX.

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_run()

RZ_API int rz_main_run	(	RzMain *	m,
		int	argc,
		const char **	argv
	)

Definition at line 44 of file main.c.

                                                               {
    rz_return_val_if_fail(m && m->main, -1);
    return m->main(argc, argv);
}

References argv, regress::m, and rz_return_val_if_fail.

Referenced by MAIN_NAME().

rz_main_rz_agent()

RZ_API int rz_main_rz_agent	(	int	argc,
		const char **	argv
	)

Definition at line 61 of file rz-agent.c.

                                                         {
    RzSocket *s;
    RzSocketHTTPOptions so;
    RzSocketHTTPRequest *rs;
    int c;
    int dodaemon = 0;
    bool listenlocal = true;
    const char *port = "8080";
    const char *httpauthfile = NULL;
    char *pfile = NULL;
    memset(&so, 0, sizeof(so));
 
    RzGetopt opt;
    rz_getopt_init(&opt, argc, argv, "adhup:t:sv");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'a':
            listenlocal = false;
            break;
        case 'd':
            dodaemon = 1;
            break;
        case 'h':
            return usage(1);
        case 'v':
            return showversion();
        case 'u':
            so.httpauth = true;
            break;
        case 't':
            httpauthfile = opt.arg;
            break;
        case 'p':
            port = opt.arg;
            break;
        default:
            return usage(0);
        }
    }
    if (opt.ind != argc) {
        return usage(0);
    }
 
    so.accept_timeout = 0;
    so.timeout = 3;
 
    if (so.httpauth) {
        if (!httpauthfile) {
            eprintf("No authentication user list set\n");
            return usage(0);
        }
 
        size_t sz;
        pfile = rz_file_slurp(httpauthfile, &sz);
        if (pfile) {
            so.authtokens = rz_str_split_list(pfile, "\n", 0);
        } else {
            eprintf("Empty list of HTTP users\\n");
            return usage(0);
        }
    }
#if USE_IOS_JETSAM
    memorystatus_control(MEMORYSTATUS_CMD_SET_JETSAM_TASK_LIMIT, getpid(), 256, NULL, 0);
#endif
    if (dodaemon) {
#if HAVE_FORK
        int pid = rz_sys_fork();
        if (pid > 0) {
            printf("%d\n", pid);
            return 0;
        }
#endif
    }
    s = rz_socket_new(false);
    s->local = listenlocal;
    if (!rz_socket_listen(s, port, NULL)) {
        eprintf("Cannot listen on %d\n", s->port);
        rz_socket_free(s);
        return 1;
    }
 
    eprintf("http://localhost:%d/\n", s->port);
 
    (void)rz_cons_new();
 
    while (!rz_cons_singleton()->context->breaked) {
        char *result_heap = NULL;
        const char *result = page_index;
 
        rs = rz_socket_http_accept(s, &so);
        if (!rs) {
            continue;
        }
        if (!rs->auth) {
            rz_socket_http_response(rs, 401, "", 0, NULL);
        }
        if (!strcmp(rs->method, "GET")) {
            if (!strncmp(rs->path, "/proc/kill/", 11)) {
                // TODO: show page here?
                int pid = atoi(rs->path + 11);
                if (pid > 0) {
#if __WINDOWS__
                    rz_sys_kill(pid, 0);
#else
                    rz_sys_kill(pid, SIGKILL);
#endif
                }
            } else if (!strncmp(rs->path, "/file/open/", 11)) {
                int pid;
                int session_port = 3000 + rz_num_rand(1024);
                char *filename = rs->path + 11;
                char *escaped_filename = rz_str_escape(filename);
                size_t escaped_len = strlen(escaped_filename);
                size_t cmd_len = escaped_len + 40;
                char *cmd;
 
                if (!(cmd = malloc(cmd_len))) {
                    perror("malloc");
                    return 1;
                }
                snprintf(cmd, cmd_len, "rizin -q %s-e http.port=%d -cRh \"%s\"",
                    listenlocal ? "" : "-e http.bind=public ",
                    session_port, escaped_filename);
 
                // TODO: use rz_sys api to get pid when running in bg
                pid = rz_sys_cmdbg(cmd);
                free(cmd);
                free(escaped_filename);
                result = result_heap = malloc(1024 + escaped_len);
                if (!result) {
                    perror("malloc");
                    free(pfile);
                    rz_list_free(so.authtokens);
                    return 1;
                }
                sprintf(result_heap,
                    "<html><body>"
                    "<a href='/'>back</a><hr size=1/>"
                    " - <a target='_blank' href='http://localhost:%d/'>open</a><br />"
                    " - <a href='/proc/kill/%d'>kill</a><br />"
                    "</body></html>",
                    session_port, pid);
                eprintf("\nchild pid %d\n\n", pid);
            }
        }
        rz_socket_http_response(rs, 200, result, 0, NULL);
        rz_socket_http_close(rs);
        free(result_heap);
        result_heap = NULL;
    }
    rz_cons_free();
    free(pfile);
    rz_list_free(so.authtokens);
    rz_socket_free(s);
    return 0;
}

References rz_socket_http_options::accept_timeout, rz_getopt_t::arg, argv, rz_socket_http_options::authtokens, rz_cons_context_t::breaked, c, cmd, rz_cons_t::context, eprintf, free(), rz_socket_http_options::httpauth, rz_getopt_t::ind, rz_socket_t::local, malloc(), memset(), NULL, page_index, pid, rz_socket_t::port, printf(), rs, rz_cons_free(), rz_cons_new(), rz_cons_singleton(), rz_file_slurp(), rz_getopt_init(), rz_getopt_next(), rz_list_free(), rz_num_rand(), rz_socket_free(), rz_socket_http_accept(), rz_socket_http_close(), rz_socket_http_response(), rz_socket_listen(), rz_socket_new(), rz_str_escape(), rz_str_split_list(), rz_sys_cmdbg(), rz_sys_fork(), rz_sys_kill(), s, showversion(), SIGKILL, snprintf, sprintf, rz_socket_http_options::timeout, and usage().

Referenced by MAIN_NAME().

rz_main_rz_asm()

RZ_API int rz_main_rz_asm	(	int	argc,
		const char **	argv
	)

Referenced by rz_main_rizin().

rz_main_rz_ax()

RZ_API int rz_main_rz_ax	(	int	argc,
		const char **	argv
	)

Definition at line 721 of file rz-ax.c.

                                                      {
    int i, fm = 0;
    RzNum *num = rz_num_new(NULL, NULL, NULL);
    if (argc == 1) {
        use_stdin(num, 0, &fm);
    } else {
        ut64 flags = 0;
        for (i = 1; i < argc; i++) {
            char *argv_i = strdup(argv[i]);
            rz_str_unescape(argv_i);
            rax(num, argv_i, 0, i == argc - 1, &flags, &fm);
            free(argv_i);
        }
    }
    rz_num_free(num);
    num = NULL;
    return 0;
}

References argv, flags, free(), i, NULL, num, rax(), rz_num_free(), rz_num_new(), rz_str_unescape(), strdup(), use_stdin(), and ut64().

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_rz_bin()

RZ_API int rz_main_rz_bin	(	int	argc,
		const char **	argv
	)

Definition at line 681 of file rz-bin.c.

                                                       {
    RzBin *bin = NULL;
    const char *name = NULL;
    const char *file = NULL;
    const char *output = NULL;
    int out_mode = RZ_MODE_PRINT;
    ut64 laddr = UT64_MAX;
    ut64 baddr = UT64_MAX;
    const char *do_demangle = NULL;
    const char *query = NULL;
    int c, bits = 0, actions = 0;
    char *create = NULL;
    ut64 action = RZ_BIN_REQ_UNK;
    char *tmp, *ptr, *arch_name = NULL;
    const char *arch = NULL;
    const char *forcebin = NULL;
    const char *chksum = NULL;
    const char *op = NULL;
    RzCoreFile *fh = NULL;
    RzCoreBinFilter filter;
    int xtr_idx = 0; // load all files if extraction is necessary.
    bool rawstr = false;
    int fd = -1;
    RzCore core = { 0 };
    ut64 at = UT64_MAX;
    int result = 0;
 
    rz_core_init(&core);
    bin = core.bin;
    if (!(tmp = rz_sys_getenv("RZ_BIN_NOPLUGINS"))) {
        char *homeplugindir = rz_path_home_prefix(RZ_PLUGINS);
        // TODO: remove after 0.4.0 is released
        char *oldhomeplugindir = rz_path_home_prefix(RZ_HOME_OLD_PLUGINS);
        char *plugindir = rz_path_system(RZ_PLUGINS);
        RzLib *l = rz_lib_new(NULL, NULL);
        rz_lib_add_handler(l, RZ_LIB_TYPE_DEMANGLER, "demangler plugins",
            &__lib_demangler_cb, &__lib_demangler_dt, bin->demangler);
        rz_lib_add_handler(l, RZ_LIB_TYPE_BIN, "bin plugins",
            &__lib_bin_cb, &__lib_bin_dt, bin);
        rz_lib_add_handler(l, RZ_LIB_TYPE_BIN_XTR, "bin xtr plugins",
            &__lib_bin_xtr_cb, &__lib_bin_xtr_dt, bin);
        /* load plugins everywhere */
        char *path = rz_sys_getenv(RZ_LIB_ENV);
        if (!RZ_STR_ISEMPTY(path)) {
            rz_lib_opendir(l, path, false);
        }
        rz_lib_opendir(l, homeplugindir, false);
        rz_lib_opendir(l, oldhomeplugindir, false);
        rz_lib_opendir(l, plugindir, false);
        free(homeplugindir);
        free(oldhomeplugindir);
        free(plugindir);
        free(path);
        rz_lib_free(l);
    }
    free(tmp);
 
    if ((tmp = rz_sys_getenv("RZ_CONFIG"))) {
        Sdb *config_sdb = sdb_new(NULL, tmp, 0);
        if (config_sdb) {
            rz_config_unserialize(core.config, config_sdb, NULL);
            sdb_free(config_sdb);
        } else {
            eprintf("Cannot open file specified in RZ_CONFIG\n");
        }
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_LANG"))) {
        rz_config_set(core.config, "bin.lang", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_DEMANGLE"))) {
        rz_config_set(core.config, "bin.demangle", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_MAXSTRBUF"))) {
        rz_config_set(core.config, "bin.maxstrbuf", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_STRFILTER"))) {
        rz_config_set(core.config, "bin.str.filter", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_STRPURGE"))) {
        rz_config_set(core.config, "bin.str.purge", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_DEBASE64"))) {
        rz_config_set(core.config, "bin.debase64", tmp);
        free(tmp);
    }
    if ((tmp = rz_sys_getenv("RZ_BIN_PDBSERVER"))) {
        rz_config_set(core.config, "pdb.server", tmp);
        free(tmp);
    }
 
#define is_active(x) (action & (x))
#define set_action(x) \
    { \
        actions++; \
        action |= (x); \
    }
#define unset_action(x) action &= ~x
    RzGetopt opt;
    rz_getopt_init(&opt, argc, argv, "DjgAf:F:a:B:G:b:cC:k:K:dD:Mm:n:N:@:isSVIHeEUlRwO:o:pPqQrTvLhuxYXzZ");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'g':
            set_action(RZ_BIN_REQ_CLASSES);
            set_action(RZ_BIN_REQ_IMPORTS);
            set_action(RZ_BIN_REQ_SYMBOLS);
            set_action(RZ_BIN_REQ_SECTIONS);
            set_action(RZ_BIN_REQ_SEGMENTS);
            set_action(RZ_BIN_REQ_SECTIONS_MAPPING);
            set_action(RZ_BIN_REQ_STRINGS);
            set_action(RZ_BIN_REQ_SIZE);
            set_action(RZ_BIN_REQ_INFO);
            set_action(RZ_BIN_REQ_FIELDS);
            set_action(RZ_BIN_REQ_DWARF);
            set_action(RZ_BIN_REQ_ENTRIES);
            set_action(RZ_BIN_REQ_INITFINI);
            set_action(RZ_BIN_REQ_MAIN);
            set_action(RZ_BIN_REQ_LIBS);
            set_action(RZ_BIN_REQ_RELOCS);
            set_action(RZ_BIN_REQ_VERSIONINFO);
            break;
        case 'V': set_action(RZ_BIN_REQ_VERSIONINFO); break;
        case 'T': set_action(RZ_BIN_REQ_SIGNATURE); break;
        case 'w': set_action(RZ_BIN_REQ_TRYCATCH); break;
        case 'q':
            out_mode = (out_mode & RZ_MODE_SIMPLE ? RZ_MODE_SIMPLEST : RZ_MODE_SIMPLE);
            break;
        case 'j': out_mode = RZ_MODE_JSON; break;
        case 'A': set_action(RZ_BIN_REQ_LISTARCHS); break;
        case 'a': arch = opt.arg; break;
        case 'C':
            set_action(RZ_BIN_REQ_CREATE);
            create = strdup(opt.arg);
            break;
        case 'u': bin->filter = 0; break;
        case 'k': query = opt.arg; break;
        case 'K': chksum = opt.arg; break;
        case 'c':
            if (is_active(RZ_BIN_REQ_CLASSES)) {
                action &= ~RZ_BIN_REQ_CLASSES;
                action |= RZ_BIN_REQ_CLASSES_SOURCES;
            } else {
                set_action(RZ_BIN_REQ_CLASSES);
            }
            break;
        case 'f': arch_name = strdup(opt.arg); break;
        case 'F': forcebin = opt.arg; break;
        case 'b': bits = rz_num_math(NULL, opt.arg); break;
        case 'm':
            at = rz_num_math(NULL, opt.arg);
            set_action(RZ_BIN_REQ_SRCLINE);
            break;
        case 'i':
            set_action(RZ_BIN_REQ_IMPORTS);
            break;
        case 's':
            set_action(RZ_BIN_REQ_SYMBOLS);
            break;
        case 'S':
            if (is_active(RZ_BIN_REQ_SEGMENTS)) {
                action &= ~RZ_BIN_REQ_SEGMENTS;
                action |= RZ_BIN_REQ_SECTIONS_MAPPING;
            } else if (is_active(RZ_BIN_REQ_SECTIONS)) {
                action &= ~RZ_BIN_REQ_SECTIONS;
                action |= RZ_BIN_REQ_SEGMENTS;
            } else {
                set_action(RZ_BIN_REQ_SECTIONS);
            }
            break;
        case 'z':
            if (is_active(RZ_BIN_REQ_STRINGS)) {
                rawstr = true;
            } else {
                set_action(RZ_BIN_REQ_STRINGS);
            }
            break;
        case 'Z': set_action(RZ_BIN_REQ_SIZE); break;
        case 'I': set_action(RZ_BIN_REQ_INFO); break;
        case 'H':
            set_action(RZ_BIN_REQ_FIELDS);
            break;
        case 'd': set_action(RZ_BIN_REQ_DWARF); break;
        case 'P':
            if (is_active(RZ_BIN_REQ_PDB)) {
                action &= ~RZ_BIN_REQ_PDB;
                action |= RZ_BIN_REQ_PDB_DWNLD;
            } else {
                set_action(RZ_BIN_REQ_PDB);
            }
            break;
        case 'D':
            if (argv[opt.ind] && argv[opt.ind + 1] &&
                (!argv[opt.ind + 1][0] || !strcmp(argv[opt.ind + 1], "all"))) {
                rz_config_set(core.config, "bin.lang", argv[opt.ind]);
                rz_config_set(core.config, "bin.demangle", "true");
                opt.ind += 2;
            } else {
                do_demangle = argv[opt.ind];
            }
            break;
        case 'e':
            if (action & RZ_BIN_REQ_ENTRIES) {
                action &= ~RZ_BIN_REQ_ENTRIES;
                action |= RZ_BIN_REQ_INITFINI;
            } else {
                set_action(RZ_BIN_REQ_ENTRIES);
            }
            break;
        case 'E': set_action(RZ_BIN_REQ_EXPORTS); break;
        case 'U': set_action(RZ_BIN_REQ_RESOURCES); break;
        case 'Q': set_action(RZ_BIN_REQ_DLOPEN); break;
        case 'M': set_action(RZ_BIN_REQ_MAIN); break;
        case 'l': set_action(RZ_BIN_REQ_LIBS); break;
        case 'R': set_action(RZ_BIN_REQ_RELOCS); break;
        case 'Y': set_action(RZ_BIN_REQ_BASEFIND); break;
        case 'x': set_action(RZ_BIN_REQ_EXTRACT); break;
        case 'O':
            op = opt.arg;
            set_action(RZ_BIN_REQ_OPERATION);
            if (*op == 'c') {
                rz_sys_setenv("RZ_BIN_CODESIGN_VERBOSE", "1");
            }
            if (isBinopHelp(op)) {
                printf("Usage: iO [expression]:\n"
                       " d/s/1024          dump symbols\n"
                       " d/S/.text         dump section\n"
                       " c                 show Codesign data\n"
                       " C                 show LDID entitlements\n");
                rz_core_fini(&core);
                return 0;
            }
            if (opt.ind == argc) {
                eprintf("Missing filename\n");
                rz_core_fini(&core);
                return 1;
            }
            break;
        case 'o': output = opt.arg; break;
        case 'p': core.io->va = false; break;
        case 'r': out_mode = RZ_MODE_RIZINCMD; break;
        case 'v':
            rz_core_fini(&core);
            return rz_main_version_print("rz-bin");
        case 'L':
            set_action(RZ_BIN_REQ_LISTPLUGINS);
            break;
        case 'G':
            laddr = rz_num_math(NULL, opt.arg);
            if (laddr == UT64_MAX) {
                core.io->va = false;
            }
            break;
        case 'B':
            baddr = rz_num_math(NULL, opt.arg);
            break;
        case '@':
            at = rz_num_math(NULL, opt.arg);
            if (at == 0LL && *opt.arg != '0') {
                at = UT64_MAX;
            }
            break;
        case 'n':
            name = opt.arg;
            break;
        case 'N':
            tmp = strchr(opt.arg, ':');
            rz_config_set(core.config, "bin.minstr", opt.arg);
            if (tmp) {
                rz_config_set(core.config, "bin.maxstr", tmp + 1);
            }
            break;
        case 'h':
            rz_core_fini(&core);
            return rabin_show_help(1);
        default:
            action |= RZ_BIN_REQ_HELP;
            break;
        }
    }
 
    if (is_active(RZ_BIN_REQ_LISTPLUGINS)) {
        const char *plugin_name = NULL;
        if (opt.ind < argc) {
            plugin_name = argv[opt.ind];
        }
        PJ *pj = pj_new();
        if (!pj) {
            rz_core_fini(&core);
            return 1;
        }
        __listPlugins(bin, plugin_name, pj, out_mode);
        if (out_mode == RZ_MODE_JSON) {
            rz_cons_println(pj_string(pj));
            rz_cons_flush();
        }
        rz_core_fini(&core);
        return 0;
    }
 
    if (do_demangle) {
        int ret_num = 1;
        char *res = NULL;
        const RzDemanglerPlugin *plugin = NULL;
        if ((argc - opt.ind) < 2) {
            rz_core_fini(&core);
            return rabin_show_help(0);
        }
        file = argv[opt.ind + 1];
        plugin = rz_demangler_plugin_get(bin->demangler, do_demangle);
        if (!plugin) {
            printf("Language '%s' is unsupported\nList of supported languages:\n", do_demangle);
            rz_demangler_plugin_iterate(bin->demangler, (RzDemanglerIter)print_demangler_info, NULL);
            rz_core_fini(&core);
            return 1;
        }
        if (!strcmp(file, "-")) {
            for (;;) {
                file = stdin_gets(false);
                if (!file || !*file) {
                    break;
                }
                res = rz_demangler_plugin_demangle(plugin, file);
                if (RZ_STR_ISNOTEMPTY(res)) {
                    printf("%s\n", res);
                    ret_num = 0;
                } else if (file && *file) {
                    printf("%s\n", file);
                }
                RZ_FREE(res);
                RZ_FREE(file);
            }
            stdin_gets(true);
        } else {
            res = rz_demangler_plugin_demangle(plugin, file);
            if (RZ_STR_ISNOTEMPTY(res)) {
                printf("%s\n", res);
                ret_num = 0;
            } else {
                printf("%s\n", file);
            }
        }
        free(res);
        rz_core_fini(&core);
        return ret_num;
    }
    file = argv[opt.ind];
 
    if (file && !*file) {
        eprintf("Cannot open empty path\n");
        rz_core_fini(&core);
        return 1;
    }
 
    if (!query) {
        if (action & RZ_BIN_REQ_HELP || action == RZ_BIN_REQ_UNK || !file) {
            rz_core_fini(&core);
            return rabin_show_help(0);
        }
    }
    if (arch) {
        ptr = strchr(arch, '_');
        if (ptr) {
            *ptr = '\0';
            bits = rz_num_math(NULL, ptr + 1);
        }
    }
    if (action & RZ_BIN_REQ_CREATE) {
        // TODO: move in a function outside
        RzBuffer *b;
        int datalen, codelen;
        ut8 *data = NULL, *code = NULL;
        char *p2, *p = strchr(create, ':');
        if (!p) {
            eprintf("Invalid format for -C flag. Use 'format:codehexpair:datahexpair'\n");
            rz_core_fini(&core);
            return 1;
        }
        *p++ = 0;
        p2 = strchr(p, ':');
        if (p2) {
            // has data
            *p2++ = 0;
            data = malloc(strlen(p2) + 1);
            datalen = rz_hex_str2bin(p2, data);
            if (datalen < 0) {
                datalen = -datalen;
            }
        } else {
            data = NULL;
            datalen = 0;
        }
        code = malloc(strlen(p) + 1);
        if (!code) {
            rz_core_fini(&core);
            return 1;
        }
        codelen = rz_hex_str2bin(p, code);
        RzBinArchOptions opts;
        rz_bin_arch_options_init(&opts, arch, bits);
        b = rz_bin_create(bin, create, code, codelen, data, datalen, &opts);
        if (b) {
            ut64 tmpsz;
            const ut8 *tmp = rz_buf_data(b, &tmpsz);
            if (rz_file_dump(file, tmp, tmpsz, 0)) {
                eprintf("Dumped %" PFMT64d " bytes in '%s'\n",
                    tmpsz, file);
                (void)rz_file_chmod(file, "+x", 0);
            } else {
                eprintf("Error dumping into a.out\n");
            }
            rz_buf_free(b);
        } else {
            eprintf("Cannot create binary for this format '%s'.\n", create);
        }
        rz_core_fini(&core);
        return 0;
    }
    if (rawstr) {
        unset_action(RZ_BIN_REQ_STRINGS);
    }
 
    if (!file) {
        eprintf("Missing file.\n");
        rz_core_fini(&core);
        return 1;
    }
 
    if (file && *file && action & RZ_BIN_REQ_DLOPEN) {
#if __UNIX__
        int child = rz_sys_fork();
        if (child == -1) {
            rz_core_fini(&core);
            return 1;
        }
        if (child == 0) {
            return waitpid(child, NULL, 0);
        }
#endif
        void *addr = rz_lib_dl_open(file);
        if (addr) {
            eprintf("%s is loaded at 0x%" PFMT64x "\n", file, (ut64)(size_t)(addr));
            rz_lib_dl_close(addr);
            rz_core_fini(&core);
            return 0;
        }
        eprintf("Cannot open the '%s' library\n", file);
        rz_core_fini(&core);
        return 0;
    }
 
    if (RZ_STR_ISNOTEMPTY(file)) {
        if ((fh = rz_core_file_open(&core, file, RZ_PERM_R, 0))) {
            fd = rz_io_fd_get_current(core.io);
            if (fd == -1) {
                eprintf("rz_core: Cannot open file '%s'\n", file);
                result = 1;
                goto err;
            }
        } else {
            eprintf("rz_core: Cannot open file '%s'\n", file);
            rz_core_fini(&core);
            return 1;
        }
    }
    bin->minstrlen = rz_config_get_i(core.config, "bin.minstr");
    bin->maxstrbuf = rz_config_get_i(core.config, "bin.maxstrbuf");
 
    rz_bin_force_plugin(bin, forcebin);
    rz_bin_load_filter(bin, action);
 
    RzBinOptions bo;
    rz_bin_options_init(&bo, fd, baddr, laddr, false);
    bo.obj_opts.elf_load_sections = rz_config_get_b(core.config, "elf.load.sections");
    bo.obj_opts.elf_checks_sections = rz_config_get_b(core.config, "elf.checks.sections");
    bo.obj_opts.elf_checks_segments = rz_config_get_b(core.config, "elf.checks.segments");
    bo.obj_opts.big_endian = rz_config_get_b(core.config, "cfg.bigendian");
    bo.xtr_idx = xtr_idx;
 
    RzBinFile *bf = rz_bin_open(bin, file, &bo);
    if (!bf) {
        eprintf("rz-bin: Cannot open file\n");
        result = 1;
        goto err;
    }
    /* required to automatically select a sub-bin when not specified */
    (void)rz_core_bin_update_arch_bits(&core);
 
    if (baddr != UT64_MAX) {
        rz_bin_set_baddr(bin, baddr);
    }
    if (rawstr) {
        PJ *pj = NULL;
        if (out_mode == RZ_MODE_JSON) {
            pj = pj_new();
            if (!pj) {
                eprintf("rz-bin: Cannot allocate buffer for json array\n");
                result = 1;
                goto err;
            }
            pj_a(pj);
        }
        RzList *list = rz_bin_file_strings(bf, bin->minstrlen, true);
        RzListIter *it;
        RzBinString *string;
        rz_list_foreach (list, it, string) {
            print_string(bf, string, pj, out_mode);
        }
        rz_list_free(list);
        if (pj) {
            pj_end(pj);
            printf("%s", pj_string(pj));
            pj_free(pj);
        }
    }
    if (query) {
        if (out_mode) {
            rz_core_bin_export_info(&core, RZ_MODE_RIZINCMD);
            rz_cons_flush();
        } else {
            if (!strcmp(query, "-")) {
                __sdb_prompt(bin->cur->sdb);
            } else {
                sdb_query(bin->cur->sdb, query);
            }
        }
        result = 0;
        goto err;
    }
#define ismodejson (out_mode == RZ_MODE_JSON && actions > 0)
#define run_action(n, x, y) \
    if (action & (x)) { \
        RzCmdStateOutput *st = add_header(&state, mode, n); \
        y(&core, st); \
        add_footer(&state, st); \
    }
 
    core.bin = bin;
    bin->cb_printf = rz_cons_printf;
    filter.offset = at;
    filter.name = name;
    RzList *chksum_list = NULL;
    if (RZ_STR_ISNOTEMPTY(chksum)) {
        chksum_list = rz_str_split_duplist_n(chksum, ",", 0, true);
        if (!chksum_list) {
            result = 1;
            goto err;
        }
    }
    rz_cons_new()->context->is_interactive = false;
 
    RzCmdStateOutput state;
    RzOutputMode mode = rad2outputmode(out_mode);
    if (!rz_cmd_state_output_init(&state, mode)) {
        result = 1;
        goto chksum_err;
    }
    start_state(&state);
 
    // List fatmach0 sub-binaries, etc
    if (action & RZ_BIN_REQ_LISTARCHS || ((arch || bits || arch_name) && !rz_bin_select(bin, arch, bits, arch_name))) {
        RzCmdStateOutput *st = add_header(&state, mode == RZ_OUTPUT_MODE_STANDARD ? RZ_OUTPUT_MODE_TABLE : mode, "archs");
        rz_core_bin_archs_print(bin, st);
        add_footer(&state, st);
        free(arch_name);
    }
    if (action & RZ_BIN_REQ_PDB_DWNLD) {
        SPDBOptions pdbopts;
        pdbopts.symbol_server = (char *)rz_config_get(core.config, "pdb.server");
        pdbopts.extract = rz_config_get_i(core.config, "pdb.extract");
 
        if ((tmp = rz_sys_getenv("RZ_BIN_SYMSTORE"))) {
            rz_config_set(core.config, "pdb.symstore", tmp);
            RZ_FREE(tmp);
        }
        pdbopts.symbol_store_path = (char *)rz_config_get(core.config, "pdb.symstore");
        result = rz_bin_pdb_download(core.bin, state.mode == RZ_OUTPUT_MODE_JSON ? state.d.pj : NULL, ismodejson, &pdbopts);
    }
 
    if ((tmp = rz_sys_getenv("RZ_BIN_PREFIX"))) {
        rz_config_set(core.config, "bin.prefix", tmp);
        free(tmp);
    }
 
    ut32 mask = actions2mask(action);
    rz_core_bin_print(&core, bf, mask, &filter, &state, chksum_list);
 
    run_action("classes source", RZ_BIN_REQ_CLASSES_SOURCES, classes_as_source_print);
    if (action & RZ_BIN_REQ_SRCLINE) {
        rabin_show_srcline(bin, at);
    }
    if (action & RZ_BIN_REQ_EXTRACT) {
        if (bf->xtr_data) {
            rabin_extract(bin, (!arch && !arch_name && !bits));
        } else {
            eprintf(
                "Cannot extract bins from '%s'. No supported "
                "plugins found!\n",
                bin->file);
        }
    }
    if (op && action & RZ_BIN_REQ_OPERATION) {
        rabin_do_operation(bin, op, out_mode, output, file);
    }
    end_state(&state);
    rz_cmd_state_output_fini(&state);
 
    rz_cons_flush();
 
chksum_err:
    rz_list_free(chksum_list);
err:
    rz_core_file_close(fh);
    rz_core_fini(&core);
 
    return result;
}

References __lib_bin_cb(), __lib_bin_dt(), __lib_bin_xtr_cb(), __lib_bin_xtr_dt(), __lib_demangler_cb(), __lib_demangler_dt(), __listPlugins(), __sdb_prompt(), test-lz4-speed::action, actions2mask(), add_footer(), add_header(), addr, arch, rz_getopt_t::arg, argv, b, baddr(), rz_core_t::bin, bits(), c, classes_as_source_print(), rz_core_t::config, rz_cons_t::context, create(), end_state(), eprintf, err, SPDBOptions::extract, fd, fh, filter(), free(), rz_getopt_t::ind, rz_core_t::io, is_active, rz_cons_context_t::is_interactive, isBinopHelp(), ismodejson, list(), malloc(), mask, name, NULL, output, p, path, PFMT64d, PFMT64x, pj_a(), pj_end(), pj_free(), pj_new(), pj_string(), print_demangler_info(), print_string(), printf(), rabin_do_operation(), rabin_extract(), rabin_show_help(), rabin_show_srcline(), rad2outputmode(), run_action, rz_bin_arch_options_init(), rz_bin_create(), rz_bin_file_strings(), rz_bin_force_plugin(), rz_bin_load_filter(), rz_bin_open(), rz_bin_options_init(), rz_bin_pdb_download(), RZ_BIN_REQ_BASEFIND, RZ_BIN_REQ_CLASSES, RZ_BIN_REQ_CLASSES_SOURCES, RZ_BIN_REQ_CREATE, RZ_BIN_REQ_DLOPEN, RZ_BIN_REQ_DWARF, RZ_BIN_REQ_ENTRIES, RZ_BIN_REQ_EXPORTS, RZ_BIN_REQ_EXTRACT, RZ_BIN_REQ_FIELDS, RZ_BIN_REQ_HELP, RZ_BIN_REQ_IMPORTS, RZ_BIN_REQ_INFO, RZ_BIN_REQ_INITFINI, RZ_BIN_REQ_LIBS, RZ_BIN_REQ_LISTARCHS, RZ_BIN_REQ_LISTPLUGINS, RZ_BIN_REQ_MAIN, RZ_BIN_REQ_OPERATION, RZ_BIN_REQ_PDB, RZ_BIN_REQ_PDB_DWNLD, RZ_BIN_REQ_RELOCS, RZ_BIN_REQ_RESOURCES, RZ_BIN_REQ_SECTIONS, RZ_BIN_REQ_SECTIONS_MAPPING, RZ_BIN_REQ_SEGMENTS, RZ_BIN_REQ_SIGNATURE, RZ_BIN_REQ_SIZE, RZ_BIN_REQ_SRCLINE, RZ_BIN_REQ_STRINGS, RZ_BIN_REQ_SYMBOLS, RZ_BIN_REQ_TRYCATCH, RZ_BIN_REQ_UNK, RZ_BIN_REQ_VERSIONINFO, rz_bin_select(), rz_bin_set_baddr(), rz_buf_data(), rz_buf_free(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_config_get(), rz_config_get_b(), rz_config_get_i(), rz_config_set(), rz_config_unserialize(), rz_cons_flush(), rz_cons_new(), rz_cons_printf(), rz_cons_println(), rz_core_bin_archs_print(), rz_core_bin_export_info(), rz_core_bin_print(), rz_core_bin_update_arch_bits(), rz_core_file_close(), rz_core_file_open(), rz_core_fini(), rz_core_init(), rz_demangler_plugin_demangle, rz_demangler_plugin_get(), rz_demangler_plugin_iterate(), rz_file_chmod(), rz_file_dump(), RZ_FREE, rz_getopt_init(), rz_getopt_next(), rz_hex_str2bin(), RZ_HOME_OLD_PLUGINS, rz_io_fd_get_current(), rz_lib_add_handler(), rz_lib_dl_close(), rz_lib_dl_open(), RZ_LIB_ENV, rz_lib_free(), rz_lib_new(), rz_lib_opendir(), RZ_LIB_TYPE_BIN, RZ_LIB_TYPE_BIN_XTR, RZ_LIB_TYPE_DEMANGLER, rz_list_free(), rz_main_version_print(), RZ_MODE_JSON, RZ_MODE_PRINT, RZ_MODE_RIZINCMD, RZ_MODE_SIMPLE, RZ_MODE_SIMPLEST, rz_num_math(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, rz_path_home_prefix(), rz_path_system(), RZ_PERM_R, RZ_PLUGINS, RZ_STR_ISEMPTY, RZ_STR_ISNOTEMPTY, rz_str_split_duplist_n(), rz_sys_fork(), rz_sys_getenv(), rz_sys_setenv(), sdb_free(), sdb_new(), sdb_query(), set_action, start_state(), stdin_gets(), strdup(), SPDBOptions::symbol_server, SPDBOptions::symbol_store_path, autogen_x86imm::tmp, unset_action, ut64(), UT64_MAX, rz_io_t::va, and rz_bin_file_t::xtr_data.

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_rz_diff()

RZ_API int rz_main_rz_diff	(	int	argc,
		const char **	argv
	)

Definition at line 2254 of file rz-diff.c.

                                                        {
    bool success = false;
    DiffContext ctx;
    rz_diff_parse_arguments(argc, argv, &ctx);
 
    switch (ctx.option) {
    case DIFF_OPT_DISTANCE:
        success = rz_diff_calculate_distance(&ctx);
        break;
    case DIFF_OPT_UNIFIED:
        success = rz_diff_unified_files(&ctx);
        break;
    case DIFF_OPT_GRAPH:
        success = rz_diff_graphs_files(&ctx);
        break;
    case DIFF_OPT_HEX_VISUAL:
        success = rz_diff_hex_visual(&ctx);
        break;
    case DIFF_OPT_VERSION:
        rz_main_version_print("rz-diff");
        success = true;
        break;
    case DIFF_OPT_USAGE:
        rz_diff_show_help(true);
        break;
    case DIFF_OPT_ERROR:
        break;
    case DIFF_OPT_HELP:
        success = true;
        // fallthrough
    default:
        rz_diff_show_help(false);
        break;
    }
 
    rz_list_free(ctx.evars);
    return success ? 0 : 1;
}

References argv, DIFF_OPT_DISTANCE, DIFF_OPT_ERROR, DIFF_OPT_GRAPH, DIFF_OPT_HELP, DIFF_OPT_HEX_VISUAL, DIFF_OPT_UNIFIED, DIFF_OPT_USAGE, DIFF_OPT_VERSION, rz_diff_calculate_distance(), rz_diff_graphs_files(), rz_diff_hex_visual(), rz_diff_parse_arguments(), rz_diff_show_help(), rz_diff_unified_files(), rz_list_free(), and rz_main_version_print().

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_rz_find()

RZ_API int rz_main_rz_find	(	int	argc,
		const char **	argv
	)

Definition at line 474 of file rz-find.c.

                                                        {
    RzfindOptions ro;
    rzfind_options_init(&ro);
 
    int c;
    const char *file = NULL;
 
    RzGetopt opt;
    rz_getopt_init(&opt, argc, argv, "a:ie:b:jmM:s:w:S:I:x:Xzf:F:t:E:rqnhvZ");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'a':
            ro.align = rz_num_math(NULL, opt.arg);
            break;
        case 'r':
            ro.rad = true;
            break;
        case 'i':
            ro.identify = true;
            break;
        case 'j':
            ro.json = true;
            break;
        case 'n':
            ro.nonstop = 1;
            break;
        case 'm':
            ro.mode = RZ_SEARCH_MAGIC;
            break;
        case 'e':
            ro.mode = RZ_SEARCH_REGEXP;
            ro.hexstr = 0;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'E':
            ro.mode = RZ_SEARCH_ESIL;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 's':
            ro.mode = RZ_SEARCH_KEYWORD;
            ro.hexstr = false;
            ro.widestr = false;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'w':
            ro.mode = RZ_SEARCH_KEYWORD;
            ro.hexstr = false;
            ro.widestr = true;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'I':
            ro.import = true;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'S':
            ro.symbol = true;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'b':
            ro.bsize = rz_num_math(NULL, opt.arg);
            break;
        case 'M':
            // XXX should be from hexbin
            ro.mask = opt.arg;
            break;
        case 'f':
            ro.from = rz_num_math(NULL, opt.arg);
            break;
        case 'F': {
            size_t data_size;
            char *data = rz_file_slurp(opt.arg, &data_size);
            if (!data) {
                eprintf("Cannot slurp '%s'\n", opt.arg);
                return 1;
            }
            char *hexdata = rz_hex_bin2strdup((ut8 *)data, data_size);
            if (hexdata) {
                ro.mode = RZ_SEARCH_KEYWORD;
                ro.hexstr = true;
                ro.widestr = false;
                rz_list_append(ro.keywords, (void *)hexdata);
            }
            free(data);
        } break;
        case 't':
            ro.to = rz_num_math(NULL, opt.arg);
            break;
        case 'x':
            ro.mode = RZ_SEARCH_KEYWORD;
            ro.hexstr = 1;
            ro.widestr = 0;
            rz_list_append(ro.keywords, (void *)opt.arg);
            break;
        case 'X':
            ro.pr = rz_print_new();
            break;
        case 'q':
            ro.quiet = true;
            break;
        case 'v':
            return rz_main_version_print("rz-find");
        case 'h':
            return show_help(argv[0], 0);
        case 'z':
            ro.mode = RZ_SEARCH_STRING;
            break;
        case 'Z':
            ro.showstr = true;
            break;
        default:
            return show_help(argv[0], 1);
        }
    }
    if (opt.ind == argc) {
        return show_help(argv[0], 1);
    }
    /* Enable quiet mode if searching just a single file */
    if (opt.ind + 1 == argc && RZ_STR_ISNOTEMPTY(argv[opt.ind]) && !rz_file_is_directory(argv[opt.ind])) {
        ro.quiet = true;
    }
    if (ro.json) {
        printf("[");
    }
    for (; opt.ind < argc; opt.ind++) {
        file = argv[opt.ind];
 
        if (RZ_STR_ISEMPTY(file)) {
            eprintf("Cannot open empty path\n");
            rz_list_free(ro.keywords);
            return 1;
        }
        rzfind_open(&ro, file);
    }
    rz_list_free(ro.keywords);
    if (ro.json) {
        printf("]\n");
    }
    return 0;
}

References RzfindOptions::align, rz_getopt_t::arg, argv, RzfindOptions::bsize, c, eprintf, free(), RzfindOptions::from, RzfindOptions::hexstr, RzfindOptions::identify, RzfindOptions::import, rz_getopt_t::ind, RzfindOptions::json, RzfindOptions::keywords, RzfindOptions::mask, RzfindOptions::mode, RzfindOptions::nonstop, NULL, RzfindOptions::pr, printf(), RzfindOptions::quiet, RzfindOptions::rad, rz_file_is_directory(), rz_file_slurp(), rz_getopt_init(), rz_getopt_next(), rz_hex_bin2strdup(), rz_list_append(), rz_list_free(), rz_main_version_print(), rz_num_math(), rz_print_new(), RZ_SEARCH_ESIL, RZ_SEARCH_KEYWORD, RZ_SEARCH_MAGIC, RZ_SEARCH_REGEXP, RZ_SEARCH_STRING, RZ_STR_ISEMPTY, RZ_STR_ISNOTEMPTY, rzfind_open(), rzfind_options_init(), show_help(), RzfindOptions::showstr, RzfindOptions::symbol, RzfindOptions::to, and RzfindOptions::widestr.

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_rz_gg()

RZ_API int rz_main_rz_gg	(	int	argc,
		const char **	argv
	)

Definition at line 116 of file rz-gg.c.

                                                      {
    const char *file = NULL;
    const char *padding = NULL;
    const char *pattern = NULL;
    const char *str = NULL;
    char *bytes = NULL;
    const char *contents = NULL;
    const char *arch = RZ_SYS_ARCH;
    const char *os = RZ_EGG_OS_NAME;
    const char *format = "raw";
    bool show_execute = false;
    bool show_execute_rop = false;
    int show_hex = 1;
    int show_asm = 0;
    int show_raw = 0;
    int append = 0;
    int show_str = 0;
    ut64 get_offset = 0;
    const char *shellcode = NULL;
    const char *encoder = NULL;
    char *sequence = NULL;
    int bits = (RZ_SYS_BITS & RZ_SYS_BITS_64) ? 64 : 32;
    int fmt = 0;
    const char *ofile = NULL;
    int ofileauto = 0;
    RzBuffer *b;
    int c, i, fd = -1;
    RzEgg *egg = rz_egg_new();
 
    RzGetopt opt;
    rz_getopt_init(&opt, argc, argv, "n:N:he:a:b:f:o:sxXrk:FOI:Li:c:p:P:B:C:vd:D:w:zq:S:");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'a':
            arch = opt.arg;
            if (!strcmp(arch, "trace")) {
                show_asm = 1;
                show_hex = 0;
            }
            break;
        case 'e':
            encoder = opt.arg;
            break;
        case 'b':
            bits = atoi(opt.arg);
            break;
        case 'B':
            bytes = rz_str_append(bytes, opt.arg);
            break;
        case 'C':
            if (RZ_STR_ISEMPTY(opt.arg)) {
                eprintf("Cannot open empty contents path\n");
                free(sequence);
                rz_egg_free(egg);
                return 1;
            }
            contents = opt.arg;
            break;
        case 'w': {
            char *arg = strdup(opt.arg);
            char *p = strchr(arg, ':');
            if (p) {
                int len, off;
                ut8 *b;
                *p++ = 0;
                off = rz_num_math(NULL, arg);
                b = malloc(strlen(opt.arg) + 1);
                len = rz_hex_str2bin(p, b);
                if (len > 0) {
                    rz_egg_patch(egg, off, (const ut8 *)b, len);
                } else {
                    eprintf("Invalid hexstr for -w\n");
                }
                free(b);
            } else {
                eprintf("Missing colon in -w\n");
            }
            free(arg);
        } break;
        case 'n':
        case 'N': {
            ut64 n = rz_num_math(NULL, opt.arg);
            // TODO: support big endian too
            // (this is always little because rz_egg_setup is further below)
            rz_egg_patch_num(egg, -1, n, c == 'N' ? 64 : 32);
            append = 1;
        } break;
        case 'd':
        case 'D': {
            char *p = strchr(opt.arg, ':');
            if (p) {
                *p = '\0';
                ut64 n, off = rz_num_math(NULL, opt.arg);
                *p = ':';
                n = rz_num_math(NULL, p + 1);
                // TODO: support big endian too
                // (this is always little because rz_egg_setup is further below)
                rz_egg_patch_num(egg, off, n, c == 'D' ? 64 : 32);
            } else {
                eprintf("Missing colon in -%c\n", c);
            }
        } break;
        case 'S':
            str = opt.arg;
            break;
        case 'o':
            ofile = opt.arg;
            break;
        case 'O':
            ofileauto = 1;
            break;
        case 'I':
            if (RZ_STR_ISEMPTY(opt.arg)) {
                eprintf("Cannot open empty include path\n");
                free(sequence);
                rz_egg_free(egg);
                return 1;
            }
            rz_egg_lang_include_path(egg, opt.arg);
            break;
        case 'i':
            shellcode = opt.arg;
            break;
        case 'p':
            padding = opt.arg;
            break;
        case 'P':
            pattern = opt.arg;
            break;
        case 'c': {
            char *p = strchr(opt.arg, '=');
            if (p) {
                *p++ = 0;
                rz_egg_option_set(egg, opt.arg, p);
            } else {
                rz_egg_option_set(egg, opt.arg, "true");
            }
        } break;
        case 'F':
#if __APPLE__
            format = "mach0";
#elif __WINDOWS__
            format = "pe";
#else
            format = "elf";
#endif
            show_asm = 0;
            break;
        case 'f':
            format = opt.arg;
            show_asm = 0;
            break;
        case 's':
            show_asm = 1;
            show_hex = 0;
            break;
        case 'k':
            os = opt.arg;
            break;
        case 'r':
            show_raw = 1;
            break;
        case 'x':
            // execute
            show_execute = true;
            break;
        case 'X':
            // execute rop chain
            show_execute = 1;
            show_execute_rop = 1;
            break;
        case 'L':
            list(egg);
            rz_egg_free(egg);
            free(sequence);
            return 0;
        case 'h':
            rz_egg_free(egg);
            free(sequence);
            return usage(1);
        case 'v':
            free(sequence);
            rz_egg_free(egg);
            return rz_main_version_print("rz-gg");
        case 'z':
            show_str = 1;
            break;
        case 'q':
            get_offset = 1;
            sequence = strdup(opt.arg);
            break;
        default:
            free(sequence);
            rz_egg_free(egg);
            return 1;
        }
    }
 
    if (opt.ind == argc && !shellcode && !bytes && !contents && !encoder && !padding && !pattern && !append && !get_offset && !str) {
        free(sequence);
        rz_egg_free(egg);
        return usage(0);
    } else {
        file = argv[opt.ind];
    }
 
    if (bits == 64) {
        if (!strcmp(format, "mach0")) {
            format = "mach064";
        } else if (!strcmp(format, "elf")) {
            format = "elf64";
        }
    }
 
    // catch this first
    if (get_offset) {
        if (strncmp(sequence, "0x", 2)) {
            eprintf("Need hex value with `0x' prefix e.g. 0x41414142\n");
            free(sequence);
            rz_egg_free(egg);
            return 1;
        }
 
        get_offset = rz_num_math(0, sequence);
        printf("Little endian: %d\n", rz_debruijn_offset(0, NULL, get_offset, false));
        printf("Big endian: %d\n", rz_debruijn_offset(0, NULL, get_offset, true));
        free(sequence);
        rz_egg_free(egg);
        return 0;
    }
 
    // initialize egg
    rz_egg_setup(egg, arch, bits, 0, os);
    if (file) {
        if (RZ_STR_ISEMPTY(file)) {
            eprintf("Cannot open empty path\n");
            goto fail;
        }
        if (!strcmp(file, "-")) {
            char buf[1024];
            for (;;) {
                if (!fgets(buf, sizeof(buf), stdin)) {
                    break;
                }
                if (feof(stdin)) {
                    break;
                }
                rz_egg_load(egg, buf, 0);
            }
        } else {
            if (!rz_egg_load_file(egg, file)) {
                eprintf("Cannot load file \"%s\"\n", file);
            }
        }
    }
 
    // compile source code to assembly
    if (!rz_egg_compile(egg)) {
        if (!fmt) {
            eprintf("rz_egg_compile: fail\n");
            free(sequence);
            rz_egg_free(egg);
            return 1;
        }
    }
 
    // append the provided string
    if (str) {
        int l = strlen(str);
        if (l > 0) {
            rz_egg_raw(egg, (const ut8 *)str, l);
        }
    }
 
    // add raw file
    if (contents) {
        size_t l;
        char *buf = rz_file_slurp(contents, &l);
        if (buf && l > 0) {
            rz_egg_raw(egg, (const ut8 *)buf, (int)l);
        } else {
            eprintf("Error loading '%s'\n", contents);
        }
        free(buf);
    }
 
    // add shellcode
    if (shellcode) {
        if (!rz_egg_shellcode(egg, shellcode)) {
            eprintf("Unknown shellcode '%s'\n", shellcode);
            goto fail;
        }
    }
 
    // add raw bytes
    if (bytes) {
        ut8 *b = malloc(strlen(bytes) + 1);
        int len = rz_hex_str2bin(bytes, b);
        if (len > 0) {
            if (!rz_egg_raw(egg, b, len)) {
                eprintf("Unknown '%s'\n", shellcode);
                free(b);
                goto fail;
            }
        } else {
            eprintf("Invalid hexpair string for -B\n");
        }
        free(b);
        free(bytes);
        bytes = NULL;
    }
 
    /* set output (create output file if needed) */
    if (ofileauto) {
        if (file) {
            char *o, *q, *p = strdup(file);
            if ((o = strchr(p, '.'))) {
                while ((q = strchr(o + 1, '.'))) {
                    o = q;
                }
                *o = 0;
                fd = openfile(p, ISEXEC);
            } else {
                fd = openfile("a.out", ISEXEC);
            }
            free(p);
        } else {
            fd = openfile("a.out", ISEXEC);
        }
        if (fd == -1) {
            eprintf("cannot open file '%s'\n", opt.arg);
            goto fail;
        }
        close(fd);
    }
    if (ofile) {
        fd = openfile(ofile, ISEXEC);
        if (fd == -1) {
            eprintf("cannot open file '%s'\n", ofile);
            goto fail;
        }
    }
 
    // assemble to binary
    if (!rz_egg_assemble(egg)) {
        eprintf("rz_egg_assemble: invalid assembly\n");
        goto fail;
    }
    if (encoder) {
        if (!rz_egg_encode(egg, encoder)) {
            eprintf("Invalid encoder '%s'\n", encoder);
            goto fail;
        }
    }
 
    // add padding
    if (padding) {
        rz_egg_padding(egg, padding);
    }
 
    // add pattern
    if (pattern) {
        rz_egg_pattern(egg, rz_num_math(NULL, pattern));
    }
 
    // apply patches
    if (!egg->bin) {
        egg->bin = rz_buf_new_with_bytes(NULL, 0);
    }
    if (!rz_egg_get_bin(egg)) {
        eprintf("rz_egg_get_bin: invalid egg :(\n");
        goto fail;
    }
    rz_egg_finalize(egg);
 
    if (show_asm) {
        printf("%s\n", rz_egg_get_assembly(egg));
    }
 
    if (show_raw || show_hex || show_execute) {
        if (show_execute) {
            int r;
            if (show_execute_rop) {
                r = rz_egg_run_rop(egg);
            } else {
                r = rz_egg_run(egg);
            }
            rz_egg_free(egg);
            return r;
        }
        b = rz_egg_get_bin(egg);
        if (show_raw) {
            ut64 blen;
            const ut8 *tmp = rz_buf_data(b, &blen);
            if (write(1, tmp, blen) != blen) {
                eprintf("Failed to write buffer\n");
                goto fail;
            }
        } else {
            if (!format) {
                eprintf("No format specified\n");
                goto fail;
            }
            char *code = NULL;
            ut64 tmpsz;
            const ut8 *tmp = rz_buf_data(b, &tmpsz);
            switch (*format) {
            case 'c':
                code = rz_lang_byte_array(tmp, tmpsz, RZ_LANG_BYTE_ARRAY_C_CPP_BYTES);
                printf("%s\n", code);
                free(code);
                break;
            case 'j': // json
                code = rz_lang_byte_array(tmp, tmpsz, RZ_LANG_BYTE_ARRAY_JSON);
                printf("%s\n", code);
                free(code);
                break;
            case 'r':
                if (show_str) {
                    printf("\"");
                    for (i = 0; i < tmpsz; i++) {
                        printf("\\x%02x", tmp[i]);
                    }
                    printf("\"\n");
                } else if (show_hex) {
                    rz_buf_seek(b, 0, RZ_BUF_SET);
                    for (i = 0; i < tmpsz; i++) {
                        printf("%02x", tmp[i]);
                    }
                    printf("\n");
                } // else show_raw is_above()
                break;
            case 'p': // PE
                if (strlen(format) >= 2 && format[1] == 'y') { // Python
                    code = rz_lang_byte_array(tmp, tmpsz, RZ_LANG_BYTE_ARRAY_PYTHON);
                    printf("%s\n", code);
                    free(code);
                }
                break;
            case 'e': // ELF
            case 'm': // MACH0
                create(format, arch, bits, tmp, tmpsz);
                break;
            default:
                eprintf("unknown executable format (%s)\n", format);
                goto fail;
            }
        }
    }
    if (fd != -1) {
        close(fd);
    }
    free(sequence);
    rz_egg_free(egg);
    return 0;
fail:
    if (fd != -1) {
        close(fd);
    }
    free(sequence);
    rz_egg_free(egg);
    return 1;
}

References append, arch, rz_getopt_t::arg, argv, b, rz_egg_t::bin, bits(), bytes, c, close, create(), eprintf, fail, fd, free(), get_offset(), i, rz_getopt_t::ind, ISEXEC, len, list(), malloc(), n, NULL, off, ofile, openfile(), p, printf(), r, rz_buf_data(), rz_buf_new_with_bytes(), rz_buf_seek(), RZ_BUF_SET, rz_debruijn_offset(), rz_egg_assemble(), rz_egg_compile(), rz_egg_encode(), rz_egg_finalize(), rz_egg_free(), rz_egg_get_assembly(), rz_egg_get_bin(), rz_egg_lang_include_path(), rz_egg_load(), rz_egg_load_file(), rz_egg_new(), rz_egg_option_set(), RZ_EGG_OS_NAME, rz_egg_padding(), rz_egg_patch(), rz_egg_patch_num(), rz_egg_pattern(), rz_egg_raw(), rz_egg_run(), rz_egg_run_rop(), rz_egg_setup(), rz_egg_shellcode(), rz_file_slurp(), rz_getopt_init(), rz_getopt_next(), rz_hex_str2bin(), rz_lang_byte_array(), RZ_LANG_BYTE_ARRAY_C_CPP_BYTES, RZ_LANG_BYTE_ARRAY_JSON, RZ_LANG_BYTE_ARRAY_PYTHON, rz_main_version_print(), rz_num_math(), rz_str_append(), RZ_STR_ISEMPTY, RZ_SYS_ARCH, RZ_SYS_BITS, RZ_SYS_BITS_64, cmd_descs_generate::str, strdup(), autogen_x86imm::tmp, usage(), ut64(), and write.

Referenced by MAIN_NAME(), and rz_main_rizin().

rz_main_rz_hash()

RZ_API int rz_main_rz_hash	(	int	argc,
		const char **	argv
	)

Definition at line 1205 of file rz-hash.c.

                                                        {
    int result = 1;
    RzHashContext ctx = { 0 };
    ctx.rh = rz_hash_new();
    hash_load_plugins(&ctx);
 
    hash_parse_cmdline(argc, argv, &ctx);
 
    switch (ctx.operation) {
    case RZ_HASH_OP_LIST_ALGO:
        rz_hash_show_algorithms(&ctx);
        break;
    case RZ_HASH_OP_LUHN:
        if (!hash_context_run(&ctx, calculate_luhn)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_HASH:
        if (!hash_context_run(&ctx, calculate_hash)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_DECRYPT:
        if (!hash_context_run(&ctx, calculate_decrypt)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_ENCRYPT:
        if (!hash_context_run(&ctx, calculate_encrypt)) {
            goto rz_main_rz_hash_end;
        }
        break;
    case RZ_HASH_OP_VERSION:
        rz_main_version_print("rz-hash");
        break;
    case RZ_HASH_OP_USAGE:
        rz_hash_show_help(true);
        goto rz_main_rz_hash_end;
    case RZ_HASH_OP_ERROR:
        goto rz_main_rz_hash_end;
    case RZ_HASH_OP_HELP:
        result = 0;
        /* fall-thru */
    default:
        rz_hash_show_help(false);
        goto rz_main_rz_hash_end;
    }
 
    result = 0;
 
rz_main_rz_hash_end:
    hash_context_fini(&ctx);
    return result;
}

References argv, calculate_decrypt(), calculate_encrypt(), calculate_hash(), calculate_luhn(), hash_context_fini(), hash_context_run(), hash_load_plugins(), hash_parse_cmdline(), rz_hash_new(), RZ_HASH_OP_DECRYPT, RZ_HASH_OP_ENCRYPT, RZ_HASH_OP_ERROR, RZ_HASH_OP_HASH, RZ_HASH_OP_HELP, RZ_HASH_OP_LIST_ALGO, RZ_HASH_OP_LUHN, RZ_HASH_OP_USAGE, RZ_HASH_OP_VERSION, rz_hash_show_algorithms(), rz_hash_show_help(), and rz_main_version_print().

Referenced by MAIN_NAME().

rz_main_rz_run()

RZ_API int rz_main_rz_run	(	int	argc,
		const char **	argv
	)

Definition at line 25 of file rz-run.c.

                                                       {
    RzRunProfile *p;
    int i, ret;
    if (argc == 1 || !strcmp(argv[1], "-h")) {
        printf("Usage: rz-run -v|-t|script.rr2 [directive ..]\n");
        printf("%s", rz_run_help());
        return 1;
    }
    if (!strcmp(argv[1], "-v")) {
        return rz_main_version_print("rz-run");
    }
    const char *file = argv[1];
    if (!strcmp(file, "-t")) {
#if __UNIX__
        rz_run_tty();
        return 0;
#else
        eprintf("Not supported\n");
        return 1;
#endif
    }
    if (*file && !strchr(file, '=')) {
        p = rz_run_new(file);
    } else {
        bool noMoreDirectives = false;
        int directiveIndex = 0;
        p = rz_run_new(NULL);
        for (i = *file ? 1 : 2; i < argc; i++) {
            if (!strcmp(argv[i], "--")) {
                noMoreDirectives = true;
                continue;
            }
            if (noMoreDirectives) {
                const char *word = argv[i];
                char *line = directiveIndex
                    ? rz_str_newf("arg%d=%s", directiveIndex, word)
                    : rz_str_newf("program=%s", word);
                rz_run_parseline(p, line);
                directiveIndex++;
                free(line);
            } else {
                rz_run_parseline(p, argv[i]);
            }
        }
    }
    if (!p) {
        return 1;
    }
    ret = rz_run_config_env(p);
    if (ret) {
        printf("error while configuring the environment.\n");
        rz_run_free(p);
        return 1;
    }
    ret = rz_run_start(p);
    rz_run_free(p);
    return ret;
}

References argv, eprintf, free(), i, setup::line, NULL, p, printf(), rz_main_version_print(), rz_run_config_env(), rz_run_free(), rz_run_help(), rz_run_new(), rz_run_parseline(), rz_run_start(), and rz_str_newf().

Referenced by MAIN_NAME().

rz_main_rz_sign()

RZ_API int rz_main_rz_sign	(	int	argc,
		const char **	argv
	)

Definition at line 40 of file rz-sign.c.

                                                        {
    RzListIter *it;
    const char *input_file = NULL;
    const char *output_file = NULL;
    char *config = NULL;
    RzCore *core = NULL;
    RzList *evars = NULL;
    bool quiet = false;
    RzGetopt opt;
    int ret = 0;
    ut32 n_nodes = 0;
 
    int c, option = RZ_SIGN_OPT_NONE;
    size_t complexity = 0;
 
    evars = rz_list_newf(free);
    if (!evars) {
        RZ_LOG_ERROR("rz-sign: cannot allocate RzList\n");
        return -1;
    }
 
    rz_getopt_init(&opt, argc, argv, "aqhdc:o:e:v");
    while ((c = rz_getopt_next(&opt)) != -1) {
        switch (c) {
        case 'a':
            complexity++;
            break;
        case 'c':
            if (option != RZ_SIGN_OPT_NONE) {
                RZ_LOG_ERROR("rz-sign: cannot combine option -%c with previous options\n", c);
                ret = -1;
                goto rz_sign_end;
            }
            option = RZ_SIGN_OPT_CONVERT_FLIRT;
            output_file = opt.arg;
            break;
        case 'o':
            if (option != RZ_SIGN_OPT_NONE) {
                RZ_LOG_ERROR("rz-sign: cannot combine option -%c with previous options\n", c);
                ret = -1;
                goto rz_sign_end;
            }
            option = RZ_SIGN_OPT_CREATE_FLIRT;
            output_file = opt.arg;
            break;
        case 'd':
            if (option != RZ_SIGN_OPT_NONE) {
                RZ_LOG_ERROR("rz-sign: cannot combine option -%c with previous options\n", c);
                ret = -1;
                goto rz_sign_end;
            }
            option = RZ_SIGN_OPT_DUMP_FLIRT;
            break;
        case 'e':
            if (!(config = rz_str_new(opt.arg)) || !rz_list_append(evars, config)) {
                free(config);
                RZ_LOG_ERROR("rz-sign: cannot add evaluable config variable '%s' to RzList\n", opt.arg);
                ret = -1;
                goto rz_sign_end;
            }
            break;
        case 'q':
            quiet = true;
            break;
        case 'v':
            return rz_main_version_print("rz-sign");
        case 'h':
            rz_sign_show_help();
            goto rz_sign_end;
        default:
            RZ_LOG_ERROR("rz-sign: invalid option -%c\n", c);
            rz_sign_show_help();
            ret = -1;
            goto rz_sign_end;
        }
    }
 
    if (opt.ind >= argc) {
        RZ_LOG_ERROR("rz-sign: input file was not provided\n");
        rz_sign_show_help();
        ret = -1;
        goto rz_sign_end;
    }
 
    input_file = argv[opt.ind];
 
    if (option == RZ_SIGN_OPT_CREATE_FLIRT && complexity > 2) {
        RZ_LOG_ERROR("rz-sign: Invalid analysis complexity (too many -a defined, max -aa)\n");
        rz_sign_show_help();
        ret = -1;
        goto rz_sign_end;
    }
 
    core = rz_core_new();
    if (!core) {
        RZ_LOG_ERROR("rz-sign: Cannot allocate RzCore\n");
        ret = -1;
        goto rz_sign_end;
    }
    rz_config_set_b(core->config, "scr.interactive", false);
    rz_config_set_b(core->config, "analysis.apply.signature", false);
    rz_cons_reset();
    rz_cons_set_interactive(false);
 
    rz_core_loadlibs(core, RZ_CORE_LOADLIBS_ALL);
 
    if (!rz_core_file_open(core, input_file, 0, 0)) {
        RZ_LOG_ERROR("rz-sign: Could not open file %s\n", input_file);
        ret = -1;
        goto rz_sign_end;
    }
 
    (void)rz_core_bin_load(core, NULL, UT64_MAX);
    (void)rz_core_bin_update_arch_bits(core);
 
    // quiet mode
    if (quiet) {
        rz_config_set_b(core->config, "scr.prompt", false);
        rz_config_set_i(core->config, "scr.color", COLOR_MODE_DISABLED);
    }
 
    // set all evars
    rz_list_foreach (evars, it, config) {
        if (!rz_config_eval(core->config, config)) {
            RZ_LOG_ERROR("rz-sign: invalid option '%s'\n", config);
            ret = -1;
            goto rz_sign_end;
        }
    }
 
    switch (option) {
    case RZ_SIGN_OPT_CONVERT_FLIRT:
        // convert a flirt file from .pat to .sig or viceversa
        if (!rz_core_flirt_convert_file(core, input_file, output_file)) {
            ret = -1;
        } else if (!quiet) {
            rz_cons_printf("rz-sign: %s was converted to %s.\n", input_file, output_file);
        }
        break;
    case RZ_SIGN_OPT_CREATE_FLIRT:
        // run analysis to find functions
        perform_analysis(core, complexity);
        // create flirt file
        if (!rz_core_flirt_create_file(core, output_file, &n_nodes)) {
            ret = -1;
        } else if (!quiet) {
            rz_cons_printf("rz-sign: written %u signatures to %s.\n", n_nodes, output_file);
        }
        break;
    case RZ_SIGN_OPT_DUMP_FLIRT:
        if (!rz_core_flirt_dump_file(input_file)) {
            ret = -1;
        }
        break;
    default:
        RZ_LOG_ERROR("rz-sign: missing option, please set -c or -d or -o\n");
        ret = -1;
        break;
    }
    rz_cons_flush();
 
rz_sign_end:
    rz_list_free(evars);
    rz_core_free(core);
    return ret;
}

References rz_getopt_t::arg, argv, c, COLOR_MODE_DISABLED, rz_core_t::config, free(), rz_getopt_t::ind, NULL, perform_analysis(), rz_config_eval(), rz_config_set_b(), rz_config_set_i(), rz_cons_flush(), rz_cons_printf(), rz_cons_reset(), rz_cons_set_interactive(), rz_core_bin_load(), rz_core_bin_update_arch_bits(), rz_core_file_open(), rz_core_flirt_convert_file(), rz_core_flirt_create_file(), rz_core_flirt_dump_file(), rz_core_free(), rz_core_loadlibs(), rz_core_new(), rz_getopt_init(), rz_getopt_next(), rz_list_append(), rz_list_free(), rz_list_newf(), RZ_LOG_ERROR, rz_main_version_print(), RZ_SIGN_OPT_CONVERT_FLIRT, RZ_SIGN_OPT_CREATE_FLIRT, RZ_SIGN_OPT_DUMP_FLIRT, RZ_SIGN_OPT_NONE, rz_sign_show_help(), rz_str_new(), and UT64_MAX.

Referenced by MAIN_NAME().

rz_main_version_print()

RZ_API int rz_main_version_print

(

const char *

program

)

Definition at line 49 of file main.c.

                                                       {
    char *s = rz_str_version(progname);
    printf("%s\n", s);
    free(s);
    return 0;
}

References free(), printf(), progname, rz_str_version(), and s.

Referenced by rax(), rz_main_rizin(), rz_main_rz_asm(), rz_main_rz_bin(), rz_main_rz_diff(), rz_main_rz_find(), rz_main_rz_gg(), rz_main_rz_hash(), rz_main_rz_run(), rz_main_rz_sign(), and showversion().