projects / project / procd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
uxc: add JSON output option for 'list' command
[project/procd.git] / uxc.c
1 /*
2 * Copyright (C) 2020 Daniel Golle <daniel@makrotopia.org>
3 *
4 * This program is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License version 2.1
6 * as published by the Free Software Foundation
7 *
8 * This program is distributed in the hope that it will be useful,
9 * but WITHOUT ANY WARRANTY; without even the implied warranty of
10 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 * GNU General Public License for more details.
12 */
13
14 #ifndef _GNU_SOURCE
15 #define _GNU_SOURCE
16 #endif
17
18 #include <stdlib.h>
19 #include <stdbool.h>
20 #include <fcntl.h>
21 #include <libubus.h>
22 #include <libubox/avl-cmp.h>
23 #include <libubox/blobmsg.h>
24 #include <libubox/blobmsg_json.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <unistd.h>
28 #include <fcntl.h>
29 #include <errno.h>
30 #include <getopt.h>
31 #include <sys/stat.h>
32 #include <sys/types.h>
33 #include <glob.h>
34 #include <signal.h>
35
36 #include "log.h"
37
38 #define UXC_VERSION "0.2"
39 #define OCI_VERSION_STRING "1.0.2"
40 #define UXC_ETC_CONFDIR "/etc/uxc"
41 #define UXC_VOL_CONFDIR "/var/run/uxc"
42
43 static bool verbose = false;
44 static bool json_output = false;
45 static char *confdir = UXC_ETC_CONFDIR;
46
47 struct runtime_state {
48 struct avl_node avl;
49 char *container_name;
50 char *instance_name;
51 char *jail_name;
52 bool running;
53 int runtime_pid;
54 int exitcode;
55 struct blob_attr *ocistate;
56 };
57
58 enum uxc_cmd {
59 CMD_LIST,
60 CMD_BOOT,
61 CMD_START,
62 CMD_STATE,
63 CMD_KILL,
64 CMD_ENABLE,
65 CMD_DISABLE,
66 CMD_DELETE,
67 CMD_CREATE,
68 CMD_UNKNOWN
69 };
70
71 #define OPT_ARGS "ab:fjm:p:t:vVw:"
72 static struct option long_options[] = {
73 {"autostart", no_argument, 0, 'a' },
74 {"bundle", required_argument, 0, 'b' },
75 {"force", no_argument, 0, 'f' },
76 {"json", no_argument, 0, 'j' },
77 {"mounts", required_argument, 0, 'm' },
78 {"pid-file", required_argument, 0, 'p' },
79 {"temp-overlay-size", required_argument, 0, 't' },
80 {"write-overlay-path", required_argument, 0, 'w' },
81 {"verbose", no_argument, 0, 'v' },
82 {"version", no_argument, 0, 'V' },
83 {0, 0, 0, 0 }
84 };
85
86 AVL_TREE(runtime, avl_strcmp, false, NULL);
87 static struct blob_buf conf;
88 static struct blob_attr *blockinfo;
89 static struct blob_attr *fstabinfo;
90 static struct ubus_context *ctx;
91
92 static int usage(void) {
93 printf("syntax: uxc <command> [parameters ...]\n");
94 printf("commands:\n");
95 printf("\tlist [--json]\t\t\t\tlist all configured containers\n");
96 printf("\tcreate <conf>\t\t\t\t\t(re-)create <conf>\n");
97 printf(" [--bundle <path>]\t\t\tOCI bundle at <path>\n");
98 printf(" [--autostart]\t\t\t\tstart on boot\n");
99 printf(" [--temp-overlay-size size]\t\tuse tmpfs overlay with {size}\n");
100 printf(" [--write-overlay-path path]\t\tuse overlay on {path}\n");
101 printf(" [--mounts v1,v2,...,vN]\t\trequire filesystems to be available\n");
102 printf("\tstart <conf>\t\t\t\t\tstart container <conf>\n");
103 printf("\tstate <conf>\t\t\t\t\tget state of container <conf>\n");
104 printf("\tkill <conf> [<signal>]\t\t\t\tsend signal to container <conf>\n");
105 printf("\tenable <conf>\t\t\t\t\tstart container <conf> on boot\n");
106 printf("\tdisable <conf>\t\t\t\t\tdon't start container <conf> on boot\n");
107 printf("\tdelete <conf> [--force]\t\t\t\tdelete <conf>\n");
108 return EINVAL;
109 }
110
111 enum {
112 CONF_NAME,
113 CONF_PATH,
114 CONF_JAIL,
115 CONF_AUTOSTART,
116 CONF_PIDFILE,
117 CONF_TEMP_OVERLAY_SIZE,
118 CONF_WRITE_OVERLAY_PATH,
119 CONF_VOLUMES,
120 __CONF_MAX,
121 };
122
123 static const struct blobmsg_policy conf_policy[__CONF_MAX] = {
124 [CONF_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
125 [CONF_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING },
126 [CONF_JAIL] = { .name = "jail", .type = BLOBMSG_TYPE_STRING },
127 [CONF_AUTOSTART] = { .name = "autostart", .type = BLOBMSG_TYPE_BOOL },
128 [CONF_PIDFILE] = { .name = "pidfile", .type = BLOBMSG_TYPE_STRING },
129 [CONF_TEMP_OVERLAY_SIZE] = { .name = "temp-overlay-size", .type = BLOBMSG_TYPE_STRING },
130 [CONF_WRITE_OVERLAY_PATH] = { .name = "write-overlay-path", .type = BLOBMSG_TYPE_STRING },
131 [CONF_VOLUMES] = { .name = "volumes", .type = BLOBMSG_TYPE_ARRAY },
132 };
133
134 static int conf_load(void)
135 {
136 int gl_flags = GLOB_NOESCAPE | GLOB_MARK;
137 int j, res;
138 glob_t gl;
139 char *globstr;
140 void *c, *o;
141 struct stat sb;
142
143 if (!stat(UXC_VOL_CONFDIR, &sb)) {
144 if (sb.st_mode & S_IFDIR)
145 confdir = UXC_VOL_CONFDIR;
146 }
147
148 if (asprintf(&globstr, "%s/*.json", confdir) == -1)
149 return ENOMEM;
150
151 blob_buf_init(&conf, 0);
152 c = blobmsg_open_table(&conf, NULL);
153
154 res = glob(globstr, gl_flags, NULL, &gl);
155 free(globstr);
156 if (res < 0)
157 return 0;
158
159 for (j = 0; j < gl.gl_pathc; j++) {
160 o = blobmsg_open_table(&conf, strdup(gl.gl_pathv[j]));
161 if (!blobmsg_add_json_from_file(&conf, gl.gl_pathv[j])) {
162 ERROR("uxc: failed to load %s\n", gl.gl_pathv[j]);
163 continue;
164 }
165 blobmsg_close_table(&conf, o);
166 }
167 blobmsg_close_table(&conf, c);
168 globfree(&gl);
169
170 return 0;
171 }
172
173 enum {
174 LIST_INSTANCES,
175 __LIST_MAX,
176 };
177
178 static const struct blobmsg_policy list_policy[__LIST_MAX] = {
179 [LIST_INSTANCES] = { .name = "instances", .type = BLOBMSG_TYPE_TABLE },
180 };
181
182 enum {
183 INSTANCE_RUNNING,
184 INSTANCE_PID,
185 INSTANCE_EXITCODE,
186 INSTANCE_JAIL,
187 __INSTANCE_MAX,
188 };
189
190 static const struct blobmsg_policy instance_policy[__INSTANCE_MAX] = {
191 [INSTANCE_RUNNING] = { .name = "running", .type = BLOBMSG_TYPE_BOOL },
192 [INSTANCE_PID] = { .name = "pid", .type = BLOBMSG_TYPE_INT32 },
193 [INSTANCE_EXITCODE] = { .name = "exit_code", .type = BLOBMSG_TYPE_INT32 },
194 [INSTANCE_JAIL] = { .name = "jail", .type = BLOBMSG_TYPE_TABLE },
195 };
196
197 enum {
198 JAIL_NAME,
199 __JAIL_MAX,
200 };
201
202 static const struct blobmsg_policy jail_policy[__JAIL_MAX] = {
203 [JAIL_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING },
204 };
205
206 static struct runtime_state *
207 runtime_alloc(const char *container_name)
208 {
209 struct runtime_state *s;
210 char *new_name;
211 s = calloc_a(sizeof(*s), &new_name, strlen(container_name) + 1);
212 strcpy(new_name, container_name);
213 s->container_name = new_name;
214 s->avl.key = s->container_name;
215 return s;
216 }
217
218 enum {
219 STATE_OCIVERSION,
220 STATE_ID,
221 STATE_STATUS,
222 STATE_PID,
223 STATE_BUNDLE,
224 STATE_ANNOTATIONS,
225 __STATE_MAX,
226 };
227
228 static const struct blobmsg_policy state_policy[__STATE_MAX] = {
229 [STATE_OCIVERSION] = { .name = "ociVersion", .type = BLOBMSG_TYPE_STRING },
230 [STATE_ID] = { .name = "id", .type = BLOBMSG_TYPE_STRING },
231 [STATE_STATUS] = { .name = "status", .type = BLOBMSG_TYPE_STRING },
232 [STATE_PID] = { .name = "pid", .type = BLOBMSG_TYPE_INT32 },
233 [STATE_BUNDLE] = { .name = "bundle", .type = BLOBMSG_TYPE_STRING },
234 [STATE_ANNOTATIONS] = { .name = "annotations", .type = BLOBMSG_TYPE_TABLE },
235 };
236
237
238 static void ocistate_cb(struct ubus_request *req, int type, struct blob_attr *msg)
239 {
240 struct blob_attr **ocistate = (struct blob_attr **)req->priv;
241 struct blob_attr *tb[__STATE_MAX];
242
243 blobmsg_parse(state_policy, __STATE_MAX, tb, blobmsg_data(msg), blobmsg_len(msg));
244
245 if (!tb[STATE_OCIVERSION] ||
246 !tb[STATE_ID] ||
247 !tb[STATE_STATUS] ||
248 !tb[STATE_BUNDLE])
249 return;
250
251 *ocistate = blob_memdup(msg);
252 }
253
254 static void get_ocistate(struct blob_attr **ocistate, const char *name)
255 {
256 char *objname;
257 unsigned int id;
258 int ret;
259 *ocistate = NULL;
260
261 if (asprintf(&objname, "container.%s", name) == -1)
262 exit(ENOMEM);
263
264 ret = ubus_lookup_id(ctx, objname, &id);
265 free(objname);
266 if (ret)
267 return;
268
269 ubus_invoke(ctx, id, "state", NULL, ocistate_cb, ocistate, 3000);
270 }
271
272 static void list_cb(struct ubus_request *req, int type, struct blob_attr *msg)
273 {
274 struct blob_attr *cur, *curi, *tl[__LIST_MAX], *ti[__INSTANCE_MAX], *tj[__JAIL_MAX];
275 int rem, remi;
276 const char *container_name, *instance_name, *jail_name;
277 bool running;
278 int pid, exitcode;
279 struct runtime_state *rs;
280
281 blobmsg_for_each_attr(cur, msg, rem) {
282 container_name = blobmsg_name(cur);
283 blobmsg_parse(list_policy, __LIST_MAX, tl, blobmsg_data(cur), blobmsg_len(cur));
284 if (!tl[LIST_INSTANCES])
285 continue;
286
287 blobmsg_for_each_attr(curi, tl[LIST_INSTANCES], remi) {
288 instance_name = blobmsg_name(curi);
289 blobmsg_parse(instance_policy, __INSTANCE_MAX, ti, blobmsg_data(curi), blobmsg_len(curi));
290
291 if (!ti[INSTANCE_JAIL])
292 continue;
293
294 blobmsg_parse(jail_policy, __JAIL_MAX, tj, blobmsg_data(ti[INSTANCE_JAIL]), blobmsg_len(ti[INSTANCE_JAIL]));
295 if (!tj[JAIL_NAME])
296 continue;
297
298 jail_name = blobmsg_get_string(tj[JAIL_NAME]);
299
300 running = ti[INSTANCE_RUNNING] && blobmsg_get_bool(ti[INSTANCE_RUNNING]);
301
302 if (ti[INSTANCE_PID])
303 pid = blobmsg_get_u32(ti[INSTANCE_PID]);
304 else
305 pid = -1;
306
307 if (ti[INSTANCE_EXITCODE])
308 exitcode = blobmsg_get_u32(ti[INSTANCE_EXITCODE]);
309 else
310 exitcode = -1;
311
312 rs = runtime_alloc(container_name);
313 rs->instance_name = strdup(instance_name);
314 rs->jail_name = strdup(jail_name);
315 rs->runtime_pid = pid;
316 rs->exitcode = exitcode;
317 rs->running = running;
318 avl_insert(&runtime, &rs->avl);
319 }
320 }
321
322 return;
323 }
324
325 static int runtime_load(void)
326 {
327 struct runtime_state *item, *tmp;
328 uint32_t id;
329
330 avl_init(&runtime, avl_strcmp, false, NULL);
331 if (ubus_lookup_id(ctx, "container", &id) ||
332 ubus_invoke(ctx, id, "list", NULL, list_cb, &runtime, 3000))
333 return EIO;
334
335
336 avl_for_each_element_safe(&runtime, item, avl, tmp)
337 get_ocistate(&item->ocistate, item->jail_name);
338
339 return 0;
340 }
341
342 static void runtime_free(void)
343 {
344 struct runtime_state *item, *tmp;
345
346 avl_for_each_element_safe(&runtime, item, avl, tmp) {
347 avl_delete(&runtime, &item->avl);
348 free(item->instance_name);
349 free(item->jail_name);
350 free(item->ocistate);
351 free(item);
352 }
353
354 return;
355 }
356
357 static int uxc_state(char *name)
358 {
359 struct runtime_state *s = avl_find_element(&runtime, name, s, avl);
360 struct blob_attr *ocistate = NULL;
361 struct blob_attr *cur, *tb[__CONF_MAX];
362 int rem;
363 char *bundle = NULL;
364 char *jail_name = NULL;
365 char *state = NULL;
366 char *tmp;
367 static struct blob_buf buf;
368
369 if (s)
370 ocistate = s->ocistate;
371
372 if (ocistate) {
373 state = blobmsg_format_json_indent(ocistate, true, 0);
374 if (!state)
375 return 1;
376
377 printf("%s\n", state);
378 free(state);
379 return 0;
380 }
381
382 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
383 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
384 if (!tb[CONF_NAME] || !tb[CONF_PATH])
385 continue;
386
387 if (!strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) {
388 if (tb[CONF_JAIL])
389 jail_name = blobmsg_get_string(tb[CONF_JAIL]);
390 else
391 jail_name = name;
392
393 bundle = blobmsg_get_string(tb[CONF_PATH]);
394 break;
395 }
396 }
397
398 if (!bundle)
399 return ENOENT;
400
401 blob_buf_init(&buf, 0);
402 blobmsg_add_string(&buf, "ociVersion", OCI_VERSION_STRING);
403 blobmsg_add_string(&buf, "id", jail_name);
404 blobmsg_add_string(&buf, "status", s?"stopped":"uninitialized");
405 blobmsg_add_string(&buf, "bundle", bundle);
406
407 tmp = blobmsg_format_json_indent(buf.head, true, 0);
408 if (!tmp) {
409 blob_buf_free(&buf);
410 return ENOMEM;
411 }
412
413 printf("%s\n", tmp);
414 free(tmp);
415
416 blob_buf_free(&buf);
417
418 return 0;
419 }
420
421 static int uxc_list(void)
422 {
423 struct blob_attr *cur, *tb[__CONF_MAX], *ts[__STATE_MAX];
424 int rem;
425 struct runtime_state *s = NULL;
426 char *name, *ocistatus, *status, *tmp;
427 int container_pid = -1;
428 bool autostart;
429 static struct blob_buf buf;
430 void *arr, *obj;
431
432 if (json_output) {
433 blob_buf_init(&buf, 0);
434 arr = blobmsg_open_array(&buf, "");
435 }
436
437 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
438 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
439 if (!tb[CONF_NAME] || !tb[CONF_PATH])
440 continue;
441
442 autostart = tb[CONF_AUTOSTART] && blobmsg_get_bool(tb[CONF_AUTOSTART]);
443 ocistatus = NULL;
444 container_pid = 0;
445 name = blobmsg_get_string(tb[CONF_NAME]);
446 s = avl_find_element(&runtime, name, s, avl);
447
448 if (s && s->ocistate) {
449 blobmsg_parse(state_policy, __STATE_MAX, ts, blobmsg_data(s->ocistate), blobmsg_len(s->ocistate));
450 ocistatus = blobmsg_get_string(ts[STATE_STATUS]);
451 container_pid = blobmsg_get_u32(ts[STATE_PID]);
452 }
453
454 status = ocistatus?:(s && s->running)?"creating":"stopped";
455
456 if (json_output) {
457 obj = blobmsg_open_table(&buf, "");
458 blobmsg_add_string(&buf, "name", name);
459 blobmsg_add_string(&buf, "status", status);
460 blobmsg_add_u8(&buf, "autostart", autostart);
461 } else {
462 printf("[%c] %s %s", autostart?'*':' ', name, status);
463 }
464
465 if (s && !s->running && (s->exitcode >= 0)) {
466 if (json_output)
467 blobmsg_add_u32(&buf, "exitcode", s->exitcode);
468 else
469 printf(" exitcode: %d (%s)", s->exitcode, strerror(s->exitcode));
470 }
471
472 if (s && s->running && (s->runtime_pid >= 0)) {
473 if (json_output)
474 blobmsg_add_u32(&buf, "runtime_pid", s->runtime_pid);
475 else
476 printf(" runtime pid: %d", s->runtime_pid);
477 }
478
479 if (s && s->running && (container_pid >= 0)) {
480 if (json_output)
481 blobmsg_add_u32(&buf, "container_pid", container_pid);
482 else
483 printf(" container pid: %d", container_pid);
484 }
485
486 if (!json_output)
487 printf("\n");
488 else
489 blobmsg_close_table(&buf, obj);
490 }
491
492 if (json_output) {
493 blobmsg_close_array(&buf, arr);
494 tmp = blobmsg_format_json_indent(buf.head, true, 0);
495 if (!tmp) {
496 blob_buf_free(&buf);
497 return ENOMEM;
498 }
499 printf("%s\n", tmp);
500 free(tmp);
501 blob_buf_free(&buf);
502 };
503
504 return 0;
505 }
506
507 static int uxc_create(char *name, bool immediately)
508 {
509 static struct blob_buf req;
510 struct blob_attr *cur, *tb[__CONF_MAX];
511 int rem, ret;
512 uint32_t id;
513 struct runtime_state *s = NULL;
514 char *path = NULL, *jailname = NULL, *pidfile = NULL, *tmprwsize = NULL, *writepath = NULL;
515
516 void *in, *ins, *j;
517 bool found = false;
518
519 s = avl_find_element(&runtime, name, s, avl);
520
521 if (s && (s->running))
522 return EEXIST;
523
524 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
525 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
526 if (!tb[CONF_NAME] || !tb[CONF_PATH])
527 continue;
528
529 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME])))
530 continue;
531
532 found = true;
533 }
534
535 if (!found)
536 return ENOENT;
537
538 path = blobmsg_get_string(tb[CONF_PATH]);
539
540 if (tb[CONF_PIDFILE])
541 pidfile = blobmsg_get_string(tb[CONF_PIDFILE]);
542
543 if (tb[CONF_TEMP_OVERLAY_SIZE])
544 tmprwsize = blobmsg_get_string(tb[CONF_TEMP_OVERLAY_SIZE]);
545
546 if (tb[CONF_WRITE_OVERLAY_PATH])
547 writepath = blobmsg_get_string(tb[CONF_WRITE_OVERLAY_PATH]);
548
549
550 if (tb[CONF_JAIL])
551 jailname = blobmsg_get_string(tb[CONF_JAIL]);
552
553 blob_buf_init(&req, 0);
554 blobmsg_add_string(&req, "name", name);
555 ins = blobmsg_open_table(&req, "instances");
556 in = blobmsg_open_table(&req, name);
557 blobmsg_add_string(&req, "bundle", path);
558 j = blobmsg_open_table(&req, "jail");
559 blobmsg_add_string(&req, "name", jailname?:name);
560 blobmsg_add_u8(&req, "immediately", immediately);
561
562 if (pidfile)
563 blobmsg_add_string(&req, "pidfile", pidfile);
564
565 blobmsg_close_table(&req, j);
566
567 if (writepath)
568 blobmsg_add_string(&req, "overlaydir", writepath);
569
570 if (tmprwsize)
571 blobmsg_add_string(&req, "tmpoverlaysize", tmprwsize);
572
573 blobmsg_close_table(&req, in);
574 blobmsg_close_table(&req, ins);
575
576 if (verbose) {
577 char *tmp;
578 tmp = blobmsg_format_json_indent(req.head, true, 1);
579 if (!tmp)
580 return ENOMEM;
581
582 fprintf(stderr, "adding container to procd:\n\t%s\n", tmp);
583 free(tmp);
584 }
585
586 ret = 0;
587 if (ubus_lookup_id(ctx, "container", &id) ||
588 ubus_invoke(ctx, id, "add", req.head, NULL, NULL, 3000)) {
589 ret = EIO;
590 }
591
592 free(jailname);
593 free(path);
594 blob_buf_free(&req);
595
596 return ret;
597 }
598
599 static int uxc_start(const char *name)
600 {
601 char *objname;
602 unsigned int id;
603
604 if (asprintf(&objname, "container.%s", name) == -1)
605 return ENOMEM;
606
607 if (ubus_lookup_id(ctx, objname, &id))
608 return ENOENT;
609
610 return ubus_invoke(ctx, id, "start", NULL, NULL, NULL, 3000);
611 }
612
613 static int uxc_kill(char *name, int signal)
614 {
615 static struct blob_buf req;
616 struct blob_attr *cur, *tb[__CONF_MAX];
617 int rem, ret;
618 char *objname;
619 unsigned int id;
620 struct runtime_state *s = NULL;
621 bool found = false;
622
623 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
624 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
625 if (!tb[CONF_NAME] || !tb[CONF_PATH])
626 continue;
627
628 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME])))
629 continue;
630
631 found = true;
632 break;
633 }
634
635 if (!found)
636 return ENOENT;
637
638 s = avl_find_element(&runtime, name, s, avl);
639
640 if (!s || !(s->running))
641 return ENOENT;
642
643 blob_buf_init(&req, 0);
644 blobmsg_add_u32(&req, "signal", signal);
645 blobmsg_add_string(&req, "name", name);
646
647 if (asprintf(&objname, "container.%s", name) == -1)
648 return ENOMEM;
649
650 ret = ubus_lookup_id(ctx, objname, &id);
651 free(objname);
652 if (ret)
653 return ENOENT;
654
655 if (ubus_invoke(ctx, id, "kill", req.head, NULL, NULL, 3000))
656 return EIO;
657
658 return 0;
659 }
660
661
662 static int uxc_set(char *name, char *path, bool autostart, bool add, char *pidfile, char *_tmprwsize, char *_writepath, char *requiredmounts)
663 {
664 static struct blob_buf req;
665 struct blob_attr *cur, *tb[__CONF_MAX];
666 int rem, ret;
667 bool found = false;
668 char *fname = NULL;
669 char *keeppath = NULL;
670 char *tmprwsize = _tmprwsize;
671 char *writepath = _writepath;
672 char *curvol, *tmp, *mnttok;
673 void *mntarr;
674 int f;
675 struct stat sb;
676
677 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
678 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
679 if (!tb[CONF_NAME] || !tb[CONF_PATH])
680 continue;
681
682 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME])))
683 continue;
684
685 found = true;
686 break;
687 }
688
689 if (found && add)
690 return EEXIST;
691
692 if (!found && !add)
693 return ENOENT;
694
695 if (add && !path)
696 return EINVAL;
697
698 if (path) {
699 if (stat(path, &sb) == -1)
700 return ENOENT;
701
702 if ((sb.st_mode & S_IFMT) != S_IFDIR)
703 return ENOTDIR;
704 }
705
706 ret = mkdir(confdir, 0755);
707
708 if (ret && errno != EEXIST)
709 return ret;
710
711 if (asprintf(&fname, "%s/%s.json", confdir, name) == -1)
712 return ENOMEM;
713
714 f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0644);
715 if (f < 0)
716 return errno;
717
718 if (!add) {
719 keeppath = blobmsg_get_string(tb[CONF_PATH]);
720 if (tb[CONF_WRITE_OVERLAY_PATH])
721 writepath = blobmsg_get_string(tb[CONF_WRITE_OVERLAY_PATH]);
722
723 if (tb[CONF_TEMP_OVERLAY_SIZE])
724 tmprwsize = blobmsg_get_string(tb[CONF_TEMP_OVERLAY_SIZE]);
725 }
726
727 blob_buf_init(&req, 0);
728 blobmsg_add_string(&req, "name", name);
729 blobmsg_add_string(&req, "path", path?:keeppath);
730 blobmsg_add_u8(&req, "autostart", autostart);
731 if (pidfile)
732 blobmsg_add_string(&req, "pidfile", pidfile);
733
734 if (tmprwsize)
735 blobmsg_add_string(&req, "temp-overlay-size", tmprwsize);
736
737 if (writepath)
738 blobmsg_add_string(&req, "write-overlay-path", writepath);
739
740 if (!add && tb[CONF_VOLUMES])
741 blobmsg_add_blob(&req, tb[CONF_VOLUMES]);
742
743 if (add && requiredmounts) {
744 mntarr = blobmsg_open_array(&req, "volumes");
745 for (mnttok = requiredmounts; ; mnttok = NULL) {
746 curvol = strtok_r(mnttok, ",;", &tmp);
747 if (!curvol)
748 break;
749
750 blobmsg_add_string(&req, NULL, curvol);
751 }
752 blobmsg_close_array(&req, mntarr);
753 }
754 tmp = blobmsg_format_json_indent(req.head, true, 0);
755 if (tmp) {
756 dprintf(f, "%s\n", tmp);
757 free(tmp);
758 }
759
760 blob_buf_free(&req);
761 close(f);
762
763 return 0;
764 }
765
766 enum {
767 BLOCK_INFO_DEVICE,
768 BLOCK_INFO_UUID,
769 BLOCK_INFO_TARGET,
770 BLOCK_INFO_TYPE,
771 BLOCK_INFO_MOUNT,
772 __BLOCK_INFO_MAX,
773 };
774
775 static const struct blobmsg_policy block_info_policy[__BLOCK_INFO_MAX] = {
776 [BLOCK_INFO_DEVICE] = { .name = "device", .type = BLOBMSG_TYPE_STRING },
777 [BLOCK_INFO_UUID] = { .name = "uuid", .type = BLOBMSG_TYPE_STRING },
778 [BLOCK_INFO_TARGET] = { .name = "target", .type = BLOBMSG_TYPE_STRING },
779 [BLOCK_INFO_TYPE] = { .name = "type", .type = BLOBMSG_TYPE_STRING },
780 [BLOCK_INFO_MOUNT] = { .name = "mount", .type = BLOBMSG_TYPE_STRING },
781 };
782
783
784 /* check if device 'devname' is mounted according to blockd */
785 static int checkblock(const char *uuid)
786 {
787 struct blob_attr *tb[__BLOCK_INFO_MAX];
788 struct blob_attr *cur;
789 int rem;
790
791 blobmsg_for_each_attr(cur, blockinfo, rem) {
792 blobmsg_parse(block_info_policy, __BLOCK_INFO_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
793
794 if (!tb[BLOCK_INFO_UUID] || !tb[BLOCK_INFO_MOUNT])
795 continue;
796
797 if (!strcmp(uuid, blobmsg_get_string(tb[BLOCK_INFO_UUID])))
798 return 0;
799 }
800
801 return 1;
802 }
803
804 enum {
805 UCI_FSTAB_UUID,
806 UCI_FSTAB_ANONYMOUS,
807 __UCI_FSTAB_MAX,
808 };
809
810 static const struct blobmsg_policy uci_fstab_policy[__UCI_FSTAB_MAX] = {
811 [UCI_FSTAB_UUID] = { .name = "uuid", .type = BLOBMSG_TYPE_STRING },
812 [UCI_FSTAB_ANONYMOUS] = { .name = ".anonymous", .type = BLOBMSG_TYPE_BOOL },
813 };
814
815 static const char *resolveuuid(const char *volname)
816 {
817 struct blob_attr *tb[__UCI_FSTAB_MAX];
818 struct blob_attr *cur;
819 const char *mntname;
820 char *tmpvolname, *replc;
821 int rem, res;
822
823 blobmsg_for_each_attr(cur, fstabinfo, rem) {
824 blobmsg_parse(uci_fstab_policy, __UCI_FSTAB_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
825
826 if (!tb[UCI_FSTAB_UUID])
827 continue;
828
829 if (tb[UCI_FSTAB_ANONYMOUS] && blobmsg_get_bool(tb[UCI_FSTAB_ANONYMOUS]))
830 continue;
831
832 mntname = blobmsg_name(cur);
833 if (!mntname)
834 continue;
835
836 tmpvolname = strdup(volname);
837 while ((replc = strchr(tmpvolname, '-')))
838 *replc = '_';
839
840 res = strcmp(tmpvolname, mntname);
841 free(tmpvolname);
842
843 if (!res)
844 return blobmsg_get_string(tb[UCI_FSTAB_UUID]);
845 };
846
847 return volname;
848 };
849
850 /* check status of each required volume */
851 static int checkvolumes(struct blob_attr *volumes)
852 {
853 struct blob_attr *cur;
854 int rem;
855
856 blobmsg_for_each_attr(cur, volumes, rem) {
857 if (checkblock(resolveuuid(blobmsg_get_string(cur))))
858 return 1;
859 }
860
861 return 0;
862 }
863
864 static void block_cb(struct ubus_request *req, int type, struct blob_attr *msg)
865 {
866 blockinfo = blob_memdup(blobmsg_data(msg));
867 }
868
869 static void fstab_cb(struct ubus_request *req, int type, struct blob_attr *msg)
870 {
871 fstabinfo = blob_memdup(blobmsg_data(msg));
872 }
873
874 static int uxc_boot(void)
875 {
876 struct blob_attr *cur, *tb[__CONF_MAX];
877 struct runtime_state *s;
878 static struct blob_buf req;
879 int rem, ret = 0;
880 char *name;
881 unsigned int id;
882
883 ret = ubus_lookup_id(ctx, "block", &id);
884 if (ret)
885 return ENOENT;
886
887 ret = ubus_invoke(ctx, id, "info", NULL, block_cb, NULL, 3000);
888 if (ret)
889 return ENXIO;
890
891 ret = ubus_lookup_id(ctx, "uci", &id);
892 if (ret)
893 return ENOENT;
894
895 blob_buf_init(&req, 0);
896 blobmsg_add_string(&req, "config", "fstab");
897 blobmsg_add_string(&req, "type", "mount");
898
899 ret = ubus_invoke(ctx, id, "get", req.head, fstab_cb, NULL, 3000);
900 if (ret)
901 return ENXIO;
902
903 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
904 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
905 if (!tb[CONF_NAME] || !tb[CONF_PATH] || !tb[CONF_AUTOSTART] || !blobmsg_get_bool(tb[CONF_AUTOSTART]))
906 continue;
907
908 s = avl_find_element(&runtime, blobmsg_get_string(tb[CONF_NAME]), s, avl);
909 if (s)
910 continue;
911
912 /* make sure all volumes are ready before starting */
913 if (tb[CONF_VOLUMES])
914 if (checkvolumes(tb[CONF_VOLUMES]))
915 continue;
916
917 name = strdup(blobmsg_get_string(tb[CONF_NAME]));
918 ret += uxc_create(name, true);
919 free(name);
920 }
921
922 return ret;
923 }
924
925 static int uxc_delete(char *name, bool force)
926 {
927 struct blob_attr *cur, *tb[__CONF_MAX];
928 struct runtime_state *s = NULL;
929 static struct blob_buf req;
930 uint32_t id;
931 int rem, ret = 0;
932 bool found = false;
933 char *fname;
934 struct stat sb;
935
936 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) {
937 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur));
938 if (!tb[CONF_NAME] || !tb[CONF_PATH])
939 continue;
940
941 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME])))
942 continue;
943
944 fname = strdup(blobmsg_name(cur));
945 if (!fname)
946 return errno;
947
948 found = true;
949 break;
950 }
951
952 if (!found)
953 return ENOENT;
954
955 s = avl_find_element(&runtime, name, s, avl);
956
957 if (s && s->running) {
958 if (force) {
959 ret = uxc_kill(name, SIGKILL);
960 if (ret)
961 goto errout;
962
963 } else {
964 ret = EWOULDBLOCK;
965 goto errout;
966 }
967 }
968
969 if (s) {
970 ret = ubus_lookup_id(ctx, "container", &id);
971 if (ret)
972 goto errout;
973
974 blob_buf_init(&req, 0);
975 blobmsg_add_string(&req, "name", s->container_name);
976 blobmsg_add_string(&req, "instance", s->instance_name);
977
978 if (ubus_invoke(ctx, id, "delete", req.head, NULL, NULL, 3000)) {
979 blob_buf_free(&req);
980 ret=EIO;
981 goto errout;
982 }
983 }
984
985 if (stat(fname, &sb) == -1) {
986 ret=ENOENT;
987 goto errout;
988 }
989
990 if (unlink(fname) == -1)
991 ret=errno;
992
993 errout:
994 free(fname);
995 return ret;
996 }
997
998 static void reload_conf(void)
999 {
1000 blob_buf_free(&conf);
1001 conf_load();
1002 }
1003
1004 int main(int argc, char **argv)
1005 {
1006 enum uxc_cmd cmd = CMD_UNKNOWN;
1007 int ret = EINVAL;
1008 char *bundle = NULL;
1009 char *pidfile = NULL;
1010 char *tmprwsize = NULL;
1011 char *writepath = NULL;
1012 char *requiredmounts = NULL;
1013 bool autostart = false;
1014 bool force = false;
1015 int signal = SIGTERM;
1016 int c;
1017
1018 if (argc < 2)
1019 return usage();
1020
1021 ctx = ubus_connect(NULL);
1022 if (!ctx)
1023 return ENODEV;
1024
1025 ret = conf_load();
1026 if (ret)
1027 goto out;
1028
1029 ret = runtime_load();
1030 if (ret)
1031 goto conf_out;
1032
1033 while (true) {
1034 int option_index = 0;
1035 c = getopt_long(argc, argv, OPT_ARGS, long_options, &option_index);
1036 if (c == -1)
1037 break;
1038
1039 switch (c) {
1040 case 'a':
1041 autostart = true;
1042 break;
1043
1044 case 'b':
1045 bundle = optarg;
1046 break;
1047
1048 case 'f':
1049 force = true;
1050 break;
1051
1052 case 'j':
1053 json_output = true;
1054 break;
1055
1056 case 'p':
1057 pidfile = optarg;
1058 break;
1059
1060 case 't':
1061 tmprwsize = optarg;
1062 break;
1063
1064 case 'v':
1065 verbose = true;
1066 break;
1067
1068 case 'V':
1069 printf("uxc %s\n", UXC_VERSION);
1070 exit(0);
1071
1072 case 'w':
1073 writepath = optarg;
1074 break;
1075
1076 case 'm':
1077 requiredmounts = optarg;
1078 break;
1079 }
1080 }
1081
1082 if (optind == argc)
1083 goto usage_out;
1084
1085 if (!strcmp("list", argv[optind]))
1086 cmd = CMD_LIST;
1087 else if (!strcmp("boot", argv[optind]))
1088 cmd = CMD_BOOT;
1089 else if(!strcmp("start", argv[optind]))
1090 cmd = CMD_START;
1091 else if(!strcmp("state", argv[optind]))
1092 cmd = CMD_STATE;
1093 else if(!strcmp("kill", argv[optind]))
1094 cmd = CMD_KILL;
1095 else if(!strcmp("enable", argv[optind]))
1096 cmd = CMD_ENABLE;
1097 else if(!strcmp("disable", argv[optind]))
1098 cmd = CMD_DISABLE;
1099 else if(!strcmp("delete", argv[optind]))
1100 cmd = CMD_DELETE;
1101 else if(!strcmp("create", argv[optind]))
1102 cmd = CMD_CREATE;
1103
1104 switch (cmd) {
1105 case CMD_LIST:
1106 ret = uxc_list();
1107 break;
1108
1109 case CMD_BOOT:
1110 ret = uxc_boot();
1111 break;
1112
1113 case CMD_START:
1114 if (optind != argc - 2)
1115 goto usage_out;
1116
1117 ret = uxc_start(argv[optind + 1]);
1118 break;
1119
1120 case CMD_STATE:
1121 if (optind != argc - 2)
1122 goto usage_out;
1123
1124 ret = uxc_state(argv[optind + 1]);
1125 break;
1126
1127 case CMD_KILL:
1128 if (optind == (argc - 3))
1129 signal = atoi(argv[optind + 2]);
1130 else if (optind > argc - 2)
1131 goto usage_out;
1132
1133 ret = uxc_kill(argv[optind + 1], signal);
1134 break;
1135
1136 case CMD_ENABLE:
1137 if (optind != argc - 2)
1138 goto usage_out;
1139
1140 ret = uxc_set(argv[optind + 1], NULL, true, false, NULL, NULL, NULL, NULL);
1141 break;
1142
1143 case CMD_DISABLE:
1144 if (optind != argc - 2)
1145 goto usage_out;
1146
1147 ret = uxc_set(argv[optind + 1], NULL, false, false, NULL, NULL, NULL, NULL);
1148 break;
1149
1150 case CMD_DELETE:
1151 if (optind != argc - 2)
1152 goto usage_out;
1153
1154 ret = uxc_delete(argv[optind + 1], force);
1155 break;
1156
1157 case CMD_CREATE:
1158 if (optind != argc - 2)
1159 goto usage_out;
1160
1161 if (bundle) {
1162 ret = uxc_set(argv[optind + 1], bundle, autostart, true, pidfile, tmprwsize, writepath, requiredmounts);
1163 if (ret)
1164 goto runtime_out;
1165
1166 reload_conf();
1167 }
1168
1169 ret = uxc_create(argv[optind + 1], false);
1170 break;
1171
1172 default:
1173 goto usage_out;
1174 }
1175
1176 goto runtime_out;
1177
1178 usage_out:
1179 usage();
1180 runtime_out:
1181 runtime_free();
1182 conf_out:
1183 blob_buf_free(&conf);
1184 out:
1185 ubus_free(ctx);
1186
1187 if (ret != 0)
1188 fprintf(stderr, "uxc error: %s\n", strerror(ret));
1189
1190 return ret;
1191 }
OpenWrt service / process manager