#include <rz_core.h>
#include <rz_demangler.h>
#include <rz_types.h>
#include <rz_util.h>
#include <stdio.h>
#include <stdlib.h>
#include <rz_main.h>
#include "../../librz/bin/pdb/pdb_downloader.h"

Macros
#define	STDIN_BUF_SIZE 96096

#define	is_active(x) (action & (x))

#define	set_action(x)

#define	unset_action(x) action &= ~x

#define	ismodejson (out_mode == RZ_MODE_JSON && actions > 0)

#define	run_action(n, x, y)

Functions
static void	start_state (RzCmdStateOutput *state)

static void	end_state (RzCmdStateOutput *state)

static bool	add_footer (RzCmdStateOutput main_state, RzCmdStateOutput state)

static RzCmdStateOutput *	add_header (RzCmdStateOutput main_state, RzOutputMode mode, const char header)

static void	classes_as_source_print (RzCore core, RzCmdStateOutput state)

static RzOutputMode	rad2outputmode (int rad)

static ut32	actions2mask (ut64 action)

static int	rabin_show_help (int v)

static char *	stdin_gets (bool liberate)

static void	__sdb_prompt (Sdb *sdb)

static bool	isBinopHelp (const char *op)

static bool	extract_binobj (const RzBinFile bf, RzBinXtrData data, int idx)

static int	rabin_extract (RzBin *bin, int all)

static int	rabin_dump_symbols (RzBin *bin, int len)

static bool	__dumpSections (RzBin bin, const char scnname, const char output, const char file)

static int	rabin_do_operation (RzBin bin, const char op, int rad, const char output, const char file)

static int	rabin_show_srcline (RzBin *bin, ut64 at)

static int	__lib_demangler_cb (RzLibPlugin pl, void user, void *data)

static int	__lib_demangler_dt (RzLibPlugin pl, void p, void *u)

static int	__lib_bin_cb (RzLibPlugin pl, void user, void *data)

static int	__lib_bin_dt (RzLibPlugin pl, void p, void *u)

static int	__lib_bin_xtr_cb (RzLibPlugin pl, void user, void *data)

static int	__lib_bin_xtr_dt (RzLibPlugin pl, void p, void *u)

static void	__listPlugins (RzBin bin, const char plugin_name, PJ *pj, int rad)

static bool	print_demangler_info (const RzDemanglerPlugin plugin, void user)

static void	print_string (RzBinFile bf, RzBinString string, PJ *pj, int mode)

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

Macro Definition Documentation

◆ is_active

#define is_active ( x ) (action & (x))

◆ ismodejson

#define ismodejson (out_mode == RZ_MODE_JSON && actions > 0)

◆ run_action

#define run_action	(	n,
		x,
		y
	)

Value:

    if (action & (x)) { \
        RzCmdStateOutput *st = add_header(&state, mode, n); \
        y(&core, st); \
        add_footer(&state, st); \
    }

◆ set_action

#define set_action ( x )

Value:

    { \
        actions++; \
        action |= (x); \
    }

◆ STDIN_BUF_SIZE

#define STDIN_BUF_SIZE 96096

◆ unset_action

#define unset_action ( x ) action &= ~x

Function Documentation

◆ __dumpSections()

static bool __dumpSections	(	RzBin *	bin,
		const char *	scnname,
		const char *	output,
		const char *	file
	)

static

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

                                                                                                   {
     RzList *sections;
     RzListIter *iter;
     RzBinSection *section;
     ut8 *buf;
     char *ret;
     int r;
  
     if (!(sections = rz_bin_get_sections(bin))) {
         return false;
     }
  
     rz_list_foreach (sections, iter, section) {
         if (!strcmp(scnname, section->name)) {
             if (!(buf = malloc(section->size))) {
                 return false;
             }
             if ((section->size * 2) + 1 < section->size) {
                 free(buf);
                 return false;
             }
             if (!(ret = malloc(section->size * 2 + 1))) {
                 free(buf);
                 return false;
             }
             if (section->paddr > rz_buf_size(bin->cur->buf) ||
                 section->paddr + section->size > rz_buf_size(bin->cur->buf)) {
                 free(buf);
                 free(ret);
                 return false;
             }
             r = rz_buf_read_at(bin->cur->buf, section->paddr,
                 buf, section->size);
             if (r < 1) {
                 free(buf);
                 free(ret);
                 return false;
             }
             // it does mean the user specified an output file
             if (strcmp(output, file)) {
                 rz_file_dump(output, buf, section->size, 0);
             } else {
                 rz_hex_bin2str(buf, section->size, ret);
                 printf("%s\n", ret);
             }
             free(buf);
             free(ret);
             break;
         }
     }
     return true;
 }

