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