2014-01-18 22:02:53 +00:00
|
|
|
/* radare - Copyright 2009-2014 - pancake, nibble */
|
2010-08-24 09:58:09 +00:00
|
|
|
|
|
|
|
#include "r_core.h"
|
|
|
|
#include "r_socket.h"
|
|
|
|
|
2010-09-08 17:49:34 +00:00
|
|
|
#define endian core->assembler->big_endian
|
2010-08-24 09:58:09 +00:00
|
|
|
#define rtr_n core->rtr_n
|
|
|
|
#define rtr_host core->rtr_host
|
|
|
|
|
2012-09-06 01:12:54 +00:00
|
|
|
static RSocket *s = NULL;
|
2012-11-05 01:00:34 +00:00
|
|
|
static const char *listenport = NULL;
|
2012-09-06 01:12:54 +00:00
|
|
|
|
2014-04-11 00:22:41 +00:00
|
|
|
#define http_break r_core_rtr_http_stop
|
|
|
|
R_API int r_core_rtr_http_stop(RCore *u) {
|
2012-10-25 19:40:11 +00:00
|
|
|
RSocket* sock;
|
|
|
|
const char *port;
|
|
|
|
const int timeout = 1; // 1 second
|
2012-09-06 01:12:54 +00:00
|
|
|
RCore *core = (RCore*)u;
|
2012-10-25 19:40:11 +00:00
|
|
|
if (((size_t)u)>0xff) {
|
2014-04-16 04:26:47 +00:00
|
|
|
port = listenport? listenport: r_config_get (
|
|
|
|
core->config, "http.port");
|
2012-10-25 19:40:11 +00:00
|
|
|
sock = r_socket_new (0);
|
2014-04-16 04:26:47 +00:00
|
|
|
(void)r_socket_connect (sock, "localhost",
|
|
|
|
port, R_SOCKET_PROTO_TCP, timeout);
|
2012-11-05 01:00:34 +00:00
|
|
|
r_socket_free (sock);
|
2012-10-25 19:40:11 +00:00
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
r_socket_free (s);
|
2012-09-06 10:47:32 +00:00
|
|
|
s = NULL;
|
2014-04-11 00:22:41 +00:00
|
|
|
return 0;
|
2012-09-06 01:12:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
2012-09-06 23:48:09 +00:00
|
|
|
SECURITY IMPLICATIONS
|
2012-09-06 01:12:54 +00:00
|
|
|
- no ssl
|
|
|
|
- no auth
|
|
|
|
- commands can be executed by anyone
|
|
|
|
- default is to listen on localhost
|
|
|
|
- can access full filesystem
|
|
|
|
- follow symlinks
|
|
|
|
#endif
|
|
|
|
|
2014-06-22 12:57:54 +00:00
|
|
|
static char *rtr_dir_files (const char *path) {
|
|
|
|
char *ptr = strdup ("<html><body>\n");
|
|
|
|
const char *file;
|
|
|
|
RListIter *iter;
|
|
|
|
// list files
|
|
|
|
RList *files = r_sys_dir (path);
|
|
|
|
eprintf ("Listing directory %s\n", path);
|
|
|
|
r_list_foreach (files, iter, file) {
|
|
|
|
if (file[0] == '.') continue;
|
|
|
|
ptr = r_str_concatf (ptr, "<a href=\"%s%s\">%s</a><br />\n",
|
|
|
|
path, file, file);
|
|
|
|
}
|
|
|
|
r_list_free (files);
|
|
|
|
return r_str_concat (ptr, "</body></html>\n");
|
|
|
|
}
|
|
|
|
|
2013-01-24 02:48:24 +00:00
|
|
|
R_API int r_core_rtr_http(RCore *core, int launch, const char *path) {
|
2013-01-25 02:47:09 +00:00
|
|
|
char buf[32];
|
2012-09-07 10:49:36 +00:00
|
|
|
RSocketHTTPRequest *rs;
|
2013-01-25 02:47:09 +00:00
|
|
|
int iport, oldsandbox = -1;
|
2012-12-03 03:01:55 +00:00
|
|
|
int timeout = r_config_get_i (core->config, "http.timeout");
|
2012-09-06 01:12:54 +00:00
|
|
|
int x = r_config_get_i (core->config, "scr.html");
|
|
|
|
int y = r_config_get_i (core->config, "scr.color");
|
2012-09-06 23:48:09 +00:00
|
|
|
int z = r_config_get_i (core->config, "asm.bytes");
|
2012-09-25 12:06:09 +00:00
|
|
|
int u = r_config_get_i (core->config, "scr.interactive");
|
2012-10-01 07:32:04 +00:00
|
|
|
int v = r_config_get_i (core->config, "asm.cmtright");
|
2012-09-06 01:12:54 +00:00
|
|
|
const char *port = r_config_get (core->config, "http.port");
|
2013-02-25 00:47:55 +00:00
|
|
|
char *allow = (char *)r_config_get (core->config, "http.allow");
|
2013-02-06 09:35:23 +00:00
|
|
|
if (core->http_up) {
|
|
|
|
eprintf ("http server is already running\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2012-10-19 22:31:18 +00:00
|
|
|
if (r_sandbox_enable (0)) {
|
|
|
|
eprintf ("sandbox: connect disabled\n");
|
|
|
|
return 1;
|
|
|
|
}
|
2013-02-06 09:35:23 +00:00
|
|
|
if (path && atoi (path)) {
|
|
|
|
port = path;
|
|
|
|
path = NULL;
|
|
|
|
}
|
2013-01-25 02:47:09 +00:00
|
|
|
if (!strcmp (port, "0")) {
|
|
|
|
r_num_irand ();
|
|
|
|
iport = 1024+r_num_rand (45256);
|
|
|
|
snprintf (buf, sizeof (buf), "%d", iport);
|
|
|
|
port = buf;
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
s = r_socket_new (R_FALSE);
|
2012-09-07 01:26:38 +00:00
|
|
|
s->local = !r_config_get_i (core->config, "http.public");
|
2012-09-06 01:12:54 +00:00
|
|
|
if (!r_socket_listen (s, port, NULL)) {
|
|
|
|
eprintf ("Cannot listen on http.port\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (launch) {
|
|
|
|
char cmd[128];
|
|
|
|
const char *browser = r_config_get (core->config, "http.browser");
|
2013-10-19 22:25:37 +00:00
|
|
|
snprintf (cmd, sizeof (cmd)-1, "%s http://localhost:%d/%s &",
|
2013-01-24 02:48:24 +00:00
|
|
|
browser, atoi (port), path?path:"");
|
2012-09-06 01:12:54 +00:00
|
|
|
r_sys_cmd (cmd);
|
|
|
|
}
|
2012-10-01 07:32:04 +00:00
|
|
|
r_config_set (core->config, "asm.cmtright", "false");
|
2012-09-06 01:12:54 +00:00
|
|
|
r_config_set (core->config, "scr.html", "true");
|
|
|
|
r_config_set (core->config, "scr.color", "false");
|
2012-09-06 23:48:09 +00:00
|
|
|
r_config_set (core->config, "asm.bytes", "false");
|
2012-09-25 12:06:09 +00:00
|
|
|
r_config_set (core->config, "scr.interactive", "false");
|
2012-12-03 03:01:55 +00:00
|
|
|
if (r_config_get_i (core->config, "http.sandbox")) {
|
|
|
|
oldsandbox = r_config_get_i (core->config, "cfg.sandbox");
|
|
|
|
r_config_set (core->config, "cfg.sandbox", "true");
|
|
|
|
}
|
2012-09-06 23:48:09 +00:00
|
|
|
eprintf ("Starting http server...\n");
|
|
|
|
eprintf ("http://localhost:%d/\n", atoi (port));
|
2013-02-06 09:35:23 +00:00
|
|
|
core->http_up = R_TRUE;
|
2012-09-06 01:12:54 +00:00
|
|
|
while (!r_cons_singleton ()->breaked) {
|
2014-06-22 12:57:54 +00:00
|
|
|
r_cons_break ((RConsBreak)http_break, core);
|
2012-12-03 03:01:55 +00:00
|
|
|
rs = r_socket_http_accept (s, timeout);
|
2012-09-06 23:48:09 +00:00
|
|
|
if (!rs) {
|
2012-10-25 19:40:11 +00:00
|
|
|
if (!s) break;
|
2013-02-25 00:47:55 +00:00
|
|
|
r_sys_usleep (100);
|
2012-09-06 23:48:09 +00:00
|
|
|
continue;
|
|
|
|
}
|
2013-02-25 00:47:55 +00:00
|
|
|
if (allow && *allow) {
|
|
|
|
int accepted = R_FALSE;
|
|
|
|
const char *host;
|
|
|
|
char *p, *peer = r_socket_to_string (rs->s);
|
|
|
|
char *allows = strdup (allow);
|
|
|
|
//eprintf ("Firewall (%s)\n", allows);
|
|
|
|
int i, count = r_str_split (allows, ',');
|
|
|
|
p = strchr (peer, ':');
|
|
|
|
if (p) *p = 0;
|
|
|
|
for (i=0; i<count; i++) {
|
|
|
|
host = r_str_word_get0 (allows, i);
|
|
|
|
//eprintf ("--- (%s) (%s)\n", host, peer);
|
|
|
|
if (!strcmp (host, peer)) {
|
|
|
|
accepted = R_TRUE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free (peer);
|
|
|
|
free (allows);
|
|
|
|
if (!accepted) {
|
|
|
|
r_socket_http_close (rs);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2012-12-03 03:36:00 +00:00
|
|
|
if (!rs->method || !rs->path) {
|
2014-04-21 10:55:34 +00:00
|
|
|
eprintf ("Invalid http headers received from client\n");
|
2012-12-03 03:36:00 +00:00
|
|
|
r_socket_http_close (rs);
|
|
|
|
continue;
|
|
|
|
}
|
2014-06-22 12:57:54 +00:00
|
|
|
char *dir = NULL;
|
|
|
|
|
|
|
|
if (r_config_get_i (core->config, "http.dirlist"))
|
|
|
|
if (r_file_is_directory (rs->path))
|
|
|
|
dir = strdup (rs->path);
|
2012-09-06 01:12:54 +00:00
|
|
|
if (!strcmp (rs->method, "GET")) {
|
2013-01-04 09:16:41 +00:00
|
|
|
if (!memcmp (rs->path, "/up", 3)) {
|
2013-01-03 00:43:23 +00:00
|
|
|
if (r_config_get_i (core->config, "http.upget")) {
|
2013-01-04 09:16:41 +00:00
|
|
|
const char *uproot = r_config_get (core->config, "http.uproot");
|
|
|
|
if (!rs->path[3] || (rs->path[3]=='/'&&!rs->path[4])) {
|
2014-06-22 12:57:54 +00:00
|
|
|
char *ptr = rtr_dir_files (uproot);
|
2013-01-04 09:16:41 +00:00
|
|
|
r_socket_http_response (rs, 200, ptr, 0, NULL);
|
2014-06-22 12:57:54 +00:00
|
|
|
free (ptr);
|
2013-01-04 09:16:41 +00:00
|
|
|
} else {
|
|
|
|
char *path = r_file_root (uproot, rs->path + 4);
|
|
|
|
if (r_file_exists (path)) {
|
|
|
|
int sz = 0;
|
|
|
|
char *f = r_file_slurp (path, &sz);
|
|
|
|
if (f) {
|
|
|
|
r_socket_http_response (rs, 200, f, sz, NULL);
|
|
|
|
free (f);
|
|
|
|
} else {
|
|
|
|
r_socket_http_response (rs, 403, "Permission denied", 0, NULL);
|
|
|
|
eprintf ("http: Cannot open '%s'\n", path);
|
|
|
|
}
|
|
|
|
} else {
|
2014-06-22 12:57:54 +00:00
|
|
|
if (dir) {
|
|
|
|
char *resp = rtr_dir_files (dir);
|
|
|
|
r_socket_http_response (rs, 404, resp, 0, NULL);
|
|
|
|
free (resp);
|
|
|
|
} else {
|
|
|
|
eprintf ("File '%s' not found\n", path);
|
|
|
|
r_socket_http_response (rs, 404, "File not found\n", 0, NULL);
|
|
|
|
}
|
2013-01-04 09:16:41 +00:00
|
|
|
}
|
|
|
|
free (path);
|
|
|
|
}
|
2013-01-03 00:43:23 +00:00
|
|
|
} else {
|
|
|
|
r_socket_http_response (rs, 403,
|
2013-01-04 09:16:41 +00:00
|
|
|
"Permission denied\n", 0, NULL);
|
2013-01-03 00:43:23 +00:00
|
|
|
}
|
2013-01-04 09:16:41 +00:00
|
|
|
} else if (!memcmp (rs->path, "/cmd/", 5)) {
|
2013-02-06 09:35:23 +00:00
|
|
|
char *cmd = rs->path +5;
|
|
|
|
char foo[32];
|
|
|
|
const char *httpcmd = r_config_get (core->config, "http.uri");
|
|
|
|
while (*cmd=='/') cmd++;
|
|
|
|
if (httpcmd && *httpcmd) {
|
|
|
|
int len;
|
|
|
|
char *res;
|
|
|
|
// do remote http query and proxy response
|
|
|
|
snprintf (foo, sizeof (foo), "%s/%s", httpcmd, cmd);
|
|
|
|
res = r_socket_http_get (foo, NULL, &len);
|
|
|
|
if (res) {
|
|
|
|
res[len]=0;
|
|
|
|
r_cons_printf ("%s\n", res);
|
|
|
|
}
|
|
|
|
} else {
|
2013-01-04 09:16:41 +00:00
|
|
|
char *out, *cmd = rs->path+5;
|
2013-02-06 09:35:23 +00:00
|
|
|
r_str_uri_decode (cmd);
|
|
|
|
// eprintf ("CMD (%s)\n", cmd);
|
|
|
|
out = r_core_cmd_str_pipe (core, cmd);
|
2013-02-11 09:51:45 +00:00
|
|
|
// eprintf ("\nOUT LEN = %d\n", strlen (out));
|
2013-02-06 09:35:23 +00:00
|
|
|
if (out) {
|
|
|
|
char *res = r_str_uri_encode (out);
|
|
|
|
r_socket_http_response (rs, 200, out, 0,
|
|
|
|
"Content-Type: text/plain\n");
|
|
|
|
free (out);
|
|
|
|
free (res);
|
|
|
|
} else r_socket_http_response (rs, 200, "", 0, NULL);
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
} else {
|
|
|
|
const char *root = r_config_get (core->config, "http.root");
|
2014-06-22 12:57:54 +00:00
|
|
|
char *path = r_file_root (root, rs->path);
|
2014-04-21 10:55:34 +00:00
|
|
|
// FD IS OK HERE
|
2012-12-01 01:35:12 +00:00
|
|
|
if (rs->path [strlen (rs->path)-1] == '/') {
|
2013-01-04 09:16:41 +00:00
|
|
|
path = r_str_concat (path, "index.html");
|
|
|
|
//rs->path = r_str_concat (rs->path, "index.html");
|
2012-12-01 01:35:12 +00:00
|
|
|
} else {
|
2013-01-04 09:16:41 +00:00
|
|
|
//snprintf (path, sizeof (path), "%s/%s", root, rs->path);
|
2012-12-01 01:35:12 +00:00
|
|
|
if (r_file_is_directory (path)) {
|
2013-01-04 09:16:41 +00:00
|
|
|
char res[128];
|
|
|
|
snprintf (res, sizeof (res),
|
2013-01-03 00:43:23 +00:00
|
|
|
"Location: %s/\n", rs->path);
|
|
|
|
r_socket_http_response (rs, 302,
|
2013-01-04 09:16:41 +00:00
|
|
|
NULL, 0, res);
|
2012-12-01 01:35:12 +00:00
|
|
|
r_socket_http_close (rs);
|
2013-01-04 09:16:41 +00:00
|
|
|
free (path);
|
2014-06-23 23:01:27 +00:00
|
|
|
free (dir);
|
|
|
|
dir = NULL;
|
2012-12-01 01:35:12 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
}
|
2012-09-06 06:59:13 +00:00
|
|
|
if (r_file_exists (path)) {
|
2012-09-06 01:12:54 +00:00
|
|
|
int sz = 0;
|
|
|
|
char *f = r_file_slurp (path, &sz);
|
|
|
|
if (f) {
|
2013-01-24 02:48:24 +00:00
|
|
|
const char *contenttype = NULL;
|
|
|
|
if (strstr (path, ".js")) contenttype = "Content-Type: application/javascript\n";
|
|
|
|
if (strstr (path, ".css")) contenttype = "Content-Type: text/css\n";
|
|
|
|
if (strstr (path, ".html")) contenttype = "Content-Type: text/html\n";
|
|
|
|
r_socket_http_response (rs, 200, f, sz, contenttype);
|
2012-09-06 01:12:54 +00:00
|
|
|
free (f);
|
2012-12-03 03:01:55 +00:00
|
|
|
} else {
|
|
|
|
r_socket_http_response (rs, 403, "Permission denied", 0, NULL);
|
|
|
|
eprintf ("http: Cannot open '%s'\n", path);
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
} else {
|
2014-06-22 12:57:54 +00:00
|
|
|
if (dir) {
|
|
|
|
char *resp = rtr_dir_files (dir);
|
|
|
|
eprintf ("Dirlisting %s\n", dir);
|
|
|
|
r_socket_http_response (rs, 404, resp, 0, NULL);
|
|
|
|
free (resp);
|
|
|
|
} else {
|
|
|
|
eprintf ("File '%s' not found\n", path);
|
|
|
|
r_socket_http_response (rs, 404, "File not found\n", 0, NULL);
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
}
|
2013-01-04 09:16:41 +00:00
|
|
|
free (path);
|
2012-09-06 01:12:54 +00:00
|
|
|
}
|
|
|
|
} else
|
|
|
|
if (!strcmp (rs->method, "POST")) {
|
2013-01-03 00:43:23 +00:00
|
|
|
ut8 *ret;
|
2013-01-02 17:37:48 +00:00
|
|
|
int retlen;
|
2013-01-02 23:47:58 +00:00
|
|
|
char buf[128];
|
|
|
|
if (r_config_get_i (core->config, "http.upload")) {
|
2013-01-03 00:43:23 +00:00
|
|
|
ret = r_socket_http_handle_upload (
|
|
|
|
rs->data, rs->data_length, &retlen);
|
|
|
|
if (ret) {
|
|
|
|
ut64 size = r_config_get_i (core->config, "http.maxsize");
|
|
|
|
if (size && retlen > size) {
|
|
|
|
r_socket_http_response (rs, 403, "403 File too big\n", 0, NULL);
|
|
|
|
} else {
|
|
|
|
char *filename = r_file_root (
|
|
|
|
r_config_get (core->config, "http.uproot"),
|
|
|
|
rs->path + 4);
|
|
|
|
eprintf ("UPLOADED '%s'\n", filename);
|
|
|
|
r_file_dump (filename, ret, retlen);
|
|
|
|
free (filename);
|
|
|
|
snprintf (buf, sizeof (buf),
|
|
|
|
"<html><body><h2>uploaded %d bytes. Thanks</h2>\n", retlen);
|
|
|
|
r_socket_http_response (rs, 200, buf, 0, NULL);
|
|
|
|
}
|
|
|
|
free (ret);
|
|
|
|
}
|
2013-01-02 23:47:58 +00:00
|
|
|
} else {
|
|
|
|
r_socket_http_response (rs, 403, "403 Forbidden\n", 0, NULL);
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
} else {
|
2012-10-03 10:10:18 +00:00
|
|
|
r_socket_http_response (rs, 404, "Invalid protocol", 0, NULL);
|
2012-09-06 01:12:54 +00:00
|
|
|
}
|
2012-12-12 03:10:44 +00:00
|
|
|
r_socket_http_close (rs);
|
2014-06-22 12:57:54 +00:00
|
|
|
free (dir);
|
2012-09-06 01:12:54 +00:00
|
|
|
}
|
2013-02-06 09:35:23 +00:00
|
|
|
core->http_up = R_FALSE;
|
2012-09-06 01:12:54 +00:00
|
|
|
r_socket_free (s);
|
|
|
|
r_cons_break_end ();
|
|
|
|
r_config_set_i (core->config, "scr.html", x);
|
|
|
|
r_config_set_i (core->config, "scr.color", y);
|
2012-09-06 23:48:09 +00:00
|
|
|
r_config_set_i (core->config, "asm.bytes", z);
|
2012-09-25 12:06:09 +00:00
|
|
|
r_config_set_i (core->config, "scr.interactive", u);
|
2012-10-01 07:32:04 +00:00
|
|
|
r_config_set_i (core->config, "asm.cmtright", v);
|
2012-12-03 03:01:55 +00:00
|
|
|
if (oldsandbox != -1)
|
|
|
|
r_config_set_i (core->config, "cfg.sandbox", oldsandbox);
|
2012-09-06 01:12:54 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2010-08-24 09:58:09 +00:00
|
|
|
R_API void r_core_rtr_help(RCore *core) {
|
2014-06-20 11:25:17 +00:00
|
|
|
const char* help_msg[] = {
|
|
|
|
"Usage:", " =[:!+-=hH] [...]", " # radare remote command execution protocol",
|
|
|
|
"\nrap commands:", "", "",
|
|
|
|
"=", "", "list all open connections",
|
|
|
|
"=<", "[fd] cmd", "send output of local command to remote fd",
|
|
|
|
"=", "[fd] cmd", "exec cmd at remote 'fd' (last open is default one)",
|
|
|
|
"=!", " cmd", "run command via r_io_system",
|
|
|
|
"=+", " [proto://]host", "add host (default=rap://, tcp://, udp://)",
|
|
|
|
"=-", "[fd]", "remove all hosts or host 'fd'",
|
|
|
|
"==", "[fd]", "open remote session with host 'fd', 'q' to quit",
|
2014-08-28 01:41:23 +00:00
|
|
|
"\nrap server:","","",
|
|
|
|
"=", ":port", "listen on given port using rap protocol (o rap://9999)",
|
|
|
|
"=", ":host:port cmd", "run 'cmd' command on remote server",
|
2014-06-20 11:25:17 +00:00
|
|
|
"\nhttp server:", "", "",
|
|
|
|
"=h", "", "listen for http connections (r2 -qc=H /bin/ls)",
|
|
|
|
"=H", "", "launch browser and listen for http",
|
|
|
|
NULL};
|
|
|
|
r_core_cmd_help (core, help_msg);
|
2010-08-24 09:58:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_rtr_pushout(RCore *core, const char *input) {
|
2011-09-03 03:09:31 +00:00
|
|
|
int fd = atoi (input);
|
2010-08-24 09:58:09 +00:00
|
|
|
const char *cmd = NULL;
|
|
|
|
char *str = NULL;
|
|
|
|
if (fd) {
|
2011-03-21 00:47:17 +00:00
|
|
|
for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd \
|
2014-08-03 22:48:23 +00:00
|
|
|
&& rtr_n < RTR_MAX_HOSTS - 1; rtr_n++);
|
2010-08-24 09:58:09 +00:00
|
|
|
if (!(cmd = strchr (input, ' '))) {
|
|
|
|
eprintf ("Error\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else cmd = input;
|
|
|
|
|
2011-03-21 00:47:17 +00:00
|
|
|
if (!rtr_host[rtr_n].fd->fd) {
|
2010-08-24 09:58:09 +00:00
|
|
|
eprintf("Error: Unknown host\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!(str = r_core_cmd_str (core, cmd))) {
|
|
|
|
eprintf ("Error: radare_cmd_str returned NULL\n");
|
|
|
|
return;
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
|
2010-08-24 09:58:09 +00:00
|
|
|
switch (rtr_host[rtr_n].proto) {
|
|
|
|
case RTR_PROT_RAP:
|
|
|
|
eprintf ("Error: Cannot use '=<' to a rap connection.\n");
|
|
|
|
break;
|
|
|
|
case RTR_PROT_TCP:
|
|
|
|
case RTR_PROT_UDP:
|
|
|
|
default:
|
|
|
|
r_socket_write (rtr_host[rtr_n].fd, str, strlen (str));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
free (str);
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_rtr_list(RCore *core) {
|
|
|
|
int i;
|
|
|
|
for (i = 0; i < RTR_MAX_HOSTS; i++)
|
|
|
|
if (rtr_host[i].fd) {
|
2011-03-21 00:47:17 +00:00
|
|
|
r_cons_printf("%i - ", rtr_host[i].fd->fd);
|
2013-02-06 09:35:23 +00:00
|
|
|
if (rtr_host[i].proto == RTR_PROT_HTTP)
|
|
|
|
r_cons_printf( "http://");
|
2010-08-24 09:58:09 +00:00
|
|
|
if (rtr_host[i].proto == RTR_PROT_TCP)
|
2013-02-06 09:35:23 +00:00
|
|
|
r_cons_printf ("tcp://");
|
2010-08-24 09:58:09 +00:00
|
|
|
else if (rtr_host[i].proto == RTR_PROT_UDP)
|
|
|
|
r_cons_printf("udp://");
|
|
|
|
else r_cons_printf("rap://");
|
|
|
|
r_cons_printf ("%s:%i/%s\n", rtr_host[i].host,
|
|
|
|
rtr_host[i].port, rtr_host[i].file);
|
|
|
|
}
|
|
|
|
}
|
2014-04-22 22:12:03 +00:00
|
|
|
|
2010-08-24 09:58:09 +00:00
|
|
|
R_API void r_core_rtr_add(RCore *core, const char *_input) {
|
2011-03-27 15:44:27 +00:00
|
|
|
char *port, input[1024], *host = NULL, *file = NULL, *ptr = NULL, buf[1024];
|
2013-11-30 01:47:29 +00:00
|
|
|
int proto, i, timeout, ret;
|
2011-03-21 00:47:17 +00:00
|
|
|
RSocket *fd;
|
2010-08-24 09:58:09 +00:00
|
|
|
|
2013-11-29 16:27:46 +00:00
|
|
|
timeout = r_config_get_i (core->config, "http.timeout");
|
2010-09-08 17:49:34 +00:00
|
|
|
strncpy (input, _input, sizeof (input)-4);
|
2010-08-24 09:58:09 +00:00
|
|
|
/* Parse uri */
|
2014-03-03 01:01:40 +00:00
|
|
|
if ((ptr = strstr (input, "tcp://"))) {
|
2010-08-24 09:58:09 +00:00
|
|
|
proto = RTR_PROT_TCP;
|
|
|
|
host = ptr+6;
|
2013-02-06 09:35:23 +00:00
|
|
|
} else if ((ptr = strstr(input, "http://"))) {
|
|
|
|
proto = RTR_PROT_HTTP;
|
|
|
|
host = ptr+7;
|
2010-08-24 09:58:09 +00:00
|
|
|
} else if ((ptr = strstr(input, "udp://"))) {
|
|
|
|
proto = RTR_PROT_UDP;
|
|
|
|
host = ptr+6;
|
|
|
|
} else if ((ptr = strstr(input, "rap://"))) {
|
|
|
|
proto = RTR_PROT_RAP;
|
|
|
|
host = ptr+6;
|
|
|
|
} else {
|
|
|
|
proto = RTR_PROT_RAP;
|
|
|
|
host = input;
|
|
|
|
}
|
2012-12-22 02:37:50 +00:00
|
|
|
while (*host && iswhitechar (*host))
|
2011-09-03 03:09:31 +00:00
|
|
|
host++;
|
2010-08-24 09:58:09 +00:00
|
|
|
|
|
|
|
if (!(ptr = strchr (host, ':'))) {
|
2013-03-17 23:38:04 +00:00
|
|
|
ptr = host;
|
|
|
|
port = "80";
|
|
|
|
} else {
|
|
|
|
*ptr++ = '\0';
|
|
|
|
port = ptr;
|
2010-08-24 09:58:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!(file = strchr (ptr, '/'))) {
|
|
|
|
eprintf("Error: Missing '/'\n");
|
|
|
|
return;
|
|
|
|
}
|
2012-09-06 01:12:54 +00:00
|
|
|
*file++ = 0;
|
2013-11-29 16:27:46 +00:00
|
|
|
port = r_str_chop (port);
|
|
|
|
while (*file==' ') file++;
|
|
|
|
if (r_sandbox_enable (0)) {
|
|
|
|
eprintf ("sandbox: connect disabled\n");
|
|
|
|
return;
|
|
|
|
}
|
2010-08-24 09:58:09 +00:00
|
|
|
|
2011-05-05 01:41:57 +00:00
|
|
|
fd = r_socket_new (R_FALSE);
|
|
|
|
if (!fd) {
|
2011-09-03 03:09:31 +00:00
|
|
|
eprintf ("Error: Cannot create new socket\n");
|
2011-05-05 01:41:57 +00:00
|
|
|
return;
|
|
|
|
}
|
2010-08-24 09:58:09 +00:00
|
|
|
switch (proto) {
|
2013-02-06 09:35:23 +00:00
|
|
|
case RTR_PROT_HTTP:
|
|
|
|
{
|
|
|
|
char uri[1024], prompt[64];
|
|
|
|
int len;
|
|
|
|
char *str, *res;
|
|
|
|
if (file[strlen (file)-1]=='/') {
|
|
|
|
snprintf (prompt, sizeof (prompt), "[http://%s:%s/%s]> ",
|
|
|
|
host, port, file);
|
|
|
|
r_line_set_prompt (prompt);
|
2013-03-03 16:28:06 +00:00
|
|
|
for (;;) {
|
|
|
|
char *ptr, *str = r_line_readline ();
|
2013-02-06 09:35:23 +00:00
|
|
|
if (!str || !*str) break;
|
2013-03-17 23:38:04 +00:00
|
|
|
if (*str == 'q') break;
|
2013-03-03 16:28:06 +00:00
|
|
|
ptr = r_str_uri_encode (str);
|
|
|
|
if (ptr) str = ptr;
|
2013-02-06 09:35:23 +00:00
|
|
|
snprintf (uri, sizeof (uri), "http://%s:%s/%s%s",
|
|
|
|
host, port, file, str);
|
2013-03-03 16:28:06 +00:00
|
|
|
if (ptr == str) free (ptr);
|
2013-02-06 09:35:23 +00:00
|
|
|
str = r_socket_http_get (uri, NULL, &len);
|
|
|
|
if (str) {
|
|
|
|
str[len] = 0;
|
|
|
|
res = strstr (str, "\n\n");
|
|
|
|
if (res) res = strstr (res+1, "\n\n");
|
|
|
|
if (res) res += 2; else res = str;
|
2013-03-03 16:28:06 +00:00
|
|
|
printf ("%s%s", res, (res[strlen (res)-1]=='\n')?"":"\n");
|
|
|
|
r_line_hist_add (str);
|
2013-02-06 09:35:23 +00:00
|
|
|
free (str);
|
2013-03-17 23:38:04 +00:00
|
|
|
}
|
2013-02-06 09:35:23 +00:00
|
|
|
}
|
2014-08-17 18:30:28 +00:00
|
|
|
r_socket_free (fd);
|
2013-02-06 09:35:23 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-11-29 16:27:46 +00:00
|
|
|
snprintf (uri, sizeof (uri), "http://%s:%s/%s",
|
|
|
|
host, port, file);
|
2013-02-06 09:35:23 +00:00
|
|
|
str = r_socket_http_get (uri, NULL, &len);
|
|
|
|
if (str) {
|
|
|
|
str[len] = 0;
|
|
|
|
res = strstr (str, "\n\n");
|
|
|
|
if (res) res = strstr (res+1, "\n\n");
|
|
|
|
if (res) res += 2; else res = str;
|
|
|
|
printf ("%s", res);
|
|
|
|
free (str);
|
2013-03-03 16:28:06 +00:00
|
|
|
} else eprintf ("HTTP connection has failed\n");
|
2013-02-06 09:35:23 +00:00
|
|
|
// do not add connection. wtf
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
break;
|
2010-08-24 09:58:09 +00:00
|
|
|
case RTR_PROT_RAP:
|
2013-11-29 16:27:46 +00:00
|
|
|
if (!r_socket_connect_tcp (fd, host, port, timeout)) { //TODO: Use rap.ssl
|
2011-09-03 03:09:31 +00:00
|
|
|
eprintf ("Error: Cannot connect to '%s' (%s)\n", host, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-11-30 01:47:29 +00:00
|
|
|
eprintf ("Connected to %s at port %s\n", host, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
/* send */
|
|
|
|
buf[0] = RTR_RAP_OPEN;
|
|
|
|
buf[1] = 0;
|
|
|
|
buf[2] = (ut8)(strlen (file)+1);
|
|
|
|
memcpy (buf+3, file, buf[2]);
|
|
|
|
r_socket_write(fd, buf, 3+buf[2]);
|
|
|
|
/* read */
|
|
|
|
eprintf ("waiting... "); fflush(stdout);
|
|
|
|
r_socket_read (fd, (ut8*)buf, 5);
|
2010-09-08 17:49:34 +00:00
|
|
|
r_mem_copyendian ((ut8 *)&i, (ut8*)buf+1, 4, core->assembler->big_endian);
|
2010-08-24 09:58:09 +00:00
|
|
|
if (buf[0] != (char)(RTR_RAP_OPEN|RTR_RAP_REPLY) || i<= 0) {
|
|
|
|
eprintf ("Error: Wrong reply\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
eprintf ("ok\n");
|
|
|
|
break;
|
|
|
|
case RTR_PROT_TCP:
|
2013-11-29 16:27:46 +00:00
|
|
|
if (!r_socket_connect_tcp (fd, host, port, timeout)) { //TODO: Use rap.ssl
|
|
|
|
core->num->value = 1;
|
2011-05-05 01:41:57 +00:00
|
|
|
eprintf("Error: Cannot connect to '%s' (%s)\n", host, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-11-29 16:27:46 +00:00
|
|
|
core->num->value = 0;
|
2011-03-27 15:44:27 +00:00
|
|
|
eprintf ("Connected to: %s at port %s\n", host, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
break;
|
|
|
|
case RTR_PROT_UDP:
|
2013-11-29 16:27:46 +00:00
|
|
|
if (!r_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);
|
2010-08-24 09:58:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2013-11-29 16:27:46 +00:00
|
|
|
core->num->value = 0;
|
2011-03-27 15:44:27 +00:00
|
|
|
eprintf("Connected to: %s at port %s\n", host, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2013-11-30 01:47:29 +00:00
|
|
|
ret = core->num->value;
|
2010-08-24 09:58:09 +00:00
|
|
|
for (i = 0; i < RTR_MAX_HOSTS; i++)
|
|
|
|
if (!rtr_host[i].fd) {
|
|
|
|
rtr_host[i].proto = proto;
|
|
|
|
memcpy (rtr_host[i].host, host, 512);
|
2013-11-29 16:27:46 +00:00
|
|
|
rtr_host[i].port = r_num_get (core->num, port);
|
2010-08-24 09:58:09 +00:00
|
|
|
memcpy (rtr_host[i].file, file, 1024);
|
|
|
|
rtr_host[i].fd = fd;
|
|
|
|
rtr_n = i;
|
|
|
|
break;
|
|
|
|
}
|
2013-11-30 01:47:29 +00:00
|
|
|
core->num->value = ret;
|
2014-08-03 22:48:23 +00:00
|
|
|
r_socket_free(fd);
|
2013-02-06 09:35:23 +00:00
|
|
|
//r_core_rtr_list (core);
|
2010-08-24 09:58:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_rtr_remove(RCore *core, const char *input) {
|
|
|
|
int fd, i;
|
|
|
|
|
|
|
|
if (input[0] >= '0' && input[0] <= '9') {
|
|
|
|
fd = r_num_math (core->num, input);
|
|
|
|
for (i = 0; i < RTR_MAX_HOSTS; i++)
|
2011-03-21 00:47:17 +00:00
|
|
|
if (rtr_host[i].fd->fd == fd) {
|
|
|
|
r_socket_free (rtr_host[i].fd);
|
|
|
|
rtr_host[i].fd = NULL;
|
2010-08-24 09:58:09 +00:00
|
|
|
if (rtr_n == i)
|
2014-08-03 22:48:23 +00:00
|
|
|
for (rtr_n = 0; !rtr_host[rtr_n].fd \
|
|
|
|
&& rtr_n < RTR_MAX_HOSTS - 1; rtr_n++);
|
2010-08-24 09:58:09 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for (i = 0; i < RTR_MAX_HOSTS; i++)
|
|
|
|
if (rtr_host[i].fd)
|
2011-03-21 00:47:17 +00:00
|
|
|
r_socket_free (rtr_host[i].fd);
|
2010-08-24 09:58:09 +00:00
|
|
|
memset (rtr_host, '\0', RTR_MAX_HOSTS * sizeof(RCoreRtrHost));
|
|
|
|
rtr_n = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API void r_core_rtr_session(RCore *core, const char *input) {
|
2014-01-18 22:02:53 +00:00
|
|
|
char prompt[64], buf[4096];
|
2010-08-24 09:58:09 +00:00
|
|
|
int fd;
|
|
|
|
|
2014-01-18 22:02:53 +00:00
|
|
|
prompt[0] = 0;
|
2010-08-24 09:58:09 +00:00
|
|
|
if (input[0] >= '0' && input[0] <= '9') {
|
|
|
|
fd = r_num_math (core->num, input);
|
2013-01-03 00:43:23 +00:00
|
|
|
for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd \
|
2014-08-03 22:48:23 +00:00
|
|
|
&& rtr_n < RTR_MAX_HOSTS - 1; rtr_n++);
|
2010-08-24 09:58:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
for (;;) {
|
2011-09-03 03:09:31 +00:00
|
|
|
if (rtr_host[rtr_n].fd)
|
|
|
|
snprintf (prompt, sizeof (prompt),
|
|
|
|
"fd:%d> ", rtr_host[rtr_n].fd->fd);
|
2012-08-19 01:28:17 +00:00
|
|
|
free (r_line_singleton ()->prompt);
|
|
|
|
r_line_singleton ()->prompt = strdup (prompt);
|
2010-08-24 09:58:09 +00:00
|
|
|
if ((r_cons_fgets (buf, sizeof (buf), 0, NULL))) {
|
2014-04-28 08:17:42 +00:00
|
|
|
if (!*buf || *buf == 'q')
|
2010-08-24 09:58:09 +00:00
|
|
|
break;
|
2014-04-28 08:17:42 +00:00
|
|
|
if (*buf == 'V') {
|
2010-08-24 09:58:09 +00:00
|
|
|
eprintf ("Visual mode not supported\n");
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
r_core_rtr_cmd (core, buf);
|
|
|
|
r_cons_flush ();
|
2014-04-28 08:17:42 +00:00
|
|
|
} else break;
|
2010-08-24 09:58:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
2012-12-30 22:40:17 +00:00
|
|
|
if (*input==':' && !strchr (input+1, ':')) {
|
|
|
|
r_core_cmdf (core, "o rap://%s", input);
|
|
|
|
return;
|
|
|
|
}
|
2010-08-24 09:58:09 +00:00
|
|
|
if (fd != 0) {
|
2011-09-03 03:09:31 +00:00
|
|
|
if (rtr_host[rtr_n].fd)
|
|
|
|
for (rtr_n = 0; rtr_host[rtr_n].fd->fd != fd
|
2014-08-03 22:48:23 +00:00
|
|
|
&& rtr_n < RTR_MAX_HOSTS - 1; rtr_n++);
|
2010-08-24 09:58:09 +00:00
|
|
|
if (!(cmd = strchr (input, ' '))) {
|
2011-09-03 03:09:31 +00:00
|
|
|
eprintf ("Error\n");
|
2010-08-24 09:58:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
} else cmd = input;
|
|
|
|
|
|
|
|
if (!rtr_host[rtr_n].fd){
|
|
|
|
eprintf ("Error: Unknown host\n");
|
2013-11-29 16:27:46 +00:00
|
|
|
core->num->value = 1; // fail
|
2010-08-24 09:58:09 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!rtr_host[rtr_n].proto == RTR_PROT_RAP){
|
|
|
|
eprintf ("Error: Not a rap:// host\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2013-11-29 16:27:46 +00:00
|
|
|
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;
|
|
|
|
}
|
2010-08-24 09:58:09 +00:00
|
|
|
/* 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) {
|
2011-09-03 03:09:31 +00:00
|
|
|
eprintf ("Error: Allocating cmd output\n");
|
2010-08-24 09:58:09 +00:00
|
|
|
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);
|
|
|
|
}
|
2012-11-05 01:00:34 +00:00
|
|
|
|
|
|
|
// TODO: support len for binary data?
|
|
|
|
R_API char *r_core_rtr_cmds_query (RCore *core, const char *host, const char *port, const char *cmd) {
|
|
|
|
int retries = 6;
|
|
|
|
unsigned char buf[1024];
|
|
|
|
char *rbuf = NULL;
|
|
|
|
const int timeout = 0;
|
|
|
|
RSocket *s = r_socket_new (0);
|
2013-01-23 13:50:50 +00:00
|
|
|
for (;retries>0; r_sys_usleep (10*1000)) {
|
2012-11-05 01:00:34 +00:00
|
|
|
if (r_socket_connect (s, host, port, R_SOCKET_PROTO_TCP, timeout))
|
|
|
|
break;
|
|
|
|
retries--;
|
|
|
|
}
|
|
|
|
if (retries>0) {
|
|
|
|
rbuf = strdup ("");
|
|
|
|
r_socket_write (s, (void*)cmd, strlen (cmd));
|
|
|
|
//r_socket_write (s, "px\n", 3);
|
|
|
|
for (;;) {
|
|
|
|
int ret = r_socket_read (s, buf, sizeof (buf));
|
|
|
|
if (ret<1) break;
|
|
|
|
buf[ret] = 0;
|
|
|
|
rbuf = r_str_concat (rbuf, (const char *)buf);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
eprintf ("Cannot connect\n");
|
|
|
|
}
|
|
|
|
r_socket_free (s);
|
|
|
|
return rbuf;
|
|
|
|
}
|
|
|
|
|
|
|
|
R_API int r_core_rtr_cmds (RCore *core, const char *port) {
|
2014-04-22 22:12:03 +00:00
|
|
|
unsigned char buf[4097];
|
2012-12-22 02:37:50 +00:00
|
|
|
RSocket *ch, *s;
|
|
|
|
int i, ret;
|
|
|
|
char *str;
|
|
|
|
|
|
|
|
if (!port || port[0]=='?') {
|
|
|
|
r_cons_printf ("Usage: .:[tcp-port] run r2 commands for clients\n");
|
|
|
|
return R_FALSE;
|
|
|
|
}
|
2012-12-03 03:01:55 +00:00
|
|
|
|
2012-12-22 02:37:50 +00:00
|
|
|
s = r_socket_new (0);
|
2012-11-05 01:00:34 +00:00
|
|
|
if (!r_socket_listen (s, port, NULL)) {
|
|
|
|
eprintf ("Error listening on port %s\n", port);
|
2012-12-22 02:37:50 +00:00
|
|
|
r_socket_free (s);
|
2012-11-05 01:00:34 +00:00
|
|
|
return R_FALSE;
|
|
|
|
}
|
2014-04-22 22:12:03 +00:00
|
|
|
|
2012-11-05 01:00:34 +00:00
|
|
|
eprintf ("Listening for commands on port %s\n", port);
|
|
|
|
listenport = port;
|
|
|
|
for (;;) {
|
2014-06-22 12:57:54 +00:00
|
|
|
r_cons_break ((RConsBreak)http_break, core);
|
2012-11-05 01:00:34 +00:00
|
|
|
ch = r_socket_accept (s);
|
|
|
|
buf[0] = 0;
|
2014-04-22 22:12:03 +00:00
|
|
|
ret = r_socket_read (ch, buf, sizeof (buf) - 1);
|
2012-11-05 01:00:34 +00:00
|
|
|
if (ret>0) {
|
|
|
|
buf[ret] = 0;
|
2012-12-03 03:01:55 +00:00
|
|
|
for (i=0; buf[i]; i++)
|
2012-11-05 01:00:34 +00:00
|
|
|
if (buf[i] == '\n')
|
2012-12-12 22:58:18 +00:00
|
|
|
buf[i] = buf[i+1]? ';': '\0';
|
2012-11-05 01:00:34 +00:00
|
|
|
if (!r_config_get_i (core->config, "scr.prompt") \
|
|
|
|
&& !strcmp ((char*)buf, "q!"))
|
2012-12-12 22:58:18 +00:00
|
|
|
break;
|
2012-11-05 01:00:34 +00:00
|
|
|
str = r_core_cmd_str (core, (const char *)buf);
|
2012-12-12 22:58:18 +00:00
|
|
|
if (str &&*str) {
|
2012-11-05 01:00:34 +00:00
|
|
|
r_socket_write (ch, str, strlen (str));
|
2014-04-22 22:12:03 +00:00
|
|
|
} else
|
2012-12-12 22:58:18 +00:00
|
|
|
r_socket_write (ch, "\n", 1);
|
|
|
|
free (str);
|
2012-11-05 01:00:34 +00:00
|
|
|
}
|
2014-06-22 12:57:54 +00:00
|
|
|
if (r_cons_singleton()->breaked)
|
|
|
|
break;
|
2012-11-05 01:00:34 +00:00
|
|
|
r_socket_close (ch);
|
|
|
|
r_cons_break_end ();
|
|
|
|
}
|
2014-08-03 22:48:23 +00:00
|
|
|
r_socket_free(s);
|
|
|
|
r_socket_free(ch);
|
2012-11-05 01:00:34 +00:00
|
|
|
return 0;
|
|
|
|
}
|