src/wgtpkg-unit.c

   1 /*
   2  Copyright 2016, 2017 IoT.bzh
   3
   4  author: José Bollo <jose.bollo@iot.bzh>
   5
   6  Licensed under the Apache License, Version 2.0 (the "License");
   7  you may not use this file except in compliance with the License.
   8  You may obtain a copy of the License at
   9
  10      http://www.apache.org/licenses/LICENSE-2.0
  11
  12  Unless required by applicable law or agreed to in writing, software
  13  distributed under the License is distributed on an "AS IS" BASIS,
  14  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  See the License for the specific language governing permissions and
  16  limitations under the License.
  17 */
  18
  19 #define _GNU_SOURCE
  20
  21 #include <stdlib.h>
  22 #include <stdio.h>
  23 #include <sys/types.h>
  24 #include <fcntl.h>
  25 #include <unistd.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <limits.h>
  29
  30 #include <json-c/json.h>
  31
  32 #include "verbose.h"
  33 #include "utils-file.h"
  34
  35 #include "wgtpkg-mustach.h"
  36 #include "utils-json.h"
  37 #include "wgt-json.h"
  38 #include "utils-systemd.h"
  39
  40 #include "wgtpkg-unit.h"
  41
  42 #if 0
  43 #include <ctype.h>
  44 #else
  45 #define isblank(c) ((c)==' '||(c)=='\t')
  46 #endif
  47
  48 /* the template for all units */
  49 static char *template;
  50
  51 /*
  52  * Search for the 'pattern' in 'text'.
  53  * Returns 1 if 'text' matches the 'pattern' or else returns 0.
  54  * When returning 1 and 'after' isn't NULL, the pointer to the
  55  * first character after the pettern in 'text' is stored in 'after'.
  56  * The characters '\n' and ' ' have a special mening in the search:
  57  *  * '\n': matches any space or tabs (including none) followed
  58  *          either by '\n' or '\0' (end of the string)
  59  *  * ' ': matches any space or tabs but at least one.
  60  */
  61 static int matches(const char *pattern, char *text, char **after)
  62 {
  63         char p, t;
  64
  65         t = *text;
  66         p = *pattern;
  67         while(p) {
  68                 switch(p) {
  69                 case '\n':
  70                         while (isblank(t))
  71                                 t = *++text;
  72                         if (t) {
  73                                 if (t != p)
  74                                         return 0;
  75                                 t = *++text;
  76                         }
  77                         break;
  78                 case ' ':
  79                         if (!isblank(t))
  80                                 return 0;
  81                         do {
  82                                 t = *++text;
  83                         } while(isblank(t));
  84                         break;
  85                 default:
  86                         if (t != p)
  87                                 return 0;
  88                         t = *++text;
  89                         break;
  90                 }
  91                 p = *++pattern;
  92         }
  93         if (after)
  94                 *after = text;
  95         return 1;
  96 }
  97
  98 /*
  99  * Pack a null terminated 'text' by removing empty lines,
 100  * lines made of blanks and terminated with \, lines
 101  * starting with the 'purge' character (can be null).
 102  * Lines made of the 'purge' character followed with
 103  * "nl" exactly (without quotes ") are replaced with
 104  * an empty line.
 105  *
 106  * Returns the size after packing (offset of the ending null).
 107  */
 108 static size_t pack(char *text, char purge)
 109 {
 110         char *read;    /* read iterator */
 111         char *write;   /* write iterator */
 112         char *begin;   /* begin the copied text of the line */
 113         char *start;   /* first character of the line that isn't blanck */
 114         char c;        /* currently scanned character (pointed by read) */
 115         char emit;     /* flag telling whether line is to be copied */
 116         char cont;     /* flag telling whether the line continues the previous one */
 117         char nextcont; /* flag telling whether the line will continues the next one */
 118
 119         nextcont = 0;
 120         c = *(write = read = text);
 121
 122         /* iteration over lines */
 123         while (c) {
 124                 /* computes emit, nextcont, emit and start for the current line */
 125                 cont = nextcont;
 126                 emit = nextcont = 0;
 127                 start = NULL;
 128                 begin = read;
 129                 while (c && c != '\n') {
 130                         if (!isblank(c)) {
 131                                 if (c == '\\' && read[1] == '\n')
 132                                         nextcont = 1;
 133                                 else {
 134                                         emit = 1;
 135                                         if (!start)
 136                                                 start = read;
 137                                 }
 138                         }
 139                         c = *++read;
 140                 }
 141                 if (c)
 142                         c = *++read;
 143                 /* emit the line if not empty */
 144                 if (emit || (cont && !nextcont)) {
 145                         /* removes the blanks on the left of not continuing lines */
 146                         if (!cont && start)
 147                                 begin = start;
 148                         /* check if purge applies */
 149                         if (purge && *begin == purge) {
 150                                 /* yes, insert new line if requested */
 151                                 if (!strncmp(begin+1, "nl\n",3))
 152                                         *write++ = '\n';
 153                         } else {
 154                                 /* copies the line */
 155                                 while (begin != read)
 156                                         *write++ = *begin++;
 157                         }
 158                 }
 159         }
 160         *write = 0;
 161         return (size_t)(write - text);
 162 }
 163
 164 /*
 165  * Searchs the first character of the next line
 166  * of the 'text' and returns its address
 167  * Returns NULL if there is no next line.
 168  */
 169 static inline char *nextline(char *text)
 170 {
 171         char *result = strchr(text, '\n');
 172         return result + !!result;
 173 }
 174
 175 /*
 176  * Search in 'text' the offset of a line beginning with the 'pattern'
 177  * Returns NULL if not found or the address of the line contning the pattern
 178  * If args isn't NULL and the pattern is found, the pointed pattern is
 179  * updated with the address of the character following the found pattern.
 180  */
 181 static char *offset(char *text, const char *pattern, char **args)
 182 {
 183         while (text && !matches(pattern, text, args))
 184                 text = nextline(text);
 185         return text;
 186 }
 187
 188 /*
 189  * process one unit
 190  */
 191 static int process_one_unit(char *spec, struct unitdesc *desc)
 192 {
 193         char *nsoc, *nsrv, *name, *wanted;
 194         int isuser, issystem, issock, isserv, iswanted;
 195         size_t len;
 196
 197         /* finds the configuration directive of the unit */
 198         isuser = !!offset(spec, "%systemd-unit user\n", NULL);
 199         issystem = !!offset(spec, "%systemd-unit system\n", NULL);
 200         issock  = !!offset(spec, "%systemd-unit socket ", &nsoc);
 201         isserv  = !!offset(spec, "%systemd-unit service ", &nsrv);
 202         iswanted = !!offset(spec, "%systemd-unit wanted-by ", &wanted);
 203
 204         /* check the unit scope */
 205         if ((isuser + issystem) == 1) {
 206                 desc->scope = isuser ? unitscope_user : unitscope_system;
 207         } else {
 208                 desc->scope = unitscope_unknown;
 209         }
 210
 211         /* check the unit type */
 212         if ((issock + isserv) == 1) {
 213                 if (issock) {
 214                         desc->type = unittype_socket;
 215                         name = nsoc;
 216                 } else {
 217                         desc->type = unittype_service;
 218                         name = nsrv;
 219                 }
 220                 len = (size_t)(strchrnul(name, '\n') - name);
 221                 desc->name = strndup(name, len);
 222                 desc->name_length = desc->name ? len : 0;
 223         } else {
 224                 desc->type = unittype_unknown;
 225                 desc->name = NULL;
 226                 desc->name_length = 0;
 227         }
 228
 229         if (iswanted) {
 230                 len = (size_t)(strchrnul(wanted, '\n') - wanted);
 231                 desc->wanted_by = strndup(wanted, len);
 232                 desc->wanted_by_length = len;
 233         } else {
 234                 desc->wanted_by = NULL;
 235                 desc->wanted_by_length = 0;
 236         }
 237
 238         desc->content = spec;
 239         desc->content_length = pack(spec, '%');
 240
 241         return 0;
 242 }
 243
 244 /*
 245  * Processes all the units of the 'corpus'.
 246  * Each unit of the corpus is separated and packed and its
 247  * charactistics are stored in a descriptor.
 248  * At the end if no error was found, calls the function 'process'
 249  * with its given 'closure' and the array descripbing the units.
 250  * Return 0 in case of success or a negative value in case of error.
 251  */
 252 static int process_all_units(char *corpus, int (*process)(void *closure, const struct unitdesc descs[], unsigned count), void *closure)
 253 {
 254         int rc, rc2;
 255         unsigned n;
 256         char *beg, *end;
 257         struct unitdesc *descs, *d;
 258
 259         descs = NULL;
 260         n = 0;
 261         rc = rc2 = 0;
 262
 263         /* while there is a unit in the corpus */
 264         while(offset(corpus, "%begin systemd-unit\n", &beg)) {
 265
 266                 /* get the end of the unit */
 267                 end = offset(beg, "%end systemd-unit\n", &corpus);
 268                 if (!end) {
 269                         /* unterminated unit !! */
 270                         ERROR("unterminated unit description!! %s", beg);
 271                         corpus = beg;
 272                         rc2 = -EINVAL;
 273                 } else {
 274                         /* separate the unit from the corpus */
 275                         *end = 0;
 276
 277                         /* allocates a descriptor for the unit */
 278                         d = realloc(descs, (n + 1) * sizeof *descs);
 279                         if (d == NULL)
 280                                 rc2 = -ENOMEM;
 281                         else {
 282                                 /* creates the unit description */
 283                                 memset(&d[n], 0, sizeof *d);
 284                                 descs = d;
 285                                 rc2 = process_one_unit(beg, &descs[n]);
 286                                 if (rc2 >= 0)
 287                                         n++;
 288                         }
 289                 }
 290                 /* records the error if there is an error */
 291                 if (rc2 < 0) {
 292                         rc = rc ? : rc2;
 293                         rc2 = 0;
 294                 }
 295         }
 296
 297         /* call the function that processes the units */
 298         if (rc == 0 && process)
 299                 rc = process(closure, descs, n);
 300
 301         /* cleanup and frees */
 302         while(n) {
 303                 free((char *)(descs[--n].name));
 304                 free((char *)(descs[n].wanted_by));
 305         }
 306         free(descs);
 307
 308         return rc;
 309 }
 310
 311 /*
 312  * Clear the unit generator
 313  */
 314 void unit_generator_off()
 315 {
 316         free(template);
 317         template = NULL;
 318 }
 319
 320 /*
 321  * Initialises the unit generator with the content of the file of path 'filename'.
 322  * Returns 0 in case of success or a negative number in case of error.
 323  */
 324 int unit_generator_on(const char *filename)
 325 {
 326         size_t size;
 327         char *tmp;
 328         int rc;
 329
 330         unit_generator_off();
 331         rc = getfile(filename ? : FWK_UNIT_CONF, &template, NULL);
 332         if (!rc) {
 333                 size = pack(template, ';');
 334                 tmp = realloc(template, 1 + size);
 335                 if (tmp)
 336                         template = tmp;
 337         }
 338         return rc;
 339 }
 340
 341 /*
 342  * Applies the object 'jdesc' to the current unit generator.
 343  * The current unit generator will be set to the default one if not unit
 344  * was previously set using the function 'unit_generator_on'.
 345  * The callback function 'process' is then called with the
 346  * unit descriptors array and the expected closure.
 347  * Return what returned process in case of success or a negative
 348  * error code.
 349  */
 350 int unit_generator_process(struct json_object *jdesc, int (*process)(void *closure, const struct unitdesc descs[], unsigned count), void *closure)
 351 {
 352         int rc;
 353         size_t size;
 354         char *instance;
 355
 356         rc = template ? 0 : unit_generator_on(NULL);
 357         if (!rc) {
 358                 instance = NULL;
 359                 rc = apply_mustach(template, jdesc, &instance, &size);
 360                 if (!rc)
 361                         rc = process_all_units(instance, process, closure);
 362                 free(instance);
 363         }
 364         return rc;
 365 }
 366
 367 /**************** SPECIALIZED PART *****************************/
 368
 369 static int check_unit_desc(const struct unitdesc *desc, int tells)
 370 {
 371         if (desc->scope != unitscope_unknown && desc->type != unittype_unknown && desc->name != NULL)
 372                 return 0;
 373
 374         if (tells) {
 375                 if (desc->scope == unitscope_unknown)
 376                         ERROR("unit of unknown scope");
 377                 if (desc->type == unittype_unknown)
 378                         ERROR("unit of unknown type");
 379                 if (desc->name == NULL)
 380                         ERROR("unit of unknown name");
 381         }
 382         errno = EINVAL;
 383         return -1;
 384 }
 385
 386 static int get_unit_path(char *path, size_t pathlen, const struct unitdesc *desc)
 387 {
 388         int rc = systemd_get_unit_path(
 389                         path, pathlen, desc->scope == unitscope_user,
 390                         desc->name, desc->type == unittype_socket ? "socket" : "service");
 391
 392         if (rc < 0)
 393                 ERROR("can't get the unit path for %s", desc->name);
 394
 395         return rc;
 396 }
 397
 398 static int get_wants_path(char *path, size_t pathlen, const struct unitdesc *desc)
 399 {
 400         int rc = systemd_get_wants_path(
 401                         path, pathlen, desc->scope == unitscope_user, desc->wanted_by,
 402                         desc->name, desc->type == unittype_socket ? "socket" : "service");
 403
 404         if (rc < 0)
 405                 ERROR("can't get the wants path for %s and %s", desc->name, desc->wanted_by);
 406
 407         return rc;
 408 }
 409
 410 static int get_wants_target(char *path, size_t pathlen, const struct unitdesc *desc)
 411 {
 412         int rc = systemd_get_wants_target(
 413                         path, pathlen,
 414                         desc->name, desc->type == unittype_socket ? "socket" : "service");
 415
 416         if (rc < 0)
 417                 ERROR("can't get the wants target for %s", desc->name);
 418
 419         return rc;
 420 }
 421
 422 static int do_send_reload(const struct unitdesc descs[], unsigned count)
 423 {
 424         unsigned i;
 425         int reloadsys, reloadusr;
 426
 427         reloadsys = reloadusr = 0;
 428         for (i = 0 ; i < count ; i++) {
 429                 if (descs[i].wanted_by != NULL) {
 430                         switch (descs[i].scope) {
 431                         case unitscope_user:
 432                                 reloadusr = 1;
 433                                 break;
 434                         case unitscope_system:
 435                                 reloadsys = 1;
 436                                 break;
 437                         default:
 438                                 break;
 439                         }
 440                 }
 441         }
 442
 443         if (reloadusr)
 444                 reloadusr = systemd_daemon_reload(1);
 445         if (reloadsys)
 446                 reloadsys = systemd_daemon_reload(0);
 447         return reloadsys ? : reloadusr ? : 0;
 448 }
 449
 450 static int do_uninstall_units(void *closure, const struct unitdesc descs[], unsigned count)
 451 {
 452         int rc, rc2;
 453         unsigned i;
 454         char path[PATH_MAX];
 455
 456         rc = 0;
 457         for (i = 0 ; i < count ; i++) {
 458                 rc2 = check_unit_desc(&descs[i], 0);
 459                 if (rc2 == 0) {
 460                         rc2 = get_unit_path(path, sizeof path, &descs[i]);
 461                         if (rc2 >= 0) {
 462                                 rc2 = unlink(path);
 463                         }
 464                         if (rc2 < 0 && rc == 0)
 465                                 rc = rc2;
 466                         if (descs[i].wanted_by != NULL) {
 467                                 rc2 = get_wants_path(path, sizeof path, &descs[i]);
 468                                 if (rc2 >= 0)
 469                                         rc2 = unlink(path);
 470                         }
 471                 }
 472                 if (rc2 < 0 && rc == 0)
 473                         rc = rc2;
 474         }
 475         rc2 = do_send_reload(descs, count);
 476         if (rc2 < 0 && rc == 0)
 477                 rc = rc2;
 478         return rc;
 479 }
 480
 481 static int do_install_units(void *closure, const struct unitdesc descs[], unsigned count)
 482 {
 483         int rc;
 484         unsigned i;
 485         char path[PATH_MAX + 1], target[PATH_MAX + 1];
 486
 487         i = 0;
 488         while (i < count) {
 489                 rc = check_unit_desc(&descs[i], 1);
 490                 if (!rc) {
 491                         rc = get_unit_path(path, sizeof path, &descs[i]);
 492                         if (rc >= 0) {
 493                                 rc = putfile(path, descs[i].content, descs[i].content_length);
 494                                 if (descs[i].wanted_by != NULL) {
 495                                         rc = get_wants_path(path, sizeof path, &descs[i]);
 496                                         if (rc >= 0) {
 497                                                 rc = get_wants_target(target, sizeof target, &descs[i]);
 498                                                 if (rc >= 0) {
 499                                                         unlink(path); /* TODO? check? */
 500                                                         rc = symlink(target, path);
 501                                                 }
 502                                         }
 503                                 }
 504                                 i++;
 505                         }
 506                 }
 507                 if (rc < 0)
 508                         goto error;
 509         }
 510         rc = do_send_reload(descs, count);
 511         if (rc < 0)
 512                 goto error;
 513         return 0;
 514 error:
 515         do_uninstall_units(closure, descs, i);
 516         return rc;
 517 }
 518
 519 static int add_metadata(struct json_object *jdesc, const char *installdir, const char *icondir, int port)
 520 {
 521         char portstr[30];
 522
 523         sprintf(portstr, "%d", port);
 524         return  j_add_many_strings_m(jdesc,
 525                 "#metadata.install-dir", installdir,
 526                 "#metadata.app-data-dir", "%h/app-data",
 527                 "#metadata.icons-dir", icondir,
 528                 "#metadata.http-port", portstr,
 529                 NULL) ? 0 : -1;
 530 }
 531
 532 static int do_install_uninstall(
 533                 struct wgt_info *ifo,
 534                 const char *installdir,
 535                 const char *icondir,
 536                 int port,
 537                 int (*doer)(void *, const struct unitdesc[], unsigned)
 538 )
 539 {
 540         int rc;
 541         struct json_object *jdesc;
 542
 543         jdesc = wgt_info_to_json(ifo);
 544         if (!jdesc)
 545                 rc = -1;
 546         else {
 547                 rc = add_metadata(jdesc, installdir, icondir, port);
 548                 if (rc)
 549                         ERROR("can't set the metadata. %m");
 550                 else {
 551                         rc = unit_generator_process(jdesc, doer, NULL);
 552                         if (rc)
 553                                 ERROR("can't install units, error %d", rc);
 554                 }
 555                 json_object_put(jdesc);
 556         }
 557         return rc;
 558 }
 559
 560 int unit_install(struct wgt_info *ifo, const char *installdir, const char *icondir, int port)
 561 {
 562         return do_install_uninstall(ifo, installdir, icondir, port, do_install_units);
 563 }
 564
 565 int unit_uninstall(struct wgt_info *ifo)
 566 {
 567         return do_install_uninstall(ifo, "", "", 0, do_uninstall_units);
 568 }
 569