projects / project / rpcd.git / blob
? search:


4ed2e5cae2a5bb277a55dd371c17535caf76e6f1
[project/rpcd.git] / file.c
1 /*
2 * rpcd - UBUS RPC server
3 *
4 * Copyright (C) 2013-2014 Jo-Philipp Wich <jow@openwrt.org>
5 * Copyright (C) 2016 Luka Perkov <luka@openwrt.org>
6 *
7 * Permission to use, copy, modify, and/or distribute this software for any
8 * purpose with or without fee is hereby granted, provided that the above
9 * copyright notice and this permission notice appear in all copies.
10 *
11 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
12 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
13 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
14 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
15 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
16 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
17 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
18 */
19
20 #define _GNU_SOURCE
21
22 #include <fcntl.h>
23 #include <errno.h>
24 #include <unistd.h>
25 #include <stdint.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <limits.h>
29 #include <dirent.h>
30 #include <sys/stat.h>
31 #include <sys/wait.h>
32 #include <libubus.h>
33 #include <libubox/blobmsg.h>
34 #include <libubox/md5.h>
35 #include <libubox/ustream.h>
36 #include <libubox/utils.h>
37
38 #include <rpcd/plugin.h>
39
40 /* limit of sys & proc files */
41 #define RPC_FILE_MIN_SIZE (4096)
42
43 /* limit of regular files and command output data */
44 #define RPC_FILE_MAX_SIZE (4096 * 64)
45
46 #define ustream_for_each_read_buffer(stream, ptr, len) \
47 for (ptr = ustream_get_read_buf(stream, &len); \
48 ptr != NULL && len > 0; \
49 ustream_consume(stream, len), ptr = ustream_get_read_buf(stream, &len))
50
51 #define ustream_declare(us, fd, name) \
52 us.stream.string_data = true; \
53 us.stream.r.buffer_len = 4096; \
54 us.stream.r.max_buffers = RPC_FILE_MAX_SIZE / 4096; \
55 us.stream.notify_read = rpc_file_##name##_read_cb; \
56 us.stream.notify_state = rpc_file_##name##_state_cb; \
57 ustream_fd_init(&us, fd);
58
59 static const struct rpc_daemon_ops *ops;
60
61 struct rpc_file_exec_context {
62 struct ubus_context *context;
63 struct ubus_request_data request;
64 struct uloop_timeout timeout;
65 struct uloop_process process;
66 struct ustream_fd opipe;
67 struct ustream_fd epipe;
68 int stat;
69 };
70
71
72 static struct blob_buf buf;
73 static char *canonpath;
74
75 enum {
76 RPC_F_R_PATH,
77 RPC_F_R_SESSION,
78 __RPC_F_R_MAX,
79 };
80
81 static const struct blobmsg_policy rpc_file_R_policy[__RPC_F_R_MAX] = {
82 [RPC_F_R_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
83 [RPC_F_R_SESSION] = { .name = "ubus_rpc_session",
84 .type = BLOBMSG_TYPE_STRING },
85 };
86
87 enum {
88 RPC_F_RB_PATH,
89 RPC_F_RB_BASE64,
90 RPC_F_RB_SESSION,
91 __RPC_F_RB_MAX,
92 };
93
94 static const struct blobmsg_policy rpc_file_RB_policy[__RPC_F_RB_MAX] = {
95 [RPC_F_RB_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
96 [RPC_F_RB_BASE64] = { .name = "base64", .type = BLOBMSG_TYPE_BOOL },
97 [RPC_F_RB_SESSION] = { .name = "ubus_rpc_session",
98 .type = BLOBMSG_TYPE_STRING },
99 };
100
101 enum {
102 RPC_F_RW_PATH,
103 RPC_F_RW_DATA,
104 RPC_F_RW_APPEND,
105 RPC_F_RW_MODE,
106 RPC_F_RW_BASE64,
107 RPC_F_RW_SESSION,
108 __RPC_F_RW_MAX,
109 };
110
111 static const struct blobmsg_policy rpc_file_RW_policy[__RPC_F_RW_MAX] = {
112 [RPC_F_RW_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
113 [RPC_F_RW_DATA] = { .name = "data", .type = BLOBMSG_TYPE_STRING },
114 [RPC_F_RW_APPEND] = { .name = "append", .type = BLOBMSG_TYPE_BOOL },
115 [RPC_F_RW_MODE] = { .name = "mode", .type = BLOBMSG_TYPE_INT32 },
116 [RPC_F_RW_BASE64] = { .name = "base64", .type = BLOBMSG_TYPE_BOOL },
117 [RPC_F_RW_SESSION] = { .name = "ubus_rpc_session",
118 .type = BLOBMSG_TYPE_STRING },
119 };
120
121 enum {
122 RPC_E_CMD,
123 RPC_E_PARM,
124 RPC_E_ENV,
125 RPC_E_SESSION,
126 __RPC_E_MAX,
127 };
128
129 static const struct blobmsg_policy rpc_exec_policy[__RPC_E_MAX] = {
130 [RPC_E_CMD] = { .name = "command", .type = BLOBMSG_TYPE_STRING },
131 [RPC_E_PARM] = { .name = "params", .type = BLOBMSG_TYPE_ARRAY },
132 [RPC_E_ENV] = { .name = "env", .type = BLOBMSG_TYPE_TABLE },
133 [RPC_E_SESSION] = { .name = "ubus_rpc_session",
134 .type = BLOBMSG_TYPE_STRING },
135 };
136
137 static const char *d_types[] = {
138 [DT_BLK] = "block",
139 [DT_CHR] = "char",
140 [DT_DIR] = "directory",
141 [DT_FIFO] = "fifo",
142 [DT_LNK] = "symlink",
143 [DT_REG] = "file",
144 [DT_SOCK] = "socket",
145 [DT_UNKNOWN] = "unknown",
146 };
147
148
149 static int
150 rpc_errno_status(void)
151 {
152 switch (errno)
153 {
154 case EACCES:
155 return UBUS_STATUS_PERMISSION_DENIED;
156
157 case ENOTDIR:
158 return UBUS_STATUS_INVALID_ARGUMENT;
159
160 case ENOENT:
161 return UBUS_STATUS_NOT_FOUND;
162
163 case EINVAL:
164 return UBUS_STATUS_INVALID_ARGUMENT;
165
166 default:
167 return UBUS_STATUS_UNKNOWN_ERROR;
168 }
169 }
170
171 static bool
172 rpc_file_access(const struct blob_attr *sid,
173 const char *path, const char *perm)
174 {
175 if (!sid)
176 return true;
177
178 return ops->session_access(blobmsg_data(sid), "file", path, perm);
179 }
180
181 static char *
182 rpc_canonicalize_path(const char *path)
183 {
184 char *cp;
185 const char *p;
186
187 if (path == NULL || *path == '\0')
188 return NULL;
189
190 if (canonpath != NULL)
191 free(canonpath);
192
193 canonpath = strdup(path);
194
195 if (canonpath == NULL)
196 return NULL;
197
198 /* normalize */
199 for (cp = canonpath, p = path; *p != '\0'; ) {
200 if (*p != '/')
201 goto next;
202
203 /* skip repeating / */
204 if (p[1] == '/') {
205 p++;
206 continue;
207 }
208
209 /* /./ or /../ */
210 if (p[1] == '.') {
211 /* skip /./ */
212 if ((p[2] == '\0') || (p[2] == '/')) {
213 p += 2;
214 continue;
215 }
216
217 /* collapse /x/../ */
218 if ((p[2] == '.') && ((p[3] == '\0') || (p[3] == '/'))) {
219 while ((cp > canonpath) && (*--cp != '/'))
220 ;
221
222 p += 3;
223 continue;
224 }
225 }
226
227 next:
228 *cp++ = *p++;
229 }
230
231 /* remove trailing slash if not root / */
232 if ((cp > canonpath + 1) && (cp[-1] == '/'))
233 cp--;
234 else if (cp == canonpath)
235 *cp++ = '/';
236
237 *cp = '\0';
238
239 return canonpath;
240 }
241
242 static struct blob_attr **
243 __rpc_check_path(const struct blobmsg_policy *policy, size_t policy_len,
244 int policy_path_idx, int policy_sid_idx, const char *perm,
245 struct blob_attr *msg, char **path, struct stat *s)
246 {
247 static struct blob_attr *tb[__RPC_F_RW_MAX]; /* largest _MAX constant */
248
249 blobmsg_parse(policy, policy_len, tb, blob_data(msg), blob_len(msg));
250
251 if (!tb[policy_path_idx])
252 {
253 errno = EINVAL;
254 return NULL;
255 }
256
257 *path = rpc_canonicalize_path(blobmsg_get_string(tb[policy_path_idx]));
258
259 if (*path == NULL)
260 {
261 errno = ENOMEM;
262 return NULL;
263 }
264
265 if (!rpc_file_access(tb[policy_sid_idx], *path, perm))
266 {
267 errno = EACCES;
268 return NULL;
269 }
270
271 if (s != NULL && stat(*path, s) != 0)
272 return NULL;
273
274 return tb;
275 }
276
277 #define rpc_check_path(msg, policy_selector, perm, path, s) \
278 __rpc_check_path(rpc_file_ ## policy_selector ## _policy, \
279 ARRAY_SIZE(rpc_file_ ## policy_selector ## _policy), \
280 RPC_F_ ## policy_selector ## _PATH, \
281 RPC_F_ ## policy_selector ## _SESSION, \
282 perm, msg, path, s)
283
284 static int
285 rpc_file_read(struct ubus_context *ctx, struct ubus_object *obj,
286 struct ubus_request_data *req, const char *method,
287 struct blob_attr *msg)
288 {
289 struct blob_attr **tb;
290 bool base64 = false;
291 int fd, rv;
292 ssize_t len;
293 char *path;
294 struct stat s;
295 char *wbuf;
296
297 tb = rpc_check_path(msg, RB, "read", &path, &s);
298
299 if (tb == NULL)
300 return rpc_errno_status();
301
302 if (s.st_size >= RPC_FILE_MAX_SIZE)
303 return UBUS_STATUS_NOT_SUPPORTED;
304
305 if ((fd = open(path, O_RDONLY)) < 0)
306 return rpc_errno_status();
307
308 /* some sysfs files do not report a length */
309 if (s.st_size == 0)
310 s.st_size = RPC_FILE_MIN_SIZE;
311
312 blob_buf_init(&buf, 0);
313
314 if (tb[RPC_F_RB_BASE64])
315 base64 = blobmsg_get_bool(tb[RPC_F_RB_BASE64]);
316
317 len = s.st_size + 1;
318 if (base64)
319 len = B64_ENCODE_LEN(s.st_size);
320 wbuf = blobmsg_alloc_string_buffer(&buf, "data", len);
321
322 if (!wbuf)
323 {
324 rv = UBUS_STATUS_UNKNOWN_ERROR;
325 goto out;
326 }
327
328 if ((len = read(fd, wbuf, s.st_size)) <= 0)
329 {
330 rv = UBUS_STATUS_NO_DATA;
331 goto out;
332 }
333
334 if (base64)
335 {
336 uint8_t *data = calloc(len, sizeof(uint8_t));
337 if (!data)
338 {
339 rv = UBUS_STATUS_UNKNOWN_ERROR;
340 goto out;
341 }
342 memcpy(data, wbuf, len);
343
344 len = b64_encode(data, len, wbuf, B64_ENCODE_LEN(len));
345 free(data);
346 if (len < 0)
347 {
348 rv = UBUS_STATUS_UNKNOWN_ERROR;
349 goto out;
350 }
351 }
352
353 *(wbuf + len) = '\0';
354 blobmsg_add_string_buffer(&buf);
355
356 ubus_send_reply(ctx, req, buf.head);
357 rv = UBUS_STATUS_OK;
358
359 out:
360 blob_buf_free(&buf);
361 close(fd);
362 return rv;
363 }
364
365 static int
366 rpc_file_write(struct ubus_context *ctx, struct ubus_object *obj,
367 struct ubus_request_data *req, const char *method,
368 struct blob_attr *msg)
369 {
370 struct blob_attr **tb;
371 int append = O_TRUNC;
372 mode_t prev_mode, mode = 0666;
373 int fd, rv = 0;
374 char *path = NULL;
375 void *data = NULL;
376 ssize_t data_len = 0;
377
378 tb = rpc_check_path(msg, RW, "write", &path, NULL);
379
380 if (tb == NULL)
381 return rpc_errno_status();
382
383 if (!tb[RPC_F_RW_DATA])
384 return UBUS_STATUS_INVALID_ARGUMENT;
385
386 data = blobmsg_data(tb[RPC_F_RW_DATA]);
387 data_len = blobmsg_data_len(tb[RPC_F_RW_DATA]) - 1;
388
389 if (tb[RPC_F_RW_APPEND] && blobmsg_get_bool(tb[RPC_F_RW_APPEND]))
390 append = O_APPEND;
391
392 if (tb[RPC_F_RW_MODE])
393 mode = blobmsg_get_u32(tb[RPC_F_RW_MODE]);
394
395 prev_mode = umask(0);
396 fd = open(path, O_CREAT | O_WRONLY | append, mode);
397 umask(prev_mode);
398 if (fd < 0)
399 return rpc_errno_status();
400
401 if (tb[RPC_F_RW_BASE64] && blobmsg_get_bool(tb[RPC_F_RW_BASE64]))
402 {
403 data_len = b64_decode(data, data, data_len);
404 if (data_len < 0)
405 {
406 rv = UBUS_STATUS_UNKNOWN_ERROR;
407 goto out;
408 }
409 }
410
411 if (write(fd, data, data_len) < 0)
412 rv = -1;
413
414 out:
415 if (fsync(fd) < 0)
416 rv = -1;
417
418 close(fd);
419 sync();
420
421 if (rv)
422 return rpc_errno_status();
423
424 return 0;
425 }
426
427 static int
428 rpc_file_md5(struct ubus_context *ctx, struct ubus_object *obj,
429 struct ubus_request_data *req, const char *method,
430 struct blob_attr *msg)
431 {
432 int rv, i;
433 char *path;
434 struct stat s;
435 uint8_t md5[16];
436 char *wbuf;
437
438 if (!rpc_check_path(msg, R, "read", &path, &s))
439 return rpc_errno_status();
440
441 if (!S_ISREG(s.st_mode))
442 return UBUS_STATUS_NOT_SUPPORTED;
443
444 if ((rv = md5sum(path, md5)) <= 0)
445 return rpc_errno_status();
446
447 blob_buf_init(&buf, 0);
448 wbuf = blobmsg_alloc_string_buffer(&buf, "md5", 33);
449
450 for (i = 0; i < 16; i++)
451 sprintf(wbuf + (i * 2), "%02x", (uint8_t) md5[i]);
452
453 blobmsg_add_string_buffer(&buf);
454 ubus_send_reply(ctx, req, buf.head);
455 blob_buf_free(&buf);
456
457 return UBUS_STATUS_OK;
458 }
459
460 static void
461 _rpc_file_add_stat(struct stat *s)
462 {
463 int type;
464
465 type = S_ISREG(s->st_mode) ? DT_REG :
466 S_ISDIR(s->st_mode) ? DT_DIR :
467 S_ISCHR(s->st_mode) ? DT_CHR :
468 S_ISBLK(s->st_mode) ? DT_BLK :
469 S_ISFIFO(s->st_mode) ? DT_FIFO :
470 S_ISLNK(s->st_mode) ? DT_LNK :
471 S_ISSOCK(s->st_mode) ? DT_SOCK :
472 DT_UNKNOWN;
473
474 blobmsg_add_string(&buf, "type", d_types[type]);
475 blobmsg_add_u32(&buf, "size", s->st_size);
476 blobmsg_add_u32(&buf, "mode", s->st_mode);
477 blobmsg_add_u32(&buf, "atime", s->st_atime);
478 blobmsg_add_u32(&buf, "mtime", s->st_mtime);
479 blobmsg_add_u32(&buf, "ctime", s->st_ctime);
480 blobmsg_add_u32(&buf, "inode", s->st_ino);
481 blobmsg_add_u32(&buf, "uid", s->st_uid);
482 blobmsg_add_u32(&buf, "gid", s->st_gid);
483 }
484
485 static int
486 rpc_file_list(struct ubus_context *ctx, struct ubus_object *obj,
487 struct ubus_request_data *req, const char *method,
488 struct blob_attr *msg)
489 {
490 DIR *fd;
491 void *c, *d;
492 struct stat s;
493 struct dirent *e;
494 char *path, *entrypath;
495
496 if (!rpc_check_path(msg, R, "list", &path, NULL))
497 return rpc_errno_status();
498
499 if ((fd = opendir(path)) == NULL)
500 return rpc_errno_status();
501
502 blob_buf_init(&buf, 0);
503 c = blobmsg_open_array(&buf, "entries");
504
505 while ((e = readdir(fd)) != NULL)
506 {
507 if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, ".."))
508 continue;
509
510 if (asprintf(&entrypath, "%s/%s", path, e->d_name) < 0)
511 continue;
512
513 if (!stat(entrypath, &s))
514 {
515 d = blobmsg_open_table(&buf, NULL);
516 blobmsg_add_string(&buf, "name", e->d_name);
517 _rpc_file_add_stat(&s);
518 blobmsg_close_table(&buf, d);
519 }
520
521 free(entrypath);
522 }
523
524 closedir(fd);
525
526 blobmsg_close_array(&buf, c);
527 ubus_send_reply(ctx, req, buf.head);
528 blob_buf_free(&buf);
529
530 return 0;
531 }
532
533 static int
534 rpc_file_stat(struct ubus_context *ctx, struct ubus_object *obj,
535 struct ubus_request_data *req, const char *method,
536 struct blob_attr *msg)
537 {
538 char *path;
539 struct stat s;
540
541 if (!rpc_check_path(msg, R, "list", &path, &s))
542 return rpc_errno_status();
543
544 blob_buf_init(&buf, 0);
545
546 blobmsg_add_string(&buf, "path", path);
547 _rpc_file_add_stat(&s);
548
549 ubus_send_reply(ctx, req, buf.head);
550 blob_buf_free(&buf);
551
552 return 0;
553 }
554
555 static int
556 rpc_file_remove_recursive(const char *path);
557
558 static int
559 rpc_file_remove_recursive(const char *path)
560 {
561 DIR *fd;
562 int err = 0;
563 struct stat s;
564 struct dirent *e;
565 char *entrypath;
566
567 if ((fd = opendir(path)) == NULL)
568 return rpc_errno_status();
569
570 for (e = readdir(fd); e != NULL && err == 0; e = readdir(fd))
571 {
572 if (!strcmp(e->d_name, ".") || !strcmp(e->d_name, ".."))
573 continue;
574
575 if (asprintf(&entrypath, "%s/%s", path, e->d_name) >= 0)
576 {
577 if (!lstat(entrypath, &s))
578 {
579 if (S_ISDIR(s.st_mode))
580 err = rpc_file_remove_recursive(entrypath);
581 else if (unlink(entrypath))
582 err = rpc_errno_status();
583 }
584
585 free(entrypath);
586 }
587 else
588 {
589 err = UBUS_STATUS_UNKNOWN_ERROR;
590 }
591 }
592
593 closedir(fd);
594
595 if (!err && rmdir(path))
596 return rpc_errno_status();
597
598 return err;
599 }
600
601 static int
602 rpc_file_remove(struct ubus_context *ctx, struct ubus_object *obj,
603 struct ubus_request_data *req, const char *method,
604 struct blob_attr *msg)
605 {
606 struct stat s;
607 char *path = NULL;
608
609 if (!rpc_check_path(msg, R, "write", &path, NULL))
610 return rpc_errno_status();
611
612 if (lstat(path, &s))
613 return rpc_errno_status();
614
615 if (S_ISDIR(s.st_mode))
616 return rpc_file_remove_recursive(path);
617
618 if (unlink(path))
619 return rpc_errno_status();
620
621 return 0;
622 }
623
624 static const char *
625 rpc_file_exec_lookup(const char *cmd)
626 {
627 struct stat s;
628 int plen = 0, clen = strlen(cmd) + 1;
629 char *search, *p;
630 static char path[PATH_MAX];
631
632 if (!stat(cmd, &s) && S_ISREG(s.st_mode))
633 return cmd;
634
635 search = getenv("PATH");
636
637 if (!search)
638 search = "/bin:/usr/bin:/sbin:/usr/sbin";
639
640 p = search;
641
642 do
643 {
644 if (*p != ':' && *p != '\0')
645 continue;
646
647 plen = p - search;
648
649 if ((plen + clen) >= sizeof(path))
650 continue;
651
652 strncpy(path, search, plen);
653 sprintf(path + plen, "/%s", cmd);
654
655 if (!stat(path, &s) && S_ISREG(s.st_mode))
656 return path;
657
658 search = p + 1;
659 }
660 while (*p++);
661
662 return NULL;
663 }
664
665
666 static void
667 rpc_ustream_to_blobmsg(struct ustream *s, const char *name)
668 {
669 int len;
670 char *rbuf, *wbuf;
671
672 if ((len = ustream_pending_data(s, false)) > 0)
673 {
674 wbuf = blobmsg_alloc_string_buffer(&buf, name, len + 1);
675
676 if (!wbuf)
677 return;
678
679 ustream_for_each_read_buffer(s, rbuf, len)
680 {
681 memcpy(wbuf, rbuf, len);
682 wbuf += len;
683 }
684
685 *wbuf = 0;
686 blobmsg_add_string_buffer(&buf);
687 }
688 }
689
690 static void
691 rpc_file_exec_reply(struct rpc_file_exec_context *c, int rv)
692 {
693 uloop_timeout_cancel(&c->timeout);
694 uloop_process_delete(&c->process);
695
696 if (rv == UBUS_STATUS_OK)
697 {
698 blob_buf_init(&buf, 0);
699
700 blobmsg_add_u32(&buf, "code", WEXITSTATUS(c->stat));
701
702 rpc_ustream_to_blobmsg(&c->opipe.stream, "stdout");
703 rpc_ustream_to_blobmsg(&c->epipe.stream, "stderr");
704
705 ubus_send_reply(c->context, &c->request, buf.head);
706 blob_buf_free(&buf);
707 }
708
709 ubus_complete_deferred_request(c->context, &c->request, rv);
710
711 ustream_free(&c->opipe.stream);
712 ustream_free(&c->epipe.stream);
713
714 close(c->opipe.fd.fd);
715 close(c->epipe.fd.fd);
716
717 free(c);
718 }
719
720 static void
721 rpc_file_exec_timeout_cb(struct uloop_timeout *t)
722 {
723 struct rpc_file_exec_context *c =
724 container_of(t, struct rpc_file_exec_context, timeout);
725
726 kill(c->process.pid, SIGKILL);
727 rpc_file_exec_reply(c, UBUS_STATUS_TIMEOUT);
728 }
729
730 static void
731 rpc_file_exec_process_cb(struct uloop_process *p, int stat)
732 {
733 struct rpc_file_exec_context *c =
734 container_of(p, struct rpc_file_exec_context, process);
735
736 c->stat = stat;
737
738 ustream_poll(&c->opipe.stream);
739 ustream_poll(&c->epipe.stream);
740 }
741
742 static void
743 rpc_file_exec_opipe_read_cb(struct ustream *s, int bytes)
744 {
745 struct rpc_file_exec_context *c =
746 container_of(s, struct rpc_file_exec_context, opipe.stream);
747
748 if (ustream_read_buf_full(s))
749 rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
750 }
751
752 static void
753 rpc_file_exec_epipe_read_cb(struct ustream *s, int bytes)
754 {
755 struct rpc_file_exec_context *c =
756 container_of(s, struct rpc_file_exec_context, epipe.stream);
757
758 if (ustream_read_buf_full(s))
759 rpc_file_exec_reply(c, UBUS_STATUS_NOT_SUPPORTED);
760 }
761
762 static void
763 rpc_file_exec_opipe_state_cb(struct ustream *s)
764 {
765 struct rpc_file_exec_context *c =
766 container_of(s, struct rpc_file_exec_context, opipe.stream);
767
768 if (c->opipe.stream.eof && c->epipe.stream.eof)
769 rpc_file_exec_reply(c, UBUS_STATUS_OK);
770 }
771
772 static void
773 rpc_file_exec_epipe_state_cb(struct ustream *s)
774 {
775 struct rpc_file_exec_context *c =
776 container_of(s, struct rpc_file_exec_context, epipe.stream);
777
778 if (c->opipe.stream.eof && c->epipe.stream.eof)
779 rpc_file_exec_reply(c, UBUS_STATUS_OK);
780 }
781
782 static void
783 rpc_fdclose(int fd)
784 {
785 if (fd > 2)
786 close(fd);
787 }
788
789 static int
790 rpc_file_exec_run(const char *cmd, const struct blob_attr *sid,
791 const struct blob_attr *arg, const struct blob_attr *env,
792 struct ubus_context *ctx, struct ubus_request_data *req)
793 {
794 pid_t pid;
795
796 int devnull;
797 int opipe[2];
798 int epipe[2];
799
800 int rem;
801 struct blob_attr *cur;
802
803 uint8_t arglen;
804 char *executable, **args, **tmp;
805
806 struct rpc_file_exec_context *c;
807
808 cmd = rpc_file_exec_lookup(cmd);
809
810 if (!cmd)
811 return UBUS_STATUS_NOT_FOUND;
812
813 executable = rpc_canonicalize_path(cmd);
814
815 if (executable == NULL)
816 return UBUS_STATUS_UNKNOWN_ERROR;
817
818 if (!rpc_file_access(sid, executable, "exec"))
819 return UBUS_STATUS_PERMISSION_DENIED;
820
821 c = malloc(sizeof(*c));
822
823 if (!c)
824 return UBUS_STATUS_UNKNOWN_ERROR;
825
826 if (pipe(opipe))
827 goto fail_opipe;
828
829 if (pipe(epipe))
830 goto fail_epipe;
831
832 switch ((pid = fork()))
833 {
834 case -1:
835 goto fail_fork;
836
837 case 0:
838 uloop_done();
839
840 devnull = open("/dev/null", O_RDWR);
841
842 if (devnull == -1)
843 return UBUS_STATUS_UNKNOWN_ERROR;
844
845 dup2(devnull, 0);
846 dup2(opipe[1], 1);
847 dup2(epipe[1], 2);
848
849 rpc_fdclose(devnull);
850 rpc_fdclose(opipe[0]);
851 rpc_fdclose(opipe[1]);
852 rpc_fdclose(epipe[0]);
853 rpc_fdclose(epipe[1]);
854
855 arglen = 2;
856 args = malloc(sizeof(char *) * arglen);
857
858 if (!args)
859 return UBUS_STATUS_UNKNOWN_ERROR;
860
861 args[0] = (char *)executable;
862 args[1] = NULL;
863
864 if (arg)
865 {
866 blobmsg_for_each_attr(cur, arg, rem)
867 {
868 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
869 continue;
870
871 if (arglen == 255)
872 {
873 free(args);
874 return UBUS_STATUS_INVALID_ARGUMENT;
875 }
876
877 arglen++;
878 tmp = realloc(args, sizeof(char *) * arglen);
879
880 if (!tmp)
881 {
882 free(args);
883 return UBUS_STATUS_UNKNOWN_ERROR;
884 }
885
886 args = tmp;
887 args[arglen-2] = blobmsg_data(cur);
888 args[arglen-1] = NULL;
889 }
890 }
891
892 if (env)
893 {
894 blobmsg_for_each_attr(cur, env, rem)
895 {
896 if (blobmsg_type(cur) != BLOBMSG_TYPE_STRING)
897 continue;
898
899 setenv(blobmsg_name(cur), blobmsg_data(cur), 1);
900 }
901 }
902
903 if (execv(executable, args))
904 return rpc_errno_status();
905
906 default:
907 memset(c, 0, sizeof(*c));
908
909 ustream_declare(c->opipe, opipe[0], exec_opipe);
910 ustream_declare(c->epipe, epipe[0], exec_epipe);
911
912 c->process.pid = pid;
913 c->process.cb = rpc_file_exec_process_cb;
914 uloop_process_add(&c->process);
915
916 c->timeout.cb = rpc_file_exec_timeout_cb;
917 uloop_timeout_set(&c->timeout, *ops->exec_timeout);
918
919 close(opipe[1]);
920 close(epipe[1]);
921
922 c->context = ctx;
923 ubus_defer_request(ctx, req, &c->request);
924 }
925
926 return UBUS_STATUS_OK;
927
928 fail_fork:
929 close(epipe[0]);
930 close(epipe[1]);
931
932 fail_epipe:
933 close(opipe[0]);
934 close(opipe[1]);
935
936 fail_opipe:
937 free(c);
938 return rpc_errno_status();
939 }
940
941 static int
942 rpc_file_exec(struct ubus_context *ctx, struct ubus_object *obj,
943 struct ubus_request_data *req, const char *method,
944 struct blob_attr *msg)
945 {
946 struct blob_attr *tb[__RPC_E_MAX];
947
948 blobmsg_parse(rpc_exec_policy, __RPC_E_MAX, tb,
949 blob_data(msg), blob_len(msg));
950
951 if (!tb[RPC_E_CMD])
952 return UBUS_STATUS_INVALID_ARGUMENT;
953
954 return rpc_file_exec_run(blobmsg_data(tb[RPC_E_CMD]), tb[RPC_E_SESSION],
955 tb[RPC_E_PARM], tb[RPC_E_ENV], ctx, req);
956 }
957
958
959 static int
960 rpc_file_api_init(const struct rpc_daemon_ops *o, struct ubus_context *ctx)
961 {
962 static const struct ubus_method file_methods[] = {
963 UBUS_METHOD("read", rpc_file_read, rpc_file_RB_policy),
964 UBUS_METHOD("write", rpc_file_write, rpc_file_RW_policy),
965 UBUS_METHOD("list", rpc_file_list, rpc_file_R_policy),
966 UBUS_METHOD("stat", rpc_file_stat, rpc_file_R_policy),
967 UBUS_METHOD("md5", rpc_file_md5, rpc_file_R_policy),
968 UBUS_METHOD("remove", rpc_file_remove, rpc_file_R_policy),
969 UBUS_METHOD("exec", rpc_file_exec, rpc_exec_policy),
970 };
971
972 static struct ubus_object_type file_type =
973 UBUS_OBJECT_TYPE("luci-rpc-file", file_methods);
974
975 static struct ubus_object obj = {
976 .name = "file",
977 .type = &file_type,
978 .methods = file_methods,
979 .n_methods = ARRAY_SIZE(file_methods),
980 };
981
982 ops = o;
983
984 return ubus_add_object(ctx, &obj);
985 }
986
987 struct rpc_plugin rpc_plugin = {
988 .init = rpc_file_api_init
989 };
OpenWrt ubus RPC daemon