References bin::buf, free(), malloc(), output, printf(), r, rz_bin_get_sections(), rz_buf_read_at(), rz_buf_size(), rz_file_dump(), rz_hex_bin2str(), sections(), and section::size.

Referenced by rabin_do_operation().

◆ __lib_bin_cb()

static int __lib_bin_cb	(	RzLibPlugin *	pl,
		void *	user,
		void *	data
	)

static

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

                                                                  {
     struct rz_bin_plugin_t *hand = (struct rz_bin_plugin_t *)data;
     RzBin *bin = user;
     rz_bin_plugin_add(bin, hand);
     return true;
 }

References rz_bin_plugin_add(), and rz_bin_plugin_t::user.

Referenced by rz_main_rz_bin().

◆ __lib_bin_dt()

static int __lib_bin_dt	(	RzLibPlugin *	pl,
		void *	p,
		void *	u
	)

static

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

                                                            {
     return true;
 }

Referenced by rz_main_rz_bin().

◆ __lib_bin_xtr_cb()

static int __lib_bin_xtr_cb	(	RzLibPlugin *	pl,
		void *	user,
		void *	data
	)

static

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

                                                                      {
     struct rz_bin_xtr_plugin_t *hand = (struct rz_bin_xtr_plugin_t *)data;
     RzBin *bin = user;
     // printf(" * Added (dis)assembly plugin\n");
     rz_bin_xtr_add(bin, hand);
     return true;
 }

References rz_bin_xtr_add().

Referenced by rz_main_rz_bin().

◆ __lib_bin_xtr_dt()

static int __lib_bin_xtr_dt	(	RzLibPlugin *	pl,
		void *	p,
		void *	u
	)

static

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

                                                                {
     return true;
 }

Referenced by rz_main_rz_bin().

◆ __lib_demangler_cb()

static int __lib_demangler_cb	(	RzLibPlugin *	pl,
		void *	user,
		void *	data
	)

static

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

                                                                        {
     rz_demangler_plugin_add(user, (RzDemanglerPlugin *)data);
     return true;
 }

References rz_demangler_plugin_add().

Referenced by rz_main_rz_bin().

◆ __lib_demangler_dt()

static int __lib_demangler_dt	(	RzLibPlugin *	pl,
		void *	p,
		void *	u
	)

static

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

                                                                  {
     return true;
 }

Referenced by rz_main_rz_bin().

◆ __listPlugins()

static void __listPlugins	(	RzBin *	bin,
		const char *	plugin_name,
		PJ *	pj,
		int	rad
	)

static

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

                                                                                 {
     int format = 0;
     RzCmdStateOutput state = { 0 };
     if (rad == RZ_MODE_JSON) {
         format = 'j';
         rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_JSON);
     } else if (rad) {
         format = 'q';
         rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_QUIET);
     } else {
         rz_cmd_state_output_init(&state, RZ_OUTPUT_MODE_STANDARD);
     }
     bin->cb_printf = (PrintfCallback)printf;
     if (plugin_name) {
         rz_bin_list_plugin(bin, plugin_name, pj, format);
     } else {
         rz_core_bin_plugins_print(bin, &state);
         rz_cmd_state_output_print(&state);
         rz_cmd_state_output_fini(&state);
         rz_cons_flush();
     }
 }

References printf(), rz_bin_list_plugin(), rz_cmd_state_output_fini(), rz_cmd_state_output_init(), rz_cmd_state_output_print(), rz_cons_flush(), rz_core_bin_plugins_print(), RZ_MODE_JSON, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, and RZ_OUTPUT_MODE_STANDARD.

Referenced by rz_main_rz_bin().

◆ __sdb_prompt()

static void __sdb_prompt ( Sdb * sdb )

static

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

                                    {
     char *line;
     for (; (line = stdin_gets(false));) {
         sdb_query(sdb, line);
         free(line);
     }
 }

References free(), setup::line, sdb_query(), and stdin_gets().

Referenced by rz_main_rz_bin().

◆ actions2mask()

static ut32 actions2mask ( ut64 action )

