name.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   2
   3 #include <assert.h>
   4 #include <errno.h>
   5 #include <string.h>
   6
   7 #include "set.h"
   8 #include "name.h"
   9 #include "macro.h"
  10 #include "strv.h"
  11 #include "load-fragment.h"
  12
  13 NameType name_type_from_string(const char *n) {
  14         NameType t;
  15         static const char* suffixes[_NAME_TYPE_MAX] = {
  16                 [NAME_SERVICE] = ".service",
  17                 [NAME_TIMER] = ".timer",
  18                 [NAME_SOCKET] = ".socket",
  19                 [NAME_MILESTONE] = ".milestone",
  20                 [NAME_DEVICE] = ".device",
  21                 [NAME_MOUNT] = ".mount",
  22                 [NAME_AUTOMOUNT] = ".automount",
  23                 [NAME_SNAPSHOT] = ".snapshot",
  24         };
  25
  26         assert(n);
  27
  28         for (t = 0; t < _NAME_TYPE_MAX; t++)
  29                 if (endswith(n, suffixes[t]))
  30                         return t;
  31
  32         return _NAME_TYPE_INVALID;
  33 }
  34
  35 #define VALID_CHARS                             \
  36         "0123456789"                            \
  37         "abcdefghijklmnopqrstuvwxyz"            \
  38         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
  39         "-_"
  40
  41 bool name_is_valid(const char *n) {
  42         NameType t;
  43         const char *e, *i;
  44
  45         assert(n);
  46
  47         t = name_type_from_string(n);
  48         if (t < 0 || t >= _NAME_TYPE_MAX)
  49                 return false;
  50
  51         if (!(e = strrchr(n, '.')))
  52                 return false;
  53
  54         for (i = n; i < e; i++)
  55                 if (!strchr(VALID_CHARS, *i))
  56                         return false;
  57
  58         return true;
  59 }
  60
  61 Name *name_new(Manager *m) {
  62         Name *n;
  63
  64         assert(m);
  65
  66         if (!(n = new0(Name, 1)))
  67                 return NULL;
  68
  69         if (!(n->meta.names = set_new(string_hash_func, string_compare_func))) {
  70                 free(n);
  71                 return NULL;
  72         }
  73
  74         /* Not much initialization happening here at this time */
  75         n->meta.manager = m;
  76         n->meta.type = _NAME_TYPE_INVALID;
  77         n->meta.state = NAME_STUB;
  78
  79         /* We don't link the name here, that is left for name_link() */
  80
  81         return n;
  82 }
  83
  84 /* FIXME: Does not rollback on failure! */
  85 int name_link_names(Name *n, bool replace) {
  86         char *t;
  87         void *state;
  88         int r;
  89
  90         assert(n);
  91
  92         if (!n->meta.linked)
  93                 return 0;
  94
  95         /* Link all names that aren't linked yet. */
  96
  97         SET_FOREACH(t, n->meta.names, state)
  98                 if (replace) {
  99                         if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
 100                                 return r;
 101                 } else {
 102                         if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
 103                                 return r;
 104                 }
 105
 106         return 0;
 107 }
 108
 109 int name_link(Name *n) {
 110         int r;
 111
 112         assert(n);
 113         assert(!set_isempty(n->meta.names));
 114         assert(!n->meta.linked);
 115
 116         if ((r = name_sanitize(n)) < 0)
 117                 return r;
 118
 119         n->meta.linked = true;
 120
 121         if ((r = name_link_names(n, false)) < 0) {
 122                 char *t;
 123                 void *state;
 124
 125                 /* Rollback the registered names */
 126                 SET_FOREACH(t, n->meta.names, state)
 127                         hashmap_remove_value(n->meta.manager->names, t, n);
 128
 129                 n->meta.linked = false;
 130                 return r;
 131         }
 132
 133         if (n->meta.state == NAME_STUB)
 134                 LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
 135
 136         return 0;
 137 }
 138
 139 static void bidi_set_free(Name *name, Set *s) {
 140         void *state;
 141         Name *other;
 142
 143         assert(name);
 144
 145         /* Frees the set and makes sure we are dropped from the
 146          * inverse pointers */
 147
 148         SET_FOREACH(other, s, state) {
 149                 NameDependency d;
 150
 151                 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 152                         set_remove(other->meta.dependencies[d], name);
 153         }
 154
 155         set_free(s);
 156 }
 157
 158 void name_free(Name *name) {
 159         NameDependency d;
 160         char *t;
 161
 162         assert(name);
 163
 164         /* Detach from next 'bigger' objects */
 165         if (name->meta.linked) {
 166                 char *t;
 167                 void *state;
 168
 169                 SET_FOREACH(t, name->meta.names, state)
 170                         hashmap_remove_value(name->meta.manager->names, t, name);
 171
 172                 if (name->meta.state == NAME_STUB)
 173                         LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta);
 174         }
 175
 176         /* Free data and next 'smaller' objects */
 177         if (name->meta.job)
 178                 job_free(name->meta.job);
 179
 180         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 181                 bidi_set_free(name, name->meta.dependencies[d]);
 182
 183         switch (name->meta.type) {
 184
 185                 case NAME_SOCKET: {
 186                         unsigned i;
 187                         Socket *s = SOCKET(name);
 188
 189                         for (i = 0; i < s->n_fds; i++)
 190                                 close_nointr(s->fds[i]);
 191                         break;
 192                 }
 193
 194                 case NAME_DEVICE: {
 195                         Device *d = DEVICE(name);
 196
 197                         free(d->sysfs);
 198                         break;
 199                 }
 200
 201                 case NAME_MOUNT: {
 202                         Mount *m = MOUNT(name);
 203
 204                         free(m->path);
 205                         break;
 206                 }
 207
 208                 case NAME_AUTOMOUNT: {
 209                         Automount *a = AUTOMOUNT(name);
 210
 211                         free(a->path);
 212                         break;
 213                 }
 214
 215                 default:
 216                         ;
 217         }
 218
 219         free(name->meta.description);
 220
 221         while ((t = set_steal_first(name->meta.names)))
 222                 free(t);
 223         set_free(name->meta.names);
 224
 225         free(name);
 226 }
 227
 228 bool name_is_ready(Name *name) {
 229         assert(name);
 230
 231         if (name->meta.state != NAME_LOADED)
 232                 return false;
 233
 234         assert(name->meta.type < _NAME_TYPE_MAX);
 235
 236         switch (name->meta.type) {
 237                 case NAME_SERVICE: {
 238                         Service *s = SERVICE(name);
 239
 240                         return
 241                                 s->state == SERVICE_RUNNING ||
 242                                 s->state == SERVICE_RELOAD_PRE ||
 243                                 s->state == SERVICE_RELOAD ||
 244                                 s->state == SERVICE_RELOAD_POST;
 245                 }
 246
 247                 case NAME_TIMER: {
 248                         Timer *t = TIMER(name);
 249
 250                         return
 251                                 t->state == TIMER_WAITING ||
 252                                 t->state == TIMER_RUNNING;
 253                 }
 254
 255                 case NAME_SOCKET: {
 256                         Socket *s = SOCKET(name);
 257
 258                         return
 259                                 s->state == SOCKET_LISTENING ||
 260                                 s->state == SOCKET_RUNNING;
 261                 }
 262
 263                 case NAME_MILESTONE:
 264                         return MILESTONE(name)->state == MILESTONE_ACTIVE;
 265
 266                 case NAME_DEVICE:
 267                         return DEVICE(name)->state == DEVICE_AVAILABLE;
 268
 269                 case NAME_MOUNT:
 270                         return MOUNT(name)->state == MOUNT_MOUNTED;
 271
 272                 case NAME_AUTOMOUNT: {
 273                         Automount *a = AUTOMOUNT(name);
 274
 275                         return
 276                                 a->state == AUTOMOUNT_WAITING ||
 277                                 a->state == AUTOMOUNT_RUNNING;
 278                 }
 279
 280                 case NAME_SNAPSHOT:
 281                         return SNAPSHOT(name)->state == SNAPSHOT_ACTIVE;
 282
 283
 284                 case _NAME_TYPE_MAX:
 285                 case _NAME_TYPE_INVALID:
 286                         ;
 287         }
 288
 289         assert_not_reached("Unknown name type.");
 290         return false;
 291 }
 292
 293 bool name_is_dead(Name *name) {
 294         assert(name);
 295
 296         if (name->meta.state != NAME_LOADED)
 297                 return true;
 298         assert(name->meta.type < _NAME_TYPE_MAX);
 299
 300         switch (name->meta.type) {
 301                 case NAME_SERVICE: {
 302                         Service *s = SERVICE(name);
 303
 304                         return
 305                                 s->state == SERVICE_DEAD ||
 306                                 s->state == SERVICE_MAINTAINANCE;
 307                 }
 308
 309                 case NAME_TIMER:
 310                         return TIMER(name)->state == TIMER_DEAD;
 311
 312                 case NAME_SOCKET: {
 313                         Socket *s = SOCKET(name);
 314
 315                         return
 316                                 s->state == SOCKET_DEAD ||
 317                                 s->state == SOCKET_MAINTAINANCE;
 318                 }
 319
 320                 case NAME_MILESTONE:
 321                         return MILESTONE(name)->state == MILESTONE_DEAD;
 322
 323                 case NAME_DEVICE:
 324                         return DEVICE(name)->state == DEVICE_DEAD;
 325
 326                 case NAME_MOUNT: {
 327                         Mount *a = MOUNT(name);
 328
 329                         return
 330                                 a->state == AUTOMOUNT_DEAD ||
 331                                 a->state == AUTOMOUNT_MAINTAINANCE;
 332                 }
 333
 334                 case NAME_AUTOMOUNT: {
 335                         Automount *a = AUTOMOUNT(name);
 336
 337                         return
 338                                 a->state == AUTOMOUNT_DEAD ||
 339                                 a->state == AUTOMOUNT_MAINTAINANCE;
 340                 }
 341
 342                 case NAME_SNAPSHOT:
 343                         return SNAPSHOT(name)->state == SNAPSHOT_DEAD;
 344
 345
 346                 case _NAME_TYPE_MAX:
 347                 case _NAME_TYPE_INVALID:
 348                         ;
 349         }
 350
 351         assert_not_reached("Unknown name type.");
 352         return false;
 353 }
 354
 355
 356 static int ensure_in_set(Set **s, void *data) {
 357         int r;
 358
 359         assert(s);
 360         assert(data);
 361
 362         if (!*s)
 363                 if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
 364                         return -ENOMEM;
 365
 366         if ((r = set_put(*s, data)) < 0)
 367                 if (r != -EEXIST)
 368                         return r;
 369
 370         return 0;
 371 }
 372
 373 static int ensure_merge(Set **s, Set *other) {
 374
 375         if (!other)
 376                 return 0;
 377
 378         if (*s)
 379                 return set_merge(*s, other);
 380
 381         if (!(*s = set_copy(other)))
 382                 return -ENOMEM;
 383
 384         return 0;
 385 }
 386
 387 /* FIXME: Does not rollback on failure! */
 388 int name_merge(Name *name, Name *other) {
 389         int r;
 390         NameDependency d;
 391
 392         assert(name);
 393         assert(other);
 394         assert(name->meta.manager == other->meta.manager);
 395
 396         /* This merges 'other' into 'name'. FIXME: This does not
 397          * rollback on failure. */
 398
 399         if (name->meta.type != other->meta.type)
 400                 return -EINVAL;
 401
 402         if (other->meta.state != NAME_STUB)
 403                 return -EINVAL;
 404
 405         /* Merge names */
 406         if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
 407                 return r;
 408
 409         /* Merge dependencies */
 410         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 411                 if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
 412                         return r;
 413
 414         /* Hookup new deps and names */
 415         if (name->meta.linked) {
 416                 if ((r = name_sanitize(name)) < 0)
 417                         return r;
 418
 419                 if ((r = name_link_names(name, true)) < 0)
 420                         return r;
 421         }
 422
 423         return 0;
 424 }
 425
 426 /* FIXME: Does not rollback on failure! */
 427 static int augment(Name *n) {
 428         int r;
 429         void* state;
 430         Name *other;
 431
 432         assert(n);
 433
 434         /* Adds in the missing links to make all dependencies
 435          * bidirectional. */
 436
 437         SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
 438                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n)) < 0)
 439                         return r;
 440         SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state)
 441                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n)) < 0)
 442                         return r;
 443
 444         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
 445                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n)) < 0)
 446                         return r;
 447
 448         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
 449                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 450                         return r;
 451         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
 452                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 453                         return r;
 454
 455         SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
 456                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
 457                         return r;
 458         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
 459                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
 460                         return r;
 461         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUISITE], state)
 462                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
 463                         return r;
 464
 465         return 0;
 466 }
 467
 468 int name_sanitize(Name *n) {
 469         NameDependency d;
 470
 471         assert(n);
 472
 473         /* Remove loops */
 474         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 475                 set_remove(n->meta.dependencies[d], n);
 476
 477         return augment(n);
 478 }
 479
 480 const char* name_id(Name *n) {
 481         assert(n);
 482
 483         return set_first(n->meta.names);
 484 }
 485
 486 void name_dump(Name *n, FILE *f, const char *prefix) {
 487
 488         static const char* const state_table[_NAME_STATE_MAX] = {
 489                 [NAME_STUB] = "stub",
 490                 [NAME_LOADED] = "loaded",
 491                 [NAME_FAILED] = "failed"
 492         };
 493
 494         static const char* const socket_state_table[_SOCKET_STATE_MAX] = {
 495                 [SOCKET_DEAD] = "dead",
 496                 [SOCKET_BEFORE] = "before",
 497                 [SOCKET_START_PRE] = "start-pre",
 498                 [SOCKET_START] = "start",
 499                 [SOCKET_START_POST] = "start-post",
 500                 [SOCKET_LISTENING] = "listening",
 501                 [SOCKET_RUNNING] = "running",
 502                 [SOCKET_STOP_PRE] = "stop-pre",
 503                 [SOCKET_STOP] = "stop",
 504                 [SOCKET_STOP_POST] = "stop-post",
 505                 [SOCKET_MAINTAINANCE] = "maintainance"
 506         };
 507
 508         static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = {
 509                 [NAME_REQUIRES] = "Requires",
 510                 [NAME_SOFT_REQUIRES] = "SoftRequires",
 511                 [NAME_WANTS] = "Wants",
 512                 [NAME_REQUISITE] = "Requisite",
 513                 [NAME_SOFT_REQUISITE] = "SoftRequisite",
 514                 [NAME_REQUIRED_BY] = "RequiredBy",
 515                 [NAME_WANTED_BY] = "WantedBy",
 516                 [NAME_CONFLICTS] = "Conflicts",
 517                 [NAME_BEFORE] = "Before",
 518                 [NAME_AFTER] = "After",
 519         };
 520
 521         void *state;
 522         char *t;
 523         NameDependency d;
 524
 525         assert(n);
 526
 527         if (!prefix)
 528                 prefix = "";
 529
 530         fprintf(f,
 531                 "%sName %s:\n"
 532                 "%s\tDescription: %s\n"
 533                 "%s\tName State: %s\n",
 534                 prefix, name_id(n),
 535                 prefix, n->meta.description ? n->meta.description : name_id(n),
 536                 prefix, state_table[n->meta.state]);
 537
 538         fprintf(f, "%s\tNames: ", prefix);
 539         SET_FOREACH(t, n->meta.names, state)
 540                 fprintf(f, "%s ", t);
 541         fprintf(f, "\n");
 542
 543         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
 544                 void *state;
 545                 Name *other;
 546
 547                 if (set_isempty(n->meta.dependencies[d]))
 548                         continue;
 549
 550                 fprintf(f, "%s\t%s: ", prefix, dependency_table[d]);
 551
 552                 SET_FOREACH(other, n->meta.dependencies[d], state)
 553                         fprintf(f, "%s ", name_id(other));
 554
 555                 fprintf(f, "\n");
 556         }
 557
 558
 559         switch (n->meta.type) {
 560                 case NAME_SOCKET: {
 561                         int r;
 562                         char *s = NULL;
 563                         const char *t;
 564
 565                         if ((r = address_print(&n->socket.address, &s)) < 0)
 566                                 t = strerror(-r);
 567                         else
 568                                 t = s;
 569
 570                         fprintf(f,
 571                                 "%s\tAddress: %s\n"
 572                                 "%s\tSocket State: %s\n",
 573                                 prefix, t,
 574                                 prefix, socket_state_table[n->socket.state]);
 575
 576                         free(s);
 577                         break;
 578                 }
 579
 580                 default:
 581                         ;
 582         }
 583
 584         if (n->meta.job) {
 585                 char *p;
 586
 587                 if (asprintf(&p, "%s\t", prefix) >= 0)
 588                         prefix = p;
 589                 else
 590                         p = NULL;
 591
 592                 job_dump(n->meta.job, f, prefix);
 593                 free(p);
 594         }
 595 }
 596
 597 static int verify_type(Name *name) {
 598         char *n;
 599         void *state;
 600
 601         assert(name);
 602
 603         /* Checks that all aliases of this name have the same and valid type */
 604
 605         SET_FOREACH(n, name->meta.names, state) {
 606                 NameType t;
 607
 608                 if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
 609                         return -EINVAL;
 610
 611                 if (name->meta.type == _NAME_TYPE_INVALID) {
 612                         name->meta.type = t;
 613                         continue;
 614                 }
 615
 616                 if (name->meta.type != t)
 617                         return -EINVAL;
 618         }
 619
 620         if (name->meta.type == _NAME_TYPE_INVALID)
 621                 return -EINVAL;
 622
 623         return 0;
 624 }
 625
 626 static int service_load_sysv(Service *s) {
 627         assert(s);
 628
 629         /* Load service data from SysV init scripts, preferably with
 630          * LSB headers ... */
 631
 632         return -ENOENT;
 633 }
 634
 635 static int name_load_fstab(Name *n) {
 636         assert(n);
 637         assert(n->meta.type == NAME_MOUNT || n->meta.type == NAME_AUTOMOUNT);
 638
 639         /* Load mount data from /etc/fstab */
 640
 641         return 0;
 642 }
 643
 644 static int snapshot_load(Snapshot *s) {
 645         assert(s);
 646
 647         /* Load snapshots from disk */
 648
 649         return 0;
 650 }
 651
 652 static int name_load_dropin(Name *n) {
 653         assert(n);
 654
 655         /* Load dependencies from drop-in directories */
 656
 657         return 0;
 658 }
 659
 660 int name_load(Name *name) {
 661         int r;
 662
 663         assert(name);
 664
 665         if (name->meta.state != NAME_STUB)
 666                 return 0;
 667
 668         if ((r = verify_type(name)) < 0)
 669                 return r;
 670
 671         if (name->meta.type == NAME_SERVICE) {
 672
 673                 /* Load a .service file */
 674                 if ((r = name_load_fragment(name)) == 0)
 675                         goto finish;
 676
 677                 /* Load a classic init script */
 678                 if (r == -ENOENT)
 679                         if ((r = service_load_sysv(SERVICE(name))) == 0)
 680                                 goto finish;
 681
 682         } else if (name->meta.type == NAME_MOUNT ||
 683                    name->meta.type == NAME_AUTOMOUNT) {
 684
 685                 if ((r = name_load_fstab(name)) == 0)
 686                         goto finish;
 687
 688         } else if (name->meta.type == NAME_SNAPSHOT) {
 689
 690                 if ((r = snapshot_load(SNAPSHOT(name))) == 0)
 691                         goto finish;
 692
 693         } else {
 694                 if ((r = name_load_fragment(name)) == 0)
 695                         goto finish;
 696         }
 697
 698         name->meta.state = NAME_FAILED;
 699         return r;
 700
 701 finish:
 702         if ((r = name_load_dropin(name)) < 0)
 703                 return r;
 704
 705         if ((r = name_sanitize(name)) < 0)
 706                 return r;
 707
 708         if ((r = name_link_names(name, false)) < 0)
 709                 return r;
 710
 711         name->meta.state = NAME_LOADED;
 712         return 0;
 713 }