static RIODesc *__open(RIO *io, const char *pathname, int rw, int mode) {
char *out;
int rlen, code;
if (__plugin_open (io, pathname, 0)) {
RIOR2Web *mal = R_NEW0 (RIOR2Web);
if (!mal) return NULL;
char *url = r_str_newf ("http://%s/?V", pathname+8);
//eprintf ("URL:(%s)\n", url);
out = r_socket_http_get (url, &code, &rlen);
//eprintf ("RES %d %d\n", code, rlen);
//eprintf ("OUT(%s)\n", out);
if (out && rlen>0) {
mal->fd = getmalfd (mal);
mal->url = r_str_newf ("http://%s", pathname+8);
free (out);
free (url);
return r_io_desc_new (&r_io_plugin_r2web,
mal->fd, pathname, rw, mode, mal);
}
free (url);
free (mal);
free (out);
}
return NULL;
}
static RIODesc *__open(RIO *io, const char *pathname, int rw, int mode) {
char *out;
int rlen, code;
if (__plugin_open (io, pathname, 0)) {
out = r_socket_http_get (pathname, &code, &rlen);
if (out && rlen>0) {
RIOMalloc *mal = R_NEW0 (RIOMalloc);
if (!mal) return NULL;
mal->size = rlen;
mal->buf = malloc (mal->size+1);
if (!mal->buf) {
free (mal);
return NULL;
}
if (mal->buf != NULL) {
mal->fd = getmalfd (mal);
memcpy (mal->buf, out, mal->size);
free (out);
return r_io_desc_new (io, &r_io_plugin_http,
pathname, rw, mode, mal);
}
eprintf ("Cannot allocate (%s) %d bytes\n", pathname+9, mal->size);
free (mal);
}
free (out);
}
return NULL;
}
static int __system(RIO *io, RIODesc *fd, const char *command) {
int code, rlen;
char *out;
int ret = 0;
char *url = r_str_newf ("%s/%s", rURL(fd), command);
out = r_socket_http_get (url, &code, &rlen);
if (out && rlen>0) {
io->cb_printf ("%s", out);
}
free (out);
free (url);
return ret;
}
static int __write(RIO *io, RIODesc *fd, const ut8 *buf, int count) {
int code, rlen;
char *out, *url, *hexbuf;
if (fd == NULL || fd->data == NULL)
return -1;
hexbuf = malloc (count * 3);
hexbuf[0] = 0;
r_hex_bin2str (buf, count, hexbuf);
url = r_str_newf ("%s/wx%%20%s@%"PFMT64d,
rURL(fd), hexbuf, io->off);
out = r_socket_http_get (url, &code, &rlen);
free (out);
free (url);
free (hexbuf);
return count;
}
static int __read(RIO *io, RIODesc *fd, ut8 *buf, int count) {
int code, rlen;
char *out, *url;
int ret = 0;
if (fd == NULL || fd->data == NULL)
return -1;
url = r_str_newf ("%s/p8%%20%d@%"PFMT64d,
rURL(fd), count, io->off);
out = r_socket_http_get (url, &code, &rlen);
if (out && rlen>0) {
ut8 *tmp = malloc (rlen+1);
ret = r_hex_str2bin (out, tmp);
memcpy (buf, tmp, R_MIN (count, rlen));
free (tmp);
if (ret<0) ret = -ret;
}
free (out);
free (url);
return ret;
}
R_API int r_core_rtr_http(RCore *core, int launch, const char *path) {
char buf[32];
RSocketHTTPRequest *rs;
int iport, oldsandbox = -1;
int timeout = r_config_get_i (core->config, "http.timeout");
int x = r_config_get_i (core->config, "scr.html");
int y = r_config_get_i (core->config, "scr.color");
int z = r_config_get_i (core->config, "asm.bytes");
int u = r_config_get_i (core->config, "scr.interactive");
int v = r_config_get_i (core->config, "asm.cmtright");
const char *port = r_config_get (core->config, "http.port");
char *allow = (char *)r_config_get (core->config, "http.allow");
if (core->http_up) {
eprintf ("http server is already running\n");
return 1;
}
if (r_sandbox_enable (0)) {
eprintf ("sandbox: connect disabled\n");
return 1;
}
if (path && atoi (path)) {
port = path;
path = NULL;
}
if (!strcmp (port, "0")) {
r_num_irand ();
iport = 1024+r_num_rand (45256);
snprintf (buf, sizeof (buf), "%d", iport);
port = buf;
}
s = r_socket_new (R_FALSE);
s->local = !r_config_get_i (core->config, "http.public");
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");
snprintf (cmd, sizeof (cmd)-1, "%s http://localhost:%d/%s &",
browser, atoi (port), path?path:"");
r_sys_cmd (cmd);
}
r_config_set (core->config, "asm.cmtright", "false");
r_config_set (core->config, "scr.html", "true");
r_config_set (core->config, "scr.color", "false");
r_config_set (core->config, "asm.bytes", "false");
r_config_set (core->config, "scr.interactive", "false");
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");
}
eprintf ("Starting http server...\n");
eprintf ("http://localhost:%d/\n", atoi (port));
core->http_up = R_TRUE;
while (!r_cons_singleton ()->breaked) {
r_cons_break ((RConsBreak)http_break, core);
rs = r_socket_http_accept (s, timeout);
if (!rs) {
if (!s) break;
r_sys_usleep (100);
continue;
}
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;
}
}
if (!rs->method || !rs->path) {
eprintf ("Invalid http headers received from client\n");
r_socket_http_close (rs);
continue;
}
char *dir = NULL;
if (r_config_get_i (core->config, "http.dirlist"))
if (r_file_is_directory (rs->path))
dir = strdup (rs->path);
if (!strcmp (rs->method, "GET")) {
if (!memcmp (rs->path, "/up", 3)) {
if (r_config_get_i (core->config, "http.upget")) {
const char *uproot = r_config_get (core->config, "http.uproot");
if (!rs->path[3] || (rs->path[3]=='/'&&!rs->path[4])) {
char *ptr = rtr_dir_files (uproot);
r_socket_http_response (rs, 200, ptr, 0, NULL);
free (ptr);
} 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 {
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);
}
}
free (path);
}
} else {
r_socket_http_response (rs, 403,
"Permission denied\n", 0, NULL);
}
} else if (!memcmp (rs->path, "/cmd/", 5)) {
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 {
char *out, *cmd = rs->path+5;
r_str_uri_decode (cmd);
// eprintf ("CMD (%s)\n", cmd);
out = r_core_cmd_str_pipe (core, cmd);
// eprintf ("\nOUT LEN = %d\n", strlen (out));
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);
}
} else {
const char *root = r_config_get (core->config, "http.root");
char *path = r_file_root (root, rs->path);
// FD IS OK HERE
if (rs->path [strlen (rs->path)-1] == '/') {
path = r_str_concat (path, "index.html");
//rs->path = r_str_concat (rs->path, "index.html");
} else {
//snprintf (path, sizeof (path), "%s/%s", root, rs->path);
if (r_file_is_directory (path)) {
char res[128];
snprintf (res, sizeof (res),
"Location: %s/\n", rs->path);
r_socket_http_response (rs, 302,
NULL, 0, res);
r_socket_http_close (rs);
free (path);
free (dir);
dir = NULL;
continue;
}
}
if (r_file_exists (path)) {
int sz = 0;
char *f = r_file_slurp (path, &sz);
if (f) {
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);
free (f);
} else {
r_socket_http_response (rs, 403, "Permission denied", 0, NULL);
eprintf ("http: Cannot open '%s'\n", path);
}
} else {
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);
}
}
free (path);
}
} else
if (!strcmp (rs->method, "POST")) {
ut8 *ret;
int retlen;
char buf[128];
if (r_config_get_i (core->config, "http.upload")) {
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);
}
} else {
r_socket_http_response (rs, 403, "403 Forbidden\n", 0, NULL);
}
} else {
r_socket_http_response (rs, 404, "Invalid protocol", 0, NULL);
}
r_socket_http_close (rs);
free (dir);
}
core->http_up = R_FALSE;
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);
r_config_set_i (core->config, "asm.bytes", z);
r_config_set_i (core->config, "scr.interactive", u);
r_config_set_i (core->config, "asm.cmtright", v);
if (oldsandbox != -1)
r_config_set_i (core->config, "cfg.sandbox", oldsandbox);
return 0;
}
R_API void r_core_rtr_add(RCore *core, const char *_input) {
char *port, input[1024], *host = NULL, *file = NULL, *ptr = NULL, buf[1024];
int proto, i, timeout, ret;
RSocket *fd;
timeout = r_config_get_i (core->config, "http.timeout");
strncpy (input, _input, sizeof (input)-4);
/* Parse uri */
if ((ptr = strstr (input, "tcp://"))) {
proto = RTR_PROT_TCP;
host = ptr+6;
} else if ((ptr = strstr(input, "http://"))) {
proto = RTR_PROT_HTTP;
host = ptr+7;
} 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;
}
while (*host && iswhitechar (*host))
host++;
if (!(ptr = strchr (host, ':'))) {
ptr = host;
port = "80";
} else {
*ptr++ = '\0';
port = ptr;
}
if (!(file = strchr (ptr, '/'))) {
eprintf("Error: Missing '/'\n");
return;
}
*file++ = 0;
port = r_str_chop (port);
while (*file==' ') file++;
if (r_sandbox_enable (0)) {
eprintf ("sandbox: connect disabled\n");
return;
}
fd = r_socket_new (R_FALSE);
if (!fd) {
eprintf ("Error: Cannot create new socket\n");
return;
}
switch (proto) {
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);
for (;;) {
char *ptr, *str = r_line_readline ();
if (!str || !*str) break;
if (*str == 'q') break;
ptr = r_str_uri_encode (str);
if (ptr) str = ptr;
snprintf (uri, sizeof (uri), "http://%s:%s/%s%s",
host, port, file, str);
if (ptr == str) free (ptr);
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%s", res, (res[strlen (res)-1]=='\n')?"":"\n");
r_line_hist_add (str);
free (str);
}
}
r_socket_free (fd);
return;
}
snprintf (uri, sizeof (uri), "http://%s:%s/%s",
host, port, file);
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);
} else eprintf ("HTTP connection has failed\n");
// do not add connection. wtf
return;
}
break;
case RTR_PROT_RAP:
if (!r_socket_connect_tcp (fd, host, port, timeout)) { //TODO: Use rap.ssl
eprintf ("Error: Cannot connect to '%s' (%s)\n", host, port);
return;
}
eprintf ("Connected to %s at port %s\n", host, port);
/* 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);
r_mem_copyendian ((ut8 *)&i, (ut8*)buf+1, 4, core->assembler->big_endian);
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:
if (!r_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);
return;
}
core->num->value = 0;
eprintf ("Connected to: %s at port %s\n", host, port);
break;
case RTR_PROT_UDP:
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);
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) {
rtr_host[i].proto = proto;
memcpy (rtr_host[i].host, host, 512);
rtr_host[i].port = r_num_get (core->num, port);
memcpy (rtr_host[i].file, file, 1024);
rtr_host[i].fd = fd;
rtr_n = i;
break;
}
core->num->value = ret;
r_socket_free(fd);
//r_core_rtr_list (core);
}
