src/core/dbus-manager.c

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