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 <sys/stat.h> 31 #include <sys/types.h> 32 #include <glob.h> 33 #include <signal.h> 34 35 #include "log.h" 36 37 #define OCI_VERSION_STRING "1.0.2" 38 #define UXC_CONFDIR "/etc/uxc" 39 #define UXC_RUNDIR "/var/run/uxc" 40 41 struct runtime_state { 42 struct avl_node avl; 43 char *container_name; 44 char *instance_name; 45 char *jail_name; 46 bool running; 47 int runtime_pid; 48 int exitcode; 49 struct blob_attr *ocistate; 50 }; 51 52 AVL_TREE(runtime, avl_strcmp, false, NULL); 53 static struct blob_buf conf; 54 static struct blob_buf state; 55 56 static struct ubus_context *ctx; 57 58 static int usage(void) { 59 printf("syntax: uxc {command} [parameters ...]\n"); 60 printf("commands:\n"); 61 printf("\tlist\t\t\t\tlist all configured containers\n"); 62 printf("\tcreate {conf} [path] [enabled]\tcreate {conf} for OCI bundle at {path}\n"); 63 printf("\tstart {conf}\t\t\tstart container {conf}\n"); 64 printf("\tstate {conf}\t\t\tget state of container {conf}\n"); 65 printf("\tkill {conf} {signal}\t\tsend signal to container {conf}\n"); 66 printf("\tenable {conf}\t\t\tstart container {conf} on boot\n"); 67 printf("\tdisable {conf}\t\t\tdon't start container {conf} on boot\n"); 68 printf("\tdelete {conf}\t\t\tdelete {conf}\n"); 69 return EINVAL; 70 } 71 72 enum { 73 CONF_NAME, 74 CONF_PATH, 75 CONF_JAIL, 76 CONF_AUTOSTART, 77 __CONF_MAX, 78 }; 79 80 static const struct blobmsg_policy conf_policy[__CONF_MAX] = { 81 [CONF_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING }, 82 [CONF_PATH] = { .name = "path", .type = BLOBMSG_TYPE_STRING }, 83 [CONF_JAIL] = { .name = "jail", .type = BLOBMSG_TYPE_STRING }, 84 [CONF_AUTOSTART] = { .name = "autostart", .type = BLOBMSG_TYPE_BOOL }, 85 }; 86 87 static int conf_load(bool load_state) 88 { 89 int gl_flags = GLOB_NOESCAPE | GLOB_MARK; 90 int j, res; 91 glob_t gl; 92 char *globstr; 93 struct blob_buf *target = load_state?&state:&conf; 94 void *c, *o; 95 96 if (asprintf(&globstr, "%s/*.json", load_state?UXC_RUNDIR:UXC_CONFDIR) == -1) 97 return ENOMEM; 98 99 blob_buf_init(target, 0); 100 c = blobmsg_open_table(target, NULL); 101 102 res = glob(globstr, gl_flags, NULL, &gl); 103 free(globstr); 104 if (res < 0) 105 return 0; 106 107 for (j = 0; j < gl.gl_pathc; j++) { 108 o = blobmsg_open_table(target, strdup(gl.gl_pathv[j])); 109 if (!blobmsg_add_json_from_file(target, gl.gl_pathv[j])) { 110 ERROR("uxc: failed to load %s\n", gl.gl_pathv[j]); 111 continue; 112 } 113 blobmsg_close_table(target, o); 114 } 115 blobmsg_close_table(target, c); 116 globfree(&gl); 117 118 return 0; 119 } 120 121 enum { 122 LIST_INSTANCES, 123 __LIST_MAX, 124 }; 125 126 static const struct blobmsg_policy list_policy[__LIST_MAX] = { 127 [LIST_INSTANCES] = { .name = "instances", .type = BLOBMSG_TYPE_TABLE }, 128 }; 129 130 enum { 131 INSTANCE_RUNNING, 132 INSTANCE_PID, 133 INSTANCE_EXITCODE, 134 INSTANCE_JAIL, 135 __INSTANCE_MAX, 136 }; 137 138 static const struct blobmsg_policy instance_policy[__INSTANCE_MAX] = { 139 [INSTANCE_RUNNING] = { .name = "running", .type = BLOBMSG_TYPE_BOOL }, 140 [INSTANCE_PID] = { .name = "pid", .type = BLOBMSG_TYPE_INT32 }, 141 [INSTANCE_EXITCODE] = { .name = "exit_code", .type = BLOBMSG_TYPE_INT32 }, 142 [INSTANCE_JAIL] = { .name = "jail", .type = BLOBMSG_TYPE_TABLE }, 143 }; 144 145 enum { 146 JAIL_NAME, 147 __JAIL_MAX, 148 }; 149 150 static const struct blobmsg_policy jail_policy[__JAIL_MAX] = { 151 [JAIL_NAME] = { .name = "name", .type = BLOBMSG_TYPE_STRING }, 152 }; 153 154 static struct runtime_state * 155 runtime_alloc(const char *container_name) 156 { 157 struct runtime_state *s; 158 char *new_name; 159 s = calloc_a(sizeof(*s), &new_name, strlen(container_name) + 1); 160 strcpy(new_name, container_name); 161 s->container_name = new_name; 162 s->avl.key = s->container_name; 163 return s; 164 } 165 166 enum { 167 STATE_OCIVERSION, 168 STATE_ID, 169 STATE_STATUS, 170 STATE_PID, 171 STATE_BUNDLE, 172 STATE_ANNOTATIONS, 173 __STATE_MAX, 174 }; 175 176 static const struct blobmsg_policy state_policy[__STATE_MAX] = { 177 [STATE_OCIVERSION] = { .name = "ociVersion", .type = BLOBMSG_TYPE_STRING }, 178 [STATE_ID] = { .name = "id", .type = BLOBMSG_TYPE_STRING }, 179 [STATE_STATUS] = { .name = "status", .type = BLOBMSG_TYPE_STRING }, 180 [STATE_PID] = { .name = "pid", .type = BLOBMSG_TYPE_INT32 }, 181 [STATE_BUNDLE] = { .name = "bundle", .type = BLOBMSG_TYPE_STRING }, 182 [STATE_ANNOTATIONS] = { .name = "annotations", .type = BLOBMSG_TYPE_TABLE }, 183 }; 184 185 186 static void ocistate_cb(struct ubus_request *req, int type, struct blob_attr *msg) 187 { 188 struct blob_attr **ocistate = (struct blob_attr **)req->priv; 189 struct blob_attr *tb[__STATE_MAX]; 190 191 blobmsg_parse(state_policy, __STATE_MAX, tb, blobmsg_data(msg), blobmsg_len(msg)); 192 193 if (!tb[STATE_OCIVERSION] || 194 !tb[STATE_ID] || 195 !tb[STATE_STATUS] || 196 !tb[STATE_BUNDLE]) 197 return; 198 199 *ocistate = blob_memdup(msg); 200 } 201 202 static void get_ocistate(struct blob_attr **ocistate, const char *name) 203 { 204 char *objname; 205 unsigned int id; 206 int ret; 207 *ocistate = NULL; 208 209 asprintf(&objname, "container.%s", name); 210 ret = ubus_lookup_id(ctx, objname, &id); 211 free(objname); 212 if (ret) 213 return; 214 215 ubus_invoke(ctx, id, "state", NULL, ocistate_cb, ocistate, 3000); 216 } 217 218 static void list_cb(struct ubus_request *req, int type, struct blob_attr *msg) 219 { 220 struct blob_attr *cur, *curi, *tl[__LIST_MAX], *ti[__INSTANCE_MAX], *tj[__JAIL_MAX]; 221 int rem, remi; 222 const char *container_name, *instance_name, *jail_name; 223 bool running; 224 int pid, exitcode; 225 struct runtime_state *rs; 226 227 blobmsg_for_each_attr(cur, msg, rem) { 228 container_name = blobmsg_name(cur); 229 blobmsg_parse(list_policy, __LIST_MAX, tl, blobmsg_data(cur), blobmsg_len(cur)); 230 if (!tl[LIST_INSTANCES]) 231 continue; 232 233 blobmsg_for_each_attr(curi, tl[LIST_INSTANCES], remi) { 234 instance_name = blobmsg_name(curi); 235 blobmsg_parse(instance_policy, __INSTANCE_MAX, ti, blobmsg_data(curi), blobmsg_len(curi)); 236 237 if (!ti[INSTANCE_JAIL]) 238 continue; 239 240 blobmsg_parse(jail_policy, __JAIL_MAX, tj, blobmsg_data(ti[INSTANCE_JAIL]), blobmsg_len(ti[INSTANCE_JAIL])); 241 if (!tj[JAIL_NAME]) 242 continue; 243 244 jail_name = blobmsg_get_string(tj[JAIL_NAME]); 245 246 running = ti[INSTANCE_RUNNING] && blobmsg_get_bool(ti[INSTANCE_RUNNING]); 247 248 if (ti[INSTANCE_PID]) 249 pid = blobmsg_get_u32(ti[INSTANCE_PID]); 250 else 251 pid = -1; 252 253 if (ti[INSTANCE_EXITCODE]) 254 exitcode = blobmsg_get_u32(ti[INSTANCE_EXITCODE]); 255 else 256 exitcode = -1; 257 258 rs = runtime_alloc(container_name); 259 rs->instance_name = strdup(instance_name); 260 rs->jail_name = strdup(jail_name); 261 rs->runtime_pid = pid; 262 rs->exitcode = exitcode; 263 rs->running = running; 264 avl_insert(&runtime, &rs->avl); 265 } 266 } 267 268 return; 269 } 270 271 static int runtime_load(void) 272 { 273 struct runtime_state *item, *tmp; 274 uint32_t id; 275 276 avl_init(&runtime, avl_strcmp, false, NULL); 277 if (ubus_lookup_id(ctx, "container", &id) || 278 ubus_invoke(ctx, id, "list", NULL, list_cb, &runtime, 3000)) 279 return EIO; 280 281 282 avl_for_each_element_safe(&runtime, item, avl, tmp) 283 get_ocistate(&item->ocistate, item->jail_name); 284 285 return 0; 286 } 287 288 static void runtime_free(void) 289 { 290 struct runtime_state *item, *tmp; 291 292 avl_for_each_element_safe(&runtime, item, avl, tmp) { 293 avl_delete(&runtime, &item->avl); 294 free(item->instance_name); 295 free(item->jail_name); 296 free(item->ocistate); 297 free(item); 298 } 299 300 return; 301 } 302 303 static int uxc_state(char *name) 304 { 305 struct runtime_state *s = avl_find_element(&runtime, name, s, avl); 306 struct blob_attr *ocistate = NULL; 307 struct blob_attr *cur, *tb[__CONF_MAX]; 308 int rem; 309 char *bundle = NULL; 310 char *jail_name = NULL; 311 static struct blob_buf buf; 312 313 if (s) 314 ocistate = s->ocistate; 315 316 if (ocistate) { 317 printf("%s\n", blobmsg_format_json_indent(ocistate, true, 0)); 318 return 0; 319 } 320 321 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 322 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 323 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 324 continue; 325 326 if (!strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) { 327 if (tb[CONF_JAIL]) 328 jail_name = blobmsg_get_string(tb[CONF_JAIL]); 329 else 330 jail_name = name; 331 332 bundle = blobmsg_get_string(tb[CONF_PATH]); 333 break; 334 } 335 } 336 337 if (!bundle) 338 return ENOENT; 339 340 blob_buf_init(&buf, 0); 341 blobmsg_add_string(&buf, "ociVersion", OCI_VERSION_STRING); 342 blobmsg_add_string(&buf, "id", jail_name); 343 blobmsg_add_string(&buf, "status", s?"stopped":"uninitialized"); 344 blobmsg_add_string(&buf, "bundle", bundle); 345 346 printf("%s\n", blobmsg_format_json_indent(buf.head, true, 0)); 347 blob_buf_free(&buf); 348 349 return 0; 350 } 351 352 static int uxc_list(void) 353 { 354 struct blob_attr *cur, *tb[__CONF_MAX], *ts[__STATE_MAX]; 355 int rem; 356 struct runtime_state *s = NULL; 357 char *name; 358 char *ocistatus; 359 int container_pid = -1; 360 bool autostart; 361 362 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 363 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 364 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 365 continue; 366 367 autostart = tb[CONF_AUTOSTART] && blobmsg_get_bool(tb[CONF_AUTOSTART]); 368 ocistatus = NULL; 369 container_pid = 0; 370 name = blobmsg_get_string(tb[CONF_NAME]); 371 s = avl_find_element(&runtime, name, s, avl); 372 373 if (s && s->ocistate) { 374 blobmsg_parse(state_policy, __STATE_MAX, ts, blobmsg_data(s->ocistate), blobmsg_len(s->ocistate)); 375 ocistatus = blobmsg_get_string(ts[STATE_STATUS]); 376 container_pid = blobmsg_get_u32(ts[STATE_PID]); 377 } 378 379 printf("[%c] %s %s", autostart?'*':' ', name, ocistatus?:(s && s->running)?"creating":"stopped"); 380 381 if (s && !s->running && (s->exitcode >= 0)) 382 printf(" exitcode: %d (%s)", s->exitcode, strerror(s->exitcode)); 383 384 if (s && s->running && (s->runtime_pid >= 0)) 385 printf(" runtime pid: %d", s->runtime_pid); 386 387 if (s && s->running && (container_pid >= 0)) 388 printf(" container pid: %d", container_pid); 389 390 printf("\n"); 391 } 392 393 return 0; 394 } 395 396 static int uxc_create(char *name, bool immediately) 397 { 398 static struct blob_buf req; 399 struct blob_attr *cur, *tb[__CONF_MAX]; 400 int rem, ret; 401 uint32_t id; 402 struct runtime_state *s = NULL; 403 char *path = NULL, *jailname = NULL; 404 void *in, *ins, *j; 405 bool found = false; 406 407 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 408 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 409 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 410 continue; 411 412 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) 413 continue; 414 415 found = true; 416 path = strdup(blobmsg_get_string(tb[CONF_PATH])); 417 418 break; 419 } 420 421 if (!found) 422 return ENOENT; 423 424 s = avl_find_element(&runtime, name, s, avl); 425 426 if (s && (s->running)) 427 return EEXIST; 428 429 if (tb[CONF_JAIL]) 430 jailname = strdup(blobmsg_get_string(tb[CONF_JAIL])); 431 432 blob_buf_init(&req, 0); 433 blobmsg_add_string(&req, "name", name); 434 ins = blobmsg_open_table(&req, "instances"); 435 in = blobmsg_open_table(&req, name); 436 blobmsg_add_string(&req, "bundle", path); 437 j = blobmsg_open_table(&req, "jail"); 438 blobmsg_add_string(&req, "name", jailname?:name); 439 blobmsg_add_u8(&req, "immediately", immediately); 440 blobmsg_close_table(&req, j); 441 blobmsg_close_table(&req, in); 442 blobmsg_close_table(&req, ins); 443 444 ret = 0; 445 if (ubus_lookup_id(ctx, "container", &id) || 446 ubus_invoke(ctx, id, "add", req.head, NULL, NULL, 3000)) { 447 ret = EIO; 448 } 449 450 free(jailname); 451 free(path); 452 blob_buf_free(&req); 453 454 return ret; 455 } 456 457 static int uxc_start(const char *name) 458 { 459 char *objname; 460 unsigned int id; 461 462 asprintf(&objname, "container.%s", name); 463 if (ubus_lookup_id(ctx, objname, &id)) 464 return ENOENT; 465 466 return ubus_invoke(ctx, id, "start", NULL, NULL, NULL, 3000); 467 } 468 469 static int uxc_kill(char *name, int signal) 470 { 471 static struct blob_buf req; 472 struct blob_attr *cur, *tb[__CONF_MAX]; 473 int rem, ret; 474 char *objname; 475 unsigned int id; 476 struct runtime_state *s = NULL; 477 bool found = false; 478 479 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 480 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 481 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 482 continue; 483 484 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) 485 continue; 486 487 found = true; 488 break; 489 } 490 491 if (!found) 492 return ENOENT; 493 494 s = avl_find_element(&runtime, name, s, avl); 495 496 if (!s || !(s->running)) 497 return ENOENT; 498 499 blob_buf_init(&req, 0); 500 blobmsg_add_u32(&req, "signal", signal); 501 blobmsg_add_string(&req, "name", name); 502 503 asprintf(&objname, "container.%s", name); 504 ret = ubus_lookup_id(ctx, objname, &id); 505 free(objname); 506 if (ret) 507 return ENOENT; 508 509 if (ubus_invoke(ctx, id, "kill", req.head, NULL, NULL, 3000)) 510 return EIO; 511 512 return 0; 513 } 514 515 516 static int uxc_set(char *name, char *path, bool autostart, bool add) 517 { 518 static struct blob_buf req; 519 struct blob_attr *cur, *tb[__CONF_MAX]; 520 int rem, ret; 521 bool found = false; 522 char *fname = NULL; 523 char *keeppath = NULL; 524 int f; 525 struct stat sb; 526 527 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 528 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 529 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 530 continue; 531 532 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) 533 continue; 534 535 found = true; 536 break; 537 } 538 539 if (found && add) 540 return EEXIST; 541 542 if (!found && !add) 543 return ENOENT; 544 545 if (add && !path) 546 return EINVAL; 547 548 if (path) { 549 if (stat(path, &sb) == -1) 550 return ENOENT; 551 552 if ((sb.st_mode & S_IFMT) != S_IFDIR) 553 return ENOTDIR; 554 } 555 556 ret = mkdir(UXC_CONFDIR, 0755); 557 558 if (ret && errno != EEXIST) 559 return ret; 560 561 if (asprintf(&fname, "%s/%s.json", UXC_CONFDIR, name) < 1) 562 return ENOMEM; 563 564 f = open(fname, O_WRONLY | O_CREAT | O_TRUNC, 0644); 565 if (f < 0) 566 return errno; 567 568 if (!add) 569 keeppath = strdup(blobmsg_get_string(tb[CONF_PATH])); 570 571 blob_buf_init(&req, 0); 572 blobmsg_add_string(&req, "name", name); 573 blobmsg_add_string(&req, "path", path?:keeppath); 574 blobmsg_add_u8(&req, "autostart", autostart); 575 576 dprintf(f, "%s\n", blobmsg_format_json_indent(req.head, true, 0)); 577 578 if (!add) 579 free(keeppath); 580 581 blob_buf_free(&req); 582 583 return 0; 584 } 585 586 static int uxc_boot(void) 587 { 588 struct blob_attr *cur, *tb[__CONF_MAX]; 589 int rem, ret = 0; 590 char *name; 591 592 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 593 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 594 if (!tb[CONF_NAME] || !tb[CONF_PATH] || !tb[CONF_AUTOSTART] || !blobmsg_get_bool(tb[CONF_AUTOSTART])) 595 continue; 596 597 name = strdup(blobmsg_get_string(tb[CONF_NAME])); 598 ret += uxc_create(name, true); 599 free(name); 600 } 601 602 return ret; 603 } 604 605 static int uxc_delete(char *name) 606 { 607 struct blob_attr *cur, *tb[__CONF_MAX]; 608 int rem, ret = 0; 609 bool found = false; 610 char *fname; 611 struct stat sb; 612 613 blobmsg_for_each_attr(cur, blob_data(conf.head), rem) { 614 blobmsg_parse(conf_policy, __CONF_MAX, tb, blobmsg_data(cur), blobmsg_len(cur)); 615 if (!tb[CONF_NAME] || !tb[CONF_PATH]) 616 continue; 617 618 if (strcmp(name, blobmsg_get_string(tb[CONF_NAME]))) 619 continue; 620 621 fname = strdup(blobmsg_name(cur)); 622 if (!fname) 623 return errno; 624 625 found = true; 626 break; 627 } 628 629 if (!found) 630 return ENOENT; 631 632 if (stat(fname, &sb) == -1) { 633 ret=ENOENT; 634 goto errout; 635 } 636 637 if (unlink(fname) == -1) 638 ret=errno; 639 640 errout: 641 free(fname); 642 return ret; 643 } 644 645 static void reload_conf(void) 646 { 647 blob_buf_free(&conf); 648 conf_load(false); 649 } 650 651 int main(int argc, char **argv) 652 { 653 int ret = EINVAL; 654 655 if (argc < 2) 656 return usage(); 657 658 ctx = ubus_connect(NULL); 659 if (!ctx) 660 return ENODEV; 661 662 ret = conf_load(false); 663 if (ret) 664 goto out; 665 666 ret = mkdir(UXC_RUNDIR, 0755); 667 if (ret && errno != EEXIST) 668 goto conf_out; 669 670 ret = conf_load(true); 671 if (ret) 672 goto conf_out; 673 674 ret = runtime_load(); 675 if (ret) 676 goto state_out; 677 678 if (!strcmp("list", argv[1])) 679 ret = uxc_list(); 680 else if (!strcmp("boot", argv[1])) 681 ret = uxc_boot(); 682 else if(!strcmp("start", argv[1])) { 683 if (argc < 3) 684 goto usage_out; 685 686 ret = uxc_start(argv[2]); 687 } else if(!strcmp("state", argv[1])) { 688 if (argc < 3) 689 goto usage_out; 690 691 ret = uxc_state(argv[2]); 692 } else if(!strcmp("kill", argv[1])) { 693 int signal = SIGTERM; 694 if (argc < 3) 695 goto usage_out; 696 697 if (argc == 4) 698 signal = atoi(argv[3]); 699 700 ret = uxc_kill(argv[2], signal); 701 } else if(!strcmp("enable", argv[1])) { 702 if (argc < 3) 703 goto usage_out; 704 705 ret = uxc_set(argv[2], NULL, true, false); 706 } else if(!strcmp("disable", argv[1])) { 707 if (argc < 3) 708 goto usage_out; 709 710 ret = uxc_set(argv[2], NULL, false, false); 711 } else if(!strcmp("delete", argv[1])) { 712 if (argc < 3) 713 goto usage_out; 714 715 ret = uxc_delete(argv[2]); 716 } else if(!strcmp("create", argv[1])) { 717 bool autostart = false; 718 if (argc < 3) 719 goto usage_out; 720 721 if (argc == 5) { 722 if (!strncmp("true", argv[4], 5)) 723 autostart = true; 724 else 725 autostart = atoi(argv[4]); 726 } 727 728 if (argc >= 4) { 729 ret = uxc_set(argv[2], argv[3], autostart, true); 730 if (ret) 731 goto runtime_out; 732 733 reload_conf(); 734 } 735 ret = uxc_create(argv[2], false); 736 } else 737 goto usage_out; 738 739 goto runtime_out; 740 741 usage_out: 742 usage(); 743 runtime_out: 744 runtime_free(); 745 state_out: 746 blob_buf_free(&state); 747 conf_out: 748 blob_buf_free(&conf); 749 out: 750 ubus_free(ctx); 751 752 if (ret != 0) 753 fprintf(stderr, "uxc error: %s\n", strerror(ret)); 754 755 return ret; 756 } 757
This page was automatically generated by LXR 0.3.1. • OpenWrt