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