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