static

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

                                       {
     ut32 res = 0;
     if (action & RZ_BIN_REQ_SECTIONS) {
         res |= RZ_CORE_BIN_ACC_SECTIONS;
     }
     if (action & RZ_BIN_REQ_SEGMENTS) {
         res |= RZ_CORE_BIN_ACC_SEGMENTS;
     }
     if (action & RZ_BIN_REQ_ENTRIES) {
         res |= RZ_CORE_BIN_ACC_ENTRIES;
     }
     if (action & RZ_BIN_REQ_INITFINI) {
         res |= RZ_CORE_BIN_ACC_INITFINI;
     }
     if (action & RZ_BIN_REQ_MAIN) {
         res |= RZ_CORE_BIN_ACC_MAIN;
     }
     if (action & RZ_BIN_REQ_IMPORTS) {
         res |= RZ_CORE_BIN_ACC_IMPORTS;
     }
     if (action & RZ_BIN_REQ_CLASSES) {
         res |= RZ_CORE_BIN_ACC_CLASSES;
     }
     if (action & RZ_BIN_REQ_SYMBOLS) {
         res |= RZ_CORE_BIN_ACC_SYMBOLS;
     }
     if (action & RZ_BIN_REQ_EXPORTS) {
         res |= RZ_CORE_BIN_ACC_EXPORTS;
     }
     if (action & RZ_BIN_REQ_RESOURCES) {
         res |= RZ_CORE_BIN_ACC_RESOURCES;
     }
     if (action & RZ_BIN_REQ_STRINGS) {
         res |= RZ_CORE_BIN_ACC_STRINGS;
     }
     if (action & RZ_BIN_REQ_INFO) {
         res |= RZ_CORE_BIN_ACC_INFO;
     }
     if (action & RZ_BIN_REQ_FIELDS) {
         res |= RZ_CORE_BIN_ACC_FIELDS;
     }
     if (action & RZ_BIN_REQ_HEADER) {
         res |= RZ_CORE_BIN_ACC_HEADER;
     }
     if (action & RZ_BIN_REQ_LIBS) {
         res |= RZ_CORE_BIN_ACC_LIBS;
     }
     if (action & RZ_BIN_REQ_RELOCS) {
         res |= RZ_CORE_BIN_ACC_RELOCS;
     }
     if (action & RZ_BIN_REQ_DWARF) {
         res |= RZ_CORE_BIN_ACC_DWARF;
     }
     if (action & RZ_BIN_REQ_PDB) {
         res |= RZ_CORE_BIN_ACC_PDB;
     }
     if (action & RZ_BIN_REQ_SIZE) {
         res |= RZ_CORE_BIN_ACC_SIZE;
     }
     if (action & RZ_BIN_REQ_VERSIONINFO) {
         res |= RZ_CORE_BIN_ACC_VERSIONINFO;
     }
     if (action & RZ_BIN_REQ_SIGNATURE) {
         res |= RZ_CORE_BIN_ACC_SIGNATURE;
     }
     if (action & RZ_BIN_REQ_SECTIONS_MAPPING) {
         res |= RZ_CORE_BIN_ACC_SECTIONS_MAPPING;
     }
     if (action & RZ_BIN_REQ_BASEFIND) {
         res |= RZ_CORE_BIN_ACC_BASEFIND;
     }
     return res;
 }

References test-lz4-speed::action, RZ_BIN_REQ_BASEFIND, RZ_BIN_REQ_CLASSES, RZ_BIN_REQ_DWARF, RZ_BIN_REQ_ENTRIES, RZ_BIN_REQ_EXPORTS, RZ_BIN_REQ_FIELDS, RZ_BIN_REQ_HEADER, RZ_BIN_REQ_IMPORTS, RZ_BIN_REQ_INFO, RZ_BIN_REQ_INITFINI, RZ_BIN_REQ_LIBS, RZ_BIN_REQ_MAIN, RZ_BIN_REQ_PDB, 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_STRINGS, RZ_BIN_REQ_SYMBOLS, and RZ_BIN_REQ_VERSIONINFO.

Referenced by rz_main_rz_bin().

◆ add_footer()

static bool add_footer	(	RzCmdStateOutput *	main_state,
		RzCmdStateOutput *	state
	)

static

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

                                                                               {
     if (state->mode == RZ_OUTPUT_MODE_TABLE) {
         char *s = rz_table_tostring(state->d.t);
         if (!s) {
             return false;
         }
         rz_cons_printf("%s\n", s);
         free(s);
     } else if (state->mode == RZ_OUTPUT_MODE_JSON) {
         const char *state_json = pj_string(state->d.pj);
         pj_raw(main_state->d.pj, state_json);
     }
     rz_cmd_state_output_free(state);
     return true;
 }

References rz_cmd_state_output_t::d, free(), rz_cmd_state_output_t::pj, pj_raw(), pj_string(), rz_cmd_state_output_free(), rz_cons_printf(), RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_TABLE, rz_table_tostring(), and s.

Referenced by rz_main_rz_bin().

◆ add_header()

static RzCmdStateOutput* add_header	(	RzCmdStateOutput *	main_state,
		RzOutputMode	mode,
		const char *	header
	)

