static int cmp(const void *a, const void *b) {
char *da = NULL;
char *db = NULL;
const char *ca = r_str_trim_ro (a);
const char *cb = r_str_trim_ro (b);
if (!a || !b) {
return (int) (size_t) ((char*) a - (char*) b);
}
if (sorted_column > 0) {
da = strdup (ca);
db = strdup (cb);
int colsa = r_str_word_set0 (da);
int colsb = r_str_word_set0 (db);
ca = (colsa > sorted_column)? r_str_word_get0 (da, sorted_column): "";
cb = (colsb > sorted_column)? r_str_word_get0 (db, sorted_column): "";
}
if (IS_DIGIT (*ca) && IS_DIGIT (*cb)) {
ut64 na = r_num_get (NULL, ca);
ut64 nb = r_num_get (NULL, cb);
int ret = na > nb;
free (da);
free (db);
return ret;
}
if (da && db) {
int ret = strcmp (ca, cb);
free (da);
free (db);
return ret;
}
free (da);
free (db);
return strcmp (a, b);
}
static int flag_to_flag(RCore *core, const char *glob) {
r_return_val_if_fail (glob, 0);
glob = r_str_trim_ro (glob);
struct flag_to_flag_t u = { .next = UT64_MAX, .offset = core->offset };
r_flag_foreach_glob (core->flags, glob, flag_to_flag_foreach, &u);
if (u.next != UT64_MAX && u.next > core->offset) {
return u.next - core->offset;
}
return 0;
}
static void cmd_flag_tags (RCore *core, const char *input) {
char mode = input[1];
for (; *input && !IS_WHITESPACE (*input); input++) {}
char *inp = strdup (input);
char *arg = r_str_trim (inp);
if (!*arg && !mode) {
const char *tag;
RListIter *iter;
RList *list = r_flag_tags_list (core->flags);
r_list_foreach (list, iter, tag) {
r_cons_printf ("%s\n", tag);
}
r_list_free (list);
free (inp);
return;
}
/* remove spaces from the head of the string.
* the string is changed in place */
R_API char *r_str_trim_head(char *str) {
char *p = (char *)r_str_trim_ro (str);;
if (p) {
memmove (str, p, strlen (p) + 1);
}
return str;
}
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;
}
}
R_API void r_cons_pal_list(int rad, const char *arg) {
char *name, **color;
const char *hasnext;
int i;
if (rad == 'j') {
r_cons_print ("{");
}
for (i = 0; keys[i].name; i++) {
RColor *rcolor = RCOLOR_AT (i);
color = COLOR_AT (i);
switch (rad) {
case 'j':
hasnext = (keys[i + 1].name) ? "," : "";
r_cons_printf ("\"%s\":[%d,%d,%d]%s",
keys[i].name, rcolor->r, rcolor->g, rcolor->b, hasnext);
break;
case 'c': {
const char *prefix = r_str_trim_ro (arg);
if (!prefix) {
prefix = "";
}
hasnext = (keys[i + 1].name) ? "\n" : "";
// TODO Need to replace the '.' char because this is not valid CSS
char *name = strdup (keys[i].name);
int j, len = strlen (name);
for (j = 0; j < len; j++) {
if (name[j] == '.') {
name[j] = '_';
}
}
r_cons_printf (".%s%s { color: rgb(%d, %d, %d); }%s",
prefix, name, rcolor->r, rcolor->g, rcolor->b, hasnext);
free (name);
}
break;
case 'h':
name = strdup (keys[i].name);
r_str_replace_char (name, '.', '_');
r_cons_printf (".%s { color:#%02x%02x%02x }\n",
name, rcolor->r, rcolor->g, rcolor->b);
free (name);
break;
case '*':
case 'r':
case 1:
r_cons_printf ("ec %s rgb:%02x%02x%02x\n",
keys[i].name, rcolor->r, rcolor->g, rcolor->b);
break;
default:
r_cons_printf (" %s##"Color_RESET" %s\n", *color,
keys[i].name);
}
}
if (rad == 'j') {
r_cons_print ("}\n");
}
}
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;
}
}
// no copy, like trim_head+tail but with trim_head_ro
R_API char *r_str_trim_nc(char *str) {
char *s = (char *)r_str_trim_ro (str);
return r_str_trim_tail (s);
}
R_API void r_anal_hint_set_esil(RAnal *a, ut64 addr, const char *esil) {
setHint (a, "esil:", addr, r_str_trim_ro (esil), 0);
}
R_API void r_anal_hint_set_opcode(RAnal *a, ut64 addr, const char *opcode) {
setHint (a, "opcode:", addr, r_str_trim_ro (opcode), 0);
}
R_API void r_anal_hint_set_arch(RAnal *a, ut64 addr, const char *arch) {
setHint (a, "arch:", addr, r_str_trim_ro (arch), 0);
}
R_API void r_anal_hint_set_offset(RAnal *a, ut64 addr, const char* typeoff) {
setHint (a, "Offset:", addr, r_str_trim_ro (typeoff), 0);
}