src/core/busname.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2013 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include "special.h"
  23 #include "bus-kernel.h"
  24 #include "bus-internal.h"
  25 #include "bus-util.h"
  26 #include "service.h"
  27 #include "dbus-busname.h"
  28 #include "busname.h"
  29
  30 static const UnitActiveState state_translation_table[_BUSNAME_STATE_MAX] = {
  31         [BUSNAME_DEAD] = UNIT_INACTIVE,
  32         [BUSNAME_MAKING] = UNIT_ACTIVATING,
  33         [BUSNAME_REGISTERED] = UNIT_ACTIVE,
  34         [BUSNAME_LISTENING] = UNIT_ACTIVE,
  35         [BUSNAME_RUNNING] = UNIT_ACTIVE,
  36         [BUSNAME_SIGTERM] = UNIT_DEACTIVATING,
  37         [BUSNAME_SIGKILL] = UNIT_DEACTIVATING,
  38         [BUSNAME_FAILED] = UNIT_FAILED
  39 };
  40
  41 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata);
  42 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata);
  43
  44 static void busname_init(Unit *u) {
  45         BusName *n = BUSNAME(u);
  46
  47         assert(u);
  48         assert(u->load_state == UNIT_STUB);
  49
  50         n->starter_fd = -1;
  51         n->accept_fd = true;
  52         n->activating = true;
  53
  54         n->timeout_usec = u->manager->default_timeout_start_usec;
  55 }
  56
  57 static void busname_unwatch_control_pid(BusName *n) {
  58         assert(n);
  59
  60         if (n->control_pid <= 0)
  61                 return;
  62
  63         unit_unwatch_pid(UNIT(n), n->control_pid);
  64         n->control_pid = 0;
  65 }
  66
  67 static void busname_free_policy(BusName *n) {
  68         BusNamePolicy *p;
  69
  70         assert(n);
  71
  72         while ((p = n->policy)) {
  73                 LIST_REMOVE(policy, n->policy, p);
  74
  75                 free(p->name);
  76                 free(p);
  77         }
  78 }
  79
  80 static void busname_close_fd(BusName *n) {
  81         assert(n);
  82
  83         n->starter_event_source = sd_event_source_unref(n->starter_event_source);
  84         n->starter_fd = safe_close(n->starter_fd);
  85 }
  86
  87 static void busname_done(Unit *u) {
  88         BusName *n = BUSNAME(u);
  89
  90         assert(n);
  91
  92         free(n->name);
  93         n->name = NULL;
  94
  95         busname_free_policy(n);
  96         busname_unwatch_control_pid(n);
  97         busname_close_fd(n);
  98
  99         unit_ref_unset(&n->service);
 100
 101         n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 102 }
 103
 104 static int busname_arm_timer(BusName *n) {
 105         int r;
 106
 107         assert(n);
 108
 109         if (n->timeout_usec <= 0) {
 110                 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 111                 return 0;
 112         }
 113
 114         if (n->timer_event_source) {
 115                 r = sd_event_source_set_time(n->timer_event_source, now(CLOCK_MONOTONIC) + n->timeout_usec);
 116                 if (r < 0)
 117                         return r;
 118
 119                 return sd_event_source_set_enabled(n->timer_event_source, SD_EVENT_ONESHOT);
 120         }
 121
 122         return sd_event_add_time(
 123                         UNIT(n)->manager->event,
 124                         &n->timer_event_source,
 125                         CLOCK_MONOTONIC,
 126                         now(CLOCK_MONOTONIC) + n->timeout_usec, 0,
 127                         busname_dispatch_timer, n);
 128 }
 129
 130 static int busname_add_default_default_dependencies(BusName *n) {
 131         int r;
 132
 133         assert(n);
 134
 135         r = unit_add_dependency_by_name(UNIT(n), UNIT_BEFORE, SPECIAL_BUSNAMES_TARGET, NULL, true);
 136         if (r < 0)
 137                 return r;
 138
 139         if (UNIT(n)->manager->running_as == SYSTEMD_SYSTEM) {
 140                 r = unit_add_two_dependencies_by_name(UNIT(n), UNIT_AFTER, UNIT_REQUIRES, SPECIAL_SYSINIT_TARGET, NULL, true);
 141                 if (r < 0)
 142                         return r;
 143         }
 144
 145         return unit_add_two_dependencies_by_name(UNIT(n), UNIT_BEFORE, UNIT_CONFLICTS, SPECIAL_SHUTDOWN_TARGET, NULL, true);
 146 }
 147
 148 static int busname_add_extras(BusName *n) {
 149         Unit *u = UNIT(n);
 150         int r;
 151
 152         assert(n);
 153
 154         if (!n->name) {
 155                 n->name = unit_name_to_prefix(u->id);
 156                 if (!n->name)
 157                         return -ENOMEM;
 158         }
 159
 160         if (!u->description) {
 161                 r = unit_set_description(u, n->name);
 162                 if (r < 0)
 163                         return r;
 164         }
 165
 166         if (n->activating) {
 167                 if (!UNIT_DEREF(n->service)) {
 168                         Unit *x;
 169
 170                         r = unit_load_related_unit(u, ".service", &x);
 171                         if (r < 0)
 172                                 return r;
 173
 174                         unit_ref_set(&n->service, x);
 175                 }
 176
 177                 r = unit_add_two_dependencies(u, UNIT_BEFORE, UNIT_TRIGGERS, UNIT_DEREF(n->service), true);
 178                 if (r < 0)
 179                         return r;
 180         }
 181
 182         if (u->default_dependencies) {
 183                 r = busname_add_default_default_dependencies(n);
 184                 if (r < 0)
 185                         return r;
 186         }
 187
 188         return 0;
 189 }
 190
 191 static int busname_verify(BusName *n) {
 192         char *e;
 193
 194         assert(n);
 195
 196         if (UNIT(n)->load_state != UNIT_LOADED)
 197                 return 0;
 198
 199         if (!service_name_is_valid(n->name)) {
 200                 log_error_unit(UNIT(n)->id, "%s's Name= setting is not a valid service name Refusing.", UNIT(n)->id);
 201                 return -EINVAL;
 202         }
 203
 204         e = strappenda(n->name, ".busname");
 205         if (!unit_has_name(UNIT(n), e)) {
 206                 log_error_unit(UNIT(n)->id, "%s's Name= setting doesn't match unit name. Refusing.", UNIT(n)->id);
 207                 return -EINVAL;
 208         }
 209
 210         return 0;
 211 }
 212
 213 static int busname_load(Unit *u) {
 214         BusName *n = BUSNAME(u);
 215         int r;
 216
 217         assert(u);
 218         assert(u->load_state == UNIT_STUB);
 219
 220         r = unit_load_fragment_and_dropin(u);
 221         if (r < 0)
 222                 return r;
 223
 224         if (u->load_state == UNIT_LOADED) {
 225                 /* This is a new unit? Then let's add in some extras */
 226                 r = busname_add_extras(n);
 227                 if (r < 0)
 228                         return r;
 229         }
 230
 231         return busname_verify(n);
 232 }
 233
 234 static void busname_dump(Unit *u, FILE *f, const char *prefix) {
 235         BusName *n = BUSNAME(u);
 236
 237         assert(n);
 238         assert(f);
 239
 240         fprintf(f,
 241                 "%sBus Name State: %s\n"
 242                 "%sResult: %s\n"
 243                 "%sName: %s\n"
 244                 "%sActivating: %s\n"
 245                 "%sAccept FD: %s\n",
 246                 prefix, busname_state_to_string(n->state),
 247                 prefix, busname_result_to_string(n->result),
 248                 prefix, n->name,
 249                 prefix, yes_no(n->activating),
 250                 prefix, yes_no(n->accept_fd));
 251
 252         if (n->control_pid > 0)
 253                 fprintf(f,
 254                         "%sControl PID: "PID_FMT"\n",
 255                         prefix, n->control_pid);
 256 }
 257
 258 static void busname_unwatch_fd(BusName *n) {
 259         int r;
 260
 261         assert(n);
 262
 263         if (!n->starter_event_source)
 264                 return;
 265
 266         r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_OFF);
 267         if (r < 0)
 268                 log_debug_unit(UNIT(n)->id, "Failed to disable event source.");
 269 }
 270
 271 static int busname_watch_fd(BusName *n) {
 272         int r;
 273
 274         assert(n);
 275
 276         if (n->starter_fd < 0)
 277                 return 0;
 278
 279         if (n->starter_event_source)
 280                 r = sd_event_source_set_enabled(n->starter_event_source, SD_EVENT_ON);
 281         else
 282                 r = sd_event_add_io(UNIT(n)->manager->event, &n->starter_event_source, n->starter_fd, EPOLLIN, busname_dispatch_io, n);
 283         if (r < 0) {
 284                 log_warning_unit(UNIT(n)->id, "Failed to watch starter fd: %s", strerror(-r));
 285                 busname_unwatch_fd(n);
 286                 return r;
 287         }
 288
 289         return 0;
 290 }
 291
 292 static int busname_open_fd(BusName *n) {
 293         assert(n);
 294
 295         if (n->starter_fd >= 0)
 296                 return 0;
 297
 298         n->starter_fd = bus_kernel_open_bus_fd(UNIT(n)->manager->running_as == SYSTEMD_SYSTEM ? "system" : "user");
 299         if (n->starter_fd < 0) {
 300                 log_warning_unit(UNIT(n)->id, "Failed to create starter fd: %s", strerror(-n->starter_fd));
 301                 return n->starter_fd;
 302         }
 303
 304         return 0;
 305 }
 306
 307 static void busname_set_state(BusName *n, BusNameState state) {
 308         BusNameState old_state;
 309         assert(n);
 310
 311         old_state = n->state;
 312         n->state = state;
 313
 314         if (!IN_SET(state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 315                 n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 316                 busname_unwatch_control_pid(n);
 317         }
 318
 319         if (state != BUSNAME_LISTENING)
 320                 busname_unwatch_fd(n);
 321
 322         if (!IN_SET(state, BUSNAME_LISTENING, BUSNAME_MAKING, BUSNAME_REGISTERED, BUSNAME_RUNNING))
 323                 busname_close_fd(n);
 324
 325         if (state != old_state)
 326                 log_debug_unit(UNIT(n)->id, "%s changed %s -> %s",
 327                                UNIT(n)->id, busname_state_to_string(old_state), busname_state_to_string(state));
 328
 329         unit_notify(UNIT(n), state_translation_table[old_state], state_translation_table[state], true);
 330 }
 331
 332 static int busname_coldplug(Unit *u) {
 333         BusName *n = BUSNAME(u);
 334         int r;
 335
 336         assert(n);
 337         assert(n->state == BUSNAME_DEAD);
 338
 339         if (n->deserialized_state == n->state)
 340                 return 0;
 341
 342         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_SIGTERM, BUSNAME_SIGKILL)) {
 343
 344                 if (n->control_pid <= 0)
 345                         return -EBADMSG;
 346
 347                 r = unit_watch_pid(UNIT(n), n->control_pid);
 348                 if (r < 0)
 349                         return r;
 350
 351                 r = busname_arm_timer(n);
 352                 if (r < 0)
 353                         return r;
 354         }
 355
 356         if (IN_SET(n->deserialized_state, BUSNAME_MAKING, BUSNAME_LISTENING, BUSNAME_REGISTERED, BUSNAME_RUNNING)) {
 357                 r = busname_open_fd(n);
 358                 if (r < 0)
 359                         return r;
 360         }
 361
 362         if (n->deserialized_state == BUSNAME_LISTENING) {
 363                 r = busname_watch_fd(n);
 364                 if (r < 0)
 365                         return r;
 366         }
 367
 368         busname_set_state(n, n->deserialized_state);
 369         return 0;
 370 }
 371
 372 static int busname_make_starter(BusName *n, pid_t *_pid) {
 373         pid_t pid;
 374         int r;
 375
 376         r = busname_arm_timer(n);
 377         if (r < 0)
 378                 goto fail;
 379
 380         /* We have to resolve the user/group names out-of-process,
 381          * hence let's fork here. It's messy, but well, what can we
 382          * do? */
 383
 384         pid = fork();
 385         if (pid < 0)
 386                 return -errno;
 387
 388         if (pid == 0) {
 389                 int ret;
 390
 391                 default_signals(SIGNALS_CRASH_HANDLER, SIGNALS_IGNORE, -1);
 392                 ignore_signals(SIGPIPE, -1);
 393                 log_forget_fds();
 394
 395                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, n->policy, n->policy_world);
 396                 if (r < 0) {
 397                         ret = EXIT_MAKE_STARTER;
 398                         goto fail_child;
 399                 }
 400
 401                 _exit(0);
 402
 403         fail_child:
 404                 log_open();
 405                 log_error("Failed to create starter connection at step %s: %s", exit_status_to_string(ret, EXIT_STATUS_SYSTEMD), strerror(-r));
 406
 407                 _exit(ret);
 408         }
 409
 410         r = unit_watch_pid(UNIT(n), pid);
 411         if (r < 0)
 412                 goto fail;
 413
 414         *_pid = pid;
 415         return 0;
 416
 417 fail:
 418         n->timer_event_source = sd_event_source_unref(n->timer_event_source);
 419         return r;
 420 }
 421
 422 static void busname_enter_dead(BusName *n, BusNameResult f) {
 423         assert(n);
 424
 425         if (f != BUSNAME_SUCCESS)
 426                 n->result = f;
 427
 428         busname_set_state(n, n->result != BUSNAME_SUCCESS ? BUSNAME_FAILED : BUSNAME_DEAD);
 429 }
 430
 431 static void busname_enter_signal(BusName *n, BusNameState state, BusNameResult f) {
 432         KillContext kill_context = {};
 433         int r;
 434
 435         assert(n);
 436
 437         if (f != BUSNAME_SUCCESS)
 438                 n->result = f;
 439
 440         kill_context_init(&kill_context);
 441
 442         r = unit_kill_context(UNIT(n),
 443                               &kill_context,
 444                               state != BUSNAME_SIGTERM,
 445                               -1,
 446                               n->control_pid,
 447                               false);
 448         if (r < 0) {
 449                 log_warning_unit(UNIT(n)->id, "%s failed to kill control process: %s", UNIT(n)->id, strerror(-r));
 450                 goto fail;
 451         }
 452
 453         if (r > 0) {
 454                 r = busname_arm_timer(n);
 455                 if (r < 0) {
 456                         log_warning_unit(UNIT(n)->id, "%s failed to arm timer: %s", UNIT(n)->id, strerror(-r));
 457                         goto fail;
 458                 }
 459
 460                 busname_set_state(n, state);
 461         } else if (state == BUSNAME_SIGTERM)
 462                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_SUCCESS);
 463         else
 464                 busname_enter_dead(n, BUSNAME_SUCCESS);
 465
 466         return;
 467
 468 fail:
 469         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 470 }
 471
 472 static void busname_enter_listening(BusName *n) {
 473         int r;
 474
 475         assert(n);
 476
 477         if (n->activating) {
 478                 r = busname_watch_fd(n);
 479                 if (r < 0) {
 480                         log_warning_unit(UNIT(n)->id, "%s failed to watch names: %s", UNIT(n)->id, strerror(-r));
 481                         goto fail;
 482                 }
 483
 484                 busname_set_state(n, BUSNAME_LISTENING);
 485         } else
 486                 busname_set_state(n, BUSNAME_REGISTERED);
 487
 488         return;
 489
 490 fail:
 491         busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_RESOURCES);
 492 }
 493
 494 static void busname_enter_making(BusName *n) {
 495         int r;
 496
 497         assert(n);
 498
 499         r = busname_open_fd(n);
 500         if (r < 0)
 501                 goto fail;
 502
 503         if (n->policy) {
 504                 /* If there is a policy, we need to resolve user/group
 505                  * names, which we can't do from PID1, hence let's
 506                  * fork. */
 507                 busname_unwatch_control_pid(n);
 508
 509                 r = busname_make_starter(n, &n->control_pid);
 510                 if (r < 0) {
 511                         log_warning_unit(UNIT(n)->id, "%s failed to fork 'making' task: %s", UNIT(n)->id, strerror(-r));
 512                         goto fail;
 513                 }
 514
 515                 busname_set_state(n, BUSNAME_MAKING);
 516         } else {
 517                 /* If there is no policy, we can do everything
 518                  * directly from PID 1, hence do so. */
 519
 520                 r = bus_kernel_make_starter(n->starter_fd, n->name, n->activating, n->accept_fd, NULL, n->policy_world);
 521                 if (r < 0) {
 522                         log_warning_unit(UNIT(n)->id, "%s failed to make starter: %s", UNIT(n)->id, strerror(-r));
 523                         goto fail;
 524                 }
 525
 526                 busname_enter_listening(n);
 527         }
 528
 529         return;
 530
 531 fail:
 532         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 533 }
 534
 535 static void busname_enter_running(BusName *n) {
 536         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 537         bool pending = false;
 538         Unit *other;
 539         Iterator i;
 540         int r;
 541
 542         assert(n);
 543
 544         if (!n->activating)
 545                 return;
 546
 547         /* We don't take conenctions anymore if we are supposed to
 548          * shut down anyway */
 549
 550         if (unit_stop_pending(UNIT(n))) {
 551                 log_debug_unit(UNIT(n)->id, "Suppressing activation request on %s since unit stop is scheduled.", UNIT(n)->id);
 552
 553                 /* Flush all queued activation reqeuest by closing and reopening the connection */
 554                 bus_kernel_drop_one(n->starter_fd);
 555
 556                 busname_enter_listening(n);
 557                 return;
 558         }
 559
 560         /* If there's already a start pending don't bother to do
 561          * anything */
 562         SET_FOREACH(other, UNIT(n)->dependencies[UNIT_TRIGGERS], i)
 563                 if (unit_active_or_pending(other)) {
 564                         pending = true;
 565                         break;
 566                 }
 567
 568         if (!pending) {
 569                 r = manager_add_job(UNIT(n)->manager, JOB_START, UNIT_DEREF(n->service), JOB_REPLACE, true, &error, NULL);
 570                 if (r < 0)
 571                         goto fail;
 572         }
 573
 574         busname_set_state(n, BUSNAME_RUNNING);
 575         return;
 576
 577 fail:
 578         log_warning_unit(UNIT(n)->id, "%s failed to queue service startup job: %s", UNIT(n)->id, bus_error_message(&error, r));
 579         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 580 }
 581
 582 static int busname_start(Unit *u) {
 583         BusName *n = BUSNAME(u);
 584
 585         assert(n);
 586
 587         /* We cannot fulfill this request right now, try again later
 588          * please! */
 589         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 590                 return -EAGAIN;
 591
 592         /* Already on it! */
 593         if (n->state == BUSNAME_MAKING)
 594                 return 0;
 595
 596         if (n->activating && UNIT_ISSET(n->service)) {
 597                 Service *service;
 598
 599                 service = SERVICE(UNIT_DEREF(n->service));
 600
 601                 if (UNIT(service)->load_state != UNIT_LOADED) {
 602                         log_error_unit(u->id, "Bus service %s not loaded, refusing.", UNIT(service)->id);
 603                         return -ENOENT;
 604                 }
 605         }
 606
 607         assert(IN_SET(n->state, BUSNAME_DEAD, BUSNAME_FAILED));
 608
 609         n->result = BUSNAME_SUCCESS;
 610         busname_enter_making(n);
 611
 612         return 0;
 613 }
 614
 615 static int busname_stop(Unit *u) {
 616         BusName *n = BUSNAME(u);
 617
 618         assert(n);
 619
 620         /* Already on it */
 621         if (IN_SET(n->state, BUSNAME_SIGTERM, BUSNAME_SIGKILL))
 622                 return 0;
 623
 624         /* If there's already something running, we go directly into
 625          * kill mode. */
 626
 627         if (n->state == BUSNAME_MAKING) {
 628                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_SUCCESS);
 629                 return -EAGAIN;
 630         }
 631
 632         assert(IN_SET(n->state, BUSNAME_REGISTERED, BUSNAME_LISTENING, BUSNAME_RUNNING));
 633
 634         busname_enter_dead(n, BUSNAME_SUCCESS);
 635         return 0;
 636 }
 637
 638 static int busname_serialize(Unit *u, FILE *f, FDSet *fds) {
 639         BusName *n = BUSNAME(u);
 640
 641         assert(n);
 642         assert(f);
 643         assert(fds);
 644
 645         unit_serialize_item(u, f, "state", busname_state_to_string(n->state));
 646         unit_serialize_item(u, f, "result", busname_result_to_string(n->result));
 647
 648         if (n->control_pid > 0)
 649                 unit_serialize_item_format(u, f, "control-pid", PID_FMT, n->control_pid);
 650
 651         if (n->starter_fd >= 0) {
 652                 int copy;
 653
 654                 copy = fdset_put_dup(fds, n->starter_fd);
 655                 if (copy < 0)
 656                         return copy;
 657
 658                 unit_serialize_item_format(u, f, "starter-fd", "%i", copy);
 659         }
 660
 661         return 0;
 662 }
 663
 664 static int busname_deserialize_item(Unit *u, const char *key, const char *value, FDSet *fds) {
 665         BusName *n = BUSNAME(u);
 666
 667         assert(n);
 668         assert(key);
 669         assert(value);
 670
 671         if (streq(key, "state")) {
 672                 BusNameState state;
 673
 674                 state = busname_state_from_string(value);
 675                 if (state < 0)
 676                         log_debug_unit(u->id, "Failed to parse state value %s", value);
 677                 else
 678                         n->deserialized_state = state;
 679
 680         } else if (streq(key, "result")) {
 681                 BusNameResult f;
 682
 683                 f = busname_result_from_string(value);
 684                 if (f < 0)
 685                         log_debug_unit(u->id, "Failed to parse result value %s", value);
 686                 else if (f != BUSNAME_SUCCESS)
 687                         n->result = f;
 688
 689         } else if (streq(key, "control-pid")) {
 690                 pid_t pid;
 691
 692                 if (parse_pid(value, &pid) < 0)
 693                         log_debug_unit(u->id, "Failed to parse control-pid value %s", value);
 694                 else
 695                         n->control_pid = pid;
 696         } else if (streq(key, "starter-fd")) {
 697                 int fd;
 698
 699                 if (safe_atoi(value, &fd) < 0 || fd < 0 || !fdset_contains(fds, fd))
 700                         log_debug_unit(u->id, "Failed to parse starter fd value %s", value);
 701                 else {
 702                         safe_close(n->starter_fd);
 703                         n->starter_fd = fdset_remove(fds, fd);
 704                 }
 705         } else
 706                 log_debug_unit(u->id, "Unknown serialization key '%s'", key);
 707
 708         return 0;
 709 }
 710
 711 _pure_ static UnitActiveState busname_active_state(Unit *u) {
 712         assert(u);
 713
 714         return state_translation_table[BUSNAME(u)->state];
 715 }
 716
 717 _pure_ static const char *busname_sub_state_to_string(Unit *u) {
 718         assert(u);
 719
 720         return busname_state_to_string(BUSNAME(u)->state);
 721 }
 722
 723 static int busname_dispatch_io(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
 724         BusName *n = userdata;
 725
 726         assert(n);
 727         assert(fd >= 0);
 728
 729         if (n->state != BUSNAME_LISTENING)
 730                 return 0;
 731
 732         log_debug_unit(UNIT(n)->id, "Activation request on %s", UNIT(n)->id);
 733
 734         if (revents != EPOLLIN) {
 735                 log_error_unit(UNIT(n)->id, "%s: Got unexpected poll event (0x%x) on starter fd.",
 736                                UNIT(n)->id, revents);
 737                 goto fail;
 738         }
 739
 740         busname_enter_running(n);
 741         return 0;
 742 fail:
 743
 744         busname_enter_dead(n, BUSNAME_FAILURE_RESOURCES);
 745         return 0;
 746 }
 747
 748 static void busname_sigchld_event(Unit *u, pid_t pid, int code, int status) {
 749         BusName *n = BUSNAME(u);
 750         BusNameResult f;
 751
 752         assert(n);
 753         assert(pid >= 0);
 754
 755         if (pid != n->control_pid)
 756                 return;
 757
 758         n->control_pid = 0;
 759
 760         if (is_clean_exit(code, status, NULL))
 761                 f = BUSNAME_SUCCESS;
 762         else if (code == CLD_EXITED)
 763                 f = BUSNAME_FAILURE_EXIT_CODE;
 764         else if (code == CLD_KILLED)
 765                 f = BUSNAME_FAILURE_SIGNAL;
 766         else if (code == CLD_DUMPED)
 767                 f = BUSNAME_FAILURE_CORE_DUMP;
 768         else
 769                 assert_not_reached("Unknown sigchld code");
 770
 771         log_full_unit(f == BUSNAME_SUCCESS ? LOG_DEBUG : LOG_NOTICE,
 772                       u->id, "%s control process exited, code=%s status=%i",
 773                       u->id, sigchld_code_to_string(code), status);
 774
 775         if (f != BUSNAME_SUCCESS)
 776                 n->result = f;
 777
 778         switch (n->state) {
 779
 780         case BUSNAME_MAKING:
 781                 if (f == BUSNAME_SUCCESS)
 782                         busname_enter_listening(n);
 783                 else
 784                         busname_enter_signal(n, BUSNAME_SIGTERM, f);
 785                 break;
 786
 787         case BUSNAME_SIGTERM:
 788         case BUSNAME_SIGKILL:
 789                 busname_enter_dead(n, f);
 790                 break;
 791
 792         default:
 793                 assert_not_reached("Uh, control process died at wrong time.");
 794         }
 795
 796         /* Notify clients about changed exit status */
 797         unit_add_to_dbus_queue(u);
 798 }
 799
 800 static int busname_dispatch_timer(sd_event_source *source, usec_t usec, void *userdata) {
 801         BusName *n = BUSNAME(userdata);
 802
 803         assert(n);
 804         assert(n->timer_event_source == source);
 805
 806         switch (n->state) {
 807
 808         case BUSNAME_MAKING:
 809                 log_warning_unit(UNIT(n)->id, "%s making timed out. Terminating.", UNIT(n)->id);
 810                 busname_enter_signal(n, BUSNAME_SIGTERM, BUSNAME_FAILURE_TIMEOUT);
 811                 break;
 812
 813         case BUSNAME_SIGTERM:
 814                 log_warning_unit(UNIT(n)->id, "%s stopping timed out. Killing.", UNIT(n)->id);
 815                 busname_enter_signal(n, BUSNAME_SIGKILL, BUSNAME_FAILURE_TIMEOUT);
 816                 break;
 817
 818         case BUSNAME_SIGKILL:
 819                 log_warning_unit(UNIT(n)->id, "%s still around after SIGKILL. Ignoring.", UNIT(n)->id);
 820                 busname_enter_dead(n, BUSNAME_FAILURE_TIMEOUT);
 821                 break;
 822
 823         default:
 824                 assert_not_reached("Timeout at wrong time.");
 825         }
 826
 827         return 0;
 828 }
 829
 830 static void busname_reset_failed(Unit *u) {
 831         BusName *n = BUSNAME(u);
 832
 833         assert(n);
 834
 835         if (n->state == BUSNAME_FAILED)
 836                 busname_set_state(n, BUSNAME_DEAD);
 837
 838         n->result = BUSNAME_SUCCESS;
 839 }
 840
 841 static void busname_trigger_notify(Unit *u, Unit *other) {
 842         BusName *n = BUSNAME(u);
 843         Service *s;
 844
 845         assert(n);
 846         assert(other);
 847
 848         if (!IN_SET(n->state, BUSNAME_RUNNING, BUSNAME_LISTENING))
 849                 return;
 850
 851         if (other->load_state != UNIT_LOADED || other->type != UNIT_SERVICE)
 852                 return;
 853
 854         s = SERVICE(other);
 855
 856         if (s->state == SERVICE_FAILED && s->result == SERVICE_FAILURE_START_LIMIT)
 857                 busname_enter_dead(n, BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT);
 858         else if (IN_SET(s->state,
 859                         SERVICE_DEAD, SERVICE_FAILED,
 860                         SERVICE_STOP, SERVICE_STOP_SIGTERM, SERVICE_STOP_SIGKILL,
 861                         SERVICE_STOP_POST, SERVICE_FINAL_SIGTERM, SERVICE_FINAL_SIGKILL,
 862                         SERVICE_AUTO_RESTART))
 863                 busname_enter_listening(n);
 864 }
 865
 866 static int busname_kill(Unit *u, KillWho who, int signo, sd_bus_error *error) {
 867         return unit_kill_common(u, who, signo, -1, BUSNAME(u)->control_pid, error);
 868 }
 869
 870 static int busname_get_timeout(Unit *u, uint64_t *timeout) {
 871         BusName *n = BUSNAME(u);
 872         int r;
 873
 874         if (!n->timer_event_source)
 875                 return 0;
 876
 877         r = sd_event_source_get_time(n->timer_event_source, timeout);
 878         if (r < 0)
 879                 return r;
 880
 881         return 1;
 882 }
 883
 884 static const char* const busname_state_table[_BUSNAME_STATE_MAX] = {
 885         [BUSNAME_DEAD] = "dead",
 886         [BUSNAME_MAKING] = "making",
 887         [BUSNAME_REGISTERED] = "registered",
 888         [BUSNAME_LISTENING] = "listening",
 889         [BUSNAME_RUNNING] = "running",
 890         [BUSNAME_SIGTERM] = "sigterm",
 891         [BUSNAME_SIGKILL] = "sigkill",
 892         [BUSNAME_FAILED] = "failed",
 893 };
 894
 895 DEFINE_STRING_TABLE_LOOKUP(busname_state, BusNameState);
 896
 897 static const char* const busname_result_table[_BUSNAME_RESULT_MAX] = {
 898         [BUSNAME_SUCCESS] = "success",
 899         [BUSNAME_FAILURE_RESOURCES] = "resources",
 900         [BUSNAME_FAILURE_TIMEOUT] = "timeout",
 901         [BUSNAME_FAILURE_EXIT_CODE] = "exit-code",
 902         [BUSNAME_FAILURE_SIGNAL] = "signal",
 903         [BUSNAME_FAILURE_CORE_DUMP] = "core-dump",
 904         [BUSNAME_FAILURE_SERVICE_FAILED_PERMANENT] = "service-failed-permanent",
 905 };
 906
 907 DEFINE_STRING_TABLE_LOOKUP(busname_result, BusNameResult);
 908
 909 static const char* const busname_policy_access_table[_BUSNAME_POLICY_ACCESS_MAX] = {
 910         [BUSNAME_POLICY_ACCESS_SEE] = "see",
 911         [BUSNAME_POLICY_ACCESS_TALK] = "talk",
 912         [BUSNAME_POLICY_ACCESS_OWN] = "own",
 913 };
 914
 915 DEFINE_STRING_TABLE_LOOKUP(busname_policy_access, BusNamePolicyAccess);
 916
 917 const UnitVTable busname_vtable = {
 918         .object_size = sizeof(BusName),
 919
 920         .sections =
 921                 "Unit\0"
 922                 "BusName\0"
 923                 "Install\0",
 924         .private_section = "BusName",
 925
 926         .init = busname_init,
 927         .done = busname_done,
 928         .load = busname_load,
 929
 930         .coldplug = busname_coldplug,
 931
 932         .dump = busname_dump,
 933
 934         .start = busname_start,
 935         .stop = busname_stop,
 936
 937         .kill = busname_kill,
 938
 939         .get_timeout = busname_get_timeout,
 940
 941         .serialize = busname_serialize,
 942         .deserialize_item = busname_deserialize_item,
 943
 944         .active_state = busname_active_state,
 945         .sub_state_to_string = busname_sub_state_to_string,
 946
 947         .sigchld_event = busname_sigchld_event,
 948
 949         .trigger_notify = busname_trigger_notify,
 950
 951         .reset_failed = busname_reset_failed,
 952
 953         .bus_interface = "org.freedesktop.systemd1.BusName",
 954         .bus_vtable = bus_busname_vtable,
 955
 956         .status_message_formats = {
 957                 .finished_start_job = {
 958                         [JOB_DONE]       = "Listening on %s.",
 959                         [JOB_FAILED]     = "Failed to listen on %s.",
 960                         [JOB_DEPENDENCY] = "Dependency failed for %s.",
 961                         [JOB_TIMEOUT]    = "Timed out starting %s.",
 962                 },
 963                 .finished_stop_job = {
 964                         [JOB_DONE]       = "Closed %s.",
 965                         [JOB_FAILED]     = "Failed stopping %s.",
 966                         [JOB_TIMEOUT]    = "Timed out stopping %s.",
 967                 },
 968         },
 969 };