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