static char *projectScriptPath(RCore *core, const char *file) {
const char *magic = "# r2 rdb project file";
char *data, *prjfile;
if (r_file_is_abspath (file)) {
prjfile = strdup (file);
} else {
if (!is_valid_project_name (file)) {
return NULL;
}
prjfile = r_file_abspath (r_config_get (core->config, "dir.projects"));
prjfile = r_str_append (prjfile, R_SYS_DIR);
prjfile = r_str_append (prjfile, file);
if (!r_file_exists (prjfile) || r_file_is_directory (prjfile)) {
prjfile = r_str_append (prjfile, R_SYS_DIR "rc");
}
}
data = r_file_slurp (prjfile, NULL);
if (data) {
if (strncmp (data, magic, strlen (magic))) {
R_FREE (prjfile);
}
}
free (data);
return prjfile;
}
R_API char *r_type_enum_getbitfield(Sdb *TDB, const char *name, ut64 val) {
char *q, *ret = NULL;
const char *res;
int i;
if (r_type_kind (TDB, name) != R_TYPE_ENUM) {
return NULL;
}
bool isFirst = true;
ret = r_str_appendf (ret, "0x%08"PFMT64x" : ", val);
for (i = 0; i < 32; i++) {
if (!(val & (1 << i))) {
continue;
}
q = sdb_fmt ("enum.%s.0x%x", name, (1<<i));
res = sdb_const_get (TDB, q, 0);
if (isFirst) {
isFirst = false;
} else {
ret = r_str_append (ret, " | ");
}
if (res) {
ret = r_str_append (ret, res);
} else {
ret = r_str_appendf (ret, "0x%x", (1<<i));
}
}
return ret;
}
R_API int r_core_project_delete(RCore *core, const char *prjfile) {
if (r_sandbox_enable (0)) {
eprintf ("Cannot delete project in sandbox mode\n");
return 0;
}
char *path = projectScriptPath (core, prjfile);
if (!path) {
eprintf ("Invalid project name '%s'\n", prjfile);
return false;
}
if (r_core_is_project (core, prjfile)) {
char *prjDir = r_file_dirname (path);
if (!prjDir) {
eprintf ("Cannot resolve directory\n");
free (path);
return false;
}
// rm project file
if (r_file_exists (path)) {
r_file_rm (path);
eprintf ("rm %s\n", path);
}
//rm notes.txt file
char *notes_txt = r_str_newf ("%s%s%s", prjDir, R_SYS_DIR, "notes.txt");
if (r_file_exists (notes_txt)) {
r_file_rm (notes_txt);
eprintf ("rm %s\n", notes_txt);
}
free(notes_txt);
char *rop_d = r_str_newf ("%s%s%s", prjDir, R_SYS_DIR, "rop.d");
if (r_file_is_directory (rop_d)) {
char *f;
RListIter *iter;
RList *files = r_sys_dir (rop_d);
r_list_foreach (files, iter, f) {
char *filepath = r_str_append (strdup (rop_d), R_SYS_DIR);
filepath = r_str_append (filepath, f);
if (!r_file_is_directory (filepath)) {
eprintf ("rm %s\n", filepath);
r_file_rm (filepath);
}
free (filepath);
}
r_file_rm (rop_d);
eprintf ("rm %s\n", rop_d);
r_list_free (files);
}
free (rop_d);
// remove directory only if it's empty
r_file_rm (prjDir);
free (prjDir);
}
static char *get_and_escape_path (char *str)
{
char *path_bin = strdup (str);
char *final = NULL;
if (path_bin) {
char *p = (char*) r_str_lchr (str, '/');
char *pp = (char*) r_str_tok (p, ' ', -1);
char *args;
if (!pp) {
// There is nothing more to parse
free (path_bin);
return str;
}
path_bin[pp - str] = '\0';
if (strstr (path_bin, "\\ ")) {
path_bin = r_str_replace (path_bin, "\\ ", " ", true);
}
args = path_bin + (pp - str) + 1;
char *path_bin_escaped = r_str_arg_escape (path_bin);
int len = strlen (path_bin_escaped);
path_bin_escaped[len] = ' ';
path_bin_escaped[len + 1] = '\0';
final = r_str_append (path_bin_escaped, args);
free (path_bin);
}
static char *runcmd (const char *cmd) {
char buf[4096] = {0};
if (cmd) {
r_socket_printf (gs, "%s\n", cmd);
}
int timeout = 1000000;
char * str = NULL;
r_socket_block_time (gs, 1, timeout);
while (true) {
memset (buf, 0, sizeof (buf));
r_socket_read (gs, (ut8*)buf, sizeof (buf) - 1); // NULL-terminate the string always
char *promptFound = strstr (buf, "Wine-dbg>");
if (promptFound) {
*promptFound = 0;
return r_str_append (str, buf);
}
str = r_str_append (str, buf);
}
return NULL;
}
char* gdbr_exec_file_read(libgdbr_t *g, int pid) {
if (!g) {
return NULL;
}
char msg[128], pidstr[16];
char *path = NULL;
ut64 len = g->stub_features.pkt_sz, off = 0;
memset (pidstr, 0, sizeof (pidstr));
if (g->stub_features.multiprocess && pid > 0) {
snprintf (pidstr, sizeof (pidstr), "%x", pid);
}
while (1) {
if (snprintf (msg, sizeof (msg) - 1,
"qXfer:exec-file:read:%s:%"PFMT64x",%"PFMT64x,
pidstr, off, len) < 0) {
free (path);
return NULL;
}
if (send_msg (g, msg) < 0 || read_packet (g) < 0
|| send_ack (g) < 0 || g->data_len == 0) {
free (path);
return NULL;
}
g->data[g->data_len] = '\0';
if (g->data[0] == 'l') {
if (g->data_len == 1) {
return path;
}
return r_str_append (path, g->data + 1);
}
if (g->data[0] != 'm') {
free (path);
return NULL;
}
off += strlen (g->data + 1);
if (!(path = r_str_append (path, g->data + 1))) {
return NULL;
}
}
}
/*
* Removes grep part from *cmd* and returns newly allocated string
* with reshaped grep expression.
*
* Function converts multiple twiddle expressions into internal representation.
* For example:
* converts "~str1~str2~str3~?" into "?&str1,str2,str3"
*/
static char *preprocess_filter_expr(char *cmd, const char *quotes) {
char *p1, *p2, *ns = NULL;
const char *strsep = "&";
int len;
int i;
p1 = find_next_intgrep (cmd, quotes);
if (!p1) {
return NULL;
}
len = strlen (p1);
if (len > 4 && r_str_endswith (p1, "~?") && p1[len - 3] != '\\') {
p1[len - 2] = '\0';
ns = r_str_append (ns, "?");
}
*p1 = '\0'; // remove grep part from cmd
i = 0;
// parse words between '~'
while ((p2 = find_next_intgrep (p1 + 1, quotes))) {
ns = r_str_append (ns, strsep);
ns = r_str_appendlen (ns, p1 + 1, (int)(p2 - p1 - 1));
p1 = p2;
strsep = ",";
i++;
}
if (i > 0) {
ns = r_str_append (ns, ",");
}
ns = r_str_append (ns, p1 + 1);
return ns;
}
R_API bool r_core_is_project(RCore *core, const char *name) {
bool ret = false;
if (name && *name && *name != '.') {
char *path = projectScriptPath (core, name);
if (!path) {
return false;
}
if (r_str_endswith (path, R_SYS_DIR "rc") && r_file_exists (path)) {
ret = true;
} else {
path = r_str_append (path, ".d");
if (r_file_is_directory (path)) {
ret = true;
}
}
free (path);
}
return ret;
}
R_API int r_reg_set_profile(RReg *reg, const char *profile) {
int ret;
char *base, *file;
char *str = r_file_slurp (profile, NULL);
if (!str) {
base = r_sys_getenv (R_LIB_ENV);
if (base) {
file = r_str_append (base, profile);
str = r_file_slurp (file, NULL);
free (file);
}
}
if (!str) {
eprintf ("r_reg_set_profile: Cannot find '%s'\n", profile);
return false;
}
ret = r_reg_set_profile_string (reg, str);
free (str);
return ret;
}
static char *__system(RIO *io, RIODesc *fd, const char *cmd) {
if (!strncmp (cmd, "?", 1)) {
eprintf ("dr : show registers\n");
eprintf ("dr* : show registers as flags\n");
eprintf ("drp : show reg profile\n");
eprintf ("dr8 : show hexpairs with regstate\n");
eprintf ("ds : step into\n");
eprintf ("dp : show process info\n");
eprintf ("dc : continue\n");
eprintf ("dm : show maps\n");
eprintf ("pid : show current process id\n");
} else if (!strncmp (cmd, "dr8", 3)) {
struct winedbg_x86_32 r = regState ();
ut8 *arena = (ut8*)calloc (sizeof (struct winedbg_x86_32), 3);
if (arena) {
r_hex_bin2str ((ut8*)&r, sizeof (r), (char *)arena);
return (char *)arena;
}
} else if (!strncmp (cmd, "drp", 3)) {
const char *msg =
"=PC eip\n"\
"=SP esp\n"\
"=BP ebp\n"\
"=A0 eax\n"\
"=A1 ebx\n"\
"=A2 ecx\n"\
"=A3 edx\n"\
"=A4 esi\n"\
"=A5 edi\n"\
"=SN eax\n"\
"seg cs .16 0 0\n"\
"seg ss .16 2 0\n"\
"seg ds .16 4 0\n"\
"seg es .16 6 0\n"\
"seg fs .16 8 0\n"\
"seg gs .16 10 0\n"\
"gpr eip .32 12 0\n"\
"gpr esp .32 16 0\n"\
"gpr ebp .32 20 0\n"\
"gpr eflags .32 24 0\n"\
"gpr eax .32 28 0\n"\
"gpr ebx .32 32 0\n"\
"gpr ecx .32 36 0\n"\
"gpr edx .32 40 0\n"\
"gpr esi .32 44 0\n"\
"gpr edi .32 48 0\n"\
"flg flags .16 24 0\n"\
"flg cf .1 .192 0\n"\
"flg pf .1 .193 0\n"\
"flg af .1 .194 0\n"\
"flg zf .1 .195 0\n"\
"flg sf .1 .196 0\n"\
"flg tf .1 .197 0\n"\
"flg if .1 .198 0\n"\
"flg df .1 .199 0\n"\
"flg of .1 .200 0\n"\
"flg nt .1 .201 0\n"\
"flg rf .1 .202 0\n"\
"flg vm .1 .203 0\n";
return strdup (msg);
} else if (!strncmp (cmd, "dr", 2)) {
printcmd (io, "info reg");
} else if (!strncmp (cmd, "db ", 3)) {
free (runcmd (sdb_fmt (0, "break *%"PFMT64x, r_num_get (NULL, cmd + 3) || io->off)));
} else if (!strncmp (cmd, "ds", 2)) {
free (runcmd ("stepi"));
} else if (!strncmp (cmd, "dc", 2)) {
free (runcmd ("cont"));
} else if (!strncmp (cmd, "dso", 3)) {
eprintf ("TODO: dso\n");
} else if (!strncmp (cmd, "dp", 3)) {
printcmd (io, "info thread");
} else if (!strncmp (cmd, "dm", 3)) {
char *wineDbgMaps = runcmd ("info maps");
char *res = NULL;
if (wineDbgMaps) {
const char *perm;
char *ptr = wineDbgMaps;
for (;;) {
char *nl = strchr (ptr, '\n');
if (!nl) {
break;
}
*nl++ = 0;
perm = "r-x";
ut64 from = 0, to = 0;
if (strstr (ptr, " commit ")) {
if (strstr (ptr, "RW")) {
perm = "rw-";
}
sscanf (ptr, "%08"PFMT64x" %08"PFMT64x, &from, &to);
}
char *row = r_str_newf ("0x%08"PFMT64x" - 0x%08" PFMT64x" %s %s\n", from, to, perm, "");
ptr = nl + 1;
res = r_str_append (res, row);
free (row);
}
free (wineDbgMaps);
return res;
}
} else if (!strncmp (cmd, "pid", 3)) {
return r_str_newf ("%d", fd->fd);
} else {
printcmd (io, cmd);
}
return NULL;
}
R_API int r_sys_cmd_str_full(const char *cmd, const char *input, char **output, int *len, char **sterr) {
char *mysterr = NULL;
if (!sterr) {
sterr = &mysterr;
}
char buffer[1024], *outputptr = NULL;
char *inputptr = (char *)input;
int pid, bytes = 0, status;
int sh_in[2], sh_out[2], sh_err[2];
if (len) {
*len = 0;
}
if (pipe (sh_in)) {
return false;
}
if (output) {
if (pipe (sh_out)) {
close (sh_in[0]);
close (sh_in[1]);
close (sh_out[0]);
close (sh_out[1]);
return false;
}
}
if (pipe (sh_err)) {
close (sh_in[0]);
close (sh_in[1]);
return false;
}
switch ((pid = r_sys_fork ())) {
case -1:
return false;
case 0:
dup2 (sh_in[0], 0);
close (sh_in[0]);
close (sh_in[1]);
if (output) {
dup2 (sh_out[1], 1);
close (sh_out[0]);
close (sh_out[1]);
}
if (sterr) {
dup2 (sh_err[1], 2);
} else {
close (2);
}
close (sh_err[0]);
close (sh_err[1]);
exit (r_sandbox_system (cmd, 0));
default:
outputptr = strdup ("");
if (!outputptr) {
return false;
}
if (sterr) {
*sterr = strdup ("");
if (!*sterr) {
free (outputptr);
return false;
}
}
if (output) {
close (sh_out[1]);
}
close (sh_err[1]);
close (sh_in[0]);
if (!inputptr || !*inputptr) {
close (sh_in[1]);
}
// we should handle broken pipes somehow better
signal (SIGPIPE, SIG_IGN);
for (;;) {
fd_set rfds, wfds;
int nfd;
FD_ZERO (&rfds);
FD_ZERO (&wfds);
if (output) {
FD_SET (sh_out[0], &rfds);
}
if (sterr) {
FD_SET (sh_err[0], &rfds);
}
if (inputptr && *inputptr) {
FD_SET (sh_in[1], &wfds);
}
memset (buffer, 0, sizeof (buffer));
nfd = select (sh_err[0] + 1, &rfds, &wfds, NULL, NULL);
if (nfd < 0) {
break;
}
if (output && FD_ISSET (sh_out[0], &rfds)) {
if (!(bytes = read (sh_out[0], buffer, sizeof (buffer)-1))) {
break;
}
buffer[sizeof (buffer) - 1] = '\0';
if (len) {
*len += bytes;
}
outputptr = r_str_append (outputptr, buffer);
} else if (FD_ISSET (sh_err[0], &rfds) && sterr) {
if (!read (sh_err[0], buffer, sizeof (buffer)-1)) {
break;
}
buffer[sizeof (buffer) - 1] = '\0';
*sterr = r_str_append (*sterr, buffer);
} else if (FD_ISSET (sh_in[1], &wfds) && inputptr && *inputptr) {
int inputptr_len = strlen (inputptr);
bytes = write (sh_in[1], inputptr, inputptr_len);
if (bytes != inputptr_len) {
break;
}
inputptr += bytes;
if (!*inputptr) {
close (sh_in[1]);
/* If neither stdout nor stderr should be captured,
* abort now - nothing more to do for select(). */
if (!output && !sterr) {
break;
}
}
}
}
if (output) {
close (sh_out[0]);
}
close (sh_err[0]);
close (sh_in[1]);
waitpid (pid, &status, 0);
bool ret = true;
if (status) {
// char *escmd = r_str_escape (cmd);
// eprintf ("error code %d (%s): %s\n", WEXITSTATUS (status), escmd, *sterr);
// eprintf ("(%s)\n", output);
// eprintf ("%s: failed command '%s'\n", __func__, escmd);
// free (escmd);
ret = false;
}
if (output) {
*output = outputptr;
} else {
free (outputptr);
}
return ret;
}
return false;
}