src/core/dbus-manager.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <sys/prctl.h>
   5 #include <sys/statvfs.h>
   6 #include <unistd.h>
   7
   8 #include "alloc-util.h"
   9 #include "architecture.h"
  10 #include "build.h"
  11 #include "bus-common-errors.h"
  12 #include "bus-get-properties.h"
  13 #include "bus-log-control-api.h"
  14 #include "bus-util.h"
  15 #include "chase.h"
  16 #include "confidential-virt.h"
  17 #include "data-fd-util.h"
  18 #include "dbus-cgroup.h"
  19 #include "dbus-execute.h"
  20 #include "dbus-job.h"
  21 #include "dbus-manager.h"
  22 #include "dbus-scope.h"
  23 #include "dbus-service.h"
  24 #include "dbus-unit.h"
  25 #include "dbus.h"
  26 #include "env-util.h"
  27 #include "fd-util.h"
  28 #include "fileio.h"
  29 #include "format-util.h"
  30 #include "initrd-util.h"
  31 #include "install.h"
  32 #include "log.h"
  33 #include "manager-dump.h"
  34 #include "os-util.h"
  35 #include "parse-util.h"
  36 #include "path-util.h"
  37 #include "process-util.h"
  38 #include "selinux-access.h"
  39 #include "stat-util.h"
  40 #include "string-util.h"
  41 #include "strv.h"
  42 #include "syslog-util.h"
  43 #include "user-util.h"
  44 #include "version.h"
  45 #include "virt.h"
  46 #include "watchdog.h"
  47
  48 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state
  49  * there, and if we can't we'll fail badly. */
  50 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
  51
  52 static UnitFileFlags unit_file_bools_to_flags(bool runtime, bool force) {
  53         return (runtime ? UNIT_FILE_RUNTIME : 0) |
  54                (force   ? UNIT_FILE_FORCE   : 0);
  55 }
  56
  57 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_oom_policy, oom_policy, OOMPolicy);
  58 BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_emergency_action, emergency_action, EmergencyAction);
  59
  60 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version, "s", GIT_VERSION);
  61 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features, "s", systemd_features);
  62 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture, "s", architecture_to_string(uname_architecture()));
  63 static BUS_DEFINE_PROPERTY_GET2(property_get_system_state, "s", Manager, manager_state, manager_state_to_string);
  64 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec, "t", (uint64_t) prctl(PR_GET_TIMERSLACK));
  65 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "u", Hashmap *, hashmap_size);
  66 static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size, "u", Set *, set_size);
  67 static BUS_DEFINE_PROPERTY_GET(property_get_default_timeout_abort_usec, "t", Manager, manager_default_timeout_abort_usec);
  68 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_device, "s", watchdog_get_device());
  69 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_realtime, "t", watchdog_get_last_ping(CLOCK_REALTIME));
  70 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_monotonic, "t", watchdog_get_last_ping(CLOCK_MONOTONIC));
  71 static BUS_DEFINE_PROPERTY_GET(property_get_progress, "d", Manager, manager_get_progress);
  72
  73 static int property_get_virtualization(
  74                 sd_bus *bus,
  75                 const char *path,
  76                 const char *interface,
  77                 const char *property,
  78                 sd_bus_message *reply,
  79                 void *userdata,
  80                 sd_bus_error *error) {
  81
  82         Virtualization v;
  83
  84         assert(bus);
  85         assert(reply);
  86
  87         v = detect_virtualization();
  88
  89         /* Make sure to return the empty string when we detect no virtualization, as that is the API.
  90          *
  91          * https://github.com/systemd/systemd/issues/1423
  92          */
  93
  94         return sd_bus_message_append(
  95                         reply, "s",
  96                         v == VIRTUALIZATION_NONE ? NULL : virtualization_to_string(v));
  97 }
  98
  99 static int property_get_confidential_virtualization(
 100                 sd_bus *bus,
 101                 const char *path,
 102                 const char *interface,
 103                 const char *property,
 104                 sd_bus_message *reply,
 105                 void *userdata,
 106                 sd_bus_error *error) {
 107
 108         ConfidentialVirtualization v;
 109
 110         assert(bus);
 111         assert(reply);
 112
 113         v = detect_confidential_virtualization();
 114
 115         return sd_bus_message_append(
 116                         reply, "s",
 117                         v <= 0 ? NULL : confidential_virtualization_to_string(v));
 118 }
 119
 120 static int property_get_tainted(
 121                 sd_bus *bus,
 122                 const char *path,
 123                 const char *interface,
 124                 const char *property,
 125                 sd_bus_message *reply,
 126                 void *userdata,
 127                 sd_bus_error *error) {
 128
 129         _cleanup_free_ char *s = NULL;
 130         Manager *m = ASSERT_PTR(userdata);
 131
 132         assert(bus);
 133         assert(reply);
 134
 135         s = manager_taint_string(m);
 136         if (!s)
 137                 return log_oom();
 138
 139         return sd_bus_message_append(reply, "s", s);
 140 }
 141
 142 static int property_set_log_target(
 143                 sd_bus *bus,
 144                 const char *path,
 145                 const char *interface,
 146                 const char *property,
 147                 sd_bus_message *value,
 148                 void *userdata,
 149                 sd_bus_error *error) {
 150
 151         Manager *m = userdata;
 152         const char *t;
 153         int r;
 154
 155         assert(bus);
 156         assert(value);
 157
 158         r = sd_bus_message_read(value, "s", &t);
 159         if (r < 0)
 160                 return r;
 161
 162         if (isempty(t))
 163                 manager_restore_original_log_target(m);
 164         else {
 165                 LogTarget target;
 166
 167                 target = log_target_from_string(t);
 168                 if (target < 0)
 169                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log target '%s'", t);
 170
 171                 manager_override_log_target(m, target);
 172         }
 173
 174         return 0;
 175 }
 176
 177 static int property_set_log_level(
 178                 sd_bus *bus,
 179                 const char *path,
 180                 const char *interface,
 181                 const char *property,
 182                 sd_bus_message *value,
 183                 void *userdata,
 184                 sd_bus_error *error) {
 185
 186         Manager *m = userdata;
 187         const char *t;
 188         int r;
 189
 190         assert(bus);
 191         assert(value);
 192
 193         r = sd_bus_message_read(value, "s", &t);
 194         if (r < 0)
 195                 return r;
 196
 197         if (isempty(t))
 198                 manager_restore_original_log_level(m);
 199         else {
 200                 int level;
 201
 202                 level = log_level_from_string(t);
 203                 if (level < 0)
 204                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
 205
 206                 manager_override_log_level(m, level);
 207         }
 208
 209         return 0;
 210 }
 211
 212 static int property_get_environment(
 213                 sd_bus *bus,
 214                 const char *path,
 215                 const char *interface,
 216                 const char *property,
 217                 sd_bus_message *reply,
 218                 void *userdata,
 219                 sd_bus_error *error) {
 220
 221         _cleanup_strv_free_ char **l = NULL;
 222         Manager *m = ASSERT_PTR(userdata);
 223         int r;
 224
 225         assert(bus);
 226         assert(reply);
 227
 228         r = manager_get_effective_environment(m, &l);
 229         if (r < 0)
 230                 return r;
 231
 232         return sd_bus_message_append_strv(reply, l);
 233 }
 234
 235 static int property_get_show_status(
 236                 sd_bus *bus,
 237                 const char *path,
 238                 const char *interface,
 239                 const char *property,
 240                 sd_bus_message *reply,
 241                 void *userdata,
 242                 sd_bus_error *error) {
 243
 244         Manager *m = ASSERT_PTR(userdata);
 245
 246         assert(bus);
 247         assert(reply);
 248
 249         return sd_bus_message_append(reply, "b", manager_get_show_status_on(m));
 250 }
 251
 252 static int property_get_runtime_watchdog(
 253                 sd_bus *bus,
 254                 const char *path,
 255                 const char *interface,
 256                 const char *property,
 257                 sd_bus_message *reply,
 258                 void *userdata,
 259                 sd_bus_error *error) {
 260
 261         Manager *m = ASSERT_PTR(userdata);
 262
 263         assert(bus);
 264         assert(reply);
 265
 266         return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_RUNTIME));
 267 }
 268
 269 static int property_get_pretimeout_watchdog(
 270                 sd_bus *bus,
 271                 const char *path,
 272                 const char *interface,
 273                 const char *property,
 274                 sd_bus_message *reply,
 275                 void *userdata,
 276                 sd_bus_error *error) {
 277
 278         Manager *m = ASSERT_PTR(userdata);
 279
 280         assert(bus);
 281         assert(reply);
 282
 283         return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_PRETIMEOUT));
 284 }
 285
 286 static int property_get_pretimeout_watchdog_governor(
 287                 sd_bus *bus,
 288                 const char *path,
 289                 const char *interface,
 290                 const char *property,
 291                 sd_bus_message *reply,
 292                 void *userdata,
 293                 sd_bus_error *error) {
 294
 295         Manager *m = ASSERT_PTR(userdata);
 296
 297         assert(bus);
 298         assert(reply);
 299
 300         return sd_bus_message_append(reply, "s", m->watchdog_pretimeout_governor);
 301 }
 302
 303 static int property_get_reboot_watchdog(
 304                 sd_bus *bus,
 305                 const char *path,
 306                 const char *interface,
 307                 const char *property,
 308                 sd_bus_message *reply,
 309                 void *userdata,
 310                 sd_bus_error *error) {
 311
 312         Manager *m = ASSERT_PTR(userdata);
 313
 314         assert(bus);
 315         assert(reply);
 316
 317         return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_REBOOT));
 318 }
 319
 320 static int property_get_kexec_watchdog(
 321                 sd_bus *bus,
 322                 const char *path,
 323                 const char *interface,
 324                 const char *property,
 325                 sd_bus_message *reply,
 326                 void *userdata,
 327                 sd_bus_error *error) {
 328
 329         Manager *m = ASSERT_PTR(userdata);
 330
 331         assert(bus);
 332         assert(reply);
 333
 334         return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_KEXEC));
 335 }
 336
 337 static int property_set_watchdog(Manager *m, WatchdogType type, sd_bus_message *value) {
 338         usec_t timeout;
 339         int r;
 340
 341         assert(m);
 342         assert(value);
 343
 344         assert_cc(sizeof(usec_t) == sizeof(uint64_t));
 345
 346         r = sd_bus_message_read(value, "t", &timeout);
 347         if (r < 0)
 348                 return r;
 349
 350         manager_override_watchdog(m, type, timeout);
 351         return 0;
 352 }
 353
 354 static int property_set_runtime_watchdog(
 355                 sd_bus *bus,
 356                 const char *path,
 357                 const char *interface,
 358                 const char *property,
 359                 sd_bus_message *value,
 360                 void *userdata,
 361                 sd_bus_error *error) {
 362
 363         return property_set_watchdog(userdata, WATCHDOG_RUNTIME, value);
 364 }
 365
 366 static int property_set_pretimeout_watchdog(
 367                 sd_bus *bus,
 368                 const char *path,
 369                 const char *interface,
 370                 const char *property,
 371                 sd_bus_message *value,
 372                 void *userdata,
 373                 sd_bus_error *error) {
 374
 375         return property_set_watchdog(userdata, WATCHDOG_PRETIMEOUT, value);
 376 }
 377
 378 static int property_set_pretimeout_watchdog_governor(
 379                 sd_bus *bus,
 380                 const char *path,
 381                 const char *interface,
 382                 const char *property,
 383                 sd_bus_message *value,
 384                 void *userdata,
 385                 sd_bus_error *error) {
 386
 387         Manager *m = ASSERT_PTR(userdata);
 388         char *governor;
 389         int r;
 390
 391         r = sd_bus_message_read(value, "s", &governor);
 392         if (r < 0)
 393                 return r;
 394         if (!string_is_safe(governor))
 395                 return -EINVAL;
 396
 397         return manager_override_watchdog_pretimeout_governor(m, governor);
 398 }
 399
 400 static int property_set_reboot_watchdog(
 401                 sd_bus *bus,
 402                 const char *path,
 403                 const char *interface,
 404                 const char *property,
 405                 sd_bus_message *value,
 406                 void *userdata,
 407                 sd_bus_error *error) {
 408
 409         return property_set_watchdog(userdata, WATCHDOG_REBOOT, value);
 410 }
 411
 412 static int property_set_kexec_watchdog(
 413                 sd_bus *bus,
 414                 const char *path,
 415                 const char *interface,
 416                 const char *property,
 417                 sd_bus_message *value,
 418                 void *userdata,
 419                 sd_bus_error *error) {
 420
 421         _unused_ Manager *m = ASSERT_PTR(userdata);
 422
 423         assert(bus);
 424         assert(value);
 425
 426         return property_set_watchdog(userdata, WATCHDOG_KEXEC, value);
 427 }
 428
 429 static int property_get_oom_score_adjust(
 430                 sd_bus *bus,
 431                 const char *path,
 432                 const char *interface,
 433                 const char *property,
 434                 sd_bus_message *reply,
 435                 void *userdata,
 436                 sd_bus_error *error) {
 437
 438         Manager *m = ASSERT_PTR(userdata);
 439         int r, n;
 440
 441         assert(bus);
 442         assert(reply);
 443
 444         if (m->defaults.oom_score_adjust_set)
 445                 n = m->defaults.oom_score_adjust;
 446         else {
 447                 n = 0;
 448                 r = get_oom_score_adjust(&n);
 449                 if (r < 0)
 450                         log_debug_errno(r, "Failed to read current OOM score adjustment value, ignoring: %m");
 451         }
 452
 453         return sd_bus_message_append(reply, "i", n);
 454 }
 455
 456 static int bus_get_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
 457         Unit *u;
 458         int r;
 459
 460         assert(m);
 461         assert(message);
 462         assert(ret_unit);
 463
 464         /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up
 465          * its sleeve: if the name is specified empty we use the client's unit. */
 466
 467         if (isempty(name)) {
 468                 _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 469
 470                 r = bus_query_sender_pidref(message, &pidref);
 471                 if (r < 0)
 472                         return r;
 473
 474                 u = manager_get_unit_by_pidref(m, &pidref);
 475                 if (!u)
 476                         return sd_bus_error_set(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
 477         } else {
 478                 u = manager_get_unit(m, name);
 479                 if (!u)
 480                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
 481         }
 482
 483         *ret_unit = u;
 484         return 0;
 485 }
 486
 487 static int bus_load_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
 488         assert(m);
 489         assert(message);
 490         assert(ret_unit);
 491
 492         /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
 493
 494         if (isempty(name))
 495                 return bus_get_unit_by_name(m, message, name, ret_unit, error);
 496
 497         return manager_load_unit(m, name, NULL, error, ret_unit);
 498 }
 499
 500 static int reply_unit_path(Unit *u, sd_bus_message *message, sd_bus_error *error) {
 501         _cleanup_free_ char *path = NULL;
 502         int r;
 503
 504         assert(u);
 505         assert(message);
 506
 507         r = mac_selinux_unit_access_check(u, message, "status", error);
 508         if (r < 0)
 509                 return r;
 510
 511         path = unit_dbus_path(u);
 512         if (!path)
 513                 return log_oom();
 514
 515         return sd_bus_reply_method_return(message, "o", path);
 516 }
 517
 518 static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 519         Manager *m = ASSERT_PTR(userdata);
 520         const char *name;
 521         Unit *u;
 522         int r;
 523
 524         assert(message);
 525
 526         /* Anyone can call this method */
 527
 528         r = sd_bus_message_read(message, "s", &name);
 529         if (r < 0)
 530                 return r;
 531
 532         r = bus_get_unit_by_name(m, message, name, &u, error);
 533         if (r < 0)
 534                 return r;
 535
 536         return reply_unit_path(u, message, error);
 537 }
 538
 539 static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 540         Manager *m = ASSERT_PTR(userdata);
 541         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 542         Unit *u;
 543         int r;
 544
 545         assert(message);
 546
 547         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 548
 549         /* Anyone can call this method */
 550
 551         r = sd_bus_message_read(message, "u", &pidref.pid);
 552         if (r < 0)
 553                 return r;
 554         if (pidref.pid < 0)
 555                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PID " PID_FMT, pidref.pid);
 556         if (pidref.pid == 0) {
 557                 r = bus_query_sender_pidref(message, &pidref);
 558                 if (r < 0)
 559                         return r;
 560         }
 561
 562         u = manager_get_unit_by_pidref(m, &pidref);
 563         if (!u)
 564                 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pidref.pid);
 565
 566         return reply_unit_path(u, message, error);
 567 }
 568
 569 static int method_get_unit_by_invocation_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 570         _cleanup_free_ char *path = NULL;
 571         Manager *m = ASSERT_PTR(userdata);
 572         sd_id128_t id;
 573         Unit *u;
 574         int r;
 575
 576         assert(message);
 577
 578         /* Anyone can call this method */
 579
 580         if (bus_message_read_id128(message, &id) < 0)
 581                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid invocation ID");
 582
 583         if (sd_id128_is_null(id)) {
 584                 _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 585
 586                 r = bus_query_sender_pidref(message, &pidref);
 587                 if (r < 0)
 588                         return r;
 589
 590                 u = manager_get_unit_by_pidref(m, &pidref);
 591                 if (!u)
 592                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
 593                                                  "Client " PID_FMT " not member of any unit.", pidref.pid);
 594         } else {
 595                 u = hashmap_get(m->units_by_invocation_id, &id);
 596                 if (!u)
 597                         return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(id));
 598         }
 599
 600         r = mac_selinux_unit_access_check(u, message, "status", error);
 601         if (r < 0)
 602                 return r;
 603
 604         /* So here's a special trick: the bus path we return actually references the unit by its invocation
 605          * ID instead of the unit name. This means it stays valid only as long as the invocation ID stays the
 606          * same. */
 607         path = unit_dbus_path_invocation_id(u);
 608         if (!path)
 609                 return -ENOMEM;
 610
 611         return sd_bus_reply_method_return(message, "o", path);
 612 }
 613
 614 static int method_get_unit_by_control_group(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 615         Manager *m = userdata;
 616         const char *cgroup;
 617         Unit *u;
 618         int r;
 619
 620         r = sd_bus_message_read(message, "s", &cgroup);
 621         if (r < 0)
 622                 return r;
 623
 624         u = manager_get_unit_by_cgroup(m, cgroup);
 625         if (!u)
 626                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
 627                                          "Control group '%s' is not valid or not managed by this instance",
 628                                          cgroup);
 629
 630         return reply_unit_path(u, message, error);
 631 }
 632
 633 static int method_get_unit_by_pidfd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 634         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 635         _cleanup_(pidref_done) PidRef pidref = PIDREF_NULL;
 636         Manager *m = ASSERT_PTR(userdata);
 637         _cleanup_free_ char *path = NULL;
 638         int r, pidfd;
 639         Unit *u;
 640
 641         assert(message);
 642
 643         r = sd_bus_message_read(message, "h", &pidfd);
 644         if (r < 0)
 645                 return r;
 646
 647         r = pidref_set_pidfd(&pidref, pidfd);
 648         if (r < 0)
 649                 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
 650
 651         u = manager_get_unit_by_pidref(m, &pidref);
 652         if (!u)
 653                 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pidref.pid);
 654
 655         r = mac_selinux_unit_access_check(u, message, "status", error);
 656         if (r < 0)
 657                 return r;
 658
 659         path = unit_dbus_path(u);
 660         if (!path)
 661                 return log_oom();
 662
 663         r = sd_bus_message_new_method_return(message, &reply);
 664         if (r < 0)
 665                 return r;
 666
 667         r = sd_bus_message_append(reply, "os", path, u->id);
 668         if (r < 0)
 669                 return r;
 670
 671         r = sd_bus_message_append_array(reply, 'y', u->invocation_id.bytes, sizeof(u->invocation_id.bytes));
 672         if (r < 0)
 673                 return r;
 674
 675         /* Double-check that the process is still alive and that the PID did not change before returning the
 676          * answer. */
 677         r = pidref_verify(&pidref);
 678         if (r == -ESRCH)
 679                 return sd_bus_error_setf(error,
 680                                          BUS_ERROR_NO_SUCH_PROCESS,
 681                                          "The PIDFD's PID "PID_FMT" changed during the lookup operation.",
 682                                          pidref.pid);
 683         if (r < 0)
 684                 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
 685
 686         return sd_bus_send(NULL, reply, NULL);
 687 }
 688
 689 static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 690         Manager *m = ASSERT_PTR(userdata);
 691         const char *name;
 692         Unit *u;
 693         int r;
 694
 695         assert(message);
 696
 697         /* Anyone can call this method */
 698
 699         r = sd_bus_message_read(message, "s", &name);
 700         if (r < 0)
 701                 return r;
 702
 703         r = bus_load_unit_by_name(m, message, name, &u, error);
 704         if (r < 0)
 705                 return r;
 706
 707         return reply_unit_path(u, message, error);
 708 }
 709
 710 static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
 711         const char *name;
 712         Unit *u;
 713         int r;
 714
 715         assert(message);
 716         assert(m);
 717
 718         r = sd_bus_message_read(message, "s", &name);
 719         if (r < 0)
 720                 return r;
 721
 722         r = manager_load_unit(m, name, NULL, error, &u);
 723         if (r < 0)
 724                 return r;
 725
 726         return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
 727 }
 728
 729 static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 730         return method_start_unit_generic(message, userdata, JOB_START, /* reload_if_possible = */ false, error);
 731 }
 732
 733 static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 734         return method_start_unit_generic(message, userdata, JOB_STOP, /* reload_if_possible = */ false, error);
 735 }
 736
 737 static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 738         return method_start_unit_generic(message, userdata, JOB_RELOAD, /* reload_if_possible = */ false, error);
 739 }
 740
 741 static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 742         return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ false, error);
 743 }
 744
 745 static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 746         return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ false, error);
 747 }
 748
 749 static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 750         return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ true, error);
 751 }
 752
 753 static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 754         return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ true, error);
 755 }
 756
 757 typedef enum GenericUnitOperationFlags {
 758         GENERIC_UNIT_LOAD            = 1 << 0, /* Load if the unit is not loaded yet */
 759         GENERIC_UNIT_VALIDATE_LOADED = 1 << 1, /* Verify unit is properly loaded before forwarding call */
 760 } GenericUnitOperationFlags;
 761
 762 static int method_generic_unit_operation(
 763                 sd_bus_message *message,
 764                 Manager *m,
 765                 sd_bus_error *error,
 766                 sd_bus_message_handler_t handler,
 767                 GenericUnitOperationFlags flags) {
 768
 769         const char *name;
 770         Unit *u;
 771         int r;
 772
 773         assert(message);
 774         assert(m);
 775         assert(handler);
 776
 777         /* Read the first argument from the command and pass the operation to the specified per-unit
 778          * method. */
 779
 780         r = sd_bus_message_read(message, "s", &name);
 781         if (r < 0)
 782                 return r;
 783
 784         if (!isempty(name) && FLAGS_SET(flags, GENERIC_UNIT_LOAD))
 785                 r = manager_load_unit(m, name, NULL, error, &u);
 786         else
 787                 r = bus_get_unit_by_name(m, message, name, &u, error);
 788         if (r < 0)
 789                 return r;
 790
 791         if (FLAGS_SET(flags, GENERIC_UNIT_VALIDATE_LOADED)) {
 792                 r = bus_unit_validate_load_state(u, error);
 793                 if (r < 0)
 794                         return r;
 795         }
 796
 797         return handler(message, u, error);
 798 }
 799
 800 static int method_enqueue_unit_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 801         /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
 802         return method_generic_unit_operation(message, userdata, error, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
 803 }
 804
 805 static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 806         Manager *m = ASSERT_PTR(userdata);
 807         const char *old_name;
 808         Unit *u;
 809         int r;
 810
 811         assert(message);
 812
 813         r = sd_bus_message_read(message, "s", &old_name);
 814         if (r < 0)
 815                 return r;
 816
 817         r = bus_get_unit_by_name(m, message, old_name, &u, error);
 818         if (r < 0)
 819                 return r;
 820         if (!u->job || u->job->type != JOB_START)
 821                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
 822
 823         return method_start_unit_generic(message, m, JOB_START, /* reload_if_possible = */ false, error);
 824 }
 825
 826 static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 827         /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
 828          * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
 829         return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill, 0);
 830 }
 831
 832 static int method_clean_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 833         /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
 834          * cleaned */
 835         return method_generic_unit_operation(message, userdata, error, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 836 }
 837
 838 static int method_freeze_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 839         return method_generic_unit_operation(message, userdata, error, bus_unit_method_freeze, 0);
 840 }
 841
 842 static int method_thaw_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 843         return method_generic_unit_operation(message, userdata, error, bus_unit_method_thaw, 0);
 844 }
 845
 846 static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 847         /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
 848          * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
 849         return method_generic_unit_operation(message, userdata, error, bus_unit_method_reset_failed, 0);
 850 }
 851
 852 static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 853         /* Only change properties on fully loaded units, and load them in order to set properties */
 854         return method_generic_unit_operation(message, userdata, error, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 855 }
 856
 857 static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 858         /* Only add mounts on fully loaded units */
 859         return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
 860 }
 861
 862 static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 863         /* Only add mounts on fully loaded units */
 864         return method_generic_unit_operation(message, userdata, error, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
 865 }
 866
 867 static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 868         /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
 869         return method_generic_unit_operation(message, userdata, error, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
 870 }
 871
 872 static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 873         /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
 874          * loaded unit there's no need to load the unit for unreffing it. */
 875         return method_generic_unit_operation(message, userdata, error, bus_unit_method_unref, 0);
 876 }
 877
 878 static int reply_unit_info(sd_bus_message *reply, Unit *u) {
 879         _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
 880         Unit *following;
 881
 882         following = unit_following(u);
 883
 884         unit_path = unit_dbus_path(u);
 885         if (!unit_path)
 886                 return -ENOMEM;
 887
 888         if (u->job) {
 889                 job_path = job_dbus_path(u->job);
 890                 if (!job_path)
 891                         return -ENOMEM;
 892         }
 893
 894         return sd_bus_message_append(
 895                         reply, "(ssssssouso)",
 896                         u->id,
 897                         unit_description(u),
 898                         unit_load_state_to_string(u->load_state),
 899                         unit_active_state_to_string(unit_active_state(u)),
 900                         unit_sub_state_to_string(u),
 901                         following ? following->id : "",
 902                         unit_path,
 903                         u->job ? u->job->id : 0,
 904                         u->job ? job_type_to_string(u->job->type) : "",
 905                         empty_to_root(job_path));
 906 }
 907
 908 static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 909         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 910         Manager *m = ASSERT_PTR(userdata);
 911         int r;
 912         _cleanup_strv_free_ char **units = NULL;
 913
 914         assert(message);
 915
 916         r = sd_bus_message_read_strv(message, &units);
 917         if (r < 0)
 918                 return r;
 919
 920         r = sd_bus_message_new_method_return(message, &reply);
 921         if (r < 0)
 922                 return r;
 923
 924         r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
 925         if (r < 0)
 926                 return r;
 927
 928         STRV_FOREACH(unit, units) {
 929                 Unit *u;
 930
 931                 if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
 932                         continue;
 933
 934                 r = bus_load_unit_by_name(m, message, *unit, &u, error);
 935                 if (r < 0)
 936                         return r;
 937
 938                 r = reply_unit_info(reply, u);
 939                 if (r < 0)
 940                         return r;
 941         }
 942
 943         r = sd_bus_message_close_container(reply);
 944         if (r < 0)
 945                 return r;
 946
 947         return sd_bus_send(NULL, reply, NULL);
 948 }
 949
 950 static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 951         /* Don't load a unit actively (since it won't have any processes if it's not loaded), but don't
 952          * insist on the unit being loaded either (because even improperly loaded units might still have
 953          * processes around). */
 954         return method_generic_unit_operation(message, userdata, error, bus_unit_method_get_processes, /* flags = */ 0);
 955 }
 956
 957 static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 958         /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
 959          * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
 960          * processes to stopped units anyway. */
 961         return method_generic_unit_operation(message, userdata, error, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
 962 }
 963
 964 static int transient_unit_from_message(
 965                 Manager *m,
 966                 sd_bus_message *message,
 967                 const char *name,
 968                 Unit **unit,
 969                 sd_bus_error *error) {
 970
 971         UnitType t;
 972         Unit *u;
 973         int r;
 974
 975         assert(m);
 976         assert(message);
 977         assert(name);
 978
 979         t = unit_name_to_type(name);
 980         if (t < 0)
 981                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
 982                                          "Invalid unit name or type.");
 983
 984         if (!unit_vtable[t]->can_transient)
 985                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
 986                                          "Unit type %s does not support transient units.",
 987                                          unit_type_to_string(t));
 988
 989         r = manager_load_unit(m, name, NULL, error, &u);
 990         if (r < 0)
 991                 return r;
 992
 993         if (!unit_is_pristine(u))
 994                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
 995                                          "Unit %s was already loaded or has a fragment file.", name);
 996
 997         /* OK, the unit failed to load and is unreferenced, now let's
 998          * fill in the transient data instead */
 999         r = unit_make_transient(u);
