X-Git-Url: http://git.archive.openwrt.org/?a=blobdiff_plain;f=file.c;h=a09e9de7a44e846c0e3d0bcabf89ba56ce7a1f92;hb=23417e94d25570e6d62542bac46edd51e8e0243a;hp=d4198460b8873bf6f3666d3dfabf118fbfb455bf;hpb=bea6a818756e6c2edbdddcedac26f8e1e29affde;p=project%2Frpcd.git diff --git a/file.c b/file.c index d419846..a09e9de 100644 --- a/file.c +++ b/file.c @@ -1,7 +1,8 @@ /* - * luci-rpcd - LuCI UBUS RPC server + * rpcd - UBUS RPC server * - * Copyright (C) 2013 Jo-Philipp Wich + * Copyright (C) 2013-2014 Jo-Philipp Wich + * Copyright (C) 2016 Luka Perkov * * Permission to use, copy, modify, and/or distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -25,35 +26,99 @@ #include #include #include +#include +#include +#include +#include +#include + +#include + +/* limit of sys & proc files */ +#define RPC_FILE_MIN_SIZE (128) + +/* 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); \ + ptr != NULL && len > 0; \ + ustream_consume(stream, len), ptr = ustream_get_read_buf(stream, &len)) + +#define ustream_declare(us, fd, name) \ + us.stream.string_data = true; \ + us.stream.r.buffer_len = 4096; \ + us.stream.r.max_buffers = RPC_FILE_MAX_SIZE / 4096; \ + us.stream.notify_read = rpc_file_##name##_read_cb; \ + us.stream.notify_state = rpc_file_##name##_state_cb; \ + ustream_fd_init(&us, fd); + +struct rpc_file_exec_context { + struct ubus_context *context; + struct ubus_request_data request; + struct uloop_timeout timeout; + struct uloop_process process; + struct ustream_fd opipe; + struct ustream_fd epipe; + int outlen; + char *out; + int errlen; + char *err; + int stat; +}; -#include "file.h" static struct blob_buf buf; enum { - RPC_F_PATH, - RPC_F_DATA, - __RPC_F_MAX, + RPC_F_R_PATH, + __RPC_F_R_MAX, }; -static const struct blobmsg_policy rpc_file_policy[__RPC_F_MAX] = { - [RPC_F_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING }, - [RPC_F_DATA] = { .name = "data", .type = BLOBMSG_TYPE_STRING }, +static const struct blobmsg_policy rpc_file_r_policy[__RPC_F_R_MAX] = { + [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_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 { RPC_E_CMD, RPC_E_PARM, RPC_E_ENV, - RPC_E_MODE, __RPC_E_MAX, }; static const struct blobmsg_policy rpc_exec_policy[__RPC_E_MAX] = { - [RPC_E_CMD] = { .name = "command", .type = BLOBMSG_TYPE_STRING }, + [RPC_E_CMD] = { .name = "command", .type = BLOBMSG_TYPE_STRING }, [RPC_E_PARM] = { .name = "params", .type = BLOBMSG_TYPE_ARRAY }, [RPC_E_ENV] = { .name = "env", .type = BLOBMSG_TYPE_TABLE }, - [RPC_E_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_STRING }, }; static const char *d_types[] = { @@ -93,17 +158,17 @@ rpc_errno_status(void) static struct blob_attr ** rpc_check_path(struct blob_attr *msg, char **path, struct stat *s) { - static struct blob_attr *tb[__RPC_F_MAX]; + static struct blob_attr *tb[__RPC_F_R_MAX]; - blobmsg_parse(rpc_file_policy, __RPC_F_MAX, tb, blob_data(msg), blob_len(msg)); + blobmsg_parse(rpc_file_r_policy, __RPC_F_R_MAX, tb, blob_data(msg), blob_len(msg)); - if (!tb[RPC_F_PATH]) + if (!tb[RPC_F_R_PATH]) { errno = EINVAL; return NULL; } - *path = blobmsg_data(tb[RPC_F_PATH]); + *path = blobmsg_data(tb[RPC_F_R_PATH]); if (stat(*path, s)) return NULL; @@ -116,12 +181,22 @@ rpc_file_read(struct ubus_context *ctx, struct ubus_object *obj, 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) @@ -136,7 +211,13 @@ rpc_file_read(struct ubus_context *ctx, struct ubus_object *obj, 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) { @@ -150,13 +231,33 @@ rpc_file_read(struct ubus_context *ctx, struct ubus_object *obj, 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); rv = UBUS_STATUS_OK; out: + blob_buf_free(&buf); close(fd); return rv; } @@ -166,24 +267,91 @@ rpc_file_write(struct ubus_context *ctx, struct ubus_object *obj, 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; + + 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 (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) + rv = -1; + + close(fd); + sync(); + + if (rv) + return rpc_errno_status(); + + return 0; +} + +static int +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; - struct blob_attr **tb; + uint8_t md5[16]; + char *wbuf; - if (!(tb = rpc_check_path(msg, &path, &s))) + if (!rpc_check_path(msg, &path, &s)) return rpc_errno_status(); - if (!tb[RPC_F_DATA]) - return UBUS_STATUS_INVALID_ARGUMENT; + if (!S_ISREG(s.st_mode)) + return UBUS_STATUS_NOT_SUPPORTED; - if ((fd = open(path, O_WRONLY)) < 0) + if ((rv = md5sum(path, md5)) <= 0) return rpc_errno_status(); - write(fd, blobmsg_data(tb[RPC_F_DATA]), blobmsg_data_len(tb[RPC_F_DATA])); - close(fd); + blob_buf_init(&buf, 0); + wbuf = blobmsg_alloc_string_buffer(&buf, "md5", 33); - return 0; + for (i = 0; i < 16; i++) + sprintf(wbuf + (i * 2), "%02x", (uint8_t) md5[i]); + + blobmsg_add_string_buffer(&buf); + ubus_send_reply(ctx, req, buf.head); + blob_buf_free(&buf); + + return UBUS_STATUS_OK; } static int @@ -217,8 +385,11 @@ rpc_file_list(struct ubus_context *ctx, struct ubus_object *obj, blobmsg_close_table(&buf, d); } + closedir(fd); + blobmsg_close_array(&buf, c); ubus_send_reply(ctx, req, buf.head); + blob_buf_free(&buf); return 0; } @@ -258,6 +429,7 @@ rpc_file_stat(struct ubus_context *ctx, struct ubus_object *obj, blobmsg_add_u32(&buf, "gid", s.st_gid); ubus_send_reply(ctx, req, buf.head); + blob_buf_free(&buf); return 0; } @@ -344,6 +516,7 @@ rpc_file_exec_reply(struct rpc_file_exec_context *c, int rv) rpc_ustream_to_blobmsg(&c->epipe.stream, "stderr"); ubus_send_reply(c->context, &c->request, buf.head); + blob_buf_free(&buf); } ubus_complete_deferred_request(c->context, &c->request, rv); @@ -383,7 +556,7 @@ static void rpc_file_exec_opipe_read_cb(struct ustream *s, int bytes) { struct rpc_file_exec_context *c = - container_of(s, struct rpc_file_exec_context, opipe); + container_of(s, struct rpc_file_exec_context, opipe.stream); if (ustream_read_buf_full(s)) rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED); @@ -393,7 +566,7 @@ static void rpc_file_exec_epipe_read_cb(struct ustream *s, int bytes) { struct rpc_file_exec_context *c = - container_of(s, struct rpc_file_exec_context, epipe); + container_of(s, struct rpc_file_exec_context, epipe.stream); if (ustream_read_buf_full(s)) rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED); @@ -403,7 +576,7 @@ static void rpc_file_exec_opipe_state_cb(struct ustream *s) { struct rpc_file_exec_context *c = - container_of(s, struct rpc_file_exec_context, opipe); + container_of(s, struct rpc_file_exec_context, opipe.stream); if (c->opipe.stream.eof && c->epipe.stream.eof) rpc_file_exec_reply(c, UBUS_STATUS_OK); @@ -413,7 +586,7 @@ static void rpc_file_exec_epipe_state_cb(struct ustream *s) { struct rpc_file_exec_context *c = - container_of(s, struct rpc_file_exec_context, epipe); + container_of(s, struct rpc_file_exec_context, epipe.stream); if (c->opipe.stream.eof && c->epipe.stream.eof) rpc_file_exec_reply(c, UBUS_STATUS_OK); @@ -421,7 +594,7 @@ rpc_file_exec_epipe_state_cb(struct ustream *s) static int rpc_file_exec_run(const char *cmd, - const struct blob_attr *arg, const struct blob_attr *env, + const struct blob_attr *arg, const struct blob_attr *env, struct ubus_context *ctx, struct ubus_request_data *req) { pid_t pid; @@ -544,17 +717,19 @@ rpc_file_exec(struct ubus_context *ctx, struct ubus_object *obj, return UBUS_STATUS_INVALID_ARGUMENT; return rpc_file_exec_run(blobmsg_data(tb[RPC_E_CMD]), - tb[RPC_E_PARM], tb[RPC_E_ENV], ctx, req); + tb[RPC_E_PARM], tb[RPC_E_ENV], ctx, req); } -int rpc_file_api_init(struct ubus_context *ctx) +static int +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_policy), - UBUS_METHOD("write", rpc_file_write, rpc_file_policy), - UBUS_METHOD("list", rpc_file_list, rpc_file_policy), - UBUS_METHOD("stat", rpc_file_stat, rpc_file_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), + UBUS_METHOD("md5", rpc_file_md5, rpc_file_r_policy), UBUS_METHOD("exec", rpc_file_exec, rpc_exec_policy), }; @@ -570,3 +745,7 @@ int rpc_file_api_init(struct ubus_context *ctx) return ubus_add_object(ctx, &obj); } + +struct rpc_plugin rpc_plugin = { + .init = rpc_file_api_init +};