+static const char *
+rpc_file_exec_lookup(const char *cmd)
+{
+ struct stat s;
+ int plen = 0, clen = strlen(cmd) + 1;
+ char *search, *p;
+ static char path[PATH_MAX];
+
+ if (!stat(cmd, &s) && S_ISREG(s.st_mode))
+ return cmd;
+
+ search = getenv("PATH");
+
+ if (!search)
+ search = "/bin:/usr/bin:/sbin:/usr/sbin";
+
+ p = search;
+
+ do
+ {
+ if (*p != ':' && *p != '\0')
+ continue;
+
+ plen = p - search;
+
+ if ((plen + clen) >= sizeof(path))
+ continue;
+
+ strncpy(path, search, plen);
+ sprintf(path + plen, "/%s", cmd);
+
+ if (!stat(path, &s) && S_ISREG(s.st_mode))
+ return path;
+
+ search = p + 1;
+ }
+ while (*p++);
+
+ return NULL;
+}
+
+
+static void
+rpc_ustream_to_blobmsg(struct ustream *s, const char *name)
+{
+ int len;
+ char *rbuf, *wbuf;
+
+ if ((len = ustream_pending_data(s, false)) > 0)
+ {
+ wbuf = blobmsg_alloc_string_buffer(&buf, name, len + 1);
+
+ if (!wbuf)
+ return;
+
+ ustream_for_each_read_buffer(s, rbuf, len)
+ {
+ memcpy(wbuf, rbuf, len);
+ wbuf += len;
+ }
+
+ *wbuf = 0;
+ blobmsg_add_string_buffer(&buf);
+ }
+}
+
+static void
+rpc_file_exec_reply(struct rpc_file_exec_context *c, int rv)
+{
+ uloop_timeout_cancel(&c->timeout);
+ uloop_process_delete(&c->process);
+
+ if (rv == UBUS_STATUS_OK)
+ {
+ blob_buf_init(&buf, 0);
+
+ blobmsg_add_u32(&buf, "code", WEXITSTATUS(c->stat));
+
+ rpc_ustream_to_blobmsg(&c->opipe.stream, "stdout");
+ rpc_ustream_to_blobmsg(&c->epipe.stream, "stderr");
+
+ ubus_send_reply(c->context, &c->request, buf.head);
+ }
+
+ ubus_complete_deferred_request(c->context, &c->request, rv);
+
+ ustream_free(&c->opipe.stream);
+ ustream_free(&c->epipe.stream);
+
+ close(c->opipe.fd.fd);
+ close(c->epipe.fd.fd);
+
+ free(c);
+}
+
+static void
+rpc_file_exec_timeout_cb(struct uloop_timeout *t)
+{
+ struct rpc_file_exec_context *c =
+ container_of(t, struct rpc_file_exec_context, timeout);
+
+ kill(c->process.pid, SIGKILL);
+ rpc_file_exec_reply(c, UBUS_STATUS_TIMEOUT);
+}
+
+static void
+rpc_file_exec_process_cb(struct uloop_process *p, int stat)
+{
+ struct rpc_file_exec_context *c =
+ container_of(p, struct rpc_file_exec_context, process);
+
+ c->stat = stat;
+
+ ustream_poll(&c->opipe.stream);
+ ustream_poll(&c->epipe.stream);
+}
+
+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);
+
+ if (ustream_read_buf_full(s))
+ rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
+}
+
+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);
+
+ if (ustream_read_buf_full(s))
+ rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
+}
+
+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);
+
+ if (c->opipe.stream.eof && c->epipe.stream.eof)
+ rpc_file_exec_reply(c, UBUS_STATUS_OK);
+}
+
+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);
+
+ if (c->opipe.stream.eof && c->epipe.stream.eof)
+ rpc_file_exec_reply(c, UBUS_STATUS_OK);
+}
+
+static int
+rpc_file_exec_run(const char *cmd,
+ const struct blob_attr *arg, const struct blob_attr *env,
+ struct ubus_context *ctx, struct ubus_request_data *req)
+{
+ pid_t pid;
+
+ int opipe[2];
+ int epipe[2];
+
+ int rem;
+ struct blob_attr *cur;
+
+ char arglen;
+ char **args;
+
+ struct rpc_file_exec_context *c;
+
+ cmd = rpc_file_exec_lookup(cmd);
+
+ if (!cmd)
+ return UBUS_STATUS_NOT_FOUND;
+
+ c = malloc(sizeof(*c));
+
+ if (!c)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ if (pipe(opipe) || pipe(epipe))
+ return rpc_errno_status();
+
+ switch ((pid = fork()))
+ {
+ case -1:
+ return rpc_errno_status();
+
+ case 0:
+ uloop_done();
+
+ dup2(opipe[1], 1);
+ dup2(epipe[1], 2);
+
+ close(0);
+ close(opipe[0]);
+ close(opipe[1]);
+ close(epipe[0]);
+ close(epipe[1]);
+
+ arglen = 2;
+ args = malloc(sizeof(char *) * arglen);
+
+ if (!args)
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ args[0] = (char *)cmd;
+ args[1] = NULL;
+
+ if (arg)
+ {
+ blobmsg_for_each_attr(cur, arg, rem)
+ {
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
+ continue;
+
+ arglen++;
+
+ if (!(args = realloc(args, sizeof(char *) * arglen)))
+ return UBUS_STATUS_UNKNOWN_ERROR;
+
+ args[arglen-2] = blobmsg_data(cur);
+ args[arglen-1] = NULL;
+ }
+ }
+
+ if (env)
+ {
+ blobmsg_for_each_attr(cur, env, rem)
+ {
+ if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
+ continue;
+
+ setenv(blobmsg_name(cur), blobmsg_data(cur), 1);
+ }
+ }
+
+ if (execv(cmd, args))
+ return rpc_errno_status();
+
+ default:
+ memset(c, 0, sizeof(*c));
+
+ ustream_declare(c->opipe, opipe[0], exec_opipe);
+ ustream_declare(c->epipe, epipe[0], exec_epipe);
+
+ c->process.pid = pid;
+ c->process.cb = rpc_file_exec_process_cb;
+ uloop_process_add(&c->process);
+
+ c->timeout.cb = rpc_file_exec_timeout_cb;
+ uloop_timeout_set(&c->timeout, RPC_FILE_MAX_RUNTIME);
+
+ close(opipe[1]);
+ close(epipe[1]);
+
+ c->context = ctx;
+ ubus_defer_request(ctx, req, &c->request);
+ }
+
+ return UBUS_STATUS_OK;
+}
+
+static int
+rpc_file_exec(struct ubus_context *ctx, struct ubus_object *obj,
+ struct ubus_request_data *req, const char *method,
+ struct blob_attr *msg)
+{
+ struct blob_attr *tb[__RPC_E_MAX];
+
+ blobmsg_parse(rpc_exec_policy, __RPC_E_MAX, tb,
+ blob_data(msg), blob_len(msg));
+
+ if (!tb[RPC_E_CMD])
+ 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);
+}
+