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