src/core/dbus-manager.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2010 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <errno.h>
  23 #include <unistd.h>
  24
  25 #include "log.h"
  26 #include "strv.h"
  27 #include "build.h"
  28 #include "install.h"
  29 #include "selinux-access.h"
  30 #include "watchdog.h"
  31 #include "hwclock.h"
  32 #include "path-util.h"
  33 #include "virt.h"
  34 #include "env-util.h"
  35 #include "dbus.h"
  36 #include "dbus-manager.h"
  37 #include "dbus-unit.h"
  38 #include "dbus-snapshot.h"
  39 #include "dbus-client-track.h"
  40 #include "dbus-execute.h"
  41 #include "bus-errors.h"
  42
  43 static int property_get_version(
  44                 sd_bus *bus,
  45                 const char *path,
  46                 const char *interface,
  47                 const char *property,
  48                 sd_bus_message *reply,
  49                 sd_bus_error *error,
  50                 void *userdata) {
  51
  52         assert(bus);
  53         assert(reply);
  54
  55         return sd_bus_message_append(reply, "s", PACKAGE_VERSION);
  56 }
  57
  58 static int property_get_features(
  59                 sd_bus *bus,
  60                 const char *path,
  61                 const char *interface,
  62                 const char *property,
  63                 sd_bus_message *reply,
  64                 sd_bus_error *error,
  65                 void *userdata) {
  66
  67         assert(bus);
  68         assert(reply);
  69
  70         return sd_bus_message_append(reply, "s", SYSTEMD_FEATURES);
  71 }
  72
  73 static int property_get_virtualization(
  74                 sd_bus *bus,
  75                 const char *path,
  76                 const char *interface,
  77                 const char *property,
  78                 sd_bus_message *reply,
  79                 sd_bus_error *error,
  80                 void *userdata) {
  81
  82         const char *id = NULL;
  83
  84         assert(bus);
  85         assert(reply);
  86
  87         detect_virtualization(&id);
  88
  89         return sd_bus_message_append(reply, "s", id);
  90 }
  91
  92 static int property_get_tainted(
  93                 sd_bus *bus,
  94                 const char *path,
  95                 const char *interface,
  96                 const char *property,
  97                 sd_bus_message *reply,
  98                 sd_bus_error *error,
  99                 void *userdata) {
 100
 101         char buf[LINE_MAX] = "", *e = buf;
 102         _cleanup_free_ char *p = NULL;
 103         Manager *m = userdata;
 104
 105         assert(bus);
 106         assert(reply);
 107         assert(m);
 108
 109         if (m->taint_usr)
 110                 e = stpcpy(e, "split-usr:");
 111
 112         if (readlink_malloc("/etc/mtab", &p) < 0)
 113                 e = stpcpy(e, "mtab-not-symlink:");
 114
 115         if (access("/proc/cgroups", F_OK) < 0)
 116                 e = stpcpy(e, "cgroups-missing:");
 117
 118         if (hwclock_is_localtime() > 0)
 119                 e = stpcpy(e, "local-hwclock:");
 120
 121         /* remove the last ':' */
 122         if (e != buf)
 123                 e[-1] = 0;
 124
 125         return sd_bus_message_append(reply, "s", buf);
 126 }
 127
 128 static int property_get_log_target(
 129                 sd_bus *bus,
 130                 const char *path,
 131                 const char *interface,
 132                 const char *property,
 133                 sd_bus_message *reply,
 134                 sd_bus_error *error,
 135                 void *userdata) {
 136
 137         assert(bus);
 138         assert(reply);
 139
 140         return sd_bus_message_append(reply, "s", log_target_to_string(log_get_target()));
 141 }
 142
 143 static int property_set_log_target(
 144                 sd_bus *bus,
 145                 const char *path,
 146                 const char *interface,
 147                 const char *property,
 148                 sd_bus_message *value,
 149                 sd_bus_error *error,
 150                 void *userdata) {
 151
 152         const char *t;
 153         int r;
 154
 155         assert(bus);
 156         assert(value);
 157
 158         r = sd_bus_message_read(value, "s", &t);
 159         if (r < 0)
 160                 return r;
 161
 162         return log_set_target_from_string(t);
 163 }
 164
 165 static int property_get_log_level(
 166                 sd_bus *bus,
 167                 const char *path,
 168                 const char *interface,
 169                 const char *property,
 170                 sd_bus_message *reply,
 171                 sd_bus_error *error,
 172                 void *userdata) {
 173
 174         _cleanup_free_ char *t = NULL;
 175         int r;
 176
 177         assert(bus);
 178         assert(reply);
 179
 180         r = log_level_to_string_alloc(log_get_max_level(), &t);
 181         if (r < 0)
 182                 return r;
 183
 184         return sd_bus_message_append(reply, "s", t);
 185 }
 186
 187 static int property_set_log_level(
 188                 sd_bus *bus,
 189                 const char *path,
 190                 const char *interface,
 191                 const char *property,
 192                 sd_bus_message *value,
 193                 sd_bus_error *error,
 194                 void *userdata) {
 195
 196         const char *t;
 197         int r;
 198
 199         assert(bus);
 200         assert(value);
 201
 202         r = sd_bus_message_read(value, "s", &t);
 203         if (r < 0)
 204                 return r;
 205
 206         return log_set_max_level_from_string(t);
 207 }
 208
 209 static int property_get_n_names(
 210                 sd_bus *bus,
 211                 const char *path,
 212                 const char *interface,
 213                 const char *property,
 214                 sd_bus_message *reply,
 215                 sd_bus_error *error,
 216                 void *userdata) {
 217
 218         Manager *m = userdata;
 219
 220         assert(bus);
 221         assert(reply);
 222         assert(m);
 223
 224         return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->units));
 225 }
 226
 227 static int property_get_n_jobs(
 228                 sd_bus *bus,
 229                 const char *path,
 230                 const char *interface,
 231                 const char *property,
 232                 sd_bus_message *reply,
 233                 sd_bus_error *error,
 234                 void *userdata) {
 235
 236         Manager *m = userdata;
 237
 238         assert(bus);
 239         assert(reply);
 240         assert(m);
 241
 242         return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->jobs));
 243 }
 244
 245 static int property_get_progress(
 246                 sd_bus *bus,
 247                 const char *path,
 248                 const char *interface,
 249                 const char *property,
 250                 sd_bus_message *reply,
 251                 sd_bus_error *error,
 252                 void *userdata) {
 253
 254         Manager *m = userdata;
 255         double d;
 256
 257         assert(bus);
 258         assert(reply);
 259         assert(m);
 260
 261         if (dual_timestamp_is_set(&m->finish_timestamp))
 262                 d = 1.0;
 263         else
 264                 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
 265
 266         return sd_bus_message_append(reply, "d", d);
 267 }
 268
 269 static int property_set_runtime_watchdog(
 270                 sd_bus *bus,
 271                 const char *path,
 272                 const char *interface,
 273                 const char *property,
 274                 sd_bus_message *value,
 275                 sd_bus_error *error,
 276                 void *userdata) {
 277
 278         usec_t *t = userdata;
 279         int r;
 280
 281         assert(bus);
 282         assert(value);
 283
 284         assert_cc(sizeof(usec_t) == sizeof(uint64_t));
 285
 286         r = sd_bus_message_read(value, "t", t);
 287         if (r < 0)
 288                 return r;
 289
 290         return watchdog_set_timeout(t);
 291 }
 292
 293 static int method_get_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 294         _cleanup_free_ char *path = NULL;
 295         Manager *m = userdata;
 296         const char *name;
 297         Unit *u;
 298         int r;
 299
 300         assert(bus);
 301         assert(message);
 302         assert(m);
 303
 304         r = sd_bus_message_read(message, "s", &name);
 305         if (r < 0)
 306                 return sd_bus_reply_method_errno(message, r, NULL);
 307
 308         u = manager_get_unit(m, name);
 309         if (!u)
 310                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
 311
 312         SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
 313
 314         path = unit_dbus_path(u);
 315         if (!path)
 316                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 317
 318         return sd_bus_reply_method_return(message, "o", path);
 319 }
 320
 321 static int method_get_unit_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata) {
 322         _cleanup_free_ char *path = NULL;
 323         Manager *m = userdata;
 324         pid_t pid;
 325         Unit *u;
 326         int r;
 327
 328         assert(bus);
 329         assert(message);
 330         assert(m);
 331
 332         assert_cc(sizeof(pid_t) == sizeof(uint32_t));
 333
 334         r = sd_bus_message_read(message, "u", &pid);
 335         if (r < 0)
 336                 return sd_bus_reply_method_errno(message, r, NULL);
 337
 338         if (pid == 0) {
 339                 r = sd_bus_get_owner_pid(bus, sd_bus_message_get_sender(message), &pid);
 340                 if (r < 0)
 341                         return sd_bus_reply_method_errno(message, r, NULL);
 342         }
 343
 344         u = manager_get_unit_by_pid(m, pid);
 345         if (!u)
 346                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_UNIT_FOR_PID, "PID %u does not belong to any loaded unit.", pid);
 347
 348         SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
 349
 350         path = unit_dbus_path(u);
 351         if (!path)
 352                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 353
 354         return sd_bus_reply_method_return(message, "o", path);
 355 }
 356
 357 static int method_load_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 358         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 359         _cleanup_free_ char *path = NULL;
 360         Manager *m = userdata;
 361         const char *name;
 362         Unit *u;
 363         int r;
 364
 365         assert(bus);
 366         assert(message);
 367         assert(m);
 368
 369         r = sd_bus_message_read(message, "s", &name);
 370         if (r < 0)
 371                 return sd_bus_reply_method_errno(message, r, NULL);
 372
 373         r = manager_load_unit(m, name, NULL, &error, &u);
 374         if (r < 0)
 375                 return sd_bus_reply_method_errno(message, r, &error);
 376
 377         SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "status");
 378
 379         path = unit_dbus_path(u);
 380         if (!path)
 381                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 382
 383         return sd_bus_reply_method_return(message, "o", path);
 384 }
 385
 386 static int method_start_unit_generic(sd_bus *bus, sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible) {
 387         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 388         const char *name;
 389         Unit *u;
 390         int r;
 391
 392         assert(bus);
 393         assert(message);
 394         assert(m);
 395
 396         r = sd_bus_message_read(message, "s", &name);
 397         if (r < 0)
 398                 return sd_bus_reply_method_errno(message, r, NULL);
 399
 400         r = manager_load_unit(m, name, NULL, &error, &u);
 401         if (r < 0)
 402                 return sd_bus_reply_method_errno(message, r, &error);
 403
 404         return bus_unit_method_start_generic(bus, message, u, job_type, reload_if_possible);
 405 }
 406
 407 static int method_start_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 408         return method_start_unit_generic(bus, message, userdata, JOB_START, false);
 409 }
 410
 411 static int method_stop_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 412         return method_start_unit_generic(bus, message, userdata, JOB_STOP, false);
 413 }
 414
 415 static int method_reload_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 416         return method_start_unit_generic(bus, message, userdata, JOB_RELOAD, false);
 417 }
 418
 419 static int method_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 420         return method_start_unit_generic(bus, message, userdata, JOB_RESTART, false);
 421 }
 422
 423 static int method_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 424         return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, false);
 425 }
 426
 427 static int method_reload_or_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 428         return method_start_unit_generic(bus, message, userdata, JOB_RESTART, true);
 429 }
 430
 431 static int method_reload_or_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 432         return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, true);
 433 }
 434
 435 static int method_start_unit_replace(sd_bus *bus, sd_bus_message *message, void *userdata) {
 436         Manager *m = userdata;
 437         const char *old_name;
 438         Unit *u;
 439         int r;
 440
 441         assert(bus);
 442         assert(message);
 443         assert(m);
 444
 445         r = sd_bus_message_read(message, "s", &old_name);
 446         if (r < 0)
 447                 return sd_bus_reply_method_errno(message, r, NULL);
 448
 449         u = manager_get_unit(m, old_name);
 450         if (!u || !u->job || u->job->type != JOB_START)
 451                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
 452
 453         return method_start_unit_generic(bus, message, m, JOB_START, false);
 454 }
 455
 456 static int method_kill_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 457         Manager *m = userdata;
 458         const char *name;
 459         Unit *u;
 460         int r;
 461
 462         assert(bus);
 463         assert(message);
 464         assert(m);
 465
 466         r = sd_bus_message_read(message, "s", &name);
 467         if (r < 0)
 468                 return sd_bus_reply_method_errno(message, r, NULL);
 469
 470         u = manager_get_unit(m, name);
 471         if (!u)
 472                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
 473
 474         return bus_unit_method_kill(bus, message, u);
 475 }
 476
 477 static int method_reset_failed_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 478         Manager *m = userdata;
 479         const char *name;
 480         Unit *u;
 481         int r;
 482
 483         assert(bus);
 484         assert(message);
 485         assert(m);
 486
 487         r = sd_bus_message_read(message, "s", &name);
 488         if (r < 0)
 489                 return sd_bus_reply_method_errno(message, r, NULL);
 490
 491         u = manager_get_unit(m, name);
 492         if (!u)
 493                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
 494
 495         return bus_unit_method_reset_failed(bus, message, u);
 496 }
 497
 498 static int method_set_unit_properties(sd_bus *bus, sd_bus_message *message, void *userdata) {
 499         Manager *m = userdata;
 500         const char *name;
 501         Unit *u;
 502         int r;
 503
 504         assert(bus);
 505         assert(message);
 506         assert(m);
 507
 508         r = sd_bus_message_read(message, "s", &name);
 509         if (r < 0)
 510                 return sd_bus_reply_method_errno(message, r, NULL);
 511
 512         u = manager_get_unit(m, name);
 513         if (!u)
 514                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
 515
 516         return bus_unit_method_set_properties(bus, message, u);
 517 }
 518
 519 static int method_start_transient_unit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 520         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 521         const char *name, *smode;
 522         Manager *m = userdata;
 523         JobMode mode;
 524         UnitType t;
 525         Unit *u;
 526         int r;
 527
 528         assert(bus);
 529         assert(message);
 530         assert(m);
 531
 532         r = sd_bus_message_read(message, "ss", &name, &smode);
 533         if (r < 0)
 534                 return sd_bus_reply_method_errno(message, r, NULL);
 535
 536         t = unit_name_to_type(name);
 537         if (t < 0)
 538                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit type.");
 539
 540         if (!unit_vtable[t]->can_transient)
 541                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Unit type %s does not support transient units.");
 542
 543         mode = job_mode_from_string(smode);
 544         if (mode < 0)
 545                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
 546
 547         r = manager_load_unit(m, name, NULL, &error, &u);
 548         if (r < 0)
 549                 return sd_bus_reply_method_errno(message, r, &error);
 550
 551         SELINUX_UNIT_ACCESS_CHECK(u, bus, message, "start");
 552
 553         if (u->load_state != UNIT_NOT_FOUND || set_size(u->dependencies[UNIT_REFERENCED_BY]) > 0)
 554                 return sd_bus_reply_method_errorf(message, BUS_ERROR_UNIT_EXISTS, "Unit %s already exists.", name);
 555
 556         /* OK, the unit failed to load and is unreferenced, now let's
 557          * fill in the transient data instead */
 558         r = unit_make_transient(u);
 559         if (r < 0)
 560                 return sd_bus_reply_method_errno(message, r, NULL);
 561
 562         /* Set our properties */
 563         r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, &error);
 564         if (r < 0)
 565                 return sd_bus_reply_method_errno(message, r, &error);
 566
 567         /* And load this stub fully */
 568         r = unit_load(u);
 569         if (r < 0)
 570                 return sd_bus_reply_method_errno(message, r, &error);
 571
 572         manager_dispatch_load_queue(m);
 573
 574         /* Finally, start it */
 575         return bus_unit_queue_job(bus, message, u, JOB_START, mode, false);
 576 }
 577
 578 static int method_get_job(sd_bus *bus, sd_bus_message *message, void *userdata) {
 579         _cleanup_free_ char *path = NULL;
 580         Manager *m = userdata;
 581         uint32_t id;
 582         Job *j;
 583         int r;
 584
 585         assert(bus);
 586         assert(message);
 587         assert(m);
 588
 589         r = sd_bus_message_read(message, "u", &id);
 590         if (r < 0)
 591                 return sd_bus_reply_method_errno(message, r, NULL);
 592
 593         j = manager_get_job(m, id);
 594         if (!j)
 595                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
 596
 597         SELINUX_UNIT_ACCESS_CHECK(j->unit, bus, message, "status");
 598
 599         path = job_dbus_path(j);
 600         if (!path)
 601                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 602
 603         return sd_bus_reply_method_return(message, "o", path);
 604 }
 605
 606 static int method_cancel_job(sd_bus *bus, sd_bus_message *message, void *userdata) {
 607         Manager *m = userdata;
 608         uint32_t id;
 609         Job *j;
 610         int r;
 611
 612         assert(bus);
 613         assert(message);
 614         assert(m);
 615
 616         r = sd_bus_message_read(message, "u", &id);
 617         if (r < 0)
 618                 return sd_bus_reply_method_errno(message, r, NULL);
 619
 620         j = manager_get_job(m, id);
 621         if (!j)
 622                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
 623
 624         SELINUX_UNIT_ACCESS_CHECK(j->unit, bus, message, "stop");
 625
 626         job_finish_and_invalidate(j, JOB_CANCELED, true);
 627
 628         return sd_bus_reply_method_return(message, NULL);
 629 }
 630
 631 static int method_clear_jobs(sd_bus *bus, sd_bus_message *message, void *userdata) {
 632         Manager *m = userdata;
 633
 634         assert(bus);
 635         assert(message);
 636         assert(m);
 637
 638         SELINUX_ACCESS_CHECK(bus, message, "reboot");
 639         manager_clear_jobs(m);
 640
 641         return sd_bus_reply_method_return(message, NULL);
 642 }
 643
 644 static int method_reset_failed(sd_bus *bus, sd_bus_message *message, void *userdata) {
 645         Manager *m = userdata;
 646
 647         assert(bus);
 648         assert(message);
 649         assert(m);
 650
 651         SELINUX_ACCESS_CHECK(bus, message, "reload");
 652         manager_reset_failed(m);
 653
 654         return sd_bus_reply_method_return(message, NULL);
 655 }
 656
 657 static int method_list_units(sd_bus *bus, sd_bus_message *message, void *userdata) {
 658         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 659         Manager *m = userdata;
 660         const char *k;
 661         Iterator i;
 662         Unit *u;
 663         int r;
 664
 665         assert(bus);
 666         assert(message);
 667         assert(m);
 668
 669         SELINUX_ACCESS_CHECK(bus, message, "status");
 670
 671         r = sd_bus_message_new_method_return(message, &reply);
 672         if (r < 0)
 673                 return sd_bus_reply_method_errno(message, r, NULL);
 674
 675         r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
 676         if (r < 0)
 677                 return sd_bus_reply_method_errno(message, r, NULL);
 678
 679         HASHMAP_FOREACH_KEY(u, k, m->units, i) {
 680                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
 681                 Unit *following;
 682
 683                 if (k != u->id)
 684                         continue;
 685
 686                 following = unit_following(u);
 687
 688                 unit_path = unit_dbus_path(u);
 689                 if (!unit_path)
 690                         return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 691
 692                 if (u->job) {
 693                         job_path = job_dbus_path(u->job);
 694                         if (!job_path)
 695                                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 696                 }
 697
 698                 r = sd_bus_message_append(
 699                                 reply, "(ssssssouso)",
 700                                 u->id,
 701                                 unit_description(u),
 702                                 unit_load_state_to_string(u->load_state),
 703                                 unit_active_state_to_string(unit_active_state(u)),
 704                                 unit_sub_state_to_string(u),
 705                                 following ? following->id : "",
 706                                 unit_path,
 707                                 u->job ? u->job->id : 0,
 708                                 u->job ? job_type_to_string(u->job->type) : "",
 709                                 job_path ? job_path : "/");
 710                 if (r < 0)
 711                         return sd_bus_reply_method_errno(message, r, NULL);
 712         }
 713
 714         r = sd_bus_message_close_container(reply);
 715         if (r < 0)
 716                 return sd_bus_reply_method_errno(message, r, NULL);
 717
 718         return sd_bus_send(bus, reply, NULL);
 719 }
 720
 721 static int method_list_jobs(sd_bus *bus, sd_bus_message *message, void *userdata) {
 722         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
 723         Manager *m = userdata;
 724         Iterator i;
 725         Job *j;
 726         int r;
 727
 728         assert(bus);
 729         assert(message);
 730         assert(m);
 731
 732         SELINUX_ACCESS_CHECK(bus, message, "status");
 733
 734         r = sd_bus_message_new_method_return(message, &reply);
 735         if (r < 0)
 736                 return sd_bus_reply_method_errno(message, r, NULL);
 737
 738         r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
 739         if (r < 0)
 740                 return sd_bus_reply_method_errno(message, r, NULL);
 741
 742         HASHMAP_FOREACH(j, m->jobs, i) {
 743                 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
 744
 745                 job_path = job_dbus_path(j);
 746                 if (!job_path)
 747                         return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 748
 749                 unit_path = unit_dbus_path(j->unit);
 750                 if (!unit_path)
 751                         return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 752
 753                 r = sd_bus_message_append(
 754                                 reply, "(usssoo)",
 755                                 j->id,
 756                                 job_state_to_string(j->state),
 757                                 job_type_to_string(j->type),
 758                                 job_path,
 759                                 unit_path);
 760                 if (r < 0)
 761                         return sd_bus_reply_method_errno(message, r, NULL);
 762         }
 763
 764         r = sd_bus_message_close_container(reply);
 765         if (r < 0)
 766                 return sd_bus_reply_method_errno(message, r, NULL);
 767
 768         return sd_bus_send(bus, reply, NULL);
 769 }
 770
 771 static int method_subscribe(sd_bus *bus, sd_bus_message *message, void *userdata) {
 772         Manager *m = userdata;
 773         int r;
 774
 775         assert(bus);
 776         assert(message);
 777         assert(m);
 778
 779         SELINUX_ACCESS_CHECK(bus, message, "status");
 780
 781         r = bus_client_track(&m->subscribed, bus, sd_bus_message_get_sender(message));
 782         if (r < 0)
 783                 return sd_bus_reply_method_errno(message, r, NULL);
 784         if (r == 0)
 785                 return sd_bus_reply_method_errorf(message, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
 786
 787         return sd_bus_reply_method_return(message, NULL);
 788 }
 789
 790 static int method_unsubscribe(sd_bus *bus, sd_bus_message *message, void *userdata) {
 791         Manager *m = userdata;
 792         int r;
 793
 794         assert(bus);
 795         assert(message);
 796         assert(m);
 797
 798         SELINUX_ACCESS_CHECK(bus, message, "status");
 799
 800         r = bus_client_untrack(m->subscribed, bus, sd_bus_message_get_sender(message));
 801         if (r < 0)
 802                 return sd_bus_reply_method_errno(message, r, NULL);
 803         if (r == 0)
 804                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
 805
 806         return sd_bus_reply_method_return(message, NULL);
 807 }
 808
 809 static int method_dump(sd_bus *bus, sd_bus_message *message, void *userdata) {
 810         _cleanup_free_ char *dump = NULL;
 811         _cleanup_fclose_ FILE *f = NULL;
 812         Manager *m = userdata;
 813         size_t size;
 814
 815         assert(bus);
 816         assert(message);
 817         assert(m);
 818
 819         SELINUX_ACCESS_CHECK(bus, message, "status");
 820
 821         f = open_memstream(&dump, &size);
 822         if (!f)
 823                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 824
 825         manager_dump_units(m, f, NULL);
 826         manager_dump_jobs(m, f, NULL);
 827
 828         fflush(f);
 829
 830         if (ferror(f))
 831                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 832
 833         return sd_bus_reply_method_return(message, "s", dump);
 834 }
 835
 836 static int method_create_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata) {
 837         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
 838         _cleanup_free_ char *path = NULL;
 839         Manager *m = userdata;
 840         const char *name;
 841         int cleanup;
 842         Snapshot *s;
 843         int r;
 844
 845         assert(bus);
 846         assert(message);
 847         assert(m);
 848
 849         SELINUX_ACCESS_CHECK(bus, message, "start");
 850
 851         r = sd_bus_message_read(message, "sb", &name, &cleanup);
 852         if (r < 0)
 853                 return sd_bus_reply_method_errno(message, r, NULL);
 854
 855         if (isempty(name))
 856                 name = NULL;
 857
 858         r = snapshot_create(m, name, cleanup, &error, &s);
 859         if (r < 0)
 860                 return sd_bus_reply_method_errno(message, r, &error);
 861
 862         path = unit_dbus_path(UNIT(s));
 863         if (!path)
 864                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
 865
 866         return sd_bus_reply_method_return(message, "o", path);
 867 }
 868
 869 static int method_remove_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata) {
 870         Manager *m = userdata;
 871         const char *name;
 872         Unit *u;
 873         int r;
 874
 875         assert(bus);
 876         assert(message);
 877         assert(m);
 878
 879         SELINUX_ACCESS_CHECK(bus, message, "start");
 880
 881         r = sd_bus_message_read(message, "s", &name);
 882         if (r < 0)
 883                 return sd_bus_reply_method_errno(message, r, NULL);
 884
 885         u = manager_get_unit(m, name);
 886         if (!u)
 887                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s does not exist.", name);
 888
 889         if (u->type != UNIT_SNAPSHOT)
 890                 return sd_bus_reply_method_errorf(message, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not a snapshot", name);
 891
 892         return bus_snapshot_method_remove(bus, message, u);
 893 }
 894
 895 static int method_reload(sd_bus *bus, sd_bus_message *message, void *userdata) {
 896         Manager *m = userdata;
 897         int r;
 898
 899         assert(bus);
 900         assert(message);
 901         assert(m);
 902
 903         SELINUX_ACCESS_CHECK(bus, message, "reload");
 904
 905         /* Instead of sending the reply back right away, we just
 906          * remember that we need to and then send it after the reload
 907          * is finished. That way the caller knows when the reload
 908          * finished. */
 909
 910         assert(!m->queued_message);
 911         r = sd_bus_message_new_method_return(message, &m->queued_message);
 912         if (r < 0)
 913                 return sd_bus_reply_method_errno(message, r, NULL);
 914
 915         m->queued_message_bus = sd_bus_ref(bus);
 916         m->exit_code = MANAGER_RELOAD;
 917
 918         return 1;
 919 }
 920
 921 static int method_reexecute(sd_bus *bus, sd_bus_message *message, void *userdata) {
 922         Manager *m = userdata;
 923
 924         assert(bus);
 925         assert(message);
 926         assert(m);
 927
 928         SELINUX_ACCESS_CHECK(bus, message, "reload");
 929
 930         /* We don't send a reply back here, the client should
 931          * just wait for us disconnecting. */
 932
 933         m->exit_code = MANAGER_REEXECUTE;
 934         return 1;
 935 }
 936
 937 static int method_exit(sd_bus *bus, sd_bus_message *message, void *userdata) {
 938         Manager *m = userdata;
 939
 940         assert(bus);
 941         assert(message);
 942         assert(m);
 943
 944         SELINUX_ACCESS_CHECK(bus, message, "halt");
 945
 946         if (m->running_as == SYSTEMD_SYSTEM)
 947                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "Exit is only supported for user service managers.");
 948
 949         m->exit_code = MANAGER_EXIT;
 950
 951         return sd_bus_reply_method_return(message, NULL);
 952 }
 953
 954 static int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata) {
 955         Manager *m = userdata;
 956
 957         assert(bus);
 958         assert(message);
 959         assert(m);
 960
 961         SELINUX_ACCESS_CHECK(bus, message, "reboot");
 962
 963         if (m->running_as != SYSTEMD_SYSTEM)
 964                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
 965
 966         m->exit_code = MANAGER_REBOOT;
 967
 968         return sd_bus_reply_method_return(message, NULL);
 969 }
 970
 971
 972 static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata) {
 973         Manager *m = userdata;
 974
 975         assert(bus);
 976         assert(message);
 977         assert(m);
 978
 979         SELINUX_ACCESS_CHECK(bus, message, "halt");
 980
 981         if (m->running_as != SYSTEMD_SYSTEM)
 982                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
 983
 984         m->exit_code = MANAGER_POWEROFF;
 985
 986         return sd_bus_reply_method_return(message, NULL);
 987 }
 988
 989 static int method_halt(sd_bus *bus, sd_bus_message *message, void *userdata) {
 990         Manager *m = userdata;
 991
 992         assert(bus);
 993         assert(message);
 994         assert(m);
 995
 996         SELINUX_ACCESS_CHECK(bus, message, "halt");
 997
 998         if (m->running_as != SYSTEMD_SYSTEM)
 999                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "Halt is only supported for system managers.");
