static bool cmd_wf(RCore *core, const char *input) {
if (!core || !*input) {
return false;
}
if (input[1] == '?') {
eprintf ("Usage: wf [file] ([size] ([offset]))\n");
r_core_cmd_help (core, help_msg_wf);
return false;
}
if (input[1] == 's') { // "wfs"
return cmd_wfs (core, input + 1);
}
if (input[1] == 'f') { // "wff"
return cmd_wff (core, input + 1);
}
char *args = r_str_trim (strdup (input + 1));
char *arg = strchr (args, ' ');
int len = core->blocksize;
if (arg) {
*arg++ = 0;
len = r_num_math (core->num, arg);
}
ut64 addr = r_num_math (core->num, args);
ioMemcpy (core, core->offset, addr, len);
free (args);
r_core_block_read (core);
return true;
}
static int flag_to_flag(RCore *core, const char *glob) {
r_return_val_if_fail (glob, 0);
glob = r_str_trim_ro (glob);
struct flag_to_flag_t u = { .next = UT64_MAX, .offset = core->offset };
r_flag_foreach_glob (core->flags, glob, flag_to_flag_foreach, &u);
if (u.next != UT64_MAX && u.next > core->offset) {
return u.next - core->offset;
}
return 0;
}
static void cmd_flag_tags (RCore *core, const char *input) {
char mode = input[1];
for (; *input && !IS_WHITESPACE (*input); input++) {}
char *inp = strdup (input);
char *arg = r_str_trim (inp);
if (!*arg && !mode) {
const char *tag;
RListIter *iter;
RList *list = r_flag_tags_list (core->flags);
r_list_foreach (list, iter, tag) {
r_cons_printf ("%s\n", tag);
}
r_list_free (list);
free (inp);
return;
}
static bool cmd_wfs(RCore *core, const char *input) {
char * args = r_str_trim (strdup (input + 1));
char *arg = strchr (args, ' ');
int len = core->blocksize;
if (arg) {
*arg = 0;
len = r_num_math (core->num, arg + 1);
}
ut64 dst = core->offset;
ut64 src = r_num_math (core->num, args);
if (len > 0) {
// cache dest, memcpy, write cache
ut8 *buf = calloc (1, len);
if (buf) {
if (r_io_read_at (core->io, dst, buf, len)) {
ioMemcpy (core, core->offset, src, len);
if (r_io_write_at (core->io, src, buf, len)) {
r_core_block_read (core);
} else {
eprintf ("Failed to write at 0x%08"PFMT64x"\n", src);
}
} else {
eprintf ("cmd_wfs: failed to read at 0x%08"PFMT64x"\n", dst);
}
free (buf);
}
}
free (args);
return true;
}
R_API char * r_cons_grep_strip(char *cmd, const char *quotestr) {
char *ptr = NULL;
if (cmd) {
ptr = preprocess_filter_expr (cmd, quotestr);
r_str_trim (cmd);
}
return ptr;
}
R_API void r_cons_grep_parsecmd(char *cmd, const char *quotestr) {
char *ptr;
if (!cmd) {
return;
}
ptr = preprocess_filter_expr (cmd, quotestr);
if (ptr) {
r_str_trim (cmd);
parse_grep_expression (ptr);
free (ptr);
}
}
static bool cmd_wff(RCore *core, const char *input) {
ut8 *buf;
int size;
// XXX: file names cannot contain spaces
const char *arg = input + ((input[1] == ' ') ? 2 : 1);
int wseek = r_config_get_i (core->config, "cfg.wseek");
char *p, *a = r_str_trim (strdup (arg));
p = strchr (a, ' ');
if (p) {
*p++ = 0;
}
if (*arg =='?' || !*arg) {
eprintf ("Usage: wf [file] ([size] ([offset]))\n");
}
if (!strcmp (arg, "-")) {
char *out = r_core_editor (core, NULL, NULL);
if (out) {
r_io_write_at (core->io, core->offset,
(ut8*)out, strlen (out));
r_core_block_read (core);
free (out);
}
}
if ((buf = (ut8*) r_file_slurp (a, &size))) {
int u_size = size;
int u_offset = 0;
u_size = r_num_math (core->num, p);
if (u_size < 1) u_size = size;
if (p) {
*p++ = 0;
u_offset = r_num_math (core->num, p);
if (u_offset > size) {
eprintf ("Invalid offset\n");
free (buf);
return false;
}
}
r_io_use_fd (core->io, core->file->fd);
r_io_write_at (core->io, core->offset, buf + u_offset, u_size);
WSEEK (core, size);
free (buf);
r_core_block_read (core);
} else {
eprintf ("Cannot open file '%s'\n", arg);
}
return true;
}
R_API int r_name_filter(char *name, int maxlen) {
int i;
char *oname;
name = oname = r_str_trim (name);
for (i=0; *name!='\0'; name++, i++) {
if (maxlen && i>maxlen) {
*name = '\0';
break;
}
if (!r_name_validate_char (*name)) {
*name = '_';
//r_str_ccpy (name, name+1, 0);
//name--;
}
}
return r_name_check (oname);
}
static int exprmatchreg (RDebug *dbg, const char *regname, const char *expr) {
int ret = 0;
char *p;
char *s = strdup (expr);
if (!strcmp (regname, s)) {
ret = 1;
} else {
#define CURVAL 0){}r_str_trim(s);if (!strcmp(regname,s) && regval
ut64 regval = r_debug_reg_get_err (dbg, regname, NULL);
if (exprtoken (dbg, s, ">=", &p)) {
if (CURVAL >= r_num_math (dbg->num, p))
ret = 1;
} else if (exprtoken (dbg, s, "<=", &p)) {
if (CURVAL <= r_num_math (dbg->num, p))
ret = 1;
} else if (exprtoken (dbg, s, "==", &p)) {
if (CURVAL <= r_num_math (dbg->num, p))
ret = 1;
} else if (exprtoken (dbg, s, "<", &p)) {
if (CURVAL < r_num_math (dbg->num, p))
ret = 1;
} else if (exprtoken (dbg, s, ">", &p)) {
if (CURVAL > r_num_math (dbg->num, p))
ret = 1;
} else if (exprtoken (dbg, s, " ", &p)) {
r_str_trim (s);
if (!strcmp (regname, s)) {
ut64 num = r_num_math (dbg->num, p);
ret = exprmatch (dbg, num, s);
}
} else {
if (!strcmp (regname, s)) {
ret = 1;
}
}
}
free (s);
return ret;
}
static char *swift_demangle_cmd(const char *s) {
/* XXX: command injection issue here */
static char *swift_demangle = NULL;
if (have_swift_demangle == -1) {
if (!swift_demangle) {
have_swift_demangle = 0;
swift_demangle = r_file_path ("swift-demangle");
if (!swift_demangle || !strcmp (swift_demangle, "swift-demangle")) {
char *xcrun = r_file_path ("xcrun");
if (xcrun) {
if (strcmp (xcrun, "xcrun")) {
free (swift_demangle);
swift_demangle = r_str_newf ("%s swift-demangle", xcrun);
have_swift_demangle = 1;
}
free (xcrun);
}
}
}
}
if (swift_demangle) {
if (strstr (s, "'") || strstr (s, "\\")) {
/* nice try */
return NULL;
}
//char *res = r_sys_cmd_strf ("%s -compact -simplified '%s'",
char *res = r_sys_cmd_strf ("%s -compact '%s'",
swift_demangle, s);
if (res && !*res) {
free (res);
res = NULL;
}
return r_str_trim (res);
}
return NULL;
}
static int parse(RParse *p, const char *data, char *str) {
int i, len = strlen (data);
char w0[WSZ];
char w1[WSZ];
char w2[WSZ];
char w3[WSZ];
char w4[WSZ];
char *buf, *ptr, *optr;
if (!strcmp (data, "jr ra")) {
strcpy (str, "ret");
return true;
}
// malloc can be slow here :?
if (!(buf = malloc (len + 1))) {
return false;
}
memcpy (buf, data, len+1);
r_str_replace_char (buf, '(', ',');
r_str_replace_char (buf, ')', ' ');
r_str_trim (buf);
if (*buf) {
w0[0]='\0';
w1[0]='\0';
w2[0]='\0';
w3[0]='\0';
w4[0]='\0';
ptr = strchr (buf, ' ');
if (!ptr) {
ptr = strchr (buf, '\t');
}
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy (w0, buf, WSZ - 1);
strncpy (w1, ptr, WSZ - 1);
optr=ptr;
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy (w1, optr, WSZ - 1);
strncpy (w2, ptr, WSZ - 1);
optr=ptr;
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy (w2, optr, WSZ - 1);
strncpy (w3, ptr, WSZ - 1);
optr=ptr;
// bonus
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
;
}
strncpy (w3, optr, WSZ - 1);
strncpy (w4, ptr, WSZ - 1);
}
}
}
} else {
strncpy (w0, buf, WSZ - 1);
}
{
const char *wa[] = { w0, w1, w2, w3, w4 };
int nw = 0;
for (i=0; i<4; i++) {
if (wa[i][0] != '\0') {
nw++;
}
}
replace (nw, wa, str);
{
char *p = strdup (str);
p = r_str_replace (p, "+ -", "- ", 0);
p = r_str_replace (p, " + ]", " + 0]", 0);
p = r_str_replace (p, "zero", "0", 1);
if (!strncmp (p, "0 = ", 4)) {
*p = 0; // nop
}
if (!strcmp (w1, w2)) {
char a[32], b[32];
#define REPLACE(x,y) do { \
int snprintf_len1_ = snprintf (a, 32, x, w1, w1); \
int snprintf_len2_ = snprintf (b, 32, y, w1); \
if (snprintf_len1_ < 32 && snprintf_len2_ < 32) { \
p = r_str_replace (p, a, b, 0); \
} \
} while (0)
// TODO: optimize
REPLACE ("%s = %s +", "%s +=");
REPLACE ("%s = %s -", "%s -=");
REPLACE ("%s = %s &", "%s &=");
REPLACE ("%s = %s |", "%s |=");
REPLACE ("%s = %s ^", "%s ^=");
REPLACE ("%s = %s >>", "%s >>=");
REPLACE ("%s = %s <<", "%s <<=");
}
p = r_str_replace (p, ":", "0000", 0);
strcpy (str, p);
free (p);
}
}
}
free (buf);
return true;
}
static int parse(RParse *p, const char *data, char *str) {
int i, len = strlen (data);
char w0[WSZ];
char w1[WSZ];
char w2[WSZ];
char w3[WSZ];
char w4[WSZ];
char *buf, *ptr, *optr;
// malloc can be slow here :?
if (!(buf = malloc (len + 1))) {
return false;
}
memcpy (buf, data, len + 1);
r_str_trim (buf);
if (*buf) {
w0[0] = '\0';
w1[0] = '\0';
w2[0] = '\0';
w3[0] = '\0';
w4[0] = '\0';
ptr = strchr (buf, ' ');
if (!ptr) {
ptr = strchr (buf, '\t');
}
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
//nothing to see here
}
strncpy (w0, buf, WSZ - 1);
strncpy (w1, ptr, WSZ - 1);
optr = ptr;
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
//nothing to see here
}
strncpy (w1, optr, WSZ - 1);
strncpy (w2, ptr, WSZ - 1);
optr = ptr;
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
//nothing to see here
}
strncpy (w2, optr, WSZ - 1);
strncpy (w3, ptr, WSZ - 1);
optr = ptr;
// bonus
ptr = strchr (ptr, ',');
if (ptr) {
*ptr = '\0';
for (++ptr; *ptr == ' '; ptr++) {
//nothing to see here
}
strncpy (w3, optr, WSZ - 1);
strncpy (w4, ptr, WSZ - 1);
}
}
}
} else {
strncpy (w0, buf, WSZ - 1);
}
{
const char *wa[] = { w0, w1, w2, w3, w4 };
int nw = 0;
for (i = 0; i < 5; i++) {
if (wa[i][0] != '\0') {
nw++;
}
}
replace (nw, wa, str);
}
}
free (buf);
return true;
}
