]> git.ipfire.org Git - thirdparty/systemd.git/blame - src/core/dbus-manager.c
projects / thirdparty / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
install: make InstallChange enum type a proper type
[thirdparty/systemd.git] / src / core / dbus-manager.c
CommitLineData
db9ecf05 1/* SPDX-License-Identifier: LGPL-2.1-or-later */
a7334b09 2
ea430986 3#include <errno.h>
eed67a30 4#include <sys/prctl.h>
ae57dad3 5#include <sys/statvfs.h>
871c44a7 6#include <unistd.h>
ea430986 7
b5efdb8a 8#include "alloc-util.h"
07630cea 9#include "architecture.h"
09bde77f 10#include "build.h"
07630cea 11#include "bus-common-errors.h"
40af3d02 12#include "bus-get-properties.h"
25141692 13#include "bus-log-control-api.h"
f4351959 14#include "chase-symlinks.h"
6a818c3c 15#include "data-fd-util.h"
3a0f06c4 16#include "dbus-cgroup.h"
07630cea 17#include "dbus-execute.h"
2ea31e5b 18#include "dbus-job.h"
3ffd4af2 19#include "dbus-manager.h"
c20076a8 20#include "dbus-scope.h"
5e8deb94 21#include "dbus-service.h"
07630cea
LP		 22#include "dbus-unit.h"
23#include "dbus.h"
24#include "env-util.h"
3ffd4af2 25#include "fd-util.h"
0d39fa9c 26#include "fileio.h"
f97b34a6 27#include "format-util.h"
07630cea
LP		 28#include "install.h"
29#include "log.h"
2a341bb9 30#include "manager-dump.h"
d58ad743 31#include "os-util.h"
ae57dad3 32#include "parse-util.h"
07630cea 33#include "path-util.h"
d4a402e4 34#include "process-util.h"
07630cea 35#include "selinux-access.h"
8fcde012 36#include "stat-util.h"
07630cea
LP		 37#include "string-util.h"
38#include "strv.h"
7ccbd1ae 39#include "syslog-util.h"
29206d46 40#include "user-util.h"
07630cea
LP		 41#include "virt.h"
42#include "watchdog.h"
ea430986 43
cb31470f
ZJS		 44/* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state
45 * there, and if we can't we'll fail badly. */
ae57dad3
LP		 46#define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
47
b3796dd8
JS		 48static UnitFileFlags unit_file_bools_to_flags(bool runtime, bool force) {
49 return (runtime ? UNIT_FILE_RUNTIME : 0) |
50 (force ? UNIT_FILE_FORCE : 0);
51}
52
afcfaa69 53BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_oom_policy, oom_policy, OOMPolicy);
c44a285c 54BUS_DEFINE_PROPERTY_GET_ENUM(bus_property_get_emergency_action, emergency_action, EmergencyAction);
afcfaa69 55
681bd2c5 56static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version, "s", GIT_VERSION);
91b79ba8 57static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features, "s", systemd_features);
23c9a63a 58static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture, "s", architecture_to_string(uname_architecture()));
23c9a63a
YW		 59static BUS_DEFINE_PROPERTY_GET2(property_get_system_state, "s", Manager, manager_state, manager_state_to_string);
60static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec, "t", (uint64_t) prctl(PR_GET_TIMERSLACK));
92c23c5a
YW		 61static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "u", Hashmap *, hashmap_size);
62static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size, "u", Set *, set_size);
3bf0cb65 63static BUS_DEFINE_PROPERTY_GET(property_get_default_timeout_abort_usec, "t", Manager, manager_default_timeout_abort_usec);
10f3f4ed 64static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_device, "s", watchdog_get_device());
10f3f4ed
YW		 65static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_realtime, "t", watchdog_get_last_ping(CLOCK_REALTIME));
66static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_watchdog_last_ping_monotonic, "t", watchdog_get_last_ping(CLOCK_MONOTONIC));
718db961
LP		 67
68static int property_get_virtualization(
69 sd_bus *bus,
70 const char *path,
71 const char *interface,
72 const char *property,
73 sd_bus_message *reply,
ebcf1f97
LP		 74 void *userdata,
75 sd_bus_error *error) {
718db961 76
1b86c7c5 77 Virtualization v;
5c22925a 78
718db961
LP		 79 assert(bus);
80 assert(reply);
81
5c22925a
LP		 82 v = detect_virtualization();
83
84 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
85 *
86 * https://github.com/systemd/systemd/issues/1423
87 */
88
89 return sd_bus_message_append(
90 reply, "s",
79a60375 91 v == VIRTUALIZATION_NONE ? NULL : virtualization_to_string(v));
718db961
LP		 92}
93
94static int property_get_tainted(
95 sd_bus *bus,
96 const char *path,
97 const char *interface,
98 const char *property,
99 sd_bus_message *reply,
ebcf1f97
LP		 100 void *userdata,
101 sd_bus_error *error) {
718db961 102
af6b0ecc 103 _cleanup_free_ char *s = NULL;
99534007 104 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 105
106 assert(bus);
107 assert(reply);
c5d34390 108
af6b0ecc
LP		 109 s = manager_taint_string(m);
110 if (!s)
111 return log_oom();
c5d34390 112
af6b0ecc 113 return sd_bus_message_append(reply, "s", s);
c5d34390
LP		 114}
115
718db961
LP		 116static int property_set_log_target(
117 sd_bus *bus,
118 const char *path,
119 const char *interface,
120 const char *property,
121 sd_bus_message *value,
ebcf1f97
LP		 122 void *userdata,
123 sd_bus_error *error) {
718db961 124
bda7d78b 125 Manager *m = userdata;
c826cda4 126 const char *t;
718db961 127 int r;
c826cda4 128
718db961
LP		 129 assert(bus);
130 assert(value);
c826cda4 131
718db961
LP		 132 r = sd_bus_message_read(value, "s", &t);
133 if (r < 0)
134 return r;
c826cda4 135
bda7d78b
FB		 136 if (isempty(t))
137 manager_restore_original_log_target(m);
138 else {
139 LogTarget target;
140
141 target = log_target_from_string(t);
142 if (target < 0)
143 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log target '%s'", t);
144
145 manager_override_log_target(m, target);
146 }
147
148 return 0;
c826cda4
AB		 149}
150
718db961
LP		 151static int property_set_log_level(
152 sd_bus *bus,
153 const char *path,
154 const char *interface,
155 const char *property,
156 sd_bus_message *value,
ebcf1f97
LP		 157 void *userdata,
158 sd_bus_error *error) {
718db961 159
a6ecbf83 160 Manager *m = userdata;
c826cda4 161 const char *t;
718db961 162 int r;
c826cda4 163
718db961
LP		 164 assert(bus);
165 assert(value);
c826cda4 166
718db961
LP		 167 r = sd_bus_message_read(value, "s", &t);
168 if (r < 0)
169 return r;
c826cda4 170
a6ecbf83
FB		 171 if (isempty(t))
172 manager_restore_original_log_level(m);
173 else {
174 int level;
175
176 level = log_level_from_string(t);
177 if (level < 0)
178 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
179
180 manager_override_log_level(m, level);
181 }
182
183 return 0;
c826cda4
AB		 184}
185
718db961
LP		 186static int property_get_progress(
187 sd_bus *bus,
188 const char *path,
189 const char *interface,
190 const char *property,
191 sd_bus_message *reply,
ebcf1f97
LP		 192 void *userdata,
193 sd_bus_error *error) {
718db961 194
99534007 195 Manager *m = ASSERT_PTR(userdata);
05d6a3b6
LP		 196 double d;
197
718db961
LP		 198 assert(bus);
199 assert(reply);
05d6a3b6 200
49d5666c 201 if (MANAGER_IS_FINISHED(m))
05d6a3b6
LP		 202 d = 1.0;
203 else
204 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
205
718db961
LP		 206 return sd_bus_message_append(reply, "d", d);
207}
208
1ad6e8b3
LP		 209static int property_get_environment(
210 sd_bus *bus,
211 const char *path,
212 const char *interface,
213 const char *property,
214 sd_bus_message *reply,
215 void *userdata,
216 sd_bus_error *error) {
217
218 _cleanup_strv_free_ char **l = NULL;
99534007 219 Manager *m = ASSERT_PTR(userdata);
1ad6e8b3
LP		 220 int r;
221
222 assert(bus);
223 assert(reply);
1ad6e8b3
LP		 224
225 r = manager_get_effective_environment(m, &l);
226 if (r < 0)
227 return r;
228
229 return sd_bus_message_append_strv(reply, l);
230}
231
52d2566a
ZJS		 232static int property_get_show_status(
233 sd_bus *bus,
234 const char *path,
235 const char *interface,
236 const char *property,
237 sd_bus_message *reply,
238 void *userdata,
239 sd_bus_error *error) {
240
99534007 241 Manager *m = ASSERT_PTR(userdata);
52d2566a
ZJS		 242
243 assert(bus);
244 assert(reply);
52d2566a 245
44a41954 246 return sd_bus_message_append(reply, "b", manager_get_show_status_on(m));
52d2566a
ZJS		 247}
248
986935cf 249static int property_get_runtime_watchdog(
718db961
LP		 250 sd_bus *bus,
251 const char *path,
252 const char *interface,
253 const char *property,
986935cf 254 sd_bus_message *reply,
ebcf1f97
LP		 255 void *userdata,
256 sd_bus_error *error) {
05d6a3b6 257
99534007 258 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 259
260 assert(bus);
986935cf
FB		 261 assert(reply);
262
263 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_RUNTIME));
264}
265
5717062e
CK		 266static int property_get_pretimeout_watchdog(
267 sd_bus *bus,
268 const char *path,
269 const char *interface,
270 const char *property,
271 sd_bus_message *reply,
272 void *userdata,
273 sd_bus_error *error) {
274
99534007 275 Manager *m = ASSERT_PTR(userdata);
5717062e 276
5717062e
CK		 277 assert(bus);
278 assert(reply);
279
280 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_PRETIMEOUT));
281}
282
aff3a9e1
LB		 283static int property_get_pretimeout_watchdog_governor(
284 sd_bus *bus,
285 const char *path,
286 const char *interface,
287 const char *property,
288 sd_bus_message *reply,
289 void *userdata,
290 sd_bus_error *error) {
291
99534007 292 Manager *m = ASSERT_PTR(userdata);
aff3a9e1 293
aff3a9e1
LB		 294 assert(bus);
295 assert(reply);
296
297 return sd_bus_message_append(reply, "s", m->watchdog_pretimeout_governor);
298}
299
986935cf
FB		 300static int property_get_reboot_watchdog(
301 sd_bus *bus,
302 const char *path,
303 const char *interface,
304 const char *property,
305 sd_bus_message *reply,
306 void *userdata,
307 sd_bus_error *error) {
308
99534007 309 Manager *m = ASSERT_PTR(userdata);
986935cf 310
986935cf
FB		 311 assert(bus);
312 assert(reply);
313
314 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_REBOOT));
315}
316
317static int property_get_kexec_watchdog(
318 sd_bus *bus,
319 const char *path,
320 const char *interface,
321 const char *property,
322 sd_bus_message *reply,
323 void *userdata,
324 sd_bus_error *error) {
325
99534007 326 Manager *m = ASSERT_PTR(userdata);
986935cf 327
986935cf
FB		 328 assert(bus);
329 assert(reply);
330
331 return sd_bus_message_append(reply, "t", manager_get_watchdog(m, WATCHDOG_KEXEC));
332}
333
334static int property_set_watchdog(Manager *m, WatchdogType type, sd_bus_message *value) {
335 usec_t timeout;
336 int r;
337
338 assert(m);
718db961
LP		 339 assert(value);
340
341 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
342
986935cf 343 r = sd_bus_message_read(value, "t", &timeout);
718db961
LP		 344 if (r < 0)
345 return r;
346
aac47032
YW		 347 manager_override_watchdog(m, type, timeout);
348 return 0;
986935cf
FB		 349}
350
351static int property_set_runtime_watchdog(
352 sd_bus *bus,
353 const char *path,
354 const char *interface,
355 const char *property,
356 sd_bus_message *value,
357 void *userdata,
358 sd_bus_error *error) {
359
360 return property_set_watchdog(userdata, WATCHDOG_RUNTIME, value);
361}
362
5717062e
CK		 363static int property_set_pretimeout_watchdog(
364 sd_bus *bus,
365 const char *path,
366 const char *interface,
367 const char *property,
368 sd_bus_message *value,
369 void *userdata,
370 sd_bus_error *error) {
371
372 return property_set_watchdog(userdata, WATCHDOG_PRETIMEOUT, value);
373}
374
aff3a9e1
LB		 375static int property_set_pretimeout_watchdog_governor(
376 sd_bus *bus,
377 const char *path,
378 const char *interface,
379 const char *property,
380 sd_bus_message *value,
381 void *userdata,
382 sd_bus_error *error) {
383
99534007 384 Manager *m = ASSERT_PTR(userdata);
aff3a9e1
LB		 385 char *governor;
386 int r;
387
aff3a9e1
LB		 388 r = sd_bus_message_read(value, "s", &governor);
389 if (r < 0)
390 return r;
391 if (!string_is_safe(governor))
392 return -EINVAL;
393
394 return manager_override_watchdog_pretimeout_governor(m, governor);
395}
396
986935cf
FB		 397static int property_set_reboot_watchdog(
398 sd_bus *bus,
399 const char *path,
400 const char *interface,
401 const char *property,
402 sd_bus_message *value,
403 void *userdata,
404 sd_bus_error *error) {
405
406 return property_set_watchdog(userdata, WATCHDOG_REBOOT, value);
407}
408
409static int property_set_kexec_watchdog(
410 sd_bus *bus,
411 const char *path,
412 const char *interface,
413 const char *property,
414 sd_bus_message *value,
415 void *userdata,
416 sd_bus_error *error) {
417
99534007 418 _unused_ Manager *m = ASSERT_PTR(userdata);
986935cf 419
986935cf
FB		 420 assert(bus);
421 assert(value);
422
423 return property_set_watchdog(userdata, WATCHDOG_KEXEC, value);
05d6a3b6
LP		 424}
425
d4a402e4
LP		 426static int property_get_oom_score_adjust(
427 sd_bus *bus,
428 const char *path,
429 const char *interface,
430 const char *property,
431 sd_bus_message *reply,
432 void *userdata,
433 sd_bus_error *error) {
434
99534007 435 Manager *m = ASSERT_PTR(userdata);
d4a402e4
LP		 436 int r, n;
437
d4a402e4
LP		 438 assert(bus);
439 assert(reply);
440
441 if (m->default_oom_score_adjust_set)
442 n = m->default_oom_score_adjust;
443 else {
444 n = 0;
445 r = get_oom_score_adjust(&n);
446 if (r < 0)
447 log_debug_errno(r, "Failed to read current OOM score adjustment value, ignoring: %m");
448 }
449
450 return sd_bus_message_append(reply, "i", n);
451}
452
96cc4453 453static int bus_get_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
718db961
LP		 454 Unit *u;
455 int r;
dfae3488 456
dfae3488 457 assert(m);
96cc4453
LP		 458 assert(message);
459 assert(ret_unit);
dfae3488 460
cb31470f
ZJS		 461 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up
462 * its sleeve: if the name is specified empty we use the client's unit. */
dfae3488 463
1d22e906 464 if (isempty(name)) {
4afd3348 465 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1d22e906
LP		 466 pid_t pid;
467
468 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
469 if (r < 0)
470 return r;
471
472 r = sd_bus_creds_get_pid(creds, &pid);
473 if (r < 0)
474 return r;
475
476 u = manager_get_unit_by_pid(m, pid);
477 if (!u)
1b09b81c 478 return sd_bus_error_set(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
1d22e906
LP		 479 } else {
480 u = manager_get_unit(m, name);
481 if (!u)
482 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
483 }
dfae3488 484
96cc4453
LP		 485 *ret_unit = u;
486 return 0;
487}
488
489static int bus_load_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
490 assert(m);
491 assert(message);
492 assert(ret_unit);
493
494 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
495
496 if (isempty(name))
497 return bus_get_unit_by_name(m, message, name, ret_unit, error);
498
499 return manager_load_unit(m, name, NULL, error, ret_unit);
500}
501
4659bf6f 502static int reply_unit_path(Unit *u, sd_bus_message *message, sd_bus_error *error) {
96cc4453 503 _cleanup_free_ char *path = NULL;
4659bf6f
LP		 504 int r;
505
506 assert(u);
507 assert(message);
508
509 r = mac_selinux_unit_access_check(u, message, "status", error);
510 if (r < 0)
511 return r;
512
513 path = unit_dbus_path(u);
514 if (!path)
515 return log_oom();
516
517 return sd_bus_reply_method_return(message, "o", path);
518}
519
520static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 521 Manager *m = ASSERT_PTR(userdata);
96cc4453
LP		 522 const char *name;
523 Unit *u;
524 int r;
525
526 assert(message);
96cc4453
LP		 527
528 /* Anyone can call this method */
529
530 r = sd_bus_message_read(message, "s", &name);
531 if (r < 0)
532 return r;
533
534 r = bus_get_unit_by_name(m, message, name, &u, error);
535 if (r < 0)
536 return r;
537
4659bf6f 538 return reply_unit_path(u, message, error);
718db961 539}
c0576cd6 540
19070062 541static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 542 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 543 pid_t pid;
544 Unit *u;
545 int r;
c0576cd6 546
718db961 547 assert(message);
c0576cd6 548
718db961 549 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
729e3769 550
283868e1
SW		 551 /* Anyone can call this method */
552
718db961
LP		 553 r = sd_bus_message_read(message, "u", &pid);
554 if (r < 0)
ebcf1f97 555 return r;
07b38ba5 556 if (pid < 0)
1d22e906 557 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PID " PID_FMT, pid);
718db961
LP		 558
559 if (pid == 0) {
4afd3348 560 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
5b12334d
LP		 561
562 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
563 if (r < 0)
564 return r;
565
566 r = sd_bus_creds_get_pid(creds, &pid);
718db961 567 if (r < 0)
ebcf1f97 568 return r;
729e3769
LP		 569 }
570
718db961
LP		 571 u = manager_get_unit_by_pid(m, pid);
572 if (!u)
1fa2f38f 573 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pid);
c0576cd6 574
4659bf6f 575 return reply_unit_path(u, message, error);
718db961
LP		 576}
577
4b58153d
LP		 578static int method_get_unit_by_invocation_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
579 _cleanup_free_ char *path = NULL;
99534007 580 Manager *m = ASSERT_PTR(userdata);
4b58153d
LP		 581 sd_id128_t id;
582 const void *a;
583 Unit *u;
584 size_t sz;
585 int r;
586
587 assert(message);
4b58153d
LP		 588
589 /* Anyone can call this method */
590
591 r = sd_bus_message_read_array(message, 'y', &a, &sz);
592 if (r < 0)
593 return r;
594 if (sz == 0)
595 id = SD_ID128_NULL;
596 else if (sz == 16)
597 memcpy(&id, a, sz);
598 else
1b09b81c 599 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid invocation ID");
4b58153d
LP		 600
601 if (sd_id128_is_null(id)) {
602 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
603 pid_t pid;
604
605 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
606 if (r < 0)
607 return r;
608
609 r = sd_bus_creds_get_pid(creds, &pid);
610 if (r < 0)
611 return r;
612
613 u = manager_get_unit_by_pid(m, pid);
614 if (!u)
cb31470f
ZJS		 615 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
616 "Client " PID_FMT " not member of any unit.", pid);
4b58153d
LP		 617 } else {
618 u = hashmap_get(m->units_by_invocation_id, &id);
619 if (!u)
620 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_INVOCATION_ID, "No unit with the specified invocation ID " SD_ID128_FORMAT_STR " known.", SD_ID128_FORMAT_VAL(id));
621 }
622
623 r = mac_selinux_unit_access_check(u, message, "status", error);
624 if (r < 0)
625 return r;
626
cb31470f
ZJS		 627 /* So here's a special trick: the bus path we return actually references the unit by its invocation
628 * ID instead of the unit name. This means it stays valid only as long as the invocation ID stays the
629 * same. */
4b58153d
LP		 630 path = unit_dbus_path_invocation_id(u);
631 if (!path)
632 return -ENOMEM;
633
634 return sd_bus_reply_method_return(message, "o", path);
635}
636
267dd427 637static int method_get_unit_by_control_group(sd_bus_message *message, void *userdata, sd_bus_error *error) {
267dd427
LP		 638 Manager *m = userdata;
639 const char *cgroup;
640 Unit *u;
641 int r;
642
643 r = sd_bus_message_read(message, "s", &cgroup);
644 if (r < 0)
645 return r;
646
647 u = manager_get_unit_by_cgroup(m, cgroup);
648 if (!u)
cb31470f
ZJS		 649 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
650 "Control group '%s' is not valid or not managed by this instance",
651 cgroup);
267dd427 652
4659bf6f 653 return reply_unit_path(u, message, error);
267dd427
LP		 654}
655
19070062 656static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 657 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 658 const char *name;
659 Unit *u;
660 int r;
c0576cd6 661
718db961 662 assert(message);
718db961 663
283868e1
SW		 664 /* Anyone can call this method */
665
718db961
LP		 666 r = sd_bus_message_read(message, "s", &name);
667 if (r < 0)
ebcf1f97 668 return r;
c0576cd6 669
96cc4453
LP		 670 r = bus_load_unit_by_name(m, message, name, &u, error);
671 if (r < 0)
672 return r;
718db961 673
4659bf6f 674 return reply_unit_path(u, message, error);
c0576cd6
LP		 675}
676
19070062 677static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
718db961
LP		 678 const char *name;
679 Unit *u;
c0576cd6
LP		 680 int r;
681
718db961
LP		 682 assert(message);
683 assert(m);
c0576cd6 684
718db961
LP		 685 r = sd_bus_message_read(message, "s", &name);
686 if (r < 0)
ebcf1f97 687 return r;
c0576cd6 688
ebcf1f97 689 r = manager_load_unit(m, name, NULL, error, &u);
718db961 690 if (r < 0)
ebcf1f97 691 return r;
718db961 692
19070062 693 return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
c0576cd6
LP		 694}
695
19070062
LP		 696static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
697 return method_start_unit_generic(message, userdata, JOB_START, false, error);
718db961 698}
c757a65b 699
19070062
LP		 700static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
701 return method_start_unit_generic(message, userdata, JOB_STOP, false, error);
718db961 702}
c757a65b 703
19070062
LP		 704static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
705 return method_start_unit_generic(message, userdata, JOB_RELOAD, false, error);
718db961 706}
c757a65b 707
19070062
LP		 708static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
709 return method_start_unit_generic(message, userdata, JOB_RESTART, false, error);
c757a65b
LP		 710}
711
19070062
LP		 712static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
713 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, false, error);
718db961 714}
d200735e 715
19070062
LP		 716static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
717 return method_start_unit_generic(message, userdata, JOB_RESTART, true, error);
718db961 718}
d200735e 719
19070062
LP		 720static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
721 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, true, error);
718db961 722}
d200735e 723
42561fc9
LP		 724typedef enum GenericUnitOperationFlags {
725 GENERIC_UNIT_LOAD = 1 << 0, /* Load if the unit is not loaded yet */
726 GENERIC_UNIT_VALIDATE_LOADED = 1 << 1, /* Verify unit is properly loaded before forwarding call */
727} GenericUnitOperationFlags;
728
729static int method_generic_unit_operation(
730 sd_bus_message *message,
731 Manager *m,
732 sd_bus_error *error,
733 sd_bus_message_handler_t handler,
734 GenericUnitOperationFlags flags) {
735
50cbaba4
LP		 736 const char *name;
737 Unit *u;
738 int r;
739
740 assert(message);
741 assert(m);
742
42561fc9
LP		 743 /* Read the first argument from the command and pass the operation to the specified per-unit
744 * method. */
745
50cbaba4
LP		 746 r = sd_bus_message_read(message, "s", &name);
747 if (r < 0)
748 return r;
749
42561fc9
LP		 750 if (!isempty(name) && FLAGS_SET(flags, GENERIC_UNIT_LOAD))
751 r = manager_load_unit(m, name, NULL, error, &u);
752 else
753 r = bus_get_unit_by_name(m, message, name, &u, error);
50cbaba4
LP		 754 if (r < 0)
755 return r;
756
42561fc9
LP		 757 if (FLAGS_SET(flags, GENERIC_UNIT_VALIDATE_LOADED)) {
758 r = bus_unit_validate_load_state(u, error);
759 if (r < 0)
760 return r;
761 }
762
763 return handler(message, u, error);
764}
765
766static int method_enqueue_unit_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
767 /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
768 return method_generic_unit_operation(message, userdata, error, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
50cbaba4
LP		 769}
770
19070062 771static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 772 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 773 const char *old_name;
774 Unit *u;
1adf1049 775 int r;
ea430986 776
ea430986 777 assert(message);
ea430986 778
718db961
LP		 779 r = sd_bus_message_read(message, "s", &old_name);
780 if (r < 0)
ebcf1f97 781 return r;
ea430986 782
96cc4453
LP		 783 r = bus_get_unit_by_name(m, message, old_name, &u, error);
784 if (r < 0)
785 return r;
786 if (!u->job || u->job->type != JOB_START)
ebcf1f97 787 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
c0576cd6 788
19070062 789 return method_start_unit_generic(message, m, JOB_START, false, error);
718db961 790}
ea430986 791
19070062 792static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 793 /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
794 * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
795 return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill, 0);
718db961 796}
8a0867d6 797
4d3bac56
LP		 798static int method_clean_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
799 /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
800 * cleaned */
801 return method_generic_unit_operation(message, userdata, error, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
802}
803
d9e45bc3
MS		 804static int method_freeze_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
805 return method_generic_unit_operation(message, userdata, error, bus_unit_method_freeze, 0);
806}
807
808static int method_thaw_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
809 return method_generic_unit_operation(message, userdata, error, bus_unit_method_thaw, 0);
810}
811
19070062 812static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 813 /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
814 * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
815 return method_generic_unit_operation(message, userdata, error, bus_unit_method_reset_failed, 0);
718db961 816}
5dd9014f 817
19070062 818static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 819 /* Only change properties on fully loaded units, and load them in order to set properties */
820 return method_generic_unit_operation(message, userdata, error, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
718db961
LP		 821}
822
5e8deb94
LB		 823static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
824 /* Only add mounts on fully loaded units */
825 return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
826}
827
af477139
LB		 828static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
829 /* Only add mounts on fully loaded units */
830 return method_generic_unit_operation(message, userdata, error, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
831}
832
05a98afd 833static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 834 /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
835 return method_generic_unit_operation(message, userdata, error, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
05a98afd
LP		 836}
837
838static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 839 /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
840 * loaded unit there's no need to load the unit for unreffing it. */
841 return method_generic_unit_operation(message, userdata, error, bus_unit_method_unref, 0);
05a98afd
LP		 842}
843
6900c740 844static int reply_unit_info(sd_bus_message *reply, Unit *u) {
845 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
846 Unit *following;
847
848 following = unit_following(u);
849
850 unit_path = unit_dbus_path(u);
851 if (!unit_path)
852 return -ENOMEM;
853
854 if (u->job) {
855 job_path = job_dbus_path(u->job);
856 if (!job_path)
857 return -ENOMEM;
858 }
859
860 return sd_bus_message_append(
861 reply, "(ssssssouso)",
862 u->id,
863 unit_description(u),
864 unit_load_state_to_string(u->load_state),
865 unit_active_state_to_string(unit_active_state(u)),
866 unit_sub_state_to_string(u),
867 following ? following->id : "",
868 unit_path,
869 u->job ? u->job->id : 0,
870 u->job ? job_type_to_string(u->job->type) : "",
c1d95b71 871 empty_to_root(job_path));
6900c740 872}
873
874static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
875 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 876 Manager *m = ASSERT_PTR(userdata);
6900c740 877 int r;
6900c740 878 _cleanup_strv_free_ char **units = NULL;
879
880 assert(message);
6900c740 881
882 r = sd_bus_message_read_strv(message, &units);
883 if (r < 0)
884 return r;
885
886 r = sd_bus_message_new_method_return(message, &reply);
887 if (r < 0)
888 return r;
889
890 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
891 if (r < 0)
892 return r;
893
894 STRV_FOREACH(unit, units) {
895 Unit *u;
896
897 if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
898 continue;
899
96cc4453 900 r = bus_load_unit_by_name(m, message, *unit, &u, error);
6900c740 901 if (r < 0)
902 return r;
903
904 r = reply_unit_info(reply, u);
905 if (r < 0)
906 return r;
907 }
908
909 r = sd_bus_message_close_container(reply);
910 if (r < 0)
911 return r;
912
913 return sd_bus_send(NULL, reply, NULL);
914}
915
291d565a 916static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 917 /* Don't load a unit (since it won't have any processes if it's not loaded), but don't insist on the
918 * unit being loaded (because even improperly loaded units might still have processes around */
919 return method_generic_unit_operation(message, userdata, error, bus_unit_method_get_processes, 0);
291d565a
LP		 920}
921
6592b975 922static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 923 /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
924 * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
925 * processes to stopped units anyway. */
926 return method_generic_unit_operation(message, userdata, error, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
6592b975
LP		 927}
928
ab31f6b8
WC		 929static int transient_unit_from_message(
930 Manager *m,
931 sd_bus_message *message,
932 const char *name,
933 Unit **unit,
934 sd_bus_error *error) {
935
06cc6afa 936 UnitType t;
ab31f6b8
WC		 937 Unit *u;
938 int r;
939
940 assert(m);
941 assert(message);
942 assert(name);
943
06cc6afa
LP		 944 t = unit_name_to_type(name);
945 if (t < 0)
cb31470f
ZJS		 946 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
947 "Invalid unit name or type.");
06cc6afa
LP		 948
949 if (!unit_vtable[t]->can_transient)
cb31470f
ZJS		 950 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
951 "Unit type %s does not support transient units.",
952 unit_type_to_string(t));
06cc6afa 953
ab31f6b8
WC		 954 r = manager_load_unit(m, name, NULL, error, &u);
955 if (r < 0)
956 return r;
957
0f13f3bd 958 if (!unit_is_pristine(u))
cb31470f
ZJS		 959 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
960 "Unit %s already exists.", name);
ab31f6b8
WC		 961
962 /* OK, the unit failed to load and is unreferenced, now let's
963 * fill in the transient data instead */
964 r = unit_make_transient(u);
965 if (r < 0)
966 return r;
967
968 /* Set our properties */
969 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
970 if (r < 0)
971 return r;
972
05a98afd
LP		 973 /* If the client asked for it, automatically add a reference to this unit. */
974 if (u->bus_track_add) {
975 r = bus_unit_track_add_sender(u, message);
976 if (r < 0)
977 return log_error_errno(r, "Failed to watch sender: %m");
978 }
979
97329d20 980 /* Now load the missing bits of the unit we just created */
4f952a3f 981 unit_add_to_load_queue(u);
97329d20
LP		 982 manager_dispatch_load_queue(m);
983
ab31f6b8
WC		 984 *unit = u;
985
986 return 0;
987}
988
989static int transient_aux_units_from_message(
990 Manager *m,
991 sd_bus_message *message,
992 sd_bus_error *error) {
993
ab31f6b8
WC		 994 int r;
995
996 assert(m);
997 assert(message);
998
999 r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
1000 if (r < 0)
1001 return r;
1002
1003 while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
97329d20
LP		 1004 const char *name = NULL;
1005 Unit *u;
1006
ab31f6b8
WC		 1007 r = sd_bus_message_read(message, "s", &name);
1008 if (r < 0)
1009 return r;
1010
1011 r = transient_unit_from_message(m, message, name, &u, error);
97329d20 1012 if (r < 0)
ab31f6b8
WC		 1013 return r;
1014
ab31f6b8
WC		 1015 r = sd_bus_message_exit_container(message);
1016 if (r < 0)
1017 return r;
1018 }
1019 if (r < 0)
1020 return r;
1021
1022 r = sd_bus_message_exit_container(message);
1023 if (r < 0)
1024 return r;
1025
1026 return 0;
1027}
1028
19070062 1029static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1030 const char *name, *smode;
99534007 1031 Manager *m = ASSERT_PTR(userdata);
718db961 1032 JobMode mode;
718db961
LP		 1033 Unit *u;
1034 int r;
ea430986 1035
718db961 1036 assert(message);
ea430986 1037
1d22e906 1038 r = mac_selinux_access_check(message, "start", error);
283868e1
SW		 1039 if (r < 0)
1040 return r;
283868e1 1041
718db961
LP		 1042 r = sd_bus_message_read(message, "ss", &name, &smode);
1043 if (r < 0)
ebcf1f97 1044 return r;
5632e374 1045
718db961
LP		 1046 mode = job_mode_from_string(smode);
1047 if (mode < 0)
ebcf1f97 1048 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
5632e374 1049
1d22e906 1050 r = bus_verify_manage_units_async(m, message, error);
718db961 1051 if (r < 0)
ebcf1f97 1052 return r;
1d22e906
LP		 1053 if (r == 0)
1054 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
5632e374 1055
ab31f6b8 1056 r = transient_unit_from_message(m, message, name, &u, error);
ebcf1f97
LP		 1057 if (r < 0)
1058 return r;
5632e374 1059
ab31f6b8 1060 r = transient_aux_units_from_message(m, message, error);
718db961 1061 if (r < 0)
ebcf1f97 1062 return r;
ea430986 1063
718db961 1064 /* Finally, start it */
50cbaba4 1065 return bus_unit_queue_job(message, u, JOB_START, mode, 0, error);
718db961 1066}
ea430986 1067
19070062 1068static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1069 _cleanup_free_ char *path = NULL;
99534007 1070 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1071 uint32_t id;
1072 Job *j;
1073 int r;
ea430986 1074
718db961 1075 assert(message);
ea430986 1076
283868e1
SW		 1077 /* Anyone can call this method */
1078
718db961
LP		 1079 r = sd_bus_message_read(message, "u", &id);
1080 if (r < 0)
ebcf1f97 1081 return r;
ea430986 1082
718db961
LP		 1083 j = manager_get_job(m, id);
1084 if (!j)
ebcf1f97 1085 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1086
8a188de9 1087 r = mac_selinux_unit_access_check(j->unit, message, "status", error);
ebcf1f97
LP		 1088 if (r < 0)
1089 return r;
ea430986 1090
718db961
LP		 1091 path = job_dbus_path(j);
1092 if (!path)
ebcf1f97 1093 return -ENOMEM;
ea430986 1094
df2d202e 1095 return sd_bus_reply_method_return(message, "o", path);
718db961 1096}
ea430986 1097
19070062 1098static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1099 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1100 uint32_t id;
1101 Job *j;
1102 int r;
ea430986 1103
718db961 1104 assert(message);
ea430986 1105
718db961
LP		 1106 r = sd_bus_message_read(message, "u", &id);
1107 if (r < 0)
ebcf1f97 1108 return r;
ea430986 1109
718db961
LP		 1110 j = manager_get_job(m, id);
1111 if (!j)
ebcf1f97 1112 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1113
19070062 1114 return bus_job_method_cancel(message, j, error);
718db961 1115}
c1e1601e 1116
19070062 1117static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1118 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1119 int r;
c1e1601e 1120
718db961 1121 assert(message);
c1e1601e 1122
1d22e906 1123 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1124 if (r < 0)
1125 return r;
1126
1d22e906
LP		 1127 r = bus_verify_manage_units_async(m, message, error);
1128 if (r < 0)
1129 return r;
1130 if (r == 0)
1131 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1132
718db961 1133 manager_clear_jobs(m);
c1e1601e 1134
df2d202e 1135 return sd_bus_reply_method_return(message, NULL);
718db961 1136}
c1e1601e 1137
19070062 1138static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1139 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1140 int r;
cad45ba1 1141
718db961 1142 assert(message);
718db961 1143
8a188de9 1144 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1145 if (r < 0)
1146 return r;
1147
1d22e906
LP		 1148 r = bus_verify_manage_units_async(m, message, error);
1149 if (r < 0)
1150 return r;
1151 if (r == 0)
1152 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1153
718db961 1154 manager_reset_failed(m);
c1e1601e 1155
df2d202e 1156 return sd_bus_reply_method_return(message, NULL);
718db961 1157}
c1e1601e 1158
313fe66f 1159static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 1160 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1161 Manager *m = ASSERT_PTR(userdata);
718db961 1162 const char *k;
718db961
LP		 1163 Unit *u;
1164 int r;
c1e1601e 1165
718db961 1166 assert(message);
b152adec 1167
283868e1
SW		 1168 /* Anyone can call this method */
1169
8a188de9 1170 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1171 if (r < 0)
1172 return r;
cad45ba1 1173
df2d202e 1174 r = sd_bus_message_new_method_return(message, &reply);
718db961 1175 if (r < 0)
ebcf1f97 1176 return r;
b152adec 1177
718db961
LP		 1178 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
1179 if (r < 0)
ebcf1f97 1180 return r;
b152adec 1181
90e74a66 1182 HASHMAP_FOREACH_KEY(u, k, m->units) {
718db961
LP		 1183 if (k != u->id)
1184 continue;
b152adec 1185
cdc06ed7
DS		 1186 if (!strv_isempty(states) &&
1187 !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
1188 !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
1189 !strv_contains(states, unit_sub_state_to_string(u)))
1190 continue;
1191
313fe66f 1192 if (!strv_isempty(patterns) &&
1193 !strv_fnmatch_or_empty(patterns, u->id, FNM_NOESCAPE))
1194 continue;
1195
6900c740 1196 r = reply_unit_info(reply, u);
718db961 1197 if (r < 0)
ebcf1f97 1198 return r;
718db961 1199 }
4139c1b2 1200
718db961
LP		 1201 r = sd_bus_message_close_container(reply);
1202 if (r < 0)
ebcf1f97 1203 return r;
cad45ba1 1204
9030ca46 1205 return sd_bus_send(NULL, reply, NULL);
718db961 1206}
4139c1b2 1207
19070062 1208static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
313fe66f 1209 return list_units_filtered(message, userdata, error, NULL, NULL);
cdc06ed7
DS		 1210}
1211
19070062 1212static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cdc06ed7
DS		 1213 _cleanup_strv_free_ char **states = NULL;
1214 int r;
1215
1216 r = sd_bus_message_read_strv(message, &states);
1217 if (r < 0)
1218 return r;
1219
313fe66f 1220 return list_units_filtered(message, userdata, error, states, NULL);
1221}
1222
1223static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1224 _cleanup_strv_free_ char **states = NULL;
1225 _cleanup_strv_free_ char **patterns = NULL;
1226 int r;
1227
1228 r = sd_bus_message_read_strv(message, &states);
1229 if (r < 0)
1230 return r;
1231
1232 r = sd_bus_message_read_strv(message, &patterns);
1233 if (r < 0)
1234 return r;
1235
1236 return list_units_filtered(message, userdata, error, states, patterns);
cdc06ed7
DS		 1237}
1238
19070062 1239static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
4afd3348 1240 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1241 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1242 Job *j;
1243 int r;
4139c1b2 1244
718db961 1245 assert(message);
718db961 1246
283868e1
SW		 1247 /* Anyone can call this method */
1248
8a188de9 1249 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1250 if (r < 0)
1251 return r;
718db961 1252
df2d202e 1253 r = sd_bus_message_new_method_return(message, &reply);
718db961 1254 if (r < 0)
ebcf1f97 1255 return r;
718db961
LP		 1256
1257 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
1258 if (r < 0)
ebcf1f97 1259 return r;
718db961 1260
90e74a66 1261 HASHMAP_FOREACH(j, m->jobs) {
718db961
LP		 1262 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
1263
1264 job_path = job_dbus_path(j);
1265 if (!job_path)
ebcf1f97 1266 return -ENOMEM;
718db961
LP		 1267
1268 unit_path = unit_dbus_path(j->unit);
1269 if (!unit_path)
ebcf1f97 1270 return -ENOMEM;
718db961
LP		 1271
1272 r = sd_bus_message_append(
1273 reply, "(usssoo)",
1274 j->id,
1302759d 1275 j->unit->id,
718db961 1276 job_type_to_string(j->type),
1302759d 1277 job_state_to_string(j->state),
718db961
LP		 1278 job_path,
1279 unit_path);
cad45ba1 1280 if (r < 0)
ebcf1f97 1281 return r;
718db961 1282 }
5dd9014f 1283
718db961
LP		 1284 r = sd_bus_message_close_container(reply);
1285 if (r < 0)
ebcf1f97 1286 return r;
5dd9014f 1287
9030ca46 1288 return sd_bus_send(NULL, reply, NULL);
718db961 1289}
5dd9014f 1290
19070062 1291static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1292 Manager *m = ASSERT_PTR(userdata);
718db961 1293 int r;
5dd9014f 1294
718db961 1295 assert(message);
ea430986 1296
283868e1
SW		 1297 /* Anyone can call this method */
1298
8a188de9 1299 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1300 if (r < 0)
1301 return r;
cad45ba1 1302
19070062 1303 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1304
1305 /* Note that direct bus connection subscribe by
1306 * default, we only track peers on the API bus here */
1307
1308 if (!m->subscribed) {
19070062 1309 r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
8f8f05a9
LP		 1310 if (r < 0)
1311 return r;
1312 }
1313
1314 r = sd_bus_track_add_sender(m->subscribed, message);
1315 if (r < 0)
1316 return r;
1317 if (r == 0)
1b09b81c 1318 return sd_bus_error_set(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
8f8f05a9 1319 }
ea430986 1320
df2d202e 1321 return sd_bus_reply_method_return(message, NULL);
718db961 1322}
ea430986 1323
19070062 1324static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1325 Manager *m = ASSERT_PTR(userdata);
718db961 1326 int r;
ea430986 1327
718db961 1328 assert(message);
ea430986 1329
283868e1
SW		 1330 /* Anyone can call this method */
1331
8a188de9 1332 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1333 if (r < 0)
1334 return r;
ea430986 1335
19070062 1336 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1337 r = sd_bus_track_remove_sender(m->subscribed, message);
1338 if (r < 0)
1339 return r;
1340 if (r == 0)
1b09b81c 1341 return sd_bus_error_set(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
8f8f05a9 1342 }
ea430986 1343
df2d202e 1344 return sd_bus_reply_method_return(message, NULL);
718db961 1345}
ea430986 1346
d1d8786c
FB		 1347static int dump_impl(
1348 sd_bus_message *message,
1349 void *userdata,
1350 sd_bus_error *error,
1351 char **patterns,
1352 int (*reply)(sd_bus_message *, char *)) {
1353
718db961 1354 _cleanup_free_ char *dump = NULL;
99534007 1355 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1356 int r;
ea430986 1357
718db961 1358 assert(message);
ea430986 1359
283868e1
SW		 1360 /* Anyone can call this method */
1361
8a188de9 1362 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1363 if (r < 0)
1364 return r;
ea430986 1365
d1d8786c 1366 r = manager_get_dump_string(m, patterns, &dump);
dacd6cee
LP		 1367 if (r < 0)
1368 return r;
a16e1123 1369
c0a1bfac
DT		 1370 return reply(message, dump);
1371}
1372
1373static int reply_dump(sd_bus_message *message, char *dump) {
df2d202e 1374 return sd_bus_reply_method_return(message, "s", dump);
718db961 1375}
cad45ba1 1376
c0a1bfac 1377static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c 1378 return dump_impl(message, userdata, error, NULL, reply_dump);
c0a1bfac
DT		 1379}
1380
1381static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
1382 _cleanup_close_ int fd = -1;
1383
1384 fd = acquire_data_fd(dump, strlen(dump), 0);
1385 if (fd < 0)
1386 return fd;
1387
1388 return sd_bus_reply_method_return(message, "h", fd);
1389}
1390
1391static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c
FB		 1392 return dump_impl(message, userdata, error, NULL, reply_dump_by_fd);
1393}
1394
1395static int method_dump_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1396 _cleanup_strv_free_ char **patterns = NULL;
1397 int r;
1398
1399 r = sd_bus_message_read_strv(message, &patterns);
1400 if (r < 0)
1401 return r;
1402
1403 return dump_impl(message, userdata, error, patterns, reply_dump);
c0a1bfac
DT		 1404}
1405
36b4a7ba 1406static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1b09b81c 1407 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
718db961 1408}
cad45ba1 1409
ae57dad3
LP		 1410static int verify_run_space(const char *message, sd_bus_error *error) {
1411 struct statvfs svfs;
1412 uint64_t available;
1413
1414 if (statvfs("/run/systemd", &svfs) < 0)
1415 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1416
1417 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1418
2b59bf51 1419 if (available < RELOAD_DISK_SPACE_MIN)
ae57dad3
LP		 1420 return sd_bus_error_setf(error,
1421 BUS_ERROR_DISK_FULL,
1422 "%s, not enough space available on /run/systemd. "
1423 "Currently, %s are free, but a safety buffer of %s is enforced.",
1424 message,
2b59bf51
ZJS		 1425 FORMAT_BYTES(available),
1426 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3
LP		 1427
1428 return 0;
1429}
1430
1431int verify_run_space_and_log(const char *message) {
4dae8ae6 1432 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ae57dad3
LP		 1433 int r;
1434
1435 r = verify_run_space(message, &error);
1436 if (r < 0)
4ae25393 1437 return log_error_errno(r, "%s", bus_error_message(&error, r));
ae57dad3 1438
4ae25393 1439 return 0;
ae57dad3
LP		 1440}
1441
19070062 1442static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1443 Manager *m = ASSERT_PTR(userdata);
718db961 1444 int r;
6652a2b9 1445
718db961 1446 assert(message);
6652a2b9 1447
ae57dad3
LP		 1448 r = verify_run_space("Refusing to reload", error);
1449 if (r < 0)
1450 return r;
1451
1d22e906 1452 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1453 if (r < 0)
1454 return r;
283868e1 1455
1d22e906 1456 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1457 if (r < 0)
1458 return r;
1d22e906
LP		 1459 if (r == 0)
1460 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
6652a2b9 1461
718db961
LP		 1462 /* Instead of sending the reply back right away, we just
1463 * remember that we need to and then send it after the reload
1464 * is finished. That way the caller knows when the reload
1465 * finished. */
6652a2b9 1466
209de525
LP		 1467 assert(!m->pending_reload_message);
1468 r = sd_bus_message_new_method_return(message, &m->pending_reload_message);
718db961 1469 if (r < 0)
ebcf1f97 1470 return r;
cad45ba1 1471
af41e508 1472 m->objective = MANAGER_RELOAD;
6652a2b9 1473
718db961
LP		 1474 return 1;
1475}
6652a2b9 1476
19070062 1477static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1478 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1479 int r;
6652a2b9 1480
718db961 1481 assert(message);
6652a2b9 1482
ae57dad3
LP		 1483 r = verify_run_space("Refusing to reexecute", error);
1484 if (r < 0)
1485 return r;
1486
1d22e906 1487 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1488 if (r < 0)
1489 return r;
283868e1 1490
1d22e906 1491 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1492 if (r < 0)
1493 return r;
1d22e906
LP		 1494 if (r == 0)
1495 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
cad45ba1 1496
718db961
LP		 1497 /* We don't send a reply back here, the client should
1498 * just wait for us disconnecting. */
6652a2b9 1499
af41e508 1500 m->objective = MANAGER_REEXECUTE;
718db961
LP		 1501 return 1;
1502}
6652a2b9 1503
19070062 1504static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1505 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1506 int r;
6652a2b9 1507
718db961 1508 assert(message);
6652a2b9 1509
8a188de9 1510 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1511 if (r < 0)
1512 return r;
cad45ba1 1513
287419c1
AC		 1514 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1515 * we are running on the host. It will fall back on reboot() in
1516 * systemd-shutdown if it cannot do the exit() because it isn't a
1517 * container. */
6652a2b9 1518
af41e508 1519 m->objective = MANAGER_EXIT;
6652a2b9 1520
df2d202e 1521 return sd_bus_reply_method_return(message, NULL);
718db961 1522}
6652a2b9 1523
19070062 1524static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1525 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1526 int r;
664f88a7 1527
718db961 1528 assert(message);
cad45ba1 1529
8a188de9 1530 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1531 if (r < 0)
1532 return r;
664f88a7 1533
463d0d15 1534 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1535 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1536 "Reboot is only supported for system managers.");
664f88a7 1537
af41e508 1538 m->objective = MANAGER_REBOOT;
664f88a7 1539
df2d202e 1540 return sd_bus_reply_method_return(message, NULL);
718db961 1541}
664f88a7 1542
19070062 1543static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1544 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1545 int r;
50913bc0 1546
718db961 1547 assert(message);
1137a57c 1548
8a188de9 1549 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1550 if (r < 0)
1551 return r;
1137a57c 1552
463d0d15 1553 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1554 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1555 "Powering off is only supported for system managers.");
1137a57c 1556
af41e508 1557 m->objective = MANAGER_POWEROFF;
1137a57c 1558
df2d202e 1559 return sd_bus_reply_method_return(message, NULL);
718db961 1560}
1137a57c 1561
19070062 1562static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1563 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1564 int r;
1137a57c 1565
718db961 1566 assert(message);
8d0e38a2 1567
8a188de9 1568 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1569 if (r < 0)
1570 return r;
cad45ba1 1571
463d0d15 1572 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1573 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1574 "Halt is only supported for system managers.");
8d0e38a2 1575
af41e508 1576 m->objective = MANAGER_HALT;
8d0e38a2 1577
df2d202e 1578 return sd_bus_reply_method_return(message, NULL);
718db961 1579}
8d0e38a2 1580
19070062 1581static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1582 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1583 int r;
8d0e38a2 1584
718db961 1585 assert(message);
c0576cd6 1586
8a188de9 1587 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1588 if (r < 0)
1589 return r;
cad45ba1 1590
463d0d15 1591 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1592 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1593 "KExec is only supported for system managers.");
c0576cd6 1594
af41e508 1595 m->objective = MANAGER_KEXEC;
c0576cd6 1596
df2d202e 1597 return sd_bus_reply_method_return(message, NULL);
718db961 1598}
c0576cd6 1599
19070062 1600static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
87a19bfe 1601 _cleanup_free_ char *ri = NULL, *rt = NULL;
718db961 1602 const char *root, *init;
99534007 1603 Manager *m = ASSERT_PTR(userdata);
ae57dad3
LP		 1604 struct statvfs svfs;
1605 uint64_t available;
718db961 1606 int r;
c0576cd6 1607
718db961 1608 assert(message);
c0576cd6 1609
ae57dad3
LP		 1610 if (statvfs("/run/systemd", &svfs) < 0)
1611 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1612
1613 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1614
2b59bf51 1615 if (available < RELOAD_DISK_SPACE_MIN)
cb31470f 1616 log_warning("Dangerously low amount of free space on /run/systemd, root switching might fail.\n"
ae57dad3 1617 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
2b59bf51
ZJS		 1618 FORMAT_BYTES(available),
1619 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3 1620
8a188de9 1621 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1622 if (r < 0)
1623 return r;
c0576cd6 1624
463d0d15 1625 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1626 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1627 "Root switching is only supported by system manager.");
c0576cd6 1628
718db961
LP		 1629 r = sd_bus_message_read(message, "ss", &root, &init);
1630 if (r < 0)
ebcf1f97 1631 return r;
c0576cd6 1632
710028b4 1633 if (isempty(root))
cb31470f
ZJS		 1634 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1635 "New root directory may not be the empty string.");
710028b4 1636 if (!path_is_absolute(root))
cb31470f
ZJS		 1637 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1638 "New root path '%s' is not absolute.", root);
710028b4 1639 if (path_equal(root, "/"))
cb31470f
ZJS		 1640 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1641 "New root directory cannot be the old root directory.");
c0576cd6 1642
718db961
LP		 1643 /* Safety check */
1644 if (isempty(init)) {
710028b4
LP		 1645 r = path_is_os_tree(root);
1646 if (r < 0)
cb31470f
ZJS		 1647 return sd_bus_error_set_errnof(error, r,
1648 "Failed to determine whether root path '%s' contains an OS tree: %m",
1649 root);
710028b4 1650 if (r == 0)
cb31470f
ZJS		 1651 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1652 "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1653 root);
718db961 1654 } else {
710028b4 1655 _cleanup_free_ char *chased = NULL;
c0576cd6 1656
718db961 1657 if (!path_is_absolute(init))
cb31470f
ZJS		 1658 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1659 "Path to init binary '%s' not absolute.", init);
c0576cd6 1660
a5648b80 1661 r = chase_symlinks(init, root, CHASE_PREFIX_ROOT|CHASE_TRAIL_SLASH, &chased, NULL);
710028b4 1662 if (r < 0)
cb31470f
ZJS		 1663 return sd_bus_error_set_errnof(error, r,
1664 "Could not resolve init executable %s: %m", init);
710028b4
LP		 1665
1666 if (laccess(chased, X_OK) < 0) {
1667 if (errno == EACCES)
cb31470f
ZJS		 1668 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1669 "Init binary %s is not executable.", init);
c0576cd6 1670
cb31470f
ZJS		 1671 return sd_bus_error_set_errnof(error, r,
1672 "Could not check whether init binary %s is executable: %m", init);
710028b4 1673 }
718db961
LP		 1674 }
1675
1676 rt = strdup(root);
1677 if (!rt)
ebcf1f97 1678 return -ENOMEM;
718db961
LP		 1679
1680 if (!isempty(init)) {
1681 ri = strdup(init);
87a19bfe 1682 if (!ri)
ebcf1f97 1683 return -ENOMEM;
718db961 1684 }
c0576cd6 1685
87a19bfe
YW		 1686 free_and_replace(m->switch_root, rt);
1687 free_and_replace(m->switch_root_init, ri);
c0576cd6 1688
af41e508 1689 m->objective = MANAGER_SWITCH_ROOT;
92b315df 1690
df2d202e 1691 return sd_bus_reply_method_return(message, NULL);
718db961 1692}
c0576cd6 1693
19070062 1694static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1695 _cleanup_strv_free_ char **plus = NULL;
99534007 1696 Manager *m = ASSERT_PTR(userdata);
718db961 1697 int r;
c0576cd6 1698
718db961 1699 assert(message);
cad45ba1 1700
8a188de9 1701 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1702 if (r < 0)
1703 return r;
c0576cd6 1704
718db961
LP		 1705 r = sd_bus_message_read_strv(message, &plus);
1706 if (r < 0)
ebcf1f97 1707 return r;
718db961 1708 if (!strv_env_is_valid(plus))
1b09b81c 1709 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
c0576cd6 1710
1d22e906
LP		 1711 r = bus_verify_set_environment_async(m, message, error);
1712 if (r < 0)
1713 return r;
1714 if (r == 0)
1715 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1716
1ad6e8b3 1717 r = manager_client_environment_modify(m, NULL, plus);
718db961 1718 if (r < 0)
ebcf1f97 1719 return r;
c0576cd6 1720
df2d202e 1721 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1722}
1723
19070062 1724static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1725 _cleanup_strv_free_ char **minus = NULL;
99534007 1726 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1727 int r;
1728
718db961 1729 assert(message);
718db961 1730
8a188de9 1731 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1732 if (r < 0)
1733 return r;
c0576cd6 1734
718db961
LP		 1735 r = sd_bus_message_read_strv(message, &minus);
1736 if (r < 0)
ebcf1f97 1737 return r;
718db961
LP		 1738
1739 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1740 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1741 "Invalid environment variable names or assignments");
718db961 1742
1d22e906
LP		 1743 r = bus_verify_set_environment_async(m, message, error);
1744 if (r < 0)
1745 return r;
1746 if (r == 0)
1747 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1748
1ad6e8b3 1749 r = manager_client_environment_modify(m, minus, NULL);
718db961 1750 if (r < 0)
ebcf1f97 1751 return r;
718db961 1752
df2d202e 1753 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1754}
1755
19070062 1756static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1757 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
99534007 1758 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1759 int r;
1760
718db961 1761 assert(message);
718db961 1762
8a188de9 1763 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1764 if (r < 0)
1765 return r;
718db961 1766
eb6c7d20 1767 r = sd_bus_message_read_strv(message, &minus);
718db961 1768 if (r < 0)
ebcf1f97 1769 return r;
718db961 1770
eb6c7d20 1771 r = sd_bus_message_read_strv(message, &plus);
718db961 1772 if (r < 0)
ebcf1f97 1773 return r;
718db961 1774
718db961 1775 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1776 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1777 "Invalid environment variable names or assignments");
eb6c7d20 1778 if (!strv_env_is_valid(plus))
cb31470f
ZJS		 1779 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1780 "Invalid environment assignments");
718db961 1781
1d22e906
LP		 1782 r = bus_verify_set_environment_async(m, message, error);
1783 if (r < 0)
1784 return r;
1785 if (r == 0)
1786 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1787
1ad6e8b3 1788 r = manager_client_environment_modify(m, minus, plus);
718db961 1789 if (r < 0)
ebcf1f97 1790 return r;
718db961 1791
df2d202e 1792 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1793}
1794
287419c1 1795static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1796 Manager *m = ASSERT_PTR(userdata);
29206d46 1797 uint8_t code;
287419c1
AC		 1798 int r;
1799
1800 assert(message);
287419c1
AC		 1801
1802 r = mac_selinux_access_check(message, "exit", error);
1803 if (r < 0)
1804 return r;
1805
1806 r = sd_bus_message_read_basic(message, 'y', &code);
1807 if (r < 0)
1808 return r;
1809
463d0d15 1810 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
1b09b81c 1811 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "ExitCode can only be set for user service managers or in containers.");
287419c1
AC		 1812
1813 m->return_value = code;
1814
1815 return sd_bus_reply_method_return(message, NULL);
1816}
1817
29206d46 1818static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1819 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 1820 const char *name;
1821 uid_t uid;
1822 int r;
1823
1824 assert(message);
29206d46
LP		 1825
1826 r = sd_bus_message_read_basic(message, 's', &name);
1827 if (r < 0)
1828 return r;
1829
1830 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1831 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1832 "Dynamic users are only supported in the system instance.");
7a8867ab 1833 if (!valid_user_group_name(name, VALID_USER_RELAX))
cb31470f
ZJS		 1834 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1835 "User name invalid: %s", name);
29206d46
LP		 1836
1837 r = dynamic_user_lookup_name(m, name, &uid);
1838 if (r == -ESRCH)
cb31470f
ZJS		 1839 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
1840 "Dynamic user %s does not exist.", name);
29206d46
LP		 1841 if (r < 0)
1842 return r;
1843
1844 return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
1845}
1846
1847static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1848 _cleanup_free_ char *name = NULL;
99534007 1849 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 1850 uid_t uid;
1851 int r;
1852
1853 assert(message);
29206d46 1854
60d0a509 1855 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
29206d46
LP		 1856 r = sd_bus_message_read_basic(message, 'u', &uid);
1857 if (r < 0)
1858 return r;
1859
1860 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1861 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1862 "Dynamic users are only supported in the system instance.");
29206d46 1863 if (!uid_is_valid(uid))
cb31470f
ZJS		 1864 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1865 "User ID invalid: " UID_FMT, uid);
29206d46
LP		 1866
1867 r = dynamic_user_lookup_uid(m, uid, &name);
1868 if (r == -ESRCH)
cb31470f
ZJS		 1869 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
1870 "Dynamic user ID " UID_FMT " does not exist.", uid);
29206d46
LP		 1871 if (r < 0)
1872 return r;
1873
1874 return sd_bus_reply_method_return(message, "s", name);
1875}
1876
f9bfa696
YW		 1877static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1878 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1879 Manager *m = ASSERT_PTR(userdata);
f9bfa696 1880 DynamicUser *d;
f9bfa696
YW		 1881 int r;
1882
1883 assert(message);
f9bfa696
YW		 1884
1885 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
1886
1887 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1888 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1889 "Dynamic users are only supported in the system instance.");
f9bfa696
YW		 1890
1891 r = sd_bus_message_new_method_return(message, &reply);
1892 if (r < 0)
1893 return r;
1894
1895 r = sd_bus_message_open_container(reply, 'a', "(us)");
1896 if (r < 0)
1897 return r;
1898
90e74a66 1899 HASHMAP_FOREACH(d, m->dynamic_users) {
f9bfa696
YW		 1900 uid_t uid;
1901
1902 r = dynamic_user_current(d, &uid);
1903 if (r == -EAGAIN) /* not realized yet? */
1904 continue;
1905 if (r < 0)
cb31470f
ZJS		 1906 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED,
1907 "Failed to look up a dynamic user.");
f9bfa696
YW		 1908
1909 r = sd_bus_message_append(reply, "(us)", uid, d->name);
1910 if (r < 0)
1911 return r;
1912 }
1913
1914 r = sd_bus_message_close_container(reply);
1915 if (r < 0)
1916 return r;
1917
1918 return sd_bus_send(NULL, reply, NULL);
1919}
1920
70666e28 1921static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1922 Manager *m = ASSERT_PTR(userdata);
70666e28
ZJS		 1923 int r;
1924
1925 assert(message);
70666e28
ZJS		 1926
1927 r = mac_selinux_access_check(message, "start", error);
1928 if (r < 0)
1929 return r;
1930
1931 r = bus_verify_manage_units_async(m, message, error);
1932 if (r < 0)
1933 return r;
1934 if (r == 0)
1935 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1936
28e5e1e9 1937 log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS));
70666e28
ZJS		 1938
1939 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1940 r = sd_bus_message_new_method_return(message, &reply);
1941 if (r < 0)
1942 return r;
1943
1944 r = sd_bus_message_open_container(reply, 'a', "o");
1945 if (r < 0)
1946 return r;
1947
1948 Unit *u;
1949 char *k;
1950 int ret = 0;
1951 HASHMAP_FOREACH_KEY(u, k, m->units) {
1952 /* ignore aliases */
1953 if (u->id != k)
1954 continue;
1955
1956 BusUnitQueueFlags flags;
1957 if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RESTART))
1958 flags = 0;
1959 else if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RELOAD))
1960 flags = BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE;
1961 else
1962 continue;
1963
1964 r = mac_selinux_unit_access_check(u, message, "start", error);
1965 if (r >= 0)
1966 r = bus_unit_queue_job_one(message, u,
1967 JOB_TRY_RESTART, JOB_FAIL, flags,
1968 reply, error);
1969 if (r < 0) {
1970 if (ERRNO_IS_RESOURCE(r))
1971 return r;
1972 if (ret >= 0)
1973 ret = r;
1974 sd_bus_error_free(error);
1975 }
1976 }
1977
1978 if (ret < 0)
1979 return sd_bus_error_set_errnof(error, ret,
1980 "Failed to enqueue some jobs, see logs for details: %m");
1981
1982 r = sd_bus_message_close_container(reply);
1983 if (r < 0)
1984 return r;
1985
1986 return sd_bus_send(NULL, reply, NULL);
1987}
1988
313fe66f 1989static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 1990 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1991 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1992 UnitFileList *item;
1993 Hashmap *h;
718db961
LP		 1994 int r;
1995
718db961 1996 assert(message);
718db961 1997
283868e1
SW		 1998 /* Anyone can call this method */
1999
8a188de9 2000 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2001 if (r < 0)
2002 return r;
718db961 2003
df2d202e 2004 r = sd_bus_message_new_method_return(message, &reply);
718db961 2005 if (r < 0)
ebcf1f97 2006 return r;
c0576cd6 2007
d5099efc 2008 h = hashmap_new(&string_hash_ops);
718db961 2009 if (!h)
ebcf1f97 2010 return -ENOMEM;
c0576cd6 2011
313fe66f 2012 r = unit_file_get_list(m->unit_file_scope, NULL, h, states, patterns);
ebcf1f97 2013 if (r < 0)
718db961 2014 goto fail;
718db961
LP		 2015
2016 r = sd_bus_message_open_container(reply, 'a', "(ss)");
ebcf1f97 2017 if (r < 0)
718db961 2018 goto fail;
718db961 2019
90e74a66 2020 HASHMAP_FOREACH(item, h) {
718db961
LP		 2021
2022 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
ebcf1f97 2023 if (r < 0)
718db961 2024 goto fail;
718db961 2025 }
c0576cd6 2026
718db961 2027 unit_file_list_free(h);
c0576cd6 2028
718db961
LP		 2029 r = sd_bus_message_close_container(reply);
2030 if (r < 0)
ebcf1f97 2031 return r;
8d0e38a2 2032
9030ca46 2033 return sd_bus_send(NULL, reply, NULL);
99504dd4 2034
718db961
LP		 2035fail:
2036 unit_file_list_free(h);
2037 return r;
2038}
99504dd4 2039
313fe66f 2040static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2041 return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
2042}
2043
2044static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2045 _cleanup_strv_free_ char **states = NULL;
2046 _cleanup_strv_free_ char **patterns = NULL;
2047 int r;
2048
2049 r = sd_bus_message_read_strv(message, &states);
2050 if (r < 0)
2051 return r;
2052
2053 r = sd_bus_message_read_strv(message, &patterns);
2054 if (r < 0)
2055 return r;
2056
2057 return list_unit_files_by_patterns(message, userdata, error, states, patterns);
2058}
2059
19070062 2060static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2061 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2062 const char *name;
2063 UnitFileState state;
718db961 2064 int r;
99504dd4 2065
718db961 2066 assert(message);
8e2af478 2067
283868e1
SW		 2068 /* Anyone can call this method */
2069
8a188de9 2070 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2071 if (r < 0)
2072 return r;
8e2af478 2073
718db961
LP		 2074 r = sd_bus_message_read(message, "s", &name);
2075 if (r < 0)
ebcf1f97 2076 return r;
8e2af478 2077
463d0d15 2078 r = unit_file_get_state(m->unit_file_scope, NULL, name, &state);
0ec0deaa
LP		 2079 if (r < 0)
2080 return r;
8e2af478 2081
df2d202e 2082 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
718db961 2083}
8e2af478 2084
19070062 2085static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 2086 _cleanup_free_ char *default_target = NULL;
99534007 2087 Manager *m = ASSERT_PTR(userdata);
718db961 2088 int r;
c2756a68 2089
718db961 2090 assert(message);
c2756a68 2091
283868e1
SW		 2092 /* Anyone can call this method */
2093
8a188de9 2094 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2095 if (r < 0)
2096 return r;
c2756a68 2097
463d0d15 2098 r = unit_file_get_default(m->unit_file_scope, NULL, &default_target);
718db961 2099 if (r < 0)
ebcf1f97 2100 return r;
c2756a68 2101
df2d202e 2102 return sd_bus_reply_method_return(message, "s", default_target);
718db961 2103}
c2756a68 2104
8f8f05a9 2105static int send_unit_files_changed(sd_bus *bus, void *userdata) {
4afd3348 2106 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 2107 int r;
2108
2109 assert(bus);
2110
cb31470f
ZJS		 2111 r = sd_bus_message_new_signal(bus, &message,
2112 "/org/freedesktop/systemd1",
2113 "org.freedesktop.systemd1.Manager",
2114 "UnitFilesChanged");
718db961
LP		 2115 if (r < 0)
2116 return r;
2117
8f8f05a9 2118 return sd_bus_send(bus, message, NULL);
718db961
LP		 2119}
2120
af3d8113
ZJS		 2121/* Create an error reply, using the error information from changes[]
2122 * if possible, and fall back to generating an error from error code c.
2123 * The error message only describes the first error.
2124 *
cd44ec5a 2125 * Coordinate with install_changes_dump() in install.c.
af3d8113
ZJS		 2126 */
2127static int install_error(
2128 sd_bus_error *error,
2129 int c,
cd44ec5a 2130 InstallChange *changes,
da6053d0
LP		 2131 size_t n_changes) {
2132
af3d8113 2133 int r;
8e20adca 2134
fe96c0f8 2135 for (size_t i = 0; i < n_changes; i++)
637d6e5b 2136
f8662fee 2137 switch (changes[i].type) {
637d6e5b 2138
f8662fee
LP		 2139 case 0 ... _INSTALL_CHANGE_TYPE_MAX: /* not errors */
2140 break;
637d6e5b 2141
af3d8113
ZJS		 2142 case -EEXIST:
2143 if (changes[i].source)
2144 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2145 "File %s already exists and is a symlink to %s.",
2146 changes[i].path, changes[i].source);
2147 else
2148 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2149 "File %s already exists.",
2150 changes[i].path);
2151 goto found;
637d6e5b 2152
af3d8113
ZJS		 2153 case -ERFKILL:
2154 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED,
2155 "Unit file %s is masked.", changes[i].path);
2156 goto found;
637d6e5b 2157
af3d8113
ZJS		 2158 case -EADDRNOTAVAIL:
2159 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED,
2160 "Unit %s is transient or generated.", changes[i].path);
2161 goto found;
637d6e5b 2162
d7ceaf72
ZJS		 2163 case -EUCLEAN:
2164 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2165 "\"%s\" is not a valid unit name.",
2166 changes[i].path);
2167 goto found;
2168
af3d8113
ZJS		 2169 case -ELOOP:
2170 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_LINKED,
22683674
FB		 2171 "Refusing to operate on alias name or linked unit file: %s",
2172 changes[i].path);
af3d8113 2173 goto found;
637d6e5b
LP		 2174
2175 case -ENOENT:
22683674
FB		 2176 r = sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
2177 "Unit file %s does not exist.", changes[i].path);
637d6e5b
LP		 2178 goto found;
2179
af3d8113 2180 default:
f8662fee
LP		 2181 assert(changes[i].type < 0); /* other errors */
2182 r = sd_bus_error_set_errnof(error, changes[i].type, "File %s: %m", changes[i].path);
af3d8113
ZJS		 2183 goto found;
2184 }
8e20adca 2185
637d6e5b
LP		 2186 r = c < 0 ? c : -EINVAL;
2187
af3d8113 2188 found:
cd44ec5a 2189 install_changes_free(changes, n_changes);
af3d8113 2190 return r;
8e20adca
LP		 2191}
2192
cd44ec5a 2193static int reply_install_changes_and_free(
637d6e5b
LP		 2194 Manager *m,
2195 sd_bus_message *message,
2196 int carries_install_info,
cd44ec5a 2197 InstallChange *changes,
da6053d0 2198 size_t n_changes,
637d6e5b
LP		 2199 sd_bus_error *error) {
2200
2201 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2202 bool bad = false, good = false;
637d6e5b
LP		 2203 int r;
2204
cd44ec5a 2205 if (install_changes_have_modification(changes, n_changes)) {
637d6e5b
LP		 2206 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
2207 if (r < 0)
2208 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
2209 }
2210
2211 r = sd_bus_message_new_method_return(message, &reply);
2212 if (r < 0)
2213 goto fail;
2214
2215 if (carries_install_info >= 0) {
2216 r = sd_bus_message_append(reply, "b", carries_install_info);
2217 if (r < 0)
2218 goto fail;
2219 }
2220
2221 r = sd_bus_message_open_container(reply, 'a', "(sss)");
2222 if (r < 0)
2223 goto fail;
2224
fe96c0f8 2225 for (size_t i = 0; i < n_changes; i++) {
637d6e5b 2226
f8662fee 2227 if (changes[i].type < 0) {
637d6e5b
LP		 2228 bad = true;
2229 continue;
2230 }
2231
2232 r = sd_bus_message_append(
2233 reply, "(sss)",
f8662fee 2234 install_change_type_to_string(changes[i].type),
637d6e5b
LP		 2235 changes[i].path,
2236 changes[i].source);
2237 if (r < 0)
2238 goto fail;
2239
2240 good = true;
2241 }
2242
cb31470f
ZJS		 2243 /* If there was a failed change, and no successful change, then return the first failure as proper
2244 * method call error. */
637d6e5b
LP		 2245 if (bad && !good)
2246 return install_error(error, 0, changes, n_changes);
2247
2248 r = sd_bus_message_close_container(reply);
2249 if (r < 0)
2250 goto fail;
2251
cd44ec5a 2252 install_changes_free(changes, n_changes);
637d6e5b
LP		 2253 return sd_bus_send(NULL, reply, NULL);
2254
2255fail:
cd44ec5a 2256 install_changes_free(changes, n_changes);
637d6e5b
LP		 2257 return r;
2258}
2259
718db961 2260static int method_enable_unit_files_generic(
718db961 2261 sd_bus_message *message,
d309c1c3 2262 Manager *m,
cd44ec5a 2263 int (*call)(LookupScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
ebcf1f97
LP		 2264 bool carries_install_info,
2265 sd_bus_error *error) {
718db961
LP		 2266
2267 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2268 InstallChange *changes = NULL;
da6053d0 2269 size_t n_changes = 0;
b3796dd8 2270 UnitFileFlags flags;
83654007 2271 int r;
718db961 2272
718db961
LP		 2273 assert(message);
2274 assert(m);
cad45ba1 2275
718db961
LP		 2276 r = sd_bus_message_read_strv(message, &l);
2277 if (r < 0)
ebcf1f97 2278 return r;
90bb85e1 2279
83654007
LB		 2280 if (sd_bus_message_is_method_call(message, NULL, "EnableUnitFilesWithFlags")) {
2281 uint64_t raw_flags;
d309c1c3 2282
83654007
LB		 2283 r = sd_bus_message_read(message, "t", &raw_flags);
2284 if (r < 0)
2285 return r;
2286 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0)
2287 return -EINVAL;
2288 flags = raw_flags;
2289 } else {
2290 int runtime, force;
2291
2292 r = sd_bus_message_read(message, "bb", &runtime, &force);
2293 if (r < 0)
2294 return r;
2295 flags = unit_file_bools_to_flags(runtime, force);
2296 }
b3796dd8 2297
1d22e906
LP		 2298 r = bus_verify_manage_unit_files_async(m, message, error);
2299 if (r < 0)
2300 return r;
2301 if (r == 0)
2302 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2303
b3796dd8 2304 r = call(m->unit_file_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2305 if (r < 0)
2306 return install_error(error, r, changes, n_changes);
718db961 2307
cd44ec5a 2308 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2309}
c87eba54 2310
83654007
LB		 2311static int method_enable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2312 return method_enable_unit_files_generic(message, userdata, unit_file_enable, true, error);
2313}
2314
19070062 2315static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2316 return method_enable_unit_files_generic(message, userdata, unit_file_enable, true, error);
718db961 2317}
ea430986 2318
19070062 2319static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2320 return method_enable_unit_files_generic(message, userdata, unit_file_reenable, true, error);
718db961
LP		 2321}
2322
19070062 2323static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2324 return method_enable_unit_files_generic(message, userdata, unit_file_link, false, error);
718db961
LP		 2325}
2326
cd44ec5a 2327static int unit_file_preset_without_mode(LookupScope scope, UnitFileFlags flags, const char *root_dir, char **files, InstallChange **changes, size_t *n_changes) {
b3796dd8 2328 return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
d309c1c3
LP		 2329}
2330
19070062 2331static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2332 return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, true, error);
718db961
LP		 2333}
2334
19070062 2335static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2336 return method_enable_unit_files_generic(message, userdata, unit_file_mask, false, error);
718db961 2337}
ea430986 2338
19070062 2339static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d309c1c3
LP		 2340
2341 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2342 InstallChange *changes = NULL;
da6053d0 2343 size_t n_changes = 0;
99534007 2344 Manager *m = ASSERT_PTR(userdata);
8331b221 2345 UnitFilePresetMode preset_mode;
d309c1c3 2346 int runtime, force, r;
b3796dd8 2347 UnitFileFlags flags;
d309c1c3
LP		 2348 const char *mode;
2349
d309c1c3 2350 assert(message);
d309c1c3
LP		 2351
2352 r = sd_bus_message_read_strv(message, &l);
2353 if (r < 0)
2354 return r;
2355
2356 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2357 if (r < 0)
2358 return r;
2359
b3796dd8
JS		 2360 flags = unit_file_bools_to_flags(runtime, force);
2361
d309c1c3 2362 if (isempty(mode))
8331b221 2363 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2364 else {
8331b221
ZJS		 2365 preset_mode = unit_file_preset_mode_from_string(mode);
2366 if (preset_mode < 0)
d309c1c3
LP		 2367 return -EINVAL;
2368 }
2369
1d22e906
LP		 2370 r = bus_verify_manage_unit_files_async(m, message, error);
2371 if (r < 0)
2372 return r;
2373 if (r == 0)
2374 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2375
8331b221 2376 r = unit_file_preset(m->unit_file_scope, flags, NULL, l, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2377 if (r < 0)
2378 return install_error(error, r, changes, n_changes);
d309c1c3 2379
cd44ec5a 2380 return reply_install_changes_and_free(m, message, r, changes, n_changes, error);
d309c1c3
LP		 2381}
2382
718db961 2383static int method_disable_unit_files_generic(
718db961 2384 sd_bus_message *message,
596fc263 2385 Manager *m,
cd44ec5a 2386 int (*call)(LookupScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
ebcf1f97 2387 sd_bus_error *error) {
718db961
LP		 2388
2389 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2390 InstallChange *changes = NULL;
83654007 2391 UnitFileFlags flags;
da6053d0 2392 size_t n_changes = 0;
83654007 2393 int r;
718db961 2394
718db961
LP		 2395 assert(message);
2396 assert(m);
2397
df823e23 2398 r = sd_bus_message_read_strv(message, &l);
ebcf1f97
LP		 2399 if (r < 0)
2400 return r;
718db961 2401
83654007
LB		 2402 if (sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlags")) {
2403 uint64_t raw_flags;
2404
2405 r = sd_bus_message_read(message, "t", &raw_flags);
2406 if (r < 0)
2407 return r;
2408 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0 ||
2409 FLAGS_SET(raw_flags, UNIT_FILE_FORCE))
2410 return -EINVAL;
2411 flags = raw_flags;
2412 } else {
2413 int runtime;
2414
2415 r = sd_bus_message_read(message, "b", &runtime);
2416 if (r < 0)
2417 return r;
2418 flags = unit_file_bools_to_flags(runtime, false);
2419 }
718db961 2420
1d22e906
LP		 2421 r = bus_verify_manage_unit_files_async(m, message, error);
2422 if (r < 0)
2423 return r;
2424 if (r == 0)
2425 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2426
83654007 2427 r = call(m->unit_file_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2428 if (r < 0)
2429 return install_error(error, r, changes, n_changes);
718db961 2430
cd44ec5a 2431 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
718db961 2432}
ea430986 2433
83654007
LB		 2434static int method_disable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2435 return method_disable_unit_files_generic(message, userdata, unit_file_disable, error);
2436}
2437
19070062 2438static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2439 return method_disable_unit_files_generic(message, userdata, unit_file_disable, error);
ea430986
LP		 2440}
2441
19070062 2442static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
9a7c402b 2443 return method_disable_unit_files_generic(message, userdata, unit_file_unmask, error);
718db961
LP		 2444}
2445
344ca755
LP		 2446static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2447 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2448 InstallChange *changes = NULL;
da6053d0 2449 size_t n_changes = 0;
99534007 2450 Manager *m = ASSERT_PTR(userdata);
344ca755
LP		 2451 int r;
2452
2453 assert(message);
344ca755
LP		 2454
2455 r = sd_bus_message_read_strv(message, &l);
2456 if (r < 0)
2457 return r;
2458
2459 r = bus_verify_manage_unit_files_async(m, message, error);
2460 if (r < 0)
2461 return r;
2462 if (r == 0)
2463 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2464
2465 r = unit_file_revert(m->unit_file_scope, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2466 if (r < 0)
2467 return install_error(error, r, changes, n_changes);
344ca755 2468
cd44ec5a 2469 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
344ca755
LP		 2470}
2471
19070062 2472static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2473 InstallChange *changes = NULL;
da6053d0 2474 size_t n_changes = 0;
99534007 2475 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2476 const char *name;
2477 int force, r;
2478
718db961 2479 assert(message);
718db961 2480
1d22e906 2481 r = mac_selinux_access_check(message, "enable", error);
283868e1
SW		 2482 if (r < 0)
2483 return r;
283868e1 2484
1d22e906 2485 r = sd_bus_message_read(message, "sb", &name, &force);
ebcf1f97
LP		 2486 if (r < 0)
2487 return r;
718db961 2488
1d22e906 2489 r = bus_verify_manage_unit_files_async(m, message, error);
718db961 2490 if (r < 0)
ebcf1f97 2491 return r;
1d22e906
LP		 2492 if (r == 0)
2493 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
718db961 2494
b3796dd8 2495 r = unit_file_set_default(m->unit_file_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
af3d8113
ZJS		 2496 if (r < 0)
2497 return install_error(error, r, changes, n_changes);
718db961 2498
cd44ec5a 2499 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
718db961
LP		 2500}
2501
19070062 2502static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2503 InstallChange *changes = NULL;
da6053d0 2504 size_t n_changes = 0;
99534007 2505 Manager *m = ASSERT_PTR(userdata);
8331b221 2506 UnitFilePresetMode preset_mode;
d309c1c3 2507 const char *mode;
b3796dd8 2508 UnitFileFlags flags;
d309c1c3
LP		 2509 int force, runtime, r;
2510
d309c1c3 2511 assert(message);
d309c1c3 2512
8a188de9 2513 r = mac_selinux_access_check(message, "enable", error);
d309c1c3
LP		 2514 if (r < 0)
2515 return r;
2516
2517 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2518 if (r < 0)
2519 return r;
2520
b3796dd8
JS		 2521 flags = unit_file_bools_to_flags(runtime, force);
2522
d309c1c3 2523 if (isempty(mode))
8331b221 2524 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2525 else {
8331b221
ZJS		 2526 preset_mode = unit_file_preset_mode_from_string(mode);
2527 if (preset_mode < 0)
d309c1c3
LP		 2528 return -EINVAL;
2529 }
2530
1d22e906
LP		 2531 r = bus_verify_manage_unit_files_async(m, message, error);
2532 if (r < 0)
2533 return r;
2534 if (r == 0)
2535 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2536
8331b221 2537 r = unit_file_preset_all(m->unit_file_scope, flags, NULL, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2538 if (r < 0)
2539 return install_error(error, r, changes, n_changes);
d309c1c3 2540
cd44ec5a 2541 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
d309c1c3
LP		 2542}
2543
19070062 2544static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
e94937df 2545 _cleanup_strv_free_ char **l = NULL;
99534007 2546 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2547 InstallChange *changes = NULL;
da6053d0 2548 size_t n_changes = 0;
e94937df 2549 int runtime, force, r;
596fc263 2550 char *target, *type;
e94937df 2551 UnitDependency dep;
b3796dd8 2552 UnitFileFlags flags;
e94937df 2553
e94937df 2554 assert(message);
e94937df
LN		 2555
2556 r = bus_verify_manage_unit_files_async(m, message, error);
2557 if (r < 0)
2558 return r;
2559 if (r == 0)
2560 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2561
2562 r = sd_bus_message_read_strv(message, &l);
2563 if (r < 0)
2564 return r;
2565
2566 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2567 if (r < 0)
2568 return r;
2569
b3796dd8
JS		 2570 flags = unit_file_bools_to_flags(runtime, force);
2571
e94937df
LN		 2572 dep = unit_dependency_from_string(type);
2573 if (dep < 0)
2574 return -EINVAL;
2575
b3796dd8 2576 r = unit_file_add_dependency(m->unit_file_scope, flags, NULL, l, target, dep, &changes, &n_changes);
af3d8113
ZJS		 2577 if (r < 0)
2578 return install_error(error, r, changes, n_changes);
e94937df 2579
cd44ec5a 2580 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
e94937df
LN		 2581}
2582
3b3557c4
JS		 2583static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2584 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
cd44ec5a 2585 InstallChange *changes = NULL;
da6053d0 2586 size_t n_changes = 0, i;
3b3557c4
JS		 2587 UnitFileFlags flags;
2588 const char *name;
2589 char **p;
2590 int runtime, r;
2591
2592 r = sd_bus_message_read(message, "sb", &name, &runtime);
2593 if (r < 0)
2594 return r;
2595
2596 r = sd_bus_message_new_method_return(message, &reply);
2597 if (r < 0)
2598 return r;
2599
2600 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2601 if (r < 0)
2602 return r;
2603
2604 p = STRV_MAKE(name);
2605 flags = UNIT_FILE_DRY_RUN |
2606 (runtime ? UNIT_FILE_RUNTIME : 0);
2607
b380b643 2608 r = unit_file_disable(LOOKUP_SCOPE_SYSTEM, flags, NULL, p, &changes, &n_changes);
3b3557c4
JS		 2609 if (r < 0)
2610 return log_error_errno(r, "Failed to get file links for %s: %m", name);
2611
2612 for (i = 0; i < n_changes; i++)
f8662fee 2613 if (changes[i].type == INSTALL_CHANGE_UNLINK) {
3b3557c4
JS		 2614 r = sd_bus_message_append(reply, "s", changes[i].path);
2615 if (r < 0)
2616 return r;
2617 }
2618
2619 r = sd_bus_message_close_container(reply);
2620 if (r < 0)
2621 return r;
2622
2623 return sd_bus_send(NULL, reply, NULL);
2624}
2625
15ea79f8 2626static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2627 Manager *m = ASSERT_PTR(userdata);
15ea79f8
LP		 2628 uint32_t id;
2629 Job *j;
2630 int r;
2631
2632 assert(message);
15ea79f8
LP		 2633
2634 r = sd_bus_message_read(message, "u", &id);
2635 if (r < 0)
2636 return r;
2637
2638 j = manager_get_job(m, id);
2639 if (!j)
2640 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2641
2642 return bus_job_method_get_waiting_jobs(message, j, error);
2643}
2644
c20076a8 2645static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2646 Manager *m = ASSERT_PTR(userdata);
c20076a8
LP		 2647 const char *name;
2648 Unit *u;
2649 int r;
2650
2651 assert(message);
c20076a8
LP		 2652
2653 r = sd_bus_message_read(message, "s", &name);
2654 if (r < 0)
2655 return r;
2656
2657 r = bus_get_unit_by_name(m, message, name, &u, error);
2658 if (r < 0)
2659 return r;
2660
2661 if (u->type != UNIT_SCOPE)
cb31470f
ZJS		 2662 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2663 "Unit '%s' is not a scope unit, refusing.", name);
c20076a8
LP		 2664
2665 return bus_scope_method_abandon(message, u, error);
2666}
2667
0bb007f7 2668static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2669 Manager *m = ASSERT_PTR(userdata);
0bb007f7
FB		 2670 ShowStatus mode = _SHOW_STATUS_INVALID;
2671 const char *t;
2672 int r;
2673
0bb007f7
FB		 2674 assert(message);
2675
4db62561
ZJS		 2676 r = mac_selinux_access_check(message, "reload", error);
2677 if (r < 0)
2678 return r;
2679
2680 r = bus_verify_set_environment_async(m, message, error);
2681 if (r < 0)
2682 return r;
2683 if (r == 0)
2684 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2685
0bb007f7
FB		 2686 r = sd_bus_message_read(message, "s", &t);
2687 if (r < 0)
2688 return r;
2689
2690 if (!isempty(t)) {
2691 mode = show_status_from_string(t);
2692 if (mode < 0)
cb31470f
ZJS		 2693 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2694 "Invalid show status '%s'", t);
0bb007f7
FB		 2695 }
2696
43bba15a 2697 manager_override_show_status(m, mode, "bus");
0bb007f7
FB		 2698
2699 return sd_bus_reply_method_return(message, NULL);
2700}
2701
718db961
LP		 2702const sd_bus_vtable bus_manager_vtable[] = {
2703 SD_BUS_VTABLE_START(0),
2704
556089dc
LP		 2705 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2706 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2707 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
7452394e 2708 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2709 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
9f9f0342
LP		 2710 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
2711 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
2712 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
2713 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
2714 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
2715 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2716 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2717 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2718 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2719 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2720 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2721 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
49fbe940 2722 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD]), SD_BUS_VTABLE_PROPERTY_CONST),
665a9774
YW		 2723 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2724 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2725 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2726 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2727 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2728 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
25141692
LP		 2729 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
2730 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3ff52e8f
YW		 2731 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
2732 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2733 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
718db961
LP		 2734 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
2735 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
2736 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1ad6e8b3 2737 SD_BUS_PROPERTY("Environment", "as", property_get_environment, 0, 0),
556089dc 2738 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
52d2566a 2739 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
a3c4eb07 2740 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2741 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
cb6c4f37 2742 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_error), SD_BUS_VTABLE_PROPERTY_CONST),
3e911a0d
YW		 2743 SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2744 SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime, 0, 0),
2745 SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic, 0, 0),
986935cf 2746 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog, property_set_runtime_watchdog, 0, 0),
5717062e 2747 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog, property_set_pretimeout_watchdog, 0, 0),
aff3a9e1 2748 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor, property_set_pretimeout_watchdog_governor, 0, 0),
986935cf 2749 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, 0),
65224c1d 2750 /* The following item is an obsolete alias */
986935cf
FB		 2751 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, SD_BUS_VTABLE_HIDDEN),
2752 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog, property_set_kexec_watchdog, 0, 0),
2a12e32e 2753 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
b272b74d 2754 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
f755e3b7 2755 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
287419c1 2756 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
670a3efe
EV		 2757 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, default_timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2758 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2759 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
dc653bf4 2760 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec, 0, 0),
a0fe19f9 2761 SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec, offsetof(Manager, default_device_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
670a3efe 2762 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, default_restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
c075f5fc
YW		 2763 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
2764 /* The following two items are obsolete alias */
2765 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
2766 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
670a3efe
EV		 2767 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, default_start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
2768 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, default_cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2769 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2770 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, default_memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2771 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, default_tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2772 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2773 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2774 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2775 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2776 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2777 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2778 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2779 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2780 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2781 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2782 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2783 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2784 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2785 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2786 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2787 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2788 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2789 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2790 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2791 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2792 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2793 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2794 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2795 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2796 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2797 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2798 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2799 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2800 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2801 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2802 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2803 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3a0f06c4 2804 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max, offsetof(Manager, default_tasks_max), 0),
eed67a30 2805 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
afcfaa69 2806 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy, offsetof(Manager, default_oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
d4a402e4 2807 SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
c44a285c 2808 SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 2809
a008b6d7 2810 SD_BUS_METHOD_WITH_ARGS("GetUnit",
2811 SD_BUS_ARGS("s", name),
2812 SD_BUS_RESULT("o", unit),
2813 method_get_unit,
2814 SD_BUS_VTABLE_UNPRIVILEGED),
2815 SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
2816 SD_BUS_ARGS("u", pid),
2817 SD_BUS_RESULT("o", unit),
2818 method_get_unit_by_pid,
2819 SD_BUS_VTABLE_UNPRIVILEGED),
2820 SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
2821 SD_BUS_ARGS("ay", invocation_id),
2822 SD_BUS_RESULT("o", unit),
2823 method_get_unit_by_invocation_id,
2824 SD_BUS_VTABLE_UNPRIVILEGED),
2825 SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
2826 SD_BUS_ARGS("s", cgroup),
2827 SD_BUS_RESULT("o", unit),
2828 method_get_unit_by_control_group,
2829 SD_BUS_VTABLE_UNPRIVILEGED),
2830 SD_BUS_METHOD_WITH_ARGS("LoadUnit",
2831 SD_BUS_ARGS("s", name),
2832 SD_BUS_RESULT("o", unit),
2833 method_load_unit,
2834 SD_BUS_VTABLE_UNPRIVILEGED),
2835 SD_BUS_METHOD_WITH_ARGS("StartUnit",
2836 SD_BUS_ARGS("s", name, "s", mode),
2837 SD_BUS_RESULT("o", job),
2838 method_start_unit,
2839 SD_BUS_VTABLE_UNPRIVILEGED),
2840 SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
2841 SD_BUS_ARGS("s", name, "s", mode, "t", flags),
2842 SD_BUS_RESULT("o", job),
2843 method_start_unit,
2844 SD_BUS_VTABLE_UNPRIVILEGED),
2845 SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
2846 SD_BUS_ARGS("s", old_unit, "s", new_unit, "s", mode),
2847 SD_BUS_RESULT("o", job),
2848 method_start_unit_replace,
2849 SD_BUS_VTABLE_UNPRIVILEGED),
2850 SD_BUS_METHOD_WITH_ARGS("StopUnit",
2851 SD_BUS_ARGS("s", name, "s", mode),
2852 SD_BUS_RESULT("o", job),
2853 method_stop_unit,
2854 SD_BUS_VTABLE_UNPRIVILEGED),
2855 SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
2856 SD_BUS_ARGS("s", name, "s", mode),
2857 SD_BUS_RESULT("o", job),
2858 method_reload_unit,
2859 SD_BUS_VTABLE_UNPRIVILEGED),
2860 SD_BUS_METHOD_WITH_ARGS("RestartUnit",
2861 SD_BUS_ARGS("s", name, "s", mode),
2862 SD_BUS_RESULT("o", job),
2863 method_restart_unit,
2864 SD_BUS_VTABLE_UNPRIVILEGED),
2865 SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
2866 SD_BUS_ARGS("s", name, "s", mode),
2867 SD_BUS_RESULT("o", job),
2868 method_try_restart_unit,
2869 SD_BUS_VTABLE_UNPRIVILEGED),
2870 SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
2871 SD_BUS_ARGS("s", name, "s", mode),
2872 SD_BUS_RESULT("o", job),
2873 method_reload_or_restart_unit,
2874 SD_BUS_VTABLE_UNPRIVILEGED),
2875 SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
2876 SD_BUS_ARGS("s", name, "s", mode),
2877 SD_BUS_RESULT("o", job),
2878 method_reload_or_try_restart_unit,
2879 SD_BUS_VTABLE_UNPRIVILEGED),
2880 SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
2881 SD_BUS_ARGS("s", name, "s", job_type, "s", job_mode),
2882 SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
2883 method_enqueue_unit_job,
2884 SD_BUS_VTABLE_UNPRIVILEGED),
2885 SD_BUS_METHOD_WITH_ARGS("KillUnit",
2886 SD_BUS_ARGS("s", name, "s", whom, "i", signal),
2887 SD_BUS_NO_RESULT,
2888 method_kill_unit,
2889 SD_BUS_VTABLE_UNPRIVILEGED),
2890 SD_BUS_METHOD_WITH_ARGS("CleanUnit",
2891 SD_BUS_ARGS("s", name, "as", mask),
2892 SD_BUS_NO_RESULT,
2893 method_clean_unit,
2894 SD_BUS_VTABLE_UNPRIVILEGED),
2895 SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
2896 SD_BUS_ARGS("s", name),
2897 SD_BUS_NO_RESULT,
2898 method_freeze_unit,
2899 SD_BUS_VTABLE_UNPRIVILEGED),
2900 SD_BUS_METHOD_WITH_ARGS("ThawUnit",
2901 SD_BUS_ARGS("s", name),
2902 SD_BUS_NO_RESULT,
2903 method_thaw_unit,
2904 SD_BUS_VTABLE_UNPRIVILEGED),
2905 SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
2906 SD_BUS_ARGS("s", name),
2907 SD_BUS_NO_RESULT,
2908 method_reset_failed_unit,
2909 SD_BUS_VTABLE_UNPRIVILEGED),
2910 SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
2911 SD_BUS_ARGS("s", name, "b", runtime, "a(sv)", properties),
2912 SD_BUS_NO_RESULT,
2913 method_set_unit_properties,
2914 SD_BUS_VTABLE_UNPRIVILEGED),
2915 SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
2916 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir),
2917 SD_BUS_NO_RESULT,
2918 method_bind_mount_unit,
2919 SD_BUS_VTABLE_UNPRIVILEGED),
2920 SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
2921 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
2922 SD_BUS_NO_RESULT,
2923 method_mount_image_unit,
2924 SD_BUS_VTABLE_UNPRIVILEGED),
2925 SD_BUS_METHOD_WITH_ARGS("RefUnit",
2926 SD_BUS_ARGS("s", name),
2927 SD_BUS_NO_RESULT,
2928 method_ref_unit,
2929 SD_BUS_VTABLE_UNPRIVILEGED),
2930 SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
2931 SD_BUS_ARGS("s", name),
2932 SD_BUS_NO_RESULT,
2933 method_unref_unit,
2934 SD_BUS_VTABLE_UNPRIVILEGED),
2935 SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
2936 SD_BUS_ARGS("s", name, "s", mode, "a(sv)", properties, "a(sa(sv))", aux),
2937 SD_BUS_RESULT("o", job),
2938 method_start_transient_unit,
2939 SD_BUS_VTABLE_UNPRIVILEGED),
2940 SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
2941 SD_BUS_ARGS("s", name),
2942 SD_BUS_RESULT("a(sus)", processes),
2943 method_get_unit_processes,
2944 SD_BUS_VTABLE_UNPRIVILEGED),
2945 SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
2946 SD_BUS_ARGS("s", unit_name, "s", subcgroup, "au", pids),
2947 SD_BUS_NO_RESULT,
2948 method_attach_processes_to_unit,
2949 SD_BUS_VTABLE_UNPRIVILEGED),
2950 SD_BUS_METHOD_WITH_ARGS("AbandonScope",
2951 SD_BUS_ARGS("s", name),
2952 SD_BUS_NO_RESULT,
2953 method_abandon_scope,
2954 SD_BUS_VTABLE_UNPRIVILEGED),
2955 SD_BUS_METHOD_WITH_ARGS("GetJob",
2956 SD_BUS_ARGS("u", id),
2957 SD_BUS_RESULT("o", job),
2958 method_get_job,
2959 SD_BUS_VTABLE_UNPRIVILEGED),
2960 SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
2961 SD_BUS_ARGS("u", id),
2962 SD_BUS_RESULT("a(usssoo)", jobs),
2963 method_get_job_waiting,
2964 SD_BUS_VTABLE_UNPRIVILEGED),
2965 SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
2966 SD_BUS_ARGS("u", id),
2967 SD_BUS_RESULT("a(usssoo)", jobs),
2968 method_get_job_waiting,
2969 SD_BUS_VTABLE_UNPRIVILEGED),
2970 SD_BUS_METHOD_WITH_ARGS("CancelJob",
2971 SD_BUS_ARGS("u", id),
2972 SD_BUS_NO_RESULT,
2973 method_cancel_job,
2974 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 2975 SD_BUS_METHOD("ClearJobs",
2976 NULL,
2977 NULL,
2978 method_clear_jobs,
2979 SD_BUS_VTABLE_UNPRIVILEGED),
2980 SD_BUS_METHOD("ResetFailed",
2981 NULL,
2982 NULL,
2983 method_reset_failed,
2984 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 2985 SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
2986 SD_BUS_ARGS("s", mode),
2987 SD_BUS_NO_RESULT,
2988 method_set_show_status,
2989 SD_BUS_VTABLE_UNPRIVILEGED),
2990 SD_BUS_METHOD_WITH_ARGS("ListUnits",
2991 SD_BUS_NO_ARGS,
2992 SD_BUS_RESULT("a(ssssssouso)", units),
2993 method_list_units,
2994 SD_BUS_VTABLE_UNPRIVILEGED),
2995 SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
2996 SD_BUS_ARGS("as", states),
2997 SD_BUS_RESULT("a(ssssssouso)", units),
2998 method_list_units_filtered,
2999 SD_BUS_VTABLE_UNPRIVILEGED),
3000 SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3001 SD_BUS_ARGS("as", states, "as", patterns),
3002 SD_BUS_RESULT("a(ssssssouso)", units),
3003 method_list_units_by_patterns,
3004 SD_BUS_VTABLE_UNPRIVILEGED),
3005 SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3006 SD_BUS_ARGS("as", names),
3007 SD_BUS_RESULT("a(ssssssouso)", units),
3008 method_list_units_by_names,
3009 SD_BUS_VTABLE_UNPRIVILEGED),
3010 SD_BUS_METHOD_WITH_ARGS("ListJobs",
3011 SD_BUS_NO_ARGS,
3012 SD_BUS_RESULT("a(usssoo)", jobs),
3013 method_list_jobs,
3014 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3015 SD_BUS_METHOD("Subscribe",
3016 NULL,
3017 NULL,
3018 method_subscribe,
3019 SD_BUS_VTABLE_UNPRIVILEGED),
3020 SD_BUS_METHOD("Unsubscribe",
3021 NULL,
3022 NULL,
3023 method_unsubscribe,
3024 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3025 SD_BUS_METHOD_WITH_ARGS("Dump",
3026 SD_BUS_NO_ARGS,
3027 SD_BUS_RESULT("s", output),
3028 method_dump,
3029 SD_BUS_VTABLE_UNPRIVILEGED),
d1d8786c
FB		 3030 SD_BUS_METHOD_WITH_ARGS("DumpPatterns",
3031 SD_BUS_ARGS("as", patterns),
3032 SD_BUS_RESULT("s", output),
3033 method_dump_patterns,
3034 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3035 SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3036 SD_BUS_NO_ARGS,
3037 SD_BUS_RESULT("h", fd),
3038 method_dump_by_fd,
3039 SD_BUS_VTABLE_UNPRIVILEGED),
3040 SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3041 SD_BUS_ARGS("s", name, "b", cleanup),
3042 SD_BUS_RESULT("o", unit),
3043 method_refuse_snapshot,
3044 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3045 SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3046 SD_BUS_ARGS("s", name),
3047 SD_BUS_NO_RESULT,
3048 method_refuse_snapshot,
3049 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
dad97f04
ZJS		 3050 SD_BUS_METHOD("Reload",
3051 NULL,
3052 NULL,
3053 method_reload,
3054 SD_BUS_VTABLE_UNPRIVILEGED),
3055 SD_BUS_METHOD("Reexecute",
3056 NULL,
3057 NULL,
3058 method_reexecute,
624f685f 3059 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_METHOD_NO_REPLY),
dad97f04
ZJS		 3060 SD_BUS_METHOD("Exit",
3061 NULL,
3062 NULL,
3063 method_exit,
3064 0),
3065 SD_BUS_METHOD("Reboot",
3066 NULL,
3067 NULL,
3068 method_reboot,
3069 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3070 SD_BUS_METHOD("PowerOff",
3071 NULL,
3072 NULL,
3073 method_poweroff,
3074 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3075 SD_BUS_METHOD("Halt",
3076 NULL,
3077 NULL,
3078 method_halt,
3079 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3080 SD_BUS_METHOD("KExec",
3081 NULL,
3082 NULL,
3083 method_kexec,
3084 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
a008b6d7 3085 SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3086 SD_BUS_ARGS("s", new_root, "s", init),
3087 SD_BUS_NO_RESULT,
3088 method_switch_root,
3089 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3090 SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3091 SD_BUS_ARGS("as", assignments),
3092 SD_BUS_NO_RESULT,
3093 method_set_environment,
3094 SD_BUS_VTABLE_UNPRIVILEGED),
3095 SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3096 SD_BUS_ARGS("as", names),
3097 SD_BUS_NO_RESULT,
3098 method_unset_environment,
3099 SD_BUS_VTABLE_UNPRIVILEGED),
3100 SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3101 SD_BUS_ARGS("as", names, "as", assignments),
3102 SD_BUS_NO_RESULT,
3103 method_unset_and_set_environment,
3104 SD_BUS_VTABLE_UNPRIVILEGED),
3105 SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3106 SD_BUS_NO_ARGS,
3107 SD_BUS_RESULT("ao", jobs),
3108 method_enqueue_marked_jobs,
3109 SD_BUS_VTABLE_UNPRIVILEGED),
3110 SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3111 SD_BUS_NO_ARGS,
3112 SD_BUS_RESULT("a(ss)", unit_files),
3113 method_list_unit_files,
3114 SD_BUS_VTABLE_UNPRIVILEGED),
3115 SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3116 SD_BUS_ARGS("as", states, "as", patterns),
3117 SD_BUS_RESULT("a(ss)", unit_files),
3118 method_list_unit_files_by_patterns,
3119 SD_BUS_VTABLE_UNPRIVILEGED),
3120 SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3121 SD_BUS_ARGS("s", file),
3122 SD_BUS_RESULT("s", state),
3123 method_get_unit_file_state,
3124 SD_BUS_VTABLE_UNPRIVILEGED),
3125 SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3126 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3127 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3128 method_enable_unit_files,
3129 SD_BUS_VTABLE_UNPRIVILEGED),
3130 SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3131 SD_BUS_ARGS("as", files, "b", runtime),
3132 SD_BUS_RESULT("a(sss)", changes),
3133 method_disable_unit_files,
3134 SD_BUS_VTABLE_UNPRIVILEGED),
3135 SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3136 SD_BUS_ARGS("as", files, "t", flags),
3137 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3138 method_enable_unit_files_with_flags,
3139 SD_BUS_VTABLE_UNPRIVILEGED),
3140 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3141 SD_BUS_ARGS("as", files, "t", flags),
3142 SD_BUS_RESULT("a(sss)", changes),
3143 method_disable_unit_files_with_flags,
3144 SD_BUS_VTABLE_UNPRIVILEGED),
3145 SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3146 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3147 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3148 method_reenable_unit_files,
3149 SD_BUS_VTABLE_UNPRIVILEGED),
3150 SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3151 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3152 SD_BUS_RESULT("a(sss)", changes),
3153 method_link_unit_files,
3154 SD_BUS_VTABLE_UNPRIVILEGED),
3155 SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3156 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3157 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3158 method_preset_unit_files,
3159 SD_BUS_VTABLE_UNPRIVILEGED),
3160 SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3161 SD_BUS_ARGS("as", files, "s", mode, "b", runtime, "b", force),
3162 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3163 method_preset_unit_files_with_mode,
3164 SD_BUS_VTABLE_UNPRIVILEGED),
3165 SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3166 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3167 SD_BUS_RESULT("a(sss)", changes),
3168 method_mask_unit_files,
3169 SD_BUS_VTABLE_UNPRIVILEGED),
3170 SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3171 SD_BUS_ARGS("as", files, "b", runtime),
3172 SD_BUS_RESULT("a(sss)", changes),
3173 method_unmask_unit_files,
3174 SD_BUS_VTABLE_UNPRIVILEGED),
3175 SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3176 SD_BUS_ARGS("as", files),
3177 SD_BUS_RESULT("a(sss)", changes),
3178 method_revert_unit_files,
3179 SD_BUS_VTABLE_UNPRIVILEGED),
3180 SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3181 SD_BUS_ARGS("s", name, "b", force),
3182 SD_BUS_RESULT("a(sss)", changes),
3183 method_set_default_target,
3184 SD_BUS_VTABLE_UNPRIVILEGED),
3185 SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3186 SD_BUS_NO_ARGS,
3187 SD_BUS_RESULT("s", name),
3188 method_get_default_target,
3189 SD_BUS_VTABLE_UNPRIVILEGED),
3190 SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3191 SD_BUS_ARGS("s", mode, "b", runtime, "b", force),
3192 SD_BUS_RESULT("a(sss)", changes),
3193 method_preset_all_unit_files,
3194 SD_BUS_VTABLE_UNPRIVILEGED),
3195 SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3196 SD_BUS_ARGS("as", files, "s", target, "s", type, "b", runtime, "b", force),
3197 SD_BUS_RESULT("a(sss)", changes),
3198 method_add_dependency_unit_files,
3199 SD_BUS_VTABLE_UNPRIVILEGED),
3200 SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3201 SD_BUS_ARGS("s", name, "b", runtime),
3202 SD_BUS_RESULT("as", links),
3203 method_get_unit_file_links,
3204 SD_BUS_VTABLE_UNPRIVILEGED),
3205 SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3206 SD_BUS_ARGS("y", number),
3207 SD_BUS_NO_RESULT,
3208 method_set_exit_code,
3209 SD_BUS_VTABLE_UNPRIVILEGED),
3210 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3211 SD_BUS_ARGS("s", name),
3212 SD_BUS_RESULT("u", uid),
3213 method_lookup_dynamic_user_by_name,
3214 SD_BUS_VTABLE_UNPRIVILEGED),
3215 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3216 SD_BUS_ARGS("u", uid),
3217 SD_BUS_RESULT("s", name),
3218 method_lookup_dynamic_user_by_uid,
3219 SD_BUS_VTABLE_UNPRIVILEGED),
3220 SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3221 SD_BUS_NO_ARGS,
3222 SD_BUS_RESULT("a(us)", users),
3223 method_get_dynamic_users,
3224 SD_BUS_VTABLE_UNPRIVILEGED),
3225
3226 SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3227 SD_BUS_ARGS("s", id, "o", unit),
3228 0),
3229 SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3230 SD_BUS_ARGS("s", id, "o", unit),
3231 0),
3232 SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3233 SD_BUS_ARGS("u", id, "o", job, "s", unit),
3234 0),
3235 SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3236 SD_BUS_ARGS("u", id, "o", job, "s", unit, "s", result),
3237 0),
3238 SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3239 SD_BUS_ARGS("t", firmware, "t", loader, "t", kernel, "t", initrd, "t", userspace, "t", total),
3240 0),
718db961 3241 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
a008b6d7 3242 SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3243 SD_BUS_ARGS("b", active),
3244 0),
718db961
LP		 3245
3246 SD_BUS_VTABLE_END
ea430986 3247};
718db961 3248
893f801d
LP		 3249const sd_bus_vtable bus_manager_log_control_vtable[] = {
3250 SD_BUS_VTABLE_START(0),
3251
3252 /* We define a private version of this interface here, since we want slightly different
3253 * implementations for the setters. We'll still use the generic getters however, and we share the
3254 * setters with the implementations for the Manager interface above (which pre-dates the generic
3255 * service API interface). */
3256
3257 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3258 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3259 SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier, 0, 0),
3260
3261 SD_BUS_VTABLE_END,
3262};
3263
8f8f05a9 3264static int send_finished(sd_bus *bus, void *userdata) {
4afd3348 3265 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
99534007 3266 usec_t *times = ASSERT_PTR(userdata);
718db961
LP		 3267 int r;
3268
3269 assert(bus);
718db961 3270
cb31470f
ZJS		 3271 r = sd_bus_message_new_signal(bus,
3272 &message,
3273 "/org/freedesktop/systemd1",
3274 "org.freedesktop.systemd1.Manager",
3275 "StartupFinished");
718db961
LP		 3276 if (r < 0)
3277 return r;
3278
3279 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
3280 if (r < 0)
3281 return r;
3282
8f8f05a9 3283 return sd_bus_send(bus, message, NULL);
718db961
LP		 3284}
3285
39abcaee 3286void bus_manager_send_finished(
718db961
LP		 3287 Manager *m,
3288 usec_t firmware_usec,
3289 usec_t loader_usec,
3290 usec_t kernel_usec,
3291 usec_t initrd_usec,
3292 usec_t userspace_usec,
3293 usec_t total_usec) {
3294
39abcaee
LP		 3295 int r;
3296
718db961
LP		 3297 assert(m);
3298
8f8f05a9
LP		 3299 r = bus_foreach_bus(
3300 m,
3301 NULL,
3302 send_finished,
3303 (usec_t[6]) {
3304 firmware_usec,
3305 loader_usec,
3306 kernel_usec,
3307 initrd_usec,
3308 userspace_usec,
3309 total_usec
3310 });
39abcaee 3311 if (r < 0)
da927ba9 3312 log_debug_errno(r, "Failed to send finished signal: %m");
718db961
LP		 3313}
3314
8f8f05a9 3315static int send_reloading(sd_bus *bus, void *userdata) {
4afd3348 3316 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 3317 int r;
3318
3319 assert(bus);
3320
151b9b96 3321 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
718db961
LP		 3322 if (r < 0)
3323 return r;
3324
3325 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
3326 if (r < 0)
3327 return r;
3328
8f8f05a9 3329 return sd_bus_send(bus, message, NULL);
718db961
LP		 3330}
3331
39abcaee
LP		 3332void bus_manager_send_reloading(Manager *m, bool active) {
3333 int r;
3334
718db961
LP		 3335 assert(m);
3336
8f8f05a9 3337 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
39abcaee 3338 if (r < 0)
da927ba9 3339 log_debug_errno(r, "Failed to send reloading signal: %m");
03455c28
LDM		 3340}
3341
3342static int send_changed_signal(sd_bus *bus, void *userdata) {
3343 assert(bus);
3344
3345 return sd_bus_emit_properties_changed_strv(bus,
3346 "/org/freedesktop/systemd1",
3347 "org.freedesktop.systemd1.Manager",
3348 NULL);
3349}
39abcaee 3350
03455c28
LDM		 3351void bus_manager_send_change_signal(Manager *m) {
3352 int r;
3353
3354 assert(m);
3355
3356 r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
3357 if (r < 0)
3358 log_debug_errno(r, "Failed to send manager change signal: %m");
718db961 3359}
Unnamed repository; edit this file 'description' to name the repository.