* rpcd - UBUS RPC server
*
* Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
+ * Copyright (C) 2016 Luka Perkov <luka@openwrt.org>
*
* Permission to use, copy, modify, and/or distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include <fcntl.h>
#include <errno.h>
#include <unistd.h>
+#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <libubox/blobmsg.h>
#include <libubox/md5.h>
#include <libubox/ustream.h>
+#include <libubox/utils.h>
#include <rpcd/plugin.h>
/* limit of regular files and command output data */
#define RPC_FILE_MAX_SIZE (4096 * 64)
-#define RPC_FILE_MAX_RUNTIME (3 * 1000)
#define ustream_for_each_read_buffer(stream, ptr, len) \
for (ptr = ustream_get_read_buf(stream, &len); \
us.stream.notify_state = rpc_file_##name##_state_cb; \
ustream_fd_init(&us, fd);
+static const struct rpc_daemon_ops *ops;
+
struct rpc_file_exec_context {
struct ubus_context *context;
struct ubus_request_data request;
struct uloop_process process;
struct ustream_fd opipe;
struct ustream_fd epipe;
- int outlen;
- char *out;
- int errlen;
- char *err;
int stat;
};
[RPC_F_R_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
};
+enum {
+ RPC_F_RB_PATH,
+ RPC_F_RB_BASE64,
+ __RPC_F_RB_MAX,
+};
+
+static const struct blobmsg_policy rpc_file_rb_policy[__RPC_F_RB_MAX] = {
+ [RPC_F_RB_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
+ [RPC_F_RB_BASE64] = { .name = "base64", .type = BLOBMSG_TYPE_BOOL },
+};
+
enum {
RPC_F_RW_PATH,
RPC_F_RW_DATA,
+ RPC_F_RW_APPEND,
+ RPC_F_RW_MODE,
+ RPC_F_RW_BASE64,
__RPC_F_RW_MAX,
};
static const struct blobmsg_policy rpc_file_rw_policy[__RPC_F_RW_MAX] = {
- [RPC_F_RW_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
- [RPC_F_RW_DATA] = { .name = "data", .type = BLOBMSG_TYPE_STRING },
+ [RPC_F_RW_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
+ [RPC_F_RW_DATA] = { .name = "data", .type = BLOBMSG_TYPE_STRING },
+ [RPC_F_RW_APPEND] = { .name = "append", .type = BLOBMSG_TYPE_BOOL },
+ [RPC_F_RW_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_INT32 },
+ [RPC_F_RW_BASE64] = { .name = "base64", .type = BLOBMSG_TYPE_BOOL },
};
enum {
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
- int fd, rv, len;
+ static struct blob_attr *tb[__RPC_F_RB_MAX];
+ bool base64 = false;
+ int fd, rv;
+ ssize_t len;
char *path;
struct stat s;
char *wbuf;
- if (!rpc_check_path(msg, &path, &s))
+ blobmsg_parse(rpc_file_rb_policy, __RPC_F_RB_MAX, tb, blob_data(msg), blob_len(msg));
+
+ if (!tb[RPC_F_RB_PATH])
+ return rpc_errno_status();
+
+ path = blobmsg_data(tb[RPC_F_RB_PATH]);
+
+ if (stat(path, &s))
return rpc_errno_status();
if (s.st_size >= RPC_FILE_MAX_SIZE)
blob_buf_init(&buf, 0);
- wbuf = blobmsg_alloc_string_buffer(&buf, "data", s.st_size + 1);
+ if (tb[RPC_F_RB_BASE64])
+ base64 = blobmsg_get_bool(tb[RPC_F_RB_BASE64]);
+
+ len = s.st_size + 1;
+ if (base64)
+ len = B64_ENCODE_LEN(s.st_size);
+ wbuf = blobmsg_alloc_string_buffer(&buf, "data", len);
if (!wbuf)
{
goto out;
}
- *(wbuf + len) = 0;
+ if (base64)
+ {
+ uint8_t *data = calloc(len, sizeof(uint8_t));
+ if (!data)
+ {
+ rv = UBUS_STATUS_UNKNOWN_ERROR;
+ goto out;
+ }
+ memcpy(data, wbuf, len);
+
+ len = b64_encode(data, len, wbuf, B64_ENCODE_LEN(len));
+ free(data);
+ if (len < 0)
+ {
+ rv = UBUS_STATUS_UNKNOWN_ERROR;
+ goto out;
+ }
+ }
+
+ *(wbuf + len) = '\0';
blobmsg_add_string_buffer(&buf);
ubus_send_reply(ctx, req, buf.head);
- blob_buf_free(&buf);
rv = UBUS_STATUS_OK;
out:
+ blob_buf_free(&buf);
close(fd);
return rv;
}
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
{
- int fd;
struct blob_attr *tb[__RPC_F_RW_MAX];
+ int append = O_TRUNC;
+ mode_t prev_mode, mode = 0666;
+ int fd, rv = 0;
+ void *data = NULL;
+ ssize_t data_len = 0;
blobmsg_parse(rpc_file_rw_policy, __RPC_F_RW_MAX, tb,
blob_data(msg), blob_len(msg));
if (!tb[RPC_F_RW_PATH] || !tb[RPC_F_RW_DATA])
return UBUS_STATUS_INVALID_ARGUMENT;
- if ((fd = open(blobmsg_data(tb[RPC_F_RW_PATH]), O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
- return rpc_errno_status();
+ data = blobmsg_data(tb[RPC_F_RW_DATA]);
+ data_len = blobmsg_data_len(tb[RPC_F_RW_DATA]) - 1;
+
+ if (tb[RPC_F_RW_APPEND] && blobmsg_get_bool(tb[RPC_F_RW_APPEND]))
+ append = O_APPEND;
- if (write(fd, blobmsg_data(tb[RPC_F_RW_DATA]), blobmsg_data_len(tb[RPC_F_RW_DATA])) < 0)
+ if (tb[RPC_F_RW_MODE])
+ mode = blobmsg_get_u32(tb[RPC_F_RW_MODE]);
+
+ prev_mode = umask(0);
+ fd = open(blobmsg_data(tb[RPC_F_RW_PATH]), O_CREAT | O_WRONLY | append, mode);
+ umask(prev_mode);
+ if (fd < 0)
return rpc_errno_status();
+ if (tb[RPC_F_RW_BASE64] && blobmsg_get_bool(tb[RPC_F_RW_BASE64]))
+ {
+ data_len = b64_decode(data, data, data_len);
+ if (data_len < 0)
+ {
+ rv = UBUS_STATUS_UNKNOWN_ERROR;
+ goto out;
+ }
+ }
+
+ if (write(fd, data, data_len) < 0)
+ rv = -1;
+
+out:
if (fsync(fd) < 0)
- return rpc_errno_status();
+ rv = -1;
close(fd);
sync();
+ if (rv)
+ return rpc_errno_status();
+
return 0;
}
rpc_file_md5(struct ubus_context *ctx, struct ubus_object *obj,
struct ubus_request_data *req, const char *method,
struct blob_attr *msg)
-{
+{
int rv, i;
char *path;
struct stat s;
rpc_file_exec_reply(c, UBUS_STATUS_OK);
}
+static void
+rpc_fdclose(int fd)
+{
+ if (fd > 2)
+ close(fd);
+}
+
static int
rpc_file_exec_run(const char *cmd,
const struct blob_attr *arg, const struct blob_attr *env,
{
pid_t pid;
+ int devnull;
int opipe[2];
int epipe[2];
int rem;
struct blob_attr *cur;
- char arglen;
- char **args;
+ uint8_t arglen;
+ char **args, **tmp;
struct rpc_file_exec_context *c;
case 0:
uloop_done();
+ devnull = open("/dev/null", O_RDWR);
+
+ if (devnull == -1)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ dup2(devnull, 0);
dup2(opipe[1], 1);
dup2(epipe[1], 2);
- close(0);
- close(opipe[0]);
- close(opipe[1]);
- close(epipe[0]);
- close(epipe[1]);
+ rpc_fdclose(devnull);
+ rpc_fdclose(opipe[0]);
+ rpc_fdclose(opipe[1]);
+ rpc_fdclose(epipe[0]);
+ rpc_fdclose(epipe[1]);
arglen = 2;
args = malloc(sizeof(char *) * arglen);
if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
continue;
+ if (arglen == 255)
+ {
+ free(args);
+ return UBUS_STATUS_INVALID_ARGUMENT;
+ }
+
arglen++;
+ tmp = realloc(args, sizeof(char *) * arglen);
- if (!(args = realloc(args, sizeof(char *) * arglen)))
+ if (!tmp)
+ {
+ free(args);
return UBUS_STATUS_UNKNOWN_ERROR;
+ }
+ args = tmp;
args[arglen-2] = blobmsg_data(cur);
args[arglen-1] = NULL;
}
uloop_process_add(&c->process);
c->timeout.cb = rpc_file_exec_timeout_cb;
- uloop_timeout_set(&c->timeout, RPC_FILE_MAX_RUNTIME);
+ uloop_timeout_set(&c->timeout, *ops->exec_timeout);
close(opipe[1]);
close(epipe[1]);
rpc_file_api_init(const struct rpc_daemon_ops *o, struct ubus_context *ctx)
{
static const struct ubus_method file_methods[] = {
- UBUS_METHOD("read", rpc_file_read, rpc_file_r_policy),
+ UBUS_METHOD("read", rpc_file_read, rpc_file_rb_policy),
UBUS_METHOD("write", rpc_file_write, rpc_file_rw_policy),
UBUS_METHOD("list", rpc_file_list, rpc_file_r_policy),
UBUS_METHOD("stat", rpc_file_stat, rpc_file_r_policy),
.n_methods = ARRAY_SIZE(file_methods),
};
+ ops = o;
+
return ubus_add_object(ctx, &obj);
}
projects / project / rpcd.git / blobdiff