static

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

                                                                                                          {
     RzCmdStateOutput *state = RZ_NEW(RzCmdStateOutput);
     rz_cmd_state_output_init(state, mode);
     if (mode == RZ_OUTPUT_MODE_TABLE || mode == RZ_OUTPUT_MODE_STANDARD) {
         rz_cons_printf("[%c%s]\n", toupper(header[0]), header + 1);
     } else if (mode == RZ_OUTPUT_MODE_JSON) {
         pj_k(main_state->d.pj, header);
     }
     return state;
 }

References rz_cmd_state_output_t::d, header, rz_cmd_state_output_t::pj, pj_k(), rz_cmd_state_output_init(), rz_cons_printf(), RZ_NEW, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_STANDARD, RZ_OUTPUT_MODE_TABLE, and toupper.

Referenced by rz_main_rz_bin().

◆ classes_as_source_print()

static void classes_as_source_print	(	RzCore *	core,
		RzCmdStateOutput *	state
	)

static

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

                                                                            {
     RzBinFile *bf = rz_bin_cur(core->bin);
     if (bf) {
         rz_core_bin_class_as_source_print(core, bf, NULL);
     }
 }

References rz_core_t::bin, NULL, rz_bin_cur(), and rz_core_bin_class_as_source_print().

Referenced by rz_main_rz_bin().

◆ end_state()

static void end_state ( RzCmdStateOutput * state )

static

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

                                                {
     if (state->mode == RZ_OUTPUT_MODE_JSON) {
         pj_end(state->d.pj);
         const char *s = pj_string(state->d.pj);
         if (s) {
             rz_cons_printf("%s\n", s);
         }
     }
 }

References pj_end(), pj_string(), rz_cons_printf(), RZ_OUTPUT_MODE_JSON, and s.

Referenced by rz_main_rz_bin().

◆ extract_binobj()

static bool extract_binobj	(	const RzBinFile *	bf,
		RzBinXtrData *	data,
		int	idx
	)

static

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

                                                                              {
     ut64 bin_size = data ? data->size : 0;
     ut8 *bytes;
     const char *xtr_type = "";
     char *arch = "unknown";
     int bits = 0, nb;
     char *libname = NULL;
     const char *filename = bf ? bf->file : NULL;
     char *path = NULL, *ptr = NULL;
     bool res = false;
  
     if (!bf || !data || !filename) {
         return false;
     }
     if (data->metadata) {
         arch = data->metadata->arch;
         bits = data->metadata->bits;
         libname = data->metadata->libname;
         xtr_type = data->metadata->xtr_type;
     }
     if (!strcmp(xtr_type, "fat") && bin_size == bf->size && bin_size) {
         eprintf("This is not a fat bin\n");
         return false;
     }
     bytes = malloc(bin_size);
     if (!bytes) {
         eprintf("error: BinFile buffer is empty\n");
         return false;
     }
     nb = rz_buf_read_at(data->buf, 0, bytes, bin_size);
     if (nb <= 0) {
         eprintf("Couldn't read xtrdata\n");
         return false;
     }
     if (!arch) {
         arch = "unknown";
     }
     path = strdup(filename);
     if (!path) {
         return false;
     }
     ptr = (char *)rz_file_basename(path);
     char *outpath = rz_str_newf("%s.fat", ptr);
     if (!outpath || !rz_sys_mkdirp(outpath)) {
         free(path);
         free(outpath);
         eprintf("Error creating dir structure\n");
         return false;
     }
  
     char *outfile = libname
         ? rz_str_newf("%s/%s.%s.%s_%i.%d", outpath, ptr, arch, libname, bits, idx)
         : rz_str_newf("%s/%s.%s_%i.%d", outpath, ptr, arch, bits, idx);
  
     if (!outfile || !rz_file_dump(outfile, bytes, bin_size, 0)) {
         eprintf("Error extracting %s\n", outfile);
         res = false;
     } else {
         printf("%s created (%" PFMT64d ")\n", outfile, bin_size);
         res = true;
     }
  
     free(outfile);
     free(outpath);
     free(path);
     free(bytes);
     return res;
 }

References rz_bin_xtr_metadata_t::arch, arch, rz_bin_xtr_metadata_t::bits, bits(), rz_bin_xtr_extract_t::buf, bytes, eprintf, rz_bin_file_t::file, free(), setup::idx, rz_bin_xtr_metadata_t::libname, malloc(), rz_bin_xtr_extract_t::metadata, NULL, outfile, path, PFMT64d, printf(), rz_buf_read_at(), rz_file_basename(), rz_file_dump(), rz_str_newf(), rz_sys_mkdirp(), rz_bin_file_t::size, rz_bin_xtr_extract_t::size, strdup(), ut64(), and rz_bin_xtr_metadata_t::xtr_type.

