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 #include "load-dropin.h"
  13
  14 static const NameVTable * const name_vtable[_NAME_TYPE_MAX] = {
  15         [NAME_SERVICE] = &service_vtable,
  16         [NAME_TIMER] = &timer_vtable,
  17         [NAME_SOCKET] = &socket_vtable,
  18         [NAME_MILESTONE] = &milestone_vtable,
  19         [NAME_DEVICE] = &device_vtable,
  20         [NAME_MOUNT] = &mount_vtable,
  21         [NAME_AUTOMOUNT] = &automount_vtable,
  22         [NAME_SNAPSHOT] = &snapshot_vtable
  23 };
  24
  25 #define NAME_VTABLE(n) name_vtable[(n)->meta.type]
  26
  27 NameType name_type_from_string(const char *n) {
  28         NameType t;
  29
  30         assert(n);
  31
  32         for (t = 0; t < _NAME_TYPE_MAX; t++)
  33                 if (endswith(n, name_vtable[t]->suffix))
  34                         return t;
  35
  36         return _NAME_TYPE_INVALID;
  37 }
  38
  39 #define VALID_CHARS                             \
  40         "0123456789"                            \
  41         "abcdefghijklmnopqrstuvwxyz"            \
  42         "ABCDEFGHIJKLMNOPQRSTUVWXYZ"            \
  43         "-_"
  44
  45 bool name_is_valid(const char *n) {
  46         NameType t;
  47         const char *e, *i;
  48
  49         assert(n);
  50
  51         if (strlen(n) >= NAME_MAX)
  52                 return false;
  53
  54         t = name_type_from_string(n);
  55         if (t < 0 || t >= _NAME_TYPE_MAX)
  56                 return false;
  57
  58         if (!(e = strrchr(n, '.')))
  59                 return false;
  60
  61         for (i = n; i < e; i++)
  62                 if (!strchr(VALID_CHARS, *i))
  63                         return false;
  64
  65         return true;
  66 }
  67
  68 Name *name_new(Manager *m) {
  69         Name *n;
  70
  71         assert(m);
  72
  73         if (!(n = new0(Name, 1)))
  74                 return NULL;
  75
  76         if (!(n->meta.names = set_new(string_hash_func, string_compare_func))) {
  77                 free(n);
  78                 return NULL;
  79         }
  80
  81         /* Not much initialization happening here at this time */
  82         n->meta.manager = m;
  83         n->meta.type = _NAME_TYPE_INVALID;
  84
  85         /* We don't link the name here, that is left for name_link() */
  86
  87         return n;
  88 }
  89
  90 /* FIXME: Does not rollback on failure! */
  91 int name_link_names(Name *n, bool replace) {
  92         char *t;
  93         void *state;
  94         int r;
  95
  96         assert(n);
  97
  98         if (!n->meta.linked)
  99                 return 0;
 100
 101         /* Link all names that aren't linked yet. */
 102
 103         SET_FOREACH(t, n->meta.names, state)
 104                 if (replace) {
 105                         if ((r = hashmap_replace(n->meta.manager->names, t, n)) < 0)
 106                                 return r;
 107                 } else {
 108                         if ((r = hashmap_put(n->meta.manager->names, t, n)) < 0)
 109                                 return r;
 110                 }
 111
 112         return 0;
 113 }
 114
 115 int name_link(Name *n) {
 116         int r;
 117
 118         assert(n);
 119         assert(!set_isempty(n->meta.names));
 120         assert(!n->meta.linked);
 121
 122         if ((r = name_sanitize(n)) < 0)
 123                 return r;
 124
 125         n->meta.linked = true;
 126
 127         if ((r = name_link_names(n, false)) < 0) {
 128                 char *t;
 129                 void *state;
 130
 131                 /* Rollback the registered names */
 132                 SET_FOREACH(t, n->meta.names, state)
 133                         hashmap_remove_value(n->meta.manager->names, t, n);
 134
 135                 n->meta.linked = false;
 136                 return r;
 137         }
 138
 139         if (n->meta.load_state == NAME_STUB)
 140                 LIST_PREPEND(Meta, n->meta.manager->load_queue, &n->meta);
 141
 142         return 0;
 143 }
 144
 145 static void bidi_set_free(Name *name, Set *s) {
 146         void *state;
 147         Name *other;
 148
 149         assert(name);
 150
 151         /* Frees the set and makes sure we are dropped from the
 152          * inverse pointers */
 153
 154         SET_FOREACH(other, s, state) {
 155                 NameDependency d;
 156
 157                 for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 158                         set_remove(other->meta.dependencies[d], name);
 159         }
 160
 161         set_free(s);
 162 }
 163
 164 void name_free(Name *name) {
 165         NameDependency d;
 166         char *t;
 167
 168         assert(name);
 169
 170         /* Detach from next 'bigger' objects */
 171         if (name->meta.linked) {
 172                 char *t;
 173                 void *state;
 174
 175                 SET_FOREACH(t, name->meta.names, state)
 176                         hashmap_remove_value(name->meta.manager->names, t, name);
 177
 178                 if (name->meta.load_state == NAME_STUB)
 179                         LIST_REMOVE(Meta, name->meta.manager->load_queue, &name->meta);
 180         }
 181
 182         /* Free data and next 'smaller' objects */
 183         if (name->meta.job)
 184                 job_free(name->meta.job);
 185
 186         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 187                 bidi_set_free(name, name->meta.dependencies[d]);
 188
 189         if (NAME_VTABLE(name)->free_hook)
 190                 NAME_VTABLE(name)->free_hook(name);
 191
 192         free(name->meta.description);
 193
 194         while ((t = set_steal_first(name->meta.names)))
 195                 free(t);
 196         set_free(name->meta.names);
 197
 198         free(name);
 199 }
 200
 201 NameActiveState name_active_state(Name *name) {
 202         assert(name);
 203
 204         if (name->meta.load_state != NAME_LOADED)
 205                 return NAME_INACTIVE;
 206
 207         return NAME_VTABLE(name)->active_state(name);
 208 }
 209
 210 static int ensure_in_set(Set **s, void *data) {
 211         int r;
 212
 213         assert(s);
 214         assert(data);
 215
 216         if (!*s)
 217                 if (!(*s = set_new(trivial_hash_func, trivial_compare_func)))
 218                         return -ENOMEM;
 219
 220         if ((r = set_put(*s, data)) < 0)
 221                 if (r != -EEXIST)
 222                         return r;
 223
 224         return 0;
 225 }
 226
 227 static int ensure_merge(Set **s, Set *other) {
 228
 229         if (!other)
 230                 return 0;
 231
 232         if (*s)
 233                 return set_merge(*s, other);
 234
 235         if (!(*s = set_copy(other)))
 236                 return -ENOMEM;
 237
 238         return 0;
 239 }
 240
 241 /* FIXME: Does not rollback on failure! */
 242 int name_merge(Name *name, Name *other) {
 243         int r;
 244         NameDependency d;
 245
 246         assert(name);
 247         assert(other);
 248         assert(name->meta.manager == other->meta.manager);
 249
 250         /* This merges 'other' into 'name'. FIXME: This does not
 251          * rollback on failure. */
 252
 253         if (name->meta.type != other->meta.type)
 254                 return -EINVAL;
 255
 256         if (other->meta.load_state != NAME_STUB)
 257                 return -EINVAL;
 258
 259         /* Merge names */
 260         if ((r = ensure_merge(&name->meta.names, other->meta.names)) < 0)
 261                 return r;
 262
 263         /* Merge dependencies */
 264         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 265                 if ((r = ensure_merge(&name->meta.dependencies[d], other->meta.dependencies[d])) < 0)
 266                         return r;
 267
 268         /* Hookup new deps and names */
 269         if (name->meta.linked) {
 270                 if ((r = name_sanitize(name)) < 0)
 271                         return r;
 272
 273                 if ((r = name_link_names(name, true)) < 0)
 274                         return r;
 275         }
 276
 277         return 0;
 278 }
 279
 280 /* FIXME: Does not rollback on failure! */
 281 static int augment(Name *n) {
 282         int r;
 283         void* state;
 284         Name *other;
 285
 286         assert(n);
 287
 288         /* Adds in the missing links to make all dependencies
 289          * bidirectional. */
 290
 291         SET_FOREACH(other, n->meta.dependencies[NAME_BEFORE], state)
 292                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_AFTER], n)) < 0)
 293                         return r;
 294         SET_FOREACH(other, n->meta.dependencies[NAME_AFTER], state)
 295                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_BEFORE], n)) < 0)
 296                         return r;
 297
 298         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
 299                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_CONFLICTS], n)) < 0)
 300                         return r;
 301
 302         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
 303                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 304                         return r;
 305         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
 306                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_REQUIRED_BY], n)) < 0)
 307                         return r;
 308
 309         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
 310                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_SOFT_REQUIRED_BY], n)) < 0)
 311                         return r;
 312
 313         SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
 314                 if ((r = ensure_in_set(&other->meta.dependencies[NAME_WANTED_BY], n)) < 0)
 315                         return r;
 316
 317         return 0;
 318 }
 319
 320 int name_sanitize(Name *n) {
 321         NameDependency d;
 322
 323         assert(n);
 324
 325         /* Remove loops */
 326         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++)
 327                 set_remove(n->meta.dependencies[d], n);
 328
 329         return augment(n);
 330 }
 331
 332 const char* name_id(Name *n) {
 333         assert(n);
 334
 335         return set_first(n->meta.names);
 336 }
 337
 338 const char *name_description(Name *n) {
 339         assert(n);
 340
 341         if (n->meta.description)
 342                 return n->meta.description;
 343
 344         return name_id(n);
 345 }
 346
 347 void name_dump(Name *n, FILE *f, const char *prefix) {
 348
 349         static const char* const load_state_table[_NAME_LOAD_STATE_MAX] = {
 350                 [NAME_STUB] = "stub",
 351                 [NAME_LOADED] = "loaded",
 352                 [NAME_FAILED] = "failed"
 353         };
 354
 355         static const char* const active_state_table[_NAME_ACTIVE_STATE_MAX] = {
 356                 [NAME_ACTIVE] = "active",
 357                 [NAME_INACTIVE] = "inactive",
 358                 [NAME_ACTIVATING] = "activating",
 359                 [NAME_DEACTIVATING] = "deactivating"
 360         };
 361
 362         static const char* const dependency_table[_NAME_DEPENDENCY_MAX] = {
 363                 [NAME_REQUIRES] = "Requires",
 364                 [NAME_SOFT_REQUIRES] = "SoftRequires",
 365                 [NAME_WANTS] = "Wants",
 366                 [NAME_REQUISITE] = "Requisite",
 367                 [NAME_SOFT_REQUISITE] = "SoftRequisite",
 368                 [NAME_REQUIRED_BY] = "RequiredBy",
 369                 [NAME_SOFT_REQUIRED_BY] = "SoftRequiredBy",
 370                 [NAME_CONFLICTS] = "Conflicts",
 371                 [NAME_BEFORE] = "Before",
 372                 [NAME_AFTER] = "After",
 373         };
 374
 375         void *state;
 376         char *t;
 377         NameDependency d;
 378
 379         assert(n);
 380
 381         if (!prefix)
 382                 prefix = "";
 383
 384         fprintf(f,
 385                 "%sName %s:\n"
 386                 "%s\tDescription: %s\n"
 387                 "%s\tName Load State: %s\n"
 388                 "%s\tName Active State: %s\n",
 389                 prefix, name_id(n),
 390                 prefix, name_description(n),
 391                 prefix, load_state_table[n->meta.load_state],
 392                 prefix, active_state_table[name_active_state(n)]);
 393
 394         SET_FOREACH(t, n->meta.names, state)
 395                 fprintf(f, "%s\tName: %s\n", prefix, t);
 396
 397         for (d = 0; d < _NAME_DEPENDENCY_MAX; d++) {
 398                 void *state;
 399                 Name *other;
 400
 401                 if (set_isempty(n->meta.dependencies[d]))
 402                         continue;
 403
 404                 SET_FOREACH(other, n->meta.dependencies[d], state)
 405                         fprintf(f, "%s\t%s: %s\n", prefix, dependency_table[d], name_id(other));
 406         }
 407
 408         if (NAME_VTABLE(n)->dump)
 409                 NAME_VTABLE(n)->dump(n, f, prefix);
 410
 411         if (n->meta.job) {
 412                 char *p;
 413
 414                 if (asprintf(&p, "%s\t", prefix) >= 0)
 415                         prefix = p;
 416                 else
 417                         p = NULL;
 418
 419                 job_dump(n->meta.job, f, prefix);
 420                 free(p);
 421         }
 422 }
 423
 424 static int verify_type(Name *name) {
 425         char *n;
 426         void *state;
 427
 428         assert(name);
 429
 430         /* Checks that all aliases of this name have the same and valid type */
 431
 432         SET_FOREACH(n, name->meta.names, state) {
 433                 NameType t;
 434
 435                 if ((t = name_type_from_string(n)) == _NAME_TYPE_INVALID)
 436                         return -EINVAL;
 437
 438                 if (name->meta.type == _NAME_TYPE_INVALID) {
 439                         name->meta.type = t;
 440                         continue;
 441                 }
 442
 443                 if (name->meta.type != t)
 444                         return -EINVAL;
 445         }
 446
 447         if (name->meta.type == _NAME_TYPE_INVALID)
 448                 return -EINVAL;
 449
 450         return 0;
 451 }
 452
 453 /* Common implementation for multiple backends */
 454 int name_load_fragment_and_dropin(Name *n) {
 455         int r;
 456
 457         assert(n);
 458
 459         /* Load a .socket file */
 460         if ((r = name_load_fragment(n)) < 0)
 461                 return r;
 462
 463         /* Load drop-in directory data */
 464         if ((r = name_load_dropin(n)) < 0)
 465                 return r;
 466
 467         return 0;
 468 }
 469
 470 int name_load(Name *name) {
 471         int r;
 472
 473         assert(name);
 474
 475         if (name->meta.load_state != NAME_STUB)
 476                 return 0;
 477
 478         if ((r = verify_type(name)) < 0)
 479                 return r;
 480
 481         if (NAME_VTABLE(name)->load)
 482                 if ((r = NAME_VTABLE(name)->load(name)) < 0)
 483                         goto fail;
 484
 485         if ((r = name_sanitize(name)) < 0)
 486                 goto fail;
 487
 488         if ((r = name_link_names(name, false)) < 0)
 489                 goto fail;
 490
 491         name->meta.load_state = NAME_LOADED;
 492         return 0;
 493
 494 fail:
 495         name->meta.load_state = NAME_FAILED;
 496         return r;
 497 }
 498
 499 /* Errors:
 500  *         -EBADR:    This name type does not support starting.
 501  *         -EALREADY: Name is already started.
 502  *         -EAGAIN:   An operation is already in progress. Retry later.
 503  */
 504 int name_start(Name *n) {
 505         NameActiveState state;
 506
 507         assert(n);
 508
 509         if (!NAME_VTABLE(n)->start)
 510                 return -EBADR;
 511
 512         state = name_active_state(n);
 513         if (NAME_IS_ACTIVE_OR_RELOADING(state))
 514                 return -EALREADY;
 515
 516         if (state == NAME_ACTIVATING)
 517                 return 0;
 518
 519         return NAME_VTABLE(n)->start(n);
 520 }
 521
 522 bool name_type_can_start(NameType t) {
 523         assert(t >= 0 && t < _NAME_TYPE_MAX);
 524
 525         return !!name_vtable[t]->start;
 526 }
 527
 528 /* Errors:
 529  *         -EBADR:    This name type does not support stopping.
 530  *         -EALREADY: Name is already stopped.
 531  *         -EAGAIN:   An operation is already in progress. Retry later.
 532  */
 533 int name_stop(Name *n) {
 534         NameActiveState state;
 535
 536         assert(n);
 537
 538         if (!NAME_VTABLE(n)->stop)
 539                 return -EBADR;
 540
 541         state = name_active_state(n);
 542         if (state == NAME_INACTIVE)
 543                 return -EALREADY;
 544
 545         if (state == NAME_DEACTIVATING)
 546                 return 0;
 547
 548         return NAME_VTABLE(n)->stop(n);
 549 }
 550
 551 /* Errors:
 552  *         -EBADR:    This name type does not support reloading.
 553  *         -ENOEXEC:  Name is not started.
 554  *         -EAGAIN:   An operation is already in progress. Retry later.
 555  */
 556 int name_reload(Name *n) {
 557         NameActiveState state;
 558
 559         assert(n);
 560
 561         if (!NAME_VTABLE(n)->reload)
 562                 return -EBADR;
 563
 564         state = name_active_state(n);
 565         if (name_active_state(n) == NAME_ACTIVE_RELOADING)
 566                 return -EALREADY;
 567
 568         if (name_active_state(n) != NAME_ACTIVE)
 569                 return -ENOEXEC;
 570
 571         return NAME_VTABLE(n)->reload(n);
 572 }
 573
 574 bool name_type_can_reload(NameType t) {
 575         assert(t >= 0 && t < _NAME_TYPE_MAX);
 576         return !!name_vtable[t]->reload;
 577 }
 578
 579 static void retroactively_start_dependencies(Name *n) {
 580         void *state;
 581         Name *other;
 582
 583         assert(n);
 584         assert(NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(n)));
 585
 586         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRES], state)
 587                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 588                         manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
 589
 590         SET_FOREACH(other, n->meta.dependencies[NAME_SOFT_REQUIRES], state)
 591                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 592                         manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
 593
 594         SET_FOREACH(other, n->meta.dependencies[NAME_REQUISITE], state)
 595                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 596                         manager_add_job(n->meta.manager, JOB_START, other, JOB_REPLACE, true, NULL);
 597
 598         SET_FOREACH(other, n->meta.dependencies[NAME_WANTS], state)
 599                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 600                         manager_add_job(n->meta.manager, JOB_START, other, JOB_FAIL, false, NULL);
 601
 602         SET_FOREACH(other, n->meta.dependencies[NAME_CONFLICTS], state)
 603                 if (!NAME_IS_ACTIVE_OR_ACTIVATING(name_active_state(other)))
 604                         manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
 605 }
 606
 607 static void retroactively_stop_dependencies(Name *n) {
 608         void *state;
 609         Name *other;
 610
 611         assert(n);
 612         assert(NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(n)));
 613
 614         SET_FOREACH(other, n->meta.dependencies[NAME_REQUIRED_BY], state)
 615                 if (!NAME_IS_INACTIVE_OR_DEACTIVATING(name_active_state(other)))
 616                         manager_add_job(n->meta.manager, JOB_STOP, other, JOB_REPLACE, true, NULL);
 617 }
 618
 619 int name_notify(Name *n, NameActiveState os, NameActiveState ns) {
 620         assert(n);
 621         assert(os < _NAME_ACTIVE_STATE_MAX);
 622         assert(ns < _NAME_ACTIVE_STATE_MAX);
 623         assert(!(os == NAME_ACTIVE && ns == NAME_ACTIVATING));
 624         assert(!(os == NAME_INACTIVE && ns == NAME_DEACTIVATING));
 625
 626         if (os == ns)
 627                 return 0;
 628
 629         if (n->meta.job) {
 630
 631                 if (n->meta.job->state == JOB_WAITING)
 632
 633                         /* So we reached a different state for this
 634                          * job. Let's see if we can run it now if it
 635                          * failed previously due to EAGAIN. */
 636                         job_run_and_invalidate(n->meta.job);
 637
 638                 else {
 639                         assert(n->meta.job->state == JOB_RUNNING);
 640
 641                         /* Let's check of this state change
 642                          * constitutes a finished job, or maybe
 643                          * cotradicts a running job and hence needs to
 644                          * invalidate jobs. */
 645
 646                         switch (n->meta.job->type) {
 647
 648                                 case JOB_START:
 649                                 case JOB_VERIFY_ACTIVE:
 650
 651                                         if (NAME_IS_ACTIVE_OR_RELOADING(ns))
 652                                                 return job_finish_and_invalidate(n->meta.job, true);
 653                                         else if (ns == NAME_ACTIVATING)
 654                                                 return 0;
 655                                         else
 656                                                 job_finish_and_invalidate(n->meta.job, false);
 657
 658                                         break;
 659
 660                                 case JOB_RELOAD:
 661                                 case JOB_RELOAD_OR_START:
 662
 663                                         if (ns == NAME_ACTIVE)
 664                                                 return job_finish_and_invalidate(n->meta.job, true);
 665                                         else if (ns == NAME_ACTIVATING || ns == NAME_ACTIVE_RELOADING)
 666                                                 return 0;
 667                                         else
 668                                                 job_finish_and_invalidate(n->meta.job, false);
 669
 670                                         break;
 671
 672                                 case JOB_STOP:
 673                                 case JOB_RESTART:
 674                                 case JOB_TRY_RESTART:
 675
 676                                         if (ns == NAME_INACTIVE)
 677                                                 return job_finish_and_invalidate(n->meta.job, true);
 678                                         else if (ns == NAME_DEACTIVATING)
 679                                                 return 0;
 680                                         else
 681                                                 job_finish_and_invalidate(n->meta.job, false);
 682
 683                                         break;
 684
 685                                 default:
 686                                         assert_not_reached("Job type unknown");
 687                         }
 688                 }
 689         }
 690
 691         /* If this state change happened without being requested by a
 692          * job, then let's retroactively start or stop dependencies */
 693
 694         if (NAME_IS_INACTIVE_OR_DEACTIVATING(os) && NAME_IS_ACTIVE_OR_ACTIVATING(ns))
 695                 retroactively_start_dependencies(n);
 696         else if (NAME_IS_ACTIVE_OR_ACTIVATING(os) && NAME_IS_INACTIVE_OR_DEACTIVATING(ns))
 697                 retroactively_stop_dependencies(n);
 698
 699         return 0;
 700 }