1000
1001         m->exit_code = MANAGER_HALT;
1002
1003         return sd_bus_reply_method_return(message, NULL);
1004 }
1005
1006 static int method_kexec(sd_bus *bus, sd_bus_message *message, void *userdata) {
1007         Manager *m = userdata;
1008
1009         assert(bus);
1010         assert(message);
1011         assert(m);
1012
1013         SELINUX_ACCESS_CHECK(bus, message, "reboot");
1014
1015         if (m->running_as != SYSTEMD_SYSTEM)
1016                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1017
1018         m->exit_code = MANAGER_KEXEC;
1019
1020         return sd_bus_reply_method_return(message, NULL);
1021 }
1022
1023 static int method_switch_root(sd_bus *bus, sd_bus_message *message, void *userdata) {
1024         char *ri = NULL, *rt = NULL;
1025         const char *root, *init;
1026         Manager *m = userdata;
1027         int r;
1028
1029         assert(bus);
1030         assert(message);
1031         assert(m);
1032
1033         SELINUX_ACCESS_CHECK(bus, message, "reboot");
1034
1035         if (m->running_as != SYSTEMD_SYSTEM)
1036                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1037
1038         r = sd_bus_message_read(message, "ss", &root, &init);
1039         if (r < 0)
1040                 return sd_bus_reply_method_errno(message, r, NULL);
1041
1042         if (path_equal(root, "/") || !path_is_absolute(root))
1043                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid switch root path %s", root);
1044
1045         /* Safety check */
1046         if (isempty(init)) {
1047                 if (! path_is_os_tree(root))
1048                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Specified switch root path %s does not seem to be an OS tree. /etc/os-release is missing.", root);
1049         } else {
1050                 _cleanup_free_ char *p = NULL;
1051
1052                 if (!path_is_absolute(init))
1053                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid init path %s", init);
1054
1055                 p = strappend(root, init);
1056                 if (!p)
1057                         return sd_bus_reply_method_errno(message, ENOMEM, NULL);
1058
1059                 if (access(p, X_OK) < 0)
1060                         return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Specified init binary %s does not exist.", p);
1061         }
1062
1063         rt = strdup(root);
1064         if (!rt)
1065                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
1066
1067         if (!isempty(init)) {
1068                 ri = strdup(init);
1069                 if (!ri) {
1070                         free(ri);
1071                         return sd_bus_reply_method_errno(message, ENOMEM, NULL);
1072                 }
1073         }
1074
1075         free(m->switch_root);
1076         m->switch_root = rt;
1077
1078         free(m->switch_root_init);
1079         m->switch_root_init = ri;
1080
1081         return sd_bus_reply_method_return(message, NULL);
1082 }
1083
1084 static int method_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1085         _cleanup_strv_free_ char **plus = NULL;
1086         Manager *m = userdata;
1087         int r;
1088
1089         assert(bus);
1090         assert(message);
1091         assert(m);
1092
1093         SELINUX_ACCESS_CHECK(bus, message, "reload");
1094
1095         r = sd_bus_message_read_strv(message, &plus);
1096         if (r < 0)
1097                 return sd_bus_reply_method_errno(message, r, NULL);
1098         if (!strv_env_is_valid(plus))
1099                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1100
1101         r = manager_environment_add(m, NULL, plus);
1102         if (r < 0)
1103                 return sd_bus_reply_method_errno(message, r, NULL);
1104
1105         return sd_bus_reply_method_return(message, NULL);
1106 }
1107
1108 static int method_unset_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1109         _cleanup_strv_free_ char **minus = NULL;
1110         Manager *m = userdata;
1111         int r;
1112
1113         assert(bus);
1114         assert(message);
1115         assert(m);
1116
1117         SELINUX_ACCESS_CHECK(bus, message, "reload");
1118
1119         r = sd_bus_message_read_strv(message, &minus);
1120         if (r < 0)
1121                 return sd_bus_reply_method_errno(message, r, NULL);
1122
1123         if (!strv_env_name_or_assignment_is_valid(minus))
1124                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1125
1126         r = manager_environment_add(m, minus, NULL);
1127         if (r < 0)
1128                 return sd_bus_reply_method_errno(message, r, NULL);
1129
1130         return sd_bus_reply_method_return(message, NULL);
1131 }
1132
1133 static int method_unset_and_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata) {
1134         _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1135         Manager *m = userdata;
1136         int r;
1137
1138         assert(bus);
1139         assert(message);
1140         assert(m);
1141
1142         SELINUX_ACCESS_CHECK(bus, message, "reload");
1143
1144         r = sd_bus_message_read_strv(message, &plus);
1145         if (r < 0)
1146                 return sd_bus_reply_method_errno(message, r, NULL);
1147
1148         r = sd_bus_message_read_strv(message, &minus);
1149         if (r < 0)
1150                 return sd_bus_reply_method_errno(message, r, NULL);
1151
1152         if (!strv_env_is_valid(plus))
1153                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1154         if (!strv_env_name_or_assignment_is_valid(minus))
1155                 return sd_bus_reply_method_errorf(message, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1156
1157         r = manager_environment_add(m, minus, plus);
1158         if (r < 0)
1159                 return sd_bus_reply_method_errno(message, r, NULL);
1160
1161         return sd_bus_reply_method_return(message, NULL);
1162 }
1163
1164 static int method_list_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1165         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1166         Manager *m = userdata;
1167         UnitFileList *item;
1168         Hashmap *h;
1169         Iterator i;
1170         int r;
1171
1172         assert(bus);
1173         assert(message);
1174         assert(m);
1175
1176         SELINUX_ACCESS_CHECK(bus, message, "status");
1177
1178         r = sd_bus_message_new_method_return(message, &reply);
1179         if (r < 0)
1180                 return sd_bus_reply_method_errno(message, r, NULL);
1181
1182         h = hashmap_new(string_hash_func, string_compare_func);
1183         if (!h)
1184                 return sd_bus_reply_method_errno(message, ENOMEM, NULL);
1185
1186         r = unit_file_get_list(m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, h);
1187         if (r < 0) {
1188                 r = sd_bus_reply_method_errno(message, r, NULL);
1189                 goto fail;
1190         }
1191
1192         r = sd_bus_message_open_container(reply, 'a', "(ss)");
1193         if (r < 0) {
1194                 r = sd_bus_reply_method_errno(message, r, NULL);
1195                 goto fail;
1196         }
1197
1198         HASHMAP_FOREACH(item, h, i) {
1199
1200                 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
1201                 if (r < 0) {
1202                         r = sd_bus_reply_method_errno(message, r, NULL);
1203                         goto fail;
1204                 }
1205         }
1206
1207         unit_file_list_free(h);
1208
1209         r = sd_bus_message_close_container(reply);
1210         if (r < 0)
1211                 return sd_bus_reply_method_errno(message, r, NULL);
1212
1213         return sd_bus_send(bus, reply, NULL);
1214
1215 fail:
1216         unit_file_list_free(h);
1217         return r;
1218 }
1219
1220 static int method_get_unit_file_state(sd_bus *bus, sd_bus_message *message, void *userdata) {
1221         Manager *m = userdata;
1222         const char *name;
1223         UnitFileState state;
1224         UnitFileScope scope;
1225         int r;
1226
1227         assert(bus);
1228         assert(message);
1229         assert(m);
1230
1231         SELINUX_ACCESS_CHECK(bus, message, "status");
1232
1233         r = sd_bus_message_read(message, "s", &name);
1234         if (r < 0)
1235                 return sd_bus_reply_method_errno(message, r, NULL);
1236
1237         scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1238
1239         state = unit_file_get_state(scope, NULL, name);
1240         if (state < 0)
1241                 return sd_bus_reply_method_errno(message, state, NULL);
1242
1243         return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
1244 }
1245
1246 static int method_get_default_target(sd_bus *bus, sd_bus_message *message, void *userdata) {
1247         _cleanup_free_ char *default_target = NULL;
1248         Manager *m = userdata;
1249         UnitFileScope scope;
1250         int r;
1251
1252         assert(bus);
1253         assert(message);
1254         assert(m);
1255
1256         SELINUX_ACCESS_CHECK(bus, message, "status");
1257
1258         scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1259
1260         r = unit_file_get_default(scope, NULL, &default_target);
1261         if (r < 0)
1262                 return sd_bus_reply_method_errno(message, r, NULL);
1263
1264         return sd_bus_reply_method_return(message, "s", default_target);
1265 }
1266
1267 static int send_unit_files_changed(sd_bus *bus, const char *destination, void *userdata) {
1268         _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1269         int r;
1270
1271         assert(bus);
1272
1273         r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged", &message);
1274         if (r < 0)
1275                 return r;
1276
1277         return sd_bus_send_to(bus, message, destination, NULL);
1278 }
1279
1280 static int reply_unit_file_changes_and_free(
1281                 Manager *m,
1282                 sd_bus *bus,
1283                 sd_bus_message *message,
1284                 int carries_install_info,
1285                 UnitFileChange *changes,
1286                 unsigned n_changes) {
1287
1288         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1289         unsigned i;
1290         int r;
1291
1292         if (n_changes > 0)
1293                 bus_manager_foreach_client(m, send_unit_files_changed, NULL);
1294
1295         r = sd_bus_message_new_method_return(message, &reply);
1296         if (r < 0)
1297                 goto fail;
1298
1299         if (carries_install_info >= 0) {
1300                 r = sd_bus_message_append(reply, "b", carries_install_info);
1301                 if (r < 0)
1302                         goto fail;
1303         }
1304
1305         r = sd_bus_message_open_container(reply, 'a', "(sss)");
1306         if (r < 0)
1307                 goto fail;
1308
1309         for (i = 0; i < n_changes; i++) {
1310                 r = sd_bus_message_append(
1311                                 message, "(sss)",
1312                                 unit_file_change_type_to_string(changes[i].type),
1313                                 changes[i].path,
1314                                 changes[i].source);
1315                 if (r < 0)
1316                         goto fail;
1317         }
1318
1319         r = sd_bus_message_close_container(reply);
1320         if (r < 0)
1321                 goto fail;
1322
1323         return sd_bus_send(bus, message, NULL);
1324
1325 fail:
1326         unit_file_changes_free(changes, n_changes);
1327         return sd_bus_reply_method_errno(message, r, NULL);
1328 }
1329
1330 static int method_enable_unit_files_generic(
1331                 sd_bus *bus,
1332                 sd_bus_message *message,
1333                 Manager *m, const
1334                 char *verb,
1335                 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], bool force, UnitFileChange **changes, unsigned *n_changes),
1336                 bool carries_install_info) {
1337
1338         _cleanup_strv_free_ char **l = NULL;
1339         UnitFileChange *changes = NULL;
1340         unsigned n_changes = 0;
1341         UnitFileScope scope;
1342         int runtime, force, r;
1343
1344         assert(bus);
1345         assert(message);
1346         assert(m);
1347
1348         SELINUX_ACCESS_CHECK(bus, message, verb);
1349
1350         r = sd_bus_message_read_strv(message, &l);
1351         if (r < 0)
1352                 return sd_bus_reply_method_errno(message, r, NULL);
1353
1354         r = sd_bus_message_read(message, "bb", &runtime, &force);
1355         if (r < 0)
1356                 return sd_bus_reply_method_errno(message, r, NULL);
1357
1358         scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1359
1360         r = call(scope, runtime, NULL, l, force, &changes, &n_changes);
1361         if (r < 0)
1362                 return sd_bus_reply_method_errno(message, r, NULL);
1363
1364         return reply_unit_file_changes_and_free(m, bus, message, carries_install_info ? r : -1, changes, n_changes);
1365 }
1366
1367 static int method_enable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1368         return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_enable, true);
1369 }
1370
1371 static int method_reenable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1372         return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_reenable, true);
1373 }
1374
1375 static int method_link_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1376         return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_link, false);
1377 }
1378
1379 static int method_preset_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1380         return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_preset, true);
1381 }
1382
1383 static int method_mask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1384         return method_enable_unit_files_generic(bus, message, userdata, "disable", unit_file_mask, false);
1385 }
1386
1387 static int method_disable_unit_files_generic(
1388                 sd_bus *bus,
1389                 sd_bus_message *message,
1390                 Manager *m, const
1391                 char *verb,
1392                 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], UnitFileChange **changes, unsigned *n_changes)) {
1393
1394         _cleanup_strv_free_ char **l = NULL;
1395         UnitFileChange *changes = NULL;
1396         unsigned n_changes = 0;
1397         UnitFileScope scope;
1398         int r, runtime;
1399
1400         assert(bus);
1401         assert(message);
1402         assert(m);
1403
1404         SELINUX_ACCESS_CHECK(bus, message, verb);
1405
1406         r = sd_bus_message_read_strv(message, &l);
1407         if (r < 0)
1408                 return sd_bus_reply_method_errno(message, r, NULL);
1409
1410         r = sd_bus_message_read(message, "b", &runtime);
1411         if (r < 0)
1412                 return sd_bus_reply_method_errno(message, r, NULL);
1413
1414         scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1415
1416         r = call(scope, runtime, NULL, l, &changes, &n_changes);
1417         if (r < 0)
1418                 return sd_bus_reply_method_errno(message, r, NULL);
1419
1420         return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1421 }
1422
1423 static int method_disable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1424         return method_disable_unit_files_generic(bus, message, userdata, "disable", unit_file_disable);
1425 }
1426
1427 static int method_unmask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata) {
1428         return method_disable_unit_files_generic(bus, message, userdata, "enable", unit_file_unmask);
1429 }
1430
1431 static int method_set_default_target(sd_bus *bus, sd_bus_message *message, void *userdata) {
1432         UnitFileChange *changes = NULL;
1433         unsigned n_changes = 0;
1434         Manager *m = userdata;
1435         UnitFileScope scope;
1436         const char *name;
1437         int force, r;
1438
1439         assert(bus);
1440         assert(message);
1441         assert(m);
1442
1443         SELINUX_ACCESS_CHECK(bus, message, "enable");
1444
1445         r = sd_bus_message_read(message, "sb", &name, &force);
1446         if (r < 0)
1447                 return sd_bus_reply_method_errno(message, r, NULL);
1448
1449         scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1450
1451         r = unit_file_set_default(scope, NULL, name, force, &changes, &n_changes);
1452         if (r < 0)
1453                 return sd_bus_reply_method_errno(message, r, NULL);
1454
1455         return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1456 }
1457
1458 const sd_bus_vtable bus_manager_vtable[] = {
1459         SD_BUS_VTABLE_START(0),
1460
1461         SD_BUS_PROPERTY("Version", "s", property_get_version, 0, 0),
1462         SD_BUS_PROPERTY("Features", "s", property_get_features, 0, 0),
1463         SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, 0),
1464         SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, 0),
1465         BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, firmware_timestamp), 0),
1466         BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, loader_timestamp), 0),
1467         BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, firmware_timestamp), 0),
1468         BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, initrd_timestamp), 0),
1469         BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, userspace_timestamp), 0),
1470         BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, finish_timestamp), 0),
1471         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, security_start_timestamp), 0),
1472         BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, security_finish_timestamp), 0),
1473         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, generators_start_timestamp), 0),
1474         BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, generators_finish_timestamp), 0),
1475         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, units_load_start_timestamp), 0),
1476         BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, units_load_finish_timestamp), 0),
1477         SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level, property_set_log_level, 0, 0),
1478         SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target, property_set_log_target, 0, 0),
1479         SD_BUS_PROPERTY("NNames", "u", property_get_n_names, 0, 0),
1480         SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs, 0, 0),
1481         SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
1482         SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
1483         SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1484         SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(Manager, environment), 0),
1485         SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), 0),
1486         SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool, offsetof(Manager, show_status), 0),
1487         SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.unit_path), 0),
1488         SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), 0),
1489         SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), 0),
1490         SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec, property_set_runtime_watchdog, offsetof(Manager, runtime_watchdog), 0),
1491         SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec, bus_property_set_usec, offsetof(Manager, shutdown_watchdog), 0),
1492
1493         SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit, 0),
1494         SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid, 0),
1495         SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit, 0),
1496         SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit, 0),
1497         SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace, 0),
1498         SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit, 0),
1499         SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit, 0),
1500         SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit, 0),
1501         SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit, 0),
1502         SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit, 0),
1503         SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit, 0),
1504         SD_BUS_METHOD("KillUnit", "ssi", NULL, method_kill_unit, 0),
1505         SD_BUS_METHOD("ResetFailedUnit", "s", NULL, method_reset_failed_unit, 0),
1506         SD_BUS_METHOD("SetUnitProperties", "sb", "a(sv)", method_set_unit_properties, 0),
1507         SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit, 0),
1508         SD_BUS_METHOD("GetJob", "u", "o", method_get_job, 0),
1509         SD_BUS_METHOD("CancelJob", "u", NULL, method_cancel_job, 0),
1510         SD_BUS_METHOD("ClearJobs", NULL, NULL, method_clear_jobs, 0),
1511         SD_BUS_METHOD("ResetFailed", NULL, NULL, method_reset_failed, 0),
1512         SD_BUS_METHOD("ListUnits", NULL, "a(ssssssouso)", method_list_units, 0),
1513         SD_BUS_METHOD("ListJobs", NULL, "a(usssoo)", method_list_jobs, 0),
1514         SD_BUS_METHOD("Subscribe", NULL, NULL, method_subscribe, 0),
1515         SD_BUS_METHOD("Unsubscribe", NULL, NULL, method_unsubscribe, 0),
1516         SD_BUS_METHOD("Dump", NULL, "s", method_dump, 0),
1517         SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_create_snapshot, 0),
1518         SD_BUS_METHOD("RemoveSnapshot", "s", NULL, method_remove_snapshot, 0),
1519         SD_BUS_METHOD("Reload", NULL, NULL, method_reload, 0),
1520         SD_BUS_METHOD("Reexecute", NULL, NULL, method_reexecute, 0),
1521         SD_BUS_METHOD("Exit", NULL, NULL, method_exit, 0),
1522         SD_BUS_METHOD("Reboot", NULL, NULL, method_reboot, 0),
1523         SD_BUS_METHOD("PowerOff", NULL, NULL, method_poweroff, 0),
1524         SD_BUS_METHOD("Halt", NULL, NULL, method_halt, 0),
1525         SD_BUS_METHOD("KExec", NULL, NULL, method_kexec, 0),
1526         SD_BUS_METHOD("SwitchRoot", "ss", NULL, method_switch_root, 0),
1527         SD_BUS_METHOD("SetEnvironment", "as", NULL, method_set_environment, 0),
1528         SD_BUS_METHOD("UnsetEnvironment", "as", NULL, method_unset_environment, 0),
1529         SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL, method_unset_and_set_environment, 0),
1530         SD_BUS_METHOD("ListUnitFiles", NULL, "a(ss)", method_list_unit_files, 0),
1531         SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state, 0),
1532         SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files, 0),
1533         SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files, 0),
1534         SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files, 0),
1535         SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files, 0),
1536         SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files, 0),
1537         SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files, 0),
1538         SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files, 0),
1539         SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target, 0),
1540         SD_BUS_METHOD("GetDefaultTarget", NULL, "s", method_get_default_target, 0),
1541
1542         SD_BUS_SIGNAL("UnitNew", "so", 0),
1543         SD_BUS_SIGNAL("UnitRemoved", "so", 0),
1544         SD_BUS_SIGNAL("JobNew", "uos", 0),
1545         SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
1546         SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
1547         SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
1548         SD_BUS_SIGNAL("Reloading", "b", 0),
1549
1550         SD_BUS_VTABLE_END
1551 };
1552
1553 int bus_manager_foreach_client(Manager *m, int (*send_message)(sd_bus *bus, const char *destination, void *userdata), void *userdata) {
1554         Iterator i;
1555         sd_bus *b;
1556         unsigned n;
1557         int r;
1558
1559         n = set_size(m->subscribed);
1560         if (n <= 0)
1561                 return 0;
1562         if (n == 1) {
1563                 BusTrackedClient *d;
1564
1565                 assert_se(d = set_first(m->subscribed));
1566                 return send_message(d->bus, isempty(d->name) ? NULL : d->name, userdata);
1567         }
1568
1569         /* Send to everybody */
1570         SET_FOREACH(b, m->private_buses, i) {
1571                 r = send_message(b, NULL, userdata);
1572                 if (r < 0)
1573                         return r;
1574         }
1575
1576         if (m->api_bus)
1577                 return send_message(m->api_bus, NULL, userdata);
1578
1579         return 0;
1580 }
1581
1582 static int send_finished(sd_bus *bus, const char *destination, void *userdata) {
1583         _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1584         usec_t *times = userdata;
1585         int r;
1586
1587         assert(bus);
1588         assert(times);
1589
1590         r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished", &message);
1591         if (r < 0)
1592                 return r;
1593
1594         r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
1595         if (r < 0)
1596                 return r;
1597
1598         return sd_bus_send_to(bus, message, destination, NULL);
1599 }
1600
1601 int bus_manager_send_finished(
1602                 Manager *m,
1603                 usec_t firmware_usec,
1604                 usec_t loader_usec,
1605                 usec_t kernel_usec,
1606                 usec_t initrd_usec,
1607                 usec_t userspace_usec,
1608                 usec_t total_usec) {
1609
1610         assert(m);
1611
1612         return bus_manager_foreach_client(m, send_finished,
1613                         (usec_t[6]) { firmware_usec, loader_usec, kernel_usec, initrd_usec, userspace_usec, total_usec });
1614 }
1615
1616 static int send_reloading(sd_bus *bus, const char *destination, void *userdata) {
1617         _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1618         int r;
1619
1620         assert(bus);
1621
1622         r = sd_bus_message_new_signal(bus, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading", &message);
1623         if (r < 0)
1624                 return r;
1625
1626         r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
1627         if (r < 0)
1628                 return r;
1629
1630         return sd_bus_send_to(bus, message, destination, NULL);
1631 }
1632
1633 int bus_manager_send_reloading(Manager *m, bool active) {
1634         assert(m);
1635
1636         return bus_manager_foreach_client(m, send_reloading, INT_TO_PTR(active));
1637 }