Referenced by rabin_extract().

◆ isBinopHelp()

static bool isBinopHelp ( const char * op )

static

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

                                         {
     if (!op) {
         return false;
     }
     if (!strcmp(op, "help")) {
         return true;
     }
     if (!strcmp(op, "?")) {
         return true;
     }
     if (!strcmp(op, "h")) {
         return true;
     }
     return false;
 }

Referenced by rz_main_rz_bin().

◆ print_demangler_info()

static bool print_demangler_info	(	const RzDemanglerPlugin *	plugin,
		void *	user
	)

static

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

                                                                               {
     (void)user;
     printf("%-6s %-8s %s\n", plugin->language, plugin->license, plugin->author);
     return true;
 }

References rz_demangler_plugin_t::author, rz_demangler_plugin_t::language, rz_demangler_plugin_t::license, and printf().

Referenced by rz_main_rz_bin().

◆ print_string()

static void print_string	(	RzBinFile *	bf,
		RzBinString *	string,
		PJ *	pj,
		int	mode
	)

static

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

                                                                                {
     rz_return_if_fail(bf && string);
  
     ut64 vaddr;
     RzBinSection *s = rz_bin_get_section_at(bf->o, string->paddr, false);
     if (s) {
         string->vaddr = s->vaddr + (string->paddr - s->paddr);
     }
     vaddr = bf->o ? rz_bin_object_get_vaddr(bf->o, string->paddr, string->vaddr) : UT64_MAX;
     const char *type_string = rz_str_enc_as_string(string->type);
     const char *section_name = s ? s->name : "";
  
     switch (mode) {
     case RZ_MODE_JSON:
         pj_o(pj);
         pj_kn(pj, "vaddr", vaddr);
         pj_kn(pj, "paddr", string->paddr);
         pj_kn(pj, "ordinal", string->ordinal);
         pj_kn(pj, "size", string->size);
         pj_kn(pj, "length", string->length);
         pj_ks(pj, "section", section_name);
         pj_ks(pj, "type", type_string);
         pj_ks(pj, "string", string->string);
         pj_end(pj);
         break;
     case RZ_MODE_SIMPLEST:
         printf("%s\n", string->string);
         break;
     case RZ_MODE_SIMPLE:
         printf("0x%" PFMT64x " %u %u %s\n", vaddr, string->size, string->length, string->string);
         break;
     case RZ_MODE_PRINT:
         printf("%03u 0x%08" PFMT64x " 0x%08" PFMT64x " %u %u (%s) %s %s\n",
             string->ordinal, string->paddr, vaddr,
             string->length, string->size,
             section_name, type_string, string->string);
         break;
     default:
         rz_warn_if_reached();
         break;
     }
 }

References rz_bin_string_t::length, rz_bin_file_t::o, rz_bin_string_t::ordinal, rz_bin_string_t::paddr, PFMT64x, pj_end(), pj_kn(), pj_ks(), pj_o(), printf(), rz_bin_get_section_at(), rz_bin_object_get_vaddr(), RZ_MODE_JSON, RZ_MODE_PRINT, RZ_MODE_SIMPLE, RZ_MODE_SIMPLEST, rz_return_if_fail, rz_str_enc_as_string(), rz_warn_if_reached, s, rz_bin_string_t::size, rz_bin_string_t::string, rz_bin_string_t::type, ut64(), UT64_MAX, and rz_bin_string_t::vaddr.

Referenced by rz_main_rz_bin().

◆ rabin_do_operation()

static int rabin_do_operation	(	RzBin *	bin,
		const char *	op,
		int	rad,
		const char *	output,
		const char *	file
	)