1000         if (r < 0)
1001                 return r;
1002
1003         /* Set our properties */
1004         r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
1005         if (r < 0)
1006                 return r;
1007
1008         /* If the client asked for it, automatically add a reference to this unit. */
1009         if (u->bus_track_add) {
1010                 r = bus_unit_track_add_sender(u, message);
1011                 if (r < 0)
1012                         return log_error_errno(r, "Failed to watch sender: %m");
1013         }
1014
1015         /* Now load the missing bits of the unit we just created */
1016         unit_add_to_load_queue(u);
1017         manager_dispatch_load_queue(m);
1018
1019         *unit = u;
1020
1021         return 0;
1022 }
1023
1024 static int transient_aux_units_from_message(
1025                 Manager *m,
1026                 sd_bus_message *message,
1027                 sd_bus_error *error) {
1028
1029         int r;
1030
1031         assert(m);
1032         assert(message);
1033
1034         r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
1035         if (r < 0)
1036                 return r;
1037
1038         while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
1039                 const char *name = NULL;
1040                 Unit *u;
1041
1042                 r = sd_bus_message_read(message, "s", &name);
1043                 if (r < 0)
1044                         return r;
1045
1046                 r = transient_unit_from_message(m, message, name, &u, error);
1047                 if (r < 0)
1048                         return r;
1049
1050                 r = sd_bus_message_exit_container(message);
1051                 if (r < 0)
1052                         return r;
1053         }
1054         if (r < 0)
1055                 return r;
1056
1057         r = sd_bus_message_exit_container(message);
1058         if (r < 0)
1059                 return r;
1060
1061         return 0;
1062 }
1063
1064 static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1065         const char *name, *smode;
1066         Manager *m = ASSERT_PTR(userdata);
1067         JobMode mode;
1068         Unit *u;
1069         int r;
1070
1071         assert(message);
1072
1073         r = mac_selinux_access_check(message, "start", error);
1074         if (r < 0)
1075                 return r;
1076
1077         r = sd_bus_message_read(message, "ss", &name, &smode);
1078         if (r < 0)
1079                 return r;
1080
1081         mode = job_mode_from_string(smode);
1082         if (mode < 0)
1083                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
1084
1085         r = bus_verify_manage_units_async(m, message, error);
1086         if (r < 0)
1087                 return r;
1088         if (r == 0)
1089                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1090
1091         r = transient_unit_from_message(m, message, name, &u, error);
1092         if (r < 0)
1093                 return r;
1094
1095         r = transient_aux_units_from_message(m, message, error);
1096         if (r < 0)
1097                 return r;
1098
1099         /* Finally, start it */
1100         return bus_unit_queue_job(message, u, JOB_START, mode, 0, error);
1101 }
1102
1103 static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1104         _cleanup_free_ char *path = NULL;
1105         Manager *m = ASSERT_PTR(userdata);
1106         uint32_t id;
1107         Job *j;
1108         int r;
1109
1110         assert(message);
1111
1112         /* Anyone can call this method */
1113
1114         r = sd_bus_message_read(message, "u", &id);
1115         if (r < 0)
1116                 return r;
1117
1118         j = manager_get_job(m, id);
1119         if (!j)
1120                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
1121
1122         r = mac_selinux_unit_access_check(j->unit, message, "status", error);
1123         if (r < 0)
1124                 return r;
1125
1126         path = job_dbus_path(j);
1127         if (!path)
1128                 return -ENOMEM;
1129
1130         return sd_bus_reply_method_return(message, "o", path);
1131 }
1132
1133 static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1134         Manager *m = ASSERT_PTR(userdata);
1135         uint32_t id;
1136         Job *j;
1137         int r;
1138
1139         assert(message);
1140
1141         r = sd_bus_message_read(message, "u", &id);
1142         if (r < 0)
1143                 return r;
1144
1145         j = manager_get_job(m, id);
1146         if (!j)
1147                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
1148
1149         return bus_job_method_cancel(message, j, error);
1150 }
1151
1152 static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1153         Manager *m = ASSERT_PTR(userdata);
1154         int r;
1155
1156         assert(message);
1157
1158         r = mac_selinux_access_check(message, "reload", error);
1159         if (r < 0)
1160                 return r;
1161
1162         r = bus_verify_manage_units_async(m, message, error);
1163         if (r < 0)
1164                 return r;
1165         if (r == 0)
1166                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1167
1168         manager_clear_jobs(m);
1169
1170         return sd_bus_reply_method_return(message, NULL);
1171 }
1172
1173 static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1174         Manager *m = ASSERT_PTR(userdata);
1175         int r;
1176
1177         assert(message);
1178
1179         r = mac_selinux_access_check(message, "reload", error);
1180         if (r < 0)
1181                 return r;
1182
1183         r = bus_verify_manage_units_async(m, message, error);
1184         if (r < 0)
1185                 return r;
1186         if (r == 0)
1187                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1188
1189         manager_reset_failed(m);
1190
1191         return sd_bus_reply_method_return(message, NULL);
1192 }
1193
1194 static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
1195         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1196         Manager *m = ASSERT_PTR(userdata);
1197         const char *k;
1198         Unit *u;
1199         int r;
1200
1201         assert(message);
1202
1203         /* Anyone can call this method */
1204
1205         r = mac_selinux_access_check(message, "status", error);
1206         if (r < 0)
1207                 return r;
1208
1209         r = sd_bus_message_new_method_return(message, &reply);
1210         if (r < 0)
1211                 return r;
1212
1213         r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
1214         if (r < 0)
1215                 return r;
1216
1217         HASHMAP_FOREACH_KEY(u, k, m->units) {
1218                 if (k != u->id)
1219                         continue;
1220
1221                 if (!strv_isempty(states) &&
1222                     !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
1223                     !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
1224                     !strv_contains(states, unit_sub_state_to_string(u)))
1225                         continue;
1226
1227                 if (!strv_isempty(patterns) &&
1228                     !strv_fnmatch_or_empty(patterns, u->id, FNM_NOESCAPE))
1229                         continue;
1230
1231                 r = reply_unit_info(reply, u);
1232                 if (r < 0)
1233                         return r;
1234         }
1235
1236         r = sd_bus_message_close_container(reply);
1237         if (r < 0)
1238                 return r;
1239
1240         return sd_bus_send(NULL, reply, NULL);
1241 }
1242
1243 static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1244         return list_units_filtered(message, userdata, error, NULL, NULL);
1245 }
1246
1247 static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1248         _cleanup_strv_free_ char **states = NULL;
1249         int r;
1250
1251         r = sd_bus_message_read_strv(message, &states);
1252         if (r < 0)
1253                 return r;
1254
1255         return list_units_filtered(message, userdata, error, states, NULL);
1256 }
1257
1258 static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1259         _cleanup_strv_free_ char **states = NULL;
1260         _cleanup_strv_free_ char **patterns = NULL;
1261         int r;
1262
1263         r = sd_bus_message_read_strv(message, &states);
1264         if (r < 0)
1265                 return r;
1266
1267         r = sd_bus_message_read_strv(message, &patterns);
1268         if (r < 0)
1269                 return r;
1270
1271         return list_units_filtered(message, userdata, error, states, patterns);
1272 }
1273
1274 static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1275         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1276         Manager *m = ASSERT_PTR(userdata);
1277         Job *j;
1278         int r;
1279
1280         assert(message);
1281
1282         /* Anyone can call this method */
1283
1284         r = mac_selinux_access_check(message, "status", error);
1285         if (r < 0)
1286                 return r;
1287
1288         r = sd_bus_message_new_method_return(message, &reply);
1289         if (r < 0)
1290                 return r;
1291
1292         r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
1293         if (r < 0)
1294                 return r;
1295
1296         HASHMAP_FOREACH(j, m->jobs) {
1297                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
1298
1299                 job_path = job_dbus_path(j);
1300                 if (!job_path)
1301                         return -ENOMEM;
1302
1303                 unit_path = unit_dbus_path(j->unit);
1304                 if (!unit_path)
1305                         return -ENOMEM;
1306
1307                 r = sd_bus_message_append(
1308                                 reply, "(usssoo)",
1309                                 j->id,
1310                                 j->unit->id,
1311                                 job_type_to_string(j->type),
1312                                 job_state_to_string(j->state),
1313                                 job_path,
1314                                 unit_path);
1315                 if (r < 0)
1316                         return r;
1317         }
1318
1319         r = sd_bus_message_close_container(reply);
1320         if (r < 0)
1321                 return r;
1322
1323         return sd_bus_send(NULL, reply, NULL);
1324 }
1325
1326 static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1327         Manager *m = ASSERT_PTR(userdata);
1328         int r;
1329
1330         assert(message);
1331
1332         /* Anyone can call this method */
1333
1334         r = mac_selinux_access_check(message, "status", error);
1335         if (r < 0)
1336                 return r;
1337
1338         if (sd_bus_message_get_bus(message) == m->api_bus) {
1339
1340                 /* Note that direct bus connection subscribe by
1341                  * default, we only track peers on the API bus here */
1342
1343                 if (!m->subscribed) {
1344                         r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
1345                         if (r < 0)
1346                                 return r;
1347                 }
1348
1349                 r = sd_bus_track_add_sender(m->subscribed, message);
1350                 if (r < 0)
1351                         return r;
1352                 if (r == 0)
1353                         return sd_bus_error_set(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
1354         }
1355
1356         return sd_bus_reply_method_return(message, NULL);
1357 }
1358
1359 static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1360         Manager *m = ASSERT_PTR(userdata);
1361         int r;
1362
1363         assert(message);
1364
1365         /* Anyone can call this method */
1366
1367         r = mac_selinux_access_check(message, "status", error);
1368         if (r < 0)
1369                 return r;
1370
1371         if (sd_bus_message_get_bus(message) == m->api_bus) {
1372                 r = sd_bus_track_remove_sender(m->subscribed, message);
1373                 if (r < 0)
1374                         return r;
1375                 if (r == 0)
1376                         return sd_bus_error_set(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
1377         }
1378
1379         return sd_bus_reply_method_return(message, NULL);
1380 }
1381
1382 static int dump_impl(
1383                 sd_bus_message *message,
1384                 void *userdata,
1385                 sd_bus_error *error,
1386                 char **patterns,
1387                 int (*reply)(sd_bus_message *, char *)) {
1388
1389         _cleanup_free_ char *dump = NULL;
1390         Manager *m = ASSERT_PTR(userdata);
1391         int r;
1392
1393         assert(message);
1394
1395         /* 'status' access is the bare minimum always needed for this, as the policy might straight out
1396          * forbid a client from querying any information from systemd, regardless of any rate limiting. */
1397         r = mac_selinux_access_check(message, "status", error);
1398         if (r < 0)
1399                 return r;
1400
1401         /* Rate limit reached? Check if the caller is privileged/allowed by policy to bypass this. We
1402          * check the rate limit first to avoid the expensive roundtrip to polkit when not needed. */
1403         if (!ratelimit_below(&m->dump_ratelimit)) {
1404                 /* We need a way for SELinux to constrain the operation when the rate limit is active, even
1405                  * if polkit would allow it, but we cannot easily add new named permissions, so we need to
1406                  * use an existing one. Reload/reexec are also slow but non-destructive/modifying
1407                  * operations, and can cause PID1 to stall. So it seems similar enough in terms of security
1408                  * considerations and impact, and thus use the same access check for dumps which, given the
1409                  * large amount of data to fetch, can stall PID1 for quite some time. */
1410                 r = mac_selinux_access_check(message, "reload", error);
1411                 if (r < 0)
1412                         goto ratelimited;
1413
1414                 r = bus_verify_bypass_dump_ratelimit_async(m, message, error);
1415                 if (r < 0)
1416                         goto ratelimited;
1417                 if (r == 0)
1418                         /* No authorization for now, but the async polkit stuff will call us again when it
1419                          * has it */
1420                         return 1;
1421         }
1422
1423         r = manager_get_dump_string(m, patterns, &dump);
1424         if (r < 0)
1425                 return r;
1426
1427         return reply(message, dump);
1428
1429 ratelimited:
1430         log_warning("Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1431                     FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
1432         return sd_bus_error_setf(error,
1433                                  SD_BUS_ERROR_LIMITS_EXCEEDED,
1434                                  "Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1435                                  FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
1436 }
1437
1438 static int reply_dump(sd_bus_message *message, char *dump) {
1439         return sd_bus_reply_method_return(message, "s", dump);
1440 }
1441
1442 static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1443         return dump_impl(message, userdata, error, NULL, reply_dump);
1444 }
1445
1446 static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
1447         _cleanup_close_ int fd = -EBADF;
1448
1449         fd = acquire_data_fd(dump);
1450         if (fd < 0)
1451                 return fd;
1452
1453         return sd_bus_reply_method_return(message, "h", fd);
1454 }
1455
1456 static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1457         return dump_impl(message, userdata, error, NULL, reply_dump_by_fd);
1458 }
1459
1460 static int dump_units_matching_patterns(
1461                 sd_bus_message *message,
1462                 void *userdata,
1463                 sd_bus_error *error,
1464                 int (*reply)(sd_bus_message *, char *)) {
1465         _cleanup_strv_free_ char **patterns = NULL;
1466         int r;
1467
1468         r = sd_bus_message_read_strv(message, &patterns);
1469         if (r < 0)
1470                 return r;
1471
1472         return dump_impl(message, userdata, error, patterns, reply);
1473 }
1474
1475 static int method_dump_units_matching_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1476         return dump_units_matching_patterns(message, userdata, error, reply_dump);
1477 }
1478
1479 static int method_dump_units_matching_patterns_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1480         return dump_units_matching_patterns(message, userdata, error, reply_dump_by_fd);
1481 }
1482
1483 static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1484         return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
1485 }
1486
1487 static int get_run_space(uint64_t *ret, sd_bus_error *error) {
1488         struct statvfs svfs;
1489
1490         assert(ret);
1491
1492         if (statvfs("/run/systemd", &svfs) < 0)
1493                 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1494
1495         *ret = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1496         return 0;
1497 }
1498
1499 static int verify_run_space(const char *message, sd_bus_error *error) {
1500         uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1501         int r;
1502
1503         assert(message);
1504
1505         r = get_run_space(&available, error);
1506         if (r < 0)
1507                 return r;
1508
1509         if (available < RELOAD_DISK_SPACE_MIN)
1510                 return sd_bus_error_setf(error,
1511                                          BUS_ERROR_DISK_FULL,
1512                                          "%s, not enough space available on /run/systemd/. "
1513                                          "Currently, %s are free, but a safety buffer of %s is enforced.",
1514                                          message,
1515                                          FORMAT_BYTES(available),
1516                                          FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
1517
1518         return 0;
1519 }
1520
1521 int verify_run_space_and_log(const char *message) {
1522         _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1523         int r;
1524
1525         assert(message);
1526
1527         r = verify_run_space(message, &error);
1528         if (r < 0)
1529                 return log_error_errno(r, "%s", bus_error_message(&error, r));
1530
1531         return 0;
1532 }
1533
1534 static int verify_run_space_permissive(const char *message, sd_bus_error *error) {
1535         uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1536         int r;
1537
1538         assert(message);
1539
1540         r = get_run_space(&available, error);
1541         if (r < 0)
1542                 return r;
1543
1544         if (available < RELOAD_DISK_SPACE_MIN)
1545                 log_warning("Dangerously low amount of free space on /run/systemd/, %s.\n"
1546                             "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1547                             message,
1548                             FORMAT_BYTES(available),
1549                             FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
1550
1551         return 0;
1552 }
1553
1554 static void log_caller(sd_bus_message *message, Manager *manager, const char *method) {
1555         _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1556         const char *comm = NULL;
1557         Unit *caller;
1558         pid_t pid;
1559
1560         assert(message);
1561         assert(manager);
1562         assert(method);
1563
1564         if (sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID|SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_COMM, &creds) < 0)
1565                 return;
1566
1567         /* We need at least the PID, otherwise there's nothing to log, the rest is optional */
1568         if (sd_bus_creds_get_pid(creds, &pid) < 0)
1569                 return;
1570
1571         (void) sd_bus_creds_get_comm(creds, &comm);
1572         caller = manager_get_unit_by_pid(manager, pid);
1573
1574         log_info("%s requested from client PID " PID_FMT "%s%s%s%s%s%s...",
1575                  method, pid,
1576                  comm ? " ('" : "", strempty(comm), comm ? "')" : "",
1577                  caller ? " (unit " : "", caller ? caller->id : "", caller ? ")" : "");
1578 }
1579
1580 static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1581         Manager *m = ASSERT_PTR(userdata);
1582         int r;
1583
1584         assert(message);
1585
1586         r = verify_run_space("Refusing to reload", error);
1587         if (r < 0)
1588                 return r;
1589
1590         r = mac_selinux_access_check(message, "reload", error);
1591         if (r < 0)
1592                 return r;
1593
1594         r = bus_verify_reload_daemon_async(m, message, error);
1595         if (r < 0)
1596                 return r;
1597         if (r == 0)
1598                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1599
1600         /* Write a log message noting the unit or process who requested the Reload() */
1601         log_caller(message, m, "Reloading");
1602
1603         /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1604         if (!ratelimit_below(&m->reload_reexec_ratelimit)) {
1605                 log_warning("Reloading request rejected due to rate limit.");
1606                 return sd_bus_error_setf(error,
1607                                          SD_BUS_ERROR_LIMITS_EXCEEDED,
1608                                          "Reload() request rejected due to rate limit.");
1609         }
1610
1611         /* Instead of sending the reply back right away, we just
1612          * remember that we need to and then send it after the reload
1613          * is finished. That way the caller knows when the reload
1614          * finished. */
1615
1616         assert(!m->pending_reload_message);
1617         r = sd_bus_message_new_method_return(message, &m->pending_reload_message);
1618         if (r < 0)
1619                 return r;
1620
1621         m->objective = MANAGER_RELOAD;
1622
1623         return 1;
1624 }
1625
1626 static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1627         Manager *m = ASSERT_PTR(userdata);
1628         int r;
1629
1630         assert(message);
1631
1632         r = verify_run_space("Refusing to reexecute", error);
1633         if (r < 0)
1634                 return r;
1635
1636         r = mac_selinux_access_check(message, "reload", error);
1637         if (r < 0)
1638                 return r;
1639
1640         r = bus_verify_reload_daemon_async(m, message, error);
1641         if (r < 0)
1642                 return r;
1643         if (r == 0)
1644                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1645
1646         /* Write a log message noting the unit or process who requested the Reexecute() */
1647         log_caller(message, m, "Reexecuting");
1648
1649         /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1650         if (!ratelimit_below(&m->reload_reexec_ratelimit)) {
1651                 log_warning("Reexecuting request rejected due to rate limit.");
1652                 return sd_bus_error_setf(error,
1653                                          SD_BUS_ERROR_LIMITS_EXCEEDED,
1654                                          "Reexecute() request rejected due to rate limit.");
1655         }
1656
1657         /* We don't send a reply back here, the client should
1658          * just wait for us disconnecting. */
1659
1660         m->objective = MANAGER_REEXECUTE;
1661         return 1;
1662 }
1663
1664 static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1665         Manager *m = ASSERT_PTR(userdata);
1666         int r;
1667
1668         assert(message);
1669
1670         r = mac_selinux_access_check(message, "halt", error);
1671         if (r < 0)
1672                 return r;
1673
1674         /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1675          * we are running on the host. It will fall back on reboot() in
1676          * systemd-shutdown if it cannot do the exit() because it isn't a
1677          * container. */
1678
1679         m->objective = MANAGER_EXIT;
1680
1681         return sd_bus_reply_method_return(message, NULL);
1682 }
1683
1684 static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1685         Manager *m = ASSERT_PTR(userdata);
1686         int r;
1687
1688         assert(message);
1689
1690         r = mac_selinux_access_check(message, "reboot", error);
1691         if (r < 0)
1692                 return r;
1693
1694         if (!MANAGER_IS_SYSTEM(m))
1695                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1696                                          "Reboot is only supported for system managers.");
1697
1698         m->objective = MANAGER_REBOOT;
1699
1700         return sd_bus_reply_method_return(message, NULL);
1701 }
1702
1703 static int method_soft_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1704         _cleanup_free_ char *rt = NULL;
1705         Manager *m = ASSERT_PTR(userdata);
1706         const char *root;
1707         int r;
1708
1709         assert(message);
1710
1711         r = verify_run_space_permissive("soft reboot may fail", error);
1712         if (r < 0)
1713                 return r;
1714
1715         r = mac_selinux_access_check(message, "reboot", error);
1716         if (r < 0)
1717                 return r;
1718
1719         r = sd_bus_message_read(message, "s", &root);
1720         if (r < 0)
1721                 return r;
1722
1723         if (!isempty(root)) {
1724                 if (!path_is_valid(root))
1725                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1726                                                  "New root directory '%s' must be a valid path.", root);
1727                 if (!path_is_absolute(root))
1728                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1729                                                  "New root directory path '%s' is not absolute.", root);
1730
1731                 rt = strdup(root);
1732                 if (!rt)
1733                         return -ENOMEM;
1734         }
1735
1736         free_and_replace(m->switch_root, rt);
1737         m->objective = MANAGER_SOFT_REBOOT;
1738
1739         return sd_bus_reply_method_return(message, NULL);
1740 }
1741
1742 static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1743         Manager *m = ASSERT_PTR(userdata);
1744         int r;
1745
1746         assert(message);
1747
1748         r = mac_selinux_access_check(message, "halt", error);
1749         if (r < 0)
1750                 return r;
1751
1752         if (!MANAGER_IS_SYSTEM(m))
1753                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1754                                          "Powering off is only supported for system managers.");
1755
1756         m->objective = MANAGER_POWEROFF;
1757
1758         return sd_bus_reply_method_return(message, NULL);
1759 }
1760
1761 static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1762         Manager *m = ASSERT_PTR(userdata);
1763         int r;
1764
1765         assert(message);
1766
1767         r = mac_selinux_access_check(message, "halt", error);
1768         if (r < 0)
1769                 return r;
1770
1771         if (!MANAGER_IS_SYSTEM(m))
1772                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1773                                          "Halt is only supported for system managers.");
1774
1775         m->objective = MANAGER_HALT;
1776
1777         return sd_bus_reply_method_return(message, NULL);
1778 }
1779
1780 static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1781         Manager *m = ASSERT_PTR(userdata);
1782         int r;
1783
1784         assert(message);
1785
1786         r = mac_selinux_access_check(message, "reboot", error);
1787         if (r < 0)
1788                 return r;
1789
1790         if (!MANAGER_IS_SYSTEM(m))
1791                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1792                                          "KExec is only supported for system managers.");
1793
1794         m->objective = MANAGER_KEXEC;
1795
1796         return sd_bus_reply_method_return(message, NULL);
1797 }
1798
1799 static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1800         _cleanup_free_ char *ri = NULL, *rt = NULL;
1801         Manager *m = ASSERT_PTR(userdata);
1802         const char *root, *init;
1803         int r;
1804
1805         assert(message);
1806
1807         r = verify_run_space_permissive("root switching may fail", error);
1808         if (r < 0)
1809                 return r;
1810
1811         r = mac_selinux_access_check(message, "reboot", error);
1812         if (r < 0)
1813                 return r;
1814
1815         if (!MANAGER_IS_SYSTEM(m))
1816                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1817                                          "Root switching is only supported by system manager.");
1818
1819         r = sd_bus_message_read(message, "ss", &root, &init);
1820         if (r < 0)
1821                 return r;
1822
1823         if (isempty(root))
1824                 /* If path is not specified, default to "/sysroot" which is what we generally expect initrds
1825                  * to use */
1826                 root = "/sysroot";
1827         else {
1828                 if (!path_is_valid(root))
1829                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1830                                                  "New root directory must be a valid path.");
1831
1832                 if (!path_is_absolute(root))
1833                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1834                                                  "New root path '%s' is not absolute.", root);
1835
1836                 r = path_is_root(root);
1837                 if (r < 0)
1838                         return sd_bus_error_set_errnof(error, r,
1839                                                        "Failed to check if new root directory '%s' is the same as old root: %m",
1840                                                        root);
1841                 if (r > 0)
1842                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1843                                                  "New root directory cannot be the old root directory.");
1844         }
1845
1846         /* Safety check */
1847         if (!in_initrd())
1848                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1849                                          "Not in initrd, refusing switch-root operation.");
1850
1851         r = path_is_os_tree(root);
1852         if (r < 0)
1853                 return sd_bus_error_set_errnof(error, r,
1854                                                "Failed to determine whether root path '%s' contains an OS tree: %m",
1855                                                root);
1856         if (r == 0)
1857                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1858                                          "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1859                                          root);
1860
1861         if (!isempty(init)) {
1862                 if (!path_is_valid(init))
1863                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1864                                                  "Path to init binary '%s' is not a valid path.", init);
1865
1866                 if (!path_is_absolute(init))
1867                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1868                                                  "Path to init binary '%s' not absolute.", init);
1869
1870                 r = chase_and_access(init, root, CHASE_PREFIX_ROOT, X_OK, NULL);
1871                 if (r == -EACCES)
1872                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1873                                                  "Init binary %s is not executable.", init);
1874                 if (r < 0)
1875                         return sd_bus_error_set_errnof(error, r,
1876                                                        "Could not resolve init executable %s: %m", init);
1877         }
1878
1879         rt = strdup(root);
1880         if (!rt)
1881                 return -ENOMEM;
1882
1883         if (!isempty(init)) {
1884                 ri = strdup(init);
1885                 if (!ri)
1886                         return -ENOMEM;
1887         }
1888
1889         free_and_replace(m->switch_root, rt);
1890         free_and_replace(m->switch_root_init, ri);
1891
1892         m->objective = MANAGER_SWITCH_ROOT;
1893
1894         return sd_bus_reply_method_return(message, NULL);
1895 }
1896
1897 static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1898         _cleanup_strv_free_ char **plus = NULL;
1899         Manager *m = ASSERT_PTR(userdata);
1900         int r;
1901
1902         assert(message);
1903
1904         r = mac_selinux_access_check(message, "reload", error);
1905         if (r < 0)
1906                 return r;
1907
1908         r = sd_bus_message_read_strv(message, &plus);
1909         if (r < 0)
1910                 return r;
1911         if (!strv_env_is_valid(plus))
1912                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1913
1914         r = bus_verify_set_environment_async(m, message, error);
1915         if (r < 0)
1916                 return r;
1917         if (r == 0)
1918                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1919
1920         r = manager_client_environment_modify(m, NULL, plus);
1921         if (r < 0)
1922                 return r;
1923
1924         return sd_bus_reply_method_return(message, NULL);
1925 }
1926
1927 static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1928         _cleanup_strv_free_ char **minus = NULL;
1929         Manager *m = ASSERT_PTR(userdata);
1930         int r;
1931
1932         assert(message);
1933
1934         r = mac_selinux_access_check(message, "reload", error);
1935         if (r < 0)
1936                 return r;
1937
1938         r = sd_bus_message_read_strv(message, &minus);
1939         if (r < 0)
1940                 return r;
1941
1942         if (!strv_env_name_or_assignment_is_valid(minus))
1943                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1944                                          "Invalid environment variable names or assignments");
1945
1946         r = bus_verify_set_environment_async(m, message, error);
1947         if (r < 0)
1948                 return r;
1949         if (r == 0)
1950                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1951
1952         r = manager_client_environment_modify(m, minus, NULL);
1953         if (r < 0)
1954                 return r;
1955
1956         return sd_bus_reply_method_return(message, NULL);
1957 }
1958
1959 static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1960         _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1961         Manager *m = ASSERT_PTR(userdata);
1962         int r;
1963
1964         assert(message);
1965
1966         r = mac_selinux_access_check(message, "reload", error);
1967         if (r < 0)
1968                 return r;
1969
1970         r = sd_bus_message_read_strv(message, &minus);
1971         if (r < 0)
1972                 return r;
1973
1974         r = sd_bus_message_read_strv(message, &plus);
1975         if (r < 0)
1976                 return r;
1977
1978         if (!strv_env_name_or_assignment_is_valid(minus))
1979                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1980                                          "Invalid environment variable names or assignments");
1981         if (!strv_env_is_valid(plus))
1982                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1983                                          "Invalid environment assignments");
1984
1985         r = bus_verify_set_environment_async(m, message, error);
1986         if (r < 0)
1987                 return r;
1988         if (r == 0)
1989                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1990
1991         r = manager_client_environment_modify(m, minus, plus);
1992         if (r < 0)
1993                 return r;
1994
1995         return sd_bus_reply_method_return(message, NULL);
1996 }
1997
1998 static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1999         Manager *m = ASSERT_PTR(userdata);
2000         uint8_t code;
2001         int r;
2002
2003         assert(message);
2004
2005         r = mac_selinux_access_check(message, "exit", error);
2006         if (r < 0)
2007                 return r;
2008
2009         r = sd_bus_message_read_basic(message, 'y', &code);
2010         if (r < 0)
2011                 return r;
2012
2013         m->return_value = code;
2014
2015         return sd_bus_reply_method_return(message, NULL);
2016 }
2017
2018 static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2019         Manager *m = ASSERT_PTR(userdata);
2020         const char *name;
2021         uid_t uid;
2022         int r;
2023
2024         assert(message);
2025
2026         r = sd_bus_message_read_basic(message, 's', &name);
2027         if (r < 0)
2028                 return r;
2029
2030         if (!MANAGER_IS_SYSTEM(m))
2031                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2032                                          "Dynamic users are only supported in the system instance.");
2033         if (!valid_user_group_name(name, VALID_USER_RELAX))
2034                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2035                                          "User name invalid: %s", name);
2036
2037         r = dynamic_user_lookup_name(m, name, &uid);
2038         if (r == -ESRCH)
2039                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2040                                          "Dynamic user %s does not exist.", name);
2041         if (r < 0)
2042                 return r;
2043
2044         return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
2045 }
2046
2047 static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2048         _cleanup_free_ char *name = NULL;
2049         Manager *m = ASSERT_PTR(userdata);
2050         uid_t uid;
2051         int r;
2052
2053         assert(message);
2054
2055         assert_cc(sizeof(uid_t) == sizeof(uint32_t));
2056         r = sd_bus_message_read_basic(message, 'u', &uid);
2057         if (r < 0)
2058                 return r;
2059
2060         if (!MANAGER_IS_SYSTEM(m))
2061                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2062                                          "Dynamic users are only supported in the system instance.");
2063         if (!uid_is_valid(uid))
2064                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2065                                          "User ID invalid: " UID_FMT, uid);
2066
2067         r = dynamic_user_lookup_uid(m, uid, &name);
2068         if (r == -ESRCH)
2069                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2070                                          "Dynamic user ID " UID_FMT " does not exist.", uid);
2071         if (r < 0)
2072                 return r;
2073
2074         return sd_bus_reply_method_return(message, "s", name);
2075 }
2076
2077 static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2078         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2079         Manager *m = ASSERT_PTR(userdata);
2080         DynamicUser *d;
2081         int r;
2082
2083         assert(message);
2084
2085         assert_cc(sizeof(uid_t) == sizeof(uint32_t));
2086
2087         if (!MANAGER_IS_SYSTEM(m))
2088                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2089                                          "Dynamic users are only supported in the system instance.");
2090
2091         r = sd_bus_message_new_method_return(message, &reply);
2092         if (r < 0)
2093                 return r;
2094
2095         r = sd_bus_message_open_container(reply, 'a', "(us)");
2096         if (r < 0)
2097                 return r;
2098
2099         HASHMAP_FOREACH(d, m->dynamic_users) {
2100                 uid_t uid;
2101
2102                 r = dynamic_user_current(d, &uid);
2103                 if (r == -EAGAIN) /* not realized yet? */
2104                         continue;
2105                 if (r < 0)
2106                         return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED,
2107                                                  "Failed to look up a dynamic user.");
2108
2109                 r = sd_bus_message_append(reply, "(us)", uid, d->name);
2110                 if (r < 0)
2111                         return r;
2112         }
2113
2114         r = sd_bus_message_close_container(reply);
2115         if (r < 0)
2116                 return r;
2117
2118         return sd_bus_send(NULL, reply, NULL);
2119 }
2120
2121 static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2122         Manager *m = ASSERT_PTR(userdata);
2123         int r;
2124
2125         assert(message);
2126
2127         r = mac_selinux_access_check(message, "start", error);
2128         if (r < 0)
2129                 return r;
2130
2131         r = bus_verify_manage_units_async(m, message, error);
2132         if (r < 0)
2133                 return r;
2134         if (r == 0)
2135                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2136
2137         log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS));
2138
2139         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2140         r = sd_bus_message_new_method_return(message, &reply);
2141         if (r < 0)
2142                 return r;
2143
2144         r = sd_bus_message_open_container(reply, 'a', "o");
2145         if (r < 0)
2146                 return r;
2147
2148         Unit *u;
2149         char *k;
2150         int ret = 0;
2151         HASHMAP_FOREACH_KEY(u, k, m->units) {
2152                 /* ignore aliases */
2153                 if (u->id != k)
2154                         continue;
2155
2156                 BusUnitQueueFlags flags;
2157                 if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RESTART))
2158                         flags = 0;
2159                 else if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RELOAD))
2160                         flags = BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE;
2161                 else
2162                         continue;
2163
2164                 r = mac_selinux_unit_access_check(u, message, "start", error);
2165                 if (r >= 0)
2166                         r = bus_unit_queue_job_one(message, u,
2167                                                    JOB_TRY_RESTART, JOB_FAIL, flags,
2168                                                    reply, error);
2169                 if (ERRNO_IS_NEG_RESOURCE(r))
2170                         return r;
2171                 if (r < 0) {
2172                         if (ret >= 0)
2173                                 ret = r;
2174                         sd_bus_error_free(error);
2175                 }
2176         }
2177
2178         if (ret < 0)
2179                 return sd_bus_error_set_errnof(error, ret,
2180                                                "Failed to enqueue some jobs, see logs for details: %m");
2181
2182         r = sd_bus_message_close_container(reply);
2183         if (r < 0)
2184                 return r;
2185
2186         return sd_bus_send(NULL, reply, NULL);
2187 }
2188
2189 static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
2190         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2191         Manager *m = ASSERT_PTR(userdata);
2192         UnitFileList *item;
2193         _cleanup_hashmap_free_ Hashmap *h = NULL;
2194         int r;
2195
2196         assert(message);
2197
2198         /* Anyone can call this method */
2199
2200         r = mac_selinux_access_check(message, "status", error);
2201         if (r < 0)
2202                 return r;
2203
2204         r = sd_bus_message_new_method_return(message, &reply);
2205         if (r < 0)
2206                 return r;
2207
2208         h = hashmap_new(&unit_file_list_hash_ops_free);
2209         if (!h)
2210                 return -ENOMEM;
2211
2212         r = unit_file_get_list(m->runtime_scope, NULL, h, states, patterns);
2213         if (r < 0)
2214                 return r;
2215
2216         r = sd_bus_message_open_container(reply, 'a', "(ss)");
2217         if (r < 0)
2218                 return r;
2219
2220         HASHMAP_FOREACH(item, h) {
2221
2222                 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
2223                 if (r < 0)
2224                         return r;
2225         }
2226
2227         r = sd_bus_message_close_container(reply);
2228         if (r < 0)
2229                 return r;
2230
2231         return sd_bus_send(NULL, reply, NULL);
2232 }
2233
2234 static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2235         return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
2236 }
2237
2238 static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2239         _cleanup_strv_free_ char **states = NULL;
2240         _cleanup_strv_free_ char **patterns = NULL;
2241         int r;
2242
2243         r = sd_bus_message_read_strv(message, &states);
2244         if (r < 0)
2245                 return r;
2246
2247         r = sd_bus_message_read_strv(message, &patterns);
2248         if (r < 0)
2249                 return r;
2250
2251         return list_unit_files_by_patterns(message, userdata, error, states, patterns);
2252 }
2253
2254 static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2255         Manager *m = ASSERT_PTR(userdata);
2256         const char *name;
2257         UnitFileState state;
2258         int r;
2259
2260         assert(message);
2261
2262         /* Anyone can call this method */
2263
2264         r = mac_selinux_access_check(message, "status", error);
2265         if (r < 0)
2266                 return r;
2267
2268         r = sd_bus_message_read(message, "s", &name);
2269         if (r < 0)
2270                 return r;
2271
2272         r = unit_file_get_state(m->runtime_scope, NULL, name, &state);
2273         if (r < 0)
2274                 return r;
2275
2276         return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
2277 }
2278
2279 static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2280         _cleanup_free_ char *default_target = NULL;
2281         Manager *m = ASSERT_PTR(userdata);
2282         int r;
2283
2284         assert(message);
2285
2286         /* Anyone can call this method */
2287
2288         r = mac_selinux_access_check(message, "status", error);
2289         if (r < 0)
2290                 return r;
2291
2292         r = unit_file_get_default(m->runtime_scope, NULL, &default_target);
2293         if (r == -ERFKILL)
2294                 sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
2295         if (r < 0)
2296                 return r;
2297
2298         return sd_bus_reply_method_return(message, "s", default_target);
2299 }
2300
2301 static int send_unit_files_changed(sd_bus *bus, void *userdata) {
2302         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
2303         int r;
2304
2305         assert(bus);
2306
2307         r = sd_bus_message_new_signal(bus, &message,
2308                                       "/org/freedesktop/systemd1",
2309                                       "org.freedesktop.systemd1.Manager",
2310                                       "UnitFilesChanged");
2311         if (r < 0)
2312                 return r;
2313
2314         return sd_bus_send(bus, message, NULL);
2315 }
2316
2317 static int install_error(
2318                 sd_bus_error *error,
2319                 int c,
2320                 InstallChange *changes,
2321                 size_t n_changes) {
2322
2323         int r;
2324
2325         /* Create an error reply, using the error information from changes[] if possible, and fall back to
2326          * generating an error from error code c. The error message only describes the first error. */
2327
2328         assert(changes || n_changes == 0);
2329
2330         CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2331
2332         FOREACH_ARRAY(i, changes, n_changes) {
2333                 _cleanup_free_ char *err_message = NULL;
2334                 const char *bus_error;
2335
2336                 if (i->type >= 0)
2337                         continue;
2338
2339                 r = install_change_dump_error(i, &err_message, &bus_error);
2340                 if (r == -ENOMEM)
2341                         return r;
2342                 if (r < 0)
2343                         return sd_bus_error_set_errnof(error, r, "File %s: %m", i->path);
2344
2345                 return sd_bus_error_set(error, bus_error, err_message);
2346         }
2347
2348         return c < 0 ? c : -EINVAL;
2349 }
2350
2351 static int reply_install_changes_and_free(
2352                 Manager *m,
2353                 sd_bus_message *message,
2354                 int carries_install_info,
2355                 InstallChange *changes,
2356                 size_t n_changes,
2357                 sd_bus_error *error) {
2358
2359         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2360         bool bad = false, good = false;
2361         int r;
2362
2363         CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2364
2365         if (install_changes_have_modification(changes, n_changes)) {
2366                 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
2367                 if (r < 0)
2368                         log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
2369         }
2370
2371         r = sd_bus_message_new_method_return(message, &reply);
2372         if (r < 0)
2373                 return r;
2374
2375         if (carries_install_info >= 0) {
2376                 r = sd_bus_message_append(reply, "b", carries_install_info);
2377                 if (r < 0)
2378                         return r;
2379         }
2380
2381         r = sd_bus_message_open_container(reply, 'a', "(sss)");
2382         if (r < 0)
2383                 return r;
2384
2385         FOREACH_ARRAY(i, changes, n_changes) {
2386                 if (i->type < 0) {
2387                         bad = true;
2388                         continue;
2389                 }
2390
2391                 r = sd_bus_message_append(
2392                                 reply, "(sss)",
2393                                 install_change_type_to_string(i->type),
2394                                 i->path,
2395                                 i->source);
2396                 if (r < 0)
2397                         return r;
2398
2399                 good = true;
2400         }
2401
2402         /* If there was a failed change, and no successful change, then return the first failure as proper
2403          * method call error. */
2404         if (bad && !good)
2405                 return install_error(error, 0, TAKE_PTR(changes), n_changes);
2406
2407         r = sd_bus_message_close_container(reply);
2408         if (r < 0)
2409                 return r;
2410
2411         return sd_bus_send(NULL, reply, NULL);
2412 }
2413
2414 static int method_enable_unit_files_generic(
2415                 sd_bus_message *message,
2416                 Manager *m,
2417                 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
2418                 bool carries_install_info,
2419                 sd_bus_error *error) {
2420
2421         _cleanup_strv_free_ char **l = NULL;
2422         InstallChange *changes = NULL;
2423         size_t n_changes = 0;
2424         UnitFileFlags flags;
2425         int r;
2426
2427         assert(message);
2428         assert(m);
2429
2430         r = sd_bus_message_read_strv(message, &l);
2431         if (r < 0)
2432                 return r;
2433
2434         if (sd_bus_message_is_method_call(message, NULL, "EnableUnitFilesWithFlags")) {
2435                 uint64_t raw_flags;
2436
2437                 r = sd_bus_message_read(message, "t", &raw_flags);
2438                 if (r < 0)
2439                         return r;
2440                 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0)
2441                         return -EINVAL;
2442                 flags = raw_flags;
2443         } else {
2444                 int runtime, force;
2445
2446                 r = sd_bus_message_read(message, "bb", &runtime, &force);
2447                 if (r < 0)
2448                         return r;
2449                 flags = unit_file_bools_to_flags(runtime, force);
2450         }
2451
2452         r = bus_verify_manage_unit_files_async(m, message, error);
2453         if (r < 0)
2454                 return r;
2455         if (r == 0)
2456                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2457
2458         r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
2459         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2460         if (r < 0)
2461                 return install_error(error, r, changes, n_changes);
2462
2463         return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
2464 }
2465
2466 static int method_enable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2467         return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
2468 }
2469
2470 static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2471         return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
2472 }
2473
2474 static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2475         return method_enable_unit_files_generic(message, userdata, unit_file_reenable, /* carries_install_info = */ true, error);
2476 }
2477
2478 static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2479         return method_enable_unit_files_generic(message, userdata, unit_file_link, /* carries_install_info = */ false, error);
2480 }
2481
2482 static int unit_file_preset_without_mode(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char **files, InstallChange **changes, size_t *n_changes) {
2483         return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
2484 }
2485
2486 static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2487         return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, /* carries_install_info = */ true, error);
2488 }
2489
2490 static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2491         return method_enable_unit_files_generic(message, userdata, unit_file_mask, /* carries_install_info = */ false, error);
2492 }
2493
2494 static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2495
2496         _cleanup_strv_free_ char **l = NULL;
2497         InstallChange *changes = NULL;
2498         size_t n_changes = 0;
2499         Manager *m = ASSERT_PTR(userdata);
2500         UnitFilePresetMode preset_mode;
2501         int runtime, force, r;
2502         UnitFileFlags flags;
2503         const char *mode;
2504
2505         assert(message);
2506
2507         r = sd_bus_message_read_strv(message, &l);
2508         if (r < 0)
2509                 return r;
2510
2511         r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2512         if (r < 0)
2513                 return r;
2514
2515         flags = unit_file_bools_to_flags(runtime, force);
2516
2517         if (isempty(mode))
2518                 preset_mode = UNIT_FILE_PRESET_FULL;
2519         else {
2520                 preset_mode = unit_file_preset_mode_from_string(mode);
2521                 if (preset_mode < 0)
2522                         return -EINVAL;
2523         }
2524
2525         r = bus_verify_manage_unit_files_async(m, message, error);
2526         if (r < 0)
2527                 return r;
2528         if (r == 0)
2529                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2530
2531         r = unit_file_preset(m->runtime_scope, flags, NULL, l, preset_mode, &changes, &n_changes);
2532         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2533         if (r < 0)
2534                 return install_error(error, r, changes, n_changes);
2535
2536         return reply_install_changes_and_free(m, message, r, changes, n_changes, error);
2537 }
2538
2539 static int method_disable_unit_files_generic(
2540                 sd_bus_message *message,
2541                 Manager *m,
2542                 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
2543                 bool carries_install_info,
2544                 sd_bus_error *error) {
2545
2546         _cleanup_strv_free_ char **l = NULL;
2547         InstallChange *changes = NULL;
2548         UnitFileFlags flags;
2549         size_t n_changes = 0;
2550         int r;
2551
2552         assert(message);
2553         assert(m);
2554
2555         r = sd_bus_message_read_strv(message, &l);
2556         if (r < 0)
2557                 return r;
2558
2559         if (sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlags") ||
2560             sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlagsAndInstallInfo")) {
2561                 uint64_t raw_flags;
2562
2563                 r = sd_bus_message_read(message, "t", &raw_flags);
2564                 if (r < 0)
2565                         return r;
2566                 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0 ||
2567                                 FLAGS_SET(raw_flags, UNIT_FILE_FORCE))
2568                         return -EINVAL;
2569                 flags = raw_flags;
2570         } else {
2571                 int runtime;
2572
2573                 r = sd_bus_message_read(message, "b", &runtime);
2574                 if (r < 0)
2575                         return r;
2576                 flags = unit_file_bools_to_flags(runtime, false);
2577         }
2578
2579         r = bus_verify_manage_unit_files_async(m, message, error);
2580         if (r < 0)
2581                 return r;
2582         if (r == 0)
2583                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2584
2585         r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
2586         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2587         if (r < 0)
2588                 return install_error(error, r, changes, n_changes);
2589
2590         return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
2591 }
2592
2593 static int method_disable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2594         return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
2595 }
2596
2597 static int method_disable_unit_files_with_flags_and_install_info(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2598         return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ true, error);
2599 }
2600
2601 static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2602         return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
2603 }
2604
2605 static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2606         return method_disable_unit_files_generic(message, userdata, unit_file_unmask, /* carries_install_info = */ false, error);
2607 }
2608
2609 static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2610         _cleanup_strv_free_ char **l = NULL;
2611         InstallChange *changes = NULL;
2612         size_t n_changes = 0;
2613         Manager *m = ASSERT_PTR(userdata);
2614         int r;
2615
2616         assert(message);
2617
2618         r = sd_bus_message_read_strv(message, &l);
2619         if (r < 0)
2620                 return r;
2621
2622         r = bus_verify_manage_unit_files_async(m, message, error);
2623         if (r < 0)
2624                 return r;
2625         if (r == 0)
2626                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2627
2628         r = unit_file_revert(m->runtime_scope, NULL, l, &changes, &n_changes);
2629         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2630         if (r < 0)
2631                 return install_error(error, r, changes, n_changes);
2632
2633         return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
2634 }
2635
2636 static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2637         InstallChange *changes = NULL;
2638         size_t n_changes = 0;
2639         Manager *m = ASSERT_PTR(userdata);
2640         const char *name;
2641         int force, r;
2642
2643         assert(message);
2644
2645         r = mac_selinux_access_check(message, "enable", error);
2646         if (r < 0)
2647                 return r;
2648
2649         r = sd_bus_message_read(message, "sb", &name, &force);
2650         if (r < 0)
2651                 return r;
2652
2653         r = bus_verify_manage_unit_files_async(m, message, error);
2654         if (r < 0)
2655                 return r;
2656         if (r == 0)
2657                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2658
2659         r = unit_file_set_default(m->runtime_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
2660         if (r < 0)
2661                 return install_error(error, r, changes, n_changes);
2662
2663         return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
2664 }
2665
2666 static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2667         InstallChange *changes = NULL;
2668         size_t n_changes = 0;
2669         Manager *m = ASSERT_PTR(userdata);
2670         UnitFilePresetMode preset_mode;
2671         const char *mode;
2672         UnitFileFlags flags;
2673         int force, runtime, r;
2674
2675         assert(message);
2676
2677         r = mac_selinux_access_check(message, "enable", error);
2678         if (r < 0)
2679                 return r;
2680
2681         r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2682         if (r < 0)
2683                 return r;
2684
2685         flags = unit_file_bools_to_flags(runtime, force);
2686
2687         if (isempty(mode))
2688                 preset_mode = UNIT_FILE_PRESET_FULL;
2689         else {
2690                 preset_mode = unit_file_preset_mode_from_string(mode);
2691                 if (preset_mode < 0)
2692                         return -EINVAL;
2693         }
2694
2695         r = bus_verify_manage_unit_files_async(m, message, error);
2696         if (r < 0)
2697                 return r;
2698         if (r == 0)
2699                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2700
2701         r = unit_file_preset_all(m->runtime_scope, flags, NULL, preset_mode, &changes, &n_changes);
2702         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2703         if (r < 0)
2704                 return install_error(error, r, changes, n_changes);
2705
2706         return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
2707 }
2708
2709 static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2710         _cleanup_strv_free_ char **l = NULL;
2711         Manager *m = ASSERT_PTR(userdata);
2712         InstallChange *changes = NULL;
2713         size_t n_changes = 0;
2714         int runtime, force, r;
2715         char *target, *type;
2716         UnitDependency dep;
2717         UnitFileFlags flags;
2718
2719         assert(message);
2720
2721         r = bus_verify_manage_unit_files_async(m, message, error);
2722         if (r < 0)
2723                 return r;
2724         if (r == 0)
2725                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2726
2727         r = sd_bus_message_read_strv(message, &l);
2728         if (r < 0)
2729                 return r;
2730
2731         r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2732         if (r < 0)
2733                 return r;
2734
2735         flags = unit_file_bools_to_flags(runtime, force);
2736
2737         dep = unit_dependency_from_string(type);
2738         if (dep < 0)
2739                 return -EINVAL;
2740
2741         r = unit_file_add_dependency(m->runtime_scope, flags, NULL, l, target, dep, &changes, &n_changes);
2742         m->unit_file_state_outdated = m->unit_file_state_outdated || n_changes > 0; /* See comments for this variable in manager.h */
2743         if (r < 0)
2744                 return install_error(error, r, changes, n_changes);
2745
2746         return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
2747 }
2748
2749 static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2750         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2751         Manager *m = ASSERT_PTR(userdata);
2752         InstallChange *changes = NULL;
2753         size_t n_changes = 0, i;
2754         const char *name;
2755         int runtime, r;
2756
2757         CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2758
2759         r = sd_bus_message_read(message, "sb", &name, &runtime);
2760         if (r < 0)
2761                 return r;
2762
2763         r = sd_bus_message_new_method_return(message, &reply);
2764         if (r < 0)
2765                 return r;
2766
2767         r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2768         if (r < 0)
2769                 return r;
2770
2771         r = unit_file_disable(m->runtime_scope,
2772                               UNIT_FILE_DRY_RUN | (runtime ? UNIT_FILE_RUNTIME : 0),
2773                               NULL, STRV_MAKE(name), &changes, &n_changes);
2774         if (r < 0)
2775                 return log_error_errno(r, "Failed to get file links for %s: %m", name);
2776
2777         for (i = 0; i < n_changes; i++)
2778                 if (changes[i].type == INSTALL_CHANGE_UNLINK) {
2779                         r = sd_bus_message_append(reply, "s", changes[i].path);
2780                         if (r < 0)
2781                                 return r;
2782                 }
2783
2784         r = sd_bus_message_close_container(reply);
2785         if (r < 0)
2786                 return r;
2787
2788         return sd_bus_send(NULL, reply, NULL);
2789 }
2790
2791 static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2792         Manager *m = ASSERT_PTR(userdata);
2793         uint32_t id;
2794         Job *j;
2795         int r;
2796
2797         assert(message);
2798
2799         r = sd_bus_message_read(message, "u", &id);
2800         if (r < 0)
2801                 return r;
2802
2803         j = manager_get_job(m, id);
2804         if (!j)
2805                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2806
2807         return bus_job_method_get_waiting_jobs(message, j, error);
2808 }
2809
2810 static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2811         Manager *m = ASSERT_PTR(userdata);
2812         const char *name;
2813         Unit *u;
2814         int r;
2815
2816         assert(message);
2817
2818         r = sd_bus_message_read(message, "s", &name);
2819         if (r < 0)
2820                 return r;
2821
2822         r = bus_get_unit_by_name(m, message, name, &u, error);
2823         if (r < 0)
2824                 return r;
2825
2826         if (u->type != UNIT_SCOPE)
2827                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2828                                          "Unit '%s' is not a scope unit, refusing.", name);
2829
2830         return bus_scope_method_abandon(message, u, error);
2831 }
2832
2833 static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2834         Manager *m = ASSERT_PTR(userdata);
2835         ShowStatus mode = _SHOW_STATUS_INVALID;
2836         const char *t;
2837         int r;
2838
2839         assert(message);
2840
2841         r = mac_selinux_access_check(message, "reload", error);
2842         if (r < 0)
2843                 return r;
2844
2845         r = bus_verify_set_environment_async(m, message, error);
2846         if (r < 0)
2847                 return r;
2848         if (r == 0)
2849                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2850
2851         r = sd_bus_message_read(message, "s", &t);
2852         if (r < 0)
2853                 return r;
2854
2855         if (!isempty(t)) {
2856                 mode = show_status_from_string(t);
2857                 if (mode < 0)
2858                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2859                                                  "Invalid show status '%s'", t);
2860         }
2861
2862         manager_override_show_status(m, mode, "bus");
2863
2864         return sd_bus_reply_method_return(message, NULL);
2865 }
2866
2867 static int method_dump_unit_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2868         return method_generic_unit_operation(message, userdata, error, bus_service_method_dump_file_descriptor_store, 0);
2869 }
2870
2871 static int aux_scope_from_message(Manager *m, sd_bus_message *message, Unit **ret_scope, sd_bus_error *error) {
2872         _cleanup_(pidref_done) PidRef sender_pidref = PIDREF_NULL;
2873         _cleanup_free_ PidRef *pidrefs = NULL;
2874         const char *name;
2875         Unit *from, *scope;
2876         PidRef *main_pid;
2877         CGroupContext *cc;
2878         size_t n_pids = 0;
2879         uint64_t flags;
2880         int r;
2881
2882         assert(ret_scope);
2883
2884         r = bus_query_sender_pidref(message, &sender_pidref);
2885         if (r < 0)
2886                 return r;
2887
2888         from = manager_get_unit_by_pidref(m, &sender_pidref);
2889         if (!from)
2890                 return sd_bus_error_set(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
2891
2892         if (!IN_SET(from->type, UNIT_SERVICE, UNIT_SCOPE))
2893                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2894                                          "Starting auxiliary scope is supported only for service and scope units, refusing.");
2895
2896         if (!unit_name_is_valid(from->id, UNIT_NAME_PLAIN))
2897                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2898                                          "Auxiliary scope can be started only for non-template service units and scope units, refusing.");
2899
2900         r = sd_bus_message_read(message, "s", &name);
2901         if (r < 0)
2902                 return r;
2903
2904         if (!unit_name_is_valid(name, UNIT_NAME_PLAIN))
2905                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2906                                          "Invalid name \"%s\" for auxiliary scope.", name);
2907
2908         if (unit_name_to_type(name) != UNIT_SCOPE)
2909                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2910                                          "Name \"%s\" of auxiliary scope doesn't have .scope suffix.", name);
2911
2912         main_pid = unit_main_pid(from);
2913
2914         r = sd_bus_message_enter_container(message, 'a', "h");
2915         if (r < 0)
2916                 return r;
2917
2918         for (;;) {
2919                 _cleanup_(pidref_done) PidRef p = PIDREF_NULL;
2920                 Unit *unit;
2921                 int fd;
2922
2923                 r = sd_bus_message_read(message, "h", &fd);
2924                 if (r < 0)
2925                         return r;
2926                 if (r == 0)
2927                         break;
2928
2929                 r = pidref_set_pidfd(&p, fd);
2930                 if (r < 0) {
2931                         log_unit_warning_errno(from, r, "Failed to create process reference from PIDFD, ignoring: %m");
2932                         continue;
2933                 }
2934
2935                 unit = manager_get_unit_by_pidref(m, &p);
2936                 if (!unit) {
2937                         log_unit_warning_errno(from, SYNTHETIC_ERRNO(ENOENT), "Failed to get unit from PIDFD, ignoring: %m");
2938                         continue;
2939                 }
2940
2941                 if (!streq(unit->id, from->id)) {
2942                         log_unit_warning(from, "PID " PID_FMT " is not running in the same service as the calling process, ignoring.", p.pid);
2943                         continue;
2944                 }
2945
2946                 if (pidref_equal(main_pid, &p)) {
2947                         log_unit_warning(from, "Main PID cannot be migrated into auxiliary scope, ignoring.");
2948                         continue;
2949                 }
2950
2951                 if (!GREEDY_REALLOC(pidrefs, n_pids+1))
2952                         return -ENOMEM;
2953
2954                 pidrefs[n_pids++] = TAKE_PIDREF(p);
2955         }
2956
2957         if (n_pids == 0)
2958                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "No processes can be migrated to auxiliary scope.");
2959
2960         r = sd_bus_message_exit_container(message);
2961         if (r < 0)
2962                 return r;
2963
2964         r = sd_bus_message_read(message, "t", &flags);
2965         if (r < 0)
2966                 return r;
2967
2968         if (flags != 0)
2969                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Flags must be zero.");
2970
2971         r = manager_load_unit(m, name, NULL, error, &scope);
2972         if (r < 0)
2973                 return r;
2974
2975         if (!unit_is_pristine(scope))
2976                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2977                                          "Unit %s was already loaded or has a fragment file.", name);
2978
2979         r = unit_set_slice(scope, UNIT_GET_SLICE(from));
2980         if (r < 0)
2981                 return r;
2982
2983         cc = unit_get_cgroup_context(scope);
2984
2985         r = cgroup_context_copy(cc, unit_get_cgroup_context(from));
2986         if (r < 0)
2987                 return r;
2988
2989         r = unit_make_transient(scope);
2990         if (r < 0)
2991                 return r;
2992
2993         r = bus_unit_set_properties(scope, message, UNIT_RUNTIME, true, error);
2994         if (r < 0)
2995                 return r;
2996
2997         FOREACH_ARRAY(p, pidrefs, n_pids) {
2998                 r = unit_pid_attachable(scope, p, error);
2999                 if (r < 0)
3000                         return r;
3001
3002                 r = unit_watch_pidref(scope, p, /* exclusive= */ false);
3003                 if (r < 0 && r != -EEXIST)
3004                         return r;
3005         }
3006
3007         /* Now load the missing bits of the unit we just created */
3008         unit_add_to_load_queue(scope);
3009         manager_dispatch_load_queue(m);
3010
3011         *ret_scope = TAKE_PTR(scope);
3012
3013         return 1;
3014 }
3015
3016 static int method_start_aux_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
3017         Manager *m = ASSERT_PTR(userdata);
3018         Unit *u = NULL; /* avoid false maybe-uninitialized warning */
3019         int r;
3020
3021         assert(message);
3022
3023         r = mac_selinux_access_check(message, "start", error);
3024         if (r < 0)
3025                 return r;
3026
3027         r = bus_verify_manage_units_async(m, message, error);
3028         if (r < 0)
3029                 return r;
3030         if (r == 0)
3031                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
3032
3033         r = aux_scope_from_message(m, message, &u, error);
3034         if (r < 0)
3035                 return r;
3036
3037         return bus_unit_queue_job(message, u, JOB_START, JOB_REPLACE, 0, error);
3038 }
3039
3040 const sd_bus_vtable bus_manager_vtable[] = {
3041         SD_BUS_VTABLE_START(0),
3042
3043         SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3044         SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3045         SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3046         SD_BUS_PROPERTY("ConfidentialVirtualization", "s", property_get_confidential_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3047         SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3048         SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3049         BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
3050         BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
3051         BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
3052         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
3053         BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
3054         BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3055         BUS_PROPERTY_DUAL_TIMESTAMP("SoftRebootStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SOFTREBOOT_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3056         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3057         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3058         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3059         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3060         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3061         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3062         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD]), SD_BUS_VTABLE_PROPERTY_CONST),
3063         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3064         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3065         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3066         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3067         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
3068         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
3069         SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3070         SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3071         SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
3072         SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
3073         SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
3074         SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
3075         SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
3076         SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
3077         SD_BUS_PROPERTY("Environment", "as", property_get_environment, 0, 0),
3078         SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
3079         SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
3080         SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
3081         SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, defaults.std_output), SD_BUS_VTABLE_PROPERTY_CONST),
3082         SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, defaults.std_error), SD_BUS_VTABLE_PROPERTY_CONST),
3083         SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3084         SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime, 0, 0),
3085         SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic, 0, 0),
3086         SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog, property_set_runtime_watchdog, 0, 0),
3087         SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog, property_set_pretimeout_watchdog, 0, 0),
3088         SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor, property_set_pretimeout_watchdog_governor, 0, 0),
3089         SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, 0),
3090         /* The following item is an obsolete alias */
3091         SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, SD_BUS_VTABLE_HIDDEN),
3092         SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog, property_set_kexec_watchdog, 0, 0),
3093         SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
3094         SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
3095         SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
3096         SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
3097         SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3098         SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3099         SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3100         SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec, 0, 0),
3101         SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.device_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3102         SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
3103         SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
3104         /* The following two items are obsolete alias */
3105         SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
3106         SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, defaults.start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
3107         SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, defaults.start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
3108         SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3109         SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3110         SD_BUS_PROPERTY("DefaultIOAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.io_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3111         SD_BUS_PROPERTY("DefaultIPAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.ip_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3112         SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3113         SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, defaults.tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
3114         SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
3115         SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
3116         SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
3117         SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
3118         SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
3119         SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
3120         SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
3121         SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
3122         SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
3123         SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
3124         SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
3125         SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
3126         SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
3127         SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
3128         SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
3129         SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
3130         SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
3131         SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
3132         SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
3133         SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
3134         SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
3135         SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
3136         SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
3137         SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
3138         SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
3139         SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
3140         SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
3141         SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
3142         SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
3143         SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
3144         SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3145         SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, defaults.rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3146         SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max, offsetof(Manager, defaults.tasks_max), 0),
3147         SD_BUS_PROPERTY("DefaultMemoryPressureThresholdUSec", "t", bus_property_get_usec, offsetof(Manager, defaults.memory_pressure_threshold_usec), 0),
3148         SD_BUS_PROPERTY("DefaultMemoryPressureWatch", "s", bus_property_get_cgroup_pressure_watch, offsetof(Manager, defaults.memory_pressure_watch), 0),
3149         SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3150         SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy, offsetof(Manager, defaults.oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
3151         SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
3152         SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
3153         SD_BUS_PROPERTY("SoftRebootsCount", "u", bus_property_get_unsigned, offsetof(Manager, soft_reboots_count), SD_BUS_VTABLE_PROPERTY_CONST),
3154
3155         SD_BUS_METHOD_WITH_ARGS("GetUnit",
3156                                 SD_BUS_ARGS("s", name),
3157                                 SD_BUS_RESULT("o", unit),
3158                                 method_get_unit,
3159                                 SD_BUS_VTABLE_UNPRIVILEGED),
3160         SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
3161                                 SD_BUS_ARGS("u", pid),
3162                                 SD_BUS_RESULT("o", unit),
3163                                 method_get_unit_by_pid,
3164                                 SD_BUS_VTABLE_UNPRIVILEGED),
3165         SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
3166                                 SD_BUS_ARGS("ay", invocation_id),
3167                                 SD_BUS_RESULT("o", unit),
3168                                 method_get_unit_by_invocation_id,
3169                                 SD_BUS_VTABLE_UNPRIVILEGED),
3170         SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
3171                                 SD_BUS_ARGS("s", cgroup),
3172                                 SD_BUS_RESULT("o", unit),
3173                                 method_get_unit_by_control_group,
3174                                 SD_BUS_VTABLE_UNPRIVILEGED),
3175         SD_BUS_METHOD_WITH_ARGS("GetUnitByPIDFD",
3176                                 SD_BUS_ARGS("h", pidfd),
3177                                 SD_BUS_RESULT("o", unit, "s", unit_id, "ay", invocation_id),
3178                                 method_get_unit_by_pidfd,
3179                                 SD_BUS_VTABLE_UNPRIVILEGED),
3180         SD_BUS_METHOD_WITH_ARGS("LoadUnit",
3181                                 SD_BUS_ARGS("s", name),
3182                                 SD_BUS_RESULT("o", unit),
3183                                 method_load_unit,
3184                                 SD_BUS_VTABLE_UNPRIVILEGED),
3185         SD_BUS_METHOD_WITH_ARGS("StartUnit",
3186                                 SD_BUS_ARGS("s", name, "s", mode),
3187                                 SD_BUS_RESULT("o", job),
3188                                 method_start_unit,
3189                                 SD_BUS_VTABLE_UNPRIVILEGED),
3190         SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
3191                                 SD_BUS_ARGS("s", name, "s", mode, "t", flags),
3192                                 SD_BUS_RESULT("o", job),
3193                                 method_start_unit,
3194                                 SD_BUS_VTABLE_UNPRIVILEGED),
3195         SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
3196                                 SD_BUS_ARGS("s", old_unit, "s", new_unit, "s", mode),
3197                                 SD_BUS_RESULT("o", job),
3198                                 method_start_unit_replace,
3199                                 SD_BUS_VTABLE_UNPRIVILEGED),
3200         SD_BUS_METHOD_WITH_ARGS("StopUnit",
3201                                 SD_BUS_ARGS("s", name, "s", mode),
3202                                 SD_BUS_RESULT("o", job),
3203                                 method_stop_unit,
3204                                 SD_BUS_VTABLE_UNPRIVILEGED),
3205         SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
3206                                 SD_BUS_ARGS("s", name, "s", mode),
3207                                 SD_BUS_RESULT("o", job),
3208                                 method_reload_unit,
3209                                 SD_BUS_VTABLE_UNPRIVILEGED),
3210         SD_BUS_METHOD_WITH_ARGS("RestartUnit",
3211                                 SD_BUS_ARGS("s", name, "s", mode),
3212                                 SD_BUS_RESULT("o", job),
3213                                 method_restart_unit,
3214                                 SD_BUS_VTABLE_UNPRIVILEGED),
3215         SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
3216                                 SD_BUS_ARGS("s", name, "s", mode),
3217                                 SD_BUS_RESULT("o", job),
3218                                 method_try_restart_unit,
3219                                 SD_BUS_VTABLE_UNPRIVILEGED),
3220         SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
3221                                 SD_BUS_ARGS("s", name, "s", mode),
3222                                 SD_BUS_RESULT("o", job),
3223                                 method_reload_or_restart_unit,
3224                                 SD_BUS_VTABLE_UNPRIVILEGED),
3225         SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
3226                                 SD_BUS_ARGS("s", name, "s", mode),
3227                                 SD_BUS_RESULT("o", job),
3228                                 method_reload_or_try_restart_unit,
3229                                 SD_BUS_VTABLE_UNPRIVILEGED),
3230         SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
3231                                 SD_BUS_ARGS("s", name, "s", job_type, "s", job_mode),
3232                                 SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
3233                                 method_enqueue_unit_job,
3234                                 SD_BUS_VTABLE_UNPRIVILEGED),
3235         SD_BUS_METHOD_WITH_ARGS("KillUnit",
3236                                 SD_BUS_ARGS("s", name, "s", whom, "i", signal),
3237                                 SD_BUS_NO_RESULT,
3238                                 method_kill_unit,
3239                                 SD_BUS_VTABLE_UNPRIVILEGED),
3240         SD_BUS_METHOD_WITH_ARGS("QueueSignalUnit",
3241                                 SD_BUS_ARGS("s", name, "s", whom, "i", signal, "i", value),
3242                                 SD_BUS_NO_RESULT,
3243                                 method_kill_unit,
3244                                 SD_BUS_VTABLE_UNPRIVILEGED),
3245         SD_BUS_METHOD_WITH_ARGS("CleanUnit",
3246                                 SD_BUS_ARGS("s", name, "as", mask),
3247                                 SD_BUS_NO_RESULT,
3248                                 method_clean_unit,
3249                                 SD_BUS_VTABLE_UNPRIVILEGED),
3250         SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
3251                                 SD_BUS_ARGS("s", name),
3252                                 SD_BUS_NO_RESULT,
3253                                 method_freeze_unit,
3254                                 SD_BUS_VTABLE_UNPRIVILEGED),
3255         SD_BUS_METHOD_WITH_ARGS("ThawUnit",
3256                                 SD_BUS_ARGS("s", name),
3257                                 SD_BUS_NO_RESULT,
3258                                 method_thaw_unit,
3259                                 SD_BUS_VTABLE_UNPRIVILEGED),
3260         SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
3261                                 SD_BUS_ARGS("s", name),
3262                                 SD_BUS_NO_RESULT,
3263                                 method_reset_failed_unit,
3264                                 SD_BUS_VTABLE_UNPRIVILEGED),
3265         SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
3266                                 SD_BUS_ARGS("s", name, "b", runtime, "a(sv)", properties),
3267                                 SD_BUS_NO_RESULT,
3268                                 method_set_unit_properties,
3269                                 SD_BUS_VTABLE_UNPRIVILEGED),
3270         SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
3271                                 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir),
3272                                 SD_BUS_NO_RESULT,
3273                                 method_bind_mount_unit,
3274                                 SD_BUS_VTABLE_UNPRIVILEGED),
3275         SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
3276                                 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
3277                                 SD_BUS_NO_RESULT,
3278                                 method_mount_image_unit,
3279                                 SD_BUS_VTABLE_UNPRIVILEGED),
3280         SD_BUS_METHOD_WITH_ARGS("RefUnit",
3281                                 SD_BUS_ARGS("s", name),
3282                                 SD_BUS_NO_RESULT,
3283                                 method_ref_unit,
3284                                 SD_BUS_VTABLE_UNPRIVILEGED),
3285         SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
3286                                 SD_BUS_ARGS("s", name),
3287                                 SD_BUS_NO_RESULT,
3288                                 method_unref_unit,
3289                                 SD_BUS_VTABLE_UNPRIVILEGED),
3290         SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
3291                                 SD_BUS_ARGS("s", name, "s", mode, "a(sv)", properties, "a(sa(sv))", aux),
3292                                 SD_BUS_RESULT("o", job),
3293                                 method_start_transient_unit,
3294                                 SD_BUS_VTABLE_UNPRIVILEGED),
3295         SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
3296                                 SD_BUS_ARGS("s", name),
3297                                 SD_BUS_RESULT("a(sus)", processes),
3298                                 method_get_unit_processes,
3299                                 SD_BUS_VTABLE_UNPRIVILEGED),
3300         SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
3301                                 SD_BUS_ARGS("s", unit_name, "s", subcgroup, "au", pids),
3302                                 SD_BUS_NO_RESULT,
3303                                 method_attach_processes_to_unit,
3304                                 SD_BUS_VTABLE_UNPRIVILEGED),
3305         SD_BUS_METHOD_WITH_ARGS("AbandonScope",
3306                                 SD_BUS_ARGS("s", name),
3307                                 SD_BUS_NO_RESULT,
3308                                 method_abandon_scope,
3309                                 SD_BUS_VTABLE_UNPRIVILEGED),
3310         SD_BUS_METHOD_WITH_ARGS("GetJob",
3311                                 SD_BUS_ARGS("u", id),
3312                                 SD_BUS_RESULT("o", job),
3313                                 method_get_job,
3314                                 SD_BUS_VTABLE_UNPRIVILEGED),
3315         SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
3316                                 SD_BUS_ARGS("u", id),
3317                                 SD_BUS_RESULT("a(usssoo)", jobs),
3318                                 method_get_job_waiting,
3319                                 SD_BUS_VTABLE_UNPRIVILEGED),
3320         SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
3321                                 SD_BUS_ARGS("u", id),
3322                                 SD_BUS_RESULT("a(usssoo)", jobs),
3323                                 method_get_job_waiting,
3324                                 SD_BUS_VTABLE_UNPRIVILEGED),
3325         SD_BUS_METHOD_WITH_ARGS("CancelJob",
3326                                 SD_BUS_ARGS("u", id),
3327                                 SD_BUS_NO_RESULT,
3328                                 method_cancel_job,
3329                                 SD_BUS_VTABLE_UNPRIVILEGED),
3330         SD_BUS_METHOD("ClearJobs",
3331                       NULL,
3332                       NULL,
3333                       method_clear_jobs,
3334                       SD_BUS_VTABLE_UNPRIVILEGED),
3335         SD_BUS_METHOD("ResetFailed",
3336                       NULL,
3337                       NULL,
3338                       method_reset_failed,
3339                       SD_BUS_VTABLE_UNPRIVILEGED),
3340         SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
3341                                 SD_BUS_ARGS("s", mode),
3342                                 SD_BUS_NO_RESULT,
3343                                 method_set_show_status,
3344                                 SD_BUS_VTABLE_UNPRIVILEGED),
3345         SD_BUS_METHOD_WITH_ARGS("ListUnits",
3346                                 SD_BUS_NO_ARGS,
3347                                 SD_BUS_RESULT("a(ssssssouso)", units),
3348                                 method_list_units,
3349                                 SD_BUS_VTABLE_UNPRIVILEGED),
3350         SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
3351                                 SD_BUS_ARGS("as", states),
3352                                 SD_BUS_RESULT("a(ssssssouso)", units),
3353                                 method_list_units_filtered,
3354                                 SD_BUS_VTABLE_UNPRIVILEGED),
3355         SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3356                                 SD_BUS_ARGS("as", states, "as", patterns),
3357                                 SD_BUS_RESULT("a(ssssssouso)", units),
3358                                 method_list_units_by_patterns,
3359                                 SD_BUS_VTABLE_UNPRIVILEGED),
3360         SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3361                                 SD_BUS_ARGS("as", names),
3362                                 SD_BUS_RESULT("a(ssssssouso)", units),
3363                                 method_list_units_by_names,
3364                                 SD_BUS_VTABLE_UNPRIVILEGED),
3365         SD_BUS_METHOD_WITH_ARGS("ListJobs",
3366                                 SD_BUS_NO_ARGS,
3367                                 SD_BUS_RESULT("a(usssoo)", jobs),
3368                                 method_list_jobs,
3369                                 SD_BUS_VTABLE_UNPRIVILEGED),
3370         SD_BUS_METHOD("Subscribe",
3371                       NULL,
3372                       NULL,
3373                       method_subscribe,
3374                       SD_BUS_VTABLE_UNPRIVILEGED),
3375         SD_BUS_METHOD("Unsubscribe",
3376                       NULL,
3377                       NULL,
3378                       method_unsubscribe,
3379                       SD_BUS_VTABLE_UNPRIVILEGED),
3380         SD_BUS_METHOD_WITH_ARGS("Dump",
3381                                 SD_BUS_NO_ARGS,
3382                                 SD_BUS_RESULT("s", output),
3383                                 method_dump,
3384                                 SD_BUS_VTABLE_UNPRIVILEGED),
3385         SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatterns",
3386                                 SD_BUS_ARGS("as", patterns),
3387                                 SD_BUS_RESULT("s", output),
3388                                 method_dump_units_matching_patterns,
3389                                 SD_BUS_VTABLE_UNPRIVILEGED),
3390         SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3391                                 SD_BUS_NO_ARGS,
3392                                 SD_BUS_RESULT("h", fd),
3393                                 method_dump_by_fd,
3394                                 SD_BUS_VTABLE_UNPRIVILEGED),
3395         SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatternsByFileDescriptor",
3396                                 SD_BUS_ARGS("as", patterns),
3397                                 SD_BUS_RESULT("h", fd),
3398                                 method_dump_units_matching_patterns_by_fd,
3399                                 SD_BUS_VTABLE_UNPRIVILEGED),
3400         SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3401                                 SD_BUS_ARGS("s", name, "b", cleanup),
3402                                 SD_BUS_RESULT("o", unit),
3403                                 method_refuse_snapshot,
3404                                 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3405         SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3406                                 SD_BUS_ARGS("s", name),
3407                                 SD_BUS_NO_RESULT,
3408                                 method_refuse_snapshot,
3409                                 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3410         SD_BUS_METHOD("Reload",
3411                       NULL,
3412                       NULL,
3413                       method_reload,
3414                       SD_BUS_VTABLE_UNPRIVILEGED),
3415         SD_BUS_METHOD("Reexecute",
3416                       NULL,
3417                       NULL,
3418                       method_reexecute,
3419                       SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_METHOD_NO_REPLY),
3420         SD_BUS_METHOD("Exit",
3421                       NULL,
3422                       NULL,
3423                       method_exit,
3424                       0),
3425         SD_BUS_METHOD("Reboot",
3426                       NULL,
3427                       NULL,
3428                       method_reboot,
3429                       SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3430         SD_BUS_METHOD_WITH_ARGS("SoftReboot",
3431                                 SD_BUS_ARGS("s", new_root),
3432                                 SD_BUS_NO_RESULT,
3433                                 method_soft_reboot,
3434                                 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3435         SD_BUS_METHOD("PowerOff",
3436                       NULL,
3437                       NULL,
3438                       method_poweroff,
3439                       SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3440         SD_BUS_METHOD("Halt",
3441                       NULL,
3442                       NULL,
3443                       method_halt,
3444                       SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3445         SD_BUS_METHOD("KExec",
3446                       NULL,
3447                       NULL,
3448                       method_kexec,
3449                       SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3450         SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3451                                 SD_BUS_ARGS("s", new_root, "s", init),
3452                                 SD_BUS_NO_RESULT,
3453                                 method_switch_root,
3454                                 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3455         SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3456                                 SD_BUS_ARGS("as", assignments),
3457                                 SD_BUS_NO_RESULT,
3458                                 method_set_environment,
3459                                 SD_BUS_VTABLE_UNPRIVILEGED),
3460         SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3461                                 SD_BUS_ARGS("as", names),
3462                                 SD_BUS_NO_RESULT,
3463                                 method_unset_environment,
3464                                 SD_BUS_VTABLE_UNPRIVILEGED),
3465         SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3466                                 SD_BUS_ARGS("as", names, "as", assignments),
3467                                 SD_BUS_NO_RESULT,
3468                                 method_unset_and_set_environment,
3469                                 SD_BUS_VTABLE_UNPRIVILEGED),
3470         SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3471                                 SD_BUS_NO_ARGS,
3472                                 SD_BUS_RESULT("ao", jobs),
3473                                 method_enqueue_marked_jobs,
3474                                 SD_BUS_VTABLE_UNPRIVILEGED),
3475         SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3476                                 SD_BUS_NO_ARGS,
3477                                 SD_BUS_RESULT("a(ss)", unit_files),
3478                                 method_list_unit_files,
3479                                 SD_BUS_VTABLE_UNPRIVILEGED),
3480         SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3481                                 SD_BUS_ARGS("as", states, "as", patterns),
3482                                 SD_BUS_RESULT("a(ss)", unit_files),
3483                                 method_list_unit_files_by_patterns,
3484                                 SD_BUS_VTABLE_UNPRIVILEGED),
3485         SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3486                                 SD_BUS_ARGS("s", file),
3487                                 SD_BUS_RESULT("s", state),
3488                                 method_get_unit_file_state,
3489                                 SD_BUS_VTABLE_UNPRIVILEGED),
3490         SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3491                                 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3492                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3493                                 method_enable_unit_files,
3494                                 SD_BUS_VTABLE_UNPRIVILEGED),
3495         SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3496                                 SD_BUS_ARGS("as", files, "b", runtime),
3497                                 SD_BUS_RESULT("a(sss)", changes),
3498                                 method_disable_unit_files,
3499                                 SD_BUS_VTABLE_UNPRIVILEGED),
3500         SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3501                                 SD_BUS_ARGS("as", files, "t", flags),
3502                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3503                                 method_enable_unit_files_with_flags,
3504                                 SD_BUS_VTABLE_UNPRIVILEGED),
3505         SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3506                                 SD_BUS_ARGS("as", files, "t", flags),
3507                                 SD_BUS_RESULT("a(sss)", changes),
3508                                 method_disable_unit_files_with_flags,
3509                                 SD_BUS_VTABLE_UNPRIVILEGED),
3510         SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlagsAndInstallInfo",
3511                                 SD_BUS_ARGS("as", files, "t", flags),
3512                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3513                                 method_disable_unit_files_with_flags_and_install_info,
3514                                 SD_BUS_VTABLE_UNPRIVILEGED),
3515         SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3516                                 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3517                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3518                                 method_reenable_unit_files,
3519                                 SD_BUS_VTABLE_UNPRIVILEGED),
3520         SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3521                                 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3522                                 SD_BUS_RESULT("a(sss)", changes),
3523                                 method_link_unit_files,
3524                                 SD_BUS_VTABLE_UNPRIVILEGED),
3525         SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3526                                 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3527                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3528                                 method_preset_unit_files,
3529                                 SD_BUS_VTABLE_UNPRIVILEGED),
3530         SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3531                                 SD_BUS_ARGS("as", files, "s", mode, "b", runtime, "b", force),
3532                                 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3533                                 method_preset_unit_files_with_mode,
3534                                 SD_BUS_VTABLE_UNPRIVILEGED),
3535         SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3536                                 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3537                                 SD_BUS_RESULT("a(sss)", changes),
3538                                 method_mask_unit_files,
3539                                 SD_BUS_VTABLE_UNPRIVILEGED),
3540         SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3541                                 SD_BUS_ARGS("as", files, "b", runtime),
3542                                 SD_BUS_RESULT("a(sss)", changes),
3543                                 method_unmask_unit_files,
3544                                 SD_BUS_VTABLE_UNPRIVILEGED),
3545         SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3546                                 SD_BUS_ARGS("as", files),
3547                                 SD_BUS_RESULT("a(sss)", changes),
3548                                 method_revert_unit_files,
3549                                 SD_BUS_VTABLE_UNPRIVILEGED),
3550         SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3551                                 SD_BUS_ARGS("s", name, "b", force),
3552                                 SD_BUS_RESULT("a(sss)", changes),
3553                                 method_set_default_target,
3554                                 SD_BUS_VTABLE_UNPRIVILEGED),
3555         SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3556                                 SD_BUS_NO_ARGS,
3557                                 SD_BUS_RESULT("s", name),
3558                                 method_get_default_target,
3559                                 SD_BUS_VTABLE_UNPRIVILEGED),
3560         SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3561                                 SD_BUS_ARGS("s", mode, "b", runtime, "b", force),
3562                                 SD_BUS_RESULT("a(sss)", changes),
3563                                 method_preset_all_unit_files,
3564                                 SD_BUS_VTABLE_UNPRIVILEGED),
3565         SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3566                                 SD_BUS_ARGS("as", files, "s", target, "s", type, "b", runtime, "b", force),
3567                                 SD_BUS_RESULT("a(sss)", changes),
3568                                 method_add_dependency_unit_files,
3569                                 SD_BUS_VTABLE_UNPRIVILEGED),
3570         SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3571                                 SD_BUS_ARGS("s", name, "b", runtime),
3572                                 SD_BUS_RESULT("as", links),
3573                                 method_get_unit_file_links,
3574                                 SD_BUS_VTABLE_UNPRIVILEGED),
3575         SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3576                                 SD_BUS_ARGS("y", number),
3577                                 SD_BUS_NO_RESULT,
3578                                 method_set_exit_code,
3579                                 SD_BUS_VTABLE_UNPRIVILEGED),
3580         SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3581                                 SD_BUS_ARGS("s", name),
3582                                 SD_BUS_RESULT("u", uid),
3583                                 method_lookup_dynamic_user_by_name,
3584                                 SD_BUS_VTABLE_UNPRIVILEGED),
3585         SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3586                                 SD_BUS_ARGS("u", uid),
3587                                 SD_BUS_RESULT("s", name),
3588                                 method_lookup_dynamic_user_by_uid,
3589                                 SD_BUS_VTABLE_UNPRIVILEGED),
3590         SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3591                                 SD_BUS_NO_ARGS,
3592                                 SD_BUS_RESULT("a(us)", users),
3593                                 method_get_dynamic_users,
3594                                 SD_BUS_VTABLE_UNPRIVILEGED),
3595         SD_BUS_METHOD_WITH_ARGS("DumpUnitFileDescriptorStore",
3596                                 SD_BUS_ARGS("s", name),
3597                                 SD_BUS_RESULT("a(suuutuusu)", entries),
3598                                 method_dump_unit_descriptor_store,
3599                                 SD_BUS_VTABLE_UNPRIVILEGED),
3600         SD_BUS_METHOD_WITH_ARGS("StartAuxiliaryScope",
3601                                 SD_BUS_ARGS("s", name, "ah", pidfds, "t", flags, "a(sv)", properties),
3602                                 SD_BUS_RESULT("o", job),
3603                                 method_start_aux_scope,
3604                                 SD_BUS_VTABLE_UNPRIVILEGED),
3605
3606         SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3607                                 SD_BUS_ARGS("s", id, "o", unit),
3608                                 0),
3609         SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3610                                 SD_BUS_ARGS("s", id, "o", unit),
3611                                 0),
3612         SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3613                                 SD_BUS_ARGS("u", id, "o", job, "s", unit),
3614                                 0),
3615         SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3616                                 SD_BUS_ARGS("u", id, "o", job, "s", unit, "s", result),
3617                                 0),
3618         SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3619                                 SD_BUS_ARGS("t", firmware, "t", loader, "t", kernel, "t", initrd, "t", userspace, "t", total),
3620                                 0),
3621         SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
3622         SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3623                                 SD_BUS_ARGS("b", active),
3624                                 0),
3625
3626         SD_BUS_VTABLE_END
3627 };
3628
3629 const sd_bus_vtable bus_manager_log_control_vtable[] = {
3630         SD_BUS_VTABLE_START(0),
3631
3632         /* We define a private version of this interface here, since we want slightly different
3633          * implementations for the setters. We'll still use the generic getters however, and we share the
3634          * setters with the implementations for the Manager interface above (which pre-dates the generic
3635          * service API interface). */
3636
3637         SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3638         SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3639         SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier, 0, 0),
3640
3641         SD_BUS_VTABLE_END,
3642 };
3643
3644 static int send_finished(sd_bus *bus, void *userdata) {
3645         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
3646         usec_t *times = ASSERT_PTR(userdata);
3647         int r;
3648
3649         assert(bus);
3650
3651         r = sd_bus_message_new_signal(bus,
3652                                       &message,
3653                                       "/org/freedesktop/systemd1",
3654                                       "org.freedesktop.systemd1.Manager",
3655                                       "StartupFinished");
3656         if (r < 0)
3657                 return r;
3658
3659         r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
3660         if (r < 0)
3661                 return r;
3662
3663         return sd_bus_send(bus, message, NULL);
3664 }
3665
3666 void bus_manager_send_finished(
3667                 Manager *m,
3668                 usec_t firmware_usec,
3669                 usec_t loader_usec,
3670                 usec_t kernel_usec,
3671                 usec_t initrd_usec,
3672                 usec_t userspace_usec,
3673                 usec_t total_usec) {
3674
3675         int r;
3676
3677         assert(m);
3678
3679         r = bus_foreach_bus(
3680                         m,
3681                         NULL,
3682                         send_finished,
3683                         (usec_t[6]) {
3684                                 firmware_usec,
3685                                 loader_usec,
3686                                 kernel_usec,
3687                                 initrd_usec,
3688                                 userspace_usec,
3689                                 total_usec
3690                         });
3691         if (r < 0)
3692                 log_debug_errno(r, "Failed to send finished signal: %m");
3693 }
3694
3695 static int send_reloading(sd_bus *bus, void *userdata) {
3696         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
3697         int r;
3698
3699         assert(bus);
3700
3701         r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
3702         if (r < 0)
3703                 return r;
3704
3705         r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
3706         if (r < 0)
3707                 return r;
3708
3709         return sd_bus_send(bus, message, NULL);
3710 }
3711
3712 void bus_manager_send_reloading(Manager *m, bool active) {
3713         int r;
3714
3715         assert(m);
3716
3717         r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
3718         if (r < 0)
3719                 log_debug_errno(r, "Failed to send reloading signal: %m");
3720 }
3721
3722 static int send_changed_signal(sd_bus *bus, void *userdata) {
3723         assert(bus);
3724
3725         return sd_bus_emit_properties_changed_strv(bus,
3726                                                    "/org/freedesktop/systemd1",
3727                                                    "org.freedesktop.systemd1.Manager",
3728                                                    NULL);
3729 }
3730
3731 void bus_manager_send_change_signal(Manager *m) {
3732         int r;
3733
3734         assert(m);
3735
3736         r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
3737         if (r < 0)
3738                 log_debug_errno(r, "Failed to send manager change signal: %m");
3739 }