2014-06-13 20:40:03 +00:00
|
|
|
/* radare - LGPL - Copyright 2009-2014 - pancake */
|
2012-01-31 01:45:17 +00:00
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
#include "r_core.h"
|
|
|
|
|
2013-09-23 22:43:31 +00:00
|
|
|
#define MAX_FORMAT 3
|
2012-09-28 00:20:52 +00:00
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
R_API int r_core_visual_trackflags(RCore *core) {
|
2013-09-23 22:43:31 +00:00
|
|
|
const char *fs = NULL, *fs2 = NULL;
|
|
|
|
int hit, i, j, ch;
|
2011-06-04 01:14:04 +00:00
|
|
|
RListIter *iter;
|
|
|
|
RFlagItem *flag;
|
|
|
|
int _option = 0;
|
2013-09-23 22:43:31 +00:00
|
|
|
int option = 0;
|
|
|
|
char cmd[1024];
|
|
|
|
int format = 0;
|
2011-06-04 01:14:04 +00:00
|
|
|
int delta = 7;
|
|
|
|
int menu = 0;
|
|
|
|
|
2013-09-23 22:43:31 +00:00
|
|
|
for (j=i=0; i<R_FLAG_SPACES_MAX; i++)
|
2013-09-21 15:50:09 +00:00
|
|
|
if (core->flags->spaces[i])
|
|
|
|
j = 1;
|
|
|
|
if (j==0) menu = 1;
|
2011-06-04 01:14:04 +00:00
|
|
|
for (;;) {
|
2014-09-12 17:25:42 +00:00
|
|
|
r_cons_clear00 ();
|
2011-06-04 01:14:04 +00:00
|
|
|
|
|
|
|
if (menu) {
|
|
|
|
r_cons_printf ("Flags in flagspace '%s'. Press '?' for help.\n\n",
|
|
|
|
(core->flags->space_idx==-1)?"*":core->flags->spaces[core->flags->space_idx]);
|
|
|
|
hit = 0;
|
|
|
|
i = j = 0;
|
|
|
|
r_list_foreach (core->flags->flags, iter, flag) {
|
|
|
|
/* filter per flag spaces */
|
2012-07-22 08:00:35 +00:00
|
|
|
if ((core->flags->space_idx != -1) &&
|
2011-06-04 01:14:04 +00:00
|
|
|
(flag->space != core->flags->space_idx))
|
|
|
|
continue;
|
|
|
|
if (option==i) {
|
|
|
|
fs2 = flag->name;
|
|
|
|
hit = 1;
|
|
|
|
}
|
|
|
|
if ((i>=option-delta) && ((i<option+delta)||((option<delta)&&(i<(delta<<1))))) {
|
|
|
|
r_cons_printf (" %c %03d 0x%08"PFMT64x" %4"PFMT64d" %s\n",
|
|
|
|
(option==i)?'>':' ',
|
|
|
|
i, flag->offset, flag->size, flag->name);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
if (!hit && i>0) {
|
|
|
|
option = i-1;
|
|
|
|
continue;
|
|
|
|
}
|
2013-09-21 15:50:09 +00:00
|
|
|
if (fs2) {
|
|
|
|
r_cons_printf ("\n Selected: %s\n\n", fs2);
|
2013-09-23 22:43:31 +00:00
|
|
|
// Honor MAX_FORMATS here
|
2013-09-21 15:50:09 +00:00
|
|
|
switch (format) {
|
2013-09-23 22:43:31 +00:00
|
|
|
case 0: snprintf (cmd, sizeof (cmd), "px @ %s!64", fs2); core->printidx = 0; break;
|
|
|
|
case 1: snprintf (cmd, sizeof (cmd), "pd 12 @ %s!64", fs2); core->printidx = 1; break;
|
|
|
|
case 2: snprintf (cmd, sizeof (cmd), "ps @ %s!64", fs2); core->printidx = 5; break;
|
|
|
|
case 3: strcpy (cmd, "f="); break;
|
2013-09-21 15:50:09 +00:00
|
|
|
default: format = 0; continue;
|
|
|
|
}
|
|
|
|
if (*cmd) r_core_cmd (core, cmd, 0);
|
2013-09-23 22:43:31 +00:00
|
|
|
} else r_cons_printf ("(no flags)\n");
|
2011-06-04 01:14:04 +00:00
|
|
|
} else {
|
|
|
|
r_cons_printf ("Flag spaces:\n\n");
|
|
|
|
hit = 0;
|
|
|
|
for (j=i=0;i<R_FLAG_SPACES_MAX;i++) {
|
|
|
|
if (core->flags->spaces[i]) {
|
|
|
|
if (option==i) {
|
|
|
|
fs = core->flags->spaces[i];
|
|
|
|
hit = 1;
|
|
|
|
}
|
|
|
|
if ((i >=option-delta) && ((i<option+delta)|| \
|
|
|
|
((option<delta)&&(i<(delta<<1))))) {
|
|
|
|
r_cons_printf(" %c %02d %c %s\n",
|
2012-07-22 08:00:35 +00:00
|
|
|
(option==i)?'>':' ', j,
|
2011-06-04 01:14:04 +00:00
|
|
|
(i==core->flags->space_idx)?'*':' ',
|
|
|
|
core->flags->spaces[i]);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2013-02-27 00:40:26 +00:00
|
|
|
if (core->flags->spaces[9]) {
|
2011-06-04 01:14:04 +00:00
|
|
|
if (option == j) {
|
|
|
|
fs = "*";
|
|
|
|
hit = 1;
|
|
|
|
}
|
|
|
|
r_cons_printf (" %c %02d %c %s\n",
|
2012-07-22 08:00:35 +00:00
|
|
|
(option==j)?'>':' ', j,
|
2011-06-04 01:14:04 +00:00
|
|
|
(i==core->flags->space_idx)?'*':' ',
|
|
|
|
"*");
|
|
|
|
}
|
|
|
|
if (!hit && j>0) {
|
|
|
|
option = j-1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2013-04-01 03:28:34 +00:00
|
|
|
r_cons_visual_flush ();
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_readchar ();
|
2014-02-08 11:09:12 +00:00
|
|
|
if (ch==-1||ch==4) return R_FALSE;
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_arrow_to_hjkl (ch); // get ESC+char, return 'hjkl' char
|
|
|
|
switch (ch) {
|
2013-09-23 22:43:31 +00:00
|
|
|
case 'J': option += 10; break;
|
|
|
|
case 'o': r_flag_sort (core->flags, 0); break;
|
|
|
|
case 'n': r_flag_sort (core->flags, 1); break;
|
|
|
|
case 'j': option++; break;
|
|
|
|
case 'k': if (--option<0) option = 0; break;
|
|
|
|
case 'K': option-=10; if (option<0) option = 0; break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case 'h':
|
|
|
|
case 'b': // back
|
2013-04-02 20:36:07 +00:00
|
|
|
case 'q':
|
|
|
|
if (menu<=0) return R_TRUE; menu--;
|
2011-06-04 01:14:04 +00:00
|
|
|
option = _option;
|
2013-09-21 15:50:09 +00:00
|
|
|
if (menu==0) {
|
|
|
|
// if no flagspaces, just quit
|
|
|
|
for (j=i=0;i<R_FLAG_SPACES_MAX;i++)
|
|
|
|
if (core->flags->spaces[i])
|
|
|
|
j = 1;
|
|
|
|
if (!j) return R_TRUE;
|
|
|
|
}
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'a':
|
|
|
|
switch (menu) {
|
|
|
|
case 0: // new flag space
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_line_set_prompt ("add flagspace: ");
|
|
|
|
strcpy (cmd, "fs ");
|
|
|
|
if (r_cons_fgets (cmd+3, sizeof (cmd)-4, 0, NULL) > 0) {
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 1: // new flag
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_line_set_prompt ("add flag: ");
|
|
|
|
strcpy (cmd, "f ");
|
|
|
|
if (r_cons_fgets (cmd+2, sizeof (cmd)-3, 0, NULL) > 0) {
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
r_flag_unset (core->flags, fs2, NULL);
|
|
|
|
break;
|
|
|
|
case 'e':
|
|
|
|
/* TODO: prompt for addr, size, name */
|
|
|
|
eprintf ("TODO\n");
|
|
|
|
r_sys_sleep (1);
|
|
|
|
break;
|
|
|
|
case '*':
|
|
|
|
r_core_block_size (core, core->blocksize+16);
|
|
|
|
break;
|
|
|
|
case '/':
|
|
|
|
r_core_block_size (core, core->blocksize-16);
|
|
|
|
break;
|
2013-09-21 15:50:09 +00:00
|
|
|
case '+':
|
|
|
|
if (menu==1)
|
|
|
|
r_core_cmdf (core, "f %s=%s+1", fs2, fs2);
|
|
|
|
else r_core_block_size (core, core->blocksize+1);
|
|
|
|
break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case '-':
|
2013-09-21 15:50:09 +00:00
|
|
|
if (menu==1)
|
|
|
|
r_core_cmdf (core, "f %s=%s-1", fs2, fs2);
|
|
|
|
else r_core_block_size (core, core->blocksize-1);
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
2014-10-21 23:01:38 +00:00
|
|
|
case 'r': // "Vtr"
|
2011-06-04 01:14:04 +00:00
|
|
|
if (menu == 1) {
|
|
|
|
int len;
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_set_raw (0);
|
|
|
|
// TODO: use r_flag_rename or wtf?..fr doesnt uses this..
|
|
|
|
snprintf (cmd, sizeof (cmd), "fr %s ", fs2);
|
|
|
|
len = strlen (cmd);
|
|
|
|
eprintf ("Rename flag '%s' as:\n", fs2);
|
|
|
|
r_line_set_prompt (":> ");
|
|
|
|
if (r_cons_fgets (cmd+len, sizeof (cmd)-len-1, 0, NULL) <0)
|
|
|
|
cmd[0]='\0';
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
break;
|
2012-02-27 02:35:00 +00:00
|
|
|
case 'R':
|
|
|
|
if (menu == 1) {
|
|
|
|
char line[1024];
|
|
|
|
r_cons_show_cursor (R_TRUE);
|
|
|
|
r_cons_set_raw (0);
|
|
|
|
eprintf ("Rename function '%s' as:\n", fs2);
|
|
|
|
r_line_set_prompt (":> ");
|
|
|
|
if (r_cons_fgets (line, sizeof (line), 0, NULL) <0)
|
|
|
|
cmd[0]='\0';
|
|
|
|
snprintf (cmd, sizeof (cmd), "afr %s %s", line, fs2);
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
r_cons_set_raw (1);
|
|
|
|
r_cons_show_cursor (R_FALSE);
|
|
|
|
}
|
|
|
|
break;
|
2013-09-23 22:43:31 +00:00
|
|
|
case 'P': if (--format<0) format = MAX_FORMAT; break;
|
|
|
|
// = (format<=0)? MAX_FORMAT: format-1; break;
|
|
|
|
case 'p': format++; break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case 'l':
|
|
|
|
case ' ':
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
if (menu == 1) {
|
|
|
|
sprintf (cmd, "s %s", fs2);
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
return R_TRUE;
|
|
|
|
}
|
|
|
|
r_flag_space_set (core->flags, fs);
|
|
|
|
menu = 1;
|
|
|
|
_option = option;
|
|
|
|
option = 0;
|
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
r_cons_clear00 ();
|
|
|
|
r_cons_printf (
|
|
|
|
"\nVt: Visual Track help:\n\n"
|
|
|
|
" q - quit menu\n"
|
|
|
|
" j/k - down/up keys\n"
|
|
|
|
" h/b - go back\n"
|
|
|
|
" l/' ' - accept current selection\n"
|
|
|
|
" a/d/e - add/delete/edit flag\n"
|
|
|
|
" +/- - increase/decrease block size\n"
|
|
|
|
" o - sort flags by offset\n"
|
2012-02-27 02:35:00 +00:00
|
|
|
" r/R - rename flag / Rename function\n"
|
2011-06-04 01:14:04 +00:00
|
|
|
" n - sort flags by name\n"
|
|
|
|
" p/P - rotate print format\n"
|
|
|
|
" : - enter command\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
|
|
|
case ':':
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_set_raw (0);
|
|
|
|
cmd[0]='\0';
|
|
|
|
r_line_set_prompt (":> ");
|
|
|
|
if (r_cons_fgets (cmd, sizeof (cmd)-1, 0, NULL) <0)
|
|
|
|
cmd[0]='\0';
|
|
|
|
//line[strlen(line)-1]='\0';
|
|
|
|
r_core_cmd (core, cmd, 1);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
if (cmd[0])
|
|
|
|
r_cons_any_key ();
|
|
|
|
//cons_gotoxy(0,0);
|
|
|
|
r_cons_clear ();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return R_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-11-23 01:29:09 +00:00
|
|
|
R_API int r_core_visual_comments (RCore *core) {
|
2014-03-12 01:44:49 +00:00
|
|
|
char cmd[512], *p = NULL;
|
2011-11-23 01:29:09 +00:00
|
|
|
int mode = 0;
|
|
|
|
int delta = 7;
|
|
|
|
int i, ch, option = 0;
|
|
|
|
int format = 0;
|
2011-11-24 08:50:40 +00:00
|
|
|
int found = 0;
|
2012-02-12 22:45:04 +00:00
|
|
|
ut64 from = 0, size = 0;
|
2011-11-23 01:29:09 +00:00
|
|
|
|
2013-04-16 01:24:47 +00:00
|
|
|
// XXX: mode is always 0, remove useless code
|
2011-11-23 01:29:09 +00:00
|
|
|
for (;;) {
|
2014-09-12 17:25:42 +00:00
|
|
|
r_cons_clear00 ();
|
2013-09-23 22:43:31 +00:00
|
|
|
r_cons_strcat ("Comments:\n");
|
2011-11-23 01:29:09 +00:00
|
|
|
i = 0;
|
2011-11-24 08:50:40 +00:00
|
|
|
found = 0;
|
|
|
|
mode = 0;
|
2014-03-12 01:44:49 +00:00
|
|
|
#undef DB
|
|
|
|
#define DB core->anal->sdb_meta
|
|
|
|
ut64 addr;
|
|
|
|
char key[128];
|
2014-03-30 00:38:38 +00:00
|
|
|
const char *val, *comma = NULL;
|
2014-03-12 01:44:49 +00:00
|
|
|
char *list = sdb_get (DB, "meta.C", 0);
|
|
|
|
char *str, *next, *cur = list;
|
|
|
|
if (list) {
|
|
|
|
for (i=0; ;i++) {
|
2014-03-26 03:16:03 +00:00
|
|
|
cur = sdb_anext (cur, &next);
|
2014-03-12 01:44:49 +00:00
|
|
|
addr = sdb_atoi (cur);
|
|
|
|
snprintf (key, sizeof (key)-1, "meta.C.0x%08"PFMT64x, addr);
|
|
|
|
val = sdb_const_get (DB, key, 0);
|
2014-03-30 00:38:38 +00:00
|
|
|
if (val)
|
|
|
|
comma = strchr (val, ',');
|
2014-03-12 01:44:49 +00:00
|
|
|
if (comma) {
|
|
|
|
str = (char *)sdb_decode (comma+1, 0);
|
|
|
|
if ((i>=option-delta) && ((i<option+delta)||((option<delta)&&(i<(delta<<1))))) {
|
|
|
|
r_str_sanitize (str);
|
|
|
|
if (option==i) {
|
|
|
|
mode = 0;
|
|
|
|
found = 1;
|
|
|
|
from = addr;
|
|
|
|
size = 1; // XXX: remove this thing size for comments is useless d->size;
|
|
|
|
free (p);
|
|
|
|
p = str;
|
|
|
|
r_cons_printf (" > %s\n", str);
|
|
|
|
} else {
|
|
|
|
r_cons_printf (" %s\n", str);
|
|
|
|
free (str);
|
|
|
|
}
|
|
|
|
} else free (str);
|
|
|
|
}
|
|
|
|
if (!next)
|
|
|
|
break;
|
|
|
|
cur = next;
|
2011-11-23 01:29:09 +00:00
|
|
|
}
|
|
|
|
}
|
2014-05-03 00:11:05 +00:00
|
|
|
|
2011-11-24 08:50:40 +00:00
|
|
|
if (!found) {
|
|
|
|
option--;
|
2013-04-23 22:16:35 +00:00
|
|
|
if (option<0) break;
|
2011-11-24 08:50:40 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-04-16 01:24:47 +00:00
|
|
|
r_cons_newline ();
|
|
|
|
#if 0
|
2011-11-23 01:29:09 +00:00
|
|
|
r_list_foreach (core->anal->fcns, iter, fcn) {
|
|
|
|
if ((i>=option-delta) && ((i<option+delta)||((option<delta)&&(i<(delta<<1))))) {
|
|
|
|
if (option==i) {
|
|
|
|
mode = 1;
|
|
|
|
from = fcn->addr;
|
|
|
|
size = fcn->size;
|
|
|
|
}
|
2013-04-16 01:24:47 +00:00
|
|
|
r_cons_printf(" %c .. %s\n", (option==i)?'>':' ', fcn->name);
|
2011-11-23 01:29:09 +00:00
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
2013-04-16 01:24:47 +00:00
|
|
|
#endif
|
2011-11-23 01:29:09 +00:00
|
|
|
|
|
|
|
switch (format) {
|
2012-06-26 13:21:48 +00:00
|
|
|
case 0: sprintf (cmd, "px @ 0x%"PFMT64x":64", from); core->printidx = 0; break;
|
|
|
|
case 1: sprintf (cmd, "pd 12 @ 0x%"PFMT64x":64", from); core->printidx = 1; break;
|
|
|
|
case 2: sprintf (cmd, "ps @ 0x%"PFMT64x":64", from); core->printidx = 5; break;
|
|
|
|
default: format = 0; continue;
|
2011-11-23 01:29:09 +00:00
|
|
|
}
|
|
|
|
if (*cmd) r_core_cmd (core, cmd, 0);
|
|
|
|
|
2013-04-01 03:28:34 +00:00
|
|
|
r_cons_visual_flush ();
|
2011-11-23 01:29:09 +00:00
|
|
|
ch = r_cons_readchar ();
|
|
|
|
ch = r_cons_arrow_to_hjkl (ch); // get ESC+char, return 'hjkl' char
|
|
|
|
switch (ch) {
|
|
|
|
case 'a':
|
|
|
|
//TODO
|
|
|
|
break;
|
|
|
|
case 'e':
|
|
|
|
//TODO
|
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
if (mode == 0) {
|
2014-01-23 02:28:25 +00:00
|
|
|
if (p) r_meta_del (core->anal, R_META_TYPE_ANY, from, size, p);
|
2011-11-23 01:29:09 +00:00
|
|
|
} else {
|
2012-09-28 00:20:52 +00:00
|
|
|
r_anal_fcn_del_locs (core->anal, from);
|
2011-11-23 01:29:09 +00:00
|
|
|
r_anal_fcn_del (core->anal, from);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'P':
|
|
|
|
if (--format<0)
|
|
|
|
format = MAX_FORMAT;
|
|
|
|
break;
|
|
|
|
case 'p':
|
|
|
|
format++;
|
|
|
|
break;
|
|
|
|
case 'J':
|
|
|
|
option += 10;
|
|
|
|
break;
|
|
|
|
case 'j':
|
|
|
|
option++;
|
|
|
|
break;
|
|
|
|
case 'k':
|
|
|
|
if (--option<0)
|
|
|
|
option = 0;
|
|
|
|
break;
|
|
|
|
case 'K':
|
|
|
|
option-=10;
|
|
|
|
if (option<0)
|
|
|
|
option = 0;
|
|
|
|
break;
|
|
|
|
case 'l':
|
|
|
|
case ' ':
|
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
sprintf (cmd, "s 0x%"PFMT64x, from);
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
if (p)
|
|
|
|
free (p);
|
|
|
|
return R_TRUE;
|
|
|
|
case 'q':
|
|
|
|
if (p)
|
|
|
|
free (p);
|
|
|
|
return R_TRUE;
|
2011-11-24 08:50:40 +00:00
|
|
|
case '?':
|
2011-11-23 01:29:09 +00:00
|
|
|
case 'h':
|
|
|
|
r_cons_clear00 ();
|
|
|
|
r_cons_printf (
|
|
|
|
"\nVT: Visual Comments/Anal help:\n\n"
|
|
|
|
" q - quit menu\n"
|
|
|
|
" j/k - down/up keys\n"
|
|
|
|
" h/b - go back\n"
|
|
|
|
" l/' ' - accept current selection\n"
|
|
|
|
" a/d/e - add/delete/edit comment/anal symbol\n"
|
|
|
|
" p/P - rotate print format\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (p) {
|
|
|
|
free (p);
|
|
|
|
p = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return R_TRUE;
|
|
|
|
}
|
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
static void config_visual_hit_i(RCore *core, const char *name, int delta) {
|
|
|
|
struct r_config_node_t *node;
|
|
|
|
node = r_config_node_get (core->config, name);
|
|
|
|
if (node && ((node->flags & CN_INT) || (node->flags & CN_OFFT)))
|
|
|
|
r_config_set_i(core->config, name, r_config_get_i(core->config, name)+delta);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Visually activate the config variable */
|
|
|
|
static void config_visual_hit(RCore *core, const char *name, int editor) {
|
|
|
|
char buf[1024];
|
|
|
|
RConfigNode *node;
|
|
|
|
|
|
|
|
if (!(node = r_config_node_get (core->config, name)))
|
|
|
|
return;
|
|
|
|
if (node->flags & CN_BOOL) {
|
2013-04-01 03:28:34 +00:00
|
|
|
r_config_set_i (core->config, name, node->i_value? 0:1);
|
2011-06-04 01:14:04 +00:00
|
|
|
} else {
|
2013-04-01 03:28:34 +00:00
|
|
|
// XXX: must use config_set () to run callbacks!
|
2011-06-04 01:14:04 +00:00
|
|
|
if (editor) {
|
|
|
|
char * buf = r_core_editor (core, node->value);
|
|
|
|
node->value = r_str_dup (node->value, buf);
|
|
|
|
free (buf);
|
|
|
|
} else {
|
|
|
|
// FGETS AND SO
|
|
|
|
r_cons_printf ("New value (old=%s): \n", node->value);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_set_raw (0);
|
|
|
|
r_line_set_prompt (":> ");
|
|
|
|
r_cons_fgets (buf, sizeof (buf)-1, 0, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2013-04-01 03:28:34 +00:00
|
|
|
r_config_set (core->config, name, buf);
|
|
|
|
//node->value = r_str_dup (node->value, buf);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_visual_config(RCore *core) {
|
2014-09-12 17:25:42 +00:00
|
|
|
char cmd[1024], *fs = NULL, *fs2 = NULL, *desc = NULL;
|
2013-09-23 22:43:31 +00:00
|
|
|
int i, j, ch, hit, show;
|
|
|
|
int option, _option = 0;
|
2011-06-04 01:14:04 +00:00
|
|
|
RListIter *iter;
|
|
|
|
RConfigNode *bt;
|
2013-09-23 22:43:31 +00:00
|
|
|
char old[1024];
|
2011-06-04 01:14:04 +00:00
|
|
|
int delta = 9;
|
|
|
|
int menu = 0;
|
|
|
|
old[0]='\0';
|
|
|
|
|
2012-06-26 13:21:48 +00:00
|
|
|
option = 0;
|
2011-06-04 01:14:04 +00:00
|
|
|
for (;;) {
|
2014-09-12 17:25:42 +00:00
|
|
|
r_cons_clear00 ();
|
2011-06-04 01:14:04 +00:00
|
|
|
|
|
|
|
switch (menu) {
|
|
|
|
case 0: // flag space
|
|
|
|
r_cons_printf ("\n Eval spaces:\n\n");
|
2013-04-02 20:36:07 +00:00
|
|
|
hit = j = i = 0;
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach (core->config->nodes, iter, bt) {
|
|
|
|
if (option==i) {
|
|
|
|
fs = bt->name;
|
|
|
|
}
|
|
|
|
if (old[0]=='\0') {
|
|
|
|
r_str_ccpy (old, bt->name, '.');
|
|
|
|
show = 1;
|
|
|
|
} else if (r_str_ccmp (old, bt->name, '.')) {
|
|
|
|
r_str_ccpy (old, bt->name, '.');
|
|
|
|
show = 1;
|
|
|
|
} else show = 0;
|
|
|
|
|
|
|
|
if (show) {
|
2013-04-02 20:36:07 +00:00
|
|
|
if (option == i) hit = 1;
|
|
|
|
if ( (i >=option-delta) && ((i<option+delta)||((option<delta)&&(i<(delta<<1))))) {
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_printf(" %c %s\n", (option==i)?'>':' ', old);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!hit && j>0) {
|
2013-04-02 20:36:07 +00:00
|
|
|
option--;
|
2011-06-04 01:14:04 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
r_cons_printf ("\n Sel:%s \n\n", fs);
|
|
|
|
break;
|
|
|
|
case 1: // flag selection
|
|
|
|
r_cons_printf ("\n Eval variables: (%s)\n\n", fs);
|
|
|
|
hit = 0;
|
|
|
|
j = i = 0;
|
|
|
|
// TODO: cut -d '.' -f 1 | sort | uniq !!!
|
|
|
|
r_list_foreach (core->config->nodes, iter, bt) {
|
|
|
|
if (!r_str_ccmp (bt->name, fs, '.')) {
|
2014-09-12 17:25:42 +00:00
|
|
|
if (option==i) {
|
|
|
|
fs2 = bt->name;
|
2014-09-12 17:25:42 +00:00
|
|
|
desc = bt->desc;
|
2014-09-12 17:25:42 +00:00
|
|
|
hit = 1;
|
|
|
|
}
|
2011-06-04 01:14:04 +00:00
|
|
|
if ( (i>=option-delta) && ((i<option+delta)||((option<delta)&&(i<(delta<<1))))) {
|
|
|
|
// TODO: Better align
|
|
|
|
r_cons_printf (" %c %s = %s\n", (option==i)?'>':' ', bt->name, bt->value);
|
|
|
|
j++;
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!hit && j>0) {
|
|
|
|
option = i-1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (fs2 != NULL)
|
2014-09-12 17:25:42 +00:00
|
|
|
// TODO: Break long lines.
|
|
|
|
r_cons_printf ("\n Selected: %s (%s)\n\n",
|
|
|
|
fs2, desc);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
|
2012-06-26 13:21:48 +00:00
|
|
|
if (fs && !memcmp (fs, "asm.", 4))
|
2011-06-04 01:14:04 +00:00
|
|
|
r_core_cmd (core, "pd 5", 0);
|
2013-04-01 03:28:34 +00:00
|
|
|
r_cons_visual_flush ();
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_readchar ();
|
2014-02-08 11:09:12 +00:00
|
|
|
if (ch==4||ch==-1)
|
|
|
|
return;
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_arrow_to_hjkl (ch); // get ESC+char, return 'hjkl' char
|
|
|
|
|
|
|
|
switch (ch) {
|
2013-09-23 22:43:31 +00:00
|
|
|
case 'j': option++; break;
|
|
|
|
case 'k': option = (option<=0)? 0: option-1; break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case 'h':
|
|
|
|
case 'b': // back
|
|
|
|
menu = 0;
|
|
|
|
option = _option;
|
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
if (menu<=0) return; menu--;
|
|
|
|
break;
|
|
|
|
case '*':
|
|
|
|
case '+':
|
|
|
|
if (fs2 != NULL)
|
|
|
|
config_visual_hit_i (core, fs2, +1);
|
|
|
|
continue;
|
|
|
|
case '/':
|
|
|
|
case '-':
|
|
|
|
if (fs2 != NULL)
|
|
|
|
config_visual_hit_i (core, fs2, -1);
|
|
|
|
continue;
|
|
|
|
case 'l':
|
|
|
|
case 'E': // edit value
|
|
|
|
case 'e': // edit value
|
|
|
|
case ' ':
|
|
|
|
case '\r':
|
|
|
|
case '\n': // never happens
|
|
|
|
if (menu == 1) {
|
|
|
|
if (fs2 != NULL)
|
|
|
|
config_visual_hit (core, fs2, (ch=='E'));
|
|
|
|
} else {
|
|
|
|
menu = 1;
|
|
|
|
_option = option;
|
|
|
|
option = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case '?':
|
|
|
|
r_cons_clear00 ();
|
2013-09-23 22:43:31 +00:00
|
|
|
r_cons_printf ("\nVe: Visual Eval help:\n\n"
|
|
|
|
" q - quit menu\n"
|
|
|
|
" j/k - down/up keys\n"
|
|
|
|
" h/b - go back\n"
|
|
|
|
" e/' ' - edit/toggle current variable\n"
|
|
|
|
" E - edit variable with 'cfg.editor' (vi?)\n"
|
2014-09-12 17:25:42 +00:00
|
|
|
" +/- - increase/decrease numeric value (* and /, too)\n"
|
2013-09-23 22:43:31 +00:00
|
|
|
" : - enter command\n");
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
|
|
|
case ':':
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_set_raw(0);
|
|
|
|
/* WTF READLINE?? WE DONT USE THAT!! */
|
|
|
|
#if HAVE_LIB_READLINE
|
|
|
|
{
|
|
|
|
char *ptr = readline(VISUAL_PROMPT);
|
|
|
|
if (ptr) {
|
2011-09-18 18:41:36 +00:00
|
|
|
strncpy(cmd, ptr, sizeof (cmd)-1);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_core_cmd(core, cmd, 1);
|
|
|
|
free(ptr);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
*cmd = '\0';
|
|
|
|
if (r_cons_fgets (cmd, sizeof (cmd)-1, 0, NULL) <0)
|
|
|
|
cmd[0]='\0';
|
|
|
|
//line[strlen(line)-1]='\0';
|
|
|
|
r_core_cmd (core, cmd, 1);
|
|
|
|
#endif
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
if (cmd[0])
|
|
|
|
r_cons_any_key ();
|
|
|
|
r_cons_clear00 ();
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-11 20:52:05 +00:00
|
|
|
R_API void r_core_visual_mounts (RCore *core) {
|
|
|
|
RList *list;
|
2013-04-24 15:13:52 +00:00
|
|
|
RFSRoot *fsroot;
|
2011-07-11 20:52:05 +00:00
|
|
|
RListIter *iter;
|
|
|
|
RFSFile *file;
|
2011-07-13 16:55:16 +00:00
|
|
|
RFSPartition *part;
|
2011-07-12 15:26:56 +00:00
|
|
|
int i, ch, option, mode, partition, dir, delta = 7;
|
|
|
|
char *str, path[4096], buf[1024], *root = NULL;
|
2011-07-11 20:52:05 +00:00
|
|
|
const char *n, *p;
|
|
|
|
|
|
|
|
dir = partition = option = mode = 0;
|
|
|
|
for (;;) {
|
|
|
|
/* Clear */
|
2014-09-12 17:25:42 +00:00
|
|
|
r_cons_clear00 ();
|
2011-07-11 20:52:05 +00:00
|
|
|
|
|
|
|
/* Show */
|
|
|
|
if (mode == 0) {
|
2014-11-03 03:05:19 +00:00
|
|
|
r_cons_printf ("Press '/' to navigate the root filesystem.\nPartitions:\n\n");
|
2011-07-11 20:52:05 +00:00
|
|
|
n = r_fs_partition_type_get (partition);
|
|
|
|
list = r_fs_partitions (core->fs, n, 0);
|
|
|
|
i = 0;
|
|
|
|
if (list) {
|
|
|
|
r_list_foreach (list, iter, part) {
|
2011-07-12 15:26:56 +00:00
|
|
|
if ((option-delta <= i) && (i <= option+delta)) {
|
2011-07-13 16:55:16 +00:00
|
|
|
if (option == i)
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf (" > ");
|
2011-07-13 16:55:16 +00:00
|
|
|
else r_cons_printf (" ");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf ("%d %02x 0x%010"PFMT64x" 0x%010"PFMT64x"\n",
|
|
|
|
part->number, part->type,
|
|
|
|
part->start, part->start+part->length);
|
2011-07-11 20:52:05 +00:00
|
|
|
}
|
2011-07-12 15:26:56 +00:00
|
|
|
i++;
|
2011-07-11 20:52:05 +00:00
|
|
|
}
|
|
|
|
r_list_free (list);
|
|
|
|
} else r_cons_printf ("Cannot read partition\n");
|
|
|
|
} else if (mode == 1) {
|
|
|
|
r_cons_printf ("Types:\n\n");
|
|
|
|
for(i=0;;i++) {
|
|
|
|
n = r_fs_partition_type_get (i);
|
|
|
|
if (!n) break;
|
|
|
|
r_cons_printf ("%s%s\n", (i==partition)?" > ":" ", n);
|
|
|
|
}
|
2013-04-24 15:13:52 +00:00
|
|
|
} else if (mode == 3) {
|
|
|
|
i = 0;
|
|
|
|
r_cons_printf ("Mountpoints:\n\n");
|
|
|
|
r_list_foreach (core->fs->roots, iter, fsroot) {
|
|
|
|
if ((option-delta <= i) && (i <= option+delta)) {
|
|
|
|
r_cons_printf ("%s %s\n", (option == i)?" > ":" ",
|
|
|
|
fsroot->path);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
2011-07-11 20:52:05 +00:00
|
|
|
} else {
|
|
|
|
if (root) {
|
|
|
|
list = r_fs_dir (core->fs, path);
|
|
|
|
if (list) {
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf ("%s:\n\n", path);
|
2011-07-11 20:52:05 +00:00
|
|
|
i = 0;
|
|
|
|
r_list_foreach (list, iter, file) {
|
2011-07-12 15:26:56 +00:00
|
|
|
if ((dir-delta <= i) && (i <= dir+delta)) {
|
|
|
|
r_cons_printf ("%s%c %s\n", (dir == i)?" > ":" ",
|
|
|
|
file->type, file->name);
|
|
|
|
}
|
|
|
|
i++;
|
2011-07-11 20:52:05 +00:00
|
|
|
}
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf ("\n");
|
2011-07-11 20:52:05 +00:00
|
|
|
r_list_free (list);
|
|
|
|
} else r_cons_printf ("Cannot open '%s' directory\n", root);
|
|
|
|
} else r_cons_printf ("Root undefined\n");
|
|
|
|
}
|
2011-07-12 15:26:56 +00:00
|
|
|
if (mode==2) {
|
|
|
|
r_str_chop_path (path);
|
|
|
|
str = path + strlen (path);
|
2011-09-18 18:41:36 +00:00
|
|
|
strncat (path, "/", sizeof (path)-strlen (path)-1);
|
2011-07-12 15:26:56 +00:00
|
|
|
list = r_fs_dir (core->fs, path);
|
|
|
|
file = r_list_get_n (list, dir);
|
2011-07-13 16:55:16 +00:00
|
|
|
if (file && file->type != 'd')
|
2013-07-01 14:29:47 +00:00
|
|
|
r_core_cmdf (core, "px @ 0x%"PFMT64x"!64", file->off);
|
2011-07-12 15:26:56 +00:00
|
|
|
*str='\0';
|
|
|
|
}
|
2011-07-11 20:52:05 +00:00
|
|
|
r_cons_flush ();
|
|
|
|
|
|
|
|
/* Ask for option */
|
|
|
|
ch = r_cons_readchar ();
|
2014-02-26 17:45:59 +00:00
|
|
|
if (ch==-1||ch==4) return;
|
2011-07-11 20:52:05 +00:00
|
|
|
ch = r_cons_arrow_to_hjkl (ch);
|
|
|
|
switch (ch) {
|
2014-11-03 03:05:19 +00:00
|
|
|
case '/':
|
|
|
|
root = strdup ("/");
|
|
|
|
strncpy (path, root, sizeof (path)-1);
|
|
|
|
mode = 2;
|
|
|
|
break;
|
2011-07-12 15:26:56 +00:00
|
|
|
case 'l':
|
2011-07-11 20:52:05 +00:00
|
|
|
case '\r':
|
|
|
|
case '\n':
|
|
|
|
if (mode == 0) {
|
|
|
|
n = r_fs_partition_type_get (partition);
|
|
|
|
list = r_fs_partitions (core->fs, n, 0);
|
|
|
|
if (!list) {
|
|
|
|
r_cons_printf ("Unknown partition\n");
|
|
|
|
r_cons_any_key ();
|
|
|
|
r_cons_flush ();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
part = r_list_get_n (list, option);
|
|
|
|
if (!part) {
|
|
|
|
r_cons_printf ("Unknown partition\n");
|
|
|
|
r_cons_any_key ();
|
|
|
|
r_cons_flush ();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
p = r_fs_partition_type (n, part->type);
|
|
|
|
if (p) {
|
|
|
|
if (r_fs_mount (core->fs, p, "/root", part->start)) {
|
|
|
|
if (root)
|
|
|
|
free (root);
|
|
|
|
root = strdup ("/root");
|
2011-09-18 18:41:36 +00:00
|
|
|
strncpy (path, root, sizeof (path)-1);
|
2011-07-11 20:52:05 +00:00
|
|
|
mode = 2;
|
|
|
|
} else {
|
|
|
|
r_cons_printf ("Cannot mount partition\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
r_cons_printf ("Unknown partition type\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
}
|
|
|
|
} else if (mode == 2){
|
|
|
|
r_str_chop_path (path);
|
2011-09-18 18:41:36 +00:00
|
|
|
strncat (path, "/", sizeof (path)-strlen (path)-1);
|
2011-07-11 20:52:05 +00:00
|
|
|
list = r_fs_dir (core->fs, path);
|
|
|
|
file = r_list_get_n (list, dir);
|
|
|
|
if (file) {
|
|
|
|
if (file->type == 'd') {
|
2011-09-18 18:41:36 +00:00
|
|
|
strncat (path, file->name, sizeof (path)-strlen (path)-1);
|
2011-07-11 20:52:05 +00:00
|
|
|
r_str_chop_path (path);
|
|
|
|
if (memcmp (root, path, strlen (root)-1))
|
2011-09-18 18:41:36 +00:00
|
|
|
strncpy (path, root, sizeof (path)-1);
|
2011-07-12 15:26:56 +00:00
|
|
|
} else {
|
|
|
|
r_core_cmdf (core, "s 0x%"PFMT64x, file->off);
|
2011-07-11 20:52:05 +00:00
|
|
|
r_fs_umount (core->fs, root);
|
2014-05-03 00:11:05 +00:00
|
|
|
free (root);
|
2011-07-11 20:52:05 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
r_cons_printf ("Unknown file\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
}
|
2013-04-24 15:13:52 +00:00
|
|
|
|
|
|
|
} else if (mode == 3) {
|
|
|
|
fsroot = r_list_get_n (core->fs->roots, option);
|
2014-02-26 17:45:59 +00:00
|
|
|
if (fsroot) {
|
|
|
|
root = strdup (fsroot->path);
|
|
|
|
strncpy (path, root, sizeof (path)-1);
|
|
|
|
}
|
2013-04-24 15:13:52 +00:00
|
|
|
mode = 2;
|
2011-07-11 20:52:05 +00:00
|
|
|
}
|
2011-07-12 15:26:56 +00:00
|
|
|
dir = partition = option = 0;
|
2011-07-11 20:52:05 +00:00
|
|
|
break;
|
|
|
|
case 'k':
|
2013-04-24 15:13:52 +00:00
|
|
|
if (mode == 0 || mode == 3) {
|
2011-07-11 20:52:05 +00:00
|
|
|
if (option > 0)
|
|
|
|
option--;
|
|
|
|
} else if (mode == 1) {
|
|
|
|
if (partition > 0)
|
|
|
|
partition--;
|
|
|
|
} else {
|
|
|
|
if (dir>0)
|
|
|
|
dir--;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'j':
|
|
|
|
if (mode == 0) {
|
|
|
|
n = r_fs_partition_type_get (partition);
|
|
|
|
list = r_fs_partitions (core->fs, n, 0);
|
|
|
|
if (option < r_list_length (list)-1)
|
|
|
|
option++;
|
|
|
|
} else if (mode == 1) {
|
|
|
|
if (partition < r_fs_partition_get_size ()-1)
|
|
|
|
partition++;
|
2013-04-24 15:13:52 +00:00
|
|
|
} else if (mode == 3) {
|
|
|
|
if (option < r_list_length (core->fs->roots)-1)
|
|
|
|
option++;
|
2011-07-11 20:52:05 +00:00
|
|
|
} else {
|
2011-07-12 15:26:56 +00:00
|
|
|
list = r_fs_dir (core->fs, path);
|
|
|
|
if (dir < r_list_length (list)-1)
|
|
|
|
dir++;
|
2011-07-11 20:52:05 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 't':
|
|
|
|
mode = 1;
|
|
|
|
break;
|
2011-07-12 15:26:56 +00:00
|
|
|
case 'h':
|
|
|
|
if (mode == 2) {
|
2014-02-26 17:45:59 +00:00
|
|
|
if (!root) {
|
|
|
|
mode = 0;
|
2014-09-26 13:40:17 +00:00
|
|
|
} else
|
2011-07-12 15:26:56 +00:00
|
|
|
if (strcmp (path, root)) {
|
|
|
|
strcat (path, "/..");
|
|
|
|
r_str_chop_path (path);
|
|
|
|
} else {
|
|
|
|
r_fs_umount (core->fs, root);
|
|
|
|
mode = 0;
|
|
|
|
}
|
2013-09-23 22:43:31 +00:00
|
|
|
} else if (mode == 1) {
|
2011-07-12 15:26:56 +00:00
|
|
|
mode = 0;
|
2013-09-23 22:43:31 +00:00
|
|
|
} else return;
|
2011-07-12 15:26:56 +00:00
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
if (mode == 2 && root) {
|
2011-07-11 20:52:05 +00:00
|
|
|
r_fs_umount (core->fs, root);
|
2011-07-12 15:26:56 +00:00
|
|
|
mode = 0;
|
|
|
|
} else
|
|
|
|
return;
|
|
|
|
break;
|
|
|
|
case 'g':
|
|
|
|
if (mode == 2){
|
|
|
|
r_str_chop_path (path);
|
|
|
|
str = path + strlen (path);
|
2011-09-18 18:41:36 +00:00
|
|
|
strncat (path, "/", sizeof (path)-strlen (path)-1);
|
2011-07-12 15:26:56 +00:00
|
|
|
list = r_fs_dir (core->fs, path);
|
|
|
|
file = r_list_get_n (list, dir);
|
|
|
|
if (file) {
|
2011-09-18 18:41:36 +00:00
|
|
|
strncat (path, file->name, sizeof (path)-strlen (path)-1);
|
2011-07-12 15:26:56 +00:00
|
|
|
r_str_chop_path (path);
|
|
|
|
if (memcmp (root, path, strlen (root)-1))
|
2011-09-18 18:41:36 +00:00
|
|
|
strncpy (path, root, sizeof (path)-1);
|
2011-07-12 15:26:56 +00:00
|
|
|
file = r_fs_open (core->fs, path);
|
|
|
|
if (file) {
|
|
|
|
r_fs_read (core->fs, file, 0, file->size);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_set_raw (0);
|
|
|
|
r_line_set_prompt ("Dump path (ej: /tmp/file): ");
|
|
|
|
r_cons_fgets (buf, sizeof (buf)-1, 0, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-07-12 15:26:56 +00:00
|
|
|
r_file_dump (buf, file->data, file->size);
|
|
|
|
r_fs_close (core->fs, file);
|
|
|
|
r_cons_printf ("Done\n");
|
2013-09-23 22:43:31 +00:00
|
|
|
} else r_cons_printf ("Cannot dump file\n");
|
|
|
|
} else r_cons_printf ("Cannot dump file\n");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
*str='\0';
|
|
|
|
}
|
2011-07-11 20:52:05 +00:00
|
|
|
break;
|
2013-04-24 15:13:52 +00:00
|
|
|
case 'm':
|
|
|
|
mode = 3;
|
|
|
|
option = 0;
|
|
|
|
break;
|
2011-07-11 20:52:05 +00:00
|
|
|
case '?':
|
|
|
|
r_cons_clear00 ();
|
|
|
|
r_cons_printf ("\nVM: Visual Mount points help:\n\n");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf (" q - go back or quit menu\n");
|
2011-07-11 20:52:05 +00:00
|
|
|
r_cons_printf (" j/k - down/up keys\n");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf (" h/l - forward/go keys\n");
|
2011-07-11 20:52:05 +00:00
|
|
|
r_cons_printf (" t - choose partition type\n");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf (" g - dump file\n");
|
2013-04-24 15:13:52 +00:00
|
|
|
r_cons_printf (" m - show mountpoints\n");
|
2011-07-12 15:26:56 +00:00
|
|
|
r_cons_printf (" : - enter command\n");
|
2011-07-11 20:52:05 +00:00
|
|
|
r_cons_printf (" ? - show this help\n");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
|
|
|
case ':':
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-07-11 20:52:05 +00:00
|
|
|
r_cons_set_raw (0);
|
|
|
|
r_line_set_prompt (":> ");
|
|
|
|
r_cons_fgets (buf, sizeof (buf)-1, 0, 0);
|
|
|
|
r_cons_set_raw (1);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-07-11 20:52:05 +00:00
|
|
|
r_core_cmd (core, buf, 1);
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-07-22 08:00:35 +00:00
|
|
|
static void var_index_show(RAnal *anal, RAnalFunction *fcn, ut64 addr, int idx) {
|
2011-06-04 01:14:04 +00:00
|
|
|
int i = 0;
|
|
|
|
RAnalVar *v;
|
|
|
|
RAnalVarAccess *x;
|
|
|
|
RListIter *iter, *iter2;
|
2014-10-23 07:15:55 +00:00
|
|
|
int window ;
|
|
|
|
|
|
|
|
// Adjust the windows size automaticaly
|
|
|
|
(void)r_cons_get_size (&window);
|
|
|
|
window-=5; // Size of printed things
|
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
int wdelta = (idx>5)?idx-5:0;
|
2013-09-23 22:43:31 +00:00
|
|
|
if (!fcn) return;
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach(fcn->vars, iter, v) {
|
|
|
|
if (addr == 0 || (addr >= v->addr && addr <= v->eaddr)) {
|
|
|
|
if (i>=wdelta) {
|
2013-09-23 22:43:31 +00:00
|
|
|
if (i>window+wdelta) {
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_printf("...\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (idx == i) r_cons_printf (" * ");
|
|
|
|
else r_cons_printf (" ");
|
2013-09-01 23:19:43 +00:00
|
|
|
#if 0
|
|
|
|
if (v->type->type == R_ANAL_TYPE_ARRAY) {
|
|
|
|
eprintf ("TODO: support for arrays\n");
|
2012-07-22 08:00:35 +00:00
|
|
|
r_cons_printf ("0x%08llx - 0x%08llx scope=%s type=%s name=%s delta=%d array=%d\n",
|
|
|
|
v->addr, v->eaddr, r_anal_var_scope_to_str (anal, v->scope),
|
2012-08-29 12:46:19 +00:00
|
|
|
r_anal_type_to_str (anal, v->type, ""),
|
|
|
|
v->name, v->delta, v->type->custom.a->count);
|
2014-05-03 00:11:05 +00:00
|
|
|
} else
|
2013-09-01 23:19:43 +00:00
|
|
|
#endif
|
|
|
|
{
|
|
|
|
char *s = r_anal_type_to_str (anal, v->type);
|
|
|
|
if (!s) s = strdup ("<unk>");
|
2014-04-04 01:42:22 +00:00
|
|
|
r_cons_printf ("0x%08llx - 0x%08llx scope=%d type=%s name=%s delta=%d\n",
|
|
|
|
v->addr, v->eaddr, v->scope, s, v->name, v->delta);
|
2013-09-01 23:19:43 +00:00
|
|
|
free (s);
|
|
|
|
}
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach (v->accesses, iter2, x) {
|
|
|
|
r_cons_printf (" 0x%08llx %s\n", x->addr, x->set?"set":"get");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// helper
|
|
|
|
static void function_rename(RCore *core, ut64 addr, const char *name) {
|
|
|
|
RListIter *iter;
|
2012-07-22 08:00:35 +00:00
|
|
|
RAnalFunction *fcn;
|
2011-06-04 01:14:04 +00:00
|
|
|
|
|
|
|
r_list_foreach (core->anal->fcns, iter, fcn) {
|
|
|
|
if (fcn->addr == addr) {
|
|
|
|
r_flag_unset (core->flags, fcn->name, NULL);
|
|
|
|
free (fcn->name);
|
|
|
|
fcn->name = strdup (name);
|
|
|
|
r_flag_set (core->flags, name, addr, fcn->size, 0);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-23 07:15:55 +00:00
|
|
|
|
|
|
|
// In visual mode, display function list
|
2011-06-04 01:14:04 +00:00
|
|
|
static ut64 var_functions_show(RCore *core, int idx, int show) {
|
|
|
|
int i = 0;
|
|
|
|
ut64 seek = core->offset;
|
|
|
|
ut64 addr = core->offset;
|
2014-10-23 07:15:55 +00:00
|
|
|
int window ;
|
2011-06-04 01:14:04 +00:00
|
|
|
int wdelta = (idx>5)?idx-5:0;
|
|
|
|
RListIter *iter;
|
2012-07-22 08:00:35 +00:00
|
|
|
RAnalFunction *fcn;
|
2011-06-04 01:14:04 +00:00
|
|
|
|
2014-10-23 07:15:55 +00:00
|
|
|
// Adjust the windows size automaticaly
|
|
|
|
(void)r_cons_get_size (&window);
|
|
|
|
window-=5; // Size of printed things
|
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach (core->anal->fcns, iter, fcn) {
|
|
|
|
if (i>=wdelta) {
|
|
|
|
if (i> window+wdelta) {
|
|
|
|
r_cons_printf("...\n");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
//if (seek >= fcn->addr && seek <= fcn->addr+fcn->size)
|
|
|
|
if (idx == i)
|
|
|
|
addr = fcn->addr;
|
|
|
|
if (show)
|
2012-07-22 08:00:35 +00:00
|
|
|
r_cons_printf ("%c%c 0x%08llx (%s)\n",
|
2011-06-04 01:14:04 +00:00
|
|
|
(seek == fcn->addr)?'>':' ',
|
|
|
|
(idx==i)?'*':' ',
|
|
|
|
fcn->addr, fcn->name);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
return addr;
|
|
|
|
}
|
|
|
|
|
2012-06-26 13:21:48 +00:00
|
|
|
static int level = 0;
|
|
|
|
static ut64 addr = 0;
|
|
|
|
static int option = 0;
|
|
|
|
|
2013-09-23 22:43:31 +00:00
|
|
|
static void r_core_visual_anal_refresh_column (RCore *core) {
|
2014-07-02 15:47:44 +00:00
|
|
|
const ut64 addr = level? core->offset: var_functions_show (core, option, 0);
|
2013-09-23 22:43:31 +00:00
|
|
|
r_cons_printf ("Visual code analysis manipulation\n");
|
|
|
|
r_core_cmdf (core, "pd @ 0x%"PFMT64x"!16", addr);
|
|
|
|
}
|
|
|
|
|
2014-09-22 11:45:36 +00:00
|
|
|
static ut64 r_core_visual_anal_refresh (RCore *core) {
|
2013-03-01 11:20:18 +00:00
|
|
|
RAnalFunction *fcn;
|
|
|
|
ut64 addr;
|
2012-06-26 13:21:48 +00:00
|
|
|
char old[1024];
|
2013-09-23 22:43:31 +00:00
|
|
|
int cols = r_cons_get_size (NULL);
|
2013-03-01 11:20:18 +00:00
|
|
|
|
2014-09-22 11:45:36 +00:00
|
|
|
if (!core) return 0LL;
|
2011-06-04 01:14:04 +00:00
|
|
|
old[0]='\0';
|
2013-03-01 11:20:18 +00:00
|
|
|
addr = core->offset;
|
2014-09-26 13:40:17 +00:00
|
|
|
fcn = r_anal_get_fcn_in (core->anal, addr, R_ANAL_FCN_TYPE_NULL);
|
2011-06-04 01:14:04 +00:00
|
|
|
|
2012-06-26 13:21:48 +00:00
|
|
|
cols -= 50;
|
2013-09-23 22:43:31 +00:00
|
|
|
if (cols > 60) cols = 60;
|
2014-08-23 00:27:31 +00:00
|
|
|
|
|
|
|
r_cons_clear00 ();
|
|
|
|
r_cons_flush ();
|
|
|
|
r_core_visual_anal_refresh_column (core);
|
|
|
|
if (cols>30) {
|
2013-09-01 23:19:43 +00:00
|
|
|
r_cons_column (cols);
|
2012-06-26 13:21:48 +00:00
|
|
|
}
|
|
|
|
switch (level) {
|
2014-10-23 07:15:55 +00:00
|
|
|
// Show functions list help in visual mode
|
2012-06-26 13:21:48 +00:00
|
|
|
case 0:
|
|
|
|
r_cons_printf ("-[ functions ]---------------- \n"
|
2013-09-01 23:19:43 +00:00
|
|
|
"(a) add (x)xrefs (q)quit \n"
|
2014-10-23 07:15:55 +00:00
|
|
|
"(m) modify (c)calls (g)go \n"
|
2013-09-01 23:19:43 +00:00
|
|
|
"(d) delete (v)variables (?)help \n");
|
2012-06-26 13:21:48 +00:00
|
|
|
addr = var_functions_show (core, option, 1);
|
|
|
|
break;
|
|
|
|
case 1:
|
2013-09-01 23:19:43 +00:00
|
|
|
r_cons_printf (
|
|
|
|
"-[ variables ]----- 0x%08"PFMT64x"\n"
|
|
|
|
"(a) add (x)xrefs \n"
|
|
|
|
"(m) modify (g)go \n"
|
|
|
|
"(d) delete (q)quit \n", addr);
|
2012-06-26 13:21:48 +00:00
|
|
|
var_index_show (core->anal, fcn, addr, option);
|
|
|
|
break;
|
|
|
|
case 2:
|
2014-08-23 00:27:31 +00:00
|
|
|
r_cons_printf ("Press 'q' to quit call refs\n");
|
2012-06-26 13:21:48 +00:00
|
|
|
r_cons_printf ("-[ calls ]----------------------- 0x%08"PFMT64x" (TODO)\n", addr);
|
2014-08-23 00:27:31 +00:00
|
|
|
// TODO: filter only the callrefs. but we cant grep here
|
|
|
|
sprintf(old, "afi @ 0x%08"PFMT64x, addr);
|
|
|
|
r_core_cmd0 (core, old);
|
2012-06-26 13:21:48 +00:00
|
|
|
break;
|
|
|
|
case 3:
|
2014-08-23 00:27:31 +00:00
|
|
|
r_cons_printf ("Press 'q' to view call refs\n");
|
2012-06-26 13:21:48 +00:00
|
|
|
r_cons_printf ("-[ xrefs ]----------------------- 0x%08"PFMT64x"\n", addr);
|
2014-08-23 00:27:31 +00:00
|
|
|
//sprintf (old, "axl~0x%08"PFMT64x, addr);
|
|
|
|
r_core_cmd0 (core, "pd 1");
|
|
|
|
//r_core_cmd0 (core, old);
|
2012-06-26 13:21:48 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
r_cons_flush ();
|
2014-09-22 11:45:36 +00:00
|
|
|
return addr;
|
2012-06-26 13:21:48 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Like emenu but for real */
|
|
|
|
R_API void r_core_visual_anal(RCore *core) {
|
|
|
|
char old[218];
|
2013-09-23 22:43:31 +00:00
|
|
|
int ch, _option = 0;
|
|
|
|
RConsEvent olde = core->cons->event_resize;
|
|
|
|
core->cons->event_resize = (RConsEvent) r_core_visual_anal_refresh;
|
2012-06-26 13:21:48 +00:00
|
|
|
level = 0;
|
|
|
|
addr = core->offset;
|
|
|
|
|
2014-08-23 00:27:31 +00:00
|
|
|
int asmbytes = r_config_get_i (core->config, "asm.bytes");
|
|
|
|
r_config_set_i (core->config, "asm.bytes", 0);
|
2012-06-26 13:21:48 +00:00
|
|
|
for (;;) {
|
2014-09-22 11:45:36 +00:00
|
|
|
addr = r_core_visual_anal_refresh (core);
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_readchar ();
|
2014-02-08 11:09:12 +00:00
|
|
|
if (ch==4||ch==-1) {
|
|
|
|
if (level==0)
|
|
|
|
goto beach;
|
|
|
|
level--;
|
|
|
|
continue;
|
|
|
|
}
|
2011-06-04 01:14:04 +00:00
|
|
|
ch = r_cons_arrow_to_hjkl (ch); // get ESC+char, return 'hjkl' char
|
|
|
|
switch (ch) {
|
2013-09-01 23:19:43 +00:00
|
|
|
case '?':
|
|
|
|
r_cons_clear ();
|
|
|
|
r_cons_printf (
|
|
|
|
"Usage: Vv [\n"
|
|
|
|
"Actions supported:\n"
|
|
|
|
" functions: Add, Modify, Delete, Xrefs Calls Vars\n"
|
|
|
|
" variables: Add, Modify, Delete\n"
|
|
|
|
"Moving:\n"
|
|
|
|
" j,k select next/prev item\n"
|
|
|
|
" h,q go back, quit\n"
|
|
|
|
" l,ret enter, function\n"
|
|
|
|
);
|
|
|
|
r_cons_flush ();
|
|
|
|
r_cons_any_key ();
|
|
|
|
break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case ':':
|
2011-06-04 01:23:12 +00:00
|
|
|
r_core_visual_prompt (core);
|
2011-06-04 01:14:04 +00:00
|
|
|
continue;
|
|
|
|
case 'a':
|
|
|
|
switch (level) {
|
|
|
|
case 0:
|
2014-02-08 11:09:12 +00:00
|
|
|
eprintf ("TODO: Add new function manually\n");
|
2011-06-04 01:14:04 +00:00
|
|
|
/*
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_set_raw (R_FALSE);
|
|
|
|
r_line_set_prompt ("Address: ");
|
|
|
|
if (!r_cons_fgets (old, sizeof (old), 0, NULL)) break;
|
|
|
|
old[strlen (old)-1] = 0;
|
|
|
|
if (!*old) break;
|
|
|
|
addr = r_num_math (core->num, old);
|
|
|
|
r_line_set_prompt ("Size: ");
|
|
|
|
if (!r_cons_fgets (old, sizeof (old), 0, NULL)) break;
|
|
|
|
old[strlen (old)-1] = 0;
|
|
|
|
if (!*old) break;
|
|
|
|
size = r_num_math (core->num, old);
|
|
|
|
r_line_set_prompt ("Name: ");
|
|
|
|
if (!r_cons_fgets (old, sizeof (old), 0, NULL)) break;
|
|
|
|
old[strlen (old)-1] = 0;
|
|
|
|
r_flag_set (core->flags, old, addr, 0, 0);
|
|
|
|
//XXX sprintf(cmd, "CF %lld @ 0x%08llx", size, addr);
|
|
|
|
// XXX r_core_cmd0(core, cmd);
|
|
|
|
r_cons_set_raw (R_TRUE);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
*/
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'm':
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_TRUE);
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_set_raw (R_FALSE);
|
|
|
|
r_line_set_prompt ("New name: ");
|
|
|
|
if (!r_cons_fgets (old, sizeof (old), 0, NULL)) break;
|
|
|
|
//old[strlen (old)-1] = 0;
|
|
|
|
function_rename (core, addr, old);
|
|
|
|
r_cons_set_raw (R_TRUE);
|
2011-12-02 00:58:34 +00:00
|
|
|
r_cons_show_cursor (R_FALSE);
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'd':
|
|
|
|
switch (level) {
|
|
|
|
case 0:
|
|
|
|
eprintf ("TODO\n");
|
|
|
|
//data_del(addr, DATA_FUN, 0);
|
|
|
|
// XXX correcly remove all the data contained inside the size of the function
|
|
|
|
//flag_remove_at(addr);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2013-09-23 22:43:31 +00:00
|
|
|
case 'x': level = 3; break;
|
|
|
|
case 'c': level = 2; break;
|
|
|
|
case 'v': level = 1; break;
|
|
|
|
case 'j': option++; break;
|
|
|
|
case 'k': option = (option<=0)? 0: option-1; break;
|
2014-05-03 00:11:05 +00:00
|
|
|
case 'g':
|
2011-06-04 01:14:04 +00:00
|
|
|
r_core_seek (core, addr, SEEK_SET);
|
2012-06-26 13:21:48 +00:00
|
|
|
goto beach;
|
2011-06-04 01:14:04 +00:00
|
|
|
case ' ':
|
|
|
|
case 'l':
|
|
|
|
level = 1;
|
|
|
|
_option = option;
|
|
|
|
break;
|
|
|
|
case 'h':
|
|
|
|
case 'b': // back
|
|
|
|
level = 0;
|
|
|
|
option = _option;
|
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
if (level==0)
|
2012-06-26 13:21:48 +00:00
|
|
|
goto beach;
|
2013-09-23 22:43:31 +00:00
|
|
|
level--;
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2012-06-26 13:21:48 +00:00
|
|
|
beach:
|
|
|
|
core->cons->event_resize = olde;
|
|
|
|
level = 0;
|
2014-08-23 00:27:31 +00:00
|
|
|
r_config_set_i (core->config, "asm.bytes", asmbytes);
|
2011-06-04 01:14:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_seek_next(RCore *core, const char *type) {
|
|
|
|
RListIter *iter;
|
|
|
|
ut64 next = UT64_MAX;
|
|
|
|
if (strstr (type, "opc")) {
|
|
|
|
RAnalOp aop;
|
|
|
|
if (r_anal_op (core->anal, &aop, core->offset, core->block, core->blocksize))
|
2013-12-06 04:18:57 +00:00
|
|
|
next = core->offset + aop.size;
|
2011-06-04 01:14:04 +00:00
|
|
|
else eprintf ("Invalid opcode\n");
|
|
|
|
} else
|
|
|
|
if (strstr (type, "fun")) {
|
2012-07-22 08:00:35 +00:00
|
|
|
RAnalFunction *fcni;
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach (core->anal->fcns, iter, fcni) {
|
|
|
|
if (fcni->addr < next && fcni->addr > core->offset)
|
|
|
|
next = fcni->addr;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
if (strstr (type, "hit")) {
|
|
|
|
const char *pfx = r_config_get (core->config, "search.prefix");
|
|
|
|
RFlagItem *flag;
|
|
|
|
r_list_foreach (core->flags->flags, iter, flag) {
|
|
|
|
if (!memcmp (flag->name, pfx, strlen (pfx)))
|
|
|
|
if (flag->offset < next && flag->offset > core->offset)
|
|
|
|
next = flag->offset;
|
|
|
|
}
|
|
|
|
} else { // flags
|
|
|
|
RFlagItem *flag;
|
|
|
|
r_list_foreach (core->flags->flags, iter, flag) {
|
|
|
|
if (flag->offset < next && flag->offset > core->offset)
|
|
|
|
next = flag->offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (next!=UT64_MAX)
|
|
|
|
r_core_seek (core, next, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_seek_previous (RCore *core, const char *type) {
|
|
|
|
RListIter *iter;
|
|
|
|
ut64 next = 0;
|
|
|
|
if (strstr (type, "opc")) {
|
|
|
|
eprintf ("TODO: r_core_seek_previous (opc)\n");
|
|
|
|
} else
|
|
|
|
if (strstr (type, "fun")) {
|
2012-07-22 08:00:35 +00:00
|
|
|
RAnalFunction *fcni;
|
2011-06-04 01:14:04 +00:00
|
|
|
r_list_foreach (core->anal->fcns, iter, fcni) {
|
|
|
|
if (fcni->addr > next && fcni->addr < core->offset)
|
|
|
|
next = fcni->addr;
|
|
|
|
}
|
|
|
|
} else
|
|
|
|
if (strstr (type, "hit")) {
|
|
|
|
RFlagItem *flag;
|
|
|
|
const char *pfx = r_config_get (core->config, "search.prefix");
|
|
|
|
r_list_foreach (core->flags->flags, iter, flag) {
|
|
|
|
if (!memcmp (flag->name, pfx, strlen (pfx)))
|
|
|
|
if (flag->offset > next && flag->offset< core->offset)
|
|
|
|
next = flag->offset;
|
|
|
|
}
|
|
|
|
} else { // flags
|
|
|
|
RFlagItem *flag;
|
|
|
|
r_list_foreach (core->flags->flags, iter, flag) {
|
|
|
|
if (flag->offset > next && flag->offset < core->offset)
|
|
|
|
next = flag->offset;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (next!=0)
|
|
|
|
r_core_seek (core, next, 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_visual_define (RCore *core) {
|
2011-06-09 00:12:46 +00:00
|
|
|
int plen = core->blocksize;
|
2013-06-28 09:58:30 +00:00
|
|
|
ut64 off = core->offset;
|
|
|
|
int n, ch, ntotal = 0;
|
|
|
|
ut8 *p = core->block;
|
2014-10-21 23:01:38 +00:00
|
|
|
int delta = 0;
|
|
|
|
ut64 here = core->offset;
|
|
|
|
if (core->print->cur_enabled)
|
|
|
|
delta = core->print->cur;
|
|
|
|
here += delta;
|
2013-06-28 09:58:30 +00:00
|
|
|
char *name;
|
2011-06-09 00:12:46 +00:00
|
|
|
if (core->print->cur_enabled) {
|
2014-03-02 00:49:19 +00:00
|
|
|
int cur = core->print->cur;
|
|
|
|
if (core->print->ocur != -1) {
|
|
|
|
plen = R_ABS (core->print->cur- core->print->ocur)+1;
|
|
|
|
if (core->print->ocur<cur)
|
|
|
|
cur = core->print->ocur;
|
|
|
|
}
|
2013-06-28 09:58:30 +00:00
|
|
|
off += cur;
|
|
|
|
p += cur;
|
2011-06-09 00:12:46 +00:00
|
|
|
}
|
2014-09-07 23:33:50 +00:00
|
|
|
{
|
|
|
|
int h;
|
|
|
|
(void)r_cons_get_size (&h);
|
2014-09-28 01:27:22 +00:00
|
|
|
h-=19;
|
2014-09-07 23:33:50 +00:00
|
|
|
if (h<0) {
|
|
|
|
r_cons_clear00 ();
|
|
|
|
} else {
|
|
|
|
r_cons_gotoxy (0, h);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
const char *lines[] = { ""
|
|
|
|
,"[Vd]- Define current block as:"
|
|
|
|
," $ define flag size"
|
|
|
|
," b set as byte"
|
|
|
|
," B set as short word (2 bytes)"
|
|
|
|
," c set as code"
|
|
|
|
," C define flag color (fc)"
|
|
|
|
," d set as data"
|
|
|
|
," e end of function"
|
|
|
|
," f analyze function"
|
|
|
|
," F format"
|
2014-09-27 01:48:54 +00:00
|
|
|
," h highlight word"
|
2014-09-07 23:33:50 +00:00
|
|
|
," q quit/cancel operation"
|
|
|
|
," r rename function"
|
|
|
|
," s set string"
|
|
|
|
," S set strings in current block"
|
|
|
|
," u undefine metadata here"
|
|
|
|
," w set as 32bit word"
|
|
|
|
," W set as 64bit word"
|
|
|
|
," q quit this menu"
|
|
|
|
, NULL};
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
for (i=0;lines[i];i++) {
|
|
|
|
r_cons_fill_line ();
|
|
|
|
r_cons_printf ("\r%s\n", lines[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-06-04 01:14:04 +00:00
|
|
|
r_cons_flush ();
|
|
|
|
|
|
|
|
// get ESC+char, return 'hjkl' char
|
|
|
|
ch = r_cons_arrow_to_hjkl (r_cons_readchar ());
|
|
|
|
|
|
|
|
switch (ch) {
|
2014-09-03 08:25:29 +00:00
|
|
|
case 'F':
|
|
|
|
{
|
|
|
|
char cmd[128];
|
|
|
|
r_cons_show_cursor (R_TRUE);
|
|
|
|
r_core_cmd0 (core, "pf?");
|
|
|
|
r_cons_flush ();
|
|
|
|
r_line_set_prompt ("format: ");
|
|
|
|
strcpy (cmd, "Cf 0 ");
|
|
|
|
if (r_cons_fgets (cmd+5, sizeof (cmd)-4, 0, NULL) > 0) {
|
|
|
|
r_core_cmd (core, cmd, 0);
|
|
|
|
r_cons_set_raw (1);
|
|
|
|
r_cons_show_cursor (R_FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'B':
|
|
|
|
r_meta_cleanup (core->anal, off, off+2);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_DATA, off, off+2, "");
|
|
|
|
break;
|
|
|
|
case 'b':
|
|
|
|
r_meta_cleanup (core->anal, off, off+1);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_DATA, off, off+1, "");
|
|
|
|
break;
|
2014-09-07 23:33:50 +00:00
|
|
|
case 'C':
|
|
|
|
{
|
|
|
|
RFlagItem *item = r_flag_get_i (core->flags, off);
|
|
|
|
if (item) {
|
|
|
|
char cmd[128];
|
|
|
|
r_cons_show_cursor (R_TRUE);
|
|
|
|
r_cons_flush ();
|
|
|
|
r_line_set_prompt ("color: ");
|
|
|
|
if (r_cons_fgets (cmd, sizeof (cmd)-1, 0, NULL) > 0) {
|
|
|
|
r_flag_color (core->flags, item, cmd);
|
|
|
|
r_cons_set_raw (1);
|
|
|
|
r_cons_show_cursor (R_FALSE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
eprintf ("Sorry. No flag here\n");
|
|
|
|
r_cons_any_key ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case '$':
|
|
|
|
{
|
|
|
|
RFlagItem *item = r_flag_get_i (core->flags, off);
|
|
|
|
if (item) {
|
|
|
|
char cmd[128];
|
|
|
|
r_cons_printf ("Current flag size is: %d\n", item->size);
|
|
|
|
r_cons_show_cursor (R_TRUE);
|
|
|
|
r_cons_flush ();
|
|
|
|
r_line_set_prompt ("new size: ");
|
|
|
|
if (r_cons_fgets (cmd, sizeof (cmd)-1, 0, NULL) > 0) {
|
|
|
|
item->size = r_num_math (core->num, cmd);
|
|
|
|
r_cons_set_raw (1);
|
|
|
|
r_cons_show_cursor (R_FALSE);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
eprintf ("Sorry. No flag here\n");
|
|
|
|
r_cons_any_key ();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2014-09-03 08:25:29 +00:00
|
|
|
case 'w':
|
|
|
|
{
|
|
|
|
int asmbits = 32; //r_config_get_i (core->config, "asm.bits");
|
|
|
|
r_meta_cleanup (core->anal, off, off+plen);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_DATA, off, off+(asmbits/8), "");
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case 'W':
|
|
|
|
{
|
|
|
|
int asmbits = 64; //r_config_get_i (core->config, "asm.bits");
|
|
|
|
r_meta_cleanup (core->anal, off, off+plen);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_DATA, off, off+(asmbits/8), "");
|
|
|
|
}
|
|
|
|
break;
|
2014-08-30 01:13:11 +00:00
|
|
|
case 'e':
|
|
|
|
// set function size
|
|
|
|
{
|
2014-09-26 13:40:17 +00:00
|
|
|
RAnalFunction *fcn = r_anal_get_fcn_in (core->anal, off, 0);
|
2014-08-30 01:28:09 +00:00
|
|
|
if (!fcn) {
|
2014-09-26 13:40:17 +00:00
|
|
|
fcn = r_anal_get_fcn_in (core->anal, core->offset, 0);
|
2014-08-30 01:28:09 +00:00
|
|
|
}
|
2014-08-30 01:13:11 +00:00
|
|
|
if (fcn) {
|
|
|
|
RAnalOp op;
|
|
|
|
ut64 size;
|
|
|
|
if (r_anal_op (core->anal, &op, here, core->block+delta,
|
|
|
|
core->blocksize-delta)) {
|
|
|
|
size = here - fcn->addr + op.size;
|
2014-09-02 00:41:40 +00:00
|
|
|
r_anal_fcn_resize (fcn, size);
|
2014-08-30 01:13:11 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
2014-10-21 23:01:38 +00:00
|
|
|
case 'h': // "Vdh"
|
|
|
|
r_core_cmdf (core, "?i highlight;e scr.highlight=`?y` @ 0x%08"PFMT64x, here);
|
2014-09-27 01:48:54 +00:00
|
|
|
break;
|
2014-10-21 23:01:38 +00:00
|
|
|
case 'r': // "Vdr"
|
|
|
|
r_core_cmdf (core, "?i new function name;afn `?y` @ 0x%08"PFMT64x, here);
|
2012-10-25 23:33:57 +00:00
|
|
|
break;
|
2011-06-09 00:29:24 +00:00
|
|
|
case 'S':
|
|
|
|
do {
|
2013-02-11 09:51:45 +00:00
|
|
|
n = r_str_nlen ((const char*)p+ntotal, plen-ntotal)+1;
|
2011-06-09 00:29:24 +00:00
|
|
|
name = malloc (n+10);
|
2011-09-18 18:41:36 +00:00
|
|
|
strcpy (name, "str.");
|
2011-06-09 00:29:24 +00:00
|
|
|
strncpy (name+4, (const char *)p+ntotal, n);
|
2014-09-27 23:37:55 +00:00
|
|
|
r_flag_set (core->flags, name, off+ntotal, n, 0);
|
2014-01-23 02:28:25 +00:00
|
|
|
r_meta_add (core->anal, R_META_TYPE_STRING,
|
2011-06-09 00:29:24 +00:00
|
|
|
off+ntotal, off+n+ntotal, (const char *)p+ntotal);
|
|
|
|
free (name);
|
|
|
|
if (n<2) break;
|
|
|
|
ntotal+= n;
|
|
|
|
} while (ntotal<core->blocksize);
|
|
|
|
break;
|
2011-06-04 01:14:04 +00:00
|
|
|
case 's':
|
2013-02-11 03:08:21 +00:00
|
|
|
// TODO: r_core_cmd0 (core, "Cz");
|
2013-02-11 09:51:45 +00:00
|
|
|
n = r_str_nlen ((const char*)p, plen)+1;
|
|
|
|
name = malloc (n+10);
|
|
|
|
strcpy (name, "str.");
|
|
|
|
strncpy (name+4, (const char *)p, n);
|
|
|
|
r_flag_set (core->flags, name, off, n, 0);
|
2014-01-23 02:28:25 +00:00
|
|
|
r_meta_add (core->anal, R_META_TYPE_STRING, off, off+n, (const char *)p);
|
2013-02-11 09:51:45 +00:00
|
|
|
free (name);
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'd': // TODO: check
|
2014-01-23 02:28:25 +00:00
|
|
|
r_meta_cleanup (core->anal, off, off+plen);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_DATA, off, off+plen, "");
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
2012-07-22 08:00:35 +00:00
|
|
|
case 'c': // TODO: check
|
2014-01-23 02:28:25 +00:00
|
|
|
r_meta_cleanup (core->anal, off, off+plen);
|
|
|
|
r_meta_add (core->anal, R_META_TYPE_CODE, off, off+plen, "");
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'u':
|
2014-09-22 13:00:41 +00:00
|
|
|
r_core_anal_undefine (core, off);
|
|
|
|
#if 0
|
2011-06-04 01:14:04 +00:00
|
|
|
r_flag_unset_i (core->flags, off, NULL);
|
2014-09-26 13:40:17 +00:00
|
|
|
f = r_anal_get_fcn_in (core->anal, off, 0);
|
2013-02-11 09:51:45 +00:00
|
|
|
r_anal_fcn_del_locs (core->anal, off);
|
2014-01-23 02:28:25 +00:00
|
|
|
if (f) r_meta_del (core->anal, R_META_TYPE_ANY, off, f->size, "");
|
2013-02-11 09:51:45 +00:00
|
|
|
r_anal_fcn_del (core->anal, off);
|
2014-09-22 13:00:41 +00:00
|
|
|
#endif
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'f':
|
2014-09-22 13:00:41 +00:00
|
|
|
{
|
2014-09-26 16:10:33 +00:00
|
|
|
RAnalFunction *fcn = r_anal_get_fcn_in (core->anal, core->offset, 0);
|
2014-09-26 13:40:17 +00:00
|
|
|
if (fcn)
|
2014-09-22 13:00:41 +00:00
|
|
|
r_anal_fcn_resize (fcn, core->offset - fcn->addr);
|
|
|
|
}
|
2013-07-19 01:35:45 +00:00
|
|
|
{
|
|
|
|
int funsize = 0;
|
|
|
|
int depth = r_config_get_i (core->config, "anal.depth");
|
|
|
|
if (core->print->cur_enabled) {
|
2014-03-02 00:49:19 +00:00
|
|
|
if (core->print->ocur != -1) {
|
|
|
|
funsize = 1+ R_ABS (core->print->cur - core->print->ocur);
|
|
|
|
}
|
2013-07-19 01:35:45 +00:00
|
|
|
depth = 0;
|
|
|
|
}
|
2014-03-02 00:49:19 +00:00
|
|
|
r_cons_break (NULL, NULL);
|
2013-07-19 01:35:45 +00:00
|
|
|
r_core_anal_fcn (core, off, UT64_MAX,
|
|
|
|
R_ANAL_REF_TYPE_NULL, depth);
|
|
|
|
r_cons_break_end ();
|
|
|
|
if (funsize) {
|
2014-09-26 13:40:17 +00:00
|
|
|
RAnalFunction *f = r_anal_get_fcn_in (core->anal, off, -1);
|
2013-07-19 01:35:45 +00:00
|
|
|
if (f) f->size = funsize;
|
|
|
|
}
|
|
|
|
}
|
2011-06-04 01:14:04 +00:00
|
|
|
break;
|
|
|
|
case 'q':
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2013-07-17 01:51:53 +00:00
|
|
|
|
|
|
|
R_API void r_core_visual_colors(RCore *core) {
|
|
|
|
char color[32], cstr[32];
|
|
|
|
const char *k, *kol;
|
2013-07-17 20:12:14 +00:00
|
|
|
int ch, opt = 0, oopt = -1;
|
2013-07-17 01:51:53 +00:00
|
|
|
ut8 r, g, b;
|
|
|
|
|
|
|
|
r = g = b = 0;
|
|
|
|
kol = r_cons_pal_get_color (opt);
|
2013-07-17 20:12:14 +00:00
|
|
|
r_cons_rgb_parse (kol, &r, &g, &b, NULL);
|
2013-07-17 01:51:53 +00:00
|
|
|
for (;;) {
|
|
|
|
r_cons_clear ();
|
|
|
|
k = r_cons_pal_get_i (opt);
|
|
|
|
if (!k) {
|
|
|
|
opt = 0;
|
|
|
|
k = r_cons_pal_get_i (opt);
|
|
|
|
}
|
|
|
|
r_cons_gotoxy (0, 0);
|
|
|
|
r_cons_rgb_str (cstr, r, g, b, 0);
|
2013-07-17 17:34:27 +00:00
|
|
|
r&=0xf;
|
|
|
|
g&=0xf;
|
|
|
|
b&=0xf;
|
2013-07-17 01:51:53 +00:00
|
|
|
sprintf (color, "rgb:%x%x%x", r, g, b);
|
|
|
|
//r_cons_printf ("COLOR%s(%sXXX)"Color_RESET"\n", kol, kol?kol+1:"");
|
|
|
|
r_cons_printf ("# Colorscheme %d - Use '.' and ':' to randomize palette\n"
|
|
|
|
"# Press 'rRgGbB', 'jk' or 'q'\nec %s %s # %d (%s)\n",
|
|
|
|
opt, k, color, atoi (cstr+7), cstr+1);
|
|
|
|
r_core_cmdf (core, "ec %s %s", k, color);
|
|
|
|
r_core_cmd0 (core, "pd 25");
|
|
|
|
r_cons_flush ();
|
|
|
|
ch = r_cons_readchar ();
|
|
|
|
ch = r_cons_arrow_to_hjkl (ch);
|
|
|
|
switch (ch) {
|
|
|
|
#define CASE_RGB(x,X,y) \
|
|
|
|
case x:y--;if(y>0x7f)y=0;break;\
|
|
|
|
case X:y++;if(y>15)y=15;break;
|
|
|
|
CASE_RGB ('R','r',r);
|
|
|
|
CASE_RGB ('G','g',g);
|
|
|
|
CASE_RGB ('B','b',b);
|
2013-07-17 20:12:14 +00:00
|
|
|
case 'q': return;
|
2013-07-17 17:34:27 +00:00
|
|
|
case 'k': opt--; break;
|
|
|
|
case 'j': opt++; break;
|
2013-07-17 01:51:53 +00:00
|
|
|
case 'K': opt=0; break;
|
|
|
|
case 'J': opt=0; break; // XXX must go to end
|
2013-07-17 20:12:14 +00:00
|
|
|
case ':': r_cons_pal_random (); break;
|
2013-07-17 01:51:53 +00:00
|
|
|
case '.':
|
|
|
|
r = r_num_rand (0xf);
|
|
|
|
g = r_num_rand (0xf);
|
|
|
|
b = r_num_rand (0xf);
|
|
|
|
break;
|
|
|
|
}
|
2013-07-17 20:12:14 +00:00
|
|
|
if (opt != oopt) {
|
|
|
|
kol = r_cons_pal_get_color (opt);
|
|
|
|
r_cons_rgb_parse (kol, &r, &g, &b, NULL);
|
|
|
|
oopt = opt;
|
|
|
|
}
|
2013-07-17 01:51:53 +00:00
|
|
|
}
|
|
|
|
}
|