static

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

                                                                                                          {
     char *arg = NULL, *ptr = NULL, *ptr2 = NULL;
     bool rc = true;
  
     /* Implement alloca with fixed-size buffer? */
     if (!(arg = strdup(op))) {
         return false;
     }
     if ((ptr = strchr(arg, '/'))) {
         *ptr++ = 0;
         if ((ptr2 = strchr(ptr, '/'))) {
             ptr2[0] = '\0';
             ptr2++;
         }
     }
     if (!output) {
         output = file;
     }
     RzBinFile *bf = rz_bin_cur(bin);
     if (bf) {
         RzBuffer *nb = rz_buf_new_with_buf(bf->buf);
         rz_buf_free(bf->buf);
         bf->buf = nb;
     }
  
     switch (arg[0]) {
     case 'd':
         if (!ptr) {
             goto _rabin_do_operation_error;
         }
         switch (*ptr) {
         case 's': {
             ut64 a = ptr2 ? rz_num_math(NULL, ptr2) : 0;
             if (!rabin_dump_symbols(bin, a)) {
                 goto error;
             }
         } break;
         case 'S':
             if (!ptr2) {
                 goto _rabin_do_operation_error;
             }
             if (!__dumpSections(bin, ptr2, output, file)) {
                 goto error;
             }
             break;
         default:
             goto _rabin_do_operation_error;
         }
         break;
     case 'C': {
         RzBinFile *cur = rz_bin_cur(bin);
         RzBinPlugin *plg = rz_bin_file_cur_plugin(cur);
         if (!plg && cur) {
             // are we in xtr?
             if (cur->xtr_data) {
                 // load the first one
                 RzBinXtrData *xtr_data = rz_list_get_n(cur->xtr_data, 0);
                 RzBinObjectLoadOptions obj_opts = {
                     .baseaddr = UT64_MAX,
                     .loadaddr = rz_bin_get_laddr(bin)
                 };
                 if (xtr_data && !xtr_data->loaded && !rz_bin_file_object_new_from_xtr_data(bin, cur, &obj_opts, xtr_data)) {
                     break;
                 }
             }
             plg = rz_bin_file_cur_plugin(cur);
             if (!plg) {
                 break;
             }
         }
         if (plg && plg->signature) {
             char *sign = plg->signature(cur, rad == RZ_MODE_JSON);
             if (sign) {
                 rz_cons_println(sign);
                 rz_cons_flush();
                 free(sign);
             }
         }
     } break;
     default:
     _rabin_do_operation_error:
         eprintf("Unknown operation. use -O help\n");
         goto error;
     }
     if (!rc) {
         eprintf("Cannot dump :(\n");
     }
     free(arg);
     return true;
 error:
     free(arg);
     return false;
 }

References __dumpSections(), a, rz_bin_file_load_options_t::baseaddr, rz_bin_file_t::buf, eprintf, error(), file, free(), rz_bin_xtr_extract_t::loaded, NULL, output, rabin_dump_symbols(), rz_bin_cur(), rz_bin_file_cur_plugin(), rz_bin_file_object_new_from_xtr_data(), rz_bin_get_laddr(), rz_buf_free(), rz_buf_new_with_buf(), rz_cons_flush(), rz_cons_println(), rz_list_get_n(), RZ_MODE_JSON, rz_num_math(), rz_bin_plugin_t::signature, strdup(), ut64(), UT64_MAX, and rz_bin_file_t::xtr_data.

Referenced by rz_main_rz_bin().

◆ rabin_dump_symbols()

static int rabin_dump_symbols	(	RzBin *	bin,
		int	len
	)

static

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

                                                    {
     RzList *symbols = rz_bin_get_symbols(bin);
     if (!symbols) {
         return false;
     }
  
     RzListIter *iter;
     RzBinSymbol *symbol;
     int olen = len;
     rz_list_foreach (symbols, iter, symbol) {
         if (symbol->size && (olen > symbol->size || !olen)) {
             len = symbol->size;
         } else if (!symbol->size && !olen) {
             len = 32;
         } else {
             len = olen;
         }
         ut8 *buf = calloc(1, len);
         if (!buf) {
             return false;
         }
         char *ret = malloc((len * 2) + 1);
         if (!ret) {
             free(buf);
             return false;
         }
         if (rz_buf_read_at(bin->cur->buf, symbol->paddr, buf, len) == len) {
             rz_hex_bin2str(buf, len, ret);
             printf("%s %s\n", symbol->name, ret);
         } else {
             eprintf("Cannot read from buffer\n");
         }
         free(buf);
         free(ret);
     }
     return true;
 }

References bin::buf, calloc(), eprintf, free(), len, malloc(), rz_bin_symbol_t::name, rz_bin_symbol_t::paddr, printf(), rz_bin_get_symbols(), rz_buf_read_at(), rz_hex_bin2str(), rz_bin_symbol_t::size, and symbols().

Referenced by rabin_do_operation().

◆ rabin_extract()

static int rabin_extract	(	RzBin *	bin,
		int	all
	)

static

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

                                               {
     RzBinXtrData *data = NULL;
     int res = false;
     RzBinFile *bf = rz_bin_cur(bin);
  
     if (!bf) {
         return res;
     }
     if (all) {
         int idx = 0;
         RzListIter *iter;
         rz_list_foreach (bf->xtr_data, iter, data) {
             res = extract_binobj(bf, data, idx++);
             if (!res) {
                 break;
             }
         }
     } else {
         data = rz_list_get_n(bf->xtr_data, 0);
         if (!data) {
             return res;
         }
         res = extract_binobj(bf, data, 0);
     }
     return res;
 }

