portugalfuturista/rizin
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
rizin/librz/core/rtr.c
Giovanni a988941bf2
Refactor thread code and add RzThreadQueue (#2683) 
* Kill the thread only if is alive.
* Remove rz_th_lock_guard.
* Use rz_sys_usleep since pthread_yield/sched_yield are not portable.
* Kill threads only on error.
* Avoid killing already-dead threads.
* RzThreadFunction now returns void* and added test_thread_queue.
* Removed pthread_exit
2022-06-19 21:07:13 +08:00

1300 lines
32 KiB
C
Raw Blame History

// SPDX-FileCopyrightText: 2009-2020 pancake <pancake@nopcode.org>
// SPDX-FileCopyrightText: 2009-2020 nibble <nibble.ds@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
#include "rz_core.h"
#include "rz_socket.h"
#include <libgdbr.h>
#include <gdbserver/core.h>
#if HAVE_LIBUV
#include <uv.h>
#endif
#if 0
SECURITY IMPLICATIONS
=====================
- no ssl
- no auth
- commands can be executed by anyone
- default is to listen on localhost
- can access full filesystem
- follow symlinks
#endif
#define rtr_n core->rtr_n
#define rtr_host core->rtr_host
static RzSocket *s = NULL;
static RzThread *httpthread = NULL;
static RzThread *rapthread = NULL;
static const char *listenport = NULL;
struct rz_core_rtr_host_t {
int proto;
char host[512];
int port;
char file[1024];
RzSocket *fd;
};
typedef struct {
const char *host;
const char *port;
const char *file;
} TextLog;
typedef struct {
RzCore *core;
int launch;
int browse;
char *path;
} HttpThread;
typedef struct {
RzCore *core;
char *input;
} RapThread;
RZ_API void rz_core_wait(RzCore *core) {
rz_cons_singleton()->context->breaked = true;
if (httpthread) {
rz_th_kill(httpthread);
}
if (rapthread) {
rz_th_kill(rapthread);
}
if (httpthread) {
rz_th_wait(httpthread);
}
if (rapthread) {
rz_th_wait(rapthread);
}
}
static void http_logf(RzCore *core, const char *fmt, ...) {
bool http_log_enabled = rz_config_get_i(core->config, "http.log");
va_list ap;
va_start(ap, fmt);
if (http_log_enabled) {
const char *http_log_file = rz_config_get(core->config, "http.logfile");
if (http_log_file && *http_log_file) {
char *msg = calloc(4096, 1);
if (msg) {
vsnprintf(msg, 4095, fmt, ap);
rz_file_dump(http_log_file, (const ut8 *)msg, -1, true);
free(msg);
}
} else {
vfprintf(stderr, fmt, ap);
}
}
va_end(ap);
}
static char *rtrcmd(TextLog T, const char *str) {
char *res, *ptr2;
char *ptr = rz_str_uri_encode(str);
char *uri = rz_str_newf("http://%s:%s/%s%s", T.host, T.port, T.file, ptr ? ptr : str);
int len;
free(ptr);
ptr2 = rz_socket_http_get(uri, NULL, &len);
free(uri);
if (ptr2) {
ptr2[len] = 0;
res = strstr(ptr2, "\n\n");
if (res) {
res = strstr(res + 1, "\n\n");
}
return res ? res + 2 : ptr2;
}
return NULL;
}
static void showcursor(RzCore *core, int x) {
if (core && core->vmode) {
rz_cons_show_cursor(x);
rz_cons_enable_mouse(x ? rz_config_get_i(core->config, "scr.wheel") : false);
} else {
rz_cons_enable_mouse(false);
}
rz_cons_flush();
}
RZ_API int rz_core_rtr_http_stop(RzCore *u) {
RzCore *core = (RzCore *)u;
const int timeout = 1; // 1 second
const char *port;
RzSocket *sock;
#if __WINDOWS__
rz_socket_http_server_set_breaked(&rz_cons_singleton()->context->breaked);
#endif
if (((size_t)u) > 0xff) {
port = listenport ? listenport : rz_config_get(core->config, "http.port");
sock = rz_socket_new(0);
(void)rz_socket_connect(sock, "localhost",
port, RZ_SOCKET_PROTO_TCP, timeout);
rz_socket_free(sock);
}
rz_socket_free(s);
s = NULL;
return 0;
}
static char *rtr_dir_files(const char *path) {
char *ptr = strdup("<html><body>\n");
const char *file;
RzListIter *iter;
// list files
RzList *files = rz_sys_dir(path);
eprintf("Listing directory %s\n", path);
rz_list_foreach (files, iter, file) {
if (file[0] == '.') {
continue;
}
ptr = rz_str_appendf(ptr, "<a href=\"%s%s\">%s</a><br />\n",
path, file, file);
}
rz_list_free(files);
return rz_str_append(ptr, "</body></html>\n");
}
#if __UNIX__
static void dietime(int sig) {
eprintf("It's Die Time!\n");
exit(0);
}
#endif
static void activateDieTime(RzCore *core) {
int dt = rz_config_get_i(core->config, "http.dietime");
if (dt > 0) {
#if __UNIX__
rz_sys_signal(SIGALRM, dietime);
alarm(dt);
#else
eprintf("http.dietime only works on *nix systems\n");
#endif
}
}
#include "rtr_http.c"
#include "rtr_shell.c"
static int write_reg_val(char *buf, ut64 sz, ut64 reg, int regsize, bool bigendian) {
if (!bigendian) {
switch (regsize) {
case 2:
reg = rz_swap_ut16(reg);
break;
case 4:
reg = rz_swap_ut32(reg);
break;
case 8:
reg = rz_swap_ut64(reg);
break;
default:
eprintf("%s: Unsupported reg size: %d\n",
__func__, regsize);
return -1;
}
}
return snprintf(buf, sz, regsize == 2 ? "%04" PFMT64x : regsize == 4 ? "%08" PFMT64x
: "%016" PFMT64x,
reg);
}
static int write_big_reg(char *buf, ut64 sz, const utX *val, int regsize, bool bigendian) {
switch (regsize) {
case 10:
if (bigendian) {
return snprintf(buf, sz,
"%04x%016" PFMT64x, val->v80.High,
val->v80.Low);
}
return snprintf(buf, sz,
"%016" PFMT64x "%04x", rz_swap_ut64(val->v80.Low),
rz_swap_ut16(val->v80.High));
case 12:
if (bigendian) {
return snprintf(buf, sz,
"%08" PFMT32x "%016" PFMT64x, val->v96.High,
val->v96.Low);
}
return snprintf(buf, sz,
"%016" PFMT64x "%08" PFMT32x, rz_swap_ut64(val->v96.Low),
rz_swap_ut32(val->v96.High));
case 16:
if (bigendian) {
return snprintf(buf, sz,
"%016" PFMT64x "%016" PFMT64x, val->v128.High,
val->v128.Low);
}
return snprintf(buf, sz,
"%016" PFMT64x "%016" PFMT64x,
rz_swap_ut64(val->v128.Low),
rz_swap_ut64(val->v128.High));
default:
eprintf("%s: big registers (%d byte(s)) not yet supported\n",
__func__, regsize);
return -1;
}
}
static int swap_big_regs(char *dest, ut64 sz, const char *src, int regsz) {
utX val;
char sdup[128] = { 0 };
if (!src || !src[0] || !src[1]) {
return -1;
}
strncpy(sdup, src + 2, sizeof(sdup) - 1);
int len = strlen(sdup);
memset(&val, 0, sizeof(val));
switch (regsz) {
case 10:
if (len <= 4) {
val.v80.High = (ut16)strtoul(sdup, NULL, 16);
} else {
val.v80.High = (ut16)strtoul(sdup + (len - 4), NULL, 16);
sdup[len - 4] = '\0';
val.v80.Low = (ut64)strtoull(sdup, NULL, 16);
}
return snprintf(dest, sz, "0x%04x%016" PFMT64x,
val.v80.High, val.v80.Low);
case 12:
if (len <= 8) {
val.v96.High = (ut32)strtoul(sdup, NULL, 16);
} else {
val.v96.High = (ut32)strtoul(sdup + (len - 8), NULL, 16);
sdup[len - 8] = '\0';
val.v96.Low = (ut64)strtoull(sdup, NULL, 16);
}
return snprintf(dest, sz, "0x%08x%016" PFMT64x,
val.v96.High, val.v96.Low);
case 16:
if (len <= 16) {
val.v128.High = (ut64)strtoul(sdup, NULL, 16);
} else {
val.v128.High = (ut64)strtoul(sdup + (len - 16), NULL, 16);
sdup[len - 16] = '\0';
val.v128.Low = (ut64)strtoull(sdup, NULL, 16);
}
return snprintf(dest, sz, "0x%016" PFMT64x "%016" PFMT64x,
val.v128.High, val.v128.Low);
default:
eprintf("%s: big registers (%d byte(s)) not yet supported\n",
__func__, regsz);
return -1;
}
}
static int rz_core_rtr_gdb_cb(libgdbr_t *g, void *core_ptr, const char *cmd,
char *out_buf, size_t max_len) {
int ret;
RzList *list;
RzListIter *iter;
gdb_reg_t *gdb_reg;
RzRegItem *r;
utX val_big;
ut64 m_off, reg_val;
bool be;
RzDebugPid *dbgpid;
if (!core_ptr || !cmd) {
return -1;
}
RzCore *core = (RzCore *)core_ptr;
switch (cmd[0]) {
case '?': // Stop reason
if (!out_buf) {
return -1;
}
// dbg->reason.signum and dbg->reason.tid are not correct for native
// debugger. This is a hack
switch (core->dbg->reason.type) {
case RZ_DEBUG_REASON_BREAKPOINT:
case RZ_DEBUG_REASON_STEP:
case RZ_DEBUG_REASON_TRAP:
default: // remove when possible
return snprintf(out_buf, max_len - 1, "T05thread:%x;",
core->dbg->tid);
}
// Fallback for when it's fixed
/*
return snprintf (out_buf, max_len - 1, "T%02xthread:%x;",
core->dbg->reason.type, core->dbg->reason.tid);
*/
case 'd':
switch (cmd[1]) {
case 'm': // dm
if (snprintf(out_buf, max_len - 1, "%" PFMT64x, rz_debug_get_baddr(core->dbg, NULL)) < 0) {
return -1;
}
return 0;
case 'p': // dp
switch (cmd[2]) {
case '\0': // dp
// TODO support multiprocess
snprintf(out_buf, max_len - 1, "QC%x", core->dbg->tid);
return 0;
case 't':
switch (cmd[3]) {
case '\0': // dpt
if (!core->dbg->cur->threads) {
return -1;
}
if (!(list = core->dbg->cur->threads(core->dbg, core->dbg->pid))) {
return -1;
}
memset(out_buf, 0, max_len);
out_buf[0] = 'm';
ret = 1;
rz_list_foreach (list, iter, dbgpid) {
// Max length of a hex pid = 8?
if (ret >= max_len - 9) {
break;
}
snprintf(out_buf + ret, max_len - ret - 1, "%x,", dbgpid->pid);
ret = strlen(out_buf);
}
if (ret > 1) {
ret--;
out_buf[ret] = '\0';
}
return 0;
case 'r': // dptr -> return current tid as int
return core->dbg->tid;
default:
return rz_core_cmd(core, cmd, 0);
}
}
break;
case 'r': // dr
rz_debug_reg_sync(core->dbg, RZ_REG_TYPE_ANY, false);
be = rz_config_get_i(core->config, "cfg.bigendian");
if (isspace((ut8)cmd[2])) { // dr reg
const char *name, *val_ptr;
char new_cmd[128] = { 0 };
int off = 0;
name = cmd + 3;
// Temporarily using new_cmd to store reg name
if ((val_ptr = strchr(name, '='))) {
strncpy(new_cmd, name, RZ_MIN(val_ptr - name, sizeof(new_cmd) - 1));
} else {
strncpy(new_cmd, name, sizeof(new_cmd) - 1);
}
if (!(r = rz_reg_get(core->dbg->reg, new_cmd, -1))) {
return -1;
}
if (val_ptr) { // dr reg=val
val_ptr++;
off = val_ptr - cmd;
if (be) {
// We don't need to swap
rz_core_cmd(core, cmd, 0);
}
// Previous contents are overwritten, since len(name) < off
strncpy(new_cmd, cmd, off);
if (r->size <= 64) {
reg_val = strtoll(val_ptr, NULL, 16);
if (write_reg_val(new_cmd + off, sizeof(new_cmd) - off - 1,
reg_val, r->size / 8, be) < 0) {
return -1;
}
return rz_core_cmd(core, new_cmd, 0);
}
// Big registers
if (swap_big_regs(new_cmd + off, sizeof(new_cmd) - off - 1,
val_ptr, r->size / 8) < 0) {
return -1;
}
return rz_core_cmd(core, new_cmd, 0);
}
if (r->size <= 64) {
reg_val = rz_reg_get_value(core->dbg->reg, r);
return write_reg_val(out_buf, max_len - 1,
reg_val, r->size / 8, be);
}
rz_reg_get_value_big(core->dbg->reg,
r, &val_big);
return write_big_reg(out_buf, max_len - 1,
&val_big, r->size / 8, be);
}
// dr - Print all registers
ret = 0;
if (!(gdb_reg = g->registers)) {
return -1;
}
while (*gdb_reg->name) {
if (ret + gdb_reg->size * 2 >= max_len - 1) {
return -1;
}
if (gdb_reg->size <= 8) {
reg_val = rz_reg_getv(core->dbg->reg, gdb_reg->name);
if (write_reg_val(out_buf + ret,
gdb_reg->size * 2 + 1,
reg_val, gdb_reg->size, be) < 0) {
return -1;
}
} else {
rz_reg_get_value_big(core->dbg->reg,
rz_reg_get(core->dbg->reg, gdb_reg->name, -1),
&val_big);
if (write_big_reg(out_buf + ret, gdb_reg->size * 2 + 1,
&val_big, gdb_reg->size, be) < 0) {
return -1;
}
}
ret += gdb_reg->size * 2;
gdb_reg++;
}
out_buf[ret] = '\0';
return ret;
default:
return rz_core_cmd(core, cmd, 0);
}
break;
case 'i':
switch (cmd[1]) {
case 'f': {
ut64 off, len, sz, namelen;
RzIODesc *desc = core && core->file ? rz_io_desc_get(core->io, core->file->fd) : NULL;
if (sscanf(cmd + 2, "%" PFMT64x ",%" PFMT64x, &off, &len) != 2) {
strcpy(out_buf, "E00");
return 0;
}
namelen = desc ? strlen(desc->name) : 0;
if (off >= namelen) {
out_buf[0] = 'l';
return 0;
}
sz = RZ_MIN(max_len, len + 2);
len = snprintf(out_buf, sz, "l%s", desc ? (desc->name + off) : "");
if (len >= sz) {
// There's more left
out_buf[0] = 'm';
}
return 0;
}
}
break;
case 'm':
sscanf(cmd + 1, "%" PFMT64x ",%x", &m_off, &ret);
if (rz_io_read_at(core->io, m_off, (ut8 *)out_buf, ret)) {
return ret;
}
return -1;
default:
return rz_core_cmd(core, cmd, 0);
}
return -1;
}
// path = "<port> <file_name>"
static int rz_core_rtr_gdb_run(RzCore *core, int launch, const char *path) {
RzSocket *sock;
int p, ret;
bool debug_msg = false;
char port[10];
char *file = NULL, *args = NULL;
libgdbr_t *g;
if (!core || !path) {
return -1;
}
if (*path == '!') {
debug_msg = true;
path++;
}
if (!(path = rz_str_trim_head_ro(path)) || !*path) {
eprintf("gdbserver: Port not specified\n");
return -1;
}
if (!(p = atoi(path)) || p < 0 || p > 65535) {
eprintf("gdbserver: Invalid port: %s\n", port);
return -1;
}
snprintf(port, sizeof(port) - 1, "%d", p);
if (!(file = strchr(path, ' '))) {
eprintf("gdbserver: File not specified\n");
return -1;
}
if (!(file = (char *)rz_str_trim_head_ro(file)) || !*file) {
eprintf("gdbserver: File not specified\n");
return -1;
}
args = strchr(file, ' ');
if (args) {
*args++ = '\0';
if (!(args = (char *)rz_str_trim_head_ro(args))) {
args = "";
}
} else {
args = "";
}
if (!rz_core_file_open(core, file, RZ_PERM_R, 0)) {
eprintf("Cannot open file (%s)\n", file);
return -1;
}
ut64 baddr = rz_config_get_i(core->config, "bin.baddr");
rz_core_bin_load(core, NULL, baddr);
rz_core_file_reopen_debug(core, args);
if (!(sock = rz_socket_new(false))) {
eprintf("gdbserver: Could not open socket for listening\n");
return -1;
}
if (!rz_socket_listen(sock, port, NULL)) {
rz_socket_free(sock);
eprintf("gdbserver: Cannot listen on port: %s\n", port);
return -1;
}
if (!(g = RZ_NEW0(libgdbr_t))) {
rz_socket_free(sock);
eprintf("gdbserver: Cannot alloc libgdbr instance\n");
return -1;
}
gdbr_init(g, true);
g->server_debug = debug_msg;
int arch = rz_sys_arch_id(rz_config_get(core->config, "asm.arch"));
int bits = rz_config_get_i(core->config, "asm.bits");
gdbr_set_architecture(g, arch, bits);
core->gdbserver_up = 1;
eprintf("gdbserver started on port: %s, file: %s\n", port, file);
for (;;) {
if (!(g->sock = rz_socket_accept(sock))) {
break;
}
g->connected = 1;
ret = gdbr_server_serve(g, rz_core_rtr_gdb_cb, (void *)core);
rz_socket_close(g->sock);
g->connected = 0;
if (ret < 0) {
break;
}
}
core->gdbserver_up = 0;
gdbr_cleanup(g);
free(g);
rz_socket_free(sock);
return 0;
}
RZ_API int rz_core_rtr_gdb(RzCore *core, int launch, const char *path) {
int ret;
// TODO: do stuff with launch
if (core->gdbserver_up) {
eprintf("gdbserver is already running\n");
return -1;
}
ret = rz_core_rtr_gdb_run(core, launch, path);
return ret;
}
RZ_API void rz_core_rtr_pushout(RzCore *core, const char *input) {
int fd = atoi(input);
const char *cmd = NULL;
char *str = NULL;
if (fd) {
for (rtr_n = 0; rtr_host[rtr_n].fd && rtr_n < RTR_MAX_HOSTS - 1; rtr_n++) {
if (rtr_host[rtr_n].fd->fd != fd) {
continue;
}
}
if (!(cmd = strchr(input, ' '))) {
eprintf("Error\n");
return;
}
} else {
cmd = input;
}
if (!rtr_host[rtr_n].fd || !rtr_host[rtr_n].fd->fd) {
eprintf("Error: Unknown host\n");
return;
}
if (!(str = rz_core_cmd_str(core, cmd))) {
eprintf("Error: rizin_cmd_str returned NULL\n");
return;
}
switch (rtr_host[rtr_n].proto) {
case RTR_PROTOCOL_RAP:
eprintf("Error: Cannot use '=<' to a rap connection.\n");
break;
case RTR_PROTOCOL_UNIX:
rz_socket_write(rtr_host[rtr_n].fd, str, strlen(str));
break;
case RTR_PROTOCOL_HTTP:
eprintf("TODO\n");
break;
case RTR_PROTOCOL_TCP:
case RTR_PROTOCOL_UDP:
rz_socket_write(rtr_host[rtr_n].fd, str, strlen(str));
break;
default:
eprintf("Unknown protocol\n");
break;
}
free(str);
}
RZ_API void rz_core_rtr_list(RzCore *core) {
int i;
for (i = 0; i < RTR_MAX_HOSTS; i++) {
if (!rtr_host[i].fd) {
continue;
}
const char *proto = "rap";
switch (rtr_host[i].proto) {
case RTR_PROTOCOL_HTTP: proto = "http"; break;
case RTR_PROTOCOL_TCP: proto = "tcp"; break;
case RTR_PROTOCOL_UDP: proto = "udp"; break;
case RTR_PROTOCOL_RAP: proto = "rap"; break;
case RTR_PROTOCOL_UNIX: proto = "unix"; break;
}
rz_cons_printf("%d fd:%i %s://%s:%i/%s\n",
i, (int)rtr_host[i].fd->fd, proto, rtr_host[i].host,
rtr_host[i].port, rtr_host[i].file);
}
}
RZ_API void rz_core_rtr_add(RzCore *core, const char *_input) {
char *port, input[1024], *file = NULL, *ptr = NULL;
int i, timeout, ret;
RzSocket *fd;
timeout = rz_config_get_i(core->config, "http.timeout");
strncpy(input, _input, sizeof(input) - 4);
input[sizeof(input) - 4] = '\0';
int proto = RTR_PROTOCOL_RAP;
char *host = (char *)rz_str_trim_head_ro(input);
char *pikaboo = strstr(host, "://");
if (pikaboo) {
struct {
const char *name;
int protocol;
} uris[7] = {
{ "tcp", RTR_PROTOCOL_TCP },
{ "udp", RTR_PROTOCOL_UDP },
{ "rap", RTR_PROTOCOL_RAP },
{ "r2p", RTR_PROTOCOL_RAP },
{ "http", RTR_PROTOCOL_HTTP },
{ "unix", RTR_PROTOCOL_UNIX },
{ NULL, 0 }
};
char *s = rz_str_ndup(input, pikaboo - input);
// int nlen = pikaboo - input;
for (i = 0; uris[i].name; i++) {
if (rz_str_endswith(s, uris[i].name)) {
proto = uris[i].protocol;
host = pikaboo + 3;
break;
}
}
free(s);
}
if (host) {
if (!(ptr = strchr(host, ':'))) {
ptr = host;
port = "80";
} else {
*ptr++ = '\0';
port = ptr;
rz_str_trim(port);
}
} else {
port = NULL;
}
file = strchr(ptr, '/');
if (file) {
*file = 0;
file = (char *)rz_str_trim_head_ro(file + 1);
} else {
if (*host == ':' || strstr(host, "://:")) { // listen
// it's fine to listen without serving a file
} else {
file = "cmd/";
eprintf("Error: Missing '/'\n");
// c:wreturn;
}
}
fd = rz_socket_new(false);
if (!fd) {
eprintf("Error: Cannot create new socket\n");
return;
}
switch (proto) {
case RTR_PROTOCOL_HTTP: {
int len;
char *uri = rz_str_newf("http://%s:%s/%s", host, port, file);
char *str = rz_socket_http_get(uri, NULL, &len);
if (!str) {
eprintf("Cannot find peer\n");
return;
}
core->num->value = 0;
// eprintf ("Connected to: 'http://%s:%s'\n", host, port);
free(str);
} break;
case RTR_PROTOCOL_RAP:
if (!rz_socket_connect_tcp(fd, host, port, timeout)) { // TODO: Use rap.ssl
eprintf("Error: Cannot connect to '%s' (%s)\n", host, port);
rz_socket_free(fd);
return;
} else {
int n = rz_socket_rap_client_open(fd, file, 0);
eprintf("opened as fd = %d\n", n);
}
break;
case RTR_PROTOCOL_UNIX:
if (!rz_socket_connect_unix(fd, host)) {
core->num->value = 1;
eprintf("Error: Cannot connect to 'unix://%s'\n", host);
rz_socket_free(fd);
return;
}
core->num->value = 0;
eprintf("Connected to: 'unix://%s'\n", host);
break;
case RTR_PROTOCOL_TCP:
if (!rz_socket_connect_tcp(fd, host, port, timeout)) { // TODO: Use rap.ssl
core->num->value = 1;
eprintf("Error: Cannot connect to '%s' (%s)\n", host, port);
rz_socket_free(fd);
return;
}
core->num->value = 0;
eprintf("Connected to: %s at port %s\n", host, port);
break;
case RTR_PROTOCOL_UDP:
if (!rz_socket_connect_udp(fd, host, port, timeout)) { // TODO: Use rap.ssl
core->num->value = 1;
eprintf("Error: Cannot connect to '%s' (%s)\n", host, port);
rz_socket_free(fd);
return;
}
core->num->value = 0;
eprintf("Connected to: %s at port %s\n", host, port);
break;
}
ret = core->num->value;
for (i = 0; i < RTR_MAX_HOSTS; i++) {
if (rtr_host[i].fd) {
continue;
}
rtr_host[i].proto = proto;
strncpy(rtr_host[i].host, host, sizeof(rtr_host[i].host) - 1);
rtr_host[i].port = rz_num_get(core->num, port);
if (!file) {
file = "";
}
strncpy(rtr_host[i].file, file, sizeof(rtr_host[i].file) - 1);
rtr_host[i].fd = fd;
rtr_n = i;
break;
}
core->num->value = ret;
// double free wtf is freed this here? rz_socket_free(fd);
// rz_core_rtr_list (core);
}
RZ_API void rz_core_rtr_remove(RzCore *core, const char *input) {
int i;
if (IS_DIGIT(input[0])) {
i = rz_num_math(core->num, input);
if (i >= 0 && i < RTR_MAX_HOSTS) {
rz_socket_free(rtr_host[i].fd);
rtr_host[i].fd = NULL;
}
} else {
for (i = 0; i < RTR_MAX_HOSTS; i++) {
if (rtr_host[i].fd) {
rz_socket_free(rtr_host[i].fd);
rtr_host[i].fd = NULL;
}
}
memset(rtr_host, '\0', RTR_MAX_HOSTS * sizeof(RzCoreRtrHost));
rtr_n = 0;
}
}
RZ_API void rz_core_rtr_session(RzCore *core, const char *input) {
__rtr_shell(core, atoi(input));
}
static bool rz_core_rtr_rap_run(RzCore *core, const char *input) {
char *file = rz_str_newf("rap://%s", input);
int flags = RZ_PERM_RW;
RzIODesc *fd = rz_io_open_nomap(core->io, file, flags, 0644);
if (fd) {
if (rz_io_is_listener(core->io)) {
if (!rz_core_serve(core, fd)) {
rz_cons_singleton()->context->breaked = true;
}
rz_io_desc_close(fd);
// avoid double free, we are not the owners of this fd so we can't destroy it
// rz_io_desc_free (fd);
}
} else {
rz_cons_singleton()->context->breaked = true;
}
return !rz_cons_singleton()->context->breaked;
// rz_core_cmdf (core, "o rap://%s", input);
}
static void *rz_core_rtr_rap_thread(RapThread *rt) {
if (!rt || !rt->core) {
return false;
}
while (rz_core_rtr_rap_run(rt->core, rt->input))
;
return NULL;
}
RZ_API void rz_core_rtr_cmd(RzCore *core, const char *input) {
unsigned int cmd_len = 0;
int fd = atoi(input);
if (!fd && *input != '0') {
fd = -1;
}
const char *cmd = strchr(rz_str_trim_head_ro(input), ' ');
if (cmd) {
cmd++;
cmd_len = strlen(cmd);
}
// "=:"
if (*input == ':' && !strchr(input + 1, ':')) {
void *bed = rz_cons_sleep_begin();
rz_core_rtr_rap_run(core, input);
rz_cons_sleep_end(bed);
return;
}
if (*input == '&') { // "Rh&" "R&:9090"
if (rapthread) {
eprintf("RAP Thread is already running\n");
eprintf("This is experimental and probably buggy. Use at your own risk\n");
} else {
// TODO: use tasks
RapThread *rap_th = RZ_NEW0(RapThread);
if (!rap_th) {
RZ_LOG_ERROR("cannot allocate RapThread\n");
return;
}
rap_th->core = core;
rap_th->input = strdup(input + 1);
// RapThread rt = { core, strdup (input + 1) };
rapthread = rz_th_new((RzThreadFunction)rz_core_rtr_rap_thread, rap_th);
if (!rap_th) {
RZ_LOG_ERROR("cannot spawn the RzThread\n");
return;
}
int cpuaff = (int)rz_config_get_i(core->config, "cfg.cpuaffinity");
if (cpuaff) {
// modify the affinity only when the flag is actually set.
rz_th_set_affinity(rapthread, cpuaff);
}
rz_th_set_name(rapthread, "rapthread");
RZ_LOG_WARN("Background rap server started.\n");
}
return;
}
if (fd != -1) {
if (fd >= 0 && fd < RTR_MAX_HOSTS) {
rtr_n = fd;
}
} else {
// XXX
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_PROTOCOL_TCP) {
RzCoreRtrHost *rh = &rtr_host[rtr_n];
RzSocket *s = rh->fd;
if (cmd_len < 1 || cmd_len > 16384) {
return;
}
rz_socket_close(s);
if (!rz_socket_connect(s, rh->host, sdb_fmt("%d", rh->port), RZ_SOCKET_PROTO_TCP, 0)) {
eprintf("Error: Cannot connect to '%s' (%d)\n", rh->host, rh->port);
rz_socket_free(s);
return;
}
rz_socket_write(s, (ut8 *)cmd, cmd_len);
rz_socket_write(s, "\n", 2);
int maxlen = 4096; // rz_read_le32 (blen);
char *cmd_output = calloc(1, maxlen + 1);
if (!cmd_output) {
eprintf("Error: Allocating cmd output\n");
return;
}
(void)rz_socket_read_block(s, (ut8 *)cmd_output, maxlen);
// ensure the termination
rz_socket_close(s);
cmd_output[maxlen] = 0;
rz_cons_println(cmd_output);
free((void *)cmd_output);
return;
}
if (rtr_host[rtr_n].proto == RTR_PROTOCOL_HTTP) {
RzCoreRtrHost *rh = &rtr_host[rtr_n];
if (cmd_len < 1 || cmd_len > 16384) {
return;
}
int len;
char *uri = rz_str_newf("http://%s:%d/cmd/%s", rh->host, rh->port, cmd);
char *str = rz_socket_http_get(uri, NULL, &len);
if (!str) {
eprintf("Cannot find '%s'\n", uri);
free(uri);
return;
}
core->num->value = 0;
str[len] = 0;
rz_cons_print(str);
free((void *)str);
free((void *)uri);
return;
}
if (rtr_host[rtr_n].proto == RTR_PROTOCOL_RAP) {
core->num->value = 0; // that's fine
cmd = rz_str_trim_head_ro(cmd);
RzSocket *fh = rtr_host[rtr_n].fd;
if (!strlen(cmd)) {
// just check if we can connect
rz_socket_close(fh);
return;
}
char *cmd_output = rz_socket_rap_client_command(fh, cmd, &core->analysis->coreb);
rz_cons_println(cmd_output);
free(cmd_output);
return;
}
eprintf("Error: Unknown protocol\n");
}
// TODO: support len for binary data?
RZ_API char *rz_core_rtr_cmds_query(RzCore *core, const char *host, const char *port, const char *cmd) {
RzSocket *s = rz_socket_new(0);
const int timeout = 0;
char *rbuf = NULL;
int retries = 6;
ut8 buf[1024];
for (; retries > 0; rz_sys_usleep(10 * 1000)) {
if (rz_socket_connect(s, host, port, RZ_SOCKET_PROTO_TCP, timeout)) {
break;
}
retries--;
}
if (retries > 0) {
rbuf = strdup("");
rz_socket_write(s, (void *)cmd, strlen(cmd));
// rz_socket_write (s, "px\n", 3);
for (;;) {
int ret = rz_socket_read(s, buf, sizeof(buf));
if (ret < 1) {
break;
}
buf[ret] = 0;
rbuf = rz_str_append(rbuf, (const char *)buf);
}
} else {
eprintf("Cannot connect\n");
}
rz_socket_free(s);
return rbuf;
}
/**
* \brief Allocates core rtr structure
*
* \param core RzCore to initialize rtr structure
*/
RZ_API bool rz_core_rtr_init(RZ_NONNULL RzCore *core) {
rz_return_val_if_fail(core, false);
rtr_host = RZ_NEWS0(RzCoreRtrHost, RTR_MAX_HOSTS);
return rtr_host;
}
#if HAVE_LIBUV
typedef struct rtr_cmds_context_t {
uv_tcp_t server;
RzPVector clients;
void *bed;
} rtr_cmds_context;
typedef struct rtr_cmds_client_context_t {
RzCore *core;
char buf[4096];
char *res;
size_t len;
uv_tcp_t *client;
} rtr_cmds_client_context;
static void rtr_cmds_client_close(uv_tcp_t *client, bool remove) {
uv_loop_t *loop = client->loop;
rtr_cmds_context *context = loop->data;
if (remove) {
size_t i;
for (i = 0; i < rz_pvector_len(&context->clients); i++) {
if (rz_pvector_at(&context->clients, i) == client) {
rz_pvector_remove_at(&context->clients, i);
break;
}
}
}
rtr_cmds_client_context *client_context = client->data;
uv_close((uv_handle_t *)client, (uv_close_cb)free);
free(client_context->res);
free(client_context);
}
static void rtr_cmds_alloc_buffer(uv_handle_t *handle, size_t suggested_size, uv_buf_t *buf) {
rtr_cmds_client_context *context = handle->data;
buf->base = context->buf + context->len;
buf->len = sizeof(context->buf) - context->len - 1;
}
static void rtr_cmds_write(uv_write_t *req, int status) {
rtr_cmds_client_context *context = req->data;
if (status) {
eprintf("Write error: %s\n", uv_strerror(status));
}
free(req);
rtr_cmds_client_close(context->client, true);
}
static void rtr_cmds_read(uv_stream_t *client, ssize_t nread, const uv_buf_t *buf) {
rtr_cmds_context *context = client->loop->data;
rtr_cmds_client_context *client_context = client->data;
if (nread < 0) {
if (nread != UV_EOF) {
eprintf("Failed to read: %s\n", uv_err_name((int)nread));
}
rtr_cmds_client_close((uv_tcp_t *)client, true);
return;
} else if (nread == 0) {
return;
}
buf->base[nread] = '\0';
char *end = strchr(buf->base, '\n');
if (!end) {
return;
}
*end = '\0';
rz_cons_sleep_end(context->bed);
client_context->res = rz_core_cmd_str(client_context->core, (const char *)client_context->buf);
context->bed = rz_cons_sleep_begin();
if (!client_context->res || !*client_context->res) {
free(client_context->res);
client_context->res = strdup("\n");
}
if (!client_context->res || (!rz_config_get_i(client_context->core->config, "scr.prompt") && !strcmp((char *)buf, "q!")) ||
!strcmp((char *)buf, ".--")) {
rtr_cmds_client_close((uv_tcp_t *)client, true);
return;
}
uv_write_t *req = RZ_NEW(uv_write_t);
if (req) {
req->data = client_context;
uv_buf_t wrbuf = uv_buf_init(client_context->res, (unsigned int)strlen(client_context->res));
uv_write(req, client, &wrbuf, 1, rtr_cmds_write);
}
uv_read_stop(client);
}
static void rtr_cmds_new_connection(uv_stream_t *server, int status) {
if (status < 0) {
eprintf("New connection error: %s\n", uv_strerror(status));
return;
}
rtr_cmds_context *context = server->loop->data;
uv_tcp_t *client = RZ_NEW(uv_tcp_t);
if (!client) {
return;
}
uv_tcp_init(server->loop, client);
if (uv_accept(server, (uv_stream_t *)client) == 0) {
rtr_cmds_client_context *client_context = RZ_NEW(rtr_cmds_client_context);
if (!client_context) {
uv_close((uv_handle_t *)client, NULL);
return;
}
client_context->core = server->data;
client_context->len = 0;
client_context->buf[0] = '\0';
client_context->res = NULL;
client_context->client = client;
client->data = client_context;
uv_read_start((uv_stream_t *)client, rtr_cmds_alloc_buffer, rtr_cmds_read);
rz_pvector_push(&context->clients, client);
} else {
uv_close((uv_handle_t *)client, NULL);
}
}
static void rtr_cmds_stop(uv_async_t *handle) {
uv_close((uv_handle_t *)handle, NULL);
rtr_cmds_context *context = handle->loop->data;
uv_close((uv_handle_t *)&context->server, NULL);
void **it;
rz_pvector_foreach (&context->clients, it) {
uv_tcp_t *client = *it;
rtr_cmds_client_close(client, false);
}
}
static void rtr_cmds_break(uv_async_t *async) {
uv_async_send(async);
}
RZ_API int rz_core_rtr_cmds(RzCore *core, const char *port) {
if (!port || port[0] == '?') {
rz_cons_printf("Usage: .:[tcp-port] run rizin commands for clients\n");
return 0;
}
uv_loop_t *loop = RZ_NEW(uv_loop_t);
if (!loop) {
return 0;
}
uv_loop_init(loop);
rtr_cmds_context context;
rz_pvector_init(&context.clients, NULL);
loop->data = &context;
context.server.data = core;
uv_tcp_init(loop, &context.server);
struct sockaddr_in addr;
bool local = (bool)rz_config_get_i(core->config, "tcp.islocal");
int porti = rz_socket_port_by_name(port);
uv_ip4_addr(local ? "127.0.0.1" : "0.0.0.0", porti, &addr);
uv_tcp_bind(&context.server, (const struct sockaddr *)&addr, 0);
int r = uv_listen((uv_stream_t *)&context.server, 32, rtr_cmds_new_connection);
if (r) {
eprintf("Failed to listen: %s\n", uv_strerror(r));
goto beach;
}
uv_async_t stop_async;
uv_async_init(loop, &stop_async, rtr_cmds_stop);
rz_cons_break_push((RzConsBreak)rtr_cmds_break, &stop_async);
context.bed = rz_cons_sleep_begin();
uv_run(loop, UV_RUN_DEFAULT);
rz_cons_sleep_end(context.bed);
rz_cons_break_pop();
beach:
uv_loop_close(loop);
free(loop);
rz_pvector_clear(&context.clients);
return 0;
}
#else
RZ_API int rz_core_rtr_cmds(RzCore *core, const char *port) {
unsigned char buf[4097];
RzSocket *ch = NULL;
int i, ret;
char *str;
if (!port || port[0] == '?') {
rz_cons_printf("Usage: .:[tcp-port] run rizin commands for clients\n");
return false;
}
RzSocket *s = rz_socket_new(0);
s->local = rz_config_get_i(core->config, "tcp.islocal");
if (!rz_socket_listen(s, port, NULL)) {
eprintf("Error listening on port %s\n", port);
rz_socket_free(s);
return false;
}
eprintf("Listening for commands on port %s\n", port);
listenport = port;
rz_cons_break_push((RzConsBreak)rz_core_rtr_http_stop, core);
for (;;) {
if (rz_cons_is_breaked()) {
break;
}
void *bed = rz_cons_sleep_begin();
ch = rz_socket_accept(s);
buf[0] = 0;
ret = rz_socket_read(ch, buf, sizeof(buf) - 1);
rz_cons_sleep_end(bed);
if (ret > 0) {
buf[ret] = 0;
for (i = 0; buf[i]; i++) {
if (buf[i] == '\n') {
buf[i] = buf[i + 1] ? ';' : '\0';
}
}
if ((!rz_config_get_i(core->config, "scr.prompt") &&
!strcmp((char *)buf, "q!")) ||
!strcmp((char *)buf, ".--")) {
rz_socket_close(ch);
break;
}
str = rz_core_cmd_str(core, (const char *)buf);
bed = rz_cons_sleep_begin();
if (str && *str) {
rz_socket_write(ch, str, strlen(str));
} else {
rz_socket_write(ch, "\n", 1);
}
rz_cons_sleep_end(bed);
free(str);
}
rz_socket_close(ch);
rz_socket_free(ch);
ch = NULL;
}
rz_cons_break_pop();
rz_socket_free(s);
rz_socket_free(ch);
return 0;
}
#endif
Reference in a new issue View git blame Copy permalink