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