References test_group_name::all, extract_binobj(), setup::idx, NULL, rz_bin_cur(), rz_list_get_n(), and rz_bin_file_t::xtr_data.

Referenced by rz_main_rz_bin().

◆ rabin_show_help()

static int rabin_show_help ( int v )

static

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

                                   {
     printf("Usage: rz-bin [-AcdeEghHiIjlLMqrRsSUvVxzZ] [-@ at] [-a arch] [-b bits] [-B addr]\n"
            "              [-C F:C:D] [-f str] [-m addr] [-n str] [-N m:M] [-P[-P] pdb]\n"
            "              [-o str] [-O str] [-k query] [-D lang symname] file\n");
     if (v) {
         printf(
             " -@ [addr]       show section, symbol or import at addr\n"
             " -A              list sub-binaries and their arch-bits pairs\n"
             " -a [arch]       set arch (x86, arm, .. or <arch>_<bits>)\n"
             " -b [bits]       set bits (32, 64 ...)\n"
             " -B [addr]       override base address (pie bins)\n"
             " -c              list classes\n"
             " -cc             list classes in header format\n"
             " -C [fmt:C:D]    create [elf,mach0,pe] with Code and Data hexpairs (see -a)\n"
             " -d              show debug/dwarf information\n"
             " -D lang name    demangle symbol name (-D all for bin.demangle=true)\n"
             " -e              entrypoint\n"
             " -ee             constructor/destructor entrypoints\n"
             " -E              globally exportable symbols\n"
             " -f [str]        select sub-bin named str\n"
             " -F [binfmt]     force to use that bin plugin (ignore header check)\n"
             " -g              same as -SMZIHVResizcld -SS -SSS -ee (show all info)\n"
             " -G [addr]       load address . offset to header\n"
             " -h              this help message\n"
             " -H              header fields\n"
             " -i              imports (symbols imported from libraries)\n"
             " -I              binary info\n"
             " -j              output in json\n"
             " -k [sdb-query]  run sdb query. for example: '*'\n"
             " -K [algo]       calculate checksums (md5, sha1, ..)\n"
             " -l              linked libraries\n"
             " -L [plugin]     list supported bin plugins or plugin details\n"
             " -m [addr]       show source line at addr\n"
             " -M              main (show address of main symbol)\n"
             " -n [str]        show section, symbol or import named str\n"
             " -N [min:max]    force min:max number of chars per string (see -z and -zz)\n"
             " -o [str]        output file/folder for write operations (out by default)\n"
             " -O [str]        write/extract operations (-O help)\n"
             " -p              show physical addresses\n"
             " -P              show debug/pdb information\n"
             " -PP             download pdb file for binary\n"
             " -q              be quiet, just show fewer data\n"
             " -qq             show less info (no offset/size for -z for ex.)\n"
             " -Q              show load address used by dlopen (non-aslr libs)\n"
             " -r              rizin output\n"
             " -R              relocations\n"
             " -s              symbols\n"
             " -S              sections\n"
             " -SS             segments\n"
             " -SSS            sections mapping to segments\n"
             " -T              display file signature\n"
             " -u              unfiltered (no rename duplicated symbols/sections)\n"
             " -U              resoUrces\n"
             " -v              display version and quit\n"
             " -V              Show binary version information\n"
             " -w              display try/catch blocks\n"
             " -x              extract bins contained in file\n"
             " -X [fmt] [f] .. package in fat or zip the given files and bins contained in file\n"
             " -Y [fw file]    calculates all the possibles base address candidates of a firmware bin\n"
             " -z              strings (from data section)\n"
             " -zz             strings (from raw strings from bin)\n"
             " -zzz            dump raw strings to stdout (for huge files)\n"
             " -Z              guess size of binary program\n");
     }
     if (v) {
         printf("Environment:\n"
                " RZ_BIN_LANG:      e bin.lang         # assume lang for demangling\n"
                " RZ_BIN_NOPLUGINS: # do not load shared plugins (speedup loading)\n"
                " RZ_BIN_DEMANGLE=0:e bin.demangle     # do not demangle symbols\n"
                " RZ_BIN_MAXSTRBUF: e bin.maxstrbuf    # specify maximum buffer size\n"
                " RZ_BIN_STRFILTER: e bin.str.filter   # rizin -qc 'e bin.str.filter=?"
                "?' -\n"
                " RZ_BIN_STRPURGE:  e bin.str.purge    # try to purge false positives\n"
                " RZ_BIN_DEBASE64:  e bin.debase64     # try to debase64 all strings\n"
                " RZ_BIN_PDBSERVER: e pdb.server       # use alternative PDB server\n"
                " RZ_BIN_SYMSTORE:  e pdb.symstore     # path to downstream symbol store\n"
                " RZ_BIN_PREFIX:    e bin.prefix       # prefix symbols/sections/relocs with a specific string\n"
                " RZ_CONFIG:        # sdb config file\n");
     }
     return 1;
 }

