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