]> 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
core/dbus-manager: also show DefaultIOAccounting and DefaultIPAccounting
[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"
f461a28d 14#include "chase.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
d9365956
LB		 1416 /* 'status' access is the bare minimum always needed for this, as the policy might straight out
1417 * forbid a client from querying any information from systemd, regardless of any rate limiting. */
8a188de9 1418 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 1419 if (r < 0)
1420 return r;
ea430986 1421
d9365956
LB		 1422 /* Rate limit reached? Check if the caller is privileged/allowed by policy to bypass this. We
1423 * check the rate limit first to avoid the expensive roundtrip to polkit when not needed. */
1424 if (!ratelimit_below(&m->dump_ratelimit)) {
1425 /* We need a way for SELinux to constrain the operation when the rate limit is active, even
1426 * if polkit would allow it, but we cannot easily add new named permissions, so we need to
1427 * use an existing one. Reload/reexec are also slow but non-destructive/modifying
1428 * operations, and can cause PID1 to stall. So it seems similar enough in terms of security
1429 * considerations and impact, and thus use the same access check for dumps which, given the
1430 * large amount of data to fetch, can stall PID1 for quite some time. */
1431 r = mac_selinux_access_check(message, "reload", error);
1432 if (r < 0)
1433 goto ratelimited;
1434
1435 r = bus_verify_bypass_dump_ratelimit_async(m, message, error);
1436 if (r < 0)
1437 goto ratelimited;
1438 if (r == 0)
1439 /* No authorization for now, but the async polkit stuff will call us again when it
1440 * has it */
1441 return 1;
1442 }
1443
d1d8786c 1444 r = manager_get_dump_string(m, patterns, &dump);
dacd6cee
LP		 1445 if (r < 0)
1446 return r;
a16e1123 1447
c0a1bfac 1448 return reply(message, dump);
d9365956
LB		 1449
1450ratelimited:
1451 log_warning("Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1452 FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
1453 return sd_bus_error_setf(error,
1454 SD_BUS_ERROR_LIMITS_EXCEEDED,
1455 "Dump request rejected due to rate limit on unprivileged callers, blocked for %s.",
1456 FORMAT_TIMESPAN(ratelimit_left(&m->dump_ratelimit), USEC_PER_SEC));
c0a1bfac
DT		 1457}
1458
1459static int reply_dump(sd_bus_message *message, char *dump) {
df2d202e 1460 return sd_bus_reply_method_return(message, "s", dump);
718db961 1461}
cad45ba1 1462
c0a1bfac 1463static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c 1464 return dump_impl(message, userdata, error, NULL, reply_dump);
c0a1bfac
DT		 1465}
1466
1467static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
254d1313 1468 _cleanup_close_ int fd = -EBADF;
c0a1bfac
DT		 1469
1470 fd = acquire_data_fd(dump, strlen(dump), 0);
1471 if (fd < 0)
1472 return fd;
1473
1474 return sd_bus_reply_method_return(message, "h", fd);
1475}
1476
1477static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d1d8786c
FB		 1478 return dump_impl(message, userdata, error, NULL, reply_dump_by_fd);
1479}
1480
f6cce15b
ZJS		 1481static int dump_units_matching_patterns(
1482 sd_bus_message *message,
1483 void *userdata,
1484 sd_bus_error *error,
1485 int (*reply)(sd_bus_message *, char *)) {
d1d8786c
FB		 1486 _cleanup_strv_free_ char **patterns = NULL;
1487 int r;
1488
1489 r = sd_bus_message_read_strv(message, &patterns);
1490 if (r < 0)
1491 return r;
1492
f6cce15b
ZJS		 1493 return dump_impl(message, userdata, error, patterns, reply);
1494}
1495
1496static int method_dump_units_matching_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1497 return dump_units_matching_patterns(message, userdata, error, reply_dump);
1498}
1499
1500static int method_dump_units_matching_patterns_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1501 return dump_units_matching_patterns(message, userdata, error, reply_dump_by_fd);
c0a1bfac
DT		 1502}
1503
36b4a7ba 1504static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1b09b81c 1505 return sd_bus_error_set(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
718db961 1506}
cad45ba1 1507
c23e9b6a 1508static int get_run_space(uint64_t *ret, sd_bus_error *error) {
ae57dad3 1509 struct statvfs svfs;
c23e9b6a
LP		 1510
1511 assert(ret);
ae57dad3
LP		 1512
1513 if (statvfs("/run/systemd", &svfs) < 0)
1514 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1515
c23e9b6a
LP		 1516 *ret = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1517 return 0;
1518}
1519
1520static int verify_run_space(const char *message, sd_bus_error *error) {
1521 uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1522 int r;
1523
1524 assert(message);
1525
1526 r = get_run_space(&available, error);
1527 if (r < 0)
1528 return r;
ae57dad3 1529
2b59bf51 1530 if (available < RELOAD_DISK_SPACE_MIN)
ae57dad3
LP		 1531 return sd_bus_error_setf(error,
1532 BUS_ERROR_DISK_FULL,
c23e9b6a 1533 "%s, not enough space available on /run/systemd/. "
ae57dad3
LP		 1534 "Currently, %s are free, but a safety buffer of %s is enforced.",
1535 message,
2b59bf51
ZJS		 1536 FORMAT_BYTES(available),
1537 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
ae57dad3
LP		 1538
1539 return 0;
1540}
1541
1542int verify_run_space_and_log(const char *message) {
4dae8ae6 1543 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
ae57dad3
LP		 1544 int r;
1545
c23e9b6a
LP		 1546 assert(message);
1547
ae57dad3
LP		 1548 r = verify_run_space(message, &error);
1549 if (r < 0)
4ae25393 1550 return log_error_errno(r, "%s", bus_error_message(&error, r));
ae57dad3 1551
4ae25393 1552 return 0;
ae57dad3
LP		 1553}
1554
c23e9b6a
LP		 1555static int verify_run_space_permissive(const char *message, sd_bus_error *error) {
1556 uint64_t available = 0; /* unnecessary, but used to trick out gcc's incorrect maybe-uninitialized warning */
1557 int r;
1558
1559 assert(message);
1560
1561 r = get_run_space(&available, error);
1562 if (r < 0)
1563 return r;
1564
1565 if (available < RELOAD_DISK_SPACE_MIN)
1566 log_warning("Dangerously low amount of free space on /run/systemd/, %s.\n"
1567 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1568 message,
1569 FORMAT_BYTES(available),
1570 FORMAT_BYTES(RELOAD_DISK_SPACE_MIN));
1571
1572 return 0;
1573}
1574
4895bacc 1575static void log_caller(sd_bus_message *message, Manager *manager, const char *method) {
9524c2fd
LB		 1576 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
1577 const char *comm = NULL;
1578 Unit *caller;
1579 pid_t pid;
1580
1581 assert(message);
1582 assert(manager);
4895bacc 1583 assert(method);
9524c2fd
LB		 1584
1585 if (sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID|SD_BUS_CREDS_AUGMENT|SD_BUS_CREDS_COMM, &creds) < 0)
1586 return;
1587
1588 /* We need at least the PID, otherwise there's nothing to log, the rest is optional */
1589 if (sd_bus_creds_get_pid(creds, &pid) < 0)
1590 return;
1591
1592 (void) sd_bus_creds_get_comm(creds, &comm);
1593 caller = manager_get_unit_by_pid(manager, pid);
1594
1980a25d
ZJS		 1595 log_info("%s requested from client PID " PID_FMT "%s%s%s%s%s%s...",
1596 method, pid,
1597 comm ? " ('" : "", strempty(comm), comm ? "')" : "",
add74820 1598 caller ? " (unit " : "", caller ? caller->id : "", caller ? ")" : "");
9524c2fd
LB		 1599}
1600
19070062 1601static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1602 Manager *m = ASSERT_PTR(userdata);
718db961 1603 int r;
6652a2b9 1604
718db961 1605 assert(message);
6652a2b9 1606
ae57dad3
LP		 1607 r = verify_run_space("Refusing to reload", error);
1608 if (r < 0)
1609 return r;
1610
1d22e906 1611 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1612 if (r < 0)
1613 return r;
283868e1 1614
1d22e906 1615 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1616 if (r < 0)
1617 return r;
1d22e906
LP		 1618 if (r == 0)
1619 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
6652a2b9 1620
9524c2fd 1621 /* Write a log message noting the unit or process who requested the Reload() */
4895bacc 1622 log_caller(message, m, "Reloading");
9524c2fd 1623
856bfaeb
LB		 1624 /* Check the rate limit after the authorization succeeds, to avoid denial-of-service issues. */
1625 if (!ratelimit_below(&m->reload_ratelimit)) {
1626 log_warning("Reloading request rejected due to rate limit.");
1627 return sd_bus_error_setf(error,
1628 SD_BUS_ERROR_LIMITS_EXCEEDED,
1629 "Reload() request rejected due to rate limit.");
1630 }
1631
718db961
LP		 1632 /* Instead of sending the reply back right away, we just
1633 * remember that we need to and then send it after the reload
1634 * is finished. That way the caller knows when the reload
1635 * finished. */
6652a2b9 1636
209de525
LP		 1637 assert(!m->pending_reload_message);
1638 r = sd_bus_message_new_method_return(message, &m->pending_reload_message);
718db961 1639 if (r < 0)
ebcf1f97 1640 return r;
cad45ba1 1641
af41e508 1642 m->objective = MANAGER_RELOAD;
6652a2b9 1643
718db961
LP		 1644 return 1;
1645}
6652a2b9 1646
19070062 1647static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1648 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1649 int r;
6652a2b9 1650
718db961 1651 assert(message);
6652a2b9 1652
ae57dad3
LP		 1653 r = verify_run_space("Refusing to reexecute", error);
1654 if (r < 0)
1655 return r;
1656
1d22e906 1657 r = mac_selinux_access_check(message, "reload", error);
283868e1
SW		 1658 if (r < 0)
1659 return r;
283868e1 1660
1d22e906 1661 r = bus_verify_reload_daemon_async(m, message, error);
ebcf1f97
LP		 1662 if (r < 0)
1663 return r;
1d22e906
LP		 1664 if (r == 0)
1665 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
cad45ba1 1666
4895bacc
LB		 1667 /* Write a log message noting the unit or process who requested the Reexecute() */
1668 log_caller(message, m, "Reexecuting");
1669
718db961
LP		 1670 /* We don't send a reply back here, the client should
1671 * just wait for us disconnecting. */
6652a2b9 1672
af41e508 1673 m->objective = MANAGER_REEXECUTE;
718db961
LP		 1674 return 1;
1675}
6652a2b9 1676
19070062 1677static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1678 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1679 int r;
6652a2b9 1680
718db961 1681 assert(message);
6652a2b9 1682
8a188de9 1683 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1684 if (r < 0)
1685 return r;
cad45ba1 1686
287419c1
AC		 1687 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1688 * we are running on the host. It will fall back on reboot() in
1689 * systemd-shutdown if it cannot do the exit() because it isn't a
1690 * container. */
6652a2b9 1691
af41e508 1692 m->objective = MANAGER_EXIT;
6652a2b9 1693
df2d202e 1694 return sd_bus_reply_method_return(message, NULL);
718db961 1695}
6652a2b9 1696
19070062 1697static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1698 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1699 int r;
664f88a7 1700
718db961 1701 assert(message);
cad45ba1 1702
8a188de9 1703 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1704 if (r < 0)
1705 return r;
664f88a7 1706
463d0d15 1707 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1708 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1709 "Reboot is only supported for system managers.");
664f88a7 1710
af41e508 1711 m->objective = MANAGER_REBOOT;
664f88a7 1712
df2d202e 1713 return sd_bus_reply_method_return(message, NULL);
718db961 1714}
664f88a7 1715
13ffc607
LP		 1716static int method_soft_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1717 _cleanup_free_ char *rt = NULL;
1718 Manager *m = ASSERT_PTR(userdata);
1719 const char *root;
1720 int r;
1721
1722 assert(message);
1723
1724 r = verify_run_space_permissive("soft reboot may fail", error);
1725 if (r < 0)
1726 return r;
1727
1728 r = mac_selinux_access_check(message, "reboot", error);
1729 if (r < 0)
1730 return r;
1731
1732 r = sd_bus_message_read(message, "s", &root);
1733 if (r < 0)
1734 return r;
1735
1736 if (!isempty(root)) {
1737 if (!path_is_valid(root))
1738 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1739 "New root directory '%s' must be a valid path.", root);
1740 if (!path_is_absolute(root))
1741 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1742 "New root directory path '%s' is not absolute.", root);
1743
1744 rt = strdup(root);
1745 if (!rt)
1746 return -ENOMEM;
1747 }
1748
1749 free_and_replace(m->switch_root, rt);
1750 m->objective = MANAGER_SOFT_REBOOT;
1751
1752 return sd_bus_reply_method_return(message, NULL);
1753}
1754
19070062 1755static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1756 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1757 int r;
50913bc0 1758
718db961 1759 assert(message);
1137a57c 1760
8a188de9 1761 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1762 if (r < 0)
1763 return r;
1137a57c 1764
463d0d15 1765 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1766 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1767 "Powering off is only supported for system managers.");
1137a57c 1768
af41e508 1769 m->objective = MANAGER_POWEROFF;
1137a57c 1770
df2d202e 1771 return sd_bus_reply_method_return(message, NULL);
718db961 1772}
1137a57c 1773
19070062 1774static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1775 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1776 int r;
1137a57c 1777
718db961 1778 assert(message);
8d0e38a2 1779
8a188de9 1780 r = mac_selinux_access_check(message, "halt", error);
ebcf1f97
LP		 1781 if (r < 0)
1782 return r;
cad45ba1 1783
463d0d15 1784 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1785 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1786 "Halt is only supported for system managers.");
8d0e38a2 1787
af41e508 1788 m->objective = MANAGER_HALT;
8d0e38a2 1789
df2d202e 1790 return sd_bus_reply_method_return(message, NULL);
718db961 1791}
8d0e38a2 1792
19070062 1793static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 1794 Manager *m = ASSERT_PTR(userdata);
ebcf1f97 1795 int r;
8d0e38a2 1796
718db961 1797 assert(message);
c0576cd6 1798
8a188de9 1799 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1800 if (r < 0)
1801 return r;
cad45ba1 1802
463d0d15 1803 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1804 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1805 "KExec is only supported for system managers.");
c0576cd6 1806
af41e508 1807 m->objective = MANAGER_KEXEC;
c0576cd6 1808
df2d202e 1809 return sd_bus_reply_method_return(message, NULL);
718db961 1810}
c0576cd6 1811
19070062 1812static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
87a19bfe 1813 _cleanup_free_ char *ri = NULL, *rt = NULL;
99534007 1814 Manager *m = ASSERT_PTR(userdata);
13ffc607 1815 const char *root, *init;
718db961 1816 int r;
c0576cd6 1817
718db961 1818 assert(message);
c0576cd6 1819
c23e9b6a
LP		 1820 r = verify_run_space_permissive("root switching may fail", error);
1821 if (r < 0)
1822 return r;
ae57dad3 1823
8a188de9 1824 r = mac_selinux_access_check(message, "reboot", error);
ebcf1f97
LP		 1825 if (r < 0)
1826 return r;
c0576cd6 1827
463d0d15 1828 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 1829 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
1830 "Root switching is only supported by system manager.");
c0576cd6 1831
718db961
LP		 1832 r = sd_bus_message_read(message, "ss", &root, &init);
1833 if (r < 0)
ebcf1f97 1834 return r;
c0576cd6 1835
5ae89ef3
LP		 1836 if (isempty(root))
1837 /* If path is not specified, default to "/sysroot" which is what we generally expect initrds
1838 * to use */
1839 root = "/sysroot";
1840 else {
1841 if (!path_is_valid(root))
1842 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1843 "New root directory must be a valid path.");
1844 if (!path_is_absolute(root))
1845 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1846 "New root path '%s' is not absolute.", root);
1847 if (path_equal(root, "/"))
1848 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1849 "New root directory cannot be the old root directory.");
1850 }
c0576cd6 1851
718db961
LP		 1852 /* Safety check */
1853 if (isempty(init)) {
710028b4
LP		 1854 r = path_is_os_tree(root);
1855 if (r < 0)
cb31470f
ZJS		 1856 return sd_bus_error_set_errnof(error, r,
1857 "Failed to determine whether root path '%s' contains an OS tree: %m",
1858 root);
710028b4 1859 if (r == 0)
cb31470f
ZJS		 1860 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1861 "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.",
1862 root);
718db961 1863 } else {
5f4c9c27
LP		 1864 if (!path_is_valid(init))
1865 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1866 "Path to init binary '%s' is not a valid path.", init);
1867
718db961 1868 if (!path_is_absolute(init))
cb31470f
ZJS		 1869 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1870 "Path to init binary '%s' not absolute.", init);
c0576cd6 1871
f461a28d 1872 r = chase_and_access(init, root, CHASE_PREFIX_ROOT, X_OK, NULL);
e10086ac
LP		 1873 if (r == -EACCES)
1874 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1875 "Init binary %s is not executable.", init);
710028b4 1876 if (r < 0)
cb31470f
ZJS		 1877 return sd_bus_error_set_errnof(error, r,
1878 "Could not resolve init executable %s: %m", init);
718db961
LP		 1879 }
1880
1881 rt = strdup(root);
1882 if (!rt)
ebcf1f97 1883 return -ENOMEM;
718db961
LP		 1884
1885 if (!isempty(init)) {
1886 ri = strdup(init);
87a19bfe 1887 if (!ri)
ebcf1f97 1888 return -ENOMEM;
718db961 1889 }
c0576cd6 1890
87a19bfe
YW		 1891 free_and_replace(m->switch_root, rt);
1892 free_and_replace(m->switch_root_init, ri);
c0576cd6 1893
af41e508 1894 m->objective = MANAGER_SWITCH_ROOT;
92b315df 1895
df2d202e 1896 return sd_bus_reply_method_return(message, NULL);
718db961 1897}
c0576cd6 1898
19070062 1899static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1900 _cleanup_strv_free_ char **plus = NULL;
99534007 1901 Manager *m = ASSERT_PTR(userdata);
718db961 1902 int r;
c0576cd6 1903
718db961 1904 assert(message);
cad45ba1 1905
8a188de9 1906 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1907 if (r < 0)
1908 return r;
c0576cd6 1909
718db961
LP		 1910 r = sd_bus_message_read_strv(message, &plus);
1911 if (r < 0)
ebcf1f97 1912 return r;
718db961 1913 if (!strv_env_is_valid(plus))
1b09b81c 1914 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
c0576cd6 1915
1d22e906
LP		 1916 r = bus_verify_set_environment_async(m, message, error);
1917 if (r < 0)
1918 return r;
1919 if (r == 0)
1920 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1921
1ad6e8b3 1922 r = manager_client_environment_modify(m, NULL, plus);
718db961 1923 if (r < 0)
ebcf1f97 1924 return r;
c0576cd6 1925
df2d202e 1926 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1927}
1928
19070062 1929static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1930 _cleanup_strv_free_ char **minus = NULL;
99534007 1931 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1932 int r;
1933
718db961 1934 assert(message);
718db961 1935
8a188de9 1936 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1937 if (r < 0)
1938 return r;
c0576cd6 1939
718db961
LP		 1940 r = sd_bus_message_read_strv(message, &minus);
1941 if (r < 0)
ebcf1f97 1942 return r;
718db961
LP		 1943
1944 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1945 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1946 "Invalid environment variable names or assignments");
718db961 1947
1d22e906
LP		 1948 r = bus_verify_set_environment_async(m, message, error);
1949 if (r < 0)
1950 return r;
1951 if (r == 0)
1952 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1953
1ad6e8b3 1954 r = manager_client_environment_modify(m, minus, NULL);
718db961 1955 if (r < 0)
ebcf1f97 1956 return r;
718db961 1957
df2d202e 1958 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1959}
1960
19070062 1961static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 1962 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
99534007 1963 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 1964 int r;
1965
718db961 1966 assert(message);
718db961 1967
8a188de9 1968 r = mac_selinux_access_check(message, "reload", error);
ebcf1f97
LP		 1969 if (r < 0)
1970 return r;
718db961 1971
eb6c7d20 1972 r = sd_bus_message_read_strv(message, &minus);
718db961 1973 if (r < 0)
ebcf1f97 1974 return r;
718db961 1975
eb6c7d20 1976 r = sd_bus_message_read_strv(message, &plus);
718db961 1977 if (r < 0)
ebcf1f97 1978 return r;
718db961 1979
718db961 1980 if (!strv_env_name_or_assignment_is_valid(minus))
cb31470f
ZJS		 1981 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1982 "Invalid environment variable names or assignments");
eb6c7d20 1983 if (!strv_env_is_valid(plus))
cb31470f
ZJS		 1984 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
1985 "Invalid environment assignments");
718db961 1986
1d22e906
LP		 1987 r = bus_verify_set_environment_async(m, message, error);
1988 if (r < 0)
1989 return r;
1990 if (r == 0)
1991 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1992
1ad6e8b3 1993 r = manager_client_environment_modify(m, minus, plus);
718db961 1994 if (r < 0)
ebcf1f97 1995 return r;
718db961 1996
df2d202e 1997 return sd_bus_reply_method_return(message, NULL);
718db961
LP		 1998}
1999
287419c1 2000static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2001 Manager *m = ASSERT_PTR(userdata);
29206d46 2002 uint8_t code;
287419c1
AC		 2003 int r;
2004
2005 assert(message);
287419c1
AC		 2006
2007 r = mac_selinux_access_check(message, "exit", error);
2008 if (r < 0)
2009 return r;
2010
2011 r = sd_bus_message_read_basic(message, 'y', &code);
2012 if (r < 0)
2013 return r;
2014
287419c1
AC		 2015 m->return_value = code;
2016
2017 return sd_bus_reply_method_return(message, NULL);
2018}
2019
29206d46 2020static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2021 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 2022 const char *name;
2023 uid_t uid;
2024 int r;
2025
2026 assert(message);
29206d46
LP		 2027
2028 r = sd_bus_message_read_basic(message, 's', &name);
2029 if (r < 0)
2030 return r;
2031
2032 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2033 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2034 "Dynamic users are only supported in the system instance.");
7a8867ab 2035 if (!valid_user_group_name(name, VALID_USER_RELAX))
cb31470f
ZJS		 2036 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2037 "User name invalid: %s", name);
29206d46
LP		 2038
2039 r = dynamic_user_lookup_name(m, name, &uid);
2040 if (r == -ESRCH)
cb31470f
ZJS		 2041 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2042 "Dynamic user %s does not exist.", name);
29206d46
LP		 2043 if (r < 0)
2044 return r;
2045
2046 return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
2047}
2048
2049static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2050 _cleanup_free_ char *name = NULL;
99534007 2051 Manager *m = ASSERT_PTR(userdata);
29206d46
LP		 2052 uid_t uid;
2053 int r;
2054
2055 assert(message);
29206d46 2056
60d0a509 2057 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
29206d46
LP		 2058 r = sd_bus_message_read_basic(message, 'u', &uid);
2059 if (r < 0)
2060 return r;
2061
2062 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2063 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2064 "Dynamic users are only supported in the system instance.");
29206d46 2065 if (!uid_is_valid(uid))
cb31470f
ZJS		 2066 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2067 "User ID invalid: " UID_FMT, uid);
29206d46
LP		 2068
2069 r = dynamic_user_lookup_uid(m, uid, &name);
2070 if (r == -ESRCH)
cb31470f
ZJS		 2071 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER,
2072 "Dynamic user ID " UID_FMT " does not exist.", uid);
29206d46
LP		 2073 if (r < 0)
2074 return r;
2075
2076 return sd_bus_reply_method_return(message, "s", name);
2077}
2078
f9bfa696
YW		 2079static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2080 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 2081 Manager *m = ASSERT_PTR(userdata);
f9bfa696 2082 DynamicUser *d;
f9bfa696
YW		 2083 int r;
2084
2085 assert(message);
f9bfa696
YW		 2086
2087 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
2088
2089 if (!MANAGER_IS_SYSTEM(m))
cb31470f
ZJS		 2090 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED,
2091 "Dynamic users are only supported in the system instance.");
f9bfa696
YW		 2092
2093 r = sd_bus_message_new_method_return(message, &reply);
2094 if (r < 0)
2095 return r;
2096
2097 r = sd_bus_message_open_container(reply, 'a', "(us)");
2098 if (r < 0)
2099 return r;
2100
90e74a66 2101 HASHMAP_FOREACH(d, m->dynamic_users) {
f9bfa696
YW		 2102 uid_t uid;
2103
2104 r = dynamic_user_current(d, &uid);
2105 if (r == -EAGAIN) /* not realized yet? */
2106 continue;
2107 if (r < 0)
cb31470f
ZJS		 2108 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED,
2109 "Failed to look up a dynamic user.");
f9bfa696
YW		 2110
2111 r = sd_bus_message_append(reply, "(us)", uid, d->name);
2112 if (r < 0)
2113 return r;
2114 }
2115
2116 r = sd_bus_message_close_container(reply);
2117 if (r < 0)
2118 return r;
2119
2120 return sd_bus_send(NULL, reply, NULL);
2121}
2122
70666e28 2123static int method_enqueue_marked_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2124 Manager *m = ASSERT_PTR(userdata);
70666e28
ZJS		 2125 int r;
2126
2127 assert(message);
70666e28
ZJS		 2128
2129 r = mac_selinux_access_check(message, "start", error);
2130 if (r < 0)
2131 return r;
2132
2133 r = bus_verify_manage_units_async(m, message, error);
2134 if (r < 0)
2135 return r;
2136 if (r == 0)
2137 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2138
28e5e1e9 2139 log_info("Queuing reload/restart jobs for marked units%s", special_glyph(SPECIAL_GLYPH_ELLIPSIS));
70666e28
ZJS		 2140
2141 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2142 r = sd_bus_message_new_method_return(message, &reply);
2143 if (r < 0)
2144 return r;
2145
2146 r = sd_bus_message_open_container(reply, 'a', "o");
2147 if (r < 0)
2148 return r;
2149
2150 Unit *u;
2151 char *k;
2152 int ret = 0;
2153 HASHMAP_FOREACH_KEY(u, k, m->units) {
2154 /* ignore aliases */
2155 if (u->id != k)
2156 continue;
2157
2158 BusUnitQueueFlags flags;
2159 if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RESTART))
2160 flags = 0;
2161 else if (FLAGS_SET(u->markers, 1u << UNIT_MARKER_NEEDS_RELOAD))
2162 flags = BUS_UNIT_QUEUE_RELOAD_IF_POSSIBLE;
2163 else
2164 continue;
2165
2166 r = mac_selinux_unit_access_check(u, message, "start", error);
2167 if (r >= 0)
2168 r = bus_unit_queue_job_one(message, u,
2169 JOB_TRY_RESTART, JOB_FAIL, flags,
2170 reply, error);
2171 if (r < 0) {
2172 if (ERRNO_IS_RESOURCE(r))
2173 return r;
2174 if (ret >= 0)
2175 ret = r;
2176 sd_bus_error_free(error);
2177 }
2178 }
2179
2180 if (ret < 0)
2181 return sd_bus_error_set_errnof(error, ret,
2182 "Failed to enqueue some jobs, see logs for details: %m");
2183
2184 r = sd_bus_message_close_container(reply);
2185 if (r < 0)
2186 return r;
2187
2188 return sd_bus_send(NULL, reply, NULL);
2189}
2190
313fe66f 2191static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
4afd3348 2192 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
99534007 2193 Manager *m = ASSERT_PTR(userdata);
718db961 2194 UnitFileList *item;
5d2a48da 2195 _cleanup_hashmap_free_ Hashmap *h = NULL;
718db961
LP		 2196 int r;
2197
718db961 2198 assert(message);
718db961 2199
283868e1
SW		 2200 /* Anyone can call this method */
2201
8a188de9 2202 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2203 if (r < 0)
2204 return r;
718db961 2205
df2d202e 2206 r = sd_bus_message_new_method_return(message, &reply);
718db961 2207 if (r < 0)
ebcf1f97 2208 return r;
c0576cd6 2209
066ba68e 2210 h = hashmap_new(&unit_file_list_hash_ops_free);
718db961 2211 if (!h)
ebcf1f97 2212 return -ENOMEM;
c0576cd6 2213
4870133b 2214 r = unit_file_get_list(m->runtime_scope, NULL, h, states, patterns);
ebcf1f97 2215 if (r < 0)
066ba68e 2216 return r;
718db961
LP		 2217
2218 r = sd_bus_message_open_container(reply, 'a', "(ss)");
ebcf1f97 2219 if (r < 0)
066ba68e 2220 return r;
718db961 2221
90e74a66 2222 HASHMAP_FOREACH(item, h) {
718db961
LP		 2223
2224 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
ebcf1f97 2225 if (r < 0)
066ba68e 2226 return r;
718db961 2227 }
c0576cd6 2228
718db961
LP		 2229 r = sd_bus_message_close_container(reply);
2230 if (r < 0)
ebcf1f97 2231 return r;
8d0e38a2 2232
9030ca46 2233 return sd_bus_send(NULL, reply, NULL);
718db961 2234}
99504dd4 2235
313fe66f 2236static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2237 return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
2238}
2239
2240static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2241 _cleanup_strv_free_ char **states = NULL;
2242 _cleanup_strv_free_ char **patterns = NULL;
2243 int r;
2244
2245 r = sd_bus_message_read_strv(message, &states);
2246 if (r < 0)
2247 return r;
2248
2249 r = sd_bus_message_read_strv(message, &patterns);
2250 if (r < 0)
2251 return r;
2252
2253 return list_unit_files_by_patterns(message, userdata, error, states, patterns);
2254}
2255
19070062 2256static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2257 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2258 const char *name;
2259 UnitFileState state;
718db961 2260 int r;
99504dd4 2261
718db961 2262 assert(message);
8e2af478 2263
283868e1
SW		 2264 /* Anyone can call this method */
2265
8a188de9 2266 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2267 if (r < 0)
2268 return r;
8e2af478 2269
718db961
LP		 2270 r = sd_bus_message_read(message, "s", &name);
2271 if (r < 0)
ebcf1f97 2272 return r;
8e2af478 2273
4870133b 2274 r = unit_file_get_state(m->runtime_scope, NULL, name, &state);
0ec0deaa
LP		 2275 if (r < 0)
2276 return r;
8e2af478 2277
df2d202e 2278 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
718db961 2279}
8e2af478 2280
19070062 2281static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
718db961 2282 _cleanup_free_ char *default_target = NULL;
99534007 2283 Manager *m = ASSERT_PTR(userdata);
718db961 2284 int r;
c2756a68 2285
718db961 2286 assert(message);
c2756a68 2287
283868e1
SW		 2288 /* Anyone can call this method */
2289
8a188de9 2290 r = mac_selinux_access_check(message, "status", error);
ebcf1f97
LP		 2291 if (r < 0)
2292 return r;
c2756a68 2293
4870133b 2294 r = unit_file_get_default(m->runtime_scope, NULL, &default_target);
7c78a193
DT		 2295 if (r == -ERFKILL)
2296 sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED, "Unit file is masked.");
718db961 2297 if (r < 0)
ebcf1f97 2298 return r;
c2756a68 2299
df2d202e 2300 return sd_bus_reply_method_return(message, "s", default_target);
718db961 2301}
c2756a68 2302
8f8f05a9 2303static int send_unit_files_changed(sd_bus *bus, void *userdata) {
4afd3348 2304 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 2305 int r;
2306
2307 assert(bus);
2308
cb31470f
ZJS		 2309 r = sd_bus_message_new_signal(bus, &message,
2310 "/org/freedesktop/systemd1",
2311 "org.freedesktop.systemd1.Manager",
2312 "UnitFilesChanged");
718db961
LP		 2313 if (r < 0)
2314 return r;
2315
8f8f05a9 2316 return sd_bus_send(bus, message, NULL);
718db961
LP		 2317}
2318
af3d8113
ZJS		 2319/* Create an error reply, using the error information from changes[]
2320 * if possible, and fall back to generating an error from error code c.
2321 * The error message only describes the first error.
af3d8113
ZJS		 2322 */
2323static int install_error(
2324 sd_bus_error *error,
2325 int c,
cd44ec5a 2326 InstallChange *changes,
da6053d0
LP		 2327 size_t n_changes) {
2328
f8888b9a 2329 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
8e20adca 2330
fe96c0f8 2331 for (size_t i = 0; i < n_changes; i++)
637d6e5b 2332
5ad58fea 2333 /* When making changes here, make sure to also change install_changes_dump() in install.c. */
637d6e5b 2334
5ad58fea 2335 switch (changes[i].type) {
f8662fee
LP		 2336 case 0 ... _INSTALL_CHANGE_TYPE_MAX: /* not errors */
2337 break;
637d6e5b 2338
af3d8113
ZJS		 2339 case -EEXIST:
2340 if (changes[i].source)
f8888b9a
DT		 2341 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2342 "File %s already exists and is a symlink to %s.",
2343 changes[i].path, changes[i].source);
2344 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
2345 "File %s already exists.",
2346 changes[i].path);
637d6e5b 2347
af3d8113 2348 case -ERFKILL:
f8888b9a
DT		 2349 return sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED,
2350 "Unit file %s is masked.", changes[i].path);
637d6e5b 2351
af3d8113 2352 case -EADDRNOTAVAIL:
f8888b9a
DT		 2353 return sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED,
2354 "Unit %s is transient or generated.", changes[i].path);
637d6e5b 2355
a6f318a5 2356 case -ETXTBSY:
f8888b9a
DT		 2357 return sd_bus_error_setf(error, BUS_ERROR_UNIT_BAD_PATH,
2358 "File %s is under the systemd unit hierarchy already.", changes[i].path);
a6f318a5 2359
c89d0c3b 2360 case -EBADSLT:
f8888b9a
DT		 2361 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2362 "Invalid specifier in %s.", changes[i].path);
c89d0c3b
JM		 2363
2364 case -EIDRM:
f8888b9a
DT		 2365 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2366 "Destination unit %s is a non-template unit.", changes[i].path);
c89d0c3b 2367
d7ceaf72 2368 case -EUCLEAN:
f8888b9a
DT		 2369 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2370 "\"%s\" is not a valid unit name.",
2371 changes[i].path);
d7ceaf72 2372
af3d8113 2373 case -ELOOP:
f8888b9a
DT		 2374 return sd_bus_error_setf(error, BUS_ERROR_UNIT_LINKED,
2375 "Refusing to operate on alias name or linked unit file: %s",
2376 changes[i].path);
637d6e5b 2377
c89d0c3b
JM		 2378 case -EXDEV:
2379 if (changes[i].source)
f8888b9a
DT		 2380 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2381 "Cannot alias %s as %s.",
2382 changes[i].source, changes[i].path);
2383 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2384 "Invalid unit reference %s.", changes[i].path);
c89d0c3b 2385
637d6e5b 2386 case -ENOENT:
f8888b9a
DT		 2387 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT,
2388 "Unit file %s does not exist.", changes[i].path);
637d6e5b 2389
c89d0c3b 2390 case -EUNATCH:
f8888b9a
DT		 2391 return sd_bus_error_setf(error, BUS_ERROR_BAD_UNIT_SETTING,
2392 "Cannot resolve specifiers in %s.", changes[i].path);
c89d0c3b 2393
af3d8113 2394 default:
f8662fee 2395 assert(changes[i].type < 0); /* other errors */
f8888b9a 2396 return sd_bus_error_set_errnof(error, changes[i].type, "File %s: %m", changes[i].path);
af3d8113 2397 }
8e20adca 2398
f8888b9a 2399 return c < 0 ? c : -EINVAL;
8e20adca
LP		 2400}
2401
cd44ec5a 2402static int reply_install_changes_and_free(
637d6e5b
LP		 2403 Manager *m,
2404 sd_bus_message *message,
2405 int carries_install_info,
cd44ec5a 2406 InstallChange *changes,
da6053d0 2407 size_t n_changes,
637d6e5b
LP		 2408 sd_bus_error *error) {
2409
2410 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2411 bool bad = false, good = false;
637d6e5b
LP		 2412 int r;
2413
8c2d0d3a
LP		 2414 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2415
cd44ec5a 2416 if (install_changes_have_modification(changes, n_changes)) {
637d6e5b
LP		 2417 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
2418 if (r < 0)
2419 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
2420 }
2421
2422 r = sd_bus_message_new_method_return(message, &reply);
2423 if (r < 0)
8c2d0d3a 2424 return r;
637d6e5b
LP		 2425
2426 if (carries_install_info >= 0) {
2427 r = sd_bus_message_append(reply, "b", carries_install_info);
2428 if (r < 0)
8c2d0d3a 2429 return r;
637d6e5b
LP		 2430 }
2431
2432 r = sd_bus_message_open_container(reply, 'a', "(sss)");
2433 if (r < 0)
8c2d0d3a 2434 return r;
637d6e5b 2435
fe96c0f8 2436 for (size_t i = 0; i < n_changes; i++) {
637d6e5b 2437
f8662fee 2438 if (changes[i].type < 0) {
637d6e5b
LP		 2439 bad = true;
2440 continue;
2441 }
2442
2443 r = sd_bus_message_append(
2444 reply, "(sss)",
f8662fee 2445 install_change_type_to_string(changes[i].type),
637d6e5b
LP		 2446 changes[i].path,
2447 changes[i].source);
2448 if (r < 0)
8c2d0d3a 2449 return r;
637d6e5b
LP		 2450
2451 good = true;
2452 }
2453
cb31470f
ZJS		 2454 /* If there was a failed change, and no successful change, then return the first failure as proper
2455 * method call error. */
637d6e5b 2456 if (bad && !good)
8c2d0d3a 2457 return install_error(error, 0, TAKE_PTR(changes), n_changes);
637d6e5b
LP		 2458
2459 r = sd_bus_message_close_container(reply);
2460 if (r < 0)
8c2d0d3a 2461 return r;
637d6e5b 2462
637d6e5b 2463 return sd_bus_send(NULL, reply, NULL);
637d6e5b
LP		 2464}
2465
718db961 2466static int method_enable_unit_files_generic(
718db961 2467 sd_bus_message *message,
d309c1c3 2468 Manager *m,
4870133b 2469 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
ebcf1f97
LP		 2470 bool carries_install_info,
2471 sd_bus_error *error) {
718db961
LP		 2472
2473 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2474 InstallChange *changes = NULL;
da6053d0 2475 size_t n_changes = 0;
b3796dd8 2476 UnitFileFlags flags;
83654007 2477 int r;
718db961 2478
718db961
LP		 2479 assert(message);
2480 assert(m);
cad45ba1 2481
718db961
LP		 2482 r = sd_bus_message_read_strv(message, &l);
2483 if (r < 0)
ebcf1f97 2484 return r;
90bb85e1 2485
83654007
LB		 2486 if (sd_bus_message_is_method_call(message, NULL, "EnableUnitFilesWithFlags")) {
2487 uint64_t raw_flags;
d309c1c3 2488
83654007
LB		 2489 r = sd_bus_message_read(message, "t", &raw_flags);
2490 if (r < 0)
2491 return r;
2492 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0)
2493 return -EINVAL;
2494 flags = raw_flags;
2495 } else {
2496 int runtime, force;
2497
2498 r = sd_bus_message_read(message, "bb", &runtime, &force);
2499 if (r < 0)
2500 return r;
2501 flags = unit_file_bools_to_flags(runtime, force);
2502 }
b3796dd8 2503
1d22e906
LP		 2504 r = bus_verify_manage_unit_files_async(m, message, error);
2505 if (r < 0)
2506 return r;
2507 if (r == 0)
2508 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2509
4870133b 2510 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2511 if (r < 0)
2512 return install_error(error, r, changes, n_changes);
718db961 2513
cd44ec5a 2514 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2515}
c87eba54 2516
83654007 2517static int method_enable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2518 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
83654007
LB		 2519}
2520
19070062 2521static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2522 return method_enable_unit_files_generic(message, userdata, unit_file_enable, /* carries_install_info = */ true, error);
718db961 2523}
ea430986 2524
19070062 2525static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2526 return method_enable_unit_files_generic(message, userdata, unit_file_reenable, /* carries_install_info = */ true, error);
718db961
LP		 2527}
2528
19070062 2529static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2530 return method_enable_unit_files_generic(message, userdata, unit_file_link, /* carries_install_info = */ false, error);
718db961
LP		 2531}
2532
4870133b 2533static int unit_file_preset_without_mode(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char **files, InstallChange **changes, size_t *n_changes) {
b3796dd8 2534 return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
d309c1c3
LP		 2535}
2536
19070062 2537static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2538 return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, /* carries_install_info = */ true, error);
718db961
LP		 2539}
2540
19070062 2541static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2d8cc7a7 2542 return method_enable_unit_files_generic(message, userdata, unit_file_mask, /* carries_install_info = */ false, error);
718db961 2543}
ea430986 2544
19070062 2545static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
d309c1c3
LP		 2546
2547 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2548 InstallChange *changes = NULL;
da6053d0 2549 size_t n_changes = 0;
99534007 2550 Manager *m = ASSERT_PTR(userdata);
8331b221 2551 UnitFilePresetMode preset_mode;
d309c1c3 2552 int runtime, force, r;
b3796dd8 2553 UnitFileFlags flags;
d309c1c3
LP		 2554 const char *mode;
2555
d309c1c3 2556 assert(message);
d309c1c3
LP		 2557
2558 r = sd_bus_message_read_strv(message, &l);
2559 if (r < 0)
2560 return r;
2561
2562 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2563 if (r < 0)
2564 return r;
2565
b3796dd8
JS		 2566 flags = unit_file_bools_to_flags(runtime, force);
2567
d309c1c3 2568 if (isempty(mode))
8331b221 2569 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2570 else {
8331b221
ZJS		 2571 preset_mode = unit_file_preset_mode_from_string(mode);
2572 if (preset_mode < 0)
d309c1c3
LP		 2573 return -EINVAL;
2574 }
2575
1d22e906
LP		 2576 r = bus_verify_manage_unit_files_async(m, message, error);
2577 if (r < 0)
2578 return r;
2579 if (r == 0)
2580 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2581
4870133b 2582 r = unit_file_preset(m->runtime_scope, flags, NULL, l, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2583 if (r < 0)
2584 return install_error(error, r, changes, n_changes);
d309c1c3 2585
cd44ec5a 2586 return reply_install_changes_and_free(m, message, r, changes, n_changes, error);
d309c1c3
LP		 2587}
2588
718db961 2589static int method_disable_unit_files_generic(
718db961 2590 sd_bus_message *message,
596fc263 2591 Manager *m,
4870133b 2592 int (*call)(RuntimeScope scope, UnitFileFlags flags, const char *root_dir, char *files[], InstallChange **changes, size_t *n_changes),
bf1bea43 2593 bool carries_install_info,
ebcf1f97 2594 sd_bus_error *error) {
718db961
LP		 2595
2596 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2597 InstallChange *changes = NULL;
83654007 2598 UnitFileFlags flags;
da6053d0 2599 size_t n_changes = 0;
83654007 2600 int r;
718db961 2601
718db961
LP		 2602 assert(message);
2603 assert(m);
2604
df823e23 2605 r = sd_bus_message_read_strv(message, &l);
ebcf1f97
LP		 2606 if (r < 0)
2607 return r;
718db961 2608
bf1bea43
MY		 2609 if (sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlags") ||
2610 sd_bus_message_is_method_call(message, NULL, "DisableUnitFilesWithFlagsAndInstallInfo")) {
83654007
LB		 2611 uint64_t raw_flags;
2612
2613 r = sd_bus_message_read(message, "t", &raw_flags);
2614 if (r < 0)
2615 return r;
2616 if ((raw_flags & ~_UNIT_FILE_FLAGS_MASK_PUBLIC) != 0 ||
2617 FLAGS_SET(raw_flags, UNIT_FILE_FORCE))
2618 return -EINVAL;
2619 flags = raw_flags;
2620 } else {
2621 int runtime;
2622
2623 r = sd_bus_message_read(message, "b", &runtime);
2624 if (r < 0)
2625 return r;
2626 flags = unit_file_bools_to_flags(runtime, false);
2627 }
718db961 2628
1d22e906
LP		 2629 r = bus_verify_manage_unit_files_async(m, message, error);
2630 if (r < 0)
2631 return r;
2632 if (r == 0)
2633 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2634
4870133b 2635 r = call(m->runtime_scope, flags, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2636 if (r < 0)
2637 return install_error(error, r, changes, n_changes);
718db961 2638
bf1bea43 2639 return reply_install_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
718db961 2640}
ea430986 2641
83654007 2642static int method_disable_unit_files_with_flags(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43
MY		 2643 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
2644}
2645
2646static int method_disable_unit_files_with_flags_and_install_info(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2647 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ true, error);
83654007
LB		 2648}
2649
19070062 2650static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2651 return method_disable_unit_files_generic(message, userdata, unit_file_disable, /* carries_install_info = */ false, error);
ea430986
LP		 2652}
2653
19070062 2654static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
bf1bea43 2655 return method_disable_unit_files_generic(message, userdata, unit_file_unmask, /* carries_install_info = */ false, error);
718db961
LP		 2656}
2657
344ca755
LP		 2658static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2659 _cleanup_strv_free_ char **l = NULL;
cd44ec5a 2660 InstallChange *changes = NULL;
da6053d0 2661 size_t n_changes = 0;
99534007 2662 Manager *m = ASSERT_PTR(userdata);
344ca755
LP		 2663 int r;
2664
2665 assert(message);
344ca755
LP		 2666
2667 r = sd_bus_message_read_strv(message, &l);
2668 if (r < 0)
2669 return r;
2670
2671 r = bus_verify_manage_unit_files_async(m, message, error);
2672 if (r < 0)
2673 return r;
2674 if (r == 0)
2675 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2676
4870133b 2677 r = unit_file_revert(m->runtime_scope, NULL, l, &changes, &n_changes);
af3d8113
ZJS		 2678 if (r < 0)
2679 return install_error(error, r, changes, n_changes);
344ca755 2680
cd44ec5a 2681 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
344ca755
LP		 2682}
2683
19070062 2684static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2685 InstallChange *changes = NULL;
da6053d0 2686 size_t n_changes = 0;
99534007 2687 Manager *m = ASSERT_PTR(userdata);
718db961
LP		 2688 const char *name;
2689 int force, r;
2690
718db961 2691 assert(message);
718db961 2692
1d22e906 2693 r = mac_selinux_access_check(message, "enable", error);
283868e1
SW		 2694 if (r < 0)
2695 return r;
283868e1 2696
1d22e906 2697 r = sd_bus_message_read(message, "sb", &name, &force);
ebcf1f97
LP		 2698 if (r < 0)
2699 return r;
718db961 2700
1d22e906 2701 r = bus_verify_manage_unit_files_async(m, message, error);
718db961 2702 if (r < 0)
ebcf1f97 2703 return r;
1d22e906
LP		 2704 if (r == 0)
2705 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
718db961 2706
4870133b 2707 r = unit_file_set_default(m->runtime_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
af3d8113
ZJS		 2708 if (r < 0)
2709 return install_error(error, r, changes, n_changes);
718db961 2710
cd44ec5a 2711 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
718db961
LP		 2712}
2713
19070062 2714static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
cd44ec5a 2715 InstallChange *changes = NULL;
da6053d0 2716 size_t n_changes = 0;
99534007 2717 Manager *m = ASSERT_PTR(userdata);
8331b221 2718 UnitFilePresetMode preset_mode;
d309c1c3 2719 const char *mode;
b3796dd8 2720 UnitFileFlags flags;
d309c1c3
LP		 2721 int force, runtime, r;
2722
d309c1c3 2723 assert(message);
d309c1c3 2724
8a188de9 2725 r = mac_selinux_access_check(message, "enable", error);
d309c1c3
LP		 2726 if (r < 0)
2727 return r;
2728
2729 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2730 if (r < 0)
2731 return r;
2732
b3796dd8
JS		 2733 flags = unit_file_bools_to_flags(runtime, force);
2734
d309c1c3 2735 if (isempty(mode))
8331b221 2736 preset_mode = UNIT_FILE_PRESET_FULL;
d309c1c3 2737 else {
8331b221
ZJS		 2738 preset_mode = unit_file_preset_mode_from_string(mode);
2739 if (preset_mode < 0)
d309c1c3
LP		 2740 return -EINVAL;
2741 }
2742
1d22e906
LP		 2743 r = bus_verify_manage_unit_files_async(m, message, error);
2744 if (r < 0)
2745 return r;
2746 if (r == 0)
2747 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2748
4870133b 2749 r = unit_file_preset_all(m->runtime_scope, flags, NULL, preset_mode, &changes, &n_changes);
af3d8113
ZJS		 2750 if (r < 0)
2751 return install_error(error, r, changes, n_changes);
d309c1c3 2752
cd44ec5a 2753 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
d309c1c3
LP		 2754}
2755
19070062 2756static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
e94937df 2757 _cleanup_strv_free_ char **l = NULL;
99534007 2758 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2759 InstallChange *changes = NULL;
da6053d0 2760 size_t n_changes = 0;
e94937df 2761 int runtime, force, r;
596fc263 2762 char *target, *type;
e94937df 2763 UnitDependency dep;
b3796dd8 2764 UnitFileFlags flags;
e94937df 2765
e94937df 2766 assert(message);
e94937df
LN		 2767
2768 r = bus_verify_manage_unit_files_async(m, message, error);
2769 if (r < 0)
2770 return r;
2771 if (r == 0)
2772 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2773
2774 r = sd_bus_message_read_strv(message, &l);
2775 if (r < 0)
2776 return r;
2777
2778 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2779 if (r < 0)
2780 return r;
2781
b3796dd8
JS		 2782 flags = unit_file_bools_to_flags(runtime, force);
2783
e94937df
LN		 2784 dep = unit_dependency_from_string(type);
2785 if (dep < 0)
2786 return -EINVAL;
2787
4870133b 2788 r = unit_file_add_dependency(m->runtime_scope, flags, NULL, l, target, dep, &changes, &n_changes);
af3d8113
ZJS		 2789 if (r < 0)
2790 return install_error(error, r, changes, n_changes);
e94937df 2791
cd44ec5a 2792 return reply_install_changes_and_free(m, message, -1, changes, n_changes, error);
e94937df
LN		 2793}
2794
3b3557c4
JS		 2795static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2796 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
47c57b48 2797 Manager *m = ASSERT_PTR(userdata);
cd44ec5a 2798 InstallChange *changes = NULL;
da6053d0 2799 size_t n_changes = 0, i;
3b3557c4 2800 const char *name;
3b3557c4
JS		 2801 int runtime, r;
2802
2a711edd
DT		 2803 CLEANUP_ARRAY(changes, n_changes, install_changes_free);
2804
3b3557c4
JS		 2805 r = sd_bus_message_read(message, "sb", &name, &runtime);
2806 if (r < 0)
2807 return r;
2808
2809 r = sd_bus_message_new_method_return(message, &reply);
2810 if (r < 0)
2811 return r;
2812
2813 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2814 if (r < 0)
2815 return r;
2816
4870133b 2817 r = unit_file_disable(m->runtime_scope,
47c57b48
YW		 2818 UNIT_FILE_DRY_RUN | (runtime ? UNIT_FILE_RUNTIME : 0),
2819 NULL, STRV_MAKE(name), &changes, &n_changes);
2a711edd
DT		 2820 if (r < 0)
2821 return log_error_errno(r, "Failed to get file links for %s: %m", name);
3b3557c4
JS		 2822
2823 for (i = 0; i < n_changes; i++)
f8662fee 2824 if (changes[i].type == INSTALL_CHANGE_UNLINK) {
3b3557c4
JS		 2825 r = sd_bus_message_append(reply, "s", changes[i].path);
2826 if (r < 0)
2a711edd 2827 return r;
3b3557c4
JS		 2828 }
2829
2830 r = sd_bus_message_close_container(reply);
2831 if (r < 0)
2a711edd 2832 return r;
a12ba535 2833
2a711edd 2834 return sd_bus_send(NULL, reply, NULL);
3b3557c4
JS		 2835}
2836
15ea79f8 2837static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2838 Manager *m = ASSERT_PTR(userdata);
15ea79f8
LP		 2839 uint32_t id;
2840 Job *j;
2841 int r;
2842
2843 assert(message);
15ea79f8
LP		 2844
2845 r = sd_bus_message_read(message, "u", &id);
2846 if (r < 0)
2847 return r;
2848
2849 j = manager_get_job(m, id);
2850 if (!j)
2851 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2852
2853 return bus_job_method_get_waiting_jobs(message, j, error);
2854}
2855
c20076a8 2856static int method_abandon_scope(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2857 Manager *m = ASSERT_PTR(userdata);
c20076a8
LP		 2858 const char *name;
2859 Unit *u;
2860 int r;
2861
2862 assert(message);
c20076a8
LP		 2863
2864 r = sd_bus_message_read(message, "s", &name);
2865 if (r < 0)
2866 return r;
2867
2868 r = bus_get_unit_by_name(m, message, name, &u, error);
2869 if (r < 0)
2870 return r;
2871
2872 if (u->type != UNIT_SCOPE)
cb31470f
ZJS		 2873 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2874 "Unit '%s' is not a scope unit, refusing.", name);
c20076a8
LP		 2875
2876 return bus_scope_method_abandon(message, u, error);
2877}
2878
0bb007f7 2879static int method_set_show_status(sd_bus_message *message, void *userdata, sd_bus_error *error) {
99534007 2880 Manager *m = ASSERT_PTR(userdata);
0bb007f7
FB		 2881 ShowStatus mode = _SHOW_STATUS_INVALID;
2882 const char *t;
2883 int r;
2884
0bb007f7
FB		 2885 assert(message);
2886
4db62561
ZJS		 2887 r = mac_selinux_access_check(message, "reload", error);
2888 if (r < 0)
2889 return r;
2890
2891 r = bus_verify_set_environment_async(m, message, error);
2892 if (r < 0)
2893 return r;
2894 if (r == 0)
2895 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2896
0bb007f7
FB		 2897 r = sd_bus_message_read(message, "s", &t);
2898 if (r < 0)
2899 return r;
2900
2901 if (!isempty(t)) {
2902 mode = show_status_from_string(t);
2903 if (mode < 0)
cb31470f
ZJS		 2904 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS,
2905 "Invalid show status '%s'", t);
0bb007f7
FB		 2906 }
2907
43bba15a 2908 manager_override_show_status(m, mode, "bus");
0bb007f7
FB		 2909
2910 return sd_bus_reply_method_return(message, NULL);
2911}
2912
2ea24611
LP		 2913static int method_dump_unit_descriptor_store(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2914 return method_generic_unit_operation(message, userdata, error, bus_service_method_dump_file_descriptor_store, 0);
2915}
2916
718db961
LP		 2917const sd_bus_vtable bus_manager_vtable[] = {
2918 SD_BUS_VTABLE_START(0),
2919
556089dc
LP		 2920 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2921 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2922 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
7452394e 2923 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2924 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
9f9f0342
LP		 2925 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
2926 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
2927 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
2928 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
2929 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
2930 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2931 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2932 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2933 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2934 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2935 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2936 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
49fbe940 2937 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD]), SD_BUS_VTABLE_PROPERTY_CONST),
665a9774
YW		 2938 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2939 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDSecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2940 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2941 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDGeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2942 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2943 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDUnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
25141692
LP		 2944 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
2945 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3ff52e8f
YW		 2946 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
2947 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2948 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
718db961
LP		 2949 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
2950 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
2951 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1ad6e8b3 2952 SD_BUS_PROPERTY("Environment", "as", property_get_environment, 0, 0),
556089dc 2953 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
52d2566a 2954 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
a3c4eb07 2955 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
556089dc 2956 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
cb6c4f37 2957 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_error), SD_BUS_VTABLE_PROPERTY_CONST),
3e911a0d
YW		 2958 SD_BUS_PROPERTY("WatchdogDevice", "s", property_get_watchdog_device, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2959 SD_BUS_PROPERTY("WatchdogLastPingTimestamp", "t", property_get_watchdog_last_ping_realtime, 0, 0),
2960 SD_BUS_PROPERTY("WatchdogLastPingTimestampMonotonic", "t", property_get_watchdog_last_ping_monotonic, 0, 0),
986935cf 2961 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", property_get_runtime_watchdog, property_set_runtime_watchdog, 0, 0),
5717062e 2962 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreUSec", "t", property_get_pretimeout_watchdog, property_set_pretimeout_watchdog, 0, 0),
aff3a9e1 2963 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogPreGovernor", "s", property_get_pretimeout_watchdog_governor, property_set_pretimeout_watchdog_governor, 0, 0),
986935cf 2964 SD_BUS_WRITABLE_PROPERTY("RebootWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, 0),
65224c1d 2965 /* The following item is an obsolete alias */
986935cf
FB		 2966 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", property_get_reboot_watchdog, property_set_reboot_watchdog, 0, SD_BUS_VTABLE_HIDDEN),
2967 SD_BUS_WRITABLE_PROPERTY("KExecWatchdogUSec", "t", property_get_kexec_watchdog, property_set_kexec_watchdog, 0, 0),
2a12e32e 2968 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
b272b74d 2969 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
f755e3b7 2970 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
287419c1 2971 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
670a3efe
EV		 2972 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, default_timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2973 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2974 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
dc653bf4 2975 SD_BUS_PROPERTY("DefaultTimeoutAbortUSec", "t", property_get_default_timeout_abort_usec, 0, 0),
a0fe19f9 2976 SD_BUS_PROPERTY("DefaultDeviceTimeoutUSec", "t", bus_property_get_usec, offsetof(Manager, default_device_timeout_usec), SD_BUS_VTABLE_PROPERTY_CONST),
670a3efe 2977 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, default_restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
c075f5fc
YW		 2978 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
2979 /* The following two items are obsolete alias */
2980 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
2981 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		 2982 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, default_start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
2983 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, default_cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2984 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
a068eeac 2985 SD_BUS_PROPERTY("DefaultIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_io_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2986 SD_BUS_PROPERTY("DefaultIPAccounting", "b", bus_property_get_bool, offsetof(Manager, default_ip_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
670a3efe
EV		 2987 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, default_memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2988 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, default_tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2989 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2990 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2991 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2992 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2993 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2994 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2995 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2996 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2997 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 2998 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 2999 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3000 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3001 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3002 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3003 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3004 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3005 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3006 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3007 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3008 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3009 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3010 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3011 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3012 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3013 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3014 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3015 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3016 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3017 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3018 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
97eb4231 3019 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
147f6858 3020 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
3a0f06c4 3021 SD_BUS_PROPERTY("DefaultTasksMax", "t", bus_property_get_tasks_max, offsetof(Manager, default_tasks_max), 0),
6bb00842
LP		 3022 SD_BUS_PROPERTY("DefaultMemoryPressureThresholdUSec", "t", bus_property_get_usec, offsetof(Manager, default_memory_pressure_threshold_usec), 0),
3023 SD_BUS_PROPERTY("DefaultMemoryPressureWatch", "s", bus_property_get_cgroup_pressure_watch, offsetof(Manager, default_memory_pressure_watch), 0),
eed67a30 3024 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
afcfaa69 3025 SD_BUS_PROPERTY("DefaultOOMPolicy", "s", bus_property_get_oom_policy, offsetof(Manager, default_oom_policy), SD_BUS_VTABLE_PROPERTY_CONST),
d4a402e4 3026 SD_BUS_PROPERTY("DefaultOOMScoreAdjust", "i", property_get_oom_score_adjust, 0, SD_BUS_VTABLE_PROPERTY_CONST),
c44a285c 3027 SD_BUS_PROPERTY("CtrlAltDelBurstAction", "s", bus_property_get_emergency_action, offsetof(Manager, cad_burst_action), SD_BUS_VTABLE_PROPERTY_CONST),
718db961 3028
a008b6d7 3029 SD_BUS_METHOD_WITH_ARGS("GetUnit",
3030 SD_BUS_ARGS("s", name),
3031 SD_BUS_RESULT("o", unit),
3032 method_get_unit,
3033 SD_BUS_VTABLE_UNPRIVILEGED),
3034 SD_BUS_METHOD_WITH_ARGS("GetUnitByPID",
3035 SD_BUS_ARGS("u", pid),
3036 SD_BUS_RESULT("o", unit),
3037 method_get_unit_by_pid,
3038 SD_BUS_VTABLE_UNPRIVILEGED),
3039 SD_BUS_METHOD_WITH_ARGS("GetUnitByInvocationID",
3040 SD_BUS_ARGS("ay", invocation_id),
3041 SD_BUS_RESULT("o", unit),
3042 method_get_unit_by_invocation_id,
3043 SD_BUS_VTABLE_UNPRIVILEGED),
3044 SD_BUS_METHOD_WITH_ARGS("GetUnitByControlGroup",
3045 SD_BUS_ARGS("s", cgroup),
3046 SD_BUS_RESULT("o", unit),
3047 method_get_unit_by_control_group,
3048 SD_BUS_VTABLE_UNPRIVILEGED),
e0e7bc82
LB		 3049 SD_BUS_METHOD_WITH_ARGS("GetUnitByPIDFD",
3050 SD_BUS_ARGS("h", pidfd),
3051 SD_BUS_RESULT("o", unit, "s", unit_id, "ay", invocation_id),
3052 method_get_unit_by_pidfd,
3053 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3054 SD_BUS_METHOD_WITH_ARGS("LoadUnit",
3055 SD_BUS_ARGS("s", name),
3056 SD_BUS_RESULT("o", unit),
3057 method_load_unit,
3058 SD_BUS_VTABLE_UNPRIVILEGED),
3059 SD_BUS_METHOD_WITH_ARGS("StartUnit",
3060 SD_BUS_ARGS("s", name, "s", mode),
3061 SD_BUS_RESULT("o", job),
3062 method_start_unit,
3063 SD_BUS_VTABLE_UNPRIVILEGED),
3064 SD_BUS_METHOD_WITH_ARGS("StartUnitWithFlags",
3065 SD_BUS_ARGS("s", name, "s", mode, "t", flags),
3066 SD_BUS_RESULT("o", job),
3067 method_start_unit,
3068 SD_BUS_VTABLE_UNPRIVILEGED),
3069 SD_BUS_METHOD_WITH_ARGS("StartUnitReplace",
3070 SD_BUS_ARGS("s", old_unit, "s", new_unit, "s", mode),
3071 SD_BUS_RESULT("o", job),
3072 method_start_unit_replace,
3073 SD_BUS_VTABLE_UNPRIVILEGED),
3074 SD_BUS_METHOD_WITH_ARGS("StopUnit",
3075 SD_BUS_ARGS("s", name, "s", mode),
3076 SD_BUS_RESULT("o", job),
3077 method_stop_unit,
3078 SD_BUS_VTABLE_UNPRIVILEGED),
3079 SD_BUS_METHOD_WITH_ARGS("ReloadUnit",
3080 SD_BUS_ARGS("s", name, "s", mode),
3081 SD_BUS_RESULT("o", job),
3082 method_reload_unit,
3083 SD_BUS_VTABLE_UNPRIVILEGED),
3084 SD_BUS_METHOD_WITH_ARGS("RestartUnit",
3085 SD_BUS_ARGS("s", name, "s", mode),
3086 SD_BUS_RESULT("o", job),
3087 method_restart_unit,
3088 SD_BUS_VTABLE_UNPRIVILEGED),
3089 SD_BUS_METHOD_WITH_ARGS("TryRestartUnit",
3090 SD_BUS_ARGS("s", name, "s", mode),
3091 SD_BUS_RESULT("o", job),
3092 method_try_restart_unit,
3093 SD_BUS_VTABLE_UNPRIVILEGED),
3094 SD_BUS_METHOD_WITH_ARGS("ReloadOrRestartUnit",
3095 SD_BUS_ARGS("s", name, "s", mode),
3096 SD_BUS_RESULT("o", job),
3097 method_reload_or_restart_unit,
3098 SD_BUS_VTABLE_UNPRIVILEGED),
3099 SD_BUS_METHOD_WITH_ARGS("ReloadOrTryRestartUnit",
3100 SD_BUS_ARGS("s", name, "s", mode),
3101 SD_BUS_RESULT("o", job),
3102 method_reload_or_try_restart_unit,
3103 SD_BUS_VTABLE_UNPRIVILEGED),
3104 SD_BUS_METHOD_WITH_ARGS("EnqueueUnitJob",
3105 SD_BUS_ARGS("s", name, "s", job_type, "s", job_mode),
3106 SD_BUS_RESULT("u", job_id, "o", job_path, "s", unit_id, "o", unit_path, "s", job_type, "a(uosos)", affected_jobs),
3107 method_enqueue_unit_job,
3108 SD_BUS_VTABLE_UNPRIVILEGED),
3109 SD_BUS_METHOD_WITH_ARGS("KillUnit",
3110 SD_BUS_ARGS("s", name, "s", whom, "i", signal),
3111 SD_BUS_NO_RESULT,
a721cd00
LP		 3112 method_kill_unit,
3113 SD_BUS_VTABLE_UNPRIVILEGED),
3114 SD_BUS_METHOD_WITH_ARGS("QueueSignalUnit",
3115 SD_BUS_ARGS("s", name, "s", whom, "i", signal, "i", value),
3116 SD_BUS_NO_RESULT,
a008b6d7 3117 method_kill_unit,
3118 SD_BUS_VTABLE_UNPRIVILEGED),
3119 SD_BUS_METHOD_WITH_ARGS("CleanUnit",
3120 SD_BUS_ARGS("s", name, "as", mask),
3121 SD_BUS_NO_RESULT,
3122 method_clean_unit,
3123 SD_BUS_VTABLE_UNPRIVILEGED),
3124 SD_BUS_METHOD_WITH_ARGS("FreezeUnit",
3125 SD_BUS_ARGS("s", name),
3126 SD_BUS_NO_RESULT,
3127 method_freeze_unit,
3128 SD_BUS_VTABLE_UNPRIVILEGED),
3129 SD_BUS_METHOD_WITH_ARGS("ThawUnit",
3130 SD_BUS_ARGS("s", name),
3131 SD_BUS_NO_RESULT,
3132 method_thaw_unit,
3133 SD_BUS_VTABLE_UNPRIVILEGED),
3134 SD_BUS_METHOD_WITH_ARGS("ResetFailedUnit",
3135 SD_BUS_ARGS("s", name),
3136 SD_BUS_NO_RESULT,
3137 method_reset_failed_unit,
3138 SD_BUS_VTABLE_UNPRIVILEGED),
3139 SD_BUS_METHOD_WITH_ARGS("SetUnitProperties",
3140 SD_BUS_ARGS("s", name, "b", runtime, "a(sv)", properties),
3141 SD_BUS_NO_RESULT,
3142 method_set_unit_properties,
3143 SD_BUS_VTABLE_UNPRIVILEGED),
3144 SD_BUS_METHOD_WITH_ARGS("BindMountUnit",
3145 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir),
3146 SD_BUS_NO_RESULT,
3147 method_bind_mount_unit,
3148 SD_BUS_VTABLE_UNPRIVILEGED),
3149 SD_BUS_METHOD_WITH_ARGS("MountImageUnit",
3150 SD_BUS_ARGS("s", name, "s", source, "s", destination, "b", read_only, "b", mkdir, "a(ss)", options),
3151 SD_BUS_NO_RESULT,
3152 method_mount_image_unit,
3153 SD_BUS_VTABLE_UNPRIVILEGED),
3154 SD_BUS_METHOD_WITH_ARGS("RefUnit",
3155 SD_BUS_ARGS("s", name),
3156 SD_BUS_NO_RESULT,
3157 method_ref_unit,
3158 SD_BUS_VTABLE_UNPRIVILEGED),
3159 SD_BUS_METHOD_WITH_ARGS("UnrefUnit",
3160 SD_BUS_ARGS("s", name),
3161 SD_BUS_NO_RESULT,
3162 method_unref_unit,
3163 SD_BUS_VTABLE_UNPRIVILEGED),
3164 SD_BUS_METHOD_WITH_ARGS("StartTransientUnit",
3165 SD_BUS_ARGS("s", name, "s", mode, "a(sv)", properties, "a(sa(sv))", aux),
3166 SD_BUS_RESULT("o", job),
3167 method_start_transient_unit,
3168 SD_BUS_VTABLE_UNPRIVILEGED),
3169 SD_BUS_METHOD_WITH_ARGS("GetUnitProcesses",
3170 SD_BUS_ARGS("s", name),
3171 SD_BUS_RESULT("a(sus)", processes),
3172 method_get_unit_processes,
3173 SD_BUS_VTABLE_UNPRIVILEGED),
3174 SD_BUS_METHOD_WITH_ARGS("AttachProcessesToUnit",
3175 SD_BUS_ARGS("s", unit_name, "s", subcgroup, "au", pids),
3176 SD_BUS_NO_RESULT,
3177 method_attach_processes_to_unit,
3178 SD_BUS_VTABLE_UNPRIVILEGED),
3179 SD_BUS_METHOD_WITH_ARGS("AbandonScope",
3180 SD_BUS_ARGS("s", name),
3181 SD_BUS_NO_RESULT,
3182 method_abandon_scope,
3183 SD_BUS_VTABLE_UNPRIVILEGED),
3184 SD_BUS_METHOD_WITH_ARGS("GetJob",
3185 SD_BUS_ARGS("u", id),
3186 SD_BUS_RESULT("o", job),
3187 method_get_job,
3188 SD_BUS_VTABLE_UNPRIVILEGED),
3189 SD_BUS_METHOD_WITH_ARGS("GetJobAfter",
3190 SD_BUS_ARGS("u", id),
3191 SD_BUS_RESULT("a(usssoo)", jobs),
3192 method_get_job_waiting,
3193 SD_BUS_VTABLE_UNPRIVILEGED),
3194 SD_BUS_METHOD_WITH_ARGS("GetJobBefore",
3195 SD_BUS_ARGS("u", id),
3196 SD_BUS_RESULT("a(usssoo)", jobs),
3197 method_get_job_waiting,
3198 SD_BUS_VTABLE_UNPRIVILEGED),
3199 SD_BUS_METHOD_WITH_ARGS("CancelJob",
3200 SD_BUS_ARGS("u", id),
3201 SD_BUS_NO_RESULT,
3202 method_cancel_job,
3203 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3204 SD_BUS_METHOD("ClearJobs",
3205 NULL,
3206 NULL,
3207 method_clear_jobs,
3208 SD_BUS_VTABLE_UNPRIVILEGED),
3209 SD_BUS_METHOD("ResetFailed",
3210 NULL,
3211 NULL,
3212 method_reset_failed,
3213 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3214 SD_BUS_METHOD_WITH_ARGS("SetShowStatus",
3215 SD_BUS_ARGS("s", mode),
3216 SD_BUS_NO_RESULT,
3217 method_set_show_status,
3218 SD_BUS_VTABLE_UNPRIVILEGED),
3219 SD_BUS_METHOD_WITH_ARGS("ListUnits",
3220 SD_BUS_NO_ARGS,
3221 SD_BUS_RESULT("a(ssssssouso)", units),
3222 method_list_units,
3223 SD_BUS_VTABLE_UNPRIVILEGED),
3224 SD_BUS_METHOD_WITH_ARGS("ListUnitsFiltered",
3225 SD_BUS_ARGS("as", states),
3226 SD_BUS_RESULT("a(ssssssouso)", units),
3227 method_list_units_filtered,
3228 SD_BUS_VTABLE_UNPRIVILEGED),
3229 SD_BUS_METHOD_WITH_ARGS("ListUnitsByPatterns",
3230 SD_BUS_ARGS("as", states, "as", patterns),
3231 SD_BUS_RESULT("a(ssssssouso)", units),
3232 method_list_units_by_patterns,
3233 SD_BUS_VTABLE_UNPRIVILEGED),
3234 SD_BUS_METHOD_WITH_ARGS("ListUnitsByNames",
3235 SD_BUS_ARGS("as", names),
3236 SD_BUS_RESULT("a(ssssssouso)", units),
3237 method_list_units_by_names,
3238 SD_BUS_VTABLE_UNPRIVILEGED),
3239 SD_BUS_METHOD_WITH_ARGS("ListJobs",
3240 SD_BUS_NO_ARGS,
3241 SD_BUS_RESULT("a(usssoo)", jobs),
3242 method_list_jobs,
3243 SD_BUS_VTABLE_UNPRIVILEGED),
dad97f04
ZJS		 3244 SD_BUS_METHOD("Subscribe",
3245 NULL,
3246 NULL,
3247 method_subscribe,
3248 SD_BUS_VTABLE_UNPRIVILEGED),
3249 SD_BUS_METHOD("Unsubscribe",
3250 NULL,
3251 NULL,
3252 method_unsubscribe,
3253 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3254 SD_BUS_METHOD_WITH_ARGS("Dump",
3255 SD_BUS_NO_ARGS,
3256 SD_BUS_RESULT("s", output),
3257 method_dump,
3258 SD_BUS_VTABLE_UNPRIVILEGED),
293b9aa3 3259 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatterns",
d1d8786c
FB		 3260 SD_BUS_ARGS("as", patterns),
3261 SD_BUS_RESULT("s", output),
293b9aa3 3262 method_dump_units_matching_patterns,
d1d8786c 3263 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3264 SD_BUS_METHOD_WITH_ARGS("DumpByFileDescriptor",
3265 SD_BUS_NO_ARGS,
3266 SD_BUS_RESULT("h", fd),
3267 method_dump_by_fd,
3268 SD_BUS_VTABLE_UNPRIVILEGED),
f6cce15b
ZJS		 3269 SD_BUS_METHOD_WITH_ARGS("DumpUnitsMatchingPatternsByFileDescriptor",
3270 SD_BUS_ARGS("as", patterns),
3271 SD_BUS_RESULT("h", fd),
3272 method_dump_units_matching_patterns_by_fd,
3273 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3274 SD_BUS_METHOD_WITH_ARGS("CreateSnapshot",
3275 SD_BUS_ARGS("s", name, "b", cleanup),
3276 SD_BUS_RESULT("o", unit),
3277 method_refuse_snapshot,
3278 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
3279 SD_BUS_METHOD_WITH_ARGS("RemoveSnapshot",
3280 SD_BUS_ARGS("s", name),
3281 SD_BUS_NO_RESULT,
3282 method_refuse_snapshot,
3283 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
dad97f04
ZJS		 3284 SD_BUS_METHOD("Reload",
3285 NULL,
3286 NULL,
3287 method_reload,
3288 SD_BUS_VTABLE_UNPRIVILEGED),
3289 SD_BUS_METHOD("Reexecute",
3290 NULL,
3291 NULL,
3292 method_reexecute,
624f685f 3293 SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_METHOD_NO_REPLY),
dad97f04
ZJS		 3294 SD_BUS_METHOD("Exit",
3295 NULL,
3296 NULL,
3297 method_exit,
3298 0),
3299 SD_BUS_METHOD("Reboot",
3300 NULL,
3301 NULL,
3302 method_reboot,
3303 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
13ffc607
LP		 3304 SD_BUS_METHOD_WITH_ARGS("SoftReboot",
3305 SD_BUS_ARGS("s", new_root),
3306 SD_BUS_NO_RESULT,
3307 method_soft_reboot,
3308 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
dad97f04
ZJS		 3309 SD_BUS_METHOD("PowerOff",
3310 NULL,
3311 NULL,
3312 method_poweroff,
3313 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3314 SD_BUS_METHOD("Halt",
3315 NULL,
3316 NULL,
3317 method_halt,
3318 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3319 SD_BUS_METHOD("KExec",
3320 NULL,
3321 NULL,
3322 method_kexec,
3323 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
a008b6d7 3324 SD_BUS_METHOD_WITH_ARGS("SwitchRoot",
3325 SD_BUS_ARGS("s", new_root, "s", init),
3326 SD_BUS_NO_RESULT,
3327 method_switch_root,
3328 SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
3329 SD_BUS_METHOD_WITH_ARGS("SetEnvironment",
3330 SD_BUS_ARGS("as", assignments),
3331 SD_BUS_NO_RESULT,
3332 method_set_environment,
3333 SD_BUS_VTABLE_UNPRIVILEGED),
3334 SD_BUS_METHOD_WITH_ARGS("UnsetEnvironment",
3335 SD_BUS_ARGS("as", names),
3336 SD_BUS_NO_RESULT,
3337 method_unset_environment,
3338 SD_BUS_VTABLE_UNPRIVILEGED),
3339 SD_BUS_METHOD_WITH_ARGS("UnsetAndSetEnvironment",
3340 SD_BUS_ARGS("as", names, "as", assignments),
3341 SD_BUS_NO_RESULT,
3342 method_unset_and_set_environment,
3343 SD_BUS_VTABLE_UNPRIVILEGED),
3344 SD_BUS_METHOD_WITH_ARGS("EnqueueMarkedJobs",
3345 SD_BUS_NO_ARGS,
3346 SD_BUS_RESULT("ao", jobs),
3347 method_enqueue_marked_jobs,
3348 SD_BUS_VTABLE_UNPRIVILEGED),
3349 SD_BUS_METHOD_WITH_ARGS("ListUnitFiles",
3350 SD_BUS_NO_ARGS,
3351 SD_BUS_RESULT("a(ss)", unit_files),
3352 method_list_unit_files,
3353 SD_BUS_VTABLE_UNPRIVILEGED),
3354 SD_BUS_METHOD_WITH_ARGS("ListUnitFilesByPatterns",
3355 SD_BUS_ARGS("as", states, "as", patterns),
3356 SD_BUS_RESULT("a(ss)", unit_files),
3357 method_list_unit_files_by_patterns,
3358 SD_BUS_VTABLE_UNPRIVILEGED),
3359 SD_BUS_METHOD_WITH_ARGS("GetUnitFileState",
3360 SD_BUS_ARGS("s", file),
3361 SD_BUS_RESULT("s", state),
3362 method_get_unit_file_state,
3363 SD_BUS_VTABLE_UNPRIVILEGED),
3364 SD_BUS_METHOD_WITH_ARGS("EnableUnitFiles",
3365 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3366 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3367 method_enable_unit_files,
3368 SD_BUS_VTABLE_UNPRIVILEGED),
3369 SD_BUS_METHOD_WITH_ARGS("DisableUnitFiles",
3370 SD_BUS_ARGS("as", files, "b", runtime),
3371 SD_BUS_RESULT("a(sss)", changes),
3372 method_disable_unit_files,
3373 SD_BUS_VTABLE_UNPRIVILEGED),
3374 SD_BUS_METHOD_WITH_ARGS("EnableUnitFilesWithFlags",
3375 SD_BUS_ARGS("as", files, "t", flags),
3376 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3377 method_enable_unit_files_with_flags,
3378 SD_BUS_VTABLE_UNPRIVILEGED),
3379 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlags",
3380 SD_BUS_ARGS("as", files, "t", flags),
3381 SD_BUS_RESULT("a(sss)", changes),
3382 method_disable_unit_files_with_flags,
3383 SD_BUS_VTABLE_UNPRIVILEGED),
bf1bea43
MY		 3384 SD_BUS_METHOD_WITH_ARGS("DisableUnitFilesWithFlagsAndInstallInfo",
3385 SD_BUS_ARGS("as", files, "t", flags),
3386 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3387 method_disable_unit_files_with_flags_and_install_info,
3388 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3389 SD_BUS_METHOD_WITH_ARGS("ReenableUnitFiles",
3390 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3391 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3392 method_reenable_unit_files,
3393 SD_BUS_VTABLE_UNPRIVILEGED),
3394 SD_BUS_METHOD_WITH_ARGS("LinkUnitFiles",
3395 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3396 SD_BUS_RESULT("a(sss)", changes),
3397 method_link_unit_files,
3398 SD_BUS_VTABLE_UNPRIVILEGED),
3399 SD_BUS_METHOD_WITH_ARGS("PresetUnitFiles",
3400 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3401 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3402 method_preset_unit_files,
3403 SD_BUS_VTABLE_UNPRIVILEGED),
3404 SD_BUS_METHOD_WITH_ARGS("PresetUnitFilesWithMode",
3405 SD_BUS_ARGS("as", files, "s", mode, "b", runtime, "b", force),
3406 SD_BUS_RESULT("b", carries_install_info, "a(sss)", changes),
3407 method_preset_unit_files_with_mode,
3408 SD_BUS_VTABLE_UNPRIVILEGED),
3409 SD_BUS_METHOD_WITH_ARGS("MaskUnitFiles",
3410 SD_BUS_ARGS("as", files, "b", runtime, "b", force),
3411 SD_BUS_RESULT("a(sss)", changes),
3412 method_mask_unit_files,
3413 SD_BUS_VTABLE_UNPRIVILEGED),
3414 SD_BUS_METHOD_WITH_ARGS("UnmaskUnitFiles",
3415 SD_BUS_ARGS("as", files, "b", runtime),
3416 SD_BUS_RESULT("a(sss)", changes),
3417 method_unmask_unit_files,
3418 SD_BUS_VTABLE_UNPRIVILEGED),
3419 SD_BUS_METHOD_WITH_ARGS("RevertUnitFiles",
3420 SD_BUS_ARGS("as", files),
3421 SD_BUS_RESULT("a(sss)", changes),
3422 method_revert_unit_files,
3423 SD_BUS_VTABLE_UNPRIVILEGED),
3424 SD_BUS_METHOD_WITH_ARGS("SetDefaultTarget",
3425 SD_BUS_ARGS("s", name, "b", force),
3426 SD_BUS_RESULT("a(sss)", changes),
3427 method_set_default_target,
3428 SD_BUS_VTABLE_UNPRIVILEGED),
3429 SD_BUS_METHOD_WITH_ARGS("GetDefaultTarget",
3430 SD_BUS_NO_ARGS,
3431 SD_BUS_RESULT("s", name),
3432 method_get_default_target,
3433 SD_BUS_VTABLE_UNPRIVILEGED),
3434 SD_BUS_METHOD_WITH_ARGS("PresetAllUnitFiles",
3435 SD_BUS_ARGS("s", mode, "b", runtime, "b", force),
3436 SD_BUS_RESULT("a(sss)", changes),
3437 method_preset_all_unit_files,
3438 SD_BUS_VTABLE_UNPRIVILEGED),
3439 SD_BUS_METHOD_WITH_ARGS("AddDependencyUnitFiles",
3440 SD_BUS_ARGS("as", files, "s", target, "s", type, "b", runtime, "b", force),
3441 SD_BUS_RESULT("a(sss)", changes),
3442 method_add_dependency_unit_files,
3443 SD_BUS_VTABLE_UNPRIVILEGED),
3444 SD_BUS_METHOD_WITH_ARGS("GetUnitFileLinks",
3445 SD_BUS_ARGS("s", name, "b", runtime),
3446 SD_BUS_RESULT("as", links),
3447 method_get_unit_file_links,
3448 SD_BUS_VTABLE_UNPRIVILEGED),
3449 SD_BUS_METHOD_WITH_ARGS("SetExitCode",
3450 SD_BUS_ARGS("y", number),
3451 SD_BUS_NO_RESULT,
3452 method_set_exit_code,
3453 SD_BUS_VTABLE_UNPRIVILEGED),
3454 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByName",
3455 SD_BUS_ARGS("s", name),
3456 SD_BUS_RESULT("u", uid),
3457 method_lookup_dynamic_user_by_name,
3458 SD_BUS_VTABLE_UNPRIVILEGED),
3459 SD_BUS_METHOD_WITH_ARGS("LookupDynamicUserByUID",
3460 SD_BUS_ARGS("u", uid),
3461 SD_BUS_RESULT("s", name),
3462 method_lookup_dynamic_user_by_uid,
3463 SD_BUS_VTABLE_UNPRIVILEGED),
3464 SD_BUS_METHOD_WITH_ARGS("GetDynamicUsers",
3465 SD_BUS_NO_ARGS,
3466 SD_BUS_RESULT("a(us)", users),
3467 method_get_dynamic_users,
3468 SD_BUS_VTABLE_UNPRIVILEGED),
2ea24611
LP		 3469 SD_BUS_METHOD_WITH_ARGS("DumpUnitFileDescriptorStore",
3470 SD_BUS_ARGS("s", name),
3471 SD_BUS_RESULT("a(suuutuusu)", entries),
3472 method_dump_unit_descriptor_store,
3473 SD_BUS_VTABLE_UNPRIVILEGED),
a008b6d7 3474
3475 SD_BUS_SIGNAL_WITH_ARGS("UnitNew",
3476 SD_BUS_ARGS("s", id, "o", unit),
3477 0),
3478 SD_BUS_SIGNAL_WITH_ARGS("UnitRemoved",
3479 SD_BUS_ARGS("s", id, "o", unit),
3480 0),
3481 SD_BUS_SIGNAL_WITH_ARGS("JobNew",
3482 SD_BUS_ARGS("u", id, "o", job, "s", unit),
3483 0),
3484 SD_BUS_SIGNAL_WITH_ARGS("JobRemoved",
3485 SD_BUS_ARGS("u", id, "o", job, "s", unit, "s", result),
3486 0),
3487 SD_BUS_SIGNAL_WITH_ARGS("StartupFinished",
3488 SD_BUS_ARGS("t", firmware, "t", loader, "t", kernel, "t", initrd, "t", userspace, "t", total),
3489 0),
718db961 3490 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
a008b6d7 3491 SD_BUS_SIGNAL_WITH_ARGS("Reloading",
3492 SD_BUS_ARGS("b", active),
3493 0),
718db961
LP		 3494
3495 SD_BUS_VTABLE_END
ea430986 3496};
718db961 3497
893f801d
LP		 3498const sd_bus_vtable bus_manager_log_control_vtable[] = {
3499 SD_BUS_VTABLE_START(0),
3500
3501 /* We define a private version of this interface here, since we want slightly different
3502 * implementations for the setters. We'll still use the generic getters however, and we share the
3503 * setters with the implementations for the Manager interface above (which pre-dates the generic
3504 * service API interface). */
3505
3506 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", bus_property_get_log_level, property_set_log_level, 0, 0),
3507 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", bus_property_get_log_target, property_set_log_target, 0, 0),
3508 SD_BUS_PROPERTY("SyslogIdentifier", "s", bus_property_get_syslog_identifier, 0, 0),
3509
3510 SD_BUS_VTABLE_END,
3511};
3512
8f8f05a9 3513static int send_finished(sd_bus *bus, void *userdata) {
4afd3348 3514 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
99534007 3515 usec_t *times = ASSERT_PTR(userdata);
718db961
LP		 3516 int r;
3517
3518 assert(bus);
718db961 3519
cb31470f
ZJS		 3520 r = sd_bus_message_new_signal(bus,
3521 &message,
3522 "/org/freedesktop/systemd1",
3523 "org.freedesktop.systemd1.Manager",
3524 "StartupFinished");
718db961
LP		 3525 if (r < 0)
3526 return r;
3527
3528 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
3529 if (r < 0)
3530 return r;
3531
8f8f05a9 3532 return sd_bus_send(bus, message, NULL);
718db961
LP		 3533}
3534
39abcaee 3535void bus_manager_send_finished(
718db961
LP		 3536 Manager *m,
3537 usec_t firmware_usec,
3538 usec_t loader_usec,
3539 usec_t kernel_usec,
3540 usec_t initrd_usec,
3541 usec_t userspace_usec,
3542 usec_t total_usec) {
3543
39abcaee
LP		 3544 int r;
3545
718db961
LP		 3546 assert(m);
3547
8f8f05a9
LP		 3548 r = bus_foreach_bus(
3549 m,
3550 NULL,
3551 send_finished,
3552 (usec_t[6]) {
3553 firmware_usec,
3554 loader_usec,
3555 kernel_usec,
3556 initrd_usec,
3557 userspace_usec,
3558 total_usec
3559 });
39abcaee 3560 if (r < 0)
da927ba9 3561 log_debug_errno(r, "Failed to send finished signal: %m");
718db961
LP		 3562}
3563
8f8f05a9 3564static int send_reloading(sd_bus *bus, void *userdata) {
4afd3348 3565 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
718db961
LP		 3566 int r;
3567
3568 assert(bus);
3569
151b9b96 3570 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
718db961
LP		 3571 if (r < 0)
3572 return r;
3573
3574 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
3575 if (r < 0)
3576 return r;
3577
8f8f05a9 3578 return sd_bus_send(bus, message, NULL);
718db961
LP		 3579}
3580
39abcaee
LP		 3581void bus_manager_send_reloading(Manager *m, bool active) {
3582 int r;
3583
718db961
LP		 3584 assert(m);
3585
8f8f05a9 3586 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
39abcaee 3587 if (r < 0)
da927ba9 3588 log_debug_errno(r, "Failed to send reloading signal: %m");
03455c28
LDM		 3589}
3590
3591static int send_changed_signal(sd_bus *bus, void *userdata) {
3592 assert(bus);
3593
3594 return sd_bus_emit_properties_changed_strv(bus,
3595 "/org/freedesktop/systemd1",
3596 "org.freedesktop.systemd1.Manager",
3597 NULL);
3598}
39abcaee 3599
03455c28
LDM		 3600void bus_manager_send_change_signal(Manager *m) {
3601 int r;
3602
3603 assert(m);
3604
3605 r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
3606 if (r < 0)
3607 log_debug_errno(r, "Failed to send manager change signal: %m");
718db961 3608}
Unnamed repository; edit this file 'description' to name the repository.