References printf(), and v.

Referenced by rz_main_rz_bin().

◆ rabin_show_srcline()

static int rabin_show_srcline	(	RzBin *	bin,
		ut64	at
	)

static

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

                                                    {
     char *srcline;
     if (at != UT64_MAX && (srcline = rz_bin_addr2text(bin, at, true))) {
         printf("%s\n", srcline);
         free(srcline);
         return true;
     }
     return false;
 }

References free(), printf(), rz_bin_addr2text(), and UT64_MAX.

Referenced by rz_main_rz_bin().

◆ rad2outputmode()

static RzOutputMode rad2outputmode ( int rad )

static

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

                                             {
     switch (rad) {
     case RZ_MODE_JSON:
         return RZ_OUTPUT_MODE_JSON;
     case RZ_MODE_SIMPLE:
         return RZ_OUTPUT_MODE_QUIET;
     case RZ_MODE_SIMPLEST:
         return RZ_OUTPUT_MODE_QUIETEST;
     case RZ_MODE_RIZINCMD:
         return RZ_OUTPUT_MODE_RIZIN;
     case RZ_MODE_PRINT:
     default:
         return RZ_OUTPUT_MODE_STANDARD;
     }
 }

References RZ_MODE_JSON, RZ_MODE_PRINT, RZ_MODE_RIZINCMD, RZ_MODE_SIMPLE, RZ_MODE_SIMPLEST, RZ_OUTPUT_MODE_JSON, RZ_OUTPUT_MODE_QUIET, RZ_OUTPUT_MODE_QUIETEST, RZ_OUTPUT_MODE_RIZIN, and RZ_OUTPUT_MODE_STANDARD.

Referenced by rz_main_rz_bin().

◆ 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().

◆ start_state()

static void start_state ( RzCmdStateOutput * state )

static

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

                                                  {
     if (state->mode == RZ_OUTPUT_MODE_JSON) {
         pj_o(state->d.pj);
     }
 }

References pj_o(), and RZ_OUTPUT_MODE_JSON.

Referenced by parser__reductions_after_sequence(), and rz_main_rz_bin().

◆ stdin_gets()

static char* stdin_gets ( bool liberate )

static

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

                                        {
     static char *stdin_buf = NULL;
 #define STDIN_BUF_SIZE 96096
     if (liberate) {
         free(stdin_buf);
         stdin_buf = NULL;
         return NULL;
     }
     if (!stdin_buf) {
         /* XXX: never freed. leaks! */
         stdin_buf = malloc(STDIN_BUF_SIZE);
         if (!stdin_buf) {
             return NULL;
         }
     }
     memset(stdin_buf, 0, STDIN_BUF_SIZE);
     if (!fgets(stdin_buf, STDIN_BUF_SIZE, stdin)) {
         return NULL;
     }
     if (feof(stdin)) {
         return NULL;
     }
     return strdup(stdin_buf);
 }

References free(), malloc(), memset(), NULL, STDIN_BUF_SIZE, and strdup().

Referenced by __sdb_prompt(), and rz_main_rz_bin().

Macros

Functions

Macro Definition Documentation

◆ is_active

◆ ismodejson

◆ run_action

◆ set_action

◆ STDIN_BUF_SIZE

◆ unset_action

Function Documentation

◆ __dumpSections()

◆ __lib_bin_cb()

◆ __lib_bin_dt()

◆ __lib_bin_xtr_cb()

◆ __lib_bin_xtr_dt()

◆ __lib_demangler_cb()

◆ __lib_demangler_dt()

◆ __listPlugins()

◆ __sdb_prompt()

◆ actions2mask()

◆ add_footer()

◆ add_header()

◆ classes_as_source_print()

◆ end_state()

◆ extract_binobj()

◆ isBinopHelp()

◆ print_demangler_info()

◆ print_string()

◆ rabin_do_operation()

◆ rabin_dump_symbols()

◆ rabin_extract()

◆ rabin_show_help()

◆ rabin_show_srcline()

◆ rad2outputmode()

◆ rz_main_rz_bin()

◆ start_state()

◆ stdin_gets()