src/core/dbus-manager.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <sys/prctl.h>
  22 #include <unistd.h>
  23
  24 #include "alloc-util.h"
  25 #include "architecture.h"
  26 #include "build.h"
  27 #include "bus-common-errors.h"
  28 #include "clock-util.h"
  29 #include "dbus-execute.h"
  30 #include "dbus-job.h"
  31 #include "dbus-manager.h"
  32 #include "dbus-unit.h"
  33 #include "dbus.h"
  34 #include "env-util.h"
  35 #include "fd-util.h"
  36 #include "fileio.h"
  37 #include "formats-util.h"
  38 #include "install.h"
  39 #include "log.h"
  40 #include "path-util.h"
  41 #include "selinux-access.h"
  42 #include "stat-util.h"
  43 #include "string-util.h"
  44 #include "strv.h"
  45 #include "syslog-util.h"
  46 #include "virt.h"
  47 #include "watchdog.h"
  48
  49 static int property_get_version(
  50                 sd_bus *bus,
  51                 const char *path,
  52                 const char *interface,
  53                 const char *property,
  54                 sd_bus_message *reply,
  55                 void *userdata,
  56                 sd_bus_error *error) {
  57
  58         assert(bus);
  59         assert(reply);
  60
  61         return sd_bus_message_append(reply, "s", PACKAGE_VERSION);
  62 }
  63
  64 static int property_get_features(
  65                 sd_bus *bus,
  66                 const char *path,
  67                 const char *interface,
  68                 const char *property,
  69                 sd_bus_message *reply,
  70                 void *userdata,
  71                 sd_bus_error *error) {
  72
  73         assert(bus);
  74         assert(reply);
  75
  76         return sd_bus_message_append(reply, "s", SYSTEMD_FEATURES);
  77 }
  78
  79 static int property_get_virtualization(
  80                 sd_bus *bus,
  81                 const char *path,
  82                 const char *interface,
  83                 const char *property,
  84                 sd_bus_message *reply,
  85                 void *userdata,
  86                 sd_bus_error *error) {
  87
  88         int v;
  89
  90         assert(bus);
  91         assert(reply);
  92
  93         v = detect_virtualization();
  94
  95         /* Make sure to return the empty string when we detect no virtualization, as that is the API.
  96          *
  97          * https://github.com/systemd/systemd/issues/1423
  98          */
  99
 100         return sd_bus_message_append(
 101                         reply, "s",
 102                         v == VIRTUALIZATION_NONE ? "" : virtualization_to_string(v));
 103 }
 104
 105 static int property_get_architecture(
 106                 sd_bus *bus,
 107                 const char *path,
 108                 const char *interface,
 109                 const char *property,
 110                 sd_bus_message *reply,
 111                 void *userdata,
 112                 sd_bus_error *error) {
 113
 114         assert(bus);
 115         assert(reply);
 116
 117         return sd_bus_message_append(reply, "s", architecture_to_string(uname_architecture()));
 118 }
 119
 120 static int property_get_tainted(
 121                 sd_bus *bus,
 122                 const char *path,
 123                 const char *interface,
 124                 const char *property,
 125                 sd_bus_message *reply,
 126                 void *userdata,
 127                 sd_bus_error *error) {
 128
 129         char buf[sizeof("split-usr:cgroups-missing:local-hwclock:")] = "", *e = buf;
 130         Manager *m = userdata;
 131
 132         assert(bus);
 133         assert(reply);
 134         assert(m);
 135
 136         if (m->taint_usr)
 137                 e = stpcpy(e, "split-usr:");
 138
 139         if (access("/proc/cgroups", F_OK) < 0)
 140                 e = stpcpy(e, "cgroups-missing:");
 141
 142         if (clock_is_localtime(NULL) > 0)
 143                 e = stpcpy(e, "local-hwclock:");
 144
 145         /* remove the last ':' */
 146         if (e != buf)
 147                 e[-1] = 0;
 148
 149         return sd_bus_message_append(reply, "s", buf);
 150 }
 151
 152 static int property_get_log_target(
 153                 sd_bus *bus,
 154                 const char *path,
 155                 const char *interface,
 156                 const char *property,
 157                 sd_bus_message *reply,
 158                 void *userdata,
 159                 sd_bus_error *error) {
 160
 161         assert(bus);
 162         assert(reply);
 163
 164         return sd_bus_message_append(reply, "s", log_target_to_string(log_get_target()));
 165 }
 166
 167 static int property_set_log_target(
 168                 sd_bus *bus,
 169                 const char *path,
 170                 const char *interface,
 171                 const char *property,
 172                 sd_bus_message *value,
 173                 void *userdata,
 174                 sd_bus_error *error) {
 175
 176         const char *t;
 177         int r;
 178
 179         assert(bus);
 180         assert(value);
 181
 182         r = sd_bus_message_read(value, "s", &t);
 183         if (r < 0)
 184                 return r;
 185
 186         return log_set_target_from_string(t);
 187 }
 188
 189 static int property_get_log_level(
 190                 sd_bus *bus,
 191                 const char *path,
 192                 const char *interface,
 193                 const char *property,
 194                 sd_bus_message *reply,
 195                 void *userdata,
 196                 sd_bus_error *error) {
 197
 198         _cleanup_free_ char *t = NULL;
 199         int r;
 200
 201         assert(bus);
 202         assert(reply);
 203
 204         r = log_level_to_string_alloc(log_get_max_level(), &t);
 205         if (r < 0)
 206                 return r;
 207
 208         return sd_bus_message_append(reply, "s", t);
 209 }
 210
 211 static int property_set_log_level(
 212                 sd_bus *bus,
 213                 const char *path,
 214                 const char *interface,
 215                 const char *property,
 216                 sd_bus_message *value,
 217                 void *userdata,
 218                 sd_bus_error *error) {
 219
 220         const char *t;
 221         int r;
 222
 223         assert(bus);
 224         assert(value);
 225
 226         r = sd_bus_message_read(value, "s", &t);
 227         if (r < 0)
 228                 return r;
 229
 230         r = log_set_max_level_from_string(t);
 231         if (r == 0)
 232                 log_info("Setting log level to %s.", t);
 233         return r;
 234 }
 235
 236 static int property_get_n_names(
 237                 sd_bus *bus,
 238                 const char *path,
 239                 const char *interface,
 240                 const char *property,
 241                 sd_bus_message *reply,
 242                 void *userdata,
 243                 sd_bus_error *error) {
 244
 245         Manager *m = userdata;
 246
 247         assert(bus);
 248         assert(reply);
 249         assert(m);
 250
 251         return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->units));
 252 }
 253
 254 static int property_get_n_failed_units(
 255                 sd_bus *bus,
 256                 const char *path,
 257                 const char *interface,
 258                 const char *property,
 259                 sd_bus_message *reply,
 260                 void *userdata,
 261                 sd_bus_error *error) {
 262
 263         Manager *m = userdata;
 264
 265         assert(bus);
 266         assert(reply);
 267         assert(m);
 268
 269         return sd_bus_message_append(reply, "u", (uint32_t) set_size(m->failed_units));
 270 }
 271
 272 static int property_get_n_jobs(
 273                 sd_bus *bus,
 274                 const char *path,
 275                 const char *interface,
 276                 const char *property,
 277                 sd_bus_message *reply,
 278                 void *userdata,
 279                 sd_bus_error *error) {
 280
 281         Manager *m = userdata;
 282
 283         assert(bus);
 284         assert(reply);
 285         assert(m);
 286
 287         return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->jobs));
 288 }
 289
 290 static int property_get_progress(
 291                 sd_bus *bus,
 292                 const char *path,
 293                 const char *interface,
 294                 const char *property,
 295                 sd_bus_message *reply,
 296                 void *userdata,
 297                 sd_bus_error *error) {
 298
 299         Manager *m = userdata;
 300         double d;
 301
 302         assert(bus);
 303         assert(reply);
 304         assert(m);
 305
 306         if (dual_timestamp_is_set(&m->finish_timestamp))
 307                 d = 1.0;
 308         else
 309                 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
 310
 311         return sd_bus_message_append(reply, "d", d);
 312 }
 313
 314 static int property_get_system_state(
 315                 sd_bus *bus,
 316                 const char *path,
 317                 const char *interface,
 318                 const char *property,
 319                 sd_bus_message *reply,
 320                 void *userdata,
 321                 sd_bus_error *error) {
 322
 323         Manager *m = userdata;
 324
 325         assert(bus);
 326         assert(reply);
 327         assert(m);
 328
 329         return sd_bus_message_append(reply, "s", manager_state_to_string(manager_state(m)));
 330 }
 331
 332 static int property_set_runtime_watchdog(
 333                 sd_bus *bus,
 334                 const char *path,
 335                 const char *interface,
 336                 const char *property,
 337                 sd_bus_message *value,
 338                 void *userdata,
 339                 sd_bus_error *error) {
 340
 341         usec_t *t = userdata;
 342         int r;
 343
 344         assert(bus);
 345         assert(value);
 346
 347         assert_cc(sizeof(usec_t) == sizeof(uint64_t));
 348
 349         r = sd_bus_message_read(value, "t", t);
 350         if (r < 0)
 351                 return r;
 352
 353         return watchdog_set_timeout(t);
 354 }
 355
 356 static int property_get_timer_slack_nsec(
 357                 sd_bus *bus,
 358                 const char *path,
 359                 const char *interface,
 360                 const char *property,
 361                 sd_bus_message *reply,
 362                 void *userdata,
 363                 sd_bus_error *error) {
 364
 365         assert(bus);
 366         assert(reply);
 367
 368         return sd_bus_message_append(reply, "t", (uint64_t) prctl(PR_GET_TIMERSLACK));
 369 }
 370
 371 static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 372         _cleanup_free_ char *path = NULL;
 373         Manager *m = userdata;
 374         const char *name;
 375         Unit *u;
 376         int r;
 377
 378         assert(message);
 379         assert(m);
 380
 381         /* Anyone can call this method */
 382
 383         r = sd_bus_message_read(message, "s", &name);
 384         if (r < 0)
 385                 return r;
 386
 387         if (isempty(name)) {
 388                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 389                 pid_t pid;
 390
 391                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
 392                 if (r < 0)
 393                         return r;
 394
 395                 r = sd_bus_creds_get_pid(creds, &pid);
 396                 if (r < 0)
 397                         return r;
 398
 399                 u = manager_get_unit_by_pid(m, pid);
 400                 if (!u)
 401                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
 402         } else {
 403                 u = manager_get_unit(m, name);
 404                 if (!u)
 405                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
 406         }
 407
 408         r = mac_selinux_unit_access_check(u, message, "status", error);
 409         if (r < 0)
 410                 return r;
 411
 412         path = unit_dbus_path(u);
 413         if (!path)
 414                 return -ENOMEM;
 415
 416         return sd_bus_reply_method_return(message, "o", path);
 417 }
 418
 419 static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 420         _cleanup_free_ char *path = NULL;
 421         Manager *m = userdata;
 422         pid_t pid;
 423         Unit *u;
 424         int r;
 425
 426         assert(message);
 427         assert(m);
 428
 429         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 430
 431         /* Anyone can call this method */
 432
 433         r = sd_bus_message_read(message, "u", &pid);
 434         if (r < 0)
 435                 return r;
 436         if (pid < 0)
 437                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PID " PID_FMT, pid);
 438
 439         if (pid == 0) {
 440                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 441
 442                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
 443                 if (r < 0)
 444                         return r;
 445
 446                 r = sd_bus_creds_get_pid(creds, &pid);
 447                 if (r < 0)
 448                         return r;
 449         }
 450
 451         u = manager_get_unit_by_pid(m, pid);
 452         if (!u)
 453                 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pid);
 454
 455         r = mac_selinux_unit_access_check(u, message, "status", error);
 456         if (r < 0)
 457                 return r;
 458
 459         path = unit_dbus_path(u);
 460         if (!path)
 461                 return -ENOMEM;
 462
 463         return sd_bus_reply_method_return(message, "o", path);
 464 }
 465
 466 static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 467         _cleanup_free_ char *path = NULL;
 468         Manager *m = userdata;
 469         const char *name;
 470         Unit *u;
 471         int r;
 472
 473         assert(message);
 474         assert(m);
 475
 476         /* Anyone can call this method */
 477
 478         r = sd_bus_message_read(message, "s", &name);
 479         if (r < 0)
 480                 return r;
 481
 482         if (isempty(name)) {
 483                 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 484                 pid_t pid;
 485
 486                 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
 487                 if (r < 0)
 488                         return r;
 489
 490                 r = sd_bus_creds_get_pid(creds, &pid);
 491                 if (r < 0)
 492                         return r;
 493
 494                 u = manager_get_unit_by_pid(m, pid);
 495                 if (!u)
 496                         return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
 497         } else {
 498                 r = manager_load_unit(m, name, NULL, error, &u);
 499                 if (r < 0)
 500                         return r;
 501         }
 502
 503         r = mac_selinux_unit_access_check(u, message, "status", error);
 504         if (r < 0)
 505                 return r;
 506
 507         path = unit_dbus_path(u);
 508         if (!path)
 509                 return -ENOMEM;
 510
 511         return sd_bus_reply_method_return(message, "o", path);
 512 }
 513
 514 static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
 515         const char *name;
 516         Unit *u;
 517         int r;
 518
 519         assert(message);
 520         assert(m);
 521
 522         r = sd_bus_message_read(message, "s", &name);
 523         if (r < 0)
 524                 return r;
 525
 526         r = manager_load_unit(m, name, NULL, error, &u);
 527         if (r < 0)
 528                 return r;
 529
 530         return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
 531 }
 532
 533 static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 534         return method_start_unit_generic(message, userdata, JOB_START, false, error);
 535 }
 536
 537 static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 538         return method_start_unit_generic(message, userdata, JOB_STOP, false, error);
 539 }
 540
 541 static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 542         return method_start_unit_generic(message, userdata, JOB_RELOAD, false, error);
 543 }
 544
 545 static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 546         return method_start_unit_generic(message, userdata, JOB_RESTART, false, error);
 547 }
 548
 549 static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 550         return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, false, error);
 551 }
 552
 553 static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 554         return method_start_unit_generic(message, userdata, JOB_RESTART, true, error);
 555 }
 556
 557 static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 558         return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, true, error);
 559 }
 560
 561 static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 562         Manager *m = userdata;
 563         const char *old_name;
 564         Unit *u;
 565         int r;
 566
 567         assert(message);
 568         assert(m);
 569
 570         r = sd_bus_message_read(message, "s", &old_name);
 571         if (r < 0)
 572                 return r;
 573
 574         u = manager_get_unit(m, old_name);
 575         if (!u || !u->job || u->job->type != JOB_START)
 576                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
 577
 578         return method_start_unit_generic(message, m, JOB_START, false, error);
 579 }
 580
 581 static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 582         Manager *m = userdata;
 583         const char *name;
 584         Unit *u;
 585         int r;
 586
 587         assert(message);
 588         assert(m);
 589
 590         r = sd_bus_message_read(message, "s", &name);
 591         if (r < 0)
 592                 return r;
 593
 594         u = manager_get_unit(m, name);
 595         if (!u)
 596                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
 597
 598         return bus_unit_method_kill(message, u, error);
 599 }
 600
 601 static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 602         Manager *m = userdata;
 603         const char *name;
 604         Unit *u;
 605         int r;
 606
 607         assert(message);
 608         assert(m);
 609
 610         r = sd_bus_message_read(message, "s", &name);
 611         if (r < 0)
 612                 return r;
 613
 614         u = manager_get_unit(m, name);
 615         if (!u)
 616                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
 617
 618         return bus_unit_method_reset_failed(message, u, error);
 619 }
 620
 621 static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 622         Manager *m = userdata;
 623         const char *name;
 624         Unit *u;
 625         int r;
 626
 627         assert(message);
 628         assert(m);
 629
 630         r = sd_bus_message_read(message, "s", &name);
 631         if (r < 0)
 632                 return r;
 633
 634         r = manager_load_unit(m, name, NULL, error, &u);
 635         if (r < 0)
 636                 return r;
 637
 638         r = bus_unit_check_load_state(u, error);
 639         if (r < 0)
 640                 return r;
 641
 642         return bus_unit_method_set_properties(message, u, error);
 643 }
 644
 645 static int transient_unit_from_message(
 646                 Manager *m,
 647                 sd_bus_message *message,
 648                 const char *name,
 649                 Unit **unit,
 650                 sd_bus_error *error) {
 651
 652         UnitType t;
 653         Unit *u;
 654         int r;
 655
 656         assert(m);
 657         assert(message);
 658         assert(name);
 659
 660         t = unit_name_to_type(name);
 661         if (t < 0)
 662                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit name or type.");
 663
 664         if (!unit_vtable[t]->can_transient)
 665                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit type %s does not support transient units.", unit_type_to_string(t));
 666
 667         r = manager_load_unit(m, name, NULL, error, &u);
 668         if (r < 0)
 669                 return r;
 670
 671         if (!unit_is_pristine(u))
 672                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit %s already exists.", name);
 673
 674         /* OK, the unit failed to load and is unreferenced, now let's
 675          * fill in the transient data instead */
 676         r = unit_make_transient(u);
 677         if (r < 0)
 678                 return r;
 679
 680         /* Set our properties */
 681         r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
 682         if (r < 0)
 683                 return r;
 684
 685         /* Now load the missing bits of the unit we just created */
 686         manager_dispatch_load_queue(m);
 687
 688         *unit = u;
 689
 690         return 0;
 691 }
 692
 693 static int transient_aux_units_from_message(
 694                 Manager *m,
 695                 sd_bus_message *message,
 696                 sd_bus_error *error) {
 697
 698         int r;
 699
 700         assert(m);
 701         assert(message);
 702
 703         r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
 704         if (r < 0)
 705                 return r;
 706
 707         while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
 708                 const char *name = NULL;
 709                 Unit *u;
 710
 711                 r = sd_bus_message_read(message, "s", &name);
 712                 if (r < 0)
 713                         return r;
 714
 715                 r = transient_unit_from_message(m, message, name, &u, error);
 716                 if (r < 0)
 717                         return r;
 718
 719                 r = sd_bus_message_exit_container(message);
 720                 if (r < 0)
 721                         return r;
 722         }
 723         if (r < 0)
 724                 return r;
 725
 726         r = sd_bus_message_exit_container(message);
 727         if (r < 0)
 728                 return r;
 729
 730         return 0;
 731 }
 732
 733 static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 734         const char *name, *smode;
 735         Manager *m = userdata;
 736         JobMode mode;
 737         Unit *u;
 738         int r;
 739
 740         assert(message);
 741         assert(m);
 742
 743         r = mac_selinux_access_check(message, "start", error);
 744         if (r < 0)
 745                 return r;
 746
 747         r = sd_bus_message_read(message, "ss", &name, &smode);
 748         if (r < 0)
 749                 return r;
 750
 751         mode = job_mode_from_string(smode);
 752         if (mode < 0)
 753                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
 754
 755         r = bus_verify_manage_units_async(m, message, error);
 756         if (r < 0)
 757                 return r;
 758         if (r == 0)
 759                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 760
 761         r = transient_unit_from_message(m, message, name, &u, error);
 762         if (r < 0)
 763                 return r;
 764
 765         r = transient_aux_units_from_message(m, message, error);
 766         if (r < 0)
 767                 return r;
 768
 769         /* Finally, start it */
 770         return bus_unit_queue_job(message, u, JOB_START, mode, false, error);
 771 }
 772
 773 static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 774         _cleanup_free_ char *path = NULL;
 775         Manager *m = userdata;
 776         uint32_t id;
 777         Job *j;
 778         int r;
 779
 780         assert(message);
 781         assert(m);
 782
 783         /* Anyone can call this method */
 784
 785         r = sd_bus_message_read(message, "u", &id);
 786         if (r < 0)
 787                 return r;
 788
 789         j = manager_get_job(m, id);
 790         if (!j)
 791                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
 792
 793         r = mac_selinux_unit_access_check(j->unit, message, "status", error);
 794         if (r < 0)
 795                 return r;
 796
 797         path = job_dbus_path(j);
 798         if (!path)
 799                 return -ENOMEM;
 800
 801         return sd_bus_reply_method_return(message, "o", path);
 802 }
 803
 804 static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 805         Manager *m = userdata;
 806         uint32_t id;
 807         Job *j;
 808         int r;
 809
 810         assert(message);
 811         assert(m);
 812
 813         r = sd_bus_message_read(message, "u", &id);
 814         if (r < 0)
 815                 return r;
 816
 817         j = manager_get_job(m, id);
 818         if (!j)
 819                 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
 820
 821         return bus_job_method_cancel(message, j, error);
 822 }
 823
 824 static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 825         Manager *m = userdata;
 826         int r;
 827
 828         assert(message);
 829         assert(m);
 830
 831         r = mac_selinux_access_check(message, "reload", error);
 832         if (r < 0)
 833                 return r;
 834
 835         r = bus_verify_manage_units_async(m, message, error);
 836         if (r < 0)
 837                 return r;
 838         if (r == 0)
 839                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 840
 841         manager_clear_jobs(m);
 842
 843         return sd_bus_reply_method_return(message, NULL);
 844 }
 845
 846 static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 847         Manager *m = userdata;
 848         int r;
 849
 850         assert(message);
 851         assert(m);
 852
 853         r = mac_selinux_access_check(message, "reload", error);
 854         if (r < 0)
 855                 return r;
 856
 857         r = bus_verify_manage_units_async(m, message, error);
 858         if (r < 0)
 859                 return r;
 860         if (r == 0)
 861                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 862
 863         manager_reset_failed(m);
 864
 865         return sd_bus_reply_method_return(message, NULL);
 866 }
 867
 868 static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states) {
 869         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 870         Manager *m = userdata;
 871         const char *k;
 872         Iterator i;
 873         Unit *u;
 874         int r;
 875
 876         assert(message);
 877         assert(m);
 878
 879         /* Anyone can call this method */
 880
 881         r = mac_selinux_access_check(message, "status", error);
 882         if (r < 0)
 883                 return r;
 884
 885         r = sd_bus_message_new_method_return(message, &reply);
 886         if (r < 0)
 887                 return r;
 888
 889         r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
 890         if (r < 0)
 891                 return r;
 892
 893         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 894                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
 895                 Unit *following;
 896
 897                 if (k != u->id)
 898                         continue;
 899
 900                 following = unit_following(u);
 901
 902                 if (!strv_isempty(states) &&
 903                     !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
 904                     !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
 905                     !strv_contains(states, unit_sub_state_to_string(u)))
 906                         continue;
 907
 908                 unit_path = unit_dbus_path(u);
 909                 if (!unit_path)
 910                         return -ENOMEM;
 911
 912                 if (u->job) {
 913                         job_path = job_dbus_path(u->job);
 914                         if (!job_path)
 915                                 return -ENOMEM;
 916                 }
 917
 918                 r = sd_bus_message_append(
 919                                 reply, "(ssssssouso)",
 920                                 u->id,
 921                                 unit_description(u),
 922                                 unit_load_state_to_string(u->load_state),
 923                                 unit_active_state_to_string(unit_active_state(u)),
 924                                 unit_sub_state_to_string(u),
 925                                 following ? following->id : "",
 926                                 unit_path,
 927                                 u->job ? u->job->id : 0,
 928                                 u->job ? job_type_to_string(u->job->type) : "",
 929                                 job_path ? job_path : "/");
 930                 if (r < 0)
 931                         return r;
 932         }
 933
 934         r = sd_bus_message_close_container(reply);
 935         if (r < 0)
 936                 return r;
 937
 938         return sd_bus_send(NULL, reply, NULL);
 939 }
 940
 941 static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 942         return list_units_filtered(message, userdata, error, NULL);
 943 }
 944
 945 static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 946         _cleanup_strv_free_ char **states = NULL;
 947         int r;
 948
 949         r = sd_bus_message_read_strv(message, &states);
 950         if (r < 0)
 951                 return r;
 952
 953         return list_units_filtered(message, userdata, error, states);
 954 }
 955
 956 static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
 957         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 958         Manager *m = userdata;
 959         Iterator i;
 960         Job *j;
 961         int r;
 962
 963         assert(message);
 964         assert(m);
 965
 966         /* Anyone can call this method */
 967
 968         r = mac_selinux_access_check(message, "status", error);
 969         if (r < 0)
 970                 return r;
 971
 972         r = sd_bus_message_new_method_return(message, &reply);
 973         if (r < 0)
 974                 return r;
 975
 976         r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
 977         if (r < 0)
 978                 return r;
 979
 980         HASHMAP_FOREACH(j, m->jobs, i) {
 981                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
 982
 983                 job_path = job_dbus_path(j);
 984                 if (!job_path)
 985                         return -ENOMEM;
 986
 987                 unit_path = unit_dbus_path(j->unit);
 988                 if (!unit_path)
 989                         return -ENOMEM;
 990
 991                 r = sd_bus_message_append(
 992                                 reply, "(usssoo)",
 993                                 j->id,
 994                                 j->unit->id,
 995                                 job_type_to_string(j->type),
 996                                 job_state_to_string(j->state),
 997                                 job_path,
 998                                 unit_path);
 999                 if (r < 0)
1000                         return r;
1001         }
1002
1003         r = sd_bus_message_close_container(reply);
1004         if (r < 0)
1005                 return r;
1006
1007         return sd_bus_send(NULL, reply, NULL);
1008 }
1009
1010 static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1011         Manager *m = userdata;
1012         int r;
1013
1014         assert(message);
1015         assert(m);
1016
1017         /* Anyone can call this method */
1018
1019         r = mac_selinux_access_check(message, "status", error);
1020         if (r < 0)
1021                 return r;
1022
1023         if (sd_bus_message_get_bus(message) == m->api_bus) {
1024
1025                 /* Note that direct bus connection subscribe by
1026                  * default, we only track peers on the API bus here */
1027
1028                 if (!m->subscribed) {
1029                         r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
1030                         if (r < 0)
1031                                 return r;
1032                 }
1033
1034                 r = sd_bus_track_add_sender(m->subscribed, message);
1035                 if (r < 0)
1036                         return r;
1037                 if (r == 0)
1038                         return sd_bus_error_setf(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
1039         }
1040
1041         return sd_bus_reply_method_return(message, NULL);
1042 }
1043
1044 static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1045         Manager *m = userdata;
1046         int r;
1047
1048         assert(message);
1049         assert(m);
1050
1051         /* Anyone can call this method */
1052
1053         r = mac_selinux_access_check(message, "status", error);
1054         if (r < 0)
1055                 return r;
1056
1057         if (sd_bus_message_get_bus(message) == m->api_bus) {
1058                 r = sd_bus_track_remove_sender(m->subscribed, message);
1059                 if (r < 0)
1060                         return r;
1061                 if (r == 0)
1062                         return sd_bus_error_setf(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
1063         }
1064
1065         return sd_bus_reply_method_return(message, NULL);
1066 }
1067
1068 static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1069         _cleanup_free_ char *dump = NULL;
1070         _cleanup_fclose_ FILE *f = NULL;
1071         Manager *m = userdata;
1072         size_t size;
1073         int r;
1074
1075         assert(message);
1076         assert(m);
1077
1078         /* Anyone can call this method */
1079
1080         r = mac_selinux_access_check(message, "status", error);
1081         if (r < 0)
1082                 return r;
1083
1084         f = open_memstream(&dump, &size);
1085         if (!f)
1086                 return -ENOMEM;
1087
1088         manager_dump_units(m, f, NULL);
1089         manager_dump_jobs(m, f, NULL);
1090
1091         r = fflush_and_check(f);
1092         if (r < 0)
1093                 return r;
1094
1095         return sd_bus_reply_method_return(message, "s", dump);
1096 }
1097
1098 static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1099         return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
1100 }
1101
1102 static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1103         Manager *m = userdata;
1104         int r;
1105
1106         assert(message);
1107         assert(m);
1108
1109         r = mac_selinux_access_check(message, "reload", error);
1110         if (r < 0)
1111                 return r;
1112
1113         r = bus_verify_reload_daemon_async(m, message, error);
1114         if (r < 0)
1115                 return r;
1116         if (r == 0)
1117                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1118
1119         /* Instead of sending the reply back right away, we just
1120          * remember that we need to and then send it after the reload
1121          * is finished. That way the caller knows when the reload
1122          * finished. */
1123
1124         assert(!m->queued_message);
1125         r = sd_bus_message_new_method_return(message, &m->queued_message);
1126         if (r < 0)
1127                 return r;
1128
1129         m->exit_code = MANAGER_RELOAD;
1130
1131         return 1;
1132 }
1133
1134 static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1135         Manager *m = userdata;
1136         int r;
1137
1138         assert(message);
1139         assert(m);
1140
1141         r = mac_selinux_access_check(message, "reload", error);
1142         if (r < 0)
1143                 return r;
1144
1145         r = bus_verify_reload_daemon_async(m, message, error);
1146         if (r < 0)
1147                 return r;
1148         if (r == 0)
1149                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1150
1151         /* We don't send a reply back here, the client should
1152          * just wait for us disconnecting. */
1153
1154         m->exit_code = MANAGER_REEXECUTE;
1155         return 1;
1156 }
1157
1158 static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1159         Manager *m = userdata;
1160         int r;
1161
1162         assert(message);
1163         assert(m);
1164
1165         r = mac_selinux_access_check(message, "halt", error);
1166         if (r < 0)
1167                 return r;
1168
1169         /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1170          * we are running on the host. It will fall back on reboot() in
1171          * systemd-shutdown if it cannot do the exit() because it isn't a
1172          * container. */
1173
1174         m->exit_code = MANAGER_EXIT;
1175
1176         return sd_bus_reply_method_return(message, NULL);
1177 }
1178
1179 static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1180         Manager *m = userdata;
1181         int r;
1182
1183         assert(message);
1184         assert(m);
1185
1186         r = mac_selinux_access_check(message, "reboot", error);
1187         if (r < 0)
1188                 return r;
1189
1190         if (m->running_as != MANAGER_SYSTEM)
1191                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
1192
1193         m->exit_code = MANAGER_REBOOT;
1194
1195         return sd_bus_reply_method_return(message, NULL);
1196 }
1197
1198 static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1199         Manager *m = userdata;
1200         int r;
1201
1202         assert(message);
1203         assert(m);
1204
1205         r = mac_selinux_access_check(message, "halt", error);
1206         if (r < 0)
1207                 return r;
1208
1209         if (m->running_as != MANAGER_SYSTEM)
1210                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
1211
1212         m->exit_code = MANAGER_POWEROFF;
1213
1214         return sd_bus_reply_method_return(message, NULL);
1215 }
1216
1217 static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1218         Manager *m = userdata;
1219         int r;
1220
1221         assert(message);
1222         assert(m);
1223
1224         r = mac_selinux_access_check(message, "halt", error);
1225         if (r < 0)
1226                 return r;
1227
1228         if (m->running_as != MANAGER_SYSTEM)
1229                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Halt is only supported for system managers.");
1230
1231         m->exit_code = MANAGER_HALT;
1232
1233         return sd_bus_reply_method_return(message, NULL);
1234 }
1235
1236 static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1237         Manager *m = userdata;
1238         int r;
1239
1240         assert(message);
1241         assert(m);
1242
1243         r = mac_selinux_access_check(message, "reboot", error);
1244         if (r < 0)
1245                 return r;
1246
1247         if (m->running_as != MANAGER_SYSTEM)
1248                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1249
1250         m->exit_code = MANAGER_KEXEC;
1251
1252         return sd_bus_reply_method_return(message, NULL);
1253 }
1254
1255 static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1256         char *ri = NULL, *rt = NULL;
1257         const char *root, *init;
1258         Manager *m = userdata;
1259         int r;
1260
1261         assert(message);
1262         assert(m);
1263
1264         r = mac_selinux_access_check(message, "reboot", error);
1265         if (r < 0)
1266                 return r;
1267
1268         if (m->running_as != MANAGER_SYSTEM)
1269                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Root switching is only supported by system manager.");
1270
1271         r = sd_bus_message_read(message, "ss", &root, &init);
1272         if (r < 0)
1273                 return r;
1274
1275         if (path_equal(root, "/") || !path_is_absolute(root))
1276                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid switch root path %s", root);
1277
1278         /* Safety check */
1279         if (isempty(init)) {
1280                 if (!path_is_os_tree(root))
1281                         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);
1282         } else {
1283                 _cleanup_free_ char *p = NULL;
1284
1285                 if (!path_is_absolute(init))
1286                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid init path %s", init);
1287
1288                 p = strappend(root, init);
1289                 if (!p)
1290                         return -ENOMEM;
1291
1292                 if (access(p, X_OK) < 0)
1293                         return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified init binary %s does not exist.", p);
1294         }
1295
1296         rt = strdup(root);
1297         if (!rt)
1298                 return -ENOMEM;
1299
1300         if (!isempty(init)) {
1301                 ri = strdup(init);
1302                 if (!ri) {
1303                         free(rt);
1304                         return -ENOMEM;
1305                 }
1306         }
1307
1308         free(m->switch_root);
1309         m->switch_root = rt;
1310
1311         free(m->switch_root_init);
1312         m->switch_root_init = ri;
1313
1314         m->exit_code = MANAGER_SWITCH_ROOT;
1315
1316         return sd_bus_reply_method_return(message, NULL);
1317 }
1318
1319 static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1320         _cleanup_strv_free_ char **plus = NULL;
1321         Manager *m = userdata;
1322         int r;
1323
1324         assert(message);
1325         assert(m);
1326
1327         r = mac_selinux_access_check(message, "reload", error);
1328         if (r < 0)
1329                 return r;
1330
1331         r = sd_bus_message_read_strv(message, &plus);
1332         if (r < 0)
1333                 return r;
1334         if (!strv_env_is_valid(plus))
1335                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1336
1337         r = bus_verify_set_environment_async(m, message, error);
1338         if (r < 0)
1339                 return r;
1340         if (r == 0)
1341                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1342
1343         r = manager_environment_add(m, NULL, plus);
1344         if (r < 0)
1345                 return r;
1346
1347         return sd_bus_reply_method_return(message, NULL);
1348 }
1349
1350 static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1351         _cleanup_strv_free_ char **minus = NULL;
1352         Manager *m = userdata;
1353         int r;
1354
1355         assert(message);
1356         assert(m);
1357
1358         r = mac_selinux_access_check(message, "reload", error);
1359         if (r < 0)
1360                 return r;
1361
1362         r = sd_bus_message_read_strv(message, &minus);
1363         if (r < 0)
1364                 return r;
1365
1366         if (!strv_env_name_or_assignment_is_valid(minus))
1367                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1368
1369         r = bus_verify_set_environment_async(m, message, error);
1370         if (r < 0)
1371                 return r;
1372         if (r == 0)
1373                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1374
1375         r = manager_environment_add(m, minus, NULL);
1376         if (r < 0)
1377                 return r;
1378
1379         return sd_bus_reply_method_return(message, NULL);
1380 }
1381
1382 static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1383         _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1384         Manager *m = userdata;
1385         int r;
1386
1387         assert(message);
1388         assert(m);
1389
1390         r = mac_selinux_access_check(message, "reload", error);
1391         if (r < 0)
1392                 return r;
1393
1394         r = sd_bus_message_read_strv(message, &minus);
1395         if (r < 0)
1396                 return r;
1397
1398         r = sd_bus_message_read_strv(message, &plus);
1399         if (r < 0)
1400                 return r;
1401
1402         if (!strv_env_name_or_assignment_is_valid(minus))
1403                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1404         if (!strv_env_is_valid(plus))
1405                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1406
1407         r = bus_verify_set_environment_async(m, message, error);
1408         if (r < 0)
1409                 return r;
1410         if (r == 0)
1411                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1412
1413         r = manager_environment_add(m, minus, plus);
1414         if (r < 0)
1415                 return r;
1416
1417         return sd_bus_reply_method_return(message, NULL);
1418 }
1419
1420 static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1421         uint8_t code;
1422         Manager *m = userdata;
1423         int r;
1424
1425         assert(message);
1426         assert(m);
1427
1428         r = mac_selinux_access_check(message, "exit", error);
1429         if (r < 0)
1430                 return r;
1431
1432         r = sd_bus_message_read_basic(message, 'y', &code);
1433         if (r < 0)
1434                 return r;
1435
1436         if (m->running_as == MANAGER_SYSTEM && detect_container() <= 0)
1437                 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "ExitCode can only be set for user service managers or in containers.");
1438
1439         m->return_value = code;
1440
1441         return sd_bus_reply_method_return(message, NULL);
1442 }
1443
1444 static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1445         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1446         Manager *m = userdata;
1447         UnitFileList *item;
1448         Hashmap *h;
1449         Iterator i;
1450         int r;
1451
1452         assert(message);
1453         assert(m);
1454
1455         /* Anyone can call this method */
1456
1457         r = mac_selinux_access_check(message, "status", error);
1458         if (r < 0)
1459                 return r;
1460
1461         r = sd_bus_message_new_method_return(message, &reply);
1462         if (r < 0)
1463                 return r;
1464
1465         h = hashmap_new(&string_hash_ops);
1466         if (!h)
1467                 return -ENOMEM;
1468
1469         r = unit_file_get_list(m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, h);
1470         if (r < 0)
1471                 goto fail;
1472
1473         r = sd_bus_message_open_container(reply, 'a', "(ss)");
1474         if (r < 0)
1475                 goto fail;
1476
1477         HASHMAP_FOREACH(item, h, i) {
1478
1479                 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
1480                 if (r < 0)
1481                         goto fail;
1482         }
1483
1484         unit_file_list_free(h);
1485
1486         r = sd_bus_message_close_container(reply);
1487         if (r < 0)
1488                 return r;
1489
1490         return sd_bus_send(NULL, reply, NULL);
1491
1492 fail:
1493         unit_file_list_free(h);
1494         return r;
1495 }
1496
1497 static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1498         Manager *m = userdata;
1499         const char *name;
1500         UnitFileState state;
1501         UnitFileScope scope;
1502         int r;
1503
1504         assert(message);
1505         assert(m);
1506
1507         /* Anyone can call this method */
1508
1509         r = mac_selinux_access_check(message, "status", error);
1510         if (r < 0)
1511                 return r;
1512
1513         r = sd_bus_message_read(message, "s", &name);
1514         if (r < 0)
1515                 return r;
1516
1517         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1518
1519         r = unit_file_get_state(scope, NULL, name, &state);
1520         if (r < 0)
1521                 return r;
1522
1523         return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
1524 }
1525
1526 static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1527         _cleanup_free_ char *default_target = NULL;
1528         Manager *m = userdata;
1529         UnitFileScope scope;
1530         int r;
1531
1532         assert(message);
1533         assert(m);
1534
1535         /* Anyone can call this method */
1536
1537         r = mac_selinux_access_check(message, "status", error);
1538         if (r < 0)
1539                 return r;
1540
1541         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1542
1543         r = unit_file_get_default(scope, NULL, &default_target);
1544         if (r < 0)
1545                 return r;
1546
1547         return sd_bus_reply_method_return(message, "s", default_target);
1548 }
1549
1550 static int send_unit_files_changed(sd_bus *bus, void *userdata) {
1551         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
1552         int r;
1553
1554         assert(bus);
1555
1556         r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1557         if (r < 0)
1558                 return r;
1559
1560         return sd_bus_send(bus, message, NULL);
1561 }
1562
1563 static int reply_unit_file_changes_and_free(
1564                 Manager *m,
1565                 sd_bus_message *message,
1566                 int carries_install_info,
1567                 UnitFileChange *changes,
1568                 unsigned n_changes) {
1569
1570         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1571         unsigned i;
1572         int r;
1573
1574         if (n_changes > 0) {
1575                 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
1576                 if (r < 0)
1577                         log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
1578         }
1579
1580         r = sd_bus_message_new_method_return(message, &reply);
1581         if (r < 0)
1582                 goto fail;
1583
1584         if (carries_install_info >= 0) {
1585                 r = sd_bus_message_append(reply, "b", carries_install_info);
1586                 if (r < 0)
1587                         goto fail;
1588         }
1589
1590         r = sd_bus_message_open_container(reply, 'a', "(sss)");
1591         if (r < 0)
1592                 goto fail;
1593
1594         for (i = 0; i < n_changes; i++) {
1595                 r = sd_bus_message_append(
1596                                 reply, "(sss)",
1597                                 unit_file_change_type_to_string(changes[i].type),
1598                                 changes[i].path,
1599                                 changes[i].source);
1600                 if (r < 0)
1601                         goto fail;
1602         }
1603
1604         r = sd_bus_message_close_container(reply);
1605         if (r < 0)
1606                 goto fail;
1607
1608         unit_file_changes_free(changes, n_changes);
1609         return sd_bus_send(NULL, reply, NULL);
1610
1611 fail:
1612         unit_file_changes_free(changes, n_changes);
1613         return r;
1614 }
1615
1616 static int method_enable_unit_files_generic(
1617                 sd_bus_message *message,
1618                 Manager *m,
1619                 const char *verb,
1620                 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], bool force, UnitFileChange **changes, unsigned *n_changes),
1621                 bool carries_install_info,
1622                 sd_bus_error *error) {
1623
1624         _cleanup_strv_free_ char **l = NULL;
1625         UnitFileChange *changes = NULL;
1626         unsigned n_changes = 0;
1627         UnitFileScope scope;
1628         int runtime, force, r;
1629
1630         assert(message);
1631         assert(m);
1632
1633         r = sd_bus_message_read_strv(message, &l);
1634         if (r < 0)
1635                 return r;
1636
1637         r = sd_bus_message_read(message, "bb", &runtime, &force);
1638         if (r < 0)
1639                 return r;
1640
1641         r = bus_verify_manage_unit_files_async(m, message, error);
1642         if (r < 0)
1643                 return r;
1644         if (r == 0)
1645                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1646
1647         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1648
1649         r = call(scope, runtime, NULL, l, force, &changes, &n_changes);
1650         if (r == -ESHUTDOWN)
1651                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
1652         if (r == -EADDRNOTAVAIL)
1653                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED, "Unit file is generated.");
1654         if (r < 0)
1655                 return r;
1656
1657         return reply_unit_file_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes);
1658 }
1659
1660 static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1661         return method_enable_unit_files_generic(message, userdata, "enable", unit_file_enable, true, error);
1662 }
1663
1664 static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1665         return method_enable_unit_files_generic(message, userdata, "enable", unit_file_reenable, true, error);
1666 }
1667
1668 static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1669         return method_enable_unit_files_generic(message, userdata, "enable", unit_file_link, false, error);
1670 }
1671
1672 static int unit_file_preset_without_mode(UnitFileScope scope, bool runtime, const char *root_dir, char **files, bool force, UnitFileChange **changes, unsigned *n_changes) {
1673         return unit_file_preset(scope, runtime, root_dir, files, UNIT_FILE_PRESET_FULL, force, changes, n_changes);
1674 }
1675
1676 static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1677         return method_enable_unit_files_generic(message, userdata, "enable", unit_file_preset_without_mode, true, error);
1678 }
1679
1680 static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1681         return method_enable_unit_files_generic(message, userdata, "disable", unit_file_mask, false, error);
1682 }
1683
1684 static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1685
1686         _cleanup_strv_free_ char **l = NULL;
1687         UnitFileChange *changes = NULL;
1688         unsigned n_changes = 0;
1689         Manager *m = userdata;
1690         UnitFilePresetMode mm;
1691         UnitFileScope scope;
1692         int runtime, force, r;
1693         const char *mode;
1694
1695         assert(message);
1696         assert(m);
1697
1698         r = sd_bus_message_read_strv(message, &l);
1699         if (r < 0)
1700                 return r;
1701
1702         r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
1703         if (r < 0)
1704                 return r;
1705
1706         if (isempty(mode))
1707                 mm = UNIT_FILE_PRESET_FULL;
1708         else {
1709                 mm = unit_file_preset_mode_from_string(mode);
1710                 if (mm < 0)
1711                         return -EINVAL;
1712         }
1713
1714         r = bus_verify_manage_unit_files_async(m, message, error);
1715         if (r < 0)
1716                 return r;
1717         if (r == 0)
1718                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1719
1720         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1721
1722         r = unit_file_preset(scope, runtime, NULL, l, mm, force, &changes, &n_changes);
1723         if (r < 0)
1724                 return r;
1725
1726         return reply_unit_file_changes_and_free(m, message, r, changes, n_changes);
1727 }
1728
1729 static int method_disable_unit_files_generic(
1730                 sd_bus_message *message,
1731                 Manager *m, const
1732                 char *verb,
1733                 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], UnitFileChange **changes, unsigned *n_changes),
1734                 sd_bus_error *error) {
1735
1736         _cleanup_strv_free_ char **l = NULL;
1737         UnitFileChange *changes = NULL;
1738         unsigned n_changes = 0;
1739         UnitFileScope scope;
1740         int r, runtime;
1741
1742         assert(message);
1743         assert(m);
1744
1745         r = sd_bus_message_read_strv(message, &l);
1746         if (r < 0)
1747                 return r;
1748
1749         r = sd_bus_message_read(message, "b", &runtime);
1750         if (r < 0)
1751                 return r;
1752
1753         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1754
1755         r = bus_verify_manage_unit_files_async(m, message, error);
1756         if (r < 0)
1757                 return r;
1758         if (r == 0)
1759                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1760
1761         r = call(scope, runtime, NULL, l, &changes, &n_changes);
1762         if (r < 0)
1763                 return r;
1764
1765         return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes);
1766 }
1767
1768 static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1769         return method_disable_unit_files_generic(message, userdata, "disable", unit_file_disable, error);
1770 }
1771
1772 static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1773         return method_disable_unit_files_generic(message, userdata, "enable", unit_file_unmask, error);
1774 }
1775
1776 static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1777         UnitFileChange *changes = NULL;
1778         unsigned n_changes = 0;
1779         Manager *m = userdata;
1780         UnitFileScope scope;
1781         const char *name;
1782         int force, r;
1783
1784         assert(message);
1785         assert(m);
1786
1787         r = mac_selinux_access_check(message, "enable", error);
1788         if (r < 0)
1789                 return r;
1790
1791         r = sd_bus_message_read(message, "sb", &name, &force);
1792         if (r < 0)
1793                 return r;
1794
1795         r = bus_verify_manage_unit_files_async(m, message, error);
1796         if (r < 0)
1797                 return r;
1798         if (r == 0)
1799                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1800
1801         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1802
1803         r = unit_file_set_default(scope, NULL, name, force, &changes, &n_changes);
1804         if (r < 0)
1805                 return r;
1806
1807         return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes);
1808 }
1809
1810 static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1811         UnitFileChange *changes = NULL;
1812         unsigned n_changes = 0;
1813         Manager *m = userdata;
1814         UnitFilePresetMode mm;
1815         UnitFileScope scope;
1816         const char *mode;
1817         int force, runtime, r;
1818
1819         assert(message);
1820         assert(m);
1821
1822         r = mac_selinux_access_check(message, "enable", error);
1823         if (r < 0)
1824                 return r;
1825
1826         r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
1827         if (r < 0)
1828                 return r;
1829
1830         if (isempty(mode))
1831                 mm = UNIT_FILE_PRESET_FULL;
1832         else {
1833                 mm = unit_file_preset_mode_from_string(mode);
1834                 if (mm < 0)
1835                         return -EINVAL;
1836         }
1837
1838         r = bus_verify_manage_unit_files_async(m, message, error);
1839         if (r < 0)
1840                 return r;
1841         if (r == 0)
1842                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1843
1844         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1845
1846         r = unit_file_preset_all(scope, runtime, NULL, mm, force, &changes, &n_changes);
1847         if (r < 0) {
1848                 unit_file_changes_free(changes, n_changes);
1849                 return r;
1850         }
1851
1852         return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes);
1853 }
1854
1855 static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1856         _cleanup_strv_free_ char **l = NULL;
1857         Manager *m = userdata;
1858         UnitFileChange *changes = NULL;
1859         unsigned n_changes = 0;
1860         UnitFileScope scope;
1861         int runtime, force, r;
1862         char *target;
1863         char *type;
1864         UnitDependency dep;
1865
1866         assert(message);
1867         assert(m);
1868
1869         r = bus_verify_manage_unit_files_async(m, message, error);
1870         if (r < 0)
1871                 return r;
1872         if (r == 0)
1873                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1874
1875         r = sd_bus_message_read_strv(message, &l);
1876         if (r < 0)
1877                 return r;
1878
1879         r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
1880         if (r < 0)
1881                 return r;
1882
1883         dep = unit_dependency_from_string(type);
1884         if (dep < 0)
1885                 return -EINVAL;
1886
1887         scope = m->running_as == MANAGER_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1888
1889         r = unit_file_add_dependency(scope, runtime, NULL, l, target, dep, force, &changes, &n_changes);
1890         if (r == -ESHUTDOWN)
1891                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
1892         if (r == -EADDRNOTAVAIL)
1893                 return sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED, "Unit file is generated.");
1894         if (r < 0)
1895                 return r;
1896
1897         return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes);
1898 }
1899
1900 const sd_bus_vtable bus_manager_vtable[] = {
1901         SD_BUS_VTABLE_START(0),
1902
1903         SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1904         SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1905         SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1906         SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1907         SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1908         BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, firmware_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1909         BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, loader_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1910         BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, kernel_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1911         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, initrd_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1912         BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, userspace_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1913         BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1914         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, security_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1915         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, security_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1916         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, generators_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1917         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, generators_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1918         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, units_load_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1919         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, units_load_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1920         SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level, property_set_log_level, 0, 0),
1921         SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target, property_set_log_target, 0, 0),
1922         SD_BUS_PROPERTY("NNames", "u", property_get_n_names, 0, 0),
1923         SD_BUS_PROPERTY("NFailedUnits", "u", property_get_n_failed_units, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1924         SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs, 0, 0),
1925         SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
1926         SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
1927         SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1928         SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(Manager, environment), 0),
1929         SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
1930         SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool, offsetof(Manager, show_status), SD_BUS_VTABLE_PROPERTY_CONST),
1931         SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
1932         SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
1933         SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
1934         SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec, property_set_runtime_watchdog, offsetof(Manager, runtime_watchdog), 0),
1935         SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec, bus_property_set_usec, offsetof(Manager, shutdown_watchdog), 0),
1936         SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
1937         SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
1938         SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
1939         SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, default_timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1940         SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1941         SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1942         SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, default_restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
1943         SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
1944         SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, default_start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
1945         SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, default_cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
1946         SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
1947         SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, default_memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
1948         SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, default_tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
1949         SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
1950         SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
1951         SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
1952         SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
1953         SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
1954         SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
1955         SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
1956         SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
1957         SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
1958         SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
1959         SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
1960         SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
1961         SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
1962         SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
1963         SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
1964         SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
1965         SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
1966         SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
1967         SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
1968         SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
1969         SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
1970         SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
1971         SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
1972         SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
1973         SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
1974         SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
1975         SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
1976         SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
1977         SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
1978         SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
1979         SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
1980         SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
1981         SD_BUS_PROPERTY("DefaultTasksMax", "t", NULL, offsetof(Manager, default_tasks_max), SD_BUS_VTABLE_PROPERTY_CONST),
1982         SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1983
1984         SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1985         SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
1986         SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1987         SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1988         SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace, SD_BUS_VTABLE_UNPRIVILEGED),
1989         SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1990         SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1991         SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1992         SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1993         SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1994         SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1995         SD_BUS_METHOD("KillUnit", "ssi", NULL, method_kill_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1996         SD_BUS_METHOD("ResetFailedUnit", "s", NULL, method_reset_failed_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1997         SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL, method_set_unit_properties, SD_BUS_VTABLE_UNPRIVILEGED),
1998         SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1999         SD_BUS_METHOD("GetJob", "u", "o", method_get_job, SD_BUS_VTABLE_UNPRIVILEGED),
2000         SD_BUS_METHOD("CancelJob", "u", NULL, method_cancel_job, SD_BUS_VTABLE_UNPRIVILEGED),
2001         SD_BUS_METHOD("ClearJobs", NULL, NULL, method_clear_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
2002         SD_BUS_METHOD("ResetFailed", NULL, NULL, method_reset_failed, SD_BUS_VTABLE_UNPRIVILEGED),
2003         SD_BUS_METHOD("ListUnits", NULL, "a(ssssssouso)", method_list_units, SD_BUS_VTABLE_UNPRIVILEGED),
2004         SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered, SD_BUS_VTABLE_UNPRIVILEGED),
2005         SD_BUS_METHOD("ListJobs", NULL, "a(usssoo)", method_list_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
2006         SD_BUS_METHOD("Subscribe", NULL, NULL, method_subscribe, SD_BUS_VTABLE_UNPRIVILEGED),
2007         SD_BUS_METHOD("Unsubscribe", NULL, NULL, method_unsubscribe, SD_BUS_VTABLE_UNPRIVILEGED),
2008         SD_BUS_METHOD("Dump", NULL, "s", method_dump, SD_BUS_VTABLE_UNPRIVILEGED),
2009         SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot, SD_BUS_VTABLE_UNPRIVILEGED),
2010         SD_BUS_METHOD("RemoveSnapshot", "s", NULL, method_refuse_snapshot, SD_BUS_VTABLE_UNPRIVILEGED),
2011         SD_BUS_METHOD("Reload", NULL, NULL, method_reload, SD_BUS_VTABLE_UNPRIVILEGED),
2012         SD_BUS_METHOD("Reexecute", NULL, NULL, method_reexecute, SD_BUS_VTABLE_UNPRIVILEGED),
2013         SD_BUS_METHOD("Exit", NULL, NULL, method_exit, 0),
2014         SD_BUS_METHOD("Reboot", NULL, NULL, method_reboot, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2015         SD_BUS_METHOD("PowerOff", NULL, NULL, method_poweroff, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2016         SD_BUS_METHOD("Halt", NULL, NULL, method_halt, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2017         SD_BUS_METHOD("KExec", NULL, NULL, method_kexec, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2018         SD_BUS_METHOD("SwitchRoot", "ss", NULL, method_switch_root, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2019         SD_BUS_METHOD("SetEnvironment", "as", NULL, method_set_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2020         SD_BUS_METHOD("UnsetEnvironment", "as", NULL, method_unset_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2021         SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL, method_unset_and_set_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2022         SD_BUS_METHOD("ListUnitFiles", NULL, "a(ss)", method_list_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2023         SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state, SD_BUS_VTABLE_UNPRIVILEGED),
2024         SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2025         SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2026         SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2027         SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2028         SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2029         SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode, SD_BUS_VTABLE_UNPRIVILEGED),
2030         SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2031         SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2032         SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2033         SD_BUS_METHOD("GetDefaultTarget", NULL, "s", method_get_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2034         SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2035         SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2036         SD_BUS_METHOD("SetExitCode", "y", NULL, method_set_exit_code, SD_BUS_VTABLE_UNPRIVILEGED),
2037
2038         SD_BUS_SIGNAL("UnitNew", "so", 0),
2039         SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2040         SD_BUS_SIGNAL("JobNew", "uos", 0),
2041         SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2042         SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2043         SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
2044         SD_BUS_SIGNAL("Reloading", "b", 0),
2045
2046         SD_BUS_VTABLE_END
2047 };
2048
2049 static int send_finished(sd_bus *bus, void *userdata) {
2050         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
2051         usec_t *times = userdata;
2052         int r;
2053
2054         assert(bus);
2055         assert(times);
2056
2057         r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2058         if (r < 0)
2059                 return r;
2060
2061         r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
2062         if (r < 0)
2063                 return r;
2064
2065         return sd_bus_send(bus, message, NULL);
2066 }
2067
2068 void bus_manager_send_finished(
2069                 Manager *m,
2070                 usec_t firmware_usec,
2071                 usec_t loader_usec,
2072                 usec_t kernel_usec,
2073                 usec_t initrd_usec,
2074                 usec_t userspace_usec,
2075                 usec_t total_usec) {
2076
2077         int r;
2078
2079         assert(m);
2080
2081         r = bus_foreach_bus(
2082                         m,
2083                         NULL,
2084                         send_finished,
2085                         (usec_t[6]) {
2086                                 firmware_usec,
2087                                 loader_usec,
2088                                 kernel_usec,
2089                                 initrd_usec,
2090                                 userspace_usec,
2091                                 total_usec
2092                         });
2093         if (r < 0)
2094                 log_debug_errno(r, "Failed to send finished signal: %m");
2095 }
2096
2097 static int send_reloading(sd_bus *bus, void *userdata) {
2098         _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
2099         int r;
2100
2101         assert(bus);
2102
2103         r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2104         if (r < 0)
2105                 return r;
2106
2107         r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
2108         if (r < 0)
2109                 return r;
2110
2111         return sd_bus_send(bus, message, NULL);
2112 }
2113
2114 void bus_manager_send_reloading(Manager *m, bool active) {
2115         int r;
2116
2117         assert(m);
2118
2119         r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
2120         if (r < 0)
2121                 log_debug_errno(r, "Failed to send reloading signal: %m");
2122 }
2123
2124 static int send_changed_signal(sd_bus *bus, void *userdata) {
2125         assert(bus);
2126
2127         return sd_bus_emit_properties_changed_strv(bus,
2128                                                    "/org/freedesktop/systemd1",
2129                                                    "org.freedesktop.systemd1.Manager",
2130                                                    NULL);
2131 }
2132
2133 void bus_manager_send_change_signal(Manager *m) {
2134         int r;
2135
2136         assert(m);
2137
2138         r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
2139         if (r < 0)
2140                 log_debug_errno(r, "Failed to send manager change signal: %m");
2141 }