session: handle NULL return values of crypt()

[project/rpcd.git] / file.c

diff --git a/file.c b/file.c
index d9835180529fd6065ec3ad5f9a2f3e9c6e6e8cd6..016f264033e6f1a8181c7d53db06b84277d5281b 100644 (file)
--- a/file.c
+++ b/file.c
@@ -2,6 +2,7 @@
  * 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
@@ -19,6 +20,7 @@
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 #include <limits.h>
@@ -38,7 +40,6 @@
 
 /* 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);     \
@@ -53,6 +54,8 @@
        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;
@@ -60,10 +63,6 @@ struct rpc_file_exec_context {
        struct uloop_process process;
        struct ustream_fd opipe;
        struct ustream_fd epipe;
-       int outlen;
-       char *out;
-       int errlen;
-       char *err;
        int stat;
 };
 
@@ -93,6 +92,7 @@ static const struct blobmsg_policy rpc_file_rb_policy[__RPC_F_RB_MAX] = {
 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,
@@ -101,6 +101,7 @@ enum {
 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   },
 };
@@ -265,10 +266,11 @@ rpc_file_write(struct ubus_context *ctx, struct ubus_object *obj,
                struct blob_attr *msg)
 {
        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;
-       size_t data_len = 0;
+       ssize_t data_len = 0;
 
        blobmsg_parse(rpc_file_rw_policy, __RPC_F_RW_MAX, tb,
                      blob_data(msg), blob_len(msg));
@@ -279,11 +281,14 @@ rpc_file_write(struct ubus_context *ctx, struct ubus_object *obj,
        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 | O_TRUNC, mode);
+       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();
@@ -318,7 +323,7 @@ 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;
@@ -585,6 +590,13 @@ rpc_file_exec_epipe_state_cb(struct ustream *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,
@@ -592,14 +604,15 @@ rpc_file_exec_run(const char *cmd,
 {
        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;
 
@@ -624,14 +637,20 @@ rpc_file_exec_run(const char *cmd,
        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);
@@ -649,11 +668,22 @@ rpc_file_exec_run(const char *cmd,
                                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;
                        }
@@ -684,7 +714,7 @@ rpc_file_exec_run(const char *cmd,
                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]);
@@ -736,6 +766,8 @@ rpc_file_api_init(const struct rpc_daemon_ops *o, struct ubus_context *ctx)
                .n_methods = ARRAY_SIZE(file_methods),
        };
 
+       ops = o;
+
        return ubus_add_object(ctx, &obj);
 }