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