R_API int r_core_hack_x86(RCore *core, const char *op, const RAnalOp *analop) {
const ut8 *b = core->block;
const int size = analop->size;
if (!strcmp (op, "nop")) {
if (size * 2 + 1 < size) return false;
char *str = malloc (size * 2 + 1);
if (!str) return false;
int i;
for (i = 0; i < size; i++)
memcpy(str + (i * 2), "90", 2);
str[size*2] = '\0';
r_core_cmdf(core, "wx %s\n", str);
free(str);
} else if (!strcmp (op, "trap")) {
r_core_cmd0 (core, "wx cc\n");
} else if (!strcmp (op, "jz")) {
if (b[0] == 0x75) {
r_core_cmd0 (core, "wx 74\n");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "jnz")) {
if (b[0] == 0x74) {
r_core_cmd0 (core, "wx 75\n");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "un-cjmp")) {
if (b[0] >= 0x70 && b[0] <= 0x7f) {
r_core_cmd0 (core, "wx eb\n");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "swap-cjmp")) {
if (b[0] < 0x80 && b[0] >= 0x70){ // jo, jno, jb, jae, je, jne, jbe, ja, js, jns
r_core_cmdf (core, "wx %x\n", (b[0]%2)? b[0] - 1: b[0] + 1);
} else {
eprintf ("Invalid opcode\n");
return false;
}
} else if (!strcmp (op, "ret1")) {
r_core_cmd0 (core, "wx c20100\n");
} else if (!strcmp (op, "ret0")) {
r_core_cmd0 (core, "wx c20000\n");
} else if (!strcmp (op, "retn")) {
r_core_cmd0 (core, "wx c2ffff\n");
} else {
eprintf ("Invalid operation\n");
return false;
}
return true;
}
R_API int r_core_setup_debugger (RCore *r, const char *debugbackend, bool attach) {
int pid, *p = NULL;
bool is_gdb = !strcmp (debugbackend, "gdb");
RIODesc * fd = r->file ? r_io_desc_get (r->io, r->file->fd) : NULL;
const char *prompt = NULL;
p = fd ? fd->data : NULL;
r_config_set_i (r->config, "cfg.debug", 1);
if (!p) {
eprintf ("Invalid debug io\n");
return false;
}
r_config_set (r->config, "io.ff", "true");
r_core_cmdf (r, "dL %s", debugbackend);
if (!is_gdb) {
pid = r_io_desc_get_pid (fd);
r_core_cmdf (r, "dp=%d", pid);
if (attach) {
r_core_cmdf (r, "dpa %d", pid);
}
}
//this makes to attach twice showing warnings in the output
//we get "resource busy" so it seems isn't an issue
r_core_cmd (r, ".dr*", 0);
/* honor dbg.bep */
{
const char *bep = r_config_get (r->config, "dbg.bep");
if (bep) {
if (!strcmp (bep, "loader")) {
/* do nothing here */
} else if (!strcmp (bep, "entry")) {
r_core_cmd (r, "dcu entry0", 0);
} else {
r_core_cmdf (r, "dcu %s", bep);
}
}
}
r_core_cmd (r, "sr PC", 0);
/* set the prompt if it's not been set already by the callbacks */
prompt = r_config_get (r->config, "cmd.prompt");
if (prompt && !strcmp (prompt, "")) {
if (r_config_get_i (r->config, "dbg.status")) {
r_config_set (r->config, "cmd.prompt", ".dr*;drd;sr PC;pi 1;s-");
} else {
r_config_set (r->config, "cmd.prompt", ".dr*");
}
}
r_config_set (r->config, "cmd.vprompt", ".dr*");
return true;
}
static int readline_callback(void *_a, const char *str) {
RCoreVisualAsm *a = _a;
int xlen;
r_cons_clear00 ();
r_cons_printf ("Write your favourite %s-%d opcode...\n\n",
r_config_get (a->core->config, "asm.arch"),
r_config_get_i (a->core->config, "asm.bits"));
if (*str == '?') {
r_cons_printf ("0> ?\n\n"
"Visual assembler help:\n\n"
" assemble input while typing using asm.arch, asm.bits and cfg.bigendian\n"
" press enter to quit (prompt if there are bytes to be written)\n"
" this assembler supports various directives like .hex ...\n"
);
} else {
r_asm_code_free (a->acode);
a->acode = r_asm_massemble (a->core->assembler, str);
r_cons_printf ("%d> %s\n", a->acode? a->acode->len: 0, str);
if (a->acode && a->acode->len)
r_cons_printf ("* %s\n\n", a->acode->buf_hex);
else r_cons_printf ("\n\n");
if (a->acode) {
xlen = strlen (a->acode->buf_hex);
strcpy (a->codebuf, a->blockbuf);
memcpy (a->codebuf, a->acode->buf_hex, xlen);
}
r_core_cmdf (a->core, "pd 7@b:%s @0x%"PFMT64x, a->codebuf, a->off);
}
r_cons_flush ();
return 1;
}
R_API void r_core_rtr_cmd(RCore *core, const char *input) {
char bufw[1024], bufr[8];
const char *cmd = NULL, *cmd_output = NULL;
int i, cmd_len, fd = atoi (input);
if (*input==':' && !strchr (input+1, ':')) {
r_core_cmdf (core, "o rap://%s", input);
return;
}
if (fd != 0) {
if (rtr_host[rtr_n].fd)
for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd
&& rtr_n < RTR_MAX_HOSTS - 1; rtr_n++);
if (!(cmd = strchr (input, ' '))) {
eprintf ("Error\n");
return;
}
} else cmd = input;
if (!rtr_host[rtr_n].fd){
eprintf ("Error: Unknown host\n");
core->num->value = 1; // fail
return;
}
if (!rtr_host[rtr_n].proto == RTR_PROT_RAP){
eprintf ("Error: Not a rap:// host\n");
return;
}
core->num->value = 0; // that's fine
if (!strlen (cmd)) {
// just check if we can connect
r_socket_close (rtr_host[rtr_n].fd);
return;
}
/* send */
bufw[0] = RTR_RAP_CMD;
i = strlen (cmd) + 1;
r_mem_copyendian ((ut8*)bufw+1, (ut8*)&i, 4, endian);
memcpy (bufw+5, cmd, i);
r_socket_write (rtr_host[rtr_n].fd, bufw, 5+i);
/* read */
r_socket_read (rtr_host[rtr_n].fd, (ut8*)bufr, 5);
if (bufr[0] != (char)(RTR_RAP_CMD|RTR_RAP_REPLY)) {
eprintf ("Error: Wrong reply\n");
return;
}
r_mem_copyendian ((ut8*)&cmd_len, (ut8*)bufr+1, 4, endian);
cmd_output = malloc (cmd_len);
if (!cmd_output) {
eprintf ("Error: Allocating cmd output\n");
return;
}
r_socket_read (rtr_host[rtr_n].fd, (ut8*)cmd_output, cmd_len);
r_cons_printf ("%s\n", cmd_output);
free ((void *)cmd_output);
}
R_API bool r_core_hack_arm64(RCore *core, const char *op, const RAnalOp *analop) {
if (!strcmp (op, "nop")) {
r_core_cmdf (core, "wx 1f2003d5");
} else if (!strcmp (op, "ret")) {
r_core_cmdf (core, "wx c0035fd6t");
} else if (!strcmp (op, "trap")) {
r_core_cmdf (core, "wx 000020d4");
} else if (!strcmp (op, "jz")) {
eprintf ("ARM jz hack not supported\n");
return false;
} else if (!strcmp (op, "jinf")) {
r_core_cmdf (core, "wx 00000014");
} else if (!strcmp (op, "jnz")) {
eprintf ("ARM jnz hack not supported\n");
return false;
} else if (!strcmp (op, "nocj")) {
eprintf ("ARM jnz hack not supported\n");
return false;
} else if (!strcmp (op, "recj")) {
eprintf ("TODO: use jnz or jz\n");
return false;
} else if (!strcmp (op, "ret1")) {
r_core_cmdf (core, "wa mov x0, 1,,ret");
} else if (!strcmp (op, "ret0")) {
r_core_cmdf (core, "wa mov x0, 0,,ret");
} else if (!strcmp (op, "retn")) {
r_core_cmdf (core, "wa mov x0, -1,,ret");
} else {
eprintf ("Invalid operation '%s'\n", op);
return false;
}
return true;
}
R_API int r_core_patch_line (RCore *core, char *str) {
char *p, *q;
p = strchr (str + 1, ' ');
if (!p) {
return 0;
}
*p = 0;
for (++p; *p == ' '; p++); // XXX: skipsspaces here
switch (*p) {
case '"':
q = strchr (p + 1,'"');
if (q) *q = 0;
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "\"w %s\"", p+1);
break;
case ':':
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "wa %s", p);
break;
default:
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "wx %s", p);
break;
}
return 1;
}
R_API void r_core_visual_asm(RCore *core) {
RCoreVisualAsm cva = {0};
cva.core = core;
r_io_read_at (core->io, core->offset, cva.buf, sizeof (cva.buf));
cva.blocklen = r_hex_bin2str (cva.buf, sizeof (cva.buf), cva.blockbuf);
r_line_readline_cb (readline_callback, &cva);
if (cva.acode && cva.acode->len>0)
if (r_cons_yesno ('y', "Save changes? (Y/n)"))
r_core_cmdf (core, "wx %s", cva.acode->buf_hex);
r_asm_code_free (cva.acode);
}
static int linklist_readable (void *p, const char *k, const char *v) {
RCore *core = (RCore *)p;
if (!strncmp (k, "link.", strlen ("link."))) {
char *fmt = r_anal_type_format (core->anal, v);
if (!fmt) {
eprintf("Cant fint type %s", v);
return 1;
}
r_cons_printf ("(%s)\n", v);
r_core_cmdf (core, "pf %s @ 0x%s\n", fmt, k + strlen ("link."));
}
return 1;
}
static void save_parsed_type(RCore *core, const char *parsed) {
if (!core || !core->anal || !parsed) {
return;
}
// First, if this exists, let's remove it.
char *type = strdup (parsed);
if (type) {
char *name = strtok (type, "=");
if (!name || strchr (name, '\n') || strchr (name, ';')) {
/* do nothing */
} else {
r_core_cmdf (core, "\"t- %s\"", name);
// Now add the type to sdb.
sdb_query_lines (core->anal->sdb_types, parsed);
}
free (type);
}
}
static void nextpal(RCore *core, int mode) {
RList *files;
RListIter *iter;
const char *fn;
char *home = r_str_home (".config/radare2/cons/");
getNext = false;
if (home) {
files = r_sys_dir (home);
r_list_foreach (files, iter, fn) {
if (*fn && *fn != '.') {
if (!nextpal_item (core, mode, fn)) {
r_list_free (files);
R_FREE (home);
goto done;
}
}
}
r_list_free (files);
R_FREE (home);
}
files = r_sys_dir (R2_DATDIR"/radare2/"R2_VERSION"/cons/");
r_list_foreach (files, iter, fn) {
if (*fn && *fn != '.') {
if (!nextpal_item (core, mode, fn))
goto done;
}
}
done:
if (getNext) {
R_FREE (curtheme);
nextpal (core, mode);
return;
}
if (mode == 'l' && !curtheme && !r_list_empty (files)) {
nextpal (core, mode);
// beware infinite loop here
return;
}
r_list_free (files);
if (curtheme) {
r_core_cmdf (core, "eco %s", curtheme);
}
}
static int cmd_type(void *data, const char *input) {
RCore *core = (RCore *)data;
switch (input[0]) {
// t [typename] - show given type in C syntax
case 'u': // "tu"
switch (input[1]) {
case '?': {
const char *help_message[] = {
"USAGE tu[...]", "", "",
"tu", "", "List all loaded unions",
"tu?", "", "show this help",
NULL };
r_core_cmd_help (core, help_message);
} break;
case 0:
sdb_foreach (core->anal->sdb_types, stdprintifunion, core);
break;
}
break;
case 'k': // "tk"
if (input[1] == ' ') {
sdb_query (core->anal->sdb_types, input + 2);
} else sdb_query (core->anal->sdb_types, "*");
fflush (stdout);
break;
case 's': // "ts"
switch (input[1]) {
case '?': {
const char *help_message[] = {
"USAGE ts[...]", "", "",
"ts", "", "List all loaded structs",
"ts?", "", "show this help",
NULL };
r_core_cmd_help (core, help_message);
} break;
case 0:
sdb_foreach (core->anal->sdb_types, stdprintifstruct, core);
break;
}
break;
case 'b': {
char *p, *s = (strlen (input) > 1)? strdup (input + 2): NULL;
const char *isenum;
p = s? strchr (s, ' '): NULL;
if (p) {
*p++ = 0;
// dupp in core.c (see getbitfield())
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strcmp (isenum, "enum")) {
*--p = '.';
const char *res = sdb_const_get (core->anal->sdb_types, s, 0);
if (res)
r_cons_println (res);
else eprintf ("Invalid enum member\n");
} else {
eprintf ("This is not an enum\n");
}
} else {
eprintf ("Missing value\n");
}
free (s);
} break;
case 'e': {
if (!input[1]) {
char *name = NULL;
SdbKv *kv;
SdbListIter *iter;
SdbList *l = sdb_foreach_list (core->anal->sdb_types);
ls_foreach (l, iter, kv) {
if (!strcmp (kv->value, "enum")) {
if (!name || strcmp (kv->value, name)) {
free (name);
name = strdup (kv->key);
r_cons_println (name);
}
}
}
free (name);
ls_free (l);
break;
}
if (input[1] == '?') {
const char *help_message[] = {
"USAGE te[...]", "", "",
"te", "", "List all loaded enums",
"te", " <enum> <value>", "Show name for given enum number",
"te?", "", "show this help",
NULL };
r_core_cmd_help (core, help_message);
break;
}
char *p, *s = strdup (input + 2);
const char *isenum;
p = strchr (s, ' ');
if (p) {
*p++ = 0;
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strncmp (isenum, "enum", 4)) {
const char *q = sdb_fmt (0, "%s.0x%x", s, (ut32)r_num_math (core->num, p));
const char *res = sdb_const_get (core->anal->sdb_types, q, 0);
if (res)
r_cons_println (res);
} else {
eprintf ("This is not an enum\n");
}
} else {
//eprintf ("Missing value\n");
r_core_cmdf (core, "t~&%s,=0x", s);
}
free (s);
} break;
case ' ': {
const char *isenum = sdb_const_get (core->anal->sdb_types, input + 1, 0);
if (isenum && !strcmp (isenum, "enum")) {
eprintf ("IS ENUM! \n");
} else {
char *fmt = r_anal_type_format (core->anal, input + 1);
if (fmt) {
r_str_chop (fmt);
r_cons_printf ("pf %s\n", fmt);
free (fmt);
} else eprintf ("Cannot find '%s' type\n", input + 1);
}
} break;
// t* - list all types in 'pf' syntax
case '*':
sdb_foreach (core->anal->sdb_types, typelist, core);
break;
case 0:
sdb_foreach (core->anal->sdb_types, sdbforcb, core);
break;
case 'o':
if (!r_sandbox_enable (0)) {
if (input[1] == ' ') {
const char *filename = input + 2;
char *homefile = NULL;
if (*filename == '~') {
if (filename[1] && filename[2]) {
homefile = r_str_home (filename + 2);
filename = homefile;
}
}
if (!strcmp (filename, "-")) {
char *out, *tmp;
tmp = r_core_editor (core, NULL, "");
if (tmp) {
out = r_parse_c_string (tmp);
if (out) {
// r_cons_strcat (out);
save_parsed_type (core, out);
free (out);
}
free (tmp);
}
} else {
char *out = r_parse_c_file (filename);
if (out) {
//r_cons_strcat (out);
save_parsed_type (core, out);
free (out);
}
//r_anal_type_loadfile (core->anal, filename);
}
free (homefile);
} else if (input[1] == 's') {
const char *dbpath = input + 3;
if (r_file_exists (dbpath)) {
Sdb *db_tmp = sdb_new (0, dbpath, 0);
sdb_merge (core->anal->sdb_types, db_tmp);
sdb_close (db_tmp);
sdb_free (db_tmp);
}
}
} else {
eprintf ("Sandbox: system call disabled\n");
}
break;
// td - parse string with cparse engine and load types from it
case 'd':
if (input[1] == '?') {
const char *help_message[] = {
"Usage:", "\"td [...]\"", "",
"td", "[string]", "Load types from string",
NULL };
r_core_cmd_help (core, help_message);
r_cons_printf ("Note: The td command should be put between double quotes\n"
"Example: \" td struct foo {int bar;int cow};\""
"\nt");
} else if (input[1] == ' ') {
char tmp[8192];
snprintf (tmp, sizeof (tmp) - 1, "%s;", input + 2);
//const char *string = input + 2;
//r_anal_str_to_type (core->anal, string);
char *out = r_parse_c_string (tmp);
if (out) {
//r_cons_strcat (out);
save_parsed_type (core, out);
free (out);
}
} else {
eprintf ("Invalid use of td. See td? for help\n");
}
break;
// tl - link a type to an address
case 'l':
switch (input[1]) {
case '?': {
const char *help_message[] = {
"Usage:", "", "",
"tl", "", "list all links in readable format",
"tl", "[typename]", "link a type to current adress.",
"tl", "[typename] = [address]", "link type to given address.",
"tls", "[address]", "show link at given address",
"tl-*", "", "delete all links.",
"tl-", "[address]", "delete link at given address.",
"tl*", "", "list all links in radare2 command format",
"tl?", "", "print this help.",
NULL };
r_core_cmd_help (core, help_message);
} break;
case ' ': {
char *type = strdup (input + 2);
char *ptr = strchr (type, '=');
ut64 addr;
if (ptr) {
*ptr++ = 0;
r_str_chop (ptr);
if (ptr && *ptr) {
addr = r_num_math (core->num, ptr);
} else {
eprintf ("address is unvalid\n");
free (type);
break;
}
} else {
addr = core->offset;
}
r_str_chop (type);
char *tmp = sdb_get (core->anal->sdb_types, type, 0);
if (tmp && *tmp) {
r_anal_type_link (core->anal, type, addr);
free (tmp);
} else {
eprintf ("unknown type %s\n", type);
}
free (type);
}
break;
case 's': {
int ptr;
char *addr = strdup (input + 2);
SdbKv *kv;
SdbListIter *sdb_iter;
SdbList *sdb_list = sdb_foreach_list (core->anal->sdb_types);
r_str_chop (addr);
ptr = r_num_math (NULL, addr);
//r_core_cmdf (core, "tl~0x%08"PFMT64x" = ", addr);
ls_foreach (sdb_list, sdb_iter, kv) {
char *linkptr;
if (strncmp (kv->key, "link.", strlen ("link."))) {
continue;
}
linkptr = sdb_fmt (-1,"0x%s", kv->key + strlen ("link."));
if (ptr == r_num_math (NULL, linkptr)) {
linklist_readable (core, kv->key, kv->value);
}
}
free (addr);
ls_free (sdb_list);
}
break;
case '-':
switch (input[2]) {
case '*':
sdb_foreach (core->anal->sdb_types, sdbdeletelink, core);
break;
case ' ': {
const char *ptr = input + 3;
ut64 addr = r_num_math (core->num, ptr);
r_anal_type_unlink (core->anal, addr);
}
break;
}
break;
case '*':
sdb_foreach (core->anal->sdb_types, linklist, core);
break;
case '\0':
sdb_foreach (core->anal->sdb_types, linklist_readable, core);
break;
}
static int cmd_meta_comment(RCore *core, const char *input) {
ut64 addr = core->offset;
switch (input[1]) {
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal,
R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case '+':
case ' ':
{
const char* newcomment = input+2;
char *text;
while (*newcomment==' ') newcomment++;
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (comment) {
text = malloc (strlen (comment)+strlen (newcomment)+2);
strcpy (text, comment);
strcat (text, "\n");
strcat (text, newcomment);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, text);
free (text);
} else {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, newcomment);
}
}
break;
case '*':
r_meta_list (core->anal, R_META_TYPE_COMMENT, 1);
break;
case '-':
r_meta_del (core->anal, R_META_TYPE_COMMENT, core->offset, 1, NULL);
break;
case 'u':
//
{
const char* newcomment = input+2;
while (*newcomment==' ') newcomment++;
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (!comment || (comment && !strstr (comment, newcomment))) {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, newcomment);
}
free (comment);
}
break;
case 'a':
{
char *s, *p;
s = strchr (input, ' ');
if (s) {
s = strdup (s+1);
} else {
eprintf ("Usage\n");
return R_FALSE;
}
p = strchr (s, ' ');
if (p) *p++ = 0;
ut64 addr;
if (input[2]=='-') {
if (input[3]) {
addr = r_num_math (core->num, input+3);
r_meta_del (core->anal,
R_META_TYPE_COMMENT,
addr, 1, NULL);
} else eprintf ("Usage: CCa-[address]\n");
free (s);
return R_TRUE;
}
addr = r_num_math (core->num, s);
// Comment at
if (p) {
if (input[2]=='+') {
char *text = p;
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT,
addr);
if (comment) {
text = malloc (strlen (comment) + strlen (p)+2);
strcpy (text, comment);
strcat (text, "\n");
strcat (text, p);
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, text);
free (text);
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, p);
}
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, p);
}
} else eprintf ("Usage: CCa [address] [comment]\n");
free (s);
return R_TRUE;
}
}
return R_TRUE;
}
static int cmd_meta_hsdmf(RCore *core, const char *input) {
int n, type = input[0];
char *t = 0, *p, name[256];
int repeat = 1;
ut64 addr_end = 0LL, addr = core->offset;
switch (input[1]) {
case '?':
eprintf ("See C?\n");
break;
case '-':
switch (input[2]) {
case '*':
core->num->value = r_meta_del (core->anal,
input[0], 0, UT64_MAX, NULL);
break;
case ' ':
addr = r_num_math (core->num, input+3);
/* fallthrough */
default:
core->num->value = r_meta_del (core->anal,
input[0], addr, 1, NULL);
break;
}
break;
case '*':
r_meta_list (core->anal, input[0], 1);
break;
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case ' ':
case '\0':
if (type!='z' && input[1] == '*') {
r_meta_list (core->anal, type, 0);
break;
}
if (type == 'z') {
type = 's';
}
if (strlen (input) > 2) {
char *rep = strchr (input + 2, '[');
if (!rep) rep = strchr (input + 2, ' ');
if (rep) {
repeat = r_num_get (core->num, rep + 1);
}
}
int repcnt = 0;
if (repeat < 1) repeat = 1;
while (repcnt < repeat) {
t = strdup (r_str_chop_ro (input + 1));
p = NULL;
n = 0;
strncpy (name, t, sizeof (name) - 1);
if (type != 'C') {
n = r_num_math (core->num, t);
if (type == 'f') {
p = strchr (t, ' ');
if (p) {
n = r_print_format (core->print, addr, core->block,
core->blocksize, p + 1, 0, NULL, NULL);
}
}
if (type == 's') {
strncpy (name, t, sizeof (name) - 1);
(void)r_core_read_at (core, addr, (ut8*)name, sizeof (name) - 1);
name[sizeof (name) - 1] = '\0';
int name_len = strlen (name);
if (n == 0) {
n = name_len + 1;
} else {
if (n > 0 && n < name_len) {
name[n] = 0;
}
}
}
if (!*t || n > 0) {
RFlagItem *fi;
p = strchr (t, ' ');
if (p) {
*p = '\0';
strncpy (name, p + 1, sizeof (name)-1);
} else {
if (type != 's') {
fi = r_flag_get_i (core->flags, addr);
if (fi) strncpy (name, fi->name, sizeof (name)-1);
}
}
} else if (n < 1) {
eprintf ("Invalid length %d\n", n);
return false;
}
}
if (!n) n++;
addr_end = addr + n;
r_meta_add (core->anal, type, addr, addr_end, name);
free (t);
repcnt ++;
addr = addr_end;
}
//r_meta_cleanup (core->anal->meta, 0LL, UT64_MAX);
break;
default:
eprintf ("Missing space after CC\n");
break;
}
return true;
}
static int cmd_meta_hsdmf (RCore *core, const char *input) {
int n, type = input[0];
char *t = 0, *p, name[256];
ut64 addr_end = 0LL, addr = core->offset;
switch (input[1]) {
case '?':
eprintf ("See C?\n");
break;
case '-':
switch (input[2]) {
case '*':
core->num->value = r_meta_del (core->anal,
input[0], 0, UT64_MAX, NULL);
break;
case ' ':
addr = r_num_math (core->num, input+3);
default:
core->num->value = r_meta_del (core->anal,
input[0], addr, 1, NULL);
break;
}
break;
case '*':
r_meta_list (core->anal, input[0], 1);
break;
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal,
R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case ' ':
case '\0':
if (type!='z' && !input[1]) {
r_meta_list (core->anal, type, 0);
break;
}
t = strdup (input+2);
p = NULL;
n = 0;
strncpy (name, t, sizeof (name)-1);
if (*input != 'C') {
n = r_num_math (core->num, t);
if (type == 'f') {
p = strchr (t, ' ');
if (p)
n = r_print_format (core->print, addr, core->block,
core->blocksize, p+1, -1, NULL, NULL);
}
if (type == 's') {
/* This is kept for compatibility with old projects.
* Somewhat broken, but project will get corrected on
* save and reload.
*/
p = strchr (t, ' ');
if (p)
addr = r_num_math (core->num, p+1);
}
if (!*t || n>0) {
RFlagItem *fi;
p = strchr (t, ' ');
if (p) {
*p = '\0';
strncpy (name, p+1, sizeof (name)-1);
} else
switch (type) {
case 'z':
type='s';
case 's':
// TODO: filter \n and so on :)
strncpy (name, t, sizeof (name)-1);
name[sizeof (name)-1] = '\0';
r_core_read_at (core, addr, (ut8*)name, sizeof (name)-1);
if (n < sizeof(name))
name[n] = '\0';
else name[sizeof (name)-1] = '\0';
break;
default:
fi = r_flag_get_i (core->flags, addr);
if (fi) strncpy (name, fi->name, sizeof (name)-1);
}
} else if (n<1) {
eprintf ("Invalid length %d\n", n);
return R_FALSE;
}
}
if (!n) n++;
addr_end = addr + n;
r_meta_add (core->anal, type, addr, addr_end, name);
free (t);
//r_meta_cleanup (core->anal->meta, 0LL, UT64_MAX);
break;
default:
eprintf ("Missing space after CC\n");
break;
}
return R_TRUE;
}
static int cmd_seek(void *data, const char *input) {
RCore *core = (RCore *) data;
char *cmd, *p;
ut64 off;
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 = -off;
}
}
int sign = 1;
if (input[0] == ' ') {
switch (input[1]) {
case '-':
sign = -1;
/* pass thru */
case '+':
input++;
break;
}
}
bool silent = false;
if (*input == 's') {
silent = true;
input++;
if (*input == '?') {
const char *help_message[] = {
"Usage: ss", "", " # Seek silently (not recorded in the seek history)",
"s?", "", "Works with all s subcommands",
NULL
};
r_core_cmd_help (core, help_message);
return 0;
}
}
switch (*input) {
case 'r':
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':
if (input[1] == '*') {
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 {
const char *help_msg[] = {
"Usage:", "sC", "Comment grep",
"sC", "*", "List all comments",
"sC", " str", "Seek to the first comment matching 'str'",
NULL
};
r_core_cmd_help (core, help_msg);
}
break;
case ' ':
if (!silent) {
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
}
r_core_seek (core, off * sign, 1);
r_core_block_read (core);
break;
case '/':
{
const char *pfx = r_config_get (core->config, "search.prefix");
ut64 from = r_config_get_i (core->config, "search.from");
// 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.count", 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", from);
r_config_set_i (core->config, "search.count", 0);
break;
case '?':
eprintf ("Usage: s/.. arg.\n");
r_cons_printf ("/?\n");
break;
default:
eprintf ("unknown search method\n");
break;
}
}
break;
case '.':
for (input++; *input == '.'; input++) {
;
}
r_core_seek_base (core, input);
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\n", 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 '*':
case '=':
case '!':
{
RList *list = r_io_sundo_list (core->io, input[0]);
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\n", f->name,
(int)(undo->off- f->offset));
} else {
name = strdup (f->name);
}
}
if (!name) {
name = strdup ("");
}
r_cons_printf ("0x%"PFMT64x" %s\n", undo->off, name);
free (name);
}
r_list_free (list);
}
}
static void diff_graph(RCore *c, RCore *c2, const char *arg) {
r_core_cmdf (c, "agd %s", arg);
}
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 int cmd_meta_comment(RCore *core, const char *input) {
ut64 addr = core->offset;
switch (input[1]) {
case '?': {
const char* help_msg[] = {
"Usage:", "CC[-+!*au] [base64:..|str] @ addr", "",
"CC", "", "list all comments in human friendly form",
"CC*", "", "list all comments in r2 commands",
"CC.", "", "show comment at current offset",
"CC,", " [file]", "show or set comment file",
"CC", " [text]", "append comment at current address",
"CCf", "", "list comments in function",
"CC+", " [text]", "append comment at current address",
"CC!", "", "edit comment using cfg.editor (vim, ..)",
"CC-", " @ cmt_addr", "remove comment at given address",
"CCu", " good boy @ addr", "add good boy comment at given address",
"CCu", " base64:AA== @ addr", "add comment in base64",
NULL};
r_core_cmd_help (core, help_msg);
} break;
case ',': // "CC,"
if (input[2]=='?') {
eprintf ("Usage: CC, [file]\n");
} else if (input[2]==' ') {
const char *fn = input+2;
char *comment = r_meta_get_string (core->anal, R_META_TYPE_COMMENT, addr);
while (*fn== ' ')fn++;
if (comment && *comment) {
// append filename in current comment
char *nc = r_str_newf ("%s ,(%s)", comment, fn);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, nc);
free (nc);
} else {
char *comment = r_str_newf (",(%s)", fn);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, comment);
free (comment);
}
} else {
char *comment = r_meta_get_string (core->anal, R_META_TYPE_COMMENT, addr);
if (comment && *comment) {
char *cmtfile = r_str_between (comment, ",(", ")");
if (cmtfile && *cmtfile) {
char *getcommapath(RCore *core);
char *cwd = getcommapath (core);
r_cons_printf ("%s"R_SYS_DIR"%s\n", cwd, cmtfile);
free (cwd);
}
free (cmtfile);
}
free (comment);
}
break;
case '.':
{
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (comment) {
r_cons_println (comment);
free (comment);
}
}
break;
case 0: // "CC"
r_meta_list (core->anal, R_META_TYPE_COMMENT, 0);
break;
case 'f': // "CCf"
r_meta_list_at (core->anal, R_META_TYPE_COMMENT, 'f', core->offset);
break;
case 'j': // "CCj"
r_meta_list (core->anal, R_META_TYPE_COMMENT, 'j');
break;
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal,
R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case '+':
case ' ':
{
const char* newcomment = r_str_chop_ro (input + 2);
char *text, *comment = r_meta_get_string (core->anal, R_META_TYPE_COMMENT, addr);
char *nc = strdup (newcomment);
r_str_unescape (nc);
if (comment) {
text = malloc (strlen (comment)+strlen (newcomment)+2);
if (text) {
strcpy (text, comment);
strcat (text, "\n");
strcat (text, nc);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, text);
free (text);
} else {
r_sys_perror ("malloc");
}
} else {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, nc);
}
free (nc);
}
break;
case '*':
r_meta_list (core->anal, R_META_TYPE_COMMENT, 1);
break;
case '-': // "CC-"
r_meta_del (core->anal, R_META_TYPE_COMMENT, core->offset, 1, NULL);
break;
case 'u':
//
{
char *newcomment;
const char *arg = input + 2;
while (*arg && *arg == ' ') arg++;
if (!strncmp (arg, "base64:", 7)) {
char *s = (char *)sdb_decode (arg+7, NULL);
if (s) {
newcomment = s;
} else {
newcomment = NULL;
}
} else {
newcomment = strdup (arg);
}
if (newcomment) {
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (!comment || (comment && !strstr (comment, newcomment))) {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, newcomment);
}
free (comment);
free (newcomment);
}
}
break;
case 'a':
{
char *s, *p;
s = strchr (input, ' ');
if (s) {
s = strdup (s + 1);
} else {
eprintf ("Usage\n");
return false;
}
p = strchr (s, ' ');
if (p) {
*p++ = 0;
}
ut64 addr;
if (input[2]=='-') {
if (input[3]) {
addr = r_num_math (core->num, input+3);
r_meta_del (core->anal,
R_META_TYPE_COMMENT,
addr, 1, NULL);
} else eprintf ("Usage: CCa-[address]\n");
free (s);
return true;
}
addr = r_num_math (core->num, s);
// Comment at
if (p) {
if (input[2]=='+') {
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT,
addr);
if (comment) {
char* text = r_str_newf ("%s\n%s", comment, p);
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, text);
free (text);
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, p);
}
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr + 1, p);
}
} else {
eprintf ("Usage: CCa [address] [comment]\n");
}
free (s);
return true;
}
}
return true;
}
static int cmd_type(void *data, const char *input) {
RCore *core = (RCore*)data;
switch (input[0]) {
// t [typename] - show given type in C syntax
case 'k':
if (input[1]==' ') {
sdb_query (core->anal->sdb_types, input+2);
} else sdb_query (core->anal->sdb_types, "*");
break;
case 's':
{
char *q, *p, *o, *e;
p = o = strdup (input+1);
for (;;) {
if (*p == '\0'){
eprintf ("Usage: ts <k>=<v> Set fields at curseek linked type\n");
break;
}
q = strchr (p, ' ');
if (q) *q = 0;
if (!*p) {
p++;
continue;
}
e = strchr (p, '=');
if (e) {
*e = 0;
r_anal_type_set (core->anal, core->offset,
p, r_num_math (core->num, e+1));
} else eprintf ("TODO: implement get\n");
if (!q) break;
p = q+1;
}
free (o);
}
break;
case 'b':
{
int i;
char *p, *s = (strlen (input) > 1) ? strdup (input+2): NULL;
const char *isenum;
p = s ? strchr (s, ' ') : NULL;
if (p) {
*p++ = 0;
// dupp in core.c (see getbitfield())
#if 1
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strcmp (isenum, "enum")) {
int empty = 1;
ut32 num = (ut32)r_num_math (core->num, p);
r_cons_printf ("0x%08"PFMT64x" : ", num);
for (i=0; i< 32; i++) {
if (num & (1<<i)) {
const char *q = sdb_fmt (0, "%s.0x%x", s, (1<<i));
const char *res = sdb_const_get (core->anal->sdb_types, q, 0);
if (!empty)
r_cons_printf (" | ");
if (res) r_cons_printf ("%s", res);
else r_cons_printf ("0x%x", (1<<i));
empty = 0;
}
}
} else {
eprintf ("This is not an enum\n");
}
#endif
} else {
eprintf ("Missing value\n");
}
free (s);
}
break;
case 'e':
{
if (!input[1]) {
eprintf ("Missing value\n");
break;
}
char *p, *s = strdup (input+2);
const char *isenum;
p = strchr (s, ' ');
if (p) {
*p++ = 0;
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strcmp (isenum, "enum")) {
const char *q = sdb_fmt (0, "%s.0x%x", s, (ut32)r_num_math (core->num, p));
const char *res = sdb_const_get (core->anal->sdb_types, q, 0);
if (res)
r_cons_printf ("%s\n", res);
} else {
eprintf ("This is not an enum\n");
}
} else {
eprintf ("Missing value\n");
}
free (s);
}
break;
case ' ':
{
const char *isenum = sdb_const_get (core->anal->sdb_types, input+2, 0);
if (isenum && !strcmp (isenum, "enum")) {
eprintf ("IS ENUM! \n");
} else {
char *fmt = r_anal_type_format (core->anal, input +1);
if (fmt) {
r_cons_printf ("pf %s\n", fmt);
free (fmt);
} else eprintf ("Cannot find '%s' type\n", input+1);
}
}
break;
#if 0
// t* - list all types in 'pf' syntax
case '*':
r_anal_type_list (core->anal, R_ANAL_TYPE_ANY, 1);
break;
#endif
case 0:
sdb_foreach (core->anal->sdb_types, sdbforcb, core);
break;
case 'o':
if (input[1] == ' ') {
const char *filename = input + 2;
if (!strcmp (filename, "-")) {
char *out, *tmp;
tmp = r_core_editor (core, NULL, "");
if (tmp) {
out = r_parse_c_string (tmp);
if (out) {
// r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
free (tmp);
}
} else {
char *out = r_parse_c_file (filename);
if (out) {
// r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
//r_anal_type_loadfile (core->anal, filename);
}
}
break;
// td - parse string with cparse engine and load types from it
case 'd':
if (input[1] == '?') {
const char * help_message[] = {
"Usage:", "td[...]", "",
"td", "[string]", "Load types from string",
NULL
};
r_core_cmd_help(core, help_message);
} else
if (input[1] == '-') {
const char *arg = strchr (input+1, ' ');
if (arg) arg++; else arg = input+2;
r_anal_type_del (core->anal, arg);
} else
if (input[1] == ' ') {
char tmp[8192];
snprintf (tmp, sizeof (tmp)-1, "%s;", input+2);
//const char *string = input + 2;
//r_anal_str_to_type (core->anal, string);
char *out = r_parse_c_string (tmp);
if (out) {
//r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
} else {
eprintf ("Invalid use of td. See td? for help\n");
}
break;
// tl - link a type to an address
case 'l':
if (input[1]=='?') {
const char * help_message[] = {
"Usage: tl", " [typename|addr] ([addr])@[addr|function]", "",
NULL
};
r_core_cmd_help(core, help_message);
} else if (input[1]) {
ut64 addr = r_num_math (core->num, input+2);
char *ptr = strchr (input + 2, ' ');
if (ptr) {
addr = r_num_math (core->num, ptr + 1);
*ptr = '\0';
} else addr = core->offset;
r_anal_type_link (core->anal, input+2, addr);
} else {
r_core_cmd0 (core, "t~^link");
}
break;
case '-':
if (input[1] == '?') {
const char * help_message[] = {
"Usage: t-", " <type>", "Delete type by its name",
NULL
};
r_core_cmd_help(core, help_message);
} else
if (input[1]=='*') {
eprintf ("TODO\n");
} else {
const char *name = input + 1;
if (*name==' ') name++;
if (*name) {
r_anal_type_del (core->anal, name);
} else eprintf ("Invalid use of t- . See t-? for help.\n");
}
break;
// tv - get/set type value linked to a given address
case 'f':
{
ut64 addr;
char *fmt, key[128];
const char *type;
if (input[1]) {
addr = r_num_math (core->num, input+1);
} else addr = core->offset;
snprintf (key, sizeof (key), "link.%08"PFMT64x, addr);
type = sdb_const_get (core->anal->sdb_types, key, 0);
if (type) {
fmt = r_anal_type_format (core->anal, type);
r_cons_printf ("struct %s {\n", type);
if (fmt) {
r_core_cmdf (core, "pf %s @ 0x%08"PFMT64x"\n", fmt, addr);
free (fmt);
}// else eprintf ("Cannot find '%s' type\n", input+1);
r_cons_printf ("}\n");
} //else eprintf ("Cant find type at 0x%llx\n", addr);
}
break;
case '?':
show_help (core);
break;
}
return true;
}
static int cmd_seek(void *data, const char *input) {
RCore *core = (RCore *)data;
char *cmd, *p;
ut64 off;
if (*input == 'r') {
if (input[1] && input[2]) {
if (core->io->debug) {
off = r_debug_reg_get (core->dbg, input + 2);
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek (core, off, 1);
} else {
RReg *orig = core->dbg->reg;
core->dbg->reg = core->anal->reg;
off = r_debug_reg_get (core->dbg, input + 2);
core->dbg->reg = orig;
r_core_seek (core, off, 1);
}
} else eprintf ("|Usage| 'sr PC' seek to program counter register\n");
}
if (*input) {
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, ' ');
int sign = 1;
{
const char *u_num = inputnum? inputnum + 1: input + 1;
off = r_num_math (core->num, u_num);
if (*u_num == '-') off = -off;
}
#if 0
if (input[0]!='/' && inputnum && isalpha (inputnum[0]) && off == 0) {
if (!r_flag_get (core->flags, inputnum)) {
eprintf ("Cannot find address for '%s'\n", inputnum);
return false;
}
}
#endif
if (input[0]==' ') {
switch (input[1]) {
case '-': sign=-1;
case '+': input++; break;
}
}
switch (*input) {
case 'C':
if (input[1]=='*') {
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;
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 {
const char *help_msg[] = {
"Usage:", "sC", "Comment grep",
"sC", "*", "List all comments",
"sC", " str", "Seek to the first comment matching 'str'",
NULL };
r_core_cmd_help (core, help_msg);
}
break;
case ' ':
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek (core, off * sign, 1);
r_core_block_read (core);
break;
case '/':
{
const char *pfx = r_config_get (core->config, "search.prefix");
ut64 from = r_config_get_i (core->config, "search.from");
//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.count", 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", from);
r_config_set_i (core->config, "search.count", 0);
break;
case '?':
eprintf ("Usage: s/.. arg.\n");
r_cons_printf ("/?\n");
break;
default:
eprintf ("unknown search method\n");
break;
}
}
break;
case '.':
for (input++;*input=='.';input++);
r_core_seek_base (core, input);
break;
case '*':
case '=':
case 'j':
r_io_sundo_list (core->io, input[0]);
break;
case '+':
if (input[1]!='\0') {
int delta = (input[1]=='+')? core->blocksize: off;
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek_delta (core, delta);
} else {
RIOUndos *undo = r_io_sundo_redo (core->io);
if (undo != NULL)
r_core_seek (core, undo->off, 0);
}
break;
case '-':
if (input[1]!='\0') {
int delta = (input[1]=='-') ? -core->blocksize: -off;
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek_delta (core, delta);
} else {
RIOUndos *undo = r_io_sundo (core->io, core->offset);
if (undo) {
r_core_seek (core, undo->off, 0);
r_core_block_read (core);
}
}
break;
case 'n':
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek_next (core, r_config_get (core->config, "scr.nkey"));
break;
case 'p':
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek_previous (core, r_config_get (core->config, "scr.nkey"));
break;
case 'a':
off = core->blocksize;
if (input[1]&&input[2]) {
cmd = strdup (input);
p = strchr (cmd+2, ' ');
if (p) {
off = r_num_math (core->num, p+1);;
*p = '\0';
}
cmd[0] = 's';
// perform real seek if provided
r_cmd_call (core->rcmd, cmd);
free (cmd);
}
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_seek_align (core, off, 0);
break;
case 'b':
if (off == 0)
off = core->offset;
r_io_sundo_push (core->io, core->offset, r_print_get_cursor (core->print));
r_core_anal_bb_seek (core, off);
break;
case 'f': // "sf"
if (strlen(input) > 2 && input[1]==' ') {
RAnalFunction *fcn = r_anal_fcn_find_name (core->anal, input+2);
if (fcn) {
r_core_seek (core, fcn->addr, 1);
}
break;
}
RAnalFunction *fcn = r_anal_get_fcn_in (core->anal, core->offset, 0);
if (fcn) {
r_core_seek (core, fcn->addr + r_anal_fcn_size (fcn), 1);
}
break;
case 'o': // "so"
{
RAnalOp op;
int val=0, ret, i, n = r_num_math (core->num, input+1);
if (n==0) n = 1;
if (n<0) {
int instr_len;
ut64 addr = core->offset;
int numinstr = n * -1;
if (r_core_prevop_addr (core, core->offset, numinstr, &addr)) {
ret = core->offset - addr;
} else {
ret = r_core_asm_bwdis_len (core, &instr_len, &addr, numinstr);
}
r_core_seek (core, addr, true);
val += ret;
} else {
for (val=i=0; i<n; i++) {
ret = r_anal_op (core->anal, &op,
core->offset, core->block, core->blocksize);
if (ret<1)
ret = 1;
r_core_seek_delta (core, ret);
val += ret;
}
}
core->num->value = val;
}
break;
case 'g': // "sg"
{
RIOSection *s = r_io_section_vget (core->io, core->offset);
if (s) r_core_seek (core, s->vaddr, 1);
else r_core_seek (core, 0, 1);
}
break;
case 'G': // "sG"
{
if (!core->file) break;
RIOSection *s = r_io_section_vget (core->io, core->offset);
// XXX: this +2 is a hack. must fix gap between sections
if (s) r_core_seek (core, s->vaddr+s->size+2, 1);
else r_core_seek (core, r_io_desc_size (core->io, core->file->desc), 1);
}
break;
case 'l': // "sl"
{
int sl_arg = r_num_math (core->num, input+1);
const char *help_msg[] = {
"Usage:", "sl+ or sl- or slc", "",
"sl", " [line]", "Seek to absolute line",
"sl", "[+-][line]", "Seek to relative line",
"slc", "", "Clear line cache",
"sll", "", "Show total number of lines",
NULL };
switch (input[1]) {
case 0:
if (!core->print->lines_cache) {
__init_seek_line (core);
}
__get_current_line (core);
break;
case ' ':
if (!core->print->lines_cache) {
__init_seek_line (core);
}
__seek_line_absolute (core, sl_arg);
break;
case '+':
case '-':
if (!core->print->lines_cache) {
__init_seek_line (core);
}
__seek_line_relative (core, sl_arg);
break;
case 'c':
__clean_lines_cache (core);
break;
case 'l':
if (!core->print->lines_cache) {
__init_seek_line (core);
}
eprintf ("%d lines\n", core->print->lines_cache_sz-1);
break;
case '?':
r_core_cmd_help (core, help_msg);
break;
}
}
break;
case ':':
printPadded (core, atoi (input + 1));
break;
case '?': {
const char * help_message[] = {
"Usage: s", "", " # Seek commands",
"s", "", "Print current address",
"s:", "pad", "Print current address with N padded zeros (defaults to 8)",
"s", " addr", "Seek to address",
"s-", "", "Undo seek",
"s-", " n", "Seek n bytes backward",
"s--", "", "Seek blocksize bytes backward",
"s+", "", "Redo seek",
"s+", " n", "Seek n bytes forward",
"s++", "", "Seek blocksize bytes forward",
"s[j*=]", "", "List undo seek history (JSON, =list, *r2)",
"s/", " DATA", "Search for next occurrence of 'DATA'",
"s/x", " 9091", "Search for next occurrence of \\x90\\x91",
"s.", "hexoff", "Seek honoring a base from core->offset",
"sa", " [[+-]a] [asz]", "Seek asz (or bsize) aligned to addr",
"sb", "", "Seek aligned to bb start",
"sC", "[?] string", "Seek to comment matching given string",
"sf", "", "Seek to next function (f->addr+f->size)",
"sf", " function", "Seek to address of specified function",
"sg/sG", "", "Seek begin (sg) or end (sG) of section or file",
"sl", "[?] [+-]line", "Seek to line",
"sn/sp", "", "Seek next/prev scr.nkey",
"so", " [N]", "Seek to N next opcode(s)",
"sr", " pc", "Seek to register",
//"sp [page] seek page N (page = block)",
NULL
};
r_core_cmd_help(core, help_message);
}
break;
}
} else r_cons_printf ("0x%"PFMT64x"\n", core->offset);
return 0;
}
static int cmd_meta_hsdmf(RCore *core, const char *input) {
int n, type = input[0];
char *t = 0, *p, name[256];
int repeat = 1;
ut64 addr_end = 0LL, addr = core->offset;
switch (input[1]) {
case '?':
eprintf ("See C?\n");
break;
case '-':
switch (input[2]) {
case '*':
core->num->value = r_meta_del (core->anal,
input[0], 0, UT64_MAX, NULL);
break;
case ' ':
addr = r_num_math (core->num, input+3);
/* fallthrough */
default:
core->num->value = r_meta_del (core->anal,
input[0], addr, 1, NULL);
break;
}
break;
case '*':
r_meta_list (core->anal, input[0], 1);
break;
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case ' ':
case '\0':
if (type != 'z' && input[1] == '*') {
r_meta_list (core->anal, type, 0);
break;
}
if (type == 'z') {
type = 's';
}
if (strlen (input) > 2) {
char *rep = strchr (input + 2, '[');
if (!rep) rep = strchr (input + 2, ' ');
if (rep) {
repeat = r_num_get (core->num, rep + 1);
}
}
int repcnt = 0;
if (repeat < 1) {
repeat = 1;
}
while (repcnt < repeat) {
t = strdup (r_str_chop_ro (input + 1));
p = NULL;
n = 0;
strncpy (name, t, sizeof (name) - 1);
if (type != 'C') {
n = r_num_math (core->num, t);
if (type == 'f') { // "Cf"
p = strchr (t, ' ');
if (p) {
if (n < 1) {
n = r_print_format_struct_size (p + 1, core->print, 0);
if (n < 1) {
eprintf ("Cannot resolve struct size\n");
n = 32; //
}
}
int r = r_print_format (core->print, addr, core->block,
n, p + 1, 0, NULL, NULL);
if (r < 0) {
n = -1;
}
} else {
eprintf ("Usage: Cf [size] [pf-format-string]\n");
break;
}
} else if (type == 's') { //Cs
char tmp[256] = {0};
int i, j, name_len = 0;
(void)r_core_read_at (core, addr, (ut8*)tmp, sizeof (tmp) - 1);
name_len = r_str_nlen_w (tmp, sizeof (tmp));
//handle wide strings
for (i = 0, j = 0; i < sizeof (name); i++, j++) {
name[i] = tmp[j];
if (!tmp[j]) {
break;
}
if (!tmp[j + 1]) {
if (j + 3 < sizeof (tmp)) {
if (tmp[j + 3]) {
break;
}
}
j++;
}
}
name[sizeof (name) - 1] = '\0';
if (n == 0) {
n = name_len + 1;
} else {
if (n > 0 && n < name_len) {
name[n] = 0;
}
}
}
if (n < 1) {
/* invalid length, do not insert into db */
return false;
}
if (!*t || n > 0) {
RFlagItem *fi;
p = strchr (t, ' ');
if (p) {
*p = '\0';
strncpy (name, p + 1, sizeof (name)-1);
} else {
if (type != 's') {
fi = r_flag_get_i (core->flags, addr);
if (fi) strncpy (name, fi->name, sizeof (name)-1);
}
}
}
}
if (!n) {
n++;
}
addr_end = addr + n;
r_meta_add (core->anal, type, addr, addr_end, name);
free (t);
repcnt ++;
addr = addr_end;
}
//r_meta_cleanup (core->anal->meta, 0LL, UT64_MAX);
break;
default:
eprintf ("Missing space after CC\n");
break;
}
return true;
}
static int cmd_seek(void *data, const char *input) {
RCore *core = (RCore *)data;
char *cmd, *p;
ut64 off;
if (*input=='r') {
if (input[1] && input[2]) {
if (core->io->debug) {
off = r_debug_reg_get (core->dbg, input+2);
r_io_sundo_push (core->io, core->offset);
r_core_seek (core, off, 1);
} else {
RReg *orig = core->dbg->reg;
core->dbg->reg = core->anal->reg;
off = r_debug_reg_get (core->dbg, input+2);
core->dbg->reg = orig;
r_core_seek (core, off, 1);
}
} else eprintf ("|Usage| 'sr pc' seek to program counter register\n");
} else
if (*input) {
const char *inputnum = strchr (input+1, ' ');
int sign = 1;
inputnum = inputnum? inputnum+1: input+1;
off = r_num_math (core->num, inputnum);
if (*inputnum== '-') off = -off;
#if 0
if (input[0]!='/' && inputnum && isalpha (inputnum[0]) && off == 0) {
if (!r_flag_get (core->flags, inputnum)) {
eprintf ("Cannot find address for '%s'\n", inputnum);
return R_FALSE;
}
}
#endif
if (input[0]==' ') {
switch (input[1]) {
case '-': sign=-1;
case '+': input++; break;
}
}
switch (*input) {
case 'C':
if (input[1]=='*') {
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;
r_io_sundo_push (core->io, core->offset);
r_core_seek (core, off, 1);
r_core_block_read (core, 0);
break;
default:
eprintf ("Too many results\n");
break;
}
free (cb.str);
} else eprintf ("Usage: sC[?*] comment-grep\n"
"sC* list all comments\n"
"sC const seek to comment matching 'const'\n");
break;
case ' ':
r_io_sundo_push (core->io, core->offset);
r_core_seek (core, off*sign, 1);
r_core_block_read (core, 0);
break;
case '/':
{
const char *pfx = r_config_get (core->config, "search.prefix");
//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 'x':
r_config_set_i (core->config, "search.count", 1);
r_core_cmdf (core, "s+1; p8 ; .%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.count", 0);
break;
default:
eprintf ("unknown search method\n");
break;
}
}
break;
case '.':
for (input++;*input=='.';input++);
r_core_seek_base (core, input);
break;
case '*':
r_io_sundo_list (core->io);
break;
case '+':
if (input[1]!='\0') {
int delta = (input[1]=='+')? core->blocksize: off;
r_io_sundo_push (core->io, core->offset);
r_core_seek_delta (core, delta);
} else {
off = r_io_sundo_redo (core->io);
if (off != UT64_MAX)
r_core_seek (core, off, 0);
}
break;
case '-':
if (input[1]!='\0') {
int delta = (input[1]=='-') ? -core->blocksize: -off;
r_io_sundo_push (core->io, core->offset);
r_core_seek_delta (core, delta);
} else {
off = r_io_sundo (core->io, core->offset);
if (off != UT64_MAX)
r_core_seek (core, off, 0);
}
break;
case 'n':
r_io_sundo_push (core->io, core->offset);
r_core_seek_next (core, r_config_get (core->config, "scr.nkey"));
break;
case 'p':
r_io_sundo_push (core->io, core->offset);
r_core_seek_previous (core, r_config_get (core->config, "scr.nkey"));
break;
case 'a':
off = core->blocksize;
if (input[1]&&input[2]) {
cmd = strdup (input);
p = strchr (cmd+2, ' ');
if (p) {
off = r_num_math (core->num, p+1);;
*p = '\0';
}
cmd[0] = 's';
// perform real seek if provided
r_cmd_call (core->rcmd, cmd);
free (cmd);
}
r_io_sundo_push (core->io, core->offset);
r_core_seek_align (core, off, 0);
break;
case 'b':
if (off == 0)
off = core->offset;
r_io_sundo_push (core->io, core->offset);
r_core_anal_bb_seek (core, off);
break;
case 'f':
if (strlen(input) > 2 && input[1]==' ') {
RAnalFunction *fcn = r_anal_fcn_find_name (core->anal, input+2);
if (fcn) {
r_core_seek (core, fcn->addr, 1);
}
break;
}
RAnalFunction *fcn = r_anal_fcn_find (core->anal, core->offset, 0);
if (fcn) {
r_core_seek (core, fcn->addr+fcn->size, 1);
}
break;
case 'o':
{
RAnalOp op;
int val=0, ret, i, n = r_num_math (core->num, input+1);
if (n==0) n = 1;
if (n<0) {
int ret = prevopsz (core, n);
ret = r_anal_op (core->anal, &op,
core->offset, core->block, core->blocksize);
val += ret;
} else
for (val=i=0; i<n; i++) {
ret = r_anal_op (core->anal, &op,
core->offset, core->block, core->blocksize);
if (ret<1)
break;
r_core_seek_delta (core, ret);
val += ret;
}
core->num->value = val;
}
break;
case 'g':
{
RIOSection *s = r_io_section_vget (core->io, core->offset);
if (s) r_core_seek (core, s->vaddr, 1);
else r_core_seek (core, 0, 1);
}
break;
case 'G':
{
RIOSection *s = r_io_section_vget (core->io, core->offset);
// XXX: this +2 is a hack. must fix gap between sections
if (s) r_core_seek (core, s->vaddr+s->size+2, 1);
else r_core_seek (core, core->file->size, 1);
}
break;
case '?': {
const char * help_message[] = {
"Usage: s", "", " # Seek commands",
"s", "", "Print current address",
"s", " addr", "Seek to address",
"s-", "", "Undo seek",
"s-", " n", "Seek n bytes backward",
"s--", "", "Seek blocksize bytes backward",
"s+", "", "Redo seek",
"s+", " n", "Seek n bytes forward",
"s++", "", "Seek blocksize bytes forward",
"s*", "", "List undo seek history",
"s/", " DATA", "Search for next occurrence of 'DATA'",
"s/x", " 9091", "Search for next occurrence of \\x90\\x91",
"s.", "hexoff", "Seek honoring a base from core->offset",
"sa", " [[+-]a] [asz]", "Seek asz (or bsize) aligned to addr",
"sb", "", "Seek aligned to bb start",
"sC", " string", "Seek to comment matching given string",
"sf", "", "Seek to next function (f->addr+f->size)",
"sf", " function", "Seek to address of specified function",
"sg/sG", "", "Seek begin (sg) or end (sG) of section or file",
"sn/sp", "", "Seek next/prev scr.nkey",
"so", " [N]", "Seek to N next opcode(s)",
"sr", " pc", "Seek to register",
//"sp [page] seek page N (page = block)",
NULL
};
r_core_cmd_help(core, help_message);
}
break;
}
} else r_cons_printf ("0x%"PFMT64x"\n", core->offset);
return 0;
}
R_API bool r_core_hack_x86(RCore *core, const char *op, const RAnalOp *analop) {
const ut8 *b = core->block;
int i, size = analop->size;
if (!strcmp (op, "nop")) {
if (size * 2 + 1 < size) return false;
char *str = malloc (size * 2 + 1);
if (!str) {
return false;
}
for (i = 0; i < size; i++)
memcpy (str + (i * 2), "90", 2);
str[size*2] = '\0';
r_core_cmdf (core, "wx %s\n", str);
free (str);
} else if (!strcmp (op, "trap")) {
r_core_cmd0 (core, "wx cc\n");
} else if (!strcmp (op, "jz")) {
if (b[0] == 0x75) {
r_core_cmd0 (core, "wx 74\n");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "jnz")) {
if (b[0] == 0x74) {
r_core_cmd0 (core, "wx 75\n");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "nocj")) {
if (*b == 0xf) {
r_core_cmd0 (core, "wx 90e9");
} else if (b[0] >= 0x70 && b[0] <= 0x7f) {
r_core_cmd0 (core, "wx eb");
} else {
eprintf ("Current opcode is not conditional\n");
return false;
}
} else if (!strcmp (op, "recj")) {
int is_near = (*b == 0xf);
if (b[0] < 0x80 && b[0] >= 0x70) { // short jmps: jo, jno, jb, jae, je, jne, jbe, ja, js, jns
r_core_cmdf (core, "wx %x\n", (b[0]%2)? b[0] - 1: b[0] + 1);
} else if (is_near && b[1] < 0x90 && b[1] >= 0x80) { // near jmps: jo, jno, jb, jae, je, jne, jbe, ja, js, jns
r_core_cmdf (core, "wx 0f%x\n", (b[1]%2)? b[1] - 1: b[1] + 1);
} else {
eprintf ("Invalid conditional jump opcode\n");
return false;
}
} else if (!strcmp (op, "ret1")) {
r_core_cmd0 (core, "wx c20100\n");
} else if (!strcmp (op, "ret0")) {
r_core_cmd0 (core, "wx c20000\n");
} else if (!strcmp (op, "retn")) {
r_core_cmd0 (core, "wx c2ffff\n");
} else {
eprintf ("Invalid operation '%s'\n", op);
return false;
}
return true;
}
static int cmd_meta_comment(RCore *core, const char *input) {
ut64 addr = core->offset;
switch (input[1]) {
case '?': {
const char* help_msg[] = {
"Usage:", "CC[-+!*au] [base64:..|str] @ addr", "",
"CC", "", "list all comments in human friednly form",
"CC*", "", "list all comments in r2 commands",
"CC.", "", "show comment at current offset",
"CC", " or maybe not", "append comment at current address",
"CC+", " same as above", "append comment at current address",
"CC!", "", "edit comment using cfg.editor (vim, ..)",
"CC-", " @ cmt_addr", "remove comment at given address",
"CCu", " good boy @ addr", "add good boy comment at given address",
"CCu", " base64:AA== @ addr", "add comment in base64",
NULL};
r_core_cmd_help (core, help_msg);
} break;
case '.':
{
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (comment) {
r_cons_printf ("%s\n", comment);
free (comment);
}
}
break;
case 0:
r_meta_list (core->anal, R_META_TYPE_COMMENT, 0);
break;
case '!':
{
char *out, *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
out = r_core_editor (core, NULL, comment);
if (out) {
//r_meta_add (core->anal->meta, R_META_TYPE_COMMENT, addr, 0, out);
r_core_cmdf (core, "CC-@0x%08"PFMT64x, addr);
//r_meta_del (core->anal->meta, input[0], addr, addr+1, NULL);
r_meta_set_string (core->anal,
R_META_TYPE_COMMENT, addr, out);
free (out);
}
free (comment);
}
break;
case '+':
case ' ':
{
const char* newcomment = input+2;
char *text, *nc;
while (*newcomment==' ') newcomment++;
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
nc = strdup (newcomment);
r_str_unescape (nc);
if (comment) {
text = malloc (strlen (comment)+strlen (newcomment)+2);
strcpy (text, comment);
strcat (text, "\n");
strcat (text, nc);
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, text);
free (text);
} else {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, nc);
}
free (nc);
}
break;
case '*':
r_meta_list (core->anal, R_META_TYPE_COMMENT, 1);
break;
case '-':
r_meta_del (core->anal, R_META_TYPE_COMMENT, core->offset, 1, NULL);
break;
case 'u':
//
{
char *newcomment;
const char *arg = input+2;
while (*arg && *arg == ' ') arg++;
if (!strncmp (arg, "base64:", 7)) {
char *s = (char *)sdb_decode (arg+7, NULL);
if (s) {
newcomment = s;
} else {
newcomment = NULL;
}
} else {
newcomment = strdup (arg);
}
if (newcomment) {
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT, addr);
if (!comment || (comment && !strstr (comment, newcomment))) {
r_meta_set_string (core->anal, R_META_TYPE_COMMENT,
addr, newcomment);
}
free (comment);
free (newcomment);
}
}
break;
case 'a':
{
char *s, *p;
s = strchr (input, ' ');
if (s) {
s = strdup (s+1);
} else {
eprintf ("Usage\n");
return R_FALSE;
}
p = strchr (s, ' ');
if (p) *p++ = 0;
ut64 addr;
if (input[2]=='-') {
if (input[3]) {
addr = r_num_math (core->num, input+3);
r_meta_del (core->anal,
R_META_TYPE_COMMENT,
addr, 1, NULL);
} else eprintf ("Usage: CCa-[address]\n");
free (s);
return R_TRUE;
}
addr = r_num_math (core->num, s);
// Comment at
if (p) {
if (input[2]=='+') {
char *text = p;
char *comment = r_meta_get_string (
core->anal, R_META_TYPE_COMMENT,
addr);
if (comment) {
text = malloc (strlen (comment) + strlen (p)+2);
strcpy (text, comment);
strcat (text, "\n");
strcat (text, p);
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, text);
free (text);
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, p);
}
} else {
r_meta_add (core->anal,
R_META_TYPE_COMMENT,
addr, addr+1, p);
}
} else eprintf ("Usage: CCa [address] [comment]\n");
free (s);
return R_TRUE;
}
}
return R_TRUE;
}
R_API bool r_core_hack_arm(RCore *core, const char *op, const RAnalOp *analop) {
const int bits = core->assembler->bits;
const ut8 *b = core->block;
if (!strcmp (op, "nop")) {
const int nopsize = (bits==16)? 2: 4;
const char *nopcode = (bits==16)? "00bf":"0000a0e1";
const int len = analop->size;
char* str;
int i;
if (len % nopsize) {
eprintf ("Invalid nopcode size\n");
return false;
}
str = calloc (len + 1, 2);
if (!str) {
return false;
}
for (i=0; i < len; i+=nopsize) {
memcpy (str + i * 2, nopcode, nopsize*2);
}
str[len*2] = '\0';
r_core_cmdf (core, "wx %s\n", str);
free (str);
} else if (!strcmp (op, "trap")) {
const char* trapcode = (bits==16)? "bebe": "fedeffe7";
r_core_cmdf (core, "wx %s\n", trapcode);
} else if (!strcmp (op, "jz")) {
if (bits == 16) {
switch (b[1]) {
case 0xb9: // CBNZ
r_core_cmd0 (core, "wx b1 @@ $$+1\n"); //CBZ
break;
case 0xbb: // CBNZ
r_core_cmd0 (core, "wx b3 @@ $$+1\n"); //CBZ
break;
case 0xd1: // BNE
r_core_cmd0 (core, "wx d0 @@ $$+1\n"); //BEQ
break;
default:
eprintf ("Current opcode is not conditional\n");
return false;
}
} else {
eprintf ("ARM jz hack not supported\n");
return false;
}
} else if (!strcmp (op, "jnz")) {
if (bits == 16) {
switch (b[1]) {
case 0xb1: // CBZ
r_core_cmd0 (core, "wx b9 @@ $$+1\n"); //CBNZ
break;
case 0xb3: // CBZ
r_core_cmd0 (core, "wx bb @@ $$+1\n"); //CBNZ
break;
case 0xd0: // BEQ
r_core_cmd0 (core, "wx d1 @@ $$+1\n"); //BNE
break;
default:
eprintf ("Current opcode is not conditional\n");
return false;
}
} else {
eprintf ("ARM jnz hack not supported\n");
return false;
}
} else if (!strcmp (op, "nocj")) {
// TODO: drop conditional bit instead of that hack
if (bits == 16) {
switch (b[1]) {
case 0xb1: // CBZ
case 0xb3: // CBZ
case 0xd0: // BEQ
case 0xb9: // CBNZ
case 0xbb: // CBNZ
case 0xd1: // BNE
r_core_cmd0 (core, "wx e0 @@ $$+1\n"); //BEQ
break;
default:
eprintf ("Current opcode is not conditional\n");
return false;
}
} else {
eprintf ("ARM un-cjmp hack not supported\n");
return false;
}
} else if (!strcmp (op, "recj")) {
eprintf ("TODO: use jnz or jz\n");
return false;
} else if (!strcmp (op, "ret1")) {
if (bits == 16)
r_core_cmd0 (core, "wx 01207047 @@ $$+1\n"); // mov r0, 1; bx lr
else
r_core_cmd0 (core, "wx 0100b0e31eff2fe1 @@ $$+1\n"); // movs r0, 1; bx lr
} else if (!strcmp (op, "ret0")) {
if (bits == 16)
r_core_cmd0 (core, "wx 00207047 @@ $$+1\n"); // mov r0, 0; bx lr
else
r_core_cmd0 (core, "wx 0000a0e31eff2fe1 @@ $$+1\n"); // movs r0, 0; bx lr
} else if (!strcmp (op, "retn")) {
if (bits == 16)
r_core_cmd0 (core, "wx ff207047 @@ $$+1\n"); // mov r0, -1; bx lr
else
r_core_cmd0 (core, "wx ff00a0e31eff2fe1 @@ $$+1\n"); // movs r0, -1; bx lr
} else {
eprintf ("Invalid operation\n");
return false;
}
return true;
}
static int cmd_type(void *data, const char *input) {
RCore *core = (RCore*)data;
switch (input[0]) {
// t [typename] - show given type in C syntax
case 's':
{
char *q, *p, *o, *e;
p = o = strdup (input+1);
for (;;) {
q = strchr (p, ' ');
if (q) *q = 0;
if (!*p) {
p++;
continue;
}
e = strchr (p, '=');
if (e) {
*e = 0;
r_anal_type_set (core->anal, core->offset,
p, r_num_math (core->num, e+1));
} else eprintf ("TODO: implement get\n");
if (!q) break;
p = q+1;
}
free (o);
}
break;
case ' ':
{
char *fmt = r_anal_type_format (core->anal, input +1);
if (fmt) {
r_cons_printf ("pf %s\n", fmt);
free (fmt);
} else eprintf ("Cannot find '%s' type\n", input+1);
}
break;
#if 0
// t* - list all types in 'pf' syntax
case '*':
r_anal_type_list (core->anal, R_ANAL_TYPE_ANY, 1);
break;
#endif
case 0:
// TODO: use r_cons here
//sdb_list (core->anal->sdb_types);
sdb_foreach (core->anal->sdb_types, sdbforcb, core);
break;
case 'o':
if (input[1] == ' ') {
const char *filename = input + 2;
if (!strcmp (filename, "-")) {
char *out, *tmp;
tmp = r_core_editor (core, "");
if (tmp) {
out = r_parse_c_string (tmp);
if (out) {
r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
free (tmp);
}
} else {
char *out = r_parse_c_file (filename);
if (out) {
r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
//r_anal_type_loadfile (core->anal, filename);
}
}
break;
// td - parse string with cparse engine and load types from it
case 'd':
if (input[1] == '?') {
const char * help_message[] = {
"Usage:", "td[...]", "",
"td", "[string]", "Load types from string",
NULL
};
r_core_cmd_help(core, help_message);
} else
if (input[1] == '-') {
const char *arg = strchr (input+1, ' ');
if (arg) arg++; else arg = input+2;
r_anal_type_del (core->anal, arg);
} else
if (input[1] == ' ') {
char tmp[256];
snprintf (tmp, sizeof (tmp), "%s;", input+2);
//const char *string = input + 2;
//r_anal_str_to_type (core->anal, string);
char *out = r_parse_c_string (tmp);
if (out) {
r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
} else {
eprintf ("Invalid use of td. See td? for help\n");
}
break;
// tl - link a type to an address
case 'l':
if (input[1]=='?') {
const char * help_message[] = {
"Usage: tl", " [typename|addr] ([addr])@[addr|function]", "",
NULL
};
r_core_cmd_help(core, help_message);
} else if (input[1]) {
ut64 addr = r_num_math (core->num, input+2);
char *ptr = strchr (input + 2, ' ');
if (ptr) {
addr = r_num_math (core->num, ptr + 1);
*ptr = '\0';
} else addr = core->offset;
r_anal_type_link (core->anal, input+2, addr);
} else {
r_core_cmd0 (core, "t~^link");
}
break;
case '-':
if (input[1] == '?') {
const char * help_message[] = {
"Usage: t-", " <type>", "Delete type by its name",
NULL
};
r_core_cmd_help(core, help_message);
} else
if (input[1]=='*') {
eprintf ("TODO\n");
} else {
const char *name = input + 1;
if (*name==' ') name++;
if (*name) {
r_anal_type_del (core->anal, name);
} else eprintf ("Invalid use of t- . See t-? for help.\n");
}
break;
// tv - get/set type value linked to a given address
case 'f':
{
ut64 addr;
char *fmt, key[128];
const char *type;
if (input[1]) {
addr = r_num_math (core->num, input+1);
} else addr = core->offset;
snprintf (key, sizeof (key), "link.%"PFMT64x, addr);
type = sdb_const_get (core->anal->sdb_types, key, 0);
if (type) {
fmt = r_anal_type_format (core->anal, type);
r_cons_printf ("struct %s {\n", type);
if (fmt) {
r_core_cmdf (core, "pf %s @ 0x%08"PFMT64x"\n", fmt, addr);
free (fmt);
}// else eprintf ("Cannot find '%s' type\n", input+1);
r_cons_printf ("}\n");
}
}
break;
case '?':
if (input[1]) {
sdb_query (core->anal->sdb_types, input+1);
} else show_help(core);
break;
}
return R_TRUE;
}
static void nextpal(RCore *core, int mode) {
// TODO: use r_core_list_themes() here instead of rewalking all the time
RList *files = NULL;
RListIter *iter;
const char *fn;
int ctr = 0;
char *home = r_str_home (".config/radare2/cons/");
getNext = false;
if (mode == 'j') {
r_cons_printf ("[");
}
if (home) {
files = r_sys_dir (home);
r_list_foreach (files, iter, fn) {
if (*fn && *fn != '.') {
if (mode == 'p') {
const char *nfn = iter->n? iter->n->data: NULL;
if (!curtheme) {
free (home);
r_list_free (files);
return;
}
eprintf ("%s %s %s\n", nfn, curtheme, fn);
if (nfn && !strcmp (nfn, curtheme)) {
r_list_free (files);
files = NULL;
free (curtheme);
curtheme = strdup (fn);
R_FREE (home);
goto done;
}
} else {
if (!nextpal_item (core, mode, fn, ctr++)) {
r_list_free (files);
files = NULL;
R_FREE (home);
goto done;
}
}
}
}
r_list_free (files);
R_FREE (home);
}
files = r_sys_dir (R2_DATDIR"/radare2/"R2_VERSION"/cons/");
r_list_foreach (files, iter, fn) {
if (*fn && *fn != '.') {
if (mode == 'p') {
const char *nfn = iter->n? iter->n->data: NULL;
if (!curtheme) {
free (home);
r_list_free (files);
return;
}
eprintf ("%s %s %s\n", nfn, curtheme, fn);
if (nfn && !strcmp (nfn, curtheme)) {
free (curtheme);
curtheme = strdup (fn);
goto done;
}
} else {
if (!nextpal_item (core, mode, fn, ctr++)) {
goto done;
}
}
}
}
done:
if (getNext) {
R_FREE (curtheme);
nextpal (core, mode);
return;
}
if (mode == 'l' && !curtheme && !r_list_empty (files)) {
//nextpal (core, mode);
} else {
if (curtheme) {
r_core_cmdf (core, "eco %s", curtheme);
}
}
r_list_free (files);
files = NULL;
if (mode == 'j') {
r_cons_printf ("]\n");
}
}
static int cmd_type(void *data, const char *input) {
RCore *core = (RCore *)data;
switch (input[0]) {
// t [typename] - show given type in C syntax
case 'k':
if (input[1] == ' ') {
sdb_query (core->anal->sdb_types, input + 2);
} else sdb_query (core->anal->sdb_types, "*");
break;
case 's': {
char *q, *p, *o, *e;
p = o = strdup (input + 1);
for (;;) {
if (*p == '\0') {
eprintf ("Usage: ts <k>=<v> Set fields at curseek linked type\n");
break;
}
q = strchr (p, ' ');
if (q) *q = 0;
if (!*p) {
p++;
continue;
}
e = strchr (p, '=');
if (e) {
*e = 0;
r_anal_type_set (core->anal, core->offset,
p, r_num_math (core->num, e + 1));
} else eprintf ("TODO: implement get\n");
if (!q) break;
p = q + 1;
}
free (o);
} break;
case 'b': {
char *p, *s = (strlen (input) > 1)? strdup (input + 2): NULL;
const char *isenum;
p = s? strchr (s, ' '): NULL;
if (p) {
*p++ = 0;
// dupp in core.c (see getbitfield())
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strcmp (isenum, "enum")) {
*--p = '.';
const char *res = sdb_const_get (core->anal->sdb_types, s, 0);
if (res)
r_cons_printf ("%s\n", res);
else eprintf ("Invalid enum member\n");
} else {
eprintf ("This is not an enum\n");
}
} else {
eprintf ("Missing value\n");
}
free (s);
} break;
case 'e': {
if (!input[1]) {
char *name = NULL;
SdbKv *kv;
SdbListIter *iter;
SdbList *l = sdb_foreach_list (core->anal->sdb_types);
ls_foreach (l, iter, kv) {
if (!strcmp (kv->value, "enum")) {
if (!name || strcmp (kv->value, name)) {
free (name);
name = strdup (kv->key);
r_cons_printf ("%s\n", name);
}
}
}
free (name);
ls_free (l);
break;
}
char *p, *s = strdup (input + 2);
const char *isenum;
p = strchr (s, ' ');
if (p) {
*p++ = 0;
isenum = sdb_const_get (core->anal->sdb_types, s, 0);
if (isenum && !strcmp (isenum, "enum")) {
const char *q = sdb_fmt (0, "%s.0x%x", s, (ut32)r_num_math (core->num, p));
const char *res = sdb_const_get (core->anal->sdb_types, q, 0);
if (res)
r_cons_printf ("%s\n", res);
} else {
eprintf ("This is not an enum\n");
}
} else {
//eprintf ("Missing value\n");
r_core_cmdf (core, "t~&%s,=0x", s);
}
free (s);
} break;
case ' ': {
const char *isenum = sdb_const_get (core->anal->sdb_types, input + 1, 0);
if (isenum && !strcmp (isenum, "enum")) {
eprintf ("IS ENUM! \n");
} else {
char *fmt = r_anal_type_format (core->anal, input + 1);
if (fmt) {
r_cons_printf ("pf %s\n", fmt);
free (fmt);
} else eprintf ("Cannot find '%s' type\n", input + 1);
}
} break;
// t* - list all types in 'pf' syntax
case '*':
sdb_foreach (core->anal->sdb_types, typelist, core);
break;
case 0:
sdb_foreach (core->anal->sdb_types, sdbforcb, core);
break;
case 'o':
if (!r_sandbox_enable (0)) {
if (input[1] == ' ') {
const char *filename = input + 2;
char *homefile = NULL;
if (*filename == '~') {
if (filename[1] && filename[2]) {
homefile = r_str_home (filename + 2);
filename = homefile;
}
}
if (!strcmp (filename, "-")) {
char *out, *tmp;
tmp = r_core_editor (core, NULL, "");
if (tmp) {
out = r_parse_c_string (tmp);
if (out) {
// r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
free (tmp);
}
} else {
char *out = r_parse_c_file (filename);
if (out) {
//r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
//r_anal_type_loadfile (core->anal, filename);
}
free (homefile);
}
} else {
eprintf ("Sandbox: system call disabled\n");
}
break;
// td - parse string with cparse engine and load types from it
case 'd':
if (input[1] == '?') {
const char *help_message[] = {
"Usage:", "\"td [...]\"", "",
"td", "[string]", "Load types from string",
NULL };
r_core_cmd_help (core, help_message);
r_cons_printf ("Note: The td command should be put between double quotes\n"
"Example: \" td struct foo {int bar;int cow};\""
"\nt");
} else if (input[1] == ' ') {
char tmp[8192];
snprintf (tmp, sizeof (tmp) - 1, "%s;", input + 2);
//const char *string = input + 2;
//r_anal_str_to_type (core->anal, string);
char *out = r_parse_c_string (tmp);
if (out) {
//r_cons_strcat (out);
sdb_query_lines (core->anal->sdb_types, out);
free (out);
}
} else {
eprintf ("Invalid use of td. See td? for help\n");
}
break;
// tl - link a type to an address
case 'l':
if (input[1] == '?') {
const char *help_message[] = {
"Usage: tl", " [typename|addr] ([addr])@[addr|function]", "",
NULL };
r_core_cmd_help (core, help_message);
} else if (input[1]) {
ut64 addr = r_num_math (core->num, input + 2);
char *ptr = strchr (input + 2, ' ');
if (ptr) {
addr = r_num_math (core->num, ptr + 1);
*ptr = '\0';
} else addr = core->offset;
r_anal_type_link (core->anal, input + 2, addr);
} else {
r_core_cmd0 (core, "t~^link");
}
break;
case '-':
if (input[1] == '?') {
const char *help_message[] = {
"Usage: t-", " <type>", "Delete type by its name",
NULL };
r_core_cmd_help (core, help_message);
} else if (input[1] == '*') {
sdb_foreach (core->anal->sdb_types, sdbdelete, core);
} else {
const char *name = input + 1;
while (IS_WHITESPACE (*name)) name++;
if (*name) {
SdbKv *kv;
SdbListIter *iter;
int tmp_len = strlen (name);
char *tmp = malloc (tmp_len + 2);
r_anal_type_del (core->anal, name);
if (tmp) {
snprintf (tmp, tmp_len + 1, "%s.", name);
SdbList *l = sdb_foreach_list (core->anal->sdb_types);
ls_foreach (l, iter, kv) {
if (!strncmp (kv->key, tmp, tmp_len - 1))
r_anal_type_del (core->anal, kv->key);
}
free (tmp);
}
} else eprintf ("Invalid use of t- . See t-? for help.\n");
}
R_API int r_core_patch (RCore *core, const char *patch) {
char *p, *p2, *q, str[200], tmp[64];
ut64 noff = 0LL;
FILE *fd = r_sandbox_fopen (patch, "r");
if (fd==NULL) {
eprintf ("Cannot open patch file\n");
return 1;
}
while (!feof (fd)) {
fgets (str, sizeof (str), fd);
if (*str=='#' || *str=='\n' || *str=='\r')
continue;
if (*str==':') {
r_core_cmd0 (core, str+1);
continue;
}
if (*str=='.' || *str=='!') {
r_core_cmd0 (core, str);
continue;
}
p = strchr (str+1, ' ');
if (p) {
*p = 0;
for (++p; *p==' '; p++); // XXX: skipsspaces here
switch (*p) {
case '{': {
char *s, *off = strdup (str);
RBuffer *b = r_buf_new ();
while (!feof (fd)) {
fgets (str, sizeof (str), fd);
if (*str=='}')
break;
if ((q=strstr (str, "${"))) {
char *end = strchr (q+2,'}');
if (end) {
*q = *end = 0;
noff = r_num_math (core->num, q+2);
r_buf_append_bytes (b, (const ut8*)str, strlen (str));
snprintf (tmp, sizeof (tmp), "0x%08"PFMT64x, noff);
r_buf_append_bytes (b, (const ut8*)tmp, strlen (tmp));
r_buf_append_bytes (b, (const ut8*)end+1, strlen (end+1));
}
} else r_buf_append_bytes (b, (const ut8*)str, strlen (str));
}
s = r_buf_to_string (b);
r_egg_load (core->egg, s, 0);
free (s);
r_egg_compile (core->egg);
r_egg_assemble (core->egg);
r_buf_free (b);
b = r_egg_get_bin (core->egg);
if (strcmp (off, "+"))
noff = r_num_math (core->num, off);
r_core_write_at (core, noff, b->buf, b->length);
noff += b->length;
r_buf_free (b);
free (off);
}
break;
case '"':
p2 = strchr (p+1,'"');
if (p2) *p2=0;
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "\"w %s\"", p+1);
break;
case ':':
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "wa %s", p);
break;
default:
r_core_cmdf (core, "s %s", str);
r_core_cmdf (core, "wx %s", p);
break;
}
}
}
fclose (fd);
return 0;
}
