R_API int r_core_yank_cat (RCore *core, ut64 pos) {
int ybl = core->yank_buf->length;
if (ybl>0) {
if (pos < ybl) {
r_cons_memcat ((const char*)core->yank_buf->buf+pos,
core->yank_buf->length-pos);
r_cons_newline ();
return true;
} else eprintf ("Position exceeds buffer length.\n");
} else r_cons_newline ();
return false;
}
static void cmd_fz(RCore *core, const char *input) {
switch (*input) {
case '?':
r_core_cmd_help (core, help_msg_fz);
break;
case '.':
{
const char *a = NULL, *b = NULL;
r_flag_zone_around (core->flags, core->offset, &a, &b);
r_cons_printf ("%s %s\n", a?a:"~", b?b:"~");
}
break;
case ':':
{
const char *a, *b;
int a_len = 0;
int w = r_cons_get_size (NULL);
r_flag_zone_around (core->flags, core->offset, &a, &b);
if (a) {
r_cons_printf ("[<< %s]", a);
a_len = strlen (a) + 4;
}
int padsize = (w / 2) - a_len;
int title_size = 12;
if (a || b) {
char *title = r_str_newf ("[ 0x%08"PFMT64x" ]", core->offset);
title_size = strlen (title);
padsize -= strlen (title) / 2;
const char *halfpad = r_str_pad (' ', padsize);
r_cons_printf ("%s%s", halfpad, title);
free (title);
}
if (b) {
padsize = (w / 2) - title_size - strlen (b) - 4;
const char *halfpad = padsize > 1? r_str_pad (' ', padsize): "";
r_cons_printf ("%s[%s >>]", halfpad, b);
}
if (a || b) {
r_cons_newline();
}
}
break;
case ' ':
r_flag_zone_add (core->flags, r_str_trim_ro (input + 1), core->offset);
break;
case '-':
if (input[1] == '*') {
r_flag_zone_reset (core->flags);
} else {
r_flag_zone_del (core->flags, input + 1);
}
break;
case '*':
r_flag_zone_list (core->flags, '*');
break;
case 0:
r_flag_zone_list (core->flags, 0);
break;
}
}
static void r_cons_pal_show_256 () {
int r, g, b;
r_cons_print ("\n\nXTerm colors:\n");
for (r = 0x00; r <= 0xff; r += 0x28) {
if (r == 0x28) {
r = 0x5f;
}
for (b = 0x00; b <= 0xff; b += 0x28) {
if (b == 0x28) {
b = 0x5f;
}
for (g = 0x00; g <= 0xff; g += 0x28) {
char fg[32], bg[32];
if (g == 0x28) {
g = 0x5f;
}
if ((r <= 0x5f) && (g <= 0x5f)) {
strcpy (fg, Color_WHITE);
} else {
strcpy (fg, Color_BLACK);
}
r_cons_rgb_str (bg, r, g, b, 1);
r_cons_printf ("%s%s rgb:%02x%02x%02x "
Color_RESET, fg, bg, r, g, b);
if (g == 0xff) {
r_cons_newline ();
}
}
}
}
}
static void r_cons_pal_show_rgb () {
const int inc = 3;
int i, j, k, n = 0;
r_cons_print ("\n\nRGB:\n");
for (i = n = 0; i <= 0xf; i += inc) {
for (k = 0; k <= 0xf; k += inc) {
for (j = 0; j <= 0xf; j += inc) {
char fg[32], bg[32];
int r = i * 16;
int g = j * 16;
int b = k * 16;
strcpy (fg, ((i < 6) && (j < 5))
? Color_WHITE: Color_BLACK);
r_cons_rgb_str (bg, r, g, b, 1);
r_cons_printf ("%s%s rgb:%02x%02x%02x "
Color_RESET, fg, bg, r, g, b);
//if (n++==7) {
if (n ++== 5) {
n = 0;
r_cons_newline ();
}
}
}
}
}
static void r_cons_pal_show_256() {
RColor rc = RColor_BLACK;
r_cons_print ("\n\nXTerm colors:\n");
int r = 0;
int g = 0;
int b = 0;
for (r = 0x00; r <= 0xff; r += 0x28) {
rc.r = r;
if (rc.r == 0x28) {
rc.r = 0x5f;
}
for (b = 0x00; b <= 0xff; b += 0x28) {
rc.b = b;
if (rc.b == 0x28) {
rc.b = 0x5f;
}
for (g = 0x00; g <= 0xff; g += 0x28) {
rc.g = g;
char bg[32];
if (rc.g == 0x28) {
rc.g = 0x5f;
}
const char *fg = ((rc.r <= 0x5f) && (rc.g <= 0x5f)) ? Color_WHITE: Color_BLACK;
r_cons_rgb_str (bg, sizeof (bg), &rc);
r_cons_printf ("%s%s rgb:%02x%02x%02x "
Color_RESET, fg, bg, rc.r, rc.g, rc.b);
}
r_cons_newline ();
}
}
}
static void r_cons_pal_show_rgb() {
const int inc = 3;
int i, j, k, n = 0;
RColor rc = RColor_BLACK;
r_cons_print ("\n\nRGB:\n");
for (i = n = 0; i <= 0xf; i += inc) {
for (k = 0; k <= 0xf; k += inc) {
for (j = 0; j <= 0xf; j += inc) {
char fg[32], bg[32];
rc.r = i * 16;
rc.g = j * 16;
rc.b = k * 16;
strcpy (fg, ((i < 6) && (j < 5))
? Color_WHITE: Color_BLACK);
r_cons_rgb_str (bg, sizeof (bg), &rc);
r_cons_printf ("%s%s rgb:%02x%02x%02x "
Color_RESET, fg, bg, rc.r, rc.g, rc.b);
if (n ++== 5) {
n = 0;
r_cons_newline ();
}
}
}
}
}
int main() {
int i,j ,k;
//char *str = "\x1b[38;5;231mpop\x1b[0m";
//char *str ="\x1b]4;%d;rgb:30/20/24pop\x1b[0m";
char *str ="\x1b\\pop\x1b[0m";
i=j=k =0;
r_cons_new ();
// r_cons_rgb_init ();
printf ("3 == %d\n", r_str_ansi_len (str));
for (i=0;i<255;i+=40) {
for (j=0;j<255;j+=40) { for (k=0;k<255;k+=40) {
r_cons_rgb (i, j, k, 0);
r_cons_rgb (i, j, k, 1);
r_cons_print ("__");
r_cons_reset_colors ();
r_cons_rgb (i, j, k, 0);
// r_cons_rgb (155, 200, 200, 1);
r_cons_printf (" RGB %d %d %d", i, j, k);
r_cons_reset_colors ();
r_cons_newline ();
}
}}
r_cons_flush ();
return 0;
}
R_API void r_cons_pal_show () {
const int inc = 3;
int i, j, k, n = 0;
for (i=0; colors[i].name; i++) {
r_cons_printf ("%s%s__"Color_RESET" %s\n",
colors[i].code,
colors[i].bgcode,
colors[i].name);
}
r_cons_printf ("\nGreyscale:\n");
for (i=n=0; i<=0xf; i+=1) {
char fg[32], bg[32];
int r = i*16;
if (i<5) strcpy (fg, Color_WHITE);
else r_cons_rgb_str (fg, 0, 0, 0, 0);
r_cons_rgb_str (bg, r, r, r, 1);
r_cons_printf ("%s%s rgb:%x%x%x "
Color_RESET, fg, bg, i, i, i);
if (n++==5) {
n = 0;
r_cons_newline();
}
}
r_cons_printf ("\n\nRGB:\n");
for (i=n=0; i<=0xf; i+=inc) {
for (k=0; k<=0xf; k+=inc) {
for (j=0; j<=0xf; j+=inc) {
char fg[32], bg[32];
int r = i*16;
int g = j*16;
int b = k*16;
if ((i<6) && (j<5) )
strcpy (fg, Color_WHITE);
//if (i<2 && j<6 && k<13)
else r_cons_rgb_str (fg, 0, 0, 0, 0);
r_cons_rgb_str (bg, r, g, b, 1);
r_cons_printf ("%s%s rgb:%x%x%x "Color_RESET,
fg, bg, i, j, k);
//if (n++==7) {
if (n++==5) {
n = 0;
r_cons_newline();
}
}
}
}
}
static void handle_sha512 (const ut8 *block, int len) {
int i = 0;
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA512);
const ut8 *c = r_hash_do_sha512 (ctx, block, len);
for (i=0; i<R_HASH_SIZE_SHA512; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
}
static void handle_md5 (const ut8 *block, int len) {
int i = 0;
RHash *ctx = r_hash_new (true, R_HASH_MD5);
const ut8 *c = r_hash_do_md5 (ctx, block, len);
for (i=0; i<R_HASH_SIZE_MD5; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
}
R_API void r_debug_signal_list(RDebug *dbg, int mode) {
dbg->_mode = mode;
switch (mode) {
case 0:
case 1:
sdb_foreach (DB, siglistcb, dbg);
break;
case 2:
r_cons_strcat ("[");
sdb_foreach (DB, siglistjsoncb, dbg);
r_cons_strcat ("]");
r_cons_newline();
break;
}
dbg->_mode = 0;
}
static void algolist(int mode) {
const char *name;
ut64 bits;
int i;
for (i=0; ; i++) {
bits = 1<<i;
name = r_hash_name (bits);
if (!name||!*name) break;
if (mode) {
r_cons_printf ("%s\n", name);
} else {
r_cons_printf (" #%s", name);
if (!((i+1)%10)) r_cons_newline ();
}
}
if (!mode) r_cons_printf ("\n");
}
static int typelist (void *p, const char *k, const char *v) {
r_cons_printf ("tk %s = %s\n", k, v);
#if 0
if (!strcmp (v, "func")) {
const char *rv = sdb_const_get (DB,
sdb_fmt (0, "func.%s.ret", k), 0);
r_cons_printf ("# %s %s(", rv, k);
for (i = 0; i < 16; i++) {
char *av = sdb_get (DB,
sdb_fmt (0, "func.%s.arg.%d", k, i), 0);
if (!av) break;
r_str_replace_char (av, ',', ' ');
r_cons_printf ("%s%s", i? ", ": "", av);
free (av);
}
r_cons_printf (");\n");
// signature in pf for asf
r_cons_printf ("asf %s=", k);
// formats
for (i = 0; i < 16; i++) {
const char *fmt;
char *comma, *av = sdb_get (DB,
sdb_fmt (0, "func.%s.arg.%d", k, i), 0);
if (!av) break;
comma = strchr (av, ',');
if (comma) *comma = 0;
fmt = sdb_const_get (DB, sdb_fmt (0, "type.%s", av), 0);
r_cons_printf ("%s", fmt);
if (comma) *comma = ',';
free (av);
}
// names
for (i = 0; i < 16; i++) {
char *comma, *av = sdb_get (DB,
sdb_fmt (0, "func.%s.arg.%d", k, i), 0);
if (!av) break;
comma = strchr (av, ',');
if (comma) *comma++ = 0;
r_cons_printf (" %s", comma);
free (av);
}
r_cons_newline ();
}
#endif
return 1;
}
static void r_cons_pal_show_gs () {
int i, n;
r_cons_print ("\nGreyscale:\n");
for (i = 0x08, n = 0; i <= 0xee; i += 0xa) {
char fg[32], bg[32];
if (i < 0x76) strcpy (fg, Color_WHITE);
else strcpy (fg, Color_BLACK);
r_cons_rgb_str (bg, i, i, i, 1);
r_cons_printf ("%s%s rgb:%02x%02x%02x "Color_RESET,
fg, bg, i, i, i);
if (n++ == 5) {
n = 0;
r_cons_newline ();
}
}
}
R_API int r_core_yank_dump (RCore *core, ut64 pos) {
int res = R_FALSE, i = 0;
int ybl = core->yank_buf->length;
if (ybl>0) {
if (pos<ybl) {
r_cons_printf ("0x%08"PFMT64x " %d ",
core->yank_buf->base+pos,
core->yank_buf->length-pos);
for (i = pos; i < core->yank_buf->length; i++)
r_cons_printf ("%02x",
core->yank_buf->buf[i]);
r_cons_newline ();
res = R_TRUE;
} else eprintf ("Position exceeds buffer length.\n");
} else eprintf ("No buffer yanked already\n");
return res;
}
R_API void r_cons_strcat_justify (const char *str, int j, char c) {
int i, o, len;
for (o=i=len=0; str[i]; i++, len++) {
if (str[i]=='\n') {
r_cons_memset (' ', j);
if (c) {
r_cons_memset (c, 1);
r_cons_memset (' ', 1);
}
r_cons_memcat (str+o, len);
if (str[o+len] == '\n')
r_cons_newline ();
o = i+1;
len = 0;
}
}
if (len>1)
r_cons_memcat (str+o, len);
}
static int siglistcb (void *p, const char *k, const char *v) {
static char key[32] = "cfg.";
RDebug *dbg = (RDebug *)p;
int mode = dbg->_mode;
int opt;
if (atoi (k)>0) {
strcpy (key+4, k);
opt = sdb_num_get (DB, key, 0);
if (opt) {
r_cons_printf ("%s %s", k, v);
if (opt & R_DBG_SIGNAL_CONT)
r_cons_strcat (" cont");
if (opt & R_DBG_SIGNAL_SKIP)
r_cons_strcat (" skip");
r_cons_newline ();
} else {
if (mode == 0)
r_cons_printf ("%s %s\n", k, v);
}
}
return 1;
}
static void r_cons_pal_show_gs() {
int i, n;
r_cons_print ("\nGreyscale:\n");
RColor rcolor = RColor_BLACK;
for (i = 0x08, n = 0; i <= 0xee; i += 0xa) {
char fg[32], bg[32];
rcolor.r = i;
rcolor.g = i;
rcolor.b = i;
if (i < 0x76) {
strcpy (fg, Color_WHITE);
} else {
strcpy (fg, Color_BLACK);
}
r_cons_rgb_str (bg, sizeof (bg), &rcolor);
r_cons_printf ("%s%s rgb:%02x%02x%02x "Color_RESET,
fg, bg, i, i, i);
if (n++ == 5) {
n = 0;
r_cons_newline ();
}
}
}
static int bin_info(RCore *r, int mode) {
int i, j;
char str[R_FLAG_NAME_SIZE];
char size_str[32];
char baddr_str[32];
RBinInfo *info = r_bin_get_info (r->bin);
RBinFile *binfile = r_core_bin_cur (r);
const char *compiled = NULL;
if (!binfile || !info) {
if (mode & R_CORE_BIN_JSON) r_cons_printf ("{}");
return false;
}
compiled = get_compile_time (binfile->sdb);
snprintf (size_str, sizeof (size_str),
"%"PFMT64d, r_bin_get_size (r->bin));
snprintf (baddr_str, sizeof (baddr_str),
"%"PFMT64d, info->baddr);
if (IS_MODE_SET (mode)) {
r_config_set (r->config, "file.type", info->rclass);
r_config_set (r->config, "cfg.bigendian", info->big_endian ? "true" : "false");
if (info->rclass && !strcmp (info->rclass, "fs")) {
r_config_set (r->config, "asm.arch", info->arch);
r_core_cmdf (r, "m /root %s 0", info->arch);
} else {
if (info->lang) {
r_config_set (r->config, "bin.lang", info->lang);
}
r_config_set (r->config, "asm.os", info->os);
r_config_set (r->config, "asm.arch", info->arch);
r_config_set (r->config, "anal.arch", info->arch);
snprintf (str, R_FLAG_NAME_SIZE, "%i", info->bits);
r_config_set (r->config, "asm.bits", str);
r_config_set (r->config, "asm.dwarf",
(R_BIN_DBG_STRIPPED &info->dbg_info) ? "false" : "true");
}
} else if (IS_MODE_SIMPLE (mode)) {
r_cons_printf ("arch %s\n", info->arch);
r_cons_printf ("bits %d\n", info->bits);
r_cons_printf ("os %s\n", info->os);
r_cons_printf ("endian %s\n", info->big_endian? "big": "little");
} else if (IS_MODE_RAD (mode)) {
if (info->type && !strcmp (info->type, "fs")) {
r_cons_printf ("e file.type=fs\n");
r_cons_printf ("m /root %s 0\n", info->arch);
} else {
r_cons_printf ("e cfg.bigendian=%s\n"
"e asm.bits=%i\n"
"e asm.dwarf=%s\n",
r_str_bool (info->big_endian),
info->bits,
r_str_bool (R_BIN_DBG_STRIPPED &info->dbg_info));
if (info->lang && *info->lang) {
r_cons_printf ("e bin.lang=%s\n", info->lang);
}
if (info->rclass && *info->rclass) {
r_cons_printf ("e file.type=%s\n",
info->rclass);
}
if (info->os) {
r_cons_printf ("e asm.os=%s\n", info->os);
}
if (info->arch) {
r_cons_printf ("e asm.arch=%s\n", info->arch);
}
}
} else {
// XXX: if type is 'fs' show something different?
if (IS_MODE_JSON (mode)) r_cons_printf ("{");
pair_bool ("pic", info->has_pi, mode, false);
pair_bool ("canary", info->has_canary, mode, false);
pair_bool ("nx", info->has_nx, mode, false);
pair_bool ("crypto", info->has_crypto, mode, false);
pair_bool ("va", info->has_va, mode, false);
pair_str ("bintype", info->rclass, mode, false);
pair_str ("class", info->bclass, mode, false);
pair_str ("lang", info->lang, mode, false);
pair_str ("arch", info->arch, mode, false);
pair_int ("bits", info->bits, mode, false);
pair_str ("machine", info->machine, mode, false);
pair_str ("os", info->os, mode, false);
pair_str ("subsys", info->subsystem, mode, false);
pair_str ("endian", info->big_endian ? "big" : "little", mode, false);
pair_bool ("stripped", R_BIN_DBG_STRIPPED & info->dbg_info, mode, false);
pair_bool ("static", r_bin_is_static (r->bin), mode, false);
pair_bool ("linenum", R_BIN_DBG_LINENUMS & info->dbg_info, mode, false);
pair_bool ("lsyms", R_BIN_DBG_SYMS & info->dbg_info, mode, false);
pair_bool ("relocs", R_BIN_DBG_RELOCS & info->dbg_info, mode, false);
pair_str ("rpath", info->rpath, mode, false);
pair_str ("binsz", size_str, mode, false);
pair_str ("compiled", compiled, mode, false);
pair_str ("guid", info->guid, mode, false);
pair_str ("dbg_file", info->debug_file_name, mode, true);
for (i = 0; info->sum[i].type; i++) {
int len;
RBinHash *h = &info->sum[i];
ut64 hash = r_hash_name_to_bits (h->type);
RHash *rh = r_hash_new (true, hash);
len = r_hash_calculate (rh, hash, (const ut8*)
binfile->buf->buf+h->from, h->to);
if (len < 1) eprintf ("Invaild wtf\n");
r_hash_free (rh);
r_cons_printf ("%s\t%d-%dc\t", h->type, h->from, h->to+h->from);
for (j = 0; j < h->len; j++) {
r_cons_printf ("%02x", h->buf[j]);
}
r_cons_newline ();
}
if (IS_MODE_JSON (mode)) r_cons_printf ("}");
}
return true;
}
static void cmd_write_op (RCore *core, const char *input) {
ut8 *buf;
int len;
int value;
if (!input[0])
return;
switch (input[1]) {
case 'e':
if (input[2]!=' ') {
r_cons_printf ("Usage: 'woe from-to step'\n");
return;
}
/* fallthru */
case 'a':
case 's':
case 'A':
case 'x':
case 'r':
case 'l':
case 'm':
case 'd':
case 'o':
case 'w':
case '2':
case '4':
if (input[2]) { // parse val from arg
r_core_write_op (core, input+3, input[1]);
r_core_block_read (core);
} else { // use clipboard instead of val
r_core_write_op (core, NULL, input[1]);
r_core_block_read (core);
}
break;
case 'R':
r_core_cmd0 (core, "wr $b");
break;
case 'n':
r_core_write_op (core, "ff", 'x');
r_core_block_read (core);
break;
case 'E': // "woE" encrypt
case 'D': // "woD" decrypt
{
int direction = (input[1] == 'E') ? 0 : 1;
const char *algo = NULL;
const char *key = NULL;
const char *iv = NULL;
char *space, *args = strdup (r_str_trim_ro (input+2));
space = strchr (args, ' ');
if (space) {
*space++ = 0;
key = space;
space = strchr (key, ' ');
if (space) {
*space++ = 0;
iv = space;
}
}
algo = args;
if (algo && *algo && key) {
encrypt_or_decrypt_block (core, algo, key, direction, iv);
} else {
eprintf ("Usage: wo%c [algo] [key] [IV]\n", ((!direction)?'E':'D'));
eprintf ("Currently supported hashes:\n");
ut64 bits;
int i;
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_hash_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
eprintf ("Available Encoders/Decoders: \n");
// TODO: do not hardcode
eprintf (" base64\n");
eprintf (" base91\n");
eprintf (" punycode\n");
eprintf ("Currently supported crypto algos:\n");
for (i = 0; ; i++) {
bits = ((ut64)1) << i;
const char *name = r_crypto_name (bits);
if (!name || !*name) break;
printf (" %s\n", name);
}
}
free (args);
}
break;
case 'p': // debrujin patterns
switch (input[2]) {
case 'D': // "wopD"
len = (int)(input[3]==' ')
? r_num_math (core->num, input + 3)
: core->blocksize;
if (len > 0) {
/* XXX This seems to fail at generating long patterns (wopD 512K) */
buf = (ut8*)r_debruijn_pattern (len, 0, NULL); //debruijn_charset);
if (buf) {
const ut8 *ptr = buf;
ut64 addr = core->offset;
if (input[3] == '*') {
int i;
r_cons_printf ("wx ");
for (i = 0; i < len; i++) {
r_cons_printf ("%02x", buf[i]);
}
r_cons_newline ();
} else {
while (true) {
int res = r_core_write_at (core, addr, ptr, len);
if (res < 1 || len == res) {
break;
}
if (res < len) {
ptr += res;
len -= res;
addr += res;
}
}
}
free (buf);
} else {
eprintf ("Couldn't generate pattern of length %d\n", len);
}
}
break;
case 'O': // "wopO"
if (strlen (input) > 4 && strncmp (input + 4, "0x", 2)) {
eprintf ("Need hex value with `0x' prefix e.g. 0x41414142\n");
} else if (input[3] == ' ') {
value = r_num_get (core->num, input + 4);
core->num->value = r_debruijn_offset (value, r_config_get_i (core->config, "cfg.bigendian"));
r_cons_printf ("%"PFMT64d"\n", core->num->value);
}
break;
case '\0':
case '?':
default:
r_core_cmd_help (core, help_msg_wop);
break;
}
break;
case '\0':
case '?':
default:
r_core_cmd_help (core, help_msg_wo);
break;
}
}
static int cmd_eval(void *data, const char *input) {
char *p;
RCore *core = (RCore *)data;
switch (input[0]) {
case 't': // env
if (input[1] == 'a') {
r_cons_printf ("%s\n", (r_num_rand (10) % 2)? "wen": "son");
} else if (input[1]==' ' && input[2]) {
RConfigNode *node = r_config_node_get (core->config, input+2);
if (node) {
const char *type = r_config_node_type (node);
if (type && *type) {
r_cons_println (type);
}
}
} else {
eprintf ("Usage: et [varname] ; show type of eval var\n");
}
break;
case 'n': // env
if (!strchr (input, '=')) {
char *var, *p;
var = strchr (input, ' ');
if (var) while (*var==' ') var++;
p = r_sys_getenv (var);
if (p) {
r_cons_println (p);
free (p);
} else {
char **e = r_sys_get_environ ();
while (e && *e) {
r_cons_println (*e);
e++;
}
}
} else if (strlen (input)>3) {
char *v, *k = strdup (input+3);
if (!k) break;
v = strchr (k, '=');
if (v) {
*v++ = 0;
r_sys_setenv (k, v);
}
free (k);
}
return true;
case 'x': // exit
// XXX we need headers for the cmd_xxx files.
return cmd_quit (data, "");
case 'j': // json
r_config_list (core->config, NULL, 'j');
break;
case 'v': // verbose
r_config_list (core->config, input + 1, 'v');
break;
case 'q': // quiet list of eval keys
r_config_list (core->config, NULL, 'q');
break;
case '\0': // "e"
r_config_list (core->config, NULL, 0);
break;
case 'c': // "ec"
switch (input[1]) {
case 'd':
r_cons_pal_init (NULL);
break;
case '?': {
const char *helpmsg[] = {
"Usage ec[s?] [key][[=| ]fg] [bg]","","",
"ec","","list all color keys",
"ec*","","same as above, but using r2 commands",
"ecd","","set default palette",
"ecr","","set random palette (see also scr.randpal)",
"ecs","","show a colorful palette",
"ecj","","show palette in JSON",
"ecc"," [prefix]","show palette in CSS",
"eco"," dark|white","load white color scheme template",
"ecp","","load previous color theme",
"ecn","","load next color theme",
"ecH","[?]","highlight word or instruction",
"ec"," prompt red","change color of prompt",
"ec"," prompt red blue","change color and background of prompt",
""," ","",
"colors:","","rgb:000, red, green, blue, ...",
"e scr.rgbcolor","=1|0","for 256 color cube (boolean)",
"e scr.truecolor","=1|0","for 256*256*256 colors (boolean)",
"$DATADIR/radare2/cons","","~/.config/radare2/cons ./",
NULL};
r_core_cmd_help (core, helpmsg);
}
break;
case 'o': // "eco"
if (input[2] == 'j') {
nextpal (core, 'j');
} else if (input[2] == ' ') {
bool failed = false;
char *home, path[512];
snprintf (path, sizeof (path), ".config/radare2/cons/%s", input + 3);
home = r_str_home (path);
snprintf (path, sizeof (path), R2_DATDIR"/radare2/"
R2_VERSION"/cons/%s", input + 3);
if (!load_theme (core, home)) {
if (load_theme (core, path)) {
//curtheme = r_str_dup (curtheme, path);
curtheme = r_str_dup (curtheme, input + 3);
} else {
if (load_theme (core, input + 3)) {
curtheme = r_str_dup (curtheme, input + 3);
} else {
char *absfile = r_file_abspath (input + 3);
eprintf ("eco: cannot open colorscheme profile (%s)\n", absfile);
free (absfile);
failed = true;
}
}
}
free (home);
if (failed) {
eprintf ("Something went wrong\n");
}
} else if (input[2] == '?') {
eprintf ("Usage: eco [themename] ;load theme from "R2_DATDIR"/radare2/"R2_VERSION"/cons/\n");
} else {
nextpal (core, 'l');
}
break;
case 's': r_cons_pal_show (); break; // "ecs"
case '*': r_cons_pal_list (1, NULL); break; // "ec*"
case 'h': // echo
if (( p = strchr (input, ' ') )) {
r_cons_strcat (p+1);
r_cons_newline ();
} else {
// "ech"
r_cons_pal_list ('h', NULL);
}
break;
case 'j': // "ecj"
r_cons_pal_list ('j', NULL);
break;
case 'c': // "ecc"
r_cons_pal_list ('c', input + 2);
break;
case '\0': // "ec"
r_cons_pal_list (0, NULL);
break;
case 'r': // "ecr"
r_cons_pal_random ();
break;
case 'n': // "ecn"
nextpal (core, 'n');
break;
case 'p': // "ecp"
nextpal (core, 'p');
break;
case 'H': { // "ecH"
char *color_code = NULL;
char *word = NULL;
int argc = 0;
char** argv = r_str_argv (input + 4, &argc);
switch (input[2]) {
case '?': {
const char *helpmsg[] = {
"Usage ecH[iw-?]","","",
"ecHi","[color]","highlight current instruction with 'color' background",
"ecHw","[word] [color]","highlight 'word ' in current instruction with 'color' background",
"ecH-","","remove all highlights on current instruction",
NULL
};
r_core_cmd_help (core, helpmsg);
}
break;
case '-':
r_meta_set_string (core->anal, R_META_TYPE_HIGHLIGHT, core->offset, "");
return false;
case '\0':
case 'i': // "ecHi
if (argc) {
char *dup = r_str_newf ("bgonly %s", argv[0]);
color_code = r_cons_pal_parse (dup);
R_FREE (dup);
}
break;
case 'w': // "ecHw"
if (!argc) {
eprintf ("Usage: echw word [color]\n");
r_str_argv_free (argv);
return true;
}
word = strdup (argv[0]);
if (argc > 1) {
char *dup = r_str_newf ("bgonly %s", argv[1]);
color_code = r_cons_pal_parse (dup);
if (!color_code) {
eprintf ("Unknown color %s\n", argv[1]);
r_str_argv_free (argv);
free (dup);
free (word);
return true;
}
R_FREE (dup);
}
break;
default:
eprintf ("See ecH?\n");
r_str_argv_free (argv);
return true;
}
char *str = r_meta_get_string (core->anal, R_META_TYPE_HIGHLIGHT, core->offset);
char *dup = r_str_newf ("%s \"%s%s\"", str?str:"", word?word:"", color_code?color_code:r_cons_pal_get ("highlight"));
r_meta_set_string (core->anal, R_META_TYPE_HIGHLIGHT, core->offset, dup);
r_str_argv_free (argv);
R_FREE (word);
R_FREE (dup);
break;
}
default: {
char *p = strdup (input + 2);
char *q = strchr (p, '=');
if (!q) {
q = strchr (p, ' ');
}
if (q) {
// set
*q++ = 0;
r_cons_pal_set (p, q);
} else {
const char *k = r_cons_pal_get (p);
if (k) {
eprintf ("(%s)(%sCOLOR"Color_RESET")\n", p, k);
}
}
free (p);
}
}
break;
case 'e':
if (input[1] == ' ') {
char *p;
const char *val, *input2 = strchr (input+2, ' ');
if (input2) input2++; else input2 = input+2;
val = r_config_get (core->config, input2);
p = r_core_editor (core, NULL, val);
if (p) {
r_str_replace_char (p, '\n', ';');
r_config_set (core->config, input2, p);
}
} else {
eprintf ("Usage: ee varname\n");
}
break;
case '!':
input = r_str_chop_ro (input+1);
if (!r_config_toggle (core->config, input))
eprintf ("r_config: '%s' is not a boolean variable.\n", input);
break;
case 's':
r_config_list (core->config, (input[1])? input + 1: NULL, 's');
break;
case '-':
r_core_config_init (core);
//eprintf ("BUG: 'e-' command locks the eval hashtable. patches are welcome :)\n");
break;
case '*': r_config_list (core->config, NULL, 1); break;
case '?':
switch (input[1]) {
case '?': r_config_list (core->config, input+2, 2); break;
default: r_config_list (core->config, input+1, 2); break;
case 0:
r_core_cmd_help (core, help_msg_e);
}
break;
case 'r':
if (input[1]) {
const char *key = input+((input[1]==' ')?2:1);
if (!r_config_readonly (core->config, key)) {
eprintf ("cannot find key '%s'\n", key);
}
} else {
eprintf ("Usage: er [key]\n");
}
break;
case ' ': r_config_eval (core->config, input+1); break;
default: r_config_eval (core->config, input); break;
}
return 0;
}
static int cmd_hash(void *data, const char *input) {
char *p, algo[32];
RCore *core = (RCore *)data;
ut32 i, osize, len = core->blocksize;
const char *ptr;
if (input[0]==' ') return 0;
if (input[0]=='#' && !input[1]) {
algolist (1);
return R_TRUE;
}
if (input[0]=='!') {
const char *lang = input+1;
if (*lang==' ') {
RLangPlugin *p = r_lang_get_by_extension (core->lang, input+2);
if (p && p->name) lang = p->name;
} else if (input[1]=='?' || input[1]=='*' || input[1]=='\0') {
r_lang_list (core->lang);
return R_TRUE;
}
p = strchr (input, ' ');
if (p) *p=0;
// TODO: set argv here
if (r_lang_use (core->lang, lang)) {
r_lang_setup (core->lang);
if (p) r_lang_run_file (core->lang, p+1);
else r_lang_prompt (core->lang);
} else eprintf ("Invalid hashbang. See '#!' for help.\n");
return R_TRUE;
}
ptr = strchr (input, ' ');
sscanf (input, "%31s", algo);
if (ptr != NULL) {
int nlen = r_num_math (core->num, ptr+1);
if (nlen>0) len = nlen;
osize = core->blocksize;
if (nlen>core->blocksize) {
r_core_block_size (core, nlen);
}
} else osize =0;
/* TODO: Simplify this spaguetti monster */
if (!r_str_ccmp (input, "md4", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_MD4);
const ut8 *c = r_hash_do_md4 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_MD4; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "adler32", ' ')) {
ut32 hn = r_hash_adler32 (core->block, len);
ut8 *b = (ut8*)&hn;
r_cons_printf ("%02x%02x%02x%02x\n", b[0], b[1], b[2], b[3]);
} else
if (!r_str_ccmp (input, "md5", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_MD5);
const ut8 *c = r_hash_do_md5 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_MD5; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha1", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA1);
const ut8 *c = r_hash_do_sha1 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA1; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha256", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA256);
const ut8 *c = r_hash_do_sha256 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA256; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "sha512", ' ')) {
RHash *ctx = r_hash_new (R_TRUE, R_HASH_SHA512);
const ut8 *c = r_hash_do_sha512 (ctx, core->block, len);
for (i=0; i<R_HASH_SIZE_SHA512; i++) r_cons_printf ("%02x", c[i]);
r_cons_newline ();
r_hash_free (ctx);
} else
if (!r_str_ccmp (input, "entropy", ' ')) {
r_cons_printf ("%lf\n", r_hash_entropy (core->block, len));
} else
if (!r_str_ccmp (input, "hamdist", ' ')) {
r_cons_printf ("%d\n", r_hash_hamdist (core->block, len));
} else
if (!r_str_ccmp (input, "pcprint", ' ')) {
r_cons_printf ("%d\n", r_hash_pcprint (core->block, len));
} else
if (!r_str_ccmp (input, "crc32", ' ')) {
r_cons_printf ("%04x\n", r_hash_crc32 (core->block, len));
} else
if (!r_str_ccmp (input, "xor", ' ')) {
r_cons_printf ("%02x\n", r_hash_xor (core->block, len));
} else
if (!r_str_ccmp (input, "crc16", ' ')) {
r_cons_printf ("%02x\n", r_hash_crc16 (0, core->block, len));
} else
if (input[0]=='?') {
r_cons_printf (
"Usage: #algo <size> @ addr\n"
" # this is a comment note the space after the sharp sign\n"
" ## List hash/checksum algorithms.\n"
" #sha256 10K @ 33 calculate sha256 of 10K at 33\n"
"Hashes:\n");
algolist (0);
r_cons_printf (
"Usage #!interpreter [<args>] [<file] [<<eof]\n"
" #! list all available interpreters\n"
" #!python run python commandline\n"
" #!python foo.py run foo.py python script (same as '. foo.py')\n"
//" #!python <<EOF get python code until 'EOF' mark\n"
" #!python arg0 a1 <<q set arg0 and arg1 and read until 'q'\n");
}
if (osize)
r_core_block_size (core, osize);
return 0;
}
static int cmd_eval(void *data, const char *input) {
char *p;
RCore *core = (RCore *)data;
switch (input[0]) {
case 't': // env
if (input[1]==' ' && input[2]) {
RConfigNode *node = r_config_node_get (core->config, input+2);
if (node) {
const char *type = r_config_node_type (node);
if (type && *type) {
r_cons_printf ("%s\n", type);
}
}
} else {
eprintf ("Usage: et [varname] ; show type of eval var\n");
}
break;
case 'n': // env
if (!strchr (input, '=')) {
char *var, *p;
var = strchr (input, ' ');
if (var) while (*var==' ') var++;
p = r_sys_getenv (var);
if (p) {
r_cons_printf ("%s\n", p);
free (p);
} else {
char **e = r_sys_get_environ ();
while (e && *e) {
r_cons_printf ("%s\n", *e);
e++;
}
}
} else if (strlen (input)>3) {
char *v, *k = strdup (input+3);
if (!k) break;
v = strchr (k, '=');
if (v) {
*v++ = 0;
r_sys_setenv (k, v);
}
free (k);
}
return true;
case 'x': // exit
return cmd_quit (data, "");
case 'j':
r_config_list (core->config, NULL, 'j');
break;
case '\0':
r_config_list (core->config, NULL, 0);
break;
case 'c':
switch (input[1]) {
case 'h': // echo
if (( p = strchr (input, ' ') )) {
r_cons_strcat (p+1);
r_cons_newline ();
}
break;
case 'd':
r_cons_pal_init (NULL);
break;
case '?': {
const char *helpmsg[] = {
"Usage ec[s?] [key][[=| ]fg] [bg]","","",
"ec","","list all color keys",
"ec*","","same as above, but using r2 commands",
"ecd","","set default palette",
"ecr","","set random palette",
"ecs","","show a colorful palette",
"ecj","","show palette in JSON",
"ecc","","show palette in CSS",
"eco"," dark|white","load white color scheme template",
"ecn","","load next color theme",
"ec"," prompt red","change color of prompt",
"ec"," prompt red blue","change color and background of prompt",
""," ","",
"colors:","","rgb:000, red, green, blue, ...",
"e scr.rgbcolor","=1|0","for 256 color cube (boolean)",
"e scr.truecolor","=1|0","for 256*256*256 colors (boolean)",
"$DATADIR/radare2/cons","","~/.config/radare2/cons ./",
NULL};
r_core_cmd_help (core, helpmsg);
}
break;
case 'o': // "eco"
if (input[2] == ' ') {
bool failed = false;
char *home, path[512];
snprintf (path, sizeof (path), ".config/radare2/cons/%s", input+3);
home = r_str_home (path);
snprintf (path, sizeof (path), R2_DATDIR"/radare2/"
R2_VERSION"/cons/%s", input+3);
if (!r_core_cmd_file (core, home)) {
if (r_core_cmd_file (core, path)) {
//curtheme = r_str_dup (curtheme, path);
curtheme = r_str_dup (curtheme, input + 3);
} else {
if (r_core_cmd_file (core, input+3)) {
curtheme = r_str_dup (curtheme, input + 3);
} else {
eprintf ("eco: cannot open colorscheme profile (%s)\n", path);
failed = true;
}
}
}
free (home);
} else {
nextpal (core, 'l');
}
break;
case 's': r_cons_pal_show (); break;
case '*': r_cons_pal_list (1); break;
case 'j': r_cons_pal_list ('j'); break;
case 'c': r_cons_pal_list ('c'); break;
case '\0': r_cons_pal_list (0); break;
case 'r': // "ecr"
r_cons_pal_random ();
break;
case 'n': // "ecn"
nextpal (core, 'n');
break;
default: {
char *p = strdup (input + 2);
char *q = strchr (p, '=');
if (!q) q = strchr (p, ' ');
if (q) {
// set
*q++ = 0;
r_cons_pal_set (p, q);
} else {
const char *k = r_cons_pal_get (p);
if (k)
eprintf ("(%s)(%sCOLOR"Color_RESET")\n", p, k);
}
free (p);
}
}
break;
case 'e':
if (input[1]==' ') {
char *p;
const char *val, *input2 = strchr (input+2, ' ');
if (input2) input2++; else input2 = input+2;
val = r_config_get (core->config, input2);
p = r_core_editor (core, NULL, val);
if (p) {
r_str_replace_char (p, '\n', ';');
r_config_set (core->config, input2, p);
}
} else eprintf ("Usage: ee varname\n");
break;
case '!':
input = r_str_chop_ro (input+1);
if (!r_config_toggle (core->config, input))
eprintf ("r_config: '%s' is not a boolean variable.\n", input);
break;
case '-':
r_core_config_init (core);
//eprintf ("BUG: 'e-' command locks the eval hashtable. patches are welcome :)\n");
break;
case 'v': eprintf ("Invalid command '%s'. Use 'e?'\n", input); break;
case '*': r_config_list (core->config, NULL, 1); break;
case '?':
switch (input[1]) {
case '?': r_config_list (core->config, input+2, 2); break;
default: r_config_list (core->config, input+1, 2); break;
case 0:{
const char* help_msg[] = {
"Usage:", "e[?] [var[=value]]", "Evaluable vars",
"e","?asm.bytes", "show description",
"e", "??", "list config vars with description",
"e", "", "list config vars",
"e-", "", "reset config vars",
"e*", "", "dump config vars in r commands",
"e!", "a", "invert the boolean value of 'a' var",
"ee", "var", "open editor to change the value of var",
"er", " [key]", "set config key as readonly. no way back",
"ec", " [k] [color]", "set color for given key (prompt, offset, ...)",
"et", " [key]", "show type of given config variable",
"e", " a", "get value of var 'a'",
"e", " a=b", "set var 'a' the 'b' value",
"env", " [k[=v]]", "get/set environment variable",
NULL};
r_core_cmd_help (core, help_msg);
}
}
break;
case 'r':
if (input[1]) {
const char *key = input+((input[1]==' ')?2:1);
if (!r_config_readonly (core->config, key))
eprintf ("cannot find key '%s'\n", key);
} else eprintf ("Usage: er [key]\n");
break;
case ' ': r_config_eval (core->config, input+1); break;
default: r_config_eval (core->config, input); break;
}
return 0;
}
static int cmd_info(void *data, const char *input) {
RCore *core = (RCore *)data;
int newline = r_config_get_i (core->config, "scr.interactive");
ut64 offset = r_bin_get_offset (core->bin);
RBinObject *o = r_bin_cur_object (core->bin);
RCoreFile *cf = core->file;
int va = core->io->va || core->io->debug;
int mode = 0; //R_CORE_BIN_SIMPLE;
int is_array = 0;
Sdb *db;
if (strchr (input, '*'))
mode = R_CORE_BIN_RADARE;
if (strchr (input, 'j'))
mode = R_CORE_BIN_JSON;
if (mode == R_CORE_BIN_JSON) {
if (strlen (input+1)>1)
is_array = 1;
}
if (is_array)
r_cons_printf ("{");
if (!*input)
cmd_info_bin (core, offset, va, mode);
while (*input) {
switch (*input) {
case 'b':
{
ut64 baddr = r_config_get_i (core->config, "bin.baddr");
if (input[1]==' ')
baddr = r_num_math (core->num, input+1);
// XXX: this will reload the bin using the buffer.
// An assumption is made that assumes there is an underlying
// plugin that will be used to load the bin (e.g. malloc://)
// TODO: Might be nice to reload a bin at a specified offset?
r_core_bin_reload (core, NULL, baddr);
r_core_block_read (core, 0);
}
break;
case 'k':
db = o ? o->kv : NULL;
//:eprintf ("db = %p\n", db);
switch (input[1]) {
case 'v':
if (db) sdb_query (db, input+3);
break;
case '.':
case ' ':
if (db) sdb_query (db, input+2);
break;
case '\0':
if (db) sdb_list (db);
break;
case '?':
default:
eprintf ("Usage: ik [sdb-query]\n");
}
break;
case 'o':
{
const char *fn = input[1]==' '? input+2: cf->desc->name;
ut64 laddr = UT64_MAX;
laddr = r_config_get_i (core->config, "bin.baddr");
r_core_bin_load (core, fn, laddr);
}
break;
#define RBININFO(n,x) \
if (is_array) { \
if (is_array==1) is_array++; else r_cons_printf (","); \
r_cons_printf ("\"%s\":",n); \
}\
r_core_bin_info (core,x,mode,va,NULL,offset,NULL);
case 'A': newline=0; r_bin_list_archs (core->bin, 1); break;
case 'Z': RBININFO ("size",R_CORE_BIN_ACC_SIZE); break;
case 'S': RBININFO ("sections",R_CORE_BIN_ACC_SECTIONS); break;
case 'h': RBININFO ("fields", R_CORE_BIN_ACC_FIELDS); break;
case 'l': RBININFO ("libs", R_CORE_BIN_ACC_LIBS); break;
case 's': RBININFO ("symbols", R_CORE_BIN_ACC_SYMBOLS); break;
case 'R':
case 'r': RBININFO ("relocs", R_CORE_BIN_ACC_RELOCS); break;
case 'd': RBININFO ("dwarf", R_CORE_BIN_ACC_DWARF); break;
case 'i': RBININFO ("imports",R_CORE_BIN_ACC_IMPORTS); break;
case 'I': RBININFO ("info", R_CORE_BIN_ACC_INFO); break;
case 'e': RBININFO ("entries",R_CORE_BIN_ACC_ENTRIES); break;
case 'z': RBININFO ("strings",R_CORE_BIN_ACC_STRINGS); break;
case 'c':
case 'C': RBININFO ("classes",R_CORE_BIN_ACC_CLASSES); break;
case 'a':
{
switch (mode) {
case R_CORE_BIN_RADARE: cmd_info (core, "i*IiesSz"); break;
case R_CORE_BIN_JSON: cmd_info (core, "iIiesSzj"); break;
default:
case R_CORE_BIN_SIMPLE: cmd_info (core, "iIiesSz"); break;
}
}
break;
case '?': {
const char * help_message[] = {
"Usage: i", "", "Get info from opened file",
"Output mode:", "", "",
"'*'", "", "Output in radare commands",
"'j'", "", "Output in json",
"'q'", "", "Simple quiet output",
"Actions:", "", "",
"i|ij", "", "Show info of current file (in JSON)",
"iA", "", "List archs",
"ia", "", "Show all info (imports, exports, sections..)",
"ib", "", "Reload the current buffer for setting of the bin (use once only)",
"ic", "", "List classes",
"id", "", "Debug information (source lines)",
"ie", "", "Entrypoint",
"ih", "", "Headers",
"ii", "", "Imports",
"iI", "", "Binary info",
"ik", " [query]", "Key-value database from RBinObject",
"il", "", "Libraries",
"io", " [file]", "Load info from file (or last opened) use bin.baddr",
"ir|iR", "", "Relocs",
"is", "", "Symbols",
"iS", "", "Sections",
"iz", "", "Strings",
NULL
};
r_core_cmd_help(core, help_message);
}
goto done;
case '*':
mode = R_CORE_BIN_RADARE;
goto done;
case 'j':
mode = R_CORE_BIN_JSON;
cmd_info_bin (core, offset, va, mode);
goto done;
default:
cmd_info_bin (core, offset, va, mode);
break;
}
input++;
if (!strcmp (input, "j"))
break;
}
done:
if (is_array)
r_cons_printf ("}\n");
if (newline) r_cons_newline();
return 0;
}
R_API void r_cons_println(const char* str) {
r_cons_print (str);
r_cons_newline ();
}
static int cmd_seek(void *data, const char *input) {
RCore *core = (RCore *) data;
char *cmd, *p;
ut64 off = core->offset;
if (!*input) {
r_cons_printf ("0x%"PFMT64x "\n", core->offset);
return 0;
}
char *ptr;
if ((ptr = strstr (input, "+.")) != NULL) {
char *dup = strdup (input);
dup[ptr - input] = '\x00';
off = r_num_math (core->num, dup + 1);
core->offset = off;
free (dup);
}
const char *inputnum = strchr (input, ' ');
{
const char *u_num = inputnum? inputnum + 1: input + 1;
off = r_num_math (core->num, u_num);
if (*u_num == '-') {
off = -(st64)off;
}
}
#if 1
// int sign = 1;
if (input[0] == ' ') {
switch (input[1]) {
case '-':
// sign = -1;
/* pass thru */
case '+':
input++;
break;
}
}
#endif
bool silent = false;
if (*input == 's') {
silent = true;
input++;
if (*input == '?') {
r_core_cmd_help (core, help_msg_ss);
return 0;
}
}
switch (*input) {
case 'r': // "sr"
if (input[1] && input[2]) {
seek_to_register (core, input + 2, silent);
} else {
eprintf ("|Usage| 'sr PC' seek to program counter register\n");
}
break;
case 'C': // "sC"
if (input[1] == '*') { // "sC*"
r_core_cmd0 (core, "C*~^\"CC");
} else if (input[1] == ' ') {
typedef struct {
ut64 addr;
char *str;
} MetaCallback;
int count = 0;
MetaCallback cb = {
0, NULL
};
ut64 addr;
char key[128];
const char *val, *comma;
char *list = sdb_get (core->anal->sdb_meta, "meta.C", 0);
char *str, *next, *cur = list;
if (list) {
for (;;) {
cur = sdb_anext (cur, &next);
addr = sdb_atoi (cur);
snprintf (key, sizeof (key) - 1, "meta.C.0x%"PFMT64x, addr);
val = sdb_const_get (core->anal->sdb_meta, key, 0);
if (val) {
comma = strchr (val, ',');
if (comma) {
str = (char *) sdb_decode (comma + 1, 0);
if (strstr (str, input + 2)) {
r_cons_printf ("0x%08"PFMT64x " %s\n", addr, str);
count++;
cb.addr = addr;
free (cb.str);
cb.str = str;
} else {
free (str);
}
}
} else {
eprintf ("sdb_const_get key not found '%s'\n", key);
}
if (!next) {
break;
}
cur = next;
}
}
switch (count) {
case 0:
eprintf ("No matching comments\n");
break;
case 1:
off = cb.addr;
if (!silent) {
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
}
r_core_seek (core, off, 1);
r_core_block_read (core);
break;
default:
eprintf ("Too many results\n");
break;
}
free (cb.str);
} else {
r_core_cmd_help (core, help_msg_sC);
}
break;
case ' ': // "s "
{
ut64 addr = r_num_math (core->num, input + 1);
if (core->num->nc.errors && r_cons_singleton ()->is_interactive) {
eprintf ("Cannot seek to unknown address '%s'\n", core->num->nc.calc_buf);
break;
}
if (!silent) {
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
}
r_core_seek (core, addr, 1);
r_core_block_read (core);
}
break;
case '/': // "s/"
{
const char *pfx = r_config_get (core->config, "search.prefix");
const ut64 saved_from = r_config_get_i (core->config, "search.from");
const ut64 saved_maxhits = r_config_get_i (core->config, "search.maxhits");
// kwidx cfg var is ignored
int kwidx = core->search->n_kws; // (int)r_config_get_i (core->config, "search.kwidx")-1;
if (kwidx < 0) {
kwidx = 0;
}
switch (input[1]) {
case ' ':
case 'v':
case 'V':
case 'w':
case 'W':
case 'z':
case 'm':
case 'c':
case 'A':
case 'e':
case 'E':
case 'i':
case 'R':
case 'r':
case '/':
case 'x':
r_config_set_i (core->config, "search.from", core->offset + 1);
r_config_set_i (core->config, "search.maxhits", 1);
r_core_cmdf (core, "s+1; %s; s-1; s %s%d_0; f-%s%d_0",
input, pfx, kwidx, pfx, kwidx, pfx, kwidx);
r_config_set_i (core->config, "search.from", saved_from);
r_config_set_i (core->config, "search.maxhits", saved_maxhits);
break;
case '?':
eprintf ("Usage: s/.. arg.\n");
r_cons_printf ("/?\n");
break;
default:
eprintf ("unknown search method\n");
break;
}
}
break;
case '.': // "s."
for (input++; *input == '.'; input++) {
;
}
r_core_seek_base (core, input);
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
break;
case 'j': // "sj"
{
RList /*<ut64 *>*/ *addrs = r_list_newf (free);
RList /*<char *>*/ *names = r_list_newf (free);
RList *list = r_io_sundo_list (core->io, '!');
ut64 lsz = 0;
ut64 i;
RListIter *iter;
RIOUndos *undo;
if (list) {
r_list_foreach (list, iter, undo) {
char *name = NULL;
core->flags->space_strict = true;
RFlagItem *f = r_flag_get_at (core->flags, undo->off, true);
core->flags->space_strict = false;
if (f) {
if (f->offset != undo->off) {
name = r_str_newf ("%s+%d", f->name,
(int)(undo->off- f->offset));
} else {
name = strdup (f->name);
}
}
if (!name) {
name = strdup ("");
}
ut64 *val = malloc (sizeof (ut64));
if (!val) {
free (name);
break;
}
*val = undo->off;
r_list_append (addrs, val);
r_list_append (names, strdup (name));
lsz++;
free (name);
}
r_list_free (list);
}
r_cons_printf ("[");
for (i = 0; i < lsz; ++i) {
ut64 *addr = r_list_get_n (addrs, i);
const char *name = r_list_get_n (names, i);
// XXX(should the "name" field be optional? That might make
// a bit more sense.
r_cons_printf ("{\"offset\":%"PFMT64d",\"symbol\":\"%s\"}", *addr, name);
if (i != lsz - 1) {
r_cons_printf (",");
}
}
r_cons_printf ("]\n");
r_list_free (addrs);
r_list_free (names);
}
break;
case '*': // "s*"
case '=': // "s="
case '!': // "s!"
{
char mode = input[0];
if (input[1] == '=') {
mode = 0;
}
RList *list = r_io_sundo_list (core->io, mode);
if (list) {
RListIter *iter;
RIOUndos *undo;
r_list_foreach (list, iter, undo) {
char *name = NULL;
core->flags->space_strict = true;
RFlagItem *f = r_flag_get_at (core->flags, undo->off, true);
core->flags->space_strict = false;
if (f) {
if (f->offset != undo->off) {
name = r_str_newf ("%s + %d\n", f->name,
(int)(undo->off - f->offset));
} else {
name = strdup (f->name);
}
}
if (mode) {
r_cons_printf ("0x%"PFMT64x" %s\n", undo->off, name? name: "");
} else {
if (!name) {
name = r_str_newf ("0x%"PFMT64x, undo->off);
}
r_cons_printf ("%s%s", name, iter->n? " > ":"");
}
free (name);
}
r_list_free (list);
if (!mode) {
r_cons_newline ();
}
}
}
static void print_format_values(RCore *core, const char *fmt, bool onstack, ut64 src, bool color) {
char opt;
ut64 bval = src;
int i;
int endian = core->print->big_endian;
int width = (core->anal->bits == 64)? 8: 4;
int bsize = R_MIN (64, core->blocksize);
ut8 *buf = malloc (bsize);
if (!buf) {
eprintf ("Cannot allocate %d byte(s)\n", bsize);
free (buf);
return;
}
if (fmt) {
opt = *fmt;
} else {
opt = 'p'; // void *ptr
}
if (onstack || ((opt != 'd' && opt != 'x') && !onstack)) {
if (color) {
r_cons_printf (Color_BGREEN"0x%08"PFMT64x Color_RESET" --> ", bval);
} else {
r_cons_printf ("0x%08"PFMT64x" --> ", bval);
}
r_io_read_at (core->io, bval, buf, bsize);
}
if (onstack) { // Fetch value from stack
bval = get_buf_val (buf, endian, width);
if (opt != 'd' && opt != 'x') {
r_io_read_at (core->io, bval, buf, bsize); // update buf with val from stack
}
}
r_cons_print (color? Color_BGREEN: "");
switch (opt) {
case 'z' : // Null terminated string
r_cons_print (color ?Color_RESET Color_BWHITE:"");
r_cons_print ("\"");
for (i = 0; i < MAXSTRLEN; i++) {
if (buf[i] == '\0') {
break;
}
ut8 b = buf[i];
if (IS_PRINTABLE (b)) {
r_cons_printf ("%c", b);
} else {
r_cons_printf ("\\x%02x", b);
}
if (i == MAXSTRLEN - 1) {
r_cons_print ("..."); // To show string is truncated
}
}
r_cons_print ("\"");
r_cons_newline ();
break;
case 'd' : // integer
case 'x' :
r_cons_printf ("0x%08" PFMT64x, bval);
r_cons_newline ();
break;
case 'c' : // char
r_cons_print ("\'");
ut8 ch = buf[0];
if (IS_PRINTABLE (ch)) {
r_cons_printf ("%c", ch);
} else {
r_cons_printf ("\\x%02x", ch);
}
r_cons_print ("\'");
r_cons_newline ();
break;
case 'p' : // pointer
{
// Try to deref the pointer once again
r_cons_printf ("0x%08"PFMT64x, get_buf_val (buf, endian, width));
r_cons_newline ();
break;
}
default:
//TODO: support types like structs and unions
r_cons_println ("unk_format");
}
r_cons_print (Color_RESET);
free (buf);
}
R_API int r_cons_grepbuf(char *buf, int len) {
RCons *cons = r_cons_singleton ();
char *tline, *tbuf, *p, *out, *in = buf;
int ret, total_lines = 0, buffer_len = 0, l = 0, tl = 0;
bool show = false;
if (cons->filter) {
cons->buffer_len = 0;
R_FREE (cons->buffer);
return 0;
}
if ((!len || !buf || buf[0] == '\0') &&
(cons->grep.json || cons->grep.less)) {
cons->grep.json = 0;
cons->grep.less = 0;
return 0;
}
if (cons->grep.json) {
if (cons->grep.json_path) {
char *u = sdb_json_get_str (cons->buffer, cons->grep.json_path);
if (u) {
cons->buffer = u;
cons->buffer_len = strlen (u);
cons->buffer_sz = cons->buffer_len + 1;
cons->grep.json = 0;
r_cons_newline ();
}
R_FREE (cons->grep.json_path);
} else {
const char *palette[] = {
cons->pal.graph_false, // f
cons->pal.graph_true, // t
cons->pal.num, // k
cons->pal.comment, // v
Color_RESET,
NULL
};
char *out = r_print_json_indent (buf, I (color), " ", palette);
if (!out) {
return 0;
}
free (cons->buffer);
cons->buffer = out;
cons->buffer_len = strlen (out);
cons->buffer_sz = cons->buffer_len + 1;
cons->grep.json = 0;
if (cons->grep.less) {
cons->grep.less = 0;
r_cons_less_str (cons->buffer, NULL);
}
}
return 3;
}
if (cons->grep.less) {
int less = cons->grep.less;
cons->grep.less = 0;
if (less == 2) {
char *res = r_cons_hud_string (buf);
r_cons_println (res);
free (res);
} else {
r_cons_less_str (buf, NULL);
buf[0] = 0;
cons->buffer_len = 0;
if (cons->buffer) {
cons->buffer[0] = 0;
}
R_FREE (cons->buffer);
}
return 0;
}
if (!cons->buffer) {
cons->buffer_len = len + 20;
cons->buffer = malloc (cons->buffer_len);
cons->buffer[0] = 0;
}
out = tbuf = calloc (1, len);
if (!out) {
return 0;
}
tline = malloc (len);
if (!tline) {
free (out);
return 0;
}
cons->lines = 0;
// used to count lines and change negative grep.line values
while ((int) (size_t) (in - buf) < len) {
p = strchr (in, '\n');
if (!p) {
break;
}
l = p - in;
if (l > 0) {
in += l + 1;
} else {
in++;
}
total_lines++;
}
if (!cons->grep.range_line && cons->grep.line < 0) {
cons->grep.line = total_lines + cons->grep.line;
}
if (cons->grep.range_line == 1) {
if (cons->grep.f_line < 0) {
cons->grep.f_line = total_lines + cons->grep.f_line;
}
if (cons->grep.l_line < 0) {
cons->grep.l_line = total_lines + cons->grep.l_line;
}
}
in = buf;
while ((int) (size_t) (in - buf) < len) {
p = strchr (in, '\n');
if (!p) {
free (tbuf);
free (tline);
return 0;
}
l = p - in;
if (l > 0) {
memcpy (tline, in, l);
if (cons->grep_color) {
tl = l;
} else {
tl = r_str_ansi_filter (tline, NULL, NULL, l);
}
if (tl < 0) {
ret = -1;
} else {
ret = r_cons_grep_line (tline, tl);
if (!cons->grep.range_line) {
if (cons->grep.line == cons->lines) {
show = true;
}
} else if (cons->grep.range_line == 1) {
if (cons->grep.f_line == cons->lines) {
show = true;
}
if (cons->grep.l_line == cons->lines) {
show = false;
}
} else {
show = true;
}
}
if (ret > 0) {
if (show) {
memcpy (out, tline, ret);
memcpy (out + ret, "\n", 1);
out += ret + 1;
buffer_len += ret + 1;
}
if (!cons->grep.range_line) {
show = false;
}
cons->lines++;
} else if (ret < 0) {
free (tbuf);
free (tline);
return 0;
}
in += l + 1;
} else {
in++;
}
}
memcpy (buf, tbuf, len);
cons->buffer_len = buffer_len;
free (tbuf);
free (tline);
if (cons->grep.counter) {
int cnt = cons->grep.charCounter? strlen (cons->buffer): cons->lines;
if (cons->buffer_len < 10) {
cons->buffer_len = 10; // HACK
}
snprintf (cons->buffer, cons->buffer_len, "%d\n", cnt);
cons->buffer_len = strlen (cons->buffer);
cons->num->value = cons->lines;
}
if (cons->grep.sort != -1) {
#define INSERT_LINES(list)\
do {\
r_list_foreach (list, iter, str) {\
int len = strlen (str);\
memcpy (ptr, str, len);\
memcpy (ptr + len, "\n", 2);\
ptr += len + 1;\
nl++;\
}\
}\
while (false)
RListIter *iter;
int nl = 0;
char *ptr = cons->buffer;
char *str;
sorted_column = cons->grep.sort;
r_list_sort (sorted_lines, cmp);
if (cons->grep.sort_invert) {
r_list_reverse (sorted_lines);
}
INSERT_LINES (unsorted_lines);
INSERT_LINES (sorted_lines);
cons->lines = nl;
r_list_free (sorted_lines);
sorted_lines = NULL;
r_list_free (unsorted_lines);
unsorted_lines = NULL;
}
return cons->lines;
}
static int cmd_info(void *data, const char *input) {
RCore *core = (RCore *)data;
int newline = r_config_get_i (core->config, "scr.interactive");
ut64 offset = r_bin_get_offset (core->bin);
RBinObject *o = r_bin_cur_object (core->bin);
RCoreFile *cf = core->file;
int va = core->io->va || core->io->debug;
int mode = 0; //R_CORE_BIN_SIMPLE;
int is_array = 0;
Sdb *db;
if (strchr (input, '*'))
mode = R_CORE_BIN_RADARE;
if (strchr (input, 'j'))
mode = R_CORE_BIN_JSON;
if (mode == R_CORE_BIN_JSON) {
if (strlen (input+1)>1)
is_array = 1;
}
if (is_array)
r_cons_printf ("{");
if (!*input)
cmd_info_bin (core, offset, va, mode);
while (*input) {
switch (*input) {
case 'b':
{
ut64 baddr = r_config_get_i (core->config, "bin.baddr");
if (input[1]==' ')
baddr = r_num_math (core->num, input+1);
// XXX: this will reload the bin using the buffer.
// An assumption is made that assumes there is an underlying
// plugin that will be used to load the bin (e.g. malloc://)
// TODO: Might be nice to reload a bin at a specified offset?
r_core_bin_reload (core, NULL, baddr);
r_core_block_read (core, 0);
}
break;
case 'k':
db = o ? o->kv : NULL;
//:eprintf ("db = %p\n", db);
switch (input[1]) {
case 'v':
if (db) sdb_query (db, input+3);
break;
case '.':
case ' ':
if (db) sdb_query (db, input+2);
break;
case '\0':
if (db) sdb_list (db);
break;
case '?':
default:
eprintf ("Usage: ik [sdb-query]\n");
}
break;
case 'o': r_core_bin_load (core, input[1]==' '?
input+2: cf->filename,
r_config_get_i (core->config, "bin.baddr"));
break;
#define RBININFO(n,x) \
if (is_array) { \
if (is_array==1) is_array++; else r_cons_printf (","); \
r_cons_printf ("\"%s\":",n); \
}\
r_core_bin_info (core,x,mode,va,NULL,offset);
case 'A': newline=0; r_bin_list_archs (core->bin, 1); break;
case 'S': RBININFO ("sections",R_CORE_BIN_ACC_SECTIONS); break;
case 'h': RBININFO ("fields", R_CORE_BIN_ACC_FIELDS); break;
case 'l': RBININFO ("libs", R_CORE_BIN_ACC_LIBS); break;
case 's': RBININFO ("symbols", R_CORE_BIN_ACC_SYMBOLS); break;
case 'R':
case 'r': RBININFO ("relocs", R_CORE_BIN_ACC_RELOCS); break;
case 'd': RBININFO ("dwarf", R_CORE_BIN_ACC_DWARF); break;
case 'i': RBININFO ("imports",R_CORE_BIN_ACC_IMPORTS); break;
case 'I': RBININFO ("info", R_CORE_BIN_ACC_INFO); break;
case 'e': RBININFO ("entries",R_CORE_BIN_ACC_ENTRIES); break;
case 'z': RBININFO ("strings",R_CORE_BIN_ACC_STRINGS); break;
case 'c':
case 'C': RBININFO ("classes",R_CORE_BIN_ACC_CLASSES); break;
case 'a':
{
switch (mode) {
case R_CORE_BIN_RADARE: cmd_info (core, "i*IiesSz"); break;
case R_CORE_BIN_JSON: cmd_info (core, "ijIiesSz"); break;
default:
case R_CORE_BIN_SIMPLE: cmd_info (core, "iIiesSz"); break;
}
}
break;
case '?':
r_cons_printf (
"|Usage: i[aeciIsosSz][jq*] ; get info from opened file\n"
"|Output mode:\n"
"| '*' output in radare commands\n"
"| 'j' output in json\n"
"| 'q' simple quiet output\n"
"|Actions:\n"
"| i, ij show info of current file (in JSON)\n"
"| iA list archs\n"
"| ia show all info (imports, exports, sections..)\n"
"| ib reload the current buffer for setting of the bin (use once only)\n"
"| ic list classes\n"
"| id debug information (source lines)\n"
"| ie entrypoint\n"
"| ih headers\n"
"| ii imports\n"
"| iI binary info\n"
"| il libraries\n"
"| ik [query] key-value database from RBinObject\n"
"| io [file] load info from file (or last opened) use bin.baddr\n"
"| is symbols\n"
"| iS sections\n"
"| ir/iR relocs\n"
"| iz strings\n"
);
goto done;
case '*':
mode = R_CORE_BIN_RADARE;
goto done;
case 'j':
mode = R_CORE_BIN_JSON;
cmd_info_bin (core, offset, va, mode);
goto done;
default:
cmd_info_bin (core, offset, va, mode);
break;
}
input++;
if (!strcmp (input, "j"))
break;
}
done:
if (is_array)
r_cons_printf ("}\n");
if (newline) r_cons_newline();
return 0;
}
