]> 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
Merge pull request #26783 from yuwata/loop-ref-follow-up
[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
e0e7bc82
LB		 656static int method_get_unit_by_pidfd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
657 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
658 Manager *m = ASSERT_PTR(userdata);
659 _cleanup_free_ char *path = NULL;
660 int r, pidfd;
f840c7d5 661 pid_t pid;
e0e7bc82
LB		 662 Unit *u;
663
664 assert(message);
665
666 r = sd_bus_message_read(message, "h", &pidfd);
667 if (r < 0)
668 return r;
669
f840c7d5 670 r = pidfd_get_pid(pidfd, &pid);
e0e7bc82
LB		 671 if (r < 0)
672 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
673
f840c7d5 674 u = manager_get_unit_by_pid(m, pid);
e0e7bc82 675 if (!u)
f840c7d5 676 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pid);
e0e7bc82
LB		 677
678 r = mac_selinux_unit_access_check(u, message, "status", error);
679 if (r < 0)
680 return r;
681
682 path = unit_dbus_path(u);
683 if (!path)
684 return log_oom();
685
686 r = sd_bus_message_new_method_return(message, &reply);
687 if (r < 0)
688 return r;
689
690 r = sd_bus_message_append(reply, "os", path, u->id);
691 if (r < 0)
692 return r;
693
694 r = sd_bus_message_append_array(reply, 'y', u->invocation_id.bytes, sizeof(u->invocation_id.bytes));
695 if (r < 0)
696 return r;
697
698 /* Double-check that the process is still alive and that the PID did not change before returning the
699 * answer. */
f840c7d5
LB		 700 r = pidfd_verify_pid(pidfd, pid);
701 if (r == -ESRCH)
e0e7bc82
LB		 702 return sd_bus_error_setf(error,
703 BUS_ERROR_NO_SUCH_PROCESS,
f840c7d5
LB		 704 "The PIDFD's PID "PID_FMT" changed during the lookup operation.",
705 pid);
706 if (r < 0)
707 return sd_bus_error_set_errnof(error, r, "Failed to get PID from PIDFD: %m");
e0e7bc82
LB		 708
709 return sd_bus_send(NULL, reply, NULL);
710}
711
19070062 712static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 713 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 714 const char *name;
715 Unit *u;
716 int r;
c0576cd6 717
718db961 718 assert(message);
718db961 719
283868e1
SW		 720 /* Anyone can call this method */
721
718db961
LP		 722 r = sd_bus_message_read(message, "s", &name);
723 if (r < 0)
ebcf1f97 724 return r;
c0576cd6 725
96cc4453
LP		 726 r = bus_load_unit_by_name(m, message, name, &u, error);
727 if (r < 0)
728 return r;
718db961 729
4659bf6f 730 return reply_unit_path(u, message, error);
c0576cd6
LP		 731}
732
19070062 733static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
718db961
LP		 734 const char *name;
735 Unit *u;
c0576cd6
LP		 736 int r;
737
718db961
LP		 738 assert(message);
739 assert(m);
c0576cd6 740
718db961
LP		 741 r = sd_bus_message_read(message, "s", &name);
742 if (r < 0)
ebcf1f97 743 return r;
c0576cd6 744
ebcf1f97 745 r = manager_load_unit(m, name, NULL, error, &u);
718db961 746 if (r < 0)
ebcf1f97 747 return r;
718db961 748
19070062 749 return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
c0576cd6
LP		 750}
751
19070062 752static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 753 return method_start_unit_generic(message, userdata, JOB_START, /* reload_if_possible = */ false, error);
718db961 754}
c757a65b 755
19070062 756static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 757 return method_start_unit_generic(message, userdata, JOB_STOP, /* reload_if_possible = */ false, error);
718db961 758}
c757a65b 759
19070062 760static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 761 return method_start_unit_generic(message, userdata, JOB_RELOAD, /* reload_if_possible = */ false, error);
718db961 762}
c757a65b 763
19070062 764static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 765 return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ false, error);
c757a65b
LP		 766}
767
19070062 768static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 769 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ false, error);
718db961 770}
d200735e 771
19070062 772static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 773 return method_start_unit_generic(message, userdata, JOB_RESTART, /* reload_if_possible = */ true, error);
718db961 774}
d200735e 775
19070062 776static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 777 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, /* reload_if_possible = */ true, error);
718db961 778}
d200735e 779
42561fc9
LP		 780typedef enum GenericUnitOperationFlags {
781 GENERIC_UNIT_LOAD = 1 << 0, /* Load if the unit is not loaded yet */
782 GENERIC_UNIT_VALIDATE_LOADED = 1 << 1, /* Verify unit is properly loaded before forwarding call */
783} GenericUnitOperationFlags;
784
785static int method_generic_unit_operation(
786 sd_bus_message *message,
787 Manager *m,
788 sd_bus_error *error,
789 sd_bus_message_handler_t handler,
790 GenericUnitOperationFlags flags) {
791
50cbaba4
LP		 792 const char *name;
793 Unit *u;
794 int r;
795
796 assert(message);
797 assert(m);
798
42561fc9
LP		 799 /* Read the first argument from the command and pass the operation to the specified per-unit
800 * method. */
801
50cbaba4
LP		 802 r = sd_bus_message_read(message, "s", &name);
803 if (r < 0)
804 return r;
805
42561fc9
LP		 806 if (!isempty(name) && FLAGS_SET(flags, GENERIC_UNIT_LOAD))
807 r = manager_load_unit(m, name, NULL, error, &u);
808 else
809 r = bus_get_unit_by_name(m, message, name, &u, error);
50cbaba4
LP		 810 if (r < 0)
811 return r;
812
42561fc9
LP		 813 if (FLAGS_SET(flags, GENERIC_UNIT_VALIDATE_LOADED)) {
814 r = bus_unit_validate_load_state(u, error);
815 if (r < 0)
816 return r;
817 }
818
819 return handler(message, u, error);
820}
821
822static int method_enqueue_unit_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
823 /* We don't bother with GENERIC_UNIT_VALIDATE_LOADED here, as the job logic validates that anyway */
824 return method_generic_unit_operation(message, userdata, error, bus_unit_method_enqueue_job, GENERIC_UNIT_LOAD);
50cbaba4
LP		 825}
826
19070062 827static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 828 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 829 const char *old_name;
830 Unit *u;
1adf1049 831 int r;
ea430986 832
ea430986 833 assert(message);
ea430986 834
718db961
LP		 835 r = sd_bus_message_read(message, "s", &old_name);
836 if (r < 0)
ebcf1f97 837 return r;
ea430986 838
96cc4453
LP		 839 r = bus_get_unit_by_name(m, message, old_name, &u, error);
840 if (r < 0)
841 return r;
842 if (!u->job || u->job->type != JOB_START)
ebcf1f97 843 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
c0576cd6 844
2d8cc7a7 845 return method_start_unit_generic(message, m, JOB_START, /* reload_if_possible = */ false, error);
718db961 846}
ea430986 847
19070062 848static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 849 /* We don't bother with GENERIC_UNIT_LOAD nor GENERIC_UNIT_VALIDATE_LOADED here, as it shouldn't
850 * matter whether a unit is loaded for killing any processes possibly in the unit's cgroup. */
851 return method_generic_unit_operation(message, userdata, error, bus_unit_method_kill, 0);
718db961 852}
8a0867d6 853
4d3bac56
LP		 854static int method_clean_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
855 /* Load the unit if necessary, in order to load it, and insist on the unit being loaded to be
856 * cleaned */
857 return method_generic_unit_operation(message, userdata, error, bus_unit_method_clean, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
858}
859
d9e45bc3
MS		 860static int method_freeze_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
861 return method_generic_unit_operation(message, userdata, error, bus_unit_method_freeze, 0);
862}
863
864static int method_thaw_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
865 return method_generic_unit_operation(message, userdata, error, bus_unit_method_thaw, 0);
866}
867
19070062 868static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 869 /* Don't load the unit (because unloaded units can't be in failed state), and don't insist on the
870 * unit to be loaded properly (since a failed unit might have its unit file disappeared) */
871 return method_generic_unit_operation(message, userdata, error, bus_unit_method_reset_failed, 0);
718db961 872}
5dd9014f 873
19070062 874static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 875 /* Only change properties on fully loaded units, and load them in order to set properties */
876 return method_generic_unit_operation(message, userdata, error, bus_unit_method_set_properties, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
718db961
LP		 877}
878
5e8deb94
LB		 879static int method_bind_mount_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
880 /* Only add mounts on fully loaded units */
881 return method_generic_unit_operation(message, userdata, error, bus_service_method_bind_mount, GENERIC_UNIT_VALIDATE_LOADED);
882}
883
af477139
LB		 884static int method_mount_image_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
885 /* Only add mounts on fully loaded units */
886 return method_generic_unit_operation(message, userdata, error, bus_service_method_mount_image, GENERIC_UNIT_VALIDATE_LOADED);
887}
888
05a98afd 889static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 890 /* Only allow reffing of fully loaded units, and make sure reffing a unit loads it. */
891 return method_generic_unit_operation(message, userdata, error, bus_unit_method_ref, GENERIC_UNIT_LOAD|GENERIC_UNIT_VALIDATE_LOADED);
05a98afd
LP		 892}
893
894static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 895 /* Dropping a ref OTOH should not require the unit to still be loaded. And since a reffed unit is a
896 * loaded unit there's no need to load the unit for unreffing it. */
897 return method_generic_unit_operation(message, userdata, error, bus_unit_method_unref, 0);
05a98afd
LP		 898}
899
6900c740 900static int reply_unit_info(sd_bus_message *reply, Unit *u) {
901 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
902 Unit *following;
903
904 following = unit_following(u);
905
906 unit_path = unit_dbus_path(u);
907 if (!unit_path)
908 return -ENOMEM;
909
910 if (u->job) {
911 job_path = job_dbus_path(u->job);
912 if (!job_path)
913 return -ENOMEM;
914 }
915
916 return sd_bus_message_append(
917 reply, "(ssssssouso)",
918 u->id,
919 unit_description(u),
920 unit_load_state_to_string(u->load_state),
921 unit_active_state_to_string(unit_active_state(u)),
922 unit_sub_state_to_string(u),
923 following ? following->id : "",
924 unit_path,
925 u->job ? u->job->id : 0,
926 u->job ? job_type_to_string(u->job->type) : "",
c1d95b71 927 empty_to_root(job_path));
6900c740 928}
929
930static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
931 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 932 Manager *m = ASSERT_PTR(userdata);
6900c740 933 int r;
6900c740 934 _cleanup_strv_free_ char **units = NULL;
935
936 assert(message);
6900c740 937
938 r = sd_bus_message_read_strv(message, &units);
939 if (r < 0)
940 return r;
941
942 r = sd_bus_message_new_method_return(message, &reply);
943 if (r < 0)
944 return r;
945
946 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
947 if (r < 0)
948 return r;
949
950 STRV_FOREACH(unit, units) {
951 Unit *u;
952
953 if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
954 continue;
955
96cc4453 956 r = bus_load_unit_by_name(m, message, *unit, &u, error);
6900c740 957 if (r < 0)
958 return r;
959
960 r = reply_unit_info(reply, u);
961 if (r < 0)
962 return r;
963 }
964
965 r = sd_bus_message_close_container(reply);
966 if (r < 0)
967 return r;
968
969 return sd_bus_send(NULL, reply, NULL);
970}
971
291d565a 972static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 973 /* Don't load a unit (since it won't have any processes if it's not loaded), but don't insist on the
974 * unit being loaded (because even improperly loaded units might still have processes around */
975 return method_generic_unit_operation(message, userdata, error, bus_unit_method_get_processes, 0);
291d565a
LP		 976}
977
6592b975 978static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
42561fc9
LP		 979 /* Don't allow attaching new processes to units that aren't loaded. Don't bother with loading a unit
980 * for this purpose though, as an unloaded unit is a stopped unit, and we don't allow attaching
981 * processes to stopped units anyway. */
982 return method_generic_unit_operation(message, userdata, error, bus_unit_method_attach_processes, GENERIC_UNIT_VALIDATE_LOADED);
6592b975
LP		 983}
984
ab31f6b8
WC		 985static int transient_unit_from_message(
986 Manager *m,
987 sd_bus_message *message,
988 const char *name,
989 Unit **unit,
990 sd_bus_error *error) {
991
06cc6afa 992 UnitType t;
ab31f6b8
WC		 993 Unit *u;
994 int r;
995
996 assert(m);
997 assert(message);
998 assert(name);
999
06cc6afa
LP		 1000 t = unit_name_to_type(name);
1001 if (t < 0)
cb31470f
ZJS		 1002 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1003 "Invalid unit name or type.");
06cc6afa
LP		 1004
1005 if (!unit_vtable[t]->can_transient)
cb31470f
ZJS		 1006 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1007 "Unit type %s does not support transient units.",
1008 unit_type_to_string(t));
06cc6afa 1009
ab31f6b8
WC		 1010 r = manager_load_unit(m, name, NULL, error, &u);
1011 if (r < 0)
1012 return r;
1013
0f13f3bd 1014 if (!unit_is_pristine(u))
cb31470f 1015 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
1f832446 1016 "Unit %s was already loaded or has a fragment file.", name);
ab31f6b8
WC		 1017
1018 /* OK, the unit failed to load and is unreferenced, now let's
1019 * fill in the transient data instead */
1020 r = unit_make_transient(u);
1021 if (r < 0)
1022 return r;
1023
1024 /* Set our properties */
1025 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
1026 if (r < 0)
1027 return r;
1028
05a98afd
LP		 1029 /* If the client asked for it, automatically add a reference to this unit. */
1030 if (u->bus_track_add) {
1031 r = bus_unit_track_add_sender(u, message);
1032 if (r < 0)
1033 return log_error_errno(r, "Failed to watch sender: %m");
1034 }
1035
97329d20 1036 /* Now load the missing bits of the unit we just created */
4f952a3f 1037 unit_add_to_load_queue(u);
97329d20
LP		 1038 manager_dispatch_load_queue(m);
1039
ab31f6b8
WC		 1040 *unit = u;
1041
1042 return 0;
1043}
1044
1045static int transient_aux_units_from_message(
1046 Manager *m,
1047 sd_bus_message *message,
1048 sd_bus_error *error) {
1049
ab31f6b8
WC		 1050 int r;
1051
1052 assert(m);
1053 assert(message);
1054
1055 r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
1056 if (r < 0)
1057 return r;
1058
1059 while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
97329d20
LP		 1060 const char *name = NULL;
1061 Unit *u;
1062
ab31f6b8
WC		 1063 r = sd_bus_message_read(message, "s", &name);
1064 if (r < 0)
1065 return r;
1066
1067 r = transient_unit_from_message(m, message, name, &u, error);
97329d20 1068 if (r < 0)
ab31f6b8
WC		 1069 return r;
1070
ab31f6b8
WC		 1071 r = sd_bus_message_exit_container(message);
1072 if (r < 0)
1073 return r;
1074 }
1075 if (r < 0)
1076 return r;
1077
1078 r = sd_bus_message_exit_container(message);
1079 if (r < 0)
1080 return r;
1081
1082 return 0;
1083}
1084
19070062 1085static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1086 const char *name, *smode;
99534007 1087 Manager *m = ASSERT_PTR(userdata);
718db961 1088 JobMode mode;
718db961
LP		 1089 Unit *u;
1090 int r;
ea430986 1091
718db961 1092 assert(message);
ea430986 1093
1d22e906 1094 r = mac_selinux_access_check(message, "start", error);
283868e1
SW		 1095 if (r < 0)
1096 return r;
283868e1 1097
718db961
LP		 1098 r = sd_bus_message_read(message, "ss", &name, &smode);
1099 if (r < 0)
ebcf1f97 1100 return r;
5632e374 1101
718db961
LP		 1102 mode = job_mode_from_string(smode);
1103 if (mode < 0)
ebcf1f97 1104 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
5632e374 1105
1d22e906 1106 r = bus_verify_manage_units_async(m, message, error);
718db961 1107 if (r < 0)
ebcf1f97 1108 return r;
1d22e906
LP		 1109 if (r == 0)
1110 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
5632e374 1111
ab31f6b8 1112 r = transient_unit_from_message(m, message, name, &u, error);
ebcf1f97
LP		 1113 if (r < 0)
1114 return r;
5632e374 1115
ab31f6b8 1116 r = transient_aux_units_from_message(m, message, error);
718db961 1117 if (r < 0)
ebcf1f97 1118 return r;
ea430986 1119
718db961 1120 /* Finally, start it */
50cbaba4 1121 return bus_unit_queue_job(message, u, JOB_START, mode, 0, error);
718db961 1122}
ea430986 1123
19070062 1124static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1125 _cleanup_free_ char *path = NULL;
99534007 1126 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1127 uint32_t id;
1128 Job *j;
1129 int r;
ea430986 1130
718db961 1131 assert(message);
ea430986 1132
283868e1
SW		 1133 /* Anyone can call this method */
1134
718db961
LP		 1135 r = sd_bus_message_read(message, "u", &id);
1136 if (r < 0)
ebcf1f97 1137 return r;
ea430986 1138
718db961
LP		 1139 j = manager_get_job(m, id);
1140 if (!j)
ebcf1f97 1141 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1142
8a188de9 1143 r = mac_selinux_unit_access_check(j->unit, message, "status", error);
ebcf1f97
LP		 1144 if (r < 0)
1145 return r;
ea430986 1146
718db961
LP		 1147 path = job_dbus_path(j);
1148 if (!path)
ebcf1f97 1149 return -ENOMEM;
ea430986 1150
df2d202e 1151 return sd_bus_reply_method_return(message, "o", path);
718db961 1152}
ea430986 1153
19070062 1154static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1155 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1156 uint32_t id;
1157 Job *j;
1158 int r;
ea430986 1159
718db961 1160 assert(message);
ea430986 1161
718db961
LP		 1162 r = sd_bus_message_read(message, "u", &id);
1163 if (r < 0)
ebcf1f97 1164 return r;
ea430986 1165
718db961
LP		 1166 j = manager_get_job(m, id);
1167 if (!j)
ebcf1f97 1168 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
ea430986 1169
19070062 1170 return bus_job_method_cancel(message, j, error);
718db961 1171}
c1e1601e 1172
19070062 1173static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1174 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1175 int r;
c1e1601e 1176
718db961 1177 assert(message);
c1e1601e 1178
1d22e906 1179 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1180 if (r < 0)
1181 return r;
1182
1d22e906
LP		 1183 r = bus_verify_manage_units_async(m, message, error);
1184 if (r < 0)
1185 return r;
1186 if (r == 0)
1187 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1188
718db961 1189 manager_clear_jobs(m);
c1e1601e 1190
df2d202e 1191 return sd_bus_reply_method_return(message, NULL);
718db961 1192}
c1e1601e 1193
19070062 1194static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1195 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1196 int r;
cad45ba1 1197
718db961 1198 assert(message);
718db961 1199
8a188de9 1200 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1201 if (r < 0)
1202 return r;
1203
1d22e906
LP		 1204 r = bus_verify_manage_units_async(m, message, error);
1205 if (r < 0)
1206 return r;
1207 if (r == 0)
1208 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1209
718db961 1210 manager_reset_failed(m);
c1e1601e 1211
df2d202e 1212 return sd_bus_reply_method_return(message, NULL);
718db961 1213}
c1e1601e 1214
313fe66f 1215static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 1216 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1217 Manager *m = ASSERT_PTR(userdata);
718db961 1218 const char *k;
718db961
LP		 1219 Unit *u;
1220 int r;
c1e1601e 1221
718db961 1222 assert(message);
b152adec 1223
283868e1
SW		 1224 /* Anyone can call this method */
1225
8a188de9 1226 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1227 if (r < 0)
1228 return r;
cad45ba1 1229
df2d202e 1230 r = sd_bus_message_new_method_return(message, &reply);
718db961 1231 if (r < 0)
ebcf1f97 1232 return r;
b152adec 1233
718db961
LP		 1234 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
1235 if (r < 0)
ebcf1f97 1236 return r;
b152adec 1237
90e74a66 1238 HASHMAP_FOREACH_KEY(u, k, m->units) {
718db961
LP		 1239 if (k != u->id)
1240 continue;
b152adec 1241
cdc06ed7
DS		 1242 if (!strv_isempty(states) &&
1243 !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
1244 !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
1245 !strv_contains(states, unit_sub_state_to_string(u)))
1246 continue;
1247
313fe66f 1248 if (!strv_isempty(patterns) &&
1249 !strv_fnmatch_or_empty(patterns, u->id, FNM_NOESCAPE))
1250 continue;
1251
6900c740 1252 r = reply_unit_info(reply, u);
718db961 1253 if (r < 0)
ebcf1f97 1254 return r;
718db961 1255 }
4139c1b2 1256
718db961
LP		 1257 r = sd_bus_message_close_container(reply);
1258 if (r < 0)
ebcf1f97 1259 return r;
cad45ba1 1260
9030ca46 1261 return sd_bus_send(NULL, reply, NULL);
718db961 1262}
4139c1b2 1263
19070062 1264static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
313fe66f 1265 return list_units_filtered(message, userdata, error, NULL, NULL);
cdc06ed7
DS		 1266}
1267
19070062 1268static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cdc06ed7
DS		 1269 _cleanup_strv_free_ char **states = NULL;
1270 int r;
1271
1272 r = sd_bus_message_read_strv(message, &states);
1273 if (r < 0)
1274 return r;
1275
313fe66f 1276 return list_units_filtered(message, userdata, error, states, NULL);
1277}
1278
1279static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1280 _cleanup_strv_free_ char **states = NULL;
1281 _cleanup_strv_free_ char **patterns = NULL;
1282 int r;
1283
1284 r = sd_bus_message_read_strv(message, &states);
1285 if (r < 0)
1286 return r;
1287
1288 r = sd_bus_message_read_strv(message, &patterns);
1289 if (r < 0)
1290 return r;
1291
1292 return list_units_filtered(message, userdata, error, states, patterns);
cdc06ed7
DS		 1293}
1294
19070062 1295static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
4afd3348 1296 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1297 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1298 Job *j;
1299 int r;
4139c1b2 1300
718db961 1301 assert(message);
718db961 1302
283868e1
SW		 1303 /* Anyone can call this method */
1304
8a188de9 1305 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1306 if (r < 0)
1307 return r;
718db961 1308
df2d202e 1309 r = sd_bus_message_new_method_return(message, &reply);
718db961 1310 if (r < 0)
ebcf1f97 1311 return r;
718db961
LP		 1312
1313 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
1314 if (r < 0)
ebcf1f97 1315 return r;
718db961 1316
90e74a66 1317 HASHMAP_FOREACH(j, m->jobs) {
718db961
LP		 1318 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
1319
1320 job_path = job_dbus_path(j);
1321 if (!job_path)
ebcf1f97 1322 return -ENOMEM;
718db961
LP		 1323
1324 unit_path = unit_dbus_path(j->unit);
1325 if (!unit_path)
ebcf1f97 1326 return -ENOMEM;
718db961
LP		 1327
1328 r = sd_bus_message_append(
1329 reply, "(usssoo)",
1330 j->id,
1302759d 1331 j->unit->id,
718db961 1332 job_type_to_string(j->type),
1302759d 1333 job_state_to_string(j->state),
718db961
LP		 1334 job_path,
1335 unit_path);
cad45ba1 1336 if (r < 0)
ebcf1f97 1337 return r;
718db961 1338 }
5dd9014f 1339
718db961
LP		 1340 r = sd_bus_message_close_container(reply);
1341 if (r < 0)
ebcf1f97 1342 return r;
5dd9014f 1343
9030ca46 1344 return sd_bus_send(NULL, reply, NULL);
718db961 1345}
5dd9014f 1346
19070062 1347static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1348 Manager *m = ASSERT_PTR(userdata);
718db961 1349 int r;
5dd9014f 1350
718db961 1351 assert(message);
ea430986 1352
283868e1
SW		 1353 /* Anyone can call this method */
1354
8a188de9 1355 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1356 if (r < 0)
1357 return r;
cad45ba1 1358
19070062 1359 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1360
1361 /* Note that direct bus connection subscribe by
1362 * default, we only track peers on the API bus here */
1363
1364 if (!m->subscribed) {
19070062 1365 r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
8f8f05a9
LP		 1366 if (r < 0)
1367 return r;
1368 }
1369
1370 r = sd_bus_track_add_sender(m->subscribed, message);
1371 if (r < 0)
1372 return r;
1373 if (r == 0)
1b09b81c 1374 return sd_bus_error_set(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
8f8f05a9 1375 }
ea430986 1376
df2d202e 1377 return sd_bus_reply_method_return(message, NULL);
718db961 1378}
ea430986 1379
19070062 1380static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1381 Manager *m = ASSERT_PTR(userdata);
718db961 1382 int r;
ea430986 1383
718db961 1384 assert(message);
ea430986 1385
283868e1
SW		 1386 /* Anyone can call this method */
1387
8a188de9 1388 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1389 if (r < 0)
1390 return r;
ea430986 1391
19070062 1392 if (sd_bus_message_get_bus(message) == m->api_bus) {
8f8f05a9
LP		 1393 r = sd_bus_track_remove_sender(m->subscribed, message);
1394 if (r < 0)
1395 return r;
1396 if (r == 0)
1b09b81c 1397 return sd_bus_error_set(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
8f8f05a9 1398 }
ea430986 1399
df2d202e 1400 return sd_bus_reply_method_return(message, NULL);
718db961 1401}
ea430986 1402
d1d8786c
FB		 1403static int dump_impl(
1404 sd_bus_message *message,
1405 void *userdata,
1406 sd_bus_error *error,
1407 char **patterns,
1408 int (*reply)(sd_bus_message *, char *)) {
1409
718db961 1410 _cleanup_free_ char *dump = NULL;
99534007 1411 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1412 int r;
ea430986 1413
718db961 1414 assert(message);
ea430986 1415
283868e1
SW		 1416 /* Anyone can call this method */
1417
8a188de9 1418 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1419 if (r < 0)
1420 return r;
ea430986 1421
d1d8786c 1422 r = manager_get_dump_string(m, patterns, &dump);
dacd6cee
LP		 1423 if (r < 0)
1424 return r;
a16e1123 1425
c0a1bfac
DT		 1426 return reply(message, dump);
1427}
1428
1429static int reply_dump(sd_bus_message *message, char *dump) {
df2d202e 1430 return sd_bus_reply_method_return(message, "s", dump);
718db961 1431}
cad45ba1 1432
c0a1bfac 1433static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c 1434 return dump_impl(message, userdata, error, NULL, reply_dump);
c0a1bfac
DT		 1435}
1436
1437static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
254d1313 1438 _cleanup_close_ int fd = -EBADF;
c0a1bfac
DT		 1439
1440 fd = acquire_data_fd(dump, strlen(dump), 0);
1441 if (fd < 0)
1442 return fd;
1443
1444 return sd_bus_reply_method_return(message, "h", fd);
1445}
1446
1447static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c
FB		 1448 return dump_impl(message, userdata, error, NULL, reply_dump_by_fd);
1449}
1450
f6cce15b
ZJS		 1451static int dump_units_matching_patterns(
1452 sd_bus_message *message,
1453 void *userdata,
1454 sd_bus_error *error,
1455 int (*reply)(sd_bus_message *, char *)) {
d1d8786c
FB		 1456 _cleanup_strv_free_ char **patterns = NULL;
1457 int r;
1458
1459 r = sd_bus_message_read_strv(message, &patterns);
1460 if (r < 0)
1461 return r;
1462
f6cce15b
ZJS		 1463 return dump_impl(message, userdata, error, patterns, reply);
1464}
1465
1466static int method_dump_units_matching_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1467 return dump_units_matching_patterns(message, userdata, error, reply_dump);
1468}
1469
1470static int method_dump_units_matching_patterns_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1471 return dump_units_matching_patterns(message, userdata, error, reply_dump_by_fd);
c0a1bfac
DT		 1472}
1473
36b4a7ba 1474static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1b09b81c 1475 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
718db961 1476}
cad45ba1 1477
ae57dad3
LP		 1478static int verify_run_space(const char *message, sd_bus_error *error) {
1479 struct statvfs svfs;
1480 uint64_t available;
1481
1482 if (statvfs("/run/systemd", &svfs) < 0)
1483 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1484
1485 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1486
2b59bf51 1487 if (available < RELOAD_DISK_SPACE_MIN)
ae57dad3
LP		 1488 return sd_bus_error_setf(error,
1489 BUS_ERROR_DISK_FULL,
1490 "%s, not enough space available on /run/systemd. "
1491 "Currently, %s are free, but a safety buffer of %s is enforced.",
1492 message,
2b59bf51
ZJS		 1493 FORMAT_BYTES(available),
1494 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3
LP		 1495
1496 return 0;
1497}
1498
1499int verify_run_space_and_log(const char *message) {
4dae8ae6 1500 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ae57dad3
LP		 1501 int r;
1502
1503 r = verify_run_space(message, &error);
1504 if (r < 0)
4ae25393 1505 return log_error_errno(r, "%s", bus_error_message(&error, r));
ae57dad3 1506
4ae25393 1507 return 0;
ae57dad3
LP		 1508}
1509
4895bacc 1510static void log_caller(sd_bus_message *message, Manager *manager, const char *method) {
9524c2fd
LB		 1511 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1512 const char *comm = NULL;
1513 Unit *caller;
1514 pid_t pid;
1515
1516 assert(message);
1517 assert(manager);
4895bacc 1518 assert(method);
9524c2fd
LB		 1519
1520 if (sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID|SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_COMM, &creds) < 0)
1521 return;
1522
1523 /* We need at least the PID, otherwise there's nothing to log, the rest is optional */
1524 if (sd_bus_creds_get_pid(creds, &pid) < 0)
1525 return;
1526
1527 (void) sd_bus_creds_get_comm(creds, &comm);
1528 caller = manager_get_unit_by_pid(manager, pid);
1529
1980a25d
ZJS		 1530 log_info("%s requested from client PID " PID_FMT "%s%s%s%s%s%s...",
1531 method, pid,
1532 comm ? " ('" : "", strempty(comm), comm ? "')" : "",
add74820 1533 caller ? " (unit " : "", caller ? caller->id : "", caller ? ")" : "");
9524c2fd
LB		 1534}
1535
19070062 1536static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1537 Manager *m = ASSERT_PTR(userdata);
718db961 1538 int r;
6652a2b9 1539
718db961 1540 assert(message);
6652a2b9 1541
ae57dad3
LP		 1542 r = verify_run_space("Refusing to reload", error);
1543 if (r < 0)
1544 return r;
1545
1d22e906 1546 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1547 if (r < 0)
1548 return r;
283868e1 1549
1d22e906 1550 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1551 if (r < 0)
1552 return r;
1d22e906
LP		 1553 if (r == 0)
1554 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
6652a2b9 1555
9524c2fd 1556 /* Write a log message noting the unit or process who requested the Reload() */
4895bacc 1557 log_caller(message, m, "Reloading");
9524c2fd 1558
856bfaeb
LB		 1559 /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1560 if (!ratelimit_below(&m->reload_ratelimit)) {
1561 log_warning("Reloading request rejected due to rate limit.");
1562 return sd_bus_error_setf(error,
1563 SD_BUS_ERROR_LIMITS_EXCEEDED,
1564 "Reload() request rejected due to rate limit.");
1565 }
1566
718db961
LP		 1567 /* Instead of sending the reply back right away, we just
1568 * remember that we need to and then send it after the reload
1569 * is finished. That way the caller knows when the reload
1570 * finished. */
6652a2b9 1571
209de525
LP		 1572 assert(!m->pending_reload_message);
1573 r = sd_bus_message_new_method_return(message, &m->pending_reload_message);
718db961 1574 if (r < 0)
ebcf1f97 1575 return r;
cad45ba1 1576
af41e508 1577 m->objective = MANAGER_RELOAD;
6652a2b9 1578
718db961
LP		 1579 return 1;
1580}
6652a2b9 1581
19070062 1582static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1583 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1584 int r;
6652a2b9 1585
718db961 1586 assert(message);
6652a2b9 1587
ae57dad3
LP		 1588 r = verify_run_space("Refusing to reexecute", error);
1589 if (r < 0)
1590 return r;
1591
1d22e906 1592 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1593 if (r < 0)
1594 return r;
283868e1 1595
1d22e906 1596 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1597 if (r < 0)
1598 return r;
1d22e906
LP		 1599 if (r == 0)
1600 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
cad45ba1 1601
4895bacc
LB		 1602 /* Write a log message noting the unit or process who requested the Reexecute() */
1603 log_caller(message, m, "Reexecuting");
1604
718db961
LP		 1605 /* We don't send a reply back here, the client should
1606 * just wait for us disconnecting. */
6652a2b9 1607
af41e508 1608 m->objective = MANAGER_REEXECUTE;
718db961
LP		 1609 return 1;
1610}
6652a2b9 1611
19070062 1612static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1613 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1614 int r;
6652a2b9 1615
718db961 1616 assert(message);
6652a2b9 1617
8a188de9 1618 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1619 if (r < 0)
1620 return r;
cad45ba1 1621
287419c1
AC		 1622 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1623 * we are running on the host. It will fall back on reboot() in
1624 * systemd-shutdown if it cannot do the exit() because it isn't a
1625 * container. */
6652a2b9 1626
af41e508 1627 m->objective = MANAGER_EXIT;
6652a2b9 1628
df2d202e 1629 return sd_bus_reply_method_return(message, NULL);
718db961 1630}
6652a2b9 1631
19070062 1632static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1633 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1634 int r;
664f88a7 1635
718db961 1636 assert(message);
cad45ba1 1637
8a188de9 1638 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1639 if (r < 0)
1640 return r;
664f88a7 1641
463d0d15 1642 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1643 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1644 "Reboot is only supported for system managers.");
664f88a7 1645
af41e508 1646 m->objective = MANAGER_REBOOT;
664f88a7 1647
df2d202e 1648 return sd_bus_reply_method_return(message, NULL);
718db961 1649}
664f88a7 1650
19070062 1651static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1652 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1653 int r;
50913bc0 1654
718db961 1655 assert(message);
1137a57c 1656
8a188de9 1657 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1658 if (r < 0)
1659 return r;
1137a57c 1660
463d0d15 1661 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1662 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1663 "Powering off is only supported for system managers.");
1137a57c 1664
af41e508 1665 m->objective = MANAGER_POWEROFF;
1137a57c 1666
df2d202e 1667 return sd_bus_reply_method_return(message, NULL);
718db961 1668}
1137a57c 1669
19070062 1670static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1671 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1672 int r;
1137a57c 1673
718db961 1674 assert(message);
8d0e38a2 1675
8a188de9 1676 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1677 if (r < 0)
1678 return r;
cad45ba1 1679
463d0d15 1680 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1681 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1682 "Halt is only supported for system managers.");
8d0e38a2 1683
af41e508 1684 m->objective = MANAGER_HALT;
8d0e38a2 1685
df2d202e 1686 return sd_bus_reply_method_return(message, NULL);
718db961 1687}
8d0e38a2 1688
19070062 1689static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1690 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1691 int r;
8d0e38a2 1692
718db961 1693 assert(message);
c0576cd6 1694
8a188de9 1695 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1696 if (r < 0)
1697 return r;
cad45ba1 1698
463d0d15 1699 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1700 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1701 "KExec is only supported for system managers.");
c0576cd6 1702
af41e508 1703 m->objective = MANAGER_KEXEC;
c0576cd6 1704
df2d202e 1705 return sd_bus_reply_method_return(message, NULL);
718db961 1706}
c0576cd6 1707
19070062 1708static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
87a19bfe 1709 _cleanup_free_ char *ri = NULL, *rt = NULL;
718db961 1710 const char *root, *init;
99534007 1711 Manager *m = ASSERT_PTR(userdata);
ae57dad3
LP		 1712 struct statvfs svfs;
1713 uint64_t available;
718db961 1714 int r;
c0576cd6 1715
718db961 1716 assert(message);
c0576cd6 1717
ae57dad3
LP		 1718 if (statvfs("/run/systemd", &svfs) < 0)
1719 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1720
1721 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1722
2b59bf51 1723 if (available < RELOAD_DISK_SPACE_MIN)
cb31470f 1724 log_warning("Dangerously low amount of free space on /run/systemd, root switching might fail.\n"
ae57dad3 1725 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
2b59bf51
ZJS		 1726 FORMAT_BYTES(available),
1727 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3 1728
8a188de9 1729 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1730 if (r < 0)
1731 return r;
c0576cd6 1732
463d0d15 1733 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1734 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1735 "Root switching is only supported by system manager.");
c0576cd6 1736
718db961
LP		 1737 r = sd_bus_message_read(message, "ss", &root, &init);
1738 if (r < 0)
ebcf1f97 1739 return r;
c0576cd6 1740
5f4c9c27 1741 if (!path_is_valid(root))
cb31470f 1742 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
5f4c9c27 1743 "New root directory must be a valid path.");
710028b4 1744 if (!path_is_absolute(root))
cb31470f
ZJS		 1745 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1746 "New root path '%s' is not absolute.", root);
710028b4 1747 if (path_equal(root, "/"))
cb31470f
ZJS		 1748 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1749 "New root directory cannot be the old root directory.");
c0576cd6 1750
718db961
LP		 1751 /* Safety check */
1752 if (isempty(init)) {
710028b4
LP		 1753 r = path_is_os_tree(root);
1754 if (r < 0)
cb31470f
ZJS		 1755 return sd_bus_error_set_errnof(error, r,
1756 "Failed to determine whether root path '%s' contains an OS tree: %m",
1757 root);
710028b4 1758 if (r == 0)
cb31470f
ZJS		 1759 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1760 "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1761 root);
718db961 1762 } else {
5f4c9c27
LP		 1763 if (!path_is_valid(init))
1764 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1765 "Path to init binary '%s' is not a valid path.", init);
1766
718db961 1767 if (!path_is_absolute(init))
cb31470f
ZJS		 1768 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1769 "Path to init binary '%s' not absolute.", init);
c0576cd6 1770
06344330 1771 r = chase_symlinks_and_access(init, root, CHASE_PREFIX_ROOT, X_OK, NULL);
e10086ac
LP		 1772 if (r == -EACCES)
1773 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1774 "Init binary %s is not executable.", init);
710028b4 1775 if (r < 0)
cb31470f
ZJS		 1776 return sd_bus_error_set_errnof(error, r,
1777 "Could not resolve init executable %s: %m", init);
718db961
LP		 1778 }
1779
1780 rt = strdup(root);
1781 if (!rt)
ebcf1f97 1782 return -ENOMEM;
718db961
LP		 1783
1784 if (!isempty(init)) {
1785 ri = strdup(init);
87a19bfe 1786 if (!ri)
ebcf1f97 1787 return -ENOMEM;
718db961 1788 }
c0576cd6 1789
87a19bfe
YW		 1790 free_and_replace(m->switch_root, rt);
1791 free_and_replace(m->switch_root_init, ri);
c0576cd6 1792
af41e508 1793 m->objective = MANAGER_SWITCH_ROOT;
92b315df 1794
df2d202e 1795 return sd_bus_reply_method_return(message, NULL);
718db961 1796}
c0576cd6 1797
19070062 1798static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1799 _cleanup_strv_free_ char **plus = NULL;
99534007 1800 Manager *m = ASSERT_PTR(userdata);
718db961 1801 int r;
c0576cd6 1802
718db961 1803 assert(message);
cad45ba1 1804
8a188de9 1805 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1806 if (r < 0)
1807 return r;
c0576cd6 1808
718db961
LP		 1809 r = sd_bus_message_read_strv(message, &plus);
1810 if (r < 0)
ebcf1f97 1811 return r;
718db961 1812 if (!strv_env_is_valid(plus))
1b09b81c 1813 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
c0576cd6 1814
1d22e906
LP		 1815 r = bus_verify_set_environment_async(m, message, error);
1816 if (r < 0)
1817 return r;
1818 if (r == 0)
1819 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1820
1ad6e8b3 1821 r = manager_client_environment_modify(m, NULL, plus);
718db961 1822 if (r < 0)
ebcf1f97 1823 return r;
c0576cd6 1824
df2d202e 1825 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1826}
1827
19070062 1828static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1829 _cleanup_strv_free_ char **minus = NULL;
99534007 1830 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1831 int r;
1832
718db961 1833 assert(message);
718db961 1834
8a188de9 1835 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1836 if (r < 0)
1837 return r;
c0576cd6 1838
718db961
LP		 1839 r = sd_bus_message_read_strv(message, &minus);
1840 if (r < 0)
ebcf1f97 1841 return r;
718db961
LP		 1842
1843 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1844 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1845 "Invalid environment variable names or assignments");
718db961 1846
1d22e906
LP		 1847 r = bus_verify_set_environment_async(m, message, error);
1848 if (r < 0)
1849 return r;
1850 if (r == 0)
1851 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1852
1ad6e8b3 1853 r = manager_client_environment_modify(m, minus, NULL);
718db961 1854 if (r < 0)
ebcf1f97 1855 return r;
718db961 1856
df2d202e 1857 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1858}
1859
19070062 1860static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1861 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
99534007 1862 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1863 int r;
1864
718db961 1865 assert(message);
718db961 1866
8a188de9 1867 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1868 if (r < 0)
1869 return r;
718db961 1870
eb6c7d20 1871 r = sd_bus_message_read_strv(message, &minus);
718db961 1872 if (r < 0)
ebcf1f97 1873 return r;
718db961 1874
eb6c7d20 1875 r = sd_bus_message_read_strv(message, &plus);
718db961 1876 if (r < 0)
ebcf1f97 1877 return r;
718db961 1878
718db961 1879 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1880 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1881 "Invalid environment variable names or assignments");
eb6c7d20 1882 if (!strv_env_is_valid(plus))
cb31470f
ZJS		 1883 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1884 "Invalid environment assignments");
718db961 1885
1d22e906
LP		 1886 r = bus_verify_set_environment_async(m, message, error);
1887 if (r < 0)
1888 return r;
1889 if (r == 0)
1890 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1891
1ad6e8b3 1892 r = manager_client_environment_modify(m, minus, plus);
718db961 1893 if (r < 0)
ebcf1f97 1894 return r;
718db961 1895
df2d202e 1896 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1897}
1898
287419c1 1899static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1900 Manager *m = ASSERT_PTR(userdata);
29206d46 1901 uint8_t code;
287419c1
AC		 1902 int r;
1903
1904 assert(message);
287419c1
AC		 1905
1906 r = mac_selinux_access_check(message, "exit", error);
1907 if (r < 0)
1908 return r;
1909
1910 r = sd_bus_message_read_basic(message, 'y', &code);
1911 if (r < 0)
1912 return r;
1913
463d0d15 1914 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
1b09b81c 1915 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		 1916
1917 m->return_value = code;
1918
1919 return sd_bus_reply_method_return(message, NULL);
1920}
1921
29206d46 1922static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1923 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 1924 const char *name;
1925 uid_t uid;
1926 int r;
1927
1928 assert(message);
29206d46
LP		 1929
1930 r = sd_bus_message_read_basic(message, 's', &name);
1931 if (r < 0)
1932 return r;
1933
1934 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1935 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1936 "Dynamic users are only supported in the system instance.");
7a8867ab 1937 if (!valid_user_group_name(name, VALID_USER_RELAX))
cb31470f
ZJS		 1938 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1939 "User name invalid: %s", name);
29206d46
LP		 1940
1941 r = dynamic_user_lookup_name(m, name, &uid);
1942 if (r == -ESRCH)
cb31470f
ZJS		 1943 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
1944 "Dynamic user %s does not exist.", name);
29206d46
LP		 1945 if (r < 0)
1946 return r;
1947
1948 return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
1949}
1950
1951static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1952 _cleanup_free_ char *name = NULL;
99534007 1953 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 1954 uid_t uid;
1955 int r;
1956
1957 assert(message);
29206d46 1958
60d0a509 1959 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
29206d46
LP		 1960 r = sd_bus_message_read_basic(message, 'u', &uid);
1961 if (r < 0)
1962 return r;
1963
1964 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1965 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1966 "Dynamic users are only supported in the system instance.");
29206d46 1967 if (!uid_is_valid(uid))
cb31470f
ZJS		 1968 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1969 "User ID invalid: " UID_FMT, uid);
29206d46
LP		 1970
1971 r = dynamic_user_lookup_uid(m, uid, &name);
1972 if (r == -ESRCH)
cb31470f
ZJS		 1973 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
1974 "Dynamic user ID " UID_FMT " does not exist.", uid);
29206d46
LP		 1975 if (r < 0)
1976 return r;
1977
1978 return sd_bus_reply_method_return(message, "s", name);
1979}
1980
f9bfa696
YW		 1981static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1982 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 1983 Manager *m = ASSERT_PTR(userdata);
f9bfa696 1984 DynamicUser *d;
f9bfa696
YW		 1985 int r;
1986
1987 assert(message);
f9bfa696
YW		 1988
1989 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
1990
1991 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1992 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1993 "Dynamic users are only supported in the system instance.");
f9bfa696
YW		 1994
1995 r = sd_bus_message_new_method_return(message, &reply);
1996 if (r < 0)
1997 return r;
1998
1999 r = sd_bus_message_open_container(reply, 'a', "(us)");
2000 if (r < 0)
2001 return r;
2002
90e74a66 2003 HASHMAP_FOREACH(d, m->dynamic_users) {
f9bfa696
YW		 2004 uid_t uid;
2005
2006 r = dynamic_user_current(d, &uid);
2007 if (r == -EAGAIN) /* not realized yet? */
2008 continue;
2009 if (r < 0)
cb31470f
ZJS		 2010 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED,
2011 "Failed to look up a dynamic user.");
f9bfa696
YW		 2012
2013 r = sd_bus_message_append(reply, "(us)", uid, d->name);
2014 if (r < 0)
2015 return r;
2016 }
2017
2018 r = sd_bus_message_close_container(reply);
2019 if (r < 0)
2020 return r;
2021
2022 return sd_bus_send(NULL, reply, NULL);
2023}
2024
70666e28 2025static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2026 Manager *m = ASSERT_PTR(userdata);
70666e28
ZJS		 2027 int r;
2028
2029 assert(message);
70666e28
ZJS		 2030
2031 r = mac_selinux_access_check(message, "start", error);
2032 if (r < 0)
2033 return r;
2034
2035 r = bus_verify_manage_units_async(m, message, error);
2036 if (r < 0)
2037 return r;
2038 if (r == 0)
2039 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2040
28e5e1e9 2041 log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS));
70666e28
ZJS		 2042
2043 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2044 r = sd_bus_message_new_method_return(message, &reply);
2045 if (r < 0)
2046 return r;
2047
2048 r = sd_bus_message_open_container(reply, 'a', "o");
2049 if (r < 0)
2050 return r;
2051
2052 Unit *u;
2053 char *k;
2054 int ret = 0;
2055 HASHMAP_FOREACH_KEY(u, k, m->units) {
2056 /* ignore aliases */
2057 if (u->id != k)
2058 continue;
2059
2060 BusUnitQueueFlags flags;
2061 if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RESTART))
2062 flags = 0;
2063 else if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RELOAD))
2064 flags = BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE;
2065 else
2066 continue;
2067
2068 r = mac_selinux_unit_access_check(u, message, "start", error);
2069 if (r >= 0)
2070 r = bus_unit_queue_job_one(message, u,
2071 JOB_TRY_RESTART, JOB_FAIL, flags,
2072 reply, error);
2073 if (r < 0) {
2074 if (ERRNO_IS_RESOURCE(r))
2075 return r;
2076 if (ret >= 0)
2077 ret = r;
2078 sd_bus_error_free(error);
2079 }
2080 }
2081
2082 if (ret < 0)
2083 return sd_bus_error_set_errnof(error, ret,
2084 "Failed to enqueue some jobs, see logs for details: %m");
2085
2086 r = sd_bus_message_close_container(reply);
2087 if (r < 0)
2088 return r;
2089
2090 return sd_bus_send(NULL, reply, NULL);
2091}
2092
313fe66f 2093static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 2094 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 2095 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2096 UnitFileList *item;
2097 Hashmap *h;
718db961
LP		 2098 int r;
2099
718db961 2100 assert(message);
718db961 2101
283868e1
SW		 2102 /* Anyone can call this method */
2103
8a188de9 2104 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2105 if (r < 0)
2106 return r;
718db961 2107
df2d202e 2108 r = sd_bus_message_new_method_return(message, &reply);
718db961 2109 if (r < 0)
ebcf1f97 2110 return r;
c0576cd6 2111
d5099efc 2112 h = hashmap_new(&string_hash_ops);
718db961 2113 if (!h)
ebcf1f97 2114 return -ENOMEM;
c0576cd6 2115
4870133b 2116 r = unit_file_get_list(m->runtime_scope, NULL, h, states, patterns);
ebcf1f97 2117 if (r < 0)
718db961 2118 goto fail;
718db961
LP		 2119
2120 r = sd_bus_message_open_container(reply, 'a', "(ss)");
ebcf1f97 2121 if (r < 0)
718db961 2122 goto fail;
718db961 2123
90e74a66 2124 HASHMAP_FOREACH(item, h) {
718db961
LP		 2125
2126 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
ebcf1f97 2127 if (r < 0)
718db961 2128 goto fail;
718db961 2129 }
c0576cd6 2130
718db961 2131 unit_file_list_free(h);
c0576cd6 2132
718db961
LP		 2133 r = sd_bus_message_close_container(reply);
2134 if (r < 0)
ebcf1f97 2135 return r;
8d0e38a2 2136
9030ca46 2137 return sd_bus_send(NULL, reply, NULL);
99504dd4 2138
718db961
LP		 2139fail:
2140 unit_file_list_free(h);
2141 return r;
2142}
99504dd4 2143
313fe66f 2144static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2145 return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
2146}
2147
2148static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2149 _cleanup_strv_free_ char **states = NULL;
2150 _cleanup_strv_free_ char **patterns = NULL;
2151 int r;
2152
2153 r = sd_bus_message_read_strv(message, &states);
2154 if (r < 0)
2155 return r;
2156
2157 r = sd_bus_message_read_strv(message, &patterns);
2158 if (r < 0)
2159 return r;
2160
2161 return list_unit_files_by_patterns(message, userdata, error, states, patterns);
2162}
2163
19070062 2164static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2165 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2166 const char *name;
2167 UnitFileState state;
718db961 2168 int r;
99504dd4 2169
718db961 2170 assert(message);
8e2af478 2171
283868e1
SW		 2172 /* Anyone can call this method */
2173
8a188de9 2174 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2175 if (r < 0)
2176 return r;
8e2af478 2177
718db961
LP		 2178 r = sd_bus_message_read(message, "s", &name);
2179 if (r < 0)
ebcf1f97 2180 return r;
8e2af478 2181
4870133b 2182 r = unit_file_get_state(m->runtime_scope, NULL, name, &state);
0ec0deaa
LP		 2183 if (r < 0)
2184 return r;
8e2af478 2185
df2d202e 2186 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
718db961 2187}
8e2af478 2188
19070062 2189static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 2190 _cleanup_free_ char *default_target = NULL;
99534007 2191 Manager *m = ASSERT_PTR(userdata);
718db961 2192 int r;
c2756a68 2193
718db961 2194 assert(message);
c2756a68 2195
283868e1
SW		 2196 /* Anyone can call this method */
2197
8a188de9 2198 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2199 if (r < 0)
2200 return r;
c2756a68 2201
4870133b 2202 r = unit_file_get_default(m->runtime_scope, NULL, &default_target);
7c78a193
DT		 2203 if (r == -ERFKILL)
2204 sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
718db961 2205 if (r < 0)
ebcf1f97 2206 return r;
c2756a68 2207
df2d202e 2208 return sd_bus_reply_method_return(message, "s", default_target);
718db961 2209}
c2756a68 2210
8f8f05a9 2211static int send_unit_files_changed(sd_bus *bus, void *userdata) {
4afd3348 2212 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 2213 int r;
2214
2215 assert(bus);
2216
cb31470f
ZJS		 2217 r = sd_bus_message_new_signal(bus, &message,
2218 "/org/freedesktop/systemd1",
2219 "org.freedesktop.systemd1.Manager",
2220 "UnitFilesChanged");
718db961
LP		 2221 if (r < 0)
2222 return r;
2223
8f8f05a9 2224 return sd_bus_send(bus, message, NULL);
718db961
LP		 2225}
2226
af3d8113
ZJS		 2227/* Create an error reply, using the error information from changes[]
2228 * if possible, and fall back to generating an error from error code c.
2229 * The error message only describes the first error.
af3d8113
ZJS		 2230 */
2231static int install_error(
2232 sd_bus_error *error,
2233 int c,
cd44ec5a 2234 InstallChange *changes,
da6053d0
LP		 2235 size_t n_changes) {
2236
af3d8113 2237 int r;
8e20adca 2238
fe96c0f8 2239 for (size_t i = 0; i < n_changes; i++)
637d6e5b 2240
5ad58fea 2241 /* When making changes here, make sure to also change install_changes_dump() in install.c. */
637d6e5b 2242
5ad58fea 2243 switch (changes[i].type) {
f8662fee
LP		 2244 case 0 ... _INSTALL_CHANGE_TYPE_MAX: /* not errors */
2245 break;
637d6e5b 2246
af3d8113
ZJS		 2247 case -EEXIST:
2248 if (changes[i].source)
2249 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2250 "File %s already exists and is a symlink to %s.",
2251 changes[i].path, changes[i].source);
2252 else
2253 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2254 "File %s already exists.",
2255 changes[i].path);
2256 goto found;
637d6e5b 2257
af3d8113
ZJS		 2258 case -ERFKILL:
2259 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED,
2260 "Unit file %s is masked.", changes[i].path);
2261 goto found;
637d6e5b 2262
af3d8113
ZJS		 2263 case -EADDRNOTAVAIL:
2264 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED,
2265 "Unit %s is transient or generated.", changes[i].path);
2266 goto found;
637d6e5b 2267
a6f318a5
ZJS		 2268 case -ETXTBSY:
2269 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_BAD_PATH,
2270 "File %s is under the systemd unit hierarchy already.", changes[i].path);
2271 goto found;
2272
c89d0c3b
JM		 2273 case -EBADSLT:
2274 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2275 "Invalid specifier in %s.", changes[i].path);
2276 goto found;
2277
2278 case -EIDRM:
2279 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2280 "Destination unit %s is a non-template unit.", changes[i].path);
2281 goto found;
2282
d7ceaf72
ZJS		 2283 case -EUCLEAN:
2284 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2285 "\"%s\" is not a valid unit name.",
2286 changes[i].path);
2287 goto found;
2288
af3d8113
ZJS		 2289 case -ELOOP:
2290 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_LINKED,
22683674
FB		 2291 "Refusing to operate on alias name or linked unit file: %s",
2292 changes[i].path);
af3d8113 2293 goto found;
637d6e5b 2294
c89d0c3b
JM		 2295 case -EXDEV:
2296 if (changes[i].source)
2297 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2298 "Cannot alias %s as %s.",
2299 changes[i].source, changes[i].path);
2300 else
2301 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2302 "Invalid unit reference %s.", changes[i].path);
2303 goto found;
2304
637d6e5b 2305 case -ENOENT:
22683674
FB		 2306 r = sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
2307 "Unit file %s does not exist.", changes[i].path);
637d6e5b
LP		 2308 goto found;
2309
c89d0c3b
JM		 2310 case -EUNATCH:
2311 r = sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2312 "Cannot resolve specifiers in %s.", changes[i].path);
2313 goto found;
2314
af3d8113 2315 default:
f8662fee
LP		 2316 assert(changes[i].type < 0); /* other errors */
2317 r = sd_bus_error_set_errnof(error, changes[i].type, "File %s: %m", changes[i].path);
af3d8113
ZJS		 2318 goto found;
2319 }
8e20adca 2320
637d6e5b
LP		 2321 r = c < 0 ? c : -EINVAL;
2322
af3d8113 2323 found:
cd44ec5a 2324 install_changes_free(changes, n_changes);
af3d8113 2325 return r;
8e20adca
LP		 2326}
2327
cd44ec5a 2328static int reply_install_changes_and_free(
637d6e5b
LP		 2329 Manager *m,
2330 sd_bus_message *message,
2331 int carries_install_info,
cd44ec5a 2332 InstallChange *changes,
da6053d0 2333 size_t n_changes,
637d6e5b
LP		 2334 sd_bus_error *error) {
2335
2336 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2337 bool bad = false, good = false;
637d6e5b
LP		 2338 int r;
2339
8c2d0d3a
LP		 2340 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2341
cd44ec5a 2342 if (install_changes_have_modification(changes, n_changes)) {
637d6e5b
LP		 2343 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
2344 if (r < 0)
2345 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
2346 }
2347
2348 r = sd_bus_message_new_method_return(message, &reply);
2349 if (r < 0)
8c2d0d3a 2350 return r;
637d6e5b
LP		 2351
2352 if (carries_install_info >= 0) {
2353 r = sd_bus_message_append(reply, "b", carries_install_info);
2354 if (r < 0)
8c2d0d3a 2355 return r;
637d6e5b
LP		 2356 }
2357
2358 r = sd_bus_message_open_container(reply, 'a', "(sss)");
2359 if (r < 0)
8c2d0d3a 2360 return r;
637d6e5b 2361
fe96c0f8 2362 for (size_t i = 0; i < n_changes; i++) {
637d6e5b 2363
f8662fee 2364 if (changes[i].type < 0) {
637d6e5b
LP		 2365 bad = true;
2366 continue;
2367 }
2368
2369 r = sd_bus_message_append(
2370 reply, "(sss)",
f8662fee 2371 install_change_type_to_string(changes[i].type),
637d6e5b
LP		 2372 changes[i].path,
2373 changes[i].source);
2374 if (r < 0)
8c2d0d3a 2375 return r;
637d6e5b
LP		 2376
2377 good = true;
2378 }
2379
cb31470f
ZJS		 2380 /* If there was a failed change, and no successful change, then return the first failure as proper
2381 * method call error. */
637d6e5b 2382 if (bad && !good)
8c2d0d3a 2383 return install_error(error, 0, TAKE_PTR(changes), n_changes);
637d6e5b
LP		 2384
2385 r = sd_bus_message_close_container(reply);
2386 if (r < 0)
8c2d0d3a 2387 return r;
637d6e5b 2388
637d6e5b 2389 return sd_bus_send(NULL, reply, NULL);
637d6e5b
LP		 2390}
2391
718db961 2392static int method_enable_unit_files_generic(
718db961 2393 sd_bus_message *message,
d309c1c3 2394 Manager *m,
4870133b 2395 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
ebcf1f97
LP		 2396 bool carries_install_info,
2397 sd_bus_error *error) {
718db961
LP		 2398
2399 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2400 InstallChange *changes = NULL;
da6053d0 2401 size_t n_changes = 0;
b3796dd8 2402 UnitFileFlags flags;
83654007 2403 int r;
718db961 2404
718db961
LP		 2405 assert(message);
2406 assert(m);
cad45ba1 2407
718db961
LP		 2408 r = sd_bus_message_read_strv(message, &l);
2409 if (r < 0)
ebcf1f97 2410 return r;
90bb85e1 2411
83654007
LB		 2412 if (sd_bus_message_is_method_call(message, NULL, "EnableUnitFilesWithFlags")) {
2413 uint64_t raw_flags;
d309c1c3 2414
83654007
LB		 2415 r = sd_bus_message_read(message, "t", &raw_flags);
2416 if (r < 0)
2417 return r;
2418 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0)
2419 return -EINVAL;
2420 flags = raw_flags;
2421 } else {
2422 int runtime, force;
2423
2424 r = sd_bus_message_read(message, "bb", &runtime, &force);
2425 if (r < 0)
2426 return r;
2427 flags = unit_file_bools_to_flags(runtime, force);
2428 }
b3796dd8 2429
1d22e906
LP		 2430 r = bus_verify_manage_unit_files_async(m, message, error);
2431 if (r < 0)
2432 return r;
2433 if (r == 0)
2434 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2435
4870133b 2436 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2437 if (r < 0)
2438 return install_error(error, r, changes, n_changes);
718db961 2439
cd44ec5a 2440 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2441}
c87eba54 2442
83654007 2443static int method_enable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2444 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
83654007
LB		 2445}
2446
19070062 2447static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2448 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
718db961 2449}
ea430986 2450
19070062 2451static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2452 return method_enable_unit_files_generic(message, userdata, unit_file_reenable, /* carries_install_info = */ true, error);
718db961
LP		 2453}
2454
19070062 2455static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2456 return method_enable_unit_files_generic(message, userdata, unit_file_link, /* carries_install_info = */ false, error);
718db961
LP		 2457}
2458
4870133b 2459static int unit_file_preset_without_mode(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char **files, InstallChange **changes, size_t *n_changes) {
b3796dd8 2460 return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
d309c1c3
LP		 2461}
2462
19070062 2463static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2464 return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, /* carries_install_info = */ true, error);
718db961
LP		 2465}
2466
19070062 2467static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2468 return method_enable_unit_files_generic(message, userdata, unit_file_mask, /* carries_install_info = */ false, error);
718db961 2469}
ea430986 2470
19070062 2471static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d309c1c3
LP		 2472
2473 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2474 InstallChange *changes = NULL;
da6053d0 2475 size_t n_changes = 0;
99534007 2476 Manager *m = ASSERT_PTR(userdata);
8331b221 2477 UnitFilePresetMode preset_mode;
d309c1c3 2478 int runtime, force, r;
b3796dd8 2479 UnitFileFlags flags;
d309c1c3
LP		 2480 const char *mode;
2481
d309c1c3 2482 assert(message);
d309c1c3
LP		 2483
2484 r = sd_bus_message_read_strv(message, &l);
2485 if (r < 0)
2486 return r;
2487
2488 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2489 if (r < 0)
2490 return r;
2491
b3796dd8
JS		 2492 flags = unit_file_bools_to_flags(runtime, force);
2493
d309c1c3 2494 if (isempty(mode))
8331b221 2495 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2496 else {
8331b221
ZJS		 2497 preset_mode = unit_file_preset_mode_from_string(mode);
2498 if (preset_mode < 0)
d309c1c3
LP		 2499 return -EINVAL;
2500 }
2501
1d22e906
LP		 2502 r = bus_verify_manage_unit_files_async(m, message, error);
2503 if (r < 0)
2504 return r;
2505 if (r == 0)
2506 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2507
4870133b 2508 r = unit_file_preset(m->runtime_scope, flags, NULL, l, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2509 if (r < 0)
2510 return install_error(error, r, changes, n_changes);
d309c1c3 2511
cd44ec5a 2512 return reply_install_changes_and_free(m, message, r, changes, n_changes, error);
d309c1c3
LP		 2513}
2514
718db961 2515static int method_disable_unit_files_generic(
718db961 2516 sd_bus_message *message,
596fc263 2517 Manager *m,
4870133b 2518 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
bf1bea43 2519 bool carries_install_info,
ebcf1f97 2520 sd_bus_error *error) {
718db961
LP		 2521
2522 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2523 InstallChange *changes = NULL;
83654007 2524 UnitFileFlags flags;
da6053d0 2525 size_t n_changes = 0;
83654007 2526 int r;
718db961 2527
718db961
LP		 2528 assert(message);
2529 assert(m);
2530
df823e23 2531 r = sd_bus_message_read_strv(message, &l);
ebcf1f97
LP		 2532 if (r < 0)
2533 return r;
718db961 2534
bf1bea43
MY		 2535 if (sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlags") ||
2536 sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlagsAndInstallInfo")) {
83654007
LB		 2537 uint64_t raw_flags;
2538
2539 r = sd_bus_message_read(message, "t", &raw_flags);
2540 if (r < 0)
2541 return r;
2542 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0 ||
2543 FLAGS_SET(raw_flags, UNIT_FILE_FORCE))
2544 return -EINVAL;
2545 flags = raw_flags;
2546 } else {
2547 int runtime;
2548
2549 r = sd_bus_message_read(message, "b", &runtime);
2550 if (r < 0)
2551 return r;
2552 flags = unit_file_bools_to_flags(runtime, false);
2553 }
718db961 2554
1d22e906
LP		 2555 r = bus_verify_manage_unit_files_async(m, message, error);
2556 if (r < 0)
2557 return r;
2558 if (r == 0)
2559 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2560
4870133b 2561 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2562 if (r < 0)
2563 return install_error(error, r, changes, n_changes);
718db961 2564
bf1bea43 2565 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2566}
ea430986 2567
83654007 2568static int method_disable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43
MY		 2569 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
2570}
2571
2572static int method_disable_unit_files_with_flags_and_install_info(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2573 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ true, error);
83654007
LB		 2574}
2575
19070062 2576static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2577 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
ea430986
LP		 2578}
2579
19070062 2580static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2581 return method_disable_unit_files_generic(message, userdata, unit_file_unmask, /* carries_install_info = */ false, error);
718db961
LP		 2582}
2583
344ca755
LP		 2584static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2585 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2586 InstallChange *changes = NULL;
da6053d0 2587 size_t n_changes = 0;
99534007 2588 Manager *m = ASSERT_PTR(userdata);
344ca755
LP		 2589 int r;
2590
2591 assert(message);
344ca755
LP		 2592
2593 r = sd_bus_message_read_strv(message, &l);
2594 if (r < 0)
2595 return r;
2596
2597 r = bus_verify_manage_unit_files_async(m, message, error);
2598 if (r < 0)
2599 return r;
2600 if (r == 0)
2601 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2602
4870133b 2603 r = unit_file_revert(m->runtime_scope, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2604 if (r < 0)
2605 return install_error(error, r, changes, n_changes);
344ca755 2606
cd44ec5a 2607 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
344ca755
LP		 2608}
2609
19070062 2610static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2611 InstallChange *changes = NULL;
da6053d0 2612 size_t n_changes = 0;
99534007 2613 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2614 const char *name;
2615 int force, r;
2616
718db961 2617 assert(message);
718db961 2618
1d22e906 2619 r = mac_selinux_access_check(message, "enable", error);
283868e1
SW		 2620 if (r < 0)
2621 return r;
283868e1 2622
1d22e906 2623 r = sd_bus_message_read(message, "sb", &name, &force);
ebcf1f97
LP		 2624 if (r < 0)
2625 return r;
718db961 2626
1d22e906 2627 r = bus_verify_manage_unit_files_async(m, message, error);
718db961 2628 if (r < 0)
ebcf1f97 2629 return r;
1d22e906
LP		 2630 if (r == 0)
2631 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
718db961 2632
4870133b 2633 r = unit_file_set_default(m->runtime_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
af3d8113
ZJS		 2634 if (r < 0)
2635 return install_error(error, r, changes, n_changes);
718db961 2636
cd44ec5a 2637 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
718db961
LP		 2638}
2639
19070062 2640static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2641 InstallChange *changes = NULL;
da6053d0 2642 size_t n_changes = 0;
99534007 2643 Manager *m = ASSERT_PTR(userdata);
8331b221 2644 UnitFilePresetMode preset_mode;
d309c1c3 2645 const char *mode;
b3796dd8 2646 UnitFileFlags flags;
d309c1c3
LP		 2647 int force, runtime, r;
2648
d309c1c3 2649 assert(message);
d309c1c3 2650
8a188de9 2651 r = mac_selinux_access_check(message, "enable", error);
d309c1c3
LP		 2652 if (r < 0)
2653 return r;
2654
2655 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2656 if (r < 0)
2657 return r;
2658
b3796dd8
JS		 2659 flags = unit_file_bools_to_flags(runtime, force);
2660
d309c1c3 2661 if (isempty(mode))
8331b221 2662 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2663 else {
8331b221
ZJS		 2664 preset_mode = unit_file_preset_mode_from_string(mode);
2665 if (preset_mode < 0)
d309c1c3
LP		 2666 return -EINVAL;
2667 }
2668
1d22e906
LP		 2669 r = bus_verify_manage_unit_files_async(m, message, error);
2670 if (r < 0)
2671 return r;
2672 if (r == 0)
2673 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2674
4870133b 2675 r = unit_file_preset_all(m->runtime_scope, flags, NULL, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2676 if (r < 0)
2677 return install_error(error, r, changes, n_changes);
d309c1c3 2678
cd44ec5a 2679 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
d309c1c3
LP		 2680}
2681
19070062 2682static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
e94937df 2683 _cleanup_strv_free_ char **l = NULL;
99534007 2684 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2685 InstallChange *changes = NULL;
da6053d0 2686 size_t n_changes = 0;
e94937df 2687 int runtime, force, r;
596fc263 2688 char *target, *type;
e94937df 2689 UnitDependency dep;
b3796dd8 2690 UnitFileFlags flags;
e94937df 2691
e94937df 2692 assert(message);
e94937df
LN		 2693
2694 r = bus_verify_manage_unit_files_async(m, message, error);
2695 if (r < 0)
2696 return r;
2697 if (r == 0)
2698 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2699
2700 r = sd_bus_message_read_strv(message, &l);
2701 if (r < 0)
2702 return r;
2703
2704 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2705 if (r < 0)
2706 return r;
2707
b3796dd8
JS		 2708 flags = unit_file_bools_to_flags(runtime, force);
2709
e94937df
LN		 2710 dep = unit_dependency_from_string(type);
2711 if (dep < 0)
2712 return -EINVAL;
2713
4870133b 2714 r = unit_file_add_dependency(m->runtime_scope, flags, NULL, l, target, dep, &changes, &n_changes);
af3d8113
ZJS		 2715 if (r < 0)
2716 return install_error(error, r, changes, n_changes);
e94937df 2717
cd44ec5a 2718 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
e94937df
LN		 2719}
2720
3b3557c4
JS		 2721static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2722 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
47c57b48 2723 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2724 InstallChange *changes = NULL;
da6053d0 2725 size_t n_changes = 0, i;
3b3557c4 2726 const char *name;
3b3557c4
JS		 2727 int runtime, r;
2728
2729 r = sd_bus_message_read(message, "sb", &name, &runtime);
2730 if (r < 0)
2731 return r;
2732
2733 r = sd_bus_message_new_method_return(message, &reply);
2734 if (r < 0)
2735 return r;
2736
2737 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2738 if (r < 0)
2739 return r;
2740
4870133b 2741 r = unit_file_disable(m->runtime_scope,
47c57b48
YW		 2742 UNIT_FILE_DRY_RUN | (runtime ? UNIT_FILE_RUNTIME : 0),
2743 NULL, STRV_MAKE(name), &changes, &n_changes);
a12ba535
YW		 2744 if (r < 0) {
2745 log_error_errno(r, "Failed to get file links for %s: %m", name);
2746 goto finish;
2747 }
3b3557c4
JS		 2748
2749 for (i = 0; i < n_changes; i++)
f8662fee 2750 if (changes[i].type == INSTALL_CHANGE_UNLINK) {
3b3557c4
JS		 2751 r = sd_bus_message_append(reply, "s", changes[i].path);
2752 if (r < 0)
a12ba535 2753 goto finish;
3b3557c4
JS		 2754 }
2755
2756 r = sd_bus_message_close_container(reply);
2757 if (r < 0)
a12ba535 2758 goto finish;
3b3557c4 2759
a12ba535
YW		 2760 r = sd_bus_send(NULL, reply, NULL);
2761
2762finish:
2763 install_changes_free(changes, n_changes);
2764 return r;
3b3557c4
JS		 2765}
2766
15ea79f8 2767static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2768 Manager *m = ASSERT_PTR(userdata);
15ea79f8
LP		 2769 uint32_t id;
2770 Job *j;
2771 int r;
2772
2773 assert(message);
15ea79f8
LP		 2774
2775 r = sd_bus_message_read(message, "u", &id);
2776 if (r < 0)
2777 return r;
2778
2779 j = manager_get_job(m, id);
2780 if (!j)
2781 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2782
2783 return bus_job_method_get_waiting_jobs(message, j, error);
2784}
2785
c20076a8 2786static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2787 Manager *m = ASSERT_PTR(userdata);
c20076a8
LP		 2788 const char *name;
2789 Unit *u;
2790 int r;
2791
2792 assert(message);
c20076a8
LP		 2793
2794 r = sd_bus_message_read(message, "s", &name);
2795 if (r < 0)
2796 return r;
2797
2798 r = bus_get_unit_by_name(m, message, name, &u, error);
2799 if (r < 0)
2800 return r;
2801
2802 if (u->type != UNIT_SCOPE)
cb31470f
ZJS		 2803 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2804 "Unit '%s' is not a scope unit, refusing.", name);
c20076a8
LP		 2805
2806 return bus_scope_method_abandon(message, u, error);
2807}
2808
0bb007f7 2809static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2810 Manager *m = ASSERT_PTR(userdata);
0bb007f7
FB		 2811 ShowStatus mode = _SHOW_STATUS_INVALID;
2812 const char *t;
2813 int r;
2814
0bb007f7
FB		 2815 assert(message);
2816
4db62561
ZJS		 2817 r = mac_selinux_access_check(message, "reload", error);
2818 if (r < 0)
2819 return r;
2820
2821 r = bus_verify_set_environment_async(m, message, error);
2822 if (r < 0)
2823 return r;
2824 if (r == 0)
2825 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2826
0bb007f7
FB		 2827 r = sd_bus_message_read(message, "s", &t);
2828 if (r < 0)
2829 return r;
2830
2831 if (!isempty(t)) {
2832 mode = show_status_from_string(t);
2833 if (mode < 0)
cb31470f
ZJS		 2834 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2835 "Invalid show status '%s'", t);
0bb007f7
FB		 2836 }
2837
43bba15a 2838 manager_override_show_status(m, mode, "bus");
0bb007f7
FB		 2839
2840 return sd_bus_reply_method_return(message, NULL);
2841}
2842
718db961
LP		 2843const sd_bus_vtable bus_manager_vtable[] = {
2844 SD_BUS_VTABLE_START(0),
2845
556089dc
LP		 2846 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2847 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2848 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
7452394e 2849 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2850 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
9f9f0342
LP		 2851 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
2852 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
2853 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
2854 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
2855 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
2856 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2857 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2858 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2859 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2860 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2861 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2862 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
49fbe940 2863 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD]), SD_BUS_VTABLE_PROPERTY_CONST),
665a9774
YW		 2864 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2865 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2866 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2867 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2868 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2869 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
25141692
LP		 2870 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
2871 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3ff52e8f
YW		 2872 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
2873 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2874 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
718db961
LP		 2875 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
2876 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
2877 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1ad6e8b3 2878 SD_BUS_PROPERTY("Environment", "as", property_get_environment, 0, 0),
556089dc 2879 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
52d2566a 2880 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
a3c4eb07 2881 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2882 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
cb6c4f37 2883 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_error), SD_BUS_VTABLE_PROPERTY_CONST),
3e911a0d
YW		 2884 SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2885 SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime, 0, 0),
2886 SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic, 0, 0),
986935cf 2887 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog, property_set_runtime_watchdog, 0, 0),
5717062e 2888 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog, property_set_pretimeout_watchdog, 0, 0),
aff3a9e1 2889 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor, property_set_pretimeout_watchdog_governor, 0, 0),
986935cf 2890 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, 0),
65224c1d 2891 /* The following item is an obsolete alias */
986935cf
FB		 2892 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, SD_BUS_VTABLE_HIDDEN),
2893 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog, property_set_kexec_watchdog, 0, 0),
2a12e32e 2894 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
b272b74d 2895 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
f755e3b7 2896 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
287419c1 2897 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
670a3efe
EV		 2898 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, default_timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2899 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2900 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
dc653bf4 2901 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec, 0, 0),
a0fe19f9 2902 SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec, offsetof(Manager, default_device_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
670a3efe 2903 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, default_restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
c075f5fc
YW		 2904 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
2905 /* The following two items are obsolete alias */
2906 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
2907 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		 2908 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, default_start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
2909 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, default_cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2910 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2911 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, default_memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2912 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, default_tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2913 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2914 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2915 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2916 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2917 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2918 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2919 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2920 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2921 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2922 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2923 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2924 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2925 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2926 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2927 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2928 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2929 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2930 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2931 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2932 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2933 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2934 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2935 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2936 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2937 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2938 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2939 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2940 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2941 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2942 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2943 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2944 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3a0f06c4 2945 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max, offsetof(Manager, default_tasks_max), 0),
6bb00842
LP		 2946 SD_BUS_PROPERTY("DefaultMemoryPressureThresholdUSec", "t", bus_property_get_usec, offsetof(Manager, default_memory_pressure_threshold_usec), 0),
2947 SD_BUS_PROPERTY("DefaultMemoryPressureWatch", "s", bus_property_get_cgroup_pressure_watch, offsetof(Manager, default_memory_pressure_watch), 0),
eed67a30 2948 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
afcfaa69 2949 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy, offsetof(Manager, default_oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
d4a402e4 2950 SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
c44a285c 2951 SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 2952
a008b6d7 2953 SD_BUS_METHOD_WITH_ARGS("GetUnit",
2954 SD_BUS_ARGS("s", name),
2955 SD_BUS_RESULT("o", unit),
2956 method_get_unit,
2957 SD_BUS_VTABLE_UNPRIVILEGED),
2958 SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
2959 SD_BUS_ARGS("u", pid),
2960 SD_BUS_RESULT("o", unit),
2961 method_get_unit_by_pid,
2962 SD_BUS_VTABLE_UNPRIVILEGED),
2963 SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
2964 SD_BUS_ARGS("ay", invocation_id),
2965 SD_BUS_RESULT("o", unit),
2966 method_get_unit_by_invocation_id,
2967 SD_BUS_VTABLE_UNPRIVILEGED),
2968 SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
2969 SD_BUS_ARGS("s", cgroup),
2970 SD_BUS_RESULT("o", unit),
2971 method_get_unit_by_control_group,
2972 SD_BUS_VTABLE_UNPRIVILEGED),
e0e7bc82
LB		 2973 SD_BUS_METHOD_WITH_ARGS("GetUnitByPIDFD",
2974 SD_BUS_ARGS("h", pidfd),
2975 SD_BUS_RESULT("o", unit, "s", unit_id, "ay", invocation_id),
2976 method_get_unit_by_pidfd,
2977 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 2978 SD_BUS_METHOD_WITH_ARGS("LoadUnit",
2979 SD_BUS_ARGS("s", name),
2980 SD_BUS_RESULT("o", unit),
2981 method_load_unit,
2982 SD_BUS_VTABLE_UNPRIVILEGED),
2983 SD_BUS_METHOD_WITH_ARGS("StartUnit",
2984 SD_BUS_ARGS("s", name, "s", mode),
2985 SD_BUS_RESULT("o", job),
2986 method_start_unit,
2987 SD_BUS_VTABLE_UNPRIVILEGED),
2988 SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
2989 SD_BUS_ARGS("s", name, "s", mode, "t", flags),
2990 SD_BUS_RESULT("o", job),
2991 method_start_unit,
2992 SD_BUS_VTABLE_UNPRIVILEGED),
2993 SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
2994 SD_BUS_ARGS("s", old_unit, "s", new_unit, "s", mode),
2995 SD_BUS_RESULT("o", job),
2996 method_start_unit_replace,
2997 SD_BUS_VTABLE_UNPRIVILEGED),
2998 SD_BUS_METHOD_WITH_ARGS("StopUnit",
2999 SD_BUS_ARGS("s", name, "s", mode),
3000 SD_BUS_RESULT("o", job),
3001 method_stop_unit,
3002 SD_BUS_VTABLE_UNPRIVILEGED),
3003 SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
3004 SD_BUS_ARGS("s", name, "s", mode),
3005 SD_BUS_RESULT("o", job),
3006 method_reload_unit,
3007 SD_BUS_VTABLE_UNPRIVILEGED),
3008 SD_BUS_METHOD_WITH_ARGS("RestartUnit",
3009 SD_BUS_ARGS("s", name, "s", mode),
3010 SD_BUS_RESULT("o", job),
3011 method_restart_unit,
3012 SD_BUS_VTABLE_UNPRIVILEGED),
3013 SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
3014 SD_BUS_ARGS("s", name, "s", mode),
3015 SD_BUS_RESULT("o", job),
3016 method_try_restart_unit,
3017 SD_BUS_VTABLE_UNPRIVILEGED),
3018 SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
3019 SD_BUS_ARGS("s", name, "s", mode),
3020 SD_BUS_RESULT("o", job),
3021 method_reload_or_restart_unit,
3022 SD_BUS_VTABLE_UNPRIVILEGED),
3023 SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
3024 SD_BUS_ARGS("s", name, "s", mode),
3025 SD_BUS_RESULT("o", job),
3026 method_reload_or_try_restart_unit,
3027 SD_BUS_VTABLE_UNPRIVILEGED),
3028 SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
3029 SD_BUS_ARGS("s", name, "s", job_type, "s", job_mode),
3030 SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
3031 method_enqueue_unit_job,
3032 SD_BUS_VTABLE_UNPRIVILEGED),
3033 SD_BUS_METHOD_WITH_ARGS("KillUnit",
3034 SD_BUS_ARGS("s", name, "s", whom, "i", signal),
3035 SD_BUS_NO_RESULT,
a721cd00
LP		 3036 method_kill_unit,
3037 SD_BUS_VTABLE_UNPRIVILEGED),
3038 SD_BUS_METHOD_WITH_ARGS("QueueSignalUnit",
3039 SD_BUS_ARGS("s", name, "s", whom, "i", signal, "i", value),
3040 SD_BUS_NO_RESULT,
a008b6d7 3041 method_kill_unit,
3042 SD_BUS_VTABLE_UNPRIVILEGED),
3043 SD_BUS_METHOD_WITH_ARGS("CleanUnit",
3044 SD_BUS_ARGS("s", name, "as", mask),
3045 SD_BUS_NO_RESULT,
3046 method_clean_unit,
3047 SD_BUS_VTABLE_UNPRIVILEGED),
3048 SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
3049 SD_BUS_ARGS("s", name),
3050 SD_BUS_NO_RESULT,
3051 method_freeze_unit,
3052 SD_BUS_VTABLE_UNPRIVILEGED),
3053 SD_BUS_METHOD_WITH_ARGS("ThawUnit",
3054 SD_BUS_ARGS("s", name),
3055 SD_BUS_NO_RESULT,
3056 method_thaw_unit,
3057 SD_BUS_VTABLE_UNPRIVILEGED),
3058 SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
3059 SD_BUS_ARGS("s", name),
3060 SD_BUS_NO_RESULT,
3061 method_reset_failed_unit,
3062 SD_BUS_VTABLE_UNPRIVILEGED),
3063 SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
3064 SD_BUS_ARGS("s", name, "b", runtime, "a(sv)", properties),
3065 SD_BUS_NO_RESULT,
3066 method_set_unit_properties,
3067 SD_BUS_VTABLE_UNPRIVILEGED),
3068 SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
3069 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir),
3070 SD_BUS_NO_RESULT,
3071 method_bind_mount_unit,
3072 SD_BUS_VTABLE_UNPRIVILEGED),
3073 SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
3074 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
3075 SD_BUS_NO_RESULT,
3076 method_mount_image_unit,
3077 SD_BUS_VTABLE_UNPRIVILEGED),
3078 SD_BUS_METHOD_WITH_ARGS("RefUnit",
3079 SD_BUS_ARGS("s", name),
3080 SD_BUS_NO_RESULT,
3081 method_ref_unit,
3082 SD_BUS_VTABLE_UNPRIVILEGED),
3083 SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
3084 SD_BUS_ARGS("s", name),
3085 SD_BUS_NO_RESULT,
3086 method_unref_unit,
3087 SD_BUS_VTABLE_UNPRIVILEGED),
3088 SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
3089 SD_BUS_ARGS("s", name, "s", mode, "a(sv)", properties, "a(sa(sv))", aux),
3090 SD_BUS_RESULT("o", job),
3091 method_start_transient_unit,
3092 SD_BUS_VTABLE_UNPRIVILEGED),
3093 SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
3094 SD_BUS_ARGS("s", name),
3095 SD_BUS_RESULT("a(sus)", processes),
3096 method_get_unit_processes,
3097 SD_BUS_VTABLE_UNPRIVILEGED),
3098 SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
3099 SD_BUS_ARGS("s", unit_name, "s", subcgroup, "au", pids),
3100 SD_BUS_NO_RESULT,
3101 method_attach_processes_to_unit,
3102 SD_BUS_VTABLE_UNPRIVILEGED),
3103 SD_BUS_METHOD_WITH_ARGS("AbandonScope",
3104 SD_BUS_ARGS("s", name),
3105 SD_BUS_NO_RESULT,
3106 method_abandon_scope,
3107 SD_BUS_VTABLE_UNPRIVILEGED),
3108 SD_BUS_METHOD_WITH_ARGS("GetJob",
3109 SD_BUS_ARGS("u", id),
3110 SD_BUS_RESULT("o", job),
3111 method_get_job,
3112 SD_BUS_VTABLE_UNPRIVILEGED),
3113 SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
3114 SD_BUS_ARGS("u", id),
3115 SD_BUS_RESULT("a(usssoo)", jobs),
3116 method_get_job_waiting,
3117 SD_BUS_VTABLE_UNPRIVILEGED),
3118 SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
3119 SD_BUS_ARGS("u", id),
3120 SD_BUS_RESULT("a(usssoo)", jobs),
3121 method_get_job_waiting,
3122 SD_BUS_VTABLE_UNPRIVILEGED),
3123 SD_BUS_METHOD_WITH_ARGS("CancelJob",
3124 SD_BUS_ARGS("u", id),
3125 SD_BUS_NO_RESULT,
3126 method_cancel_job,
3127 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3128 SD_BUS_METHOD("ClearJobs",
3129 NULL,
3130 NULL,
3131 method_clear_jobs,
3132 SD_BUS_VTABLE_UNPRIVILEGED),
3133 SD_BUS_METHOD("ResetFailed",
3134 NULL,
3135 NULL,
3136 method_reset_failed,
3137 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3138 SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
3139 SD_BUS_ARGS("s", mode),
3140 SD_BUS_NO_RESULT,
3141 method_set_show_status,
3142 SD_BUS_VTABLE_UNPRIVILEGED),
3143 SD_BUS_METHOD_WITH_ARGS("ListUnits",
3144 SD_BUS_NO_ARGS,
3145 SD_BUS_RESULT("a(ssssssouso)", units),
3146 method_list_units,
3147 SD_BUS_VTABLE_UNPRIVILEGED),
3148 SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
3149 SD_BUS_ARGS("as", states),
3150 SD_BUS_RESULT("a(ssssssouso)", units),
3151 method_list_units_filtered,
3152 SD_BUS_VTABLE_UNPRIVILEGED),
3153 SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3154 SD_BUS_ARGS("as", states, "as", patterns),
3155 SD_BUS_RESULT("a(ssssssouso)", units),
3156 method_list_units_by_patterns,
3157 SD_BUS_VTABLE_UNPRIVILEGED),
3158 SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3159 SD_BUS_ARGS("as", names),
3160 SD_BUS_RESULT("a(ssssssouso)", units),
3161 method_list_units_by_names,
3162 SD_BUS_VTABLE_UNPRIVILEGED),
3163 SD_BUS_METHOD_WITH_ARGS("ListJobs",
3164 SD_BUS_NO_ARGS,
3165 SD_BUS_RESULT("a(usssoo)", jobs),
3166 method_list_jobs,
3167 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3168 SD_BUS_METHOD("Subscribe",
3169 NULL,
3170 NULL,
3171 method_subscribe,
3172 SD_BUS_VTABLE_UNPRIVILEGED),
3173 SD_BUS_METHOD("Unsubscribe",
3174 NULL,
3175 NULL,
3176 method_unsubscribe,
3177 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3178 SD_BUS_METHOD_WITH_ARGS("Dump",
3179 SD_BUS_NO_ARGS,
3180 SD_BUS_RESULT("s", output),
3181 method_dump,
3182 SD_BUS_VTABLE_UNPRIVILEGED),
293b9aa3 3183 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatterns",
d1d8786c
FB		 3184 SD_BUS_ARGS("as", patterns),
3185 SD_BUS_RESULT("s", output),
293b9aa3 3186 method_dump_units_matching_patterns,
d1d8786c 3187 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3188 SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3189 SD_BUS_NO_ARGS,
3190 SD_BUS_RESULT("h", fd),
3191 method_dump_by_fd,
3192 SD_BUS_VTABLE_UNPRIVILEGED),
f6cce15b
ZJS		 3193 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatternsByFileDescriptor",
3194 SD_BUS_ARGS("as", patterns),
3195 SD_BUS_RESULT("h", fd),
3196 method_dump_units_matching_patterns_by_fd,
3197 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3198 SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3199 SD_BUS_ARGS("s", name, "b", cleanup),
3200 SD_BUS_RESULT("o", unit),
3201 method_refuse_snapshot,
3202 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3203 SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3204 SD_BUS_ARGS("s", name),
3205 SD_BUS_NO_RESULT,
3206 method_refuse_snapshot,
3207 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
dad97f04
ZJS		 3208 SD_BUS_METHOD("Reload",
3209 NULL,
3210 NULL,
3211 method_reload,
3212 SD_BUS_VTABLE_UNPRIVILEGED),
3213 SD_BUS_METHOD("Reexecute",
3214 NULL,
3215 NULL,
3216 method_reexecute,
624f685f 3217 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_METHOD_NO_REPLY),
dad97f04
ZJS		 3218 SD_BUS_METHOD("Exit",
3219 NULL,
3220 NULL,
3221 method_exit,
3222 0),
3223 SD_BUS_METHOD("Reboot",
3224 NULL,
3225 NULL,
3226 method_reboot,
3227 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3228 SD_BUS_METHOD("PowerOff",
3229 NULL,
3230 NULL,
3231 method_poweroff,
3232 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3233 SD_BUS_METHOD("Halt",
3234 NULL,
3235 NULL,
3236 method_halt,
3237 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3238 SD_BUS_METHOD("KExec",
3239 NULL,
3240 NULL,
3241 method_kexec,
3242 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
a008b6d7 3243 SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3244 SD_BUS_ARGS("s", new_root, "s", init),
3245 SD_BUS_NO_RESULT,
3246 method_switch_root,
3247 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3248 SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3249 SD_BUS_ARGS("as", assignments),
3250 SD_BUS_NO_RESULT,
3251 method_set_environment,
3252 SD_BUS_VTABLE_UNPRIVILEGED),
3253 SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3254 SD_BUS_ARGS("as", names),
3255 SD_BUS_NO_RESULT,
3256 method_unset_environment,
3257 SD_BUS_VTABLE_UNPRIVILEGED),
3258 SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3259 SD_BUS_ARGS("as", names, "as", assignments),
3260 SD_BUS_NO_RESULT,
3261 method_unset_and_set_environment,
3262 SD_BUS_VTABLE_UNPRIVILEGED),
3263 SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3264 SD_BUS_NO_ARGS,
3265 SD_BUS_RESULT("ao", jobs),
3266 method_enqueue_marked_jobs,
3267 SD_BUS_VTABLE_UNPRIVILEGED),
3268 SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3269 SD_BUS_NO_ARGS,
3270 SD_BUS_RESULT("a(ss)", unit_files),
3271 method_list_unit_files,
3272 SD_BUS_VTABLE_UNPRIVILEGED),
3273 SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3274 SD_BUS_ARGS("as", states, "as", patterns),
3275 SD_BUS_RESULT("a(ss)", unit_files),
3276 method_list_unit_files_by_patterns,
3277 SD_BUS_VTABLE_UNPRIVILEGED),
3278 SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3279 SD_BUS_ARGS("s", file),
3280 SD_BUS_RESULT("s", state),
3281 method_get_unit_file_state,
3282 SD_BUS_VTABLE_UNPRIVILEGED),
3283 SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3284 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3285 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3286 method_enable_unit_files,
3287 SD_BUS_VTABLE_UNPRIVILEGED),
3288 SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3289 SD_BUS_ARGS("as", files, "b", runtime),
3290 SD_BUS_RESULT("a(sss)", changes),
3291 method_disable_unit_files,
3292 SD_BUS_VTABLE_UNPRIVILEGED),
3293 SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3294 SD_BUS_ARGS("as", files, "t", flags),
3295 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3296 method_enable_unit_files_with_flags,
3297 SD_BUS_VTABLE_UNPRIVILEGED),
3298 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3299 SD_BUS_ARGS("as", files, "t", flags),
3300 SD_BUS_RESULT("a(sss)", changes),
3301 method_disable_unit_files_with_flags,
3302 SD_BUS_VTABLE_UNPRIVILEGED),
bf1bea43
MY		 3303 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlagsAndInstallInfo",
3304 SD_BUS_ARGS("as", files, "t", flags),
3305 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3306 method_disable_unit_files_with_flags_and_install_info,
3307 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3308 SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3309 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3310 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3311 method_reenable_unit_files,
3312 SD_BUS_VTABLE_UNPRIVILEGED),
3313 SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3314 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3315 SD_BUS_RESULT("a(sss)", changes),
3316 method_link_unit_files,
3317 SD_BUS_VTABLE_UNPRIVILEGED),
3318 SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3319 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3320 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3321 method_preset_unit_files,
3322 SD_BUS_VTABLE_UNPRIVILEGED),
3323 SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3324 SD_BUS_ARGS("as", files, "s", mode, "b", runtime, "b", force),
3325 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3326 method_preset_unit_files_with_mode,
3327 SD_BUS_VTABLE_UNPRIVILEGED),
3328 SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3329 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3330 SD_BUS_RESULT("a(sss)", changes),
3331 method_mask_unit_files,
3332 SD_BUS_VTABLE_UNPRIVILEGED),
3333 SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3334 SD_BUS_ARGS("as", files, "b", runtime),
3335 SD_BUS_RESULT("a(sss)", changes),
3336 method_unmask_unit_files,
3337 SD_BUS_VTABLE_UNPRIVILEGED),
3338 SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3339 SD_BUS_ARGS("as", files),
3340 SD_BUS_RESULT("a(sss)", changes),
3341 method_revert_unit_files,
3342 SD_BUS_VTABLE_UNPRIVILEGED),
3343 SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3344 SD_BUS_ARGS("s", name, "b", force),
3345 SD_BUS_RESULT("a(sss)", changes),
3346 method_set_default_target,
3347 SD_BUS_VTABLE_UNPRIVILEGED),
3348 SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3349 SD_BUS_NO_ARGS,
3350 SD_BUS_RESULT("s", name),
3351 method_get_default_target,
3352 SD_BUS_VTABLE_UNPRIVILEGED),
3353 SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3354 SD_BUS_ARGS("s", mode, "b", runtime, "b", force),
3355 SD_BUS_RESULT("a(sss)", changes),
3356 method_preset_all_unit_files,
3357 SD_BUS_VTABLE_UNPRIVILEGED),
3358 SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3359 SD_BUS_ARGS("as", files, "s", target, "s", type, "b", runtime, "b", force),
3360 SD_BUS_RESULT("a(sss)", changes),
3361 method_add_dependency_unit_files,
3362 SD_BUS_VTABLE_UNPRIVILEGED),
3363 SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3364 SD_BUS_ARGS("s", name, "b", runtime),
3365 SD_BUS_RESULT("as", links),
3366 method_get_unit_file_links,
3367 SD_BUS_VTABLE_UNPRIVILEGED),
3368 SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3369 SD_BUS_ARGS("y", number),
3370 SD_BUS_NO_RESULT,
3371 method_set_exit_code,
3372 SD_BUS_VTABLE_UNPRIVILEGED),
3373 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3374 SD_BUS_ARGS("s", name),
3375 SD_BUS_RESULT("u", uid),
3376 method_lookup_dynamic_user_by_name,
3377 SD_BUS_VTABLE_UNPRIVILEGED),
3378 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3379 SD_BUS_ARGS("u", uid),
3380 SD_BUS_RESULT("s", name),
3381 method_lookup_dynamic_user_by_uid,
3382 SD_BUS_VTABLE_UNPRIVILEGED),
3383 SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3384 SD_BUS_NO_ARGS,
3385 SD_BUS_RESULT("a(us)", users),
3386 method_get_dynamic_users,
3387 SD_BUS_VTABLE_UNPRIVILEGED),
3388
3389 SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3390 SD_BUS_ARGS("s", id, "o", unit),
3391 0),
3392 SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3393 SD_BUS_ARGS("s", id, "o", unit),
3394 0),
3395 SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3396 SD_BUS_ARGS("u", id, "o", job, "s", unit),
3397 0),
3398 SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3399 SD_BUS_ARGS("u", id, "o", job, "s", unit, "s", result),
3400 0),
3401 SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3402 SD_BUS_ARGS("t", firmware, "t", loader, "t", kernel, "t", initrd, "t", userspace, "t", total),
3403 0),
718db961 3404 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
a008b6d7 3405 SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3406 SD_BUS_ARGS("b", active),
3407 0),
718db961
LP		 3408
3409 SD_BUS_VTABLE_END
ea430986 3410};
718db961 3411
893f801d
LP		 3412const sd_bus_vtable bus_manager_log_control_vtable[] = {
3413 SD_BUS_VTABLE_START(0),
3414
3415 /* We define a private version of this interface here, since we want slightly different
3416 * implementations for the setters. We'll still use the generic getters however, and we share the
3417 * setters with the implementations for the Manager interface above (which pre-dates the generic
3418 * service API interface). */
3419
3420 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3421 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3422 SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier, 0, 0),
3423
3424 SD_BUS_VTABLE_END,
3425};
3426
8f8f05a9 3427static int send_finished(sd_bus *bus, void *userdata) {
4afd3348 3428 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
99534007 3429 usec_t *times = ASSERT_PTR(userdata);
718db961
LP		 3430 int r;
3431
3432 assert(bus);
718db961 3433
cb31470f
ZJS		 3434 r = sd_bus_message_new_signal(bus,
3435 &message,
3436 "/org/freedesktop/systemd1",
3437 "org.freedesktop.systemd1.Manager",
3438 "StartupFinished");
718db961
LP		 3439 if (r < 0)
3440 return r;
3441
3442 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
3443 if (r < 0)
3444 return r;
3445
8f8f05a9 3446 return sd_bus_send(bus, message, NULL);
718db961
LP		 3447}
3448
39abcaee 3449void bus_manager_send_finished(
718db961
LP		 3450 Manager *m,
3451 usec_t firmware_usec,
3452 usec_t loader_usec,
3453 usec_t kernel_usec,
3454 usec_t initrd_usec,
3455 usec_t userspace_usec,
3456 usec_t total_usec) {
3457
39abcaee
LP		 3458 int r;
3459
718db961
LP		 3460 assert(m);
3461
8f8f05a9
LP		 3462 r = bus_foreach_bus(
3463 m,
3464 NULL,
3465 send_finished,
3466 (usec_t[6]) {
3467 firmware_usec,
3468 loader_usec,
3469 kernel_usec,
3470 initrd_usec,
3471 userspace_usec,
3472 total_usec
3473 });
39abcaee 3474 if (r < 0)
da927ba9 3475 log_debug_errno(r, "Failed to send finished signal: %m");
718db961
LP		 3476}
3477
8f8f05a9 3478static int send_reloading(sd_bus *bus, void *userdata) {
4afd3348 3479 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 3480 int r;
3481
3482 assert(bus);
3483
151b9b96 3484 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
718db961
LP		 3485 if (r < 0)
3486 return r;
3487
3488 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
3489 if (r < 0)
3490 return r;
3491
8f8f05a9 3492 return sd_bus_send(bus, message, NULL);
718db961
LP		 3493}
3494
39abcaee
LP		 3495void bus_manager_send_reloading(Manager *m, bool active) {
3496 int r;
3497
718db961
LP		 3498 assert(m);
3499
8f8f05a9 3500 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
39abcaee 3501 if (r < 0)
da927ba9 3502 log_debug_errno(r, "Failed to send reloading signal: %m");
03455c28
LDM		 3503}
3504
3505static int send_changed_signal(sd_bus *bus, void *userdata) {
3506 assert(bus);
3507
3508 return sd_bus_emit_properties_changed_strv(bus,
3509 "/org/freedesktop/systemd1",
3510 "org.freedesktop.systemd1.Manager",
3511 NULL);
3512}
39abcaee 3513
03455c28
LDM		 3514void bus_manager_send_change_signal(Manager *m) {
3515 int r;
3516
3517 assert(m);
3518
3519 r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
3520 if (r < 0)
3521 log_debug_errno(r, "Failed to send manager change signal: %m");
718db961 3522}
Unnamed repository; edit this file 'description' to name the repository.