src/core/dbus-manager.c

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