]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/core/dbus-manager.c
pid1: preserve current value of log level across re-{load,execution}
[thirdparty/systemd.git] / src / core / dbus-manager.c
1 /* SPDX-License-Identifier: LGPL-2.1+ */
2 /***
3 This file is part of systemd.
4
5 Copyright 2010 Lennart Poettering
6 ***/
7
8 #include <errno.h>
9 #include <sys/prctl.h>
10 #include <sys/statvfs.h>
11 #include <unistd.h>
12
13 #include "alloc-util.h"
14 #include "architecture.h"
15 #include "build.h"
16 #include "bus-common-errors.h"
17 #include "dbus-execute.h"
18 #include "dbus-job.h"
19 #include "dbus-manager.h"
20 #include "dbus-unit.h"
21 #include "dbus.h"
22 #include "env-util.h"
23 #include "fd-util.h"
24 #include "fileio.h"
25 #include "format-util.h"
26 #include "fs-util.h"
27 #include "install.h"
28 #include "log.h"
29 #include "os-util.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "selinux-access.h"
33 #include "stat-util.h"
34 #include "string-util.h"
35 #include "strv.h"
36 #include "syslog-util.h"
37 #include "user-util.h"
38 #include "virt.h"
39 #include "watchdog.h"
40
41 /* Require 16MiB free in /run/systemd for reloading/reexecing. After all we need to serialize our state there, and if
42 * we can't we'll fail badly. */
43 #define RELOAD_DISK_SPACE_MIN (UINT64_C(16) * UINT64_C(1024) * UINT64_C(1024))
44
45 static UnitFileFlags unit_file_bools_to_flags(bool runtime, bool force) {
46 return (runtime ? UNIT_FILE_RUNTIME : 0) |
47 (force ? UNIT_FILE_FORCE : 0);
48 }
49
50 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_version, "s", PACKAGE_VERSION);
51 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_features, "s", SYSTEMD_FEATURES);
52 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_architecture, "s", architecture_to_string(uname_architecture()));
53 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_log_target, "s", log_target_to_string(log_get_target()));
54 static BUS_DEFINE_PROPERTY_GET2(property_get_system_state, "s", Manager, manager_state, manager_state_to_string);
55 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_timer_slack_nsec, "t", (uint64_t) prctl(PR_GET_TIMERSLACK));
56 static BUS_DEFINE_PROPERTY_GET_REF(property_get_hashmap_size, "u", Hashmap *, hashmap_size);
57 static BUS_DEFINE_PROPERTY_GET_REF(property_get_set_size, "u", Set *, set_size);
58
59 static int property_get_virtualization(
60 sd_bus *bus,
61 const char *path,
62 const char *interface,
63 const char *property,
64 sd_bus_message *reply,
65 void *userdata,
66 sd_bus_error *error) {
67
68 int v;
69
70 assert(bus);
71 assert(reply);
72
73 v = detect_virtualization();
74
75 /* Make sure to return the empty string when we detect no virtualization, as that is the API.
76 *
77 * https://github.com/systemd/systemd/issues/1423
78 */
79
80 return sd_bus_message_append(
81 reply, "s",
82 v == VIRTUALIZATION_NONE ? NULL : virtualization_to_string(v));
83 }
84
85 static int property_get_tainted(
86 sd_bus *bus,
87 const char *path,
88 const char *interface,
89 const char *property,
90 sd_bus_message *reply,
91 void *userdata,
92 sd_bus_error *error) {
93
94 _cleanup_free_ char *s = NULL;
95 Manager *m = userdata;
96
97 assert(bus);
98 assert(reply);
99 assert(m);
100
101 s = manager_taint_string(m);
102 if (!s)
103 return log_oom();
104
105 return sd_bus_message_append(reply, "s", s);
106 }
107
108 static int property_set_log_target(
109 sd_bus *bus,
110 const char *path,
111 const char *interface,
112 const char *property,
113 sd_bus_message *value,
114 void *userdata,
115 sd_bus_error *error) {
116
117 const char *t;
118 int r;
119
120 assert(bus);
121 assert(value);
122
123 r = sd_bus_message_read(value, "s", &t);
124 if (r < 0)
125 return r;
126
127 return log_set_target_from_string(t);
128 }
129
130 static int property_get_log_level(
131 sd_bus *bus,
132 const char *path,
133 const char *interface,
134 const char *property,
135 sd_bus_message *reply,
136 void *userdata,
137 sd_bus_error *error) {
138
139 _cleanup_free_ char *t = NULL;
140 int r;
141
142 assert(bus);
143 assert(reply);
144
145 r = log_level_to_string_alloc(log_get_max_level(), &t);
146 if (r < 0)
147 return r;
148
149 return sd_bus_message_append(reply, "s", t);
150 }
151
152 static int property_set_log_level(
153 sd_bus *bus,
154 const char *path,
155 const char *interface,
156 const char *property,
157 sd_bus_message *value,
158 void *userdata,
159 sd_bus_error *error) {
160
161 Manager *m = userdata;
162 const char *t;
163 int r;
164
165 assert(bus);
166 assert(value);
167
168 r = sd_bus_message_read(value, "s", &t);
169 if (r < 0)
170 return r;
171
172 if (isempty(t))
173 manager_restore_original_log_level(m);
174 else {
175 int level;
176
177 level = log_level_from_string(t);
178 if (level < 0)
179 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid log level '%s'", t);
180
181 manager_override_log_level(m, level);
182 }
183
184 return 0;
185 }
186
187 static int property_get_progress(
188 sd_bus *bus,
189 const char *path,
190 const char *interface,
191 const char *property,
192 sd_bus_message *reply,
193 void *userdata,
194 sd_bus_error *error) {
195
196 Manager *m = userdata;
197 double d;
198
199 assert(bus);
200 assert(reply);
201 assert(m);
202
203 if (MANAGER_IS_FINISHED(m))
204 d = 1.0;
205 else
206 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
207
208 return sd_bus_message_append(reply, "d", d);
209 }
210
211 static int property_get_show_status(
212 sd_bus *bus,
213 const char *path,
214 const char *interface,
215 const char *property,
216 sd_bus_message *reply,
217 void *userdata,
218 sd_bus_error *error) {
219
220 Manager *m = userdata;
221 int b;
222
223 assert(bus);
224 assert(reply);
225 assert(m);
226
227 b = m->show_status > 0;
228 return sd_bus_message_append_basic(reply, 'b', &b);
229 }
230
231 static int property_set_runtime_watchdog(
232 sd_bus *bus,
233 const char *path,
234 const char *interface,
235 const char *property,
236 sd_bus_message *value,
237 void *userdata,
238 sd_bus_error *error) {
239
240 usec_t *t = userdata;
241 int r;
242
243 assert(bus);
244 assert(value);
245
246 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
247
248 r = sd_bus_message_read(value, "t", t);
249 if (r < 0)
250 return r;
251
252 return watchdog_set_timeout(t);
253 }
254
255 static int bus_get_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
256 Unit *u;
257 int r;
258
259 assert(m);
260 assert(message);
261 assert(ret_unit);
262
263 /* More or less a wrapper around manager_get_unit() that generates nice errors and has one trick up its sleeve:
264 * if the name is specified empty we use the client's unit. */
265
266 if (isempty(name)) {
267 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
268 pid_t pid;
269
270 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
271 if (r < 0)
272 return r;
273
274 r = sd_bus_creds_get_pid(creds, &pid);
275 if (r < 0)
276 return r;
277
278 u = manager_get_unit_by_pid(m, pid);
279 if (!u)
280 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Client not member of any unit.");
281 } else {
282 u = manager_get_unit(m, name);
283 if (!u)
284 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
285 }
286
287 *ret_unit = u;
288 return 0;
289 }
290
291 static int bus_load_unit_by_name(Manager *m, sd_bus_message *message, const char *name, Unit **ret_unit, sd_bus_error *error) {
292 assert(m);
293 assert(message);
294 assert(ret_unit);
295
296 /* Pretty much the same as bus_get_unit_by_name(), but we also load the unit if necessary. */
297
298 if (isempty(name))
299 return bus_get_unit_by_name(m, message, name, ret_unit, error);
300
301 return manager_load_unit(m, name, NULL, error, ret_unit);
302 }
303
304 static int method_get_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
305 _cleanup_free_ char *path = NULL;
306 Manager *m = userdata;
307 const char *name;
308 Unit *u;
309 int r;
310
311 assert(message);
312 assert(m);
313
314 /* Anyone can call this method */
315
316 r = sd_bus_message_read(message, "s", &name);
317 if (r < 0)
318 return r;
319
320 r = bus_get_unit_by_name(m, message, name, &u, error);
321 if (r < 0)
322 return r;
323
324 r = mac_selinux_unit_access_check(u, message, "status", error);
325 if (r < 0)
326 return r;
327
328 path = unit_dbus_path(u);
329 if (!path)
330 return -ENOMEM;
331
332 return sd_bus_reply_method_return(message, "o", path);
333 }
334
335 static int method_get_unit_by_pid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
336 _cleanup_free_ char *path = NULL;
337 Manager *m = userdata;
338 pid_t pid;
339 Unit *u;
340 int r;
341
342 assert(message);
343 assert(m);
344
345 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
346
347 /* Anyone can call this method */
348
349 r = sd_bus_message_read(message, "u", &pid);
350 if (r < 0)
351 return r;
352 if (pid < 0)
353 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid PID " PID_FMT, pid);
354
355 if (pid == 0) {
356 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
357
358 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
359 if (r < 0)
360 return r;
361
362 r = sd_bus_creds_get_pid(creds, &pid);
363 if (r < 0)
364 return r;
365 }
366
367 u = manager_get_unit_by_pid(m, pid);
368 if (!u)
369 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID "PID_FMT" does not belong to any loaded unit.", pid);
370
371 r = mac_selinux_unit_access_check(u, message, "status", error);
372 if (r < 0)
373 return r;
374
375 path = unit_dbus_path(u);
376 if (!path)
377 return -ENOMEM;
378
379 return sd_bus_reply_method_return(message, "o", path);
380 }
381
382 static int method_get_unit_by_invocation_id(sd_bus_message *message, void *userdata, sd_bus_error *error) {
383 _cleanup_free_ char *path = NULL;
384 Manager *m = userdata;
385 sd_id128_t id;
386 const void *a;
387 Unit *u;
388 size_t sz;
389 int r;
390
391 assert(message);
392 assert(m);
393
394 /* Anyone can call this method */
395
396 r = sd_bus_message_read_array(message, 'y', &a, &sz);
397 if (r < 0)
398 return r;
399 if (sz == 0)
400 id = SD_ID128_NULL;
401 else if (sz == 16)
402 memcpy(&id, a, sz);
403 else
404 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid invocation ID");
405
406 if (sd_id128_is_null(id)) {
407 _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
408 pid_t pid;
409
410 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
411 if (r < 0)
412 return r;
413
414 r = sd_bus_creds_get_pid(creds, &pid);
415 if (r < 0)
416 return r;
417
418 u = manager_get_unit_by_pid(m, pid);
419 if (!u)
420 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Client " PID_FMT " not member of any unit.", pid);
421 } else {
422 u = hashmap_get(m->units_by_invocation_id, &id);
423 if (!u)
424 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));
425 }
426
427 r = mac_selinux_unit_access_check(u, message, "status", error);
428 if (r < 0)
429 return r;
430
431 /* So here's a special trick: the bus path we return actually references the unit by its invocation ID instead
432 * of the unit name. This means it stays valid only as long as the invocation ID stays the same. */
433 path = unit_dbus_path_invocation_id(u);
434 if (!path)
435 return -ENOMEM;
436
437 return sd_bus_reply_method_return(message, "o", path);
438 }
439
440 static int method_get_unit_by_control_group(sd_bus_message *message, void *userdata, sd_bus_error *error) {
441 _cleanup_free_ char *path = NULL;
442 Manager *m = userdata;
443 const char *cgroup;
444 Unit *u;
445 int r;
446
447 r = sd_bus_message_read(message, "s", &cgroup);
448 if (r < 0)
449 return r;
450
451 u = manager_get_unit_by_cgroup(m, cgroup);
452 if (!u)
453 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Control group '%s' is not valid or not managed by this instance", cgroup);
454
455 r = mac_selinux_unit_access_check(u, message, "status", error);
456 if (r < 0)
457 return r;
458
459 path = unit_dbus_path(u);
460 if (!path)
461 return -ENOMEM;
462
463 return sd_bus_reply_method_return(message, "o", path);
464 }
465
466 static int method_load_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
467 _cleanup_free_ char *path = NULL;
468 Manager *m = userdata;
469 const char *name;
470 Unit *u;
471 int r;
472
473 assert(message);
474 assert(m);
475
476 /* Anyone can call this method */
477
478 r = sd_bus_message_read(message, "s", &name);
479 if (r < 0)
480 return r;
481
482 r = bus_load_unit_by_name(m, message, name, &u, error);
483 if (r < 0)
484 return r;
485
486 r = mac_selinux_unit_access_check(u, message, "status", error);
487 if (r < 0)
488 return r;
489
490 path = unit_dbus_path(u);
491 if (!path)
492 return -ENOMEM;
493
494 return sd_bus_reply_method_return(message, "o", path);
495 }
496
497 static int method_start_unit_generic(sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
498 const char *name;
499 Unit *u;
500 int r;
501
502 assert(message);
503 assert(m);
504
505 r = sd_bus_message_read(message, "s", &name);
506 if (r < 0)
507 return r;
508
509 r = manager_load_unit(m, name, NULL, error, &u);
510 if (r < 0)
511 return r;
512
513 return bus_unit_method_start_generic(message, u, job_type, reload_if_possible, error);
514 }
515
516 static int method_start_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
517 return method_start_unit_generic(message, userdata, JOB_START, false, error);
518 }
519
520 static int method_stop_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
521 return method_start_unit_generic(message, userdata, JOB_STOP, false, error);
522 }
523
524 static int method_reload_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
525 return method_start_unit_generic(message, userdata, JOB_RELOAD, false, error);
526 }
527
528 static int method_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
529 return method_start_unit_generic(message, userdata, JOB_RESTART, false, error);
530 }
531
532 static int method_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
533 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, false, error);
534 }
535
536 static int method_reload_or_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
537 return method_start_unit_generic(message, userdata, JOB_RESTART, true, error);
538 }
539
540 static int method_reload_or_try_restart_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
541 return method_start_unit_generic(message, userdata, JOB_TRY_RESTART, true, error);
542 }
543
544 static int method_start_unit_replace(sd_bus_message *message, void *userdata, sd_bus_error *error) {
545 Manager *m = userdata;
546 const char *old_name;
547 Unit *u;
548 int r;
549
550 assert(message);
551 assert(m);
552
553 r = sd_bus_message_read(message, "s", &old_name);
554 if (r < 0)
555 return r;
556
557 r = bus_get_unit_by_name(m, message, old_name, &u, error);
558 if (r < 0)
559 return r;
560 if (!u->job || u->job->type != JOB_START)
561 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
562
563 return method_start_unit_generic(message, m, JOB_START, false, error);
564 }
565
566 static int method_kill_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
567 Manager *m = userdata;
568 const char *name;
569 Unit *u;
570 int r;
571
572 assert(message);
573 assert(m);
574
575 r = sd_bus_message_read(message, "s", &name);
576 if (r < 0)
577 return r;
578
579 r = bus_get_unit_by_name(m, message, name, &u, error);
580 if (r < 0)
581 return r;
582
583 return bus_unit_method_kill(message, u, error);
584 }
585
586 static int method_reset_failed_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
587 Manager *m = userdata;
588 const char *name;
589 Unit *u;
590 int r;
591
592 assert(message);
593 assert(m);
594
595 r = sd_bus_message_read(message, "s", &name);
596 if (r < 0)
597 return r;
598
599 r = bus_get_unit_by_name(m, message, name, &u, error);
600 if (r < 0)
601 return r;
602
603 return bus_unit_method_reset_failed(message, u, error);
604 }
605
606 static int method_set_unit_properties(sd_bus_message *message, void *userdata, sd_bus_error *error) {
607 Manager *m = userdata;
608 const char *name;
609 Unit *u;
610 int r;
611
612 assert(message);
613 assert(m);
614
615 r = sd_bus_message_read(message, "s", &name);
616 if (r < 0)
617 return r;
618
619 r = bus_load_unit_by_name(m, message, name, &u, error);
620 if (r < 0)
621 return r;
622
623 r = bus_unit_validate_load_state(u, error);
624 if (r < 0)
625 return r;
626
627 return bus_unit_method_set_properties(message, u, error);
628 }
629
630 static int method_ref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
631 Manager *m = userdata;
632 const char *name;
633 Unit *u;
634 int r;
635
636 assert(message);
637 assert(m);
638
639 r = sd_bus_message_read(message, "s", &name);
640 if (r < 0)
641 return r;
642
643 r = bus_load_unit_by_name(m, message, name, &u, error);
644 if (r < 0)
645 return r;
646
647 r = bus_unit_validate_load_state(u, error);
648 if (r < 0)
649 return r;
650
651 return bus_unit_method_ref(message, u, error);
652 }
653
654 static int method_unref_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
655 Manager *m = userdata;
656 const char *name;
657 Unit *u;
658 int r;
659
660 assert(message);
661 assert(m);
662
663 r = sd_bus_message_read(message, "s", &name);
664 if (r < 0)
665 return r;
666
667 r = bus_load_unit_by_name(m, message, name, &u, error);
668 if (r < 0)
669 return r;
670
671 r = bus_unit_validate_load_state(u, error);
672 if (r < 0)
673 return r;
674
675 return bus_unit_method_unref(message, u, error);
676 }
677
678 static int reply_unit_info(sd_bus_message *reply, Unit *u) {
679 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
680 Unit *following;
681
682 following = unit_following(u);
683
684 unit_path = unit_dbus_path(u);
685 if (!unit_path)
686 return -ENOMEM;
687
688 if (u->job) {
689 job_path = job_dbus_path(u->job);
690 if (!job_path)
691 return -ENOMEM;
692 }
693
694 return sd_bus_message_append(
695 reply, "(ssssssouso)",
696 u->id,
697 unit_description(u),
698 unit_load_state_to_string(u->load_state),
699 unit_active_state_to_string(unit_active_state(u)),
700 unit_sub_state_to_string(u),
701 following ? following->id : "",
702 unit_path,
703 u->job ? u->job->id : 0,
704 u->job ? job_type_to_string(u->job->type) : "",
705 job_path ? job_path : "/");
706 }
707
708 static int method_list_units_by_names(sd_bus_message *message, void *userdata, sd_bus_error *error) {
709 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
710 Manager *m = userdata;
711 int r;
712 char **unit;
713 _cleanup_strv_free_ char **units = NULL;
714
715 assert(message);
716 assert(m);
717
718 r = sd_bus_message_read_strv(message, &units);
719 if (r < 0)
720 return r;
721
722 r = sd_bus_message_new_method_return(message, &reply);
723 if (r < 0)
724 return r;
725
726 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
727 if (r < 0)
728 return r;
729
730 STRV_FOREACH(unit, units) {
731 Unit *u;
732
733 if (!unit_name_is_valid(*unit, UNIT_NAME_ANY))
734 continue;
735
736 r = bus_load_unit_by_name(m, message, *unit, &u, error);
737 if (r < 0)
738 return r;
739
740 r = reply_unit_info(reply, u);
741 if (r < 0)
742 return r;
743 }
744
745 r = sd_bus_message_close_container(reply);
746 if (r < 0)
747 return r;
748
749 return sd_bus_send(NULL, reply, NULL);
750 }
751
752 static int method_get_unit_processes(sd_bus_message *message, void *userdata, sd_bus_error *error) {
753 Manager *m = userdata;
754 const char *name;
755 Unit *u;
756 int r;
757
758 assert(message);
759 assert(m);
760
761 r = sd_bus_message_read(message, "s", &name);
762 if (r < 0)
763 return r;
764
765 r = bus_get_unit_by_name(m, message, name, &u, error);
766 if (r < 0)
767 return r;
768
769 return bus_unit_method_get_processes(message, u, error);
770 }
771
772 static int method_attach_processes_to_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
773 Manager *m = userdata;
774 const char *name;
775 Unit *u;
776 int r;
777
778 assert(message);
779 assert(m);
780
781 r = sd_bus_message_read(message, "s", &name);
782 if (r < 0)
783 return r;
784
785 r = bus_get_unit_by_name(m, message, name, &u, error);
786 if (r < 0)
787 return r;
788
789 return bus_unit_method_attach_processes(message, u, error);
790 }
791
792 static int transient_unit_from_message(
793 Manager *m,
794 sd_bus_message *message,
795 const char *name,
796 Unit **unit,
797 sd_bus_error *error) {
798
799 UnitType t;
800 Unit *u;
801 int r;
802
803 assert(m);
804 assert(message);
805 assert(name);
806
807 t = unit_name_to_type(name);
808 if (t < 0)
809 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit name or type.");
810
811 if (!unit_vtable[t]->can_transient)
812 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit type %s does not support transient units.", unit_type_to_string(t));
813
814 r = manager_load_unit(m, name, NULL, error, &u);
815 if (r < 0)
816 return r;
817
818 if (!unit_is_pristine(u))
819 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit %s already exists.", name);
820
821 /* OK, the unit failed to load and is unreferenced, now let's
822 * fill in the transient data instead */
823 r = unit_make_transient(u);
824 if (r < 0)
825 return r;
826
827 /* Set our properties */
828 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
829 if (r < 0)
830 return r;
831
832 /* If the client asked for it, automatically add a reference to this unit. */
833 if (u->bus_track_add) {
834 r = bus_unit_track_add_sender(u, message);
835 if (r < 0)
836 return log_error_errno(r, "Failed to watch sender: %m");
837 }
838
839 /* Now load the missing bits of the unit we just created */
840 unit_add_to_load_queue(u);
841 manager_dispatch_load_queue(m);
842
843 *unit = u;
844
845 return 0;
846 }
847
848 static int transient_aux_units_from_message(
849 Manager *m,
850 sd_bus_message *message,
851 sd_bus_error *error) {
852
853 int r;
854
855 assert(m);
856 assert(message);
857
858 r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
859 if (r < 0)
860 return r;
861
862 while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
863 const char *name = NULL;
864 Unit *u;
865
866 r = sd_bus_message_read(message, "s", &name);
867 if (r < 0)
868 return r;
869
870 r = transient_unit_from_message(m, message, name, &u, error);
871 if (r < 0)
872 return r;
873
874 r = sd_bus_message_exit_container(message);
875 if (r < 0)
876 return r;
877 }
878 if (r < 0)
879 return r;
880
881 r = sd_bus_message_exit_container(message);
882 if (r < 0)
883 return r;
884
885 return 0;
886 }
887
888 static int method_start_transient_unit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
889 const char *name, *smode;
890 Manager *m = userdata;
891 JobMode mode;
892 Unit *u;
893 int r;
894
895 assert(message);
896 assert(m);
897
898 r = mac_selinux_access_check(message, "start", error);
899 if (r < 0)
900 return r;
901
902 r = sd_bus_message_read(message, "ss", &name, &smode);
903 if (r < 0)
904 return r;
905
906 mode = job_mode_from_string(smode);
907 if (mode < 0)
908 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
909
910 r = bus_verify_manage_units_async(m, message, error);
911 if (r < 0)
912 return r;
913 if (r == 0)
914 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
915
916 r = transient_unit_from_message(m, message, name, &u, error);
917 if (r < 0)
918 return r;
919
920 r = transient_aux_units_from_message(m, message, error);
921 if (r < 0)
922 return r;
923
924 /* Finally, start it */
925 return bus_unit_queue_job(message, u, JOB_START, mode, false, error);
926 }
927
928 static int method_get_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
929 _cleanup_free_ char *path = NULL;
930 Manager *m = userdata;
931 uint32_t id;
932 Job *j;
933 int r;
934
935 assert(message);
936 assert(m);
937
938 /* Anyone can call this method */
939
940 r = sd_bus_message_read(message, "u", &id);
941 if (r < 0)
942 return r;
943
944 j = manager_get_job(m, id);
945 if (!j)
946 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
947
948 r = mac_selinux_unit_access_check(j->unit, message, "status", error);
949 if (r < 0)
950 return r;
951
952 path = job_dbus_path(j);
953 if (!path)
954 return -ENOMEM;
955
956 return sd_bus_reply_method_return(message, "o", path);
957 }
958
959 static int method_cancel_job(sd_bus_message *message, void *userdata, sd_bus_error *error) {
960 Manager *m = userdata;
961 uint32_t id;
962 Job *j;
963 int r;
964
965 assert(message);
966 assert(m);
967
968 r = sd_bus_message_read(message, "u", &id);
969 if (r < 0)
970 return r;
971
972 j = manager_get_job(m, id);
973 if (!j)
974 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
975
976 return bus_job_method_cancel(message, j, error);
977 }
978
979 static int method_clear_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
980 Manager *m = userdata;
981 int r;
982
983 assert(message);
984 assert(m);
985
986 r = mac_selinux_access_check(message, "reload", error);
987 if (r < 0)
988 return r;
989
990 r = bus_verify_manage_units_async(m, message, error);
991 if (r < 0)
992 return r;
993 if (r == 0)
994 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
995
996 manager_clear_jobs(m);
997
998 return sd_bus_reply_method_return(message, NULL);
999 }
1000
1001 static int method_reset_failed(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1002 Manager *m = userdata;
1003 int r;
1004
1005 assert(message);
1006 assert(m);
1007
1008 r = mac_selinux_access_check(message, "reload", error);
1009 if (r < 0)
1010 return r;
1011
1012 r = bus_verify_manage_units_async(m, message, error);
1013 if (r < 0)
1014 return r;
1015 if (r == 0)
1016 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1017
1018 manager_reset_failed(m);
1019
1020 return sd_bus_reply_method_return(message, NULL);
1021 }
1022
1023 static int list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
1024 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1025 Manager *m = userdata;
1026 const char *k;
1027 Iterator i;
1028 Unit *u;
1029 int r;
1030
1031 assert(message);
1032 assert(m);
1033
1034 /* Anyone can call this method */
1035
1036 r = mac_selinux_access_check(message, "status", error);
1037 if (r < 0)
1038 return r;
1039
1040 r = sd_bus_message_new_method_return(message, &reply);
1041 if (r < 0)
1042 return r;
1043
1044 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
1045 if (r < 0)
1046 return r;
1047
1048 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
1049 if (k != u->id)
1050 continue;
1051
1052 if (!strv_isempty(states) &&
1053 !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
1054 !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
1055 !strv_contains(states, unit_sub_state_to_string(u)))
1056 continue;
1057
1058 if (!strv_isempty(patterns) &&
1059 !strv_fnmatch_or_empty(patterns, u->id, FNM_NOESCAPE))
1060 continue;
1061
1062 r = reply_unit_info(reply, u);
1063 if (r < 0)
1064 return r;
1065 }
1066
1067 r = sd_bus_message_close_container(reply);
1068 if (r < 0)
1069 return r;
1070
1071 return sd_bus_send(NULL, reply, NULL);
1072 }
1073
1074 static int method_list_units(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1075 return list_units_filtered(message, userdata, error, NULL, NULL);
1076 }
1077
1078 static int method_list_units_filtered(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1079 _cleanup_strv_free_ char **states = NULL;
1080 int r;
1081
1082 r = sd_bus_message_read_strv(message, &states);
1083 if (r < 0)
1084 return r;
1085
1086 return list_units_filtered(message, userdata, error, states, NULL);
1087 }
1088
1089 static int method_list_units_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1090 _cleanup_strv_free_ char **states = NULL;
1091 _cleanup_strv_free_ char **patterns = NULL;
1092 int r;
1093
1094 r = sd_bus_message_read_strv(message, &states);
1095 if (r < 0)
1096 return r;
1097
1098 r = sd_bus_message_read_strv(message, &patterns);
1099 if (r < 0)
1100 return r;
1101
1102 return list_units_filtered(message, userdata, error, states, patterns);
1103 }
1104
1105 static int method_list_jobs(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1106 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1107 Manager *m = userdata;
1108 Iterator i;
1109 Job *j;
1110 int r;
1111
1112 assert(message);
1113 assert(m);
1114
1115 /* Anyone can call this method */
1116
1117 r = mac_selinux_access_check(message, "status", error);
1118 if (r < 0)
1119 return r;
1120
1121 r = sd_bus_message_new_method_return(message, &reply);
1122 if (r < 0)
1123 return r;
1124
1125 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
1126 if (r < 0)
1127 return r;
1128
1129 HASHMAP_FOREACH(j, m->jobs, i) {
1130 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
1131
1132 job_path = job_dbus_path(j);
1133 if (!job_path)
1134 return -ENOMEM;
1135
1136 unit_path = unit_dbus_path(j->unit);
1137 if (!unit_path)
1138 return -ENOMEM;
1139
1140 r = sd_bus_message_append(
1141 reply, "(usssoo)",
1142 j->id,
1143 j->unit->id,
1144 job_type_to_string(j->type),
1145 job_state_to_string(j->state),
1146 job_path,
1147 unit_path);
1148 if (r < 0)
1149 return r;
1150 }
1151
1152 r = sd_bus_message_close_container(reply);
1153 if (r < 0)
1154 return r;
1155
1156 return sd_bus_send(NULL, reply, NULL);
1157 }
1158
1159 static int method_subscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1160 Manager *m = userdata;
1161 int r;
1162
1163 assert(message);
1164 assert(m);
1165
1166 /* Anyone can call this method */
1167
1168 r = mac_selinux_access_check(message, "status", error);
1169 if (r < 0)
1170 return r;
1171
1172 if (sd_bus_message_get_bus(message) == m->api_bus) {
1173
1174 /* Note that direct bus connection subscribe by
1175 * default, we only track peers on the API bus here */
1176
1177 if (!m->subscribed) {
1178 r = sd_bus_track_new(sd_bus_message_get_bus(message), &m->subscribed, NULL, NULL);
1179 if (r < 0)
1180 return r;
1181 }
1182
1183 r = sd_bus_track_add_sender(m->subscribed, message);
1184 if (r < 0)
1185 return r;
1186 if (r == 0)
1187 return sd_bus_error_setf(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
1188 }
1189
1190 return sd_bus_reply_method_return(message, NULL);
1191 }
1192
1193 static int method_unsubscribe(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1194 Manager *m = userdata;
1195 int r;
1196
1197 assert(message);
1198 assert(m);
1199
1200 /* Anyone can call this method */
1201
1202 r = mac_selinux_access_check(message, "status", error);
1203 if (r < 0)
1204 return r;
1205
1206 if (sd_bus_message_get_bus(message) == m->api_bus) {
1207 r = sd_bus_track_remove_sender(m->subscribed, message);
1208 if (r < 0)
1209 return r;
1210 if (r == 0)
1211 return sd_bus_error_setf(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
1212 }
1213
1214 return sd_bus_reply_method_return(message, NULL);
1215 }
1216
1217 static int dump_impl(sd_bus_message *message, void *userdata, sd_bus_error *error, int (*reply)(sd_bus_message *, char *)) {
1218 _cleanup_free_ char *dump = NULL;
1219 Manager *m = userdata;
1220 int r;
1221
1222 assert(message);
1223 assert(m);
1224
1225 /* Anyone can call this method */
1226
1227 r = mac_selinux_access_check(message, "status", error);
1228 if (r < 0)
1229 return r;
1230
1231 r = manager_get_dump_string(m, &dump);
1232 if (r < 0)
1233 return r;
1234
1235 return reply(message, dump);
1236 }
1237
1238 static int reply_dump(sd_bus_message *message, char *dump) {
1239 return sd_bus_reply_method_return(message, "s", dump);
1240 }
1241
1242 static int method_dump(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1243 return dump_impl(message, userdata, error, reply_dump);
1244 }
1245
1246 static int reply_dump_by_fd(sd_bus_message *message, char *dump) {
1247 _cleanup_close_ int fd = -1;
1248
1249 fd = acquire_data_fd(dump, strlen(dump), 0);
1250 if (fd < 0)
1251 return fd;
1252
1253 return sd_bus_reply_method_return(message, "h", fd);
1254 }
1255
1256 static int method_dump_by_fd(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1257 return dump_impl(message, userdata, error, reply_dump_by_fd);
1258 }
1259
1260 static int method_refuse_snapshot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1261 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Support for snapshots has been removed.");
1262 }
1263
1264 static int verify_run_space(const char *message, sd_bus_error *error) {
1265 struct statvfs svfs;
1266 uint64_t available;
1267
1268 if (statvfs("/run/systemd", &svfs) < 0)
1269 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1270
1271 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1272
1273 if (available < RELOAD_DISK_SPACE_MIN) {
1274 char fb_available[FORMAT_BYTES_MAX], fb_need[FORMAT_BYTES_MAX];
1275 return sd_bus_error_setf(error,
1276 BUS_ERROR_DISK_FULL,
1277 "%s, not enough space available on /run/systemd. "
1278 "Currently, %s are free, but a safety buffer of %s is enforced.",
1279 message,
1280 format_bytes(fb_available, sizeof(fb_available), available),
1281 format_bytes(fb_need, sizeof(fb_need), RELOAD_DISK_SPACE_MIN));
1282 }
1283
1284 return 0;
1285 }
1286
1287 int verify_run_space_and_log(const char *message) {
1288 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
1289 int r;
1290
1291 r = verify_run_space(message, &error);
1292 if (r < 0)
1293 log_error_errno(r, "%s", bus_error_message(&error, r));
1294
1295 return r;
1296 }
1297
1298 static int method_reload(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1299 Manager *m = userdata;
1300 int r;
1301
1302 assert(message);
1303 assert(m);
1304
1305 r = verify_run_space("Refusing to reload", error);
1306 if (r < 0)
1307 return r;
1308
1309 r = mac_selinux_access_check(message, "reload", error);
1310 if (r < 0)
1311 return r;
1312
1313 r = bus_verify_reload_daemon_async(m, message, error);
1314 if (r < 0)
1315 return r;
1316 if (r == 0)
1317 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1318
1319 /* Instead of sending the reply back right away, we just
1320 * remember that we need to and then send it after the reload
1321 * is finished. That way the caller knows when the reload
1322 * finished. */
1323
1324 assert(!m->queued_message);
1325 r = sd_bus_message_new_method_return(message, &m->queued_message);
1326 if (r < 0)
1327 return r;
1328
1329 m->exit_code = MANAGER_RELOAD;
1330
1331 return 1;
1332 }
1333
1334 static int method_reexecute(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1335 Manager *m = userdata;
1336 int r;
1337
1338 assert(message);
1339 assert(m);
1340
1341 r = verify_run_space("Refusing to reexecute", error);
1342 if (r < 0)
1343 return r;
1344
1345 r = mac_selinux_access_check(message, "reload", error);
1346 if (r < 0)
1347 return r;
1348
1349 r = bus_verify_reload_daemon_async(m, message, error);
1350 if (r < 0)
1351 return r;
1352 if (r == 0)
1353 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1354
1355 /* We don't send a reply back here, the client should
1356 * just wait for us disconnecting. */
1357
1358 m->exit_code = MANAGER_REEXECUTE;
1359 return 1;
1360 }
1361
1362 static int method_exit(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1363 Manager *m = userdata;
1364 int r;
1365
1366 assert(message);
1367 assert(m);
1368
1369 r = mac_selinux_access_check(message, "halt", error);
1370 if (r < 0)
1371 return r;
1372
1373 /* Exit() (in contrast to SetExitCode()) is actually allowed even if
1374 * we are running on the host. It will fall back on reboot() in
1375 * systemd-shutdown if it cannot do the exit() because it isn't a
1376 * container. */
1377
1378 m->exit_code = MANAGER_EXIT;
1379
1380 return sd_bus_reply_method_return(message, NULL);
1381 }
1382
1383 static int method_reboot(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1384 Manager *m = userdata;
1385 int r;
1386
1387 assert(message);
1388 assert(m);
1389
1390 r = mac_selinux_access_check(message, "reboot", error);
1391 if (r < 0)
1392 return r;
1393
1394 if (!MANAGER_IS_SYSTEM(m))
1395 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
1396
1397 m->exit_code = MANAGER_REBOOT;
1398
1399 return sd_bus_reply_method_return(message, NULL);
1400 }
1401
1402 static int method_poweroff(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1403 Manager *m = userdata;
1404 int r;
1405
1406 assert(message);
1407 assert(m);
1408
1409 r = mac_selinux_access_check(message, "halt", error);
1410 if (r < 0)
1411 return r;
1412
1413 if (!MANAGER_IS_SYSTEM(m))
1414 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
1415
1416 m->exit_code = MANAGER_POWEROFF;
1417
1418 return sd_bus_reply_method_return(message, NULL);
1419 }
1420
1421 static int method_halt(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1422 Manager *m = userdata;
1423 int r;
1424
1425 assert(message);
1426 assert(m);
1427
1428 r = mac_selinux_access_check(message, "halt", error);
1429 if (r < 0)
1430 return r;
1431
1432 if (!MANAGER_IS_SYSTEM(m))
1433 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Halt is only supported for system managers.");
1434
1435 m->exit_code = MANAGER_HALT;
1436
1437 return sd_bus_reply_method_return(message, NULL);
1438 }
1439
1440 static int method_kexec(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1441 Manager *m = userdata;
1442 int r;
1443
1444 assert(message);
1445 assert(m);
1446
1447 r = mac_selinux_access_check(message, "reboot", error);
1448 if (r < 0)
1449 return r;
1450
1451 if (!MANAGER_IS_SYSTEM(m))
1452 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1453
1454 m->exit_code = MANAGER_KEXEC;
1455
1456 return sd_bus_reply_method_return(message, NULL);
1457 }
1458
1459 static int method_switch_root(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1460 char *ri = NULL, *rt = NULL;
1461 const char *root, *init;
1462 Manager *m = userdata;
1463 struct statvfs svfs;
1464 uint64_t available;
1465 int r;
1466
1467 assert(message);
1468 assert(m);
1469
1470 if (statvfs("/run/systemd", &svfs) < 0)
1471 return sd_bus_error_set_errnof(error, errno, "Failed to statvfs(/run/systemd): %m");
1472
1473 available = (uint64_t) svfs.f_bfree * (uint64_t) svfs.f_bsize;
1474
1475 if (available < RELOAD_DISK_SPACE_MIN) {
1476 char fb_available[FORMAT_BYTES_MAX], fb_need[FORMAT_BYTES_MAX];
1477 log_warning("Dangerously low amount of free space on /run/systemd, root switching operation might not complete successfuly. "
1478 "Currently, %s are free, but %s are suggested. Proceeding anyway.",
1479 format_bytes(fb_available, sizeof(fb_available), available),
1480 format_bytes(fb_need, sizeof(fb_need), RELOAD_DISK_SPACE_MIN));
1481 }
1482
1483 r = mac_selinux_access_check(message, "reboot", error);
1484 if (r < 0)
1485 return r;
1486
1487 if (!MANAGER_IS_SYSTEM(m))
1488 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Root switching is only supported by system manager.");
1489
1490 r = sd_bus_message_read(message, "ss", &root, &init);
1491 if (r < 0)
1492 return r;
1493
1494 if (isempty(root))
1495 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New root directory may not be the empty string.");
1496 if (!path_is_absolute(root))
1497 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New root path '%s' is not absolute.", root);
1498 if (path_equal(root, "/"))
1499 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "New root directory cannot be the old root directory.");
1500
1501 /* Safety check */
1502 if (isempty(init)) {
1503 r = path_is_os_tree(root);
1504 if (r < 0)
1505 return sd_bus_error_set_errnof(error, r, "Failed to determine whether root path '%s' contains an OS tree: %m", root);
1506 if (r == 0)
1507 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified switch root path '%s' does not seem to be an OS tree. os-release file is missing.", root);
1508 } else {
1509 _cleanup_free_ char *chased = NULL;
1510
1511 if (!path_is_absolute(init))
1512 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Path to init binary '%s' not absolute.", init);
1513
1514 r = chase_symlinks(init, root, CHASE_PREFIX_ROOT|CHASE_TRAIL_SLASH, &chased);
1515 if (r < 0)
1516 return sd_bus_error_set_errnof(error, r, "Could not resolve init executable %s: %m", init);
1517
1518 if (laccess(chased, X_OK) < 0) {
1519 if (errno == EACCES)
1520 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Init binary %s is not executable.", init);
1521
1522 return sd_bus_error_set_errnof(error, r, "Could not check whether init binary %s is executable: %m", init);
1523 }
1524 }
1525
1526 rt = strdup(root);
1527 if (!rt)
1528 return -ENOMEM;
1529
1530 if (!isempty(init)) {
1531 ri = strdup(init);
1532 if (!ri) {
1533 free(rt);
1534 return -ENOMEM;
1535 }
1536 }
1537
1538 free(m->switch_root);
1539 m->switch_root = rt;
1540
1541 free(m->switch_root_init);
1542 m->switch_root_init = ri;
1543
1544 m->exit_code = MANAGER_SWITCH_ROOT;
1545
1546 return sd_bus_reply_method_return(message, NULL);
1547 }
1548
1549 static int method_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1550 _cleanup_strv_free_ char **plus = NULL;
1551 Manager *m = userdata;
1552 int r;
1553
1554 assert(message);
1555 assert(m);
1556
1557 r = mac_selinux_access_check(message, "reload", error);
1558 if (r < 0)
1559 return r;
1560
1561 r = sd_bus_message_read_strv(message, &plus);
1562 if (r < 0)
1563 return r;
1564 if (!strv_env_is_valid(plus))
1565 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1566
1567 r = bus_verify_set_environment_async(m, message, error);
1568 if (r < 0)
1569 return r;
1570 if (r == 0)
1571 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1572
1573 r = manager_environment_add(m, NULL, plus);
1574 if (r < 0)
1575 return r;
1576
1577 return sd_bus_reply_method_return(message, NULL);
1578 }
1579
1580 static int method_unset_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1581 _cleanup_strv_free_ char **minus = NULL;
1582 Manager *m = userdata;
1583 int r;
1584
1585 assert(message);
1586 assert(m);
1587
1588 r = mac_selinux_access_check(message, "reload", error);
1589 if (r < 0)
1590 return r;
1591
1592 r = sd_bus_message_read_strv(message, &minus);
1593 if (r < 0)
1594 return r;
1595
1596 if (!strv_env_name_or_assignment_is_valid(minus))
1597 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1598
1599 r = bus_verify_set_environment_async(m, message, error);
1600 if (r < 0)
1601 return r;
1602 if (r == 0)
1603 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1604
1605 r = manager_environment_add(m, minus, NULL);
1606 if (r < 0)
1607 return r;
1608
1609 return sd_bus_reply_method_return(message, NULL);
1610 }
1611
1612 static int method_unset_and_set_environment(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1613 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1614 Manager *m = userdata;
1615 int r;
1616
1617 assert(message);
1618 assert(m);
1619
1620 r = mac_selinux_access_check(message, "reload", error);
1621 if (r < 0)
1622 return r;
1623
1624 r = sd_bus_message_read_strv(message, &minus);
1625 if (r < 0)
1626 return r;
1627
1628 r = sd_bus_message_read_strv(message, &plus);
1629 if (r < 0)
1630 return r;
1631
1632 if (!strv_env_name_or_assignment_is_valid(minus))
1633 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1634 if (!strv_env_is_valid(plus))
1635 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1636
1637 r = bus_verify_set_environment_async(m, message, error);
1638 if (r < 0)
1639 return r;
1640 if (r == 0)
1641 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1642
1643 r = manager_environment_add(m, minus, plus);
1644 if (r < 0)
1645 return r;
1646
1647 return sd_bus_reply_method_return(message, NULL);
1648 }
1649
1650 static int method_set_exit_code(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1651 Manager *m = userdata;
1652 uint8_t code;
1653 int r;
1654
1655 assert(message);
1656 assert(m);
1657
1658 r = mac_selinux_access_check(message, "exit", error);
1659 if (r < 0)
1660 return r;
1661
1662 r = sd_bus_message_read_basic(message, 'y', &code);
1663 if (r < 0)
1664 return r;
1665
1666 if (MANAGER_IS_SYSTEM(m) && detect_container() <= 0)
1667 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "ExitCode can only be set for user service managers or in containers.");
1668
1669 m->return_value = code;
1670
1671 return sd_bus_reply_method_return(message, NULL);
1672 }
1673
1674 static int method_lookup_dynamic_user_by_name(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1675 Manager *m = userdata;
1676 const char *name;
1677 uid_t uid;
1678 int r;
1679
1680 assert(message);
1681 assert(m);
1682
1683 r = sd_bus_message_read_basic(message, 's', &name);
1684 if (r < 0)
1685 return r;
1686
1687 if (!MANAGER_IS_SYSTEM(m))
1688 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Dynamic users are only supported in the system instance.");
1689 if (!valid_user_group_name(name))
1690 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "User name invalid: %s", name);
1691
1692 r = dynamic_user_lookup_name(m, name, &uid);
1693 if (r == -ESRCH)
1694 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER, "Dynamic user %s does not exist.", name);
1695 if (r < 0)
1696 return r;
1697
1698 return sd_bus_reply_method_return(message, "u", (uint32_t) uid);
1699 }
1700
1701 static int method_lookup_dynamic_user_by_uid(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1702 _cleanup_free_ char *name = NULL;
1703 Manager *m = userdata;
1704 uid_t uid;
1705 int r;
1706
1707 assert(message);
1708 assert(m);
1709
1710 assert_cc(sizeof(uid) == sizeof(uint32_t));
1711 r = sd_bus_message_read_basic(message, 'u', &uid);
1712 if (r < 0)
1713 return r;
1714
1715 if (!MANAGER_IS_SYSTEM(m))
1716 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Dynamic users are only supported in the system instance.");
1717 if (!uid_is_valid(uid))
1718 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "User ID invalid: " UID_FMT, uid);
1719
1720 r = dynamic_user_lookup_uid(m, uid, &name);
1721 if (r == -ESRCH)
1722 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_DYNAMIC_USER, "Dynamic user ID " UID_FMT " does not exist.", uid);
1723 if (r < 0)
1724 return r;
1725
1726 return sd_bus_reply_method_return(message, "s", name);
1727 }
1728
1729 static int method_get_dynamic_users(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1730 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1731 Manager *m = userdata;
1732 DynamicUser *d;
1733 Iterator i;
1734 int r;
1735
1736 assert(message);
1737 assert(m);
1738
1739 assert_cc(sizeof(uid_t) == sizeof(uint32_t));
1740
1741 if (!MANAGER_IS_SYSTEM(m))
1742 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Dynamic users are only supported in the system instance.");
1743
1744 r = sd_bus_message_new_method_return(message, &reply);
1745 if (r < 0)
1746 return r;
1747
1748 r = sd_bus_message_open_container(reply, 'a', "(us)");
1749 if (r < 0)
1750 return r;
1751
1752 HASHMAP_FOREACH(d, m->dynamic_users, i) {
1753 uid_t uid;
1754
1755 r = dynamic_user_current(d, &uid);
1756 if (r == -EAGAIN) /* not realized yet? */
1757 continue;
1758 if (r < 0)
1759 return sd_bus_error_setf(error, SD_BUS_ERROR_FAILED, "Failed to lookup a dynamic user.");
1760
1761 r = sd_bus_message_append(reply, "(us)", uid, d->name);
1762 if (r < 0)
1763 return r;
1764 }
1765
1766 r = sd_bus_message_close_container(reply);
1767 if (r < 0)
1768 return r;
1769
1770 return sd_bus_send(NULL, reply, NULL);
1771 }
1772
1773 static int list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error, char **states, char **patterns) {
1774 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1775 Manager *m = userdata;
1776 UnitFileList *item;
1777 Hashmap *h;
1778 Iterator i;
1779 int r;
1780
1781 assert(message);
1782 assert(m);
1783
1784 /* Anyone can call this method */
1785
1786 r = mac_selinux_access_check(message, "status", error);
1787 if (r < 0)
1788 return r;
1789
1790 r = sd_bus_message_new_method_return(message, &reply);
1791 if (r < 0)
1792 return r;
1793
1794 h = hashmap_new(&string_hash_ops);
1795 if (!h)
1796 return -ENOMEM;
1797
1798 r = unit_file_get_list(m->unit_file_scope, NULL, h, states, patterns);
1799 if (r < 0)
1800 goto fail;
1801
1802 r = sd_bus_message_open_container(reply, 'a', "(ss)");
1803 if (r < 0)
1804 goto fail;
1805
1806 HASHMAP_FOREACH(item, h, i) {
1807
1808 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
1809 if (r < 0)
1810 goto fail;
1811 }
1812
1813 unit_file_list_free(h);
1814
1815 r = sd_bus_message_close_container(reply);
1816 if (r < 0)
1817 return r;
1818
1819 return sd_bus_send(NULL, reply, NULL);
1820
1821 fail:
1822 unit_file_list_free(h);
1823 return r;
1824 }
1825
1826 static int method_list_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1827 return list_unit_files_by_patterns(message, userdata, error, NULL, NULL);
1828 }
1829
1830 static int method_list_unit_files_by_patterns(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1831 _cleanup_strv_free_ char **states = NULL;
1832 _cleanup_strv_free_ char **patterns = NULL;
1833 int r;
1834
1835 r = sd_bus_message_read_strv(message, &states);
1836 if (r < 0)
1837 return r;
1838
1839 r = sd_bus_message_read_strv(message, &patterns);
1840 if (r < 0)
1841 return r;
1842
1843 return list_unit_files_by_patterns(message, userdata, error, states, patterns);
1844 }
1845
1846 static int method_get_unit_file_state(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1847 Manager *m = userdata;
1848 const char *name;
1849 UnitFileState state;
1850 int r;
1851
1852 assert(message);
1853 assert(m);
1854
1855 /* Anyone can call this method */
1856
1857 r = mac_selinux_access_check(message, "status", error);
1858 if (r < 0)
1859 return r;
1860
1861 r = sd_bus_message_read(message, "s", &name);
1862 if (r < 0)
1863 return r;
1864
1865 r = unit_file_get_state(m->unit_file_scope, NULL, name, &state);
1866 if (r < 0)
1867 return r;
1868
1869 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
1870 }
1871
1872 static int method_get_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
1873 _cleanup_free_ char *default_target = NULL;
1874 Manager *m = userdata;
1875 int r;
1876
1877 assert(message);
1878 assert(m);
1879
1880 /* Anyone can call this method */
1881
1882 r = mac_selinux_access_check(message, "status", error);
1883 if (r < 0)
1884 return r;
1885
1886 r = unit_file_get_default(m->unit_file_scope, NULL, &default_target);
1887 if (r < 0)
1888 return r;
1889
1890 return sd_bus_reply_method_return(message, "s", default_target);
1891 }
1892
1893 static int send_unit_files_changed(sd_bus *bus, void *userdata) {
1894 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
1895 int r;
1896
1897 assert(bus);
1898
1899 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1900 if (r < 0)
1901 return r;
1902
1903 return sd_bus_send(bus, message, NULL);
1904 }
1905
1906 /* Create an error reply, using the error information from changes[]
1907 * if possible, and fall back to generating an error from error code c.
1908 * The error message only describes the first error.
1909 *
1910 * Coordinate with unit_file_dump_changes() in install.c.
1911 */
1912 static int install_error(
1913 sd_bus_error *error,
1914 int c,
1915 UnitFileChange *changes,
1916 size_t n_changes) {
1917
1918 size_t i;
1919 int r;
1920
1921 for (i = 0; i < n_changes; i++)
1922
1923 switch(changes[i].type) {
1924
1925 case 0 ... INT_MAX:
1926 continue;
1927
1928 case -EEXIST:
1929 if (changes[i].source)
1930 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
1931 "File %s already exists and is a symlink to %s.",
1932 changes[i].path, changes[i].source);
1933 else
1934 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS,
1935 "File %s already exists.",
1936 changes[i].path);
1937 goto found;
1938
1939 case -ERFKILL:
1940 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_MASKED,
1941 "Unit file %s is masked.", changes[i].path);
1942 goto found;
1943
1944 case -EADDRNOTAVAIL:
1945 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_GENERATED,
1946 "Unit %s is transient or generated.", changes[i].path);
1947 goto found;
1948
1949 case -ELOOP:
1950 r = sd_bus_error_setf(error, BUS_ERROR_UNIT_LINKED,
1951 "Refusing to operate on linked unit file %s", changes[i].path);
1952 goto found;
1953
1954 case -ENOENT:
1955 r = sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit file %s does not exist.", changes[i].path);
1956 goto found;
1957
1958 default:
1959 r = sd_bus_error_set_errnof(error, changes[i].type, "File %s: %m", changes[i].path);
1960 goto found;
1961 }
1962
1963 r = c < 0 ? c : -EINVAL;
1964
1965 found:
1966 unit_file_changes_free(changes, n_changes);
1967 return r;
1968 }
1969
1970 static int reply_unit_file_changes_and_free(
1971 Manager *m,
1972 sd_bus_message *message,
1973 int carries_install_info,
1974 UnitFileChange *changes,
1975 size_t n_changes,
1976 sd_bus_error *error) {
1977
1978 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1979 bool bad = false, good = false;
1980 size_t i;
1981 int r;
1982
1983 if (unit_file_changes_have_modification(changes, n_changes)) {
1984 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
1985 if (r < 0)
1986 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
1987 }
1988
1989 r = sd_bus_message_new_method_return(message, &reply);
1990 if (r < 0)
1991 goto fail;
1992
1993 if (carries_install_info >= 0) {
1994 r = sd_bus_message_append(reply, "b", carries_install_info);
1995 if (r < 0)
1996 goto fail;
1997 }
1998
1999 r = sd_bus_message_open_container(reply, 'a', "(sss)");
2000 if (r < 0)
2001 goto fail;
2002
2003 for (i = 0; i < n_changes; i++) {
2004
2005 if (changes[i].type < 0) {
2006 bad = true;
2007 continue;
2008 }
2009
2010 r = sd_bus_message_append(
2011 reply, "(sss)",
2012 unit_file_change_type_to_string(changes[i].type),
2013 changes[i].path,
2014 changes[i].source);
2015 if (r < 0)
2016 goto fail;
2017
2018 good = true;
2019 }
2020
2021 /* If there was a failed change, and no successful change, then return the first failure as proper method call
2022 * error. */
2023 if (bad && !good)
2024 return install_error(error, 0, changes, n_changes);
2025
2026 r = sd_bus_message_close_container(reply);
2027 if (r < 0)
2028 goto fail;
2029
2030 unit_file_changes_free(changes, n_changes);
2031 return sd_bus_send(NULL, reply, NULL);
2032
2033 fail:
2034 unit_file_changes_free(changes, n_changes);
2035 return r;
2036 }
2037
2038 static int method_enable_unit_files_generic(
2039 sd_bus_message *message,
2040 Manager *m,
2041 int (*call)(UnitFileScope scope, UnitFileFlags flags, const char *root_dir, char *files[], UnitFileChange **changes, size_t *n_changes),
2042 bool carries_install_info,
2043 sd_bus_error *error) {
2044
2045 _cleanup_strv_free_ char **l = NULL;
2046 UnitFileChange *changes = NULL;
2047 size_t n_changes = 0;
2048 UnitFileFlags flags;
2049 int runtime, force, r;
2050
2051 assert(message);
2052 assert(m);
2053
2054 r = sd_bus_message_read_strv(message, &l);
2055 if (r < 0)
2056 return r;
2057
2058 r = sd_bus_message_read(message, "bb", &runtime, &force);
2059 if (r < 0)
2060 return r;
2061
2062 flags = unit_file_bools_to_flags(runtime, force);
2063
2064 r = bus_verify_manage_unit_files_async(m, message, error);
2065 if (r < 0)
2066 return r;
2067 if (r == 0)
2068 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2069
2070 r = call(m->unit_file_scope, flags, NULL, l, &changes, &n_changes);
2071 if (r < 0)
2072 return install_error(error, r, changes, n_changes);
2073
2074 return reply_unit_file_changes_and_free(m, message, carries_install_info ? r : -1, changes, n_changes, error);
2075 }
2076
2077 static int method_enable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2078 return method_enable_unit_files_generic(message, userdata, unit_file_enable, true, error);
2079 }
2080
2081 static int method_reenable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2082 return method_enable_unit_files_generic(message, userdata, unit_file_reenable, true, error);
2083 }
2084
2085 static int method_link_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2086 return method_enable_unit_files_generic(message, userdata, unit_file_link, false, error);
2087 }
2088
2089 static int unit_file_preset_without_mode(UnitFileScope scope, UnitFileFlags flags, const char *root_dir, char **files, UnitFileChange **changes, size_t *n_changes) {
2090 return unit_file_preset(scope, flags, root_dir, files, UNIT_FILE_PRESET_FULL, changes, n_changes);
2091 }
2092
2093 static int method_preset_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2094 return method_enable_unit_files_generic(message, userdata, unit_file_preset_without_mode, true, error);
2095 }
2096
2097 static int method_mask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2098 return method_enable_unit_files_generic(message, userdata, unit_file_mask, false, error);
2099 }
2100
2101 static int method_preset_unit_files_with_mode(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2102
2103 _cleanup_strv_free_ char **l = NULL;
2104 UnitFileChange *changes = NULL;
2105 size_t n_changes = 0;
2106 Manager *m = userdata;
2107 UnitFilePresetMode mm;
2108 int runtime, force, r;
2109 UnitFileFlags flags;
2110 const char *mode;
2111
2112 assert(message);
2113 assert(m);
2114
2115 r = sd_bus_message_read_strv(message, &l);
2116 if (r < 0)
2117 return r;
2118
2119 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2120 if (r < 0)
2121 return r;
2122
2123 flags = unit_file_bools_to_flags(runtime, force);
2124
2125 if (isempty(mode))
2126 mm = UNIT_FILE_PRESET_FULL;
2127 else {
2128 mm = unit_file_preset_mode_from_string(mode);
2129 if (mm < 0)
2130 return -EINVAL;
2131 }
2132
2133 r = bus_verify_manage_unit_files_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
2139 r = unit_file_preset(m->unit_file_scope, flags, NULL, l, mm, &changes, &n_changes);
2140 if (r < 0)
2141 return install_error(error, r, changes, n_changes);
2142
2143 return reply_unit_file_changes_and_free(m, message, r, changes, n_changes, error);
2144 }
2145
2146 static int method_disable_unit_files_generic(
2147 sd_bus_message *message,
2148 Manager *m,
2149 int (*call)(UnitFileScope scope, UnitFileFlags flags, const char *root_dir, char *files[], UnitFileChange **changes, size_t *n_changes),
2150 sd_bus_error *error) {
2151
2152 _cleanup_strv_free_ char **l = NULL;
2153 UnitFileChange *changes = NULL;
2154 size_t n_changes = 0;
2155 int r, runtime;
2156
2157 assert(message);
2158 assert(m);
2159
2160 r = sd_bus_message_read_strv(message, &l);
2161 if (r < 0)
2162 return r;
2163
2164 r = sd_bus_message_read(message, "b", &runtime);
2165 if (r < 0)
2166 return r;
2167
2168 r = bus_verify_manage_unit_files_async(m, message, error);
2169 if (r < 0)
2170 return r;
2171 if (r == 0)
2172 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2173
2174 r = call(m->unit_file_scope, runtime ? UNIT_FILE_RUNTIME : 0, NULL, l, &changes, &n_changes);
2175 if (r < 0)
2176 return install_error(error, r, changes, n_changes);
2177
2178 return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes, error);
2179 }
2180
2181 static int method_disable_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2182 return method_disable_unit_files_generic(message, userdata, unit_file_disable, error);
2183 }
2184
2185 static int method_unmask_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2186 return method_disable_unit_files_generic(message, userdata, unit_file_unmask, error);
2187 }
2188
2189 static int method_revert_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2190 _cleanup_strv_free_ char **l = NULL;
2191 UnitFileChange *changes = NULL;
2192 size_t n_changes = 0;
2193 Manager *m = userdata;
2194 int r;
2195
2196 assert(message);
2197 assert(m);
2198
2199 r = sd_bus_message_read_strv(message, &l);
2200 if (r < 0)
2201 return r;
2202
2203 r = bus_verify_manage_unit_files_async(m, message, error);
2204 if (r < 0)
2205 return r;
2206 if (r == 0)
2207 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2208
2209 r = unit_file_revert(m->unit_file_scope, NULL, l, &changes, &n_changes);
2210 if (r < 0)
2211 return install_error(error, r, changes, n_changes);
2212
2213 return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes, error);
2214 }
2215
2216 static int method_set_default_target(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2217 UnitFileChange *changes = NULL;
2218 size_t n_changes = 0;
2219 Manager *m = userdata;
2220 const char *name;
2221 int force, r;
2222
2223 assert(message);
2224 assert(m);
2225
2226 r = mac_selinux_access_check(message, "enable", error);
2227 if (r < 0)
2228 return r;
2229
2230 r = sd_bus_message_read(message, "sb", &name, &force);
2231 if (r < 0)
2232 return r;
2233
2234 r = bus_verify_manage_unit_files_async(m, message, error);
2235 if (r < 0)
2236 return r;
2237 if (r == 0)
2238 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2239
2240 r = unit_file_set_default(m->unit_file_scope, force ? UNIT_FILE_FORCE : 0, NULL, name, &changes, &n_changes);
2241 if (r < 0)
2242 return install_error(error, r, changes, n_changes);
2243
2244 return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes, error);
2245 }
2246
2247 static int method_preset_all_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2248 UnitFileChange *changes = NULL;
2249 size_t n_changes = 0;
2250 Manager *m = userdata;
2251 UnitFilePresetMode mm;
2252 const char *mode;
2253 UnitFileFlags flags;
2254 int force, runtime, r;
2255
2256 assert(message);
2257 assert(m);
2258
2259 r = mac_selinux_access_check(message, "enable", error);
2260 if (r < 0)
2261 return r;
2262
2263 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
2264 if (r < 0)
2265 return r;
2266
2267 flags = unit_file_bools_to_flags(runtime, force);
2268
2269 if (isempty(mode))
2270 mm = UNIT_FILE_PRESET_FULL;
2271 else {
2272 mm = unit_file_preset_mode_from_string(mode);
2273 if (mm < 0)
2274 return -EINVAL;
2275 }
2276
2277 r = bus_verify_manage_unit_files_async(m, message, error);
2278 if (r < 0)
2279 return r;
2280 if (r == 0)
2281 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2282
2283 r = unit_file_preset_all(m->unit_file_scope, flags, NULL, mm, &changes, &n_changes);
2284 if (r < 0)
2285 return install_error(error, r, changes, n_changes);
2286
2287 return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes, error);
2288 }
2289
2290 static int method_add_dependency_unit_files(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2291 _cleanup_strv_free_ char **l = NULL;
2292 Manager *m = userdata;
2293 UnitFileChange *changes = NULL;
2294 size_t n_changes = 0;
2295 int runtime, force, r;
2296 char *target, *type;
2297 UnitDependency dep;
2298 UnitFileFlags flags;
2299
2300 assert(message);
2301 assert(m);
2302
2303 r = bus_verify_manage_unit_files_async(m, message, error);
2304 if (r < 0)
2305 return r;
2306 if (r == 0)
2307 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
2308
2309 r = sd_bus_message_read_strv(message, &l);
2310 if (r < 0)
2311 return r;
2312
2313 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
2314 if (r < 0)
2315 return r;
2316
2317 flags = unit_file_bools_to_flags(runtime, force);
2318
2319 dep = unit_dependency_from_string(type);
2320 if (dep < 0)
2321 return -EINVAL;
2322
2323 r = unit_file_add_dependency(m->unit_file_scope, flags, NULL, l, target, dep, &changes, &n_changes);
2324 if (r < 0)
2325 return install_error(error, r, changes, n_changes);
2326
2327 return reply_unit_file_changes_and_free(m, message, -1, changes, n_changes, error);
2328 }
2329
2330 static int method_get_unit_file_links(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2331 _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
2332 UnitFileChange *changes = NULL;
2333 size_t n_changes = 0, i;
2334 UnitFileFlags flags;
2335 const char *name;
2336 char **p;
2337 int runtime, r;
2338
2339 r = sd_bus_message_read(message, "sb", &name, &runtime);
2340 if (r < 0)
2341 return r;
2342
2343 r = sd_bus_message_new_method_return(message, &reply);
2344 if (r < 0)
2345 return r;
2346
2347 r = sd_bus_message_open_container(reply, SD_BUS_TYPE_ARRAY, "s");
2348 if (r < 0)
2349 return r;
2350
2351 p = STRV_MAKE(name);
2352 flags = UNIT_FILE_DRY_RUN |
2353 (runtime ? UNIT_FILE_RUNTIME : 0);
2354
2355 r = unit_file_disable(UNIT_FILE_SYSTEM, flags, NULL, p, &changes, &n_changes);
2356 if (r < 0)
2357 return log_error_errno(r, "Failed to get file links for %s: %m", name);
2358
2359 for (i = 0; i < n_changes; i++)
2360 if (changes[i].type == UNIT_FILE_UNLINK) {
2361 r = sd_bus_message_append(reply, "s", changes[i].path);
2362 if (r < 0)
2363 return r;
2364 }
2365
2366 r = sd_bus_message_close_container(reply);
2367 if (r < 0)
2368 return r;
2369
2370 return sd_bus_send(NULL, reply, NULL);
2371 }
2372
2373 static int method_get_job_waiting(sd_bus_message *message, void *userdata, sd_bus_error *error) {
2374 Manager *m = userdata;
2375 uint32_t id;
2376 Job *j;
2377 int r;
2378
2379 assert(message);
2380 assert(m);
2381
2382 r = sd_bus_message_read(message, "u", &id);
2383 if (r < 0)
2384 return r;
2385
2386 j = manager_get_job(m, id);
2387 if (!j)
2388 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
2389
2390 return bus_job_method_get_waiting_jobs(message, j, error);
2391 }
2392
2393 const sd_bus_vtable bus_manager_vtable[] = {
2394 SD_BUS_VTABLE_START(0),
2395
2396 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2397 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2398 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2399 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2400 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2401 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FIRMWARE]), SD_BUS_VTABLE_PROPERTY_CONST),
2402 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_LOADER]), SD_BUS_VTABLE_PROPERTY_CONST),
2403 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_KERNEL]), SD_BUS_VTABLE_PROPERTY_CONST),
2404 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_INITRD]), SD_BUS_VTABLE_PROPERTY_CONST),
2405 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_USERSPACE]), SD_BUS_VTABLE_PROPERTY_CONST),
2406 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2407 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2408 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_SECURITY_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2409 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2410 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_GENERATORS_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2411 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_START]), SD_BUS_VTABLE_PROPERTY_CONST),
2412 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, timestamps[MANAGER_TIMESTAMP_UNITS_LOAD_FINISH]), SD_BUS_VTABLE_PROPERTY_CONST),
2413 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level, property_set_log_level, 0, 0),
2414 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target, property_set_log_target, 0, 0),
2415 SD_BUS_PROPERTY("NNames", "u", property_get_hashmap_size, offsetof(Manager, units), 0),
2416 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_set_size, offsetof(Manager, failed_units), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
2417 SD_BUS_PROPERTY("NJobs", "u", property_get_hashmap_size, offsetof(Manager, jobs), 0),
2418 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
2419 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
2420 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
2421 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(Manager, environment), 0),
2422 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
2423 SD_BUS_PROPERTY("ShowStatus", "b", property_get_show_status, 0, 0),
2424 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.search_path), SD_BUS_VTABLE_PROPERTY_CONST),
2425 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
2426 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
2427 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec, property_set_runtime_watchdog, offsetof(Manager, runtime_watchdog), 0),
2428 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec, bus_property_set_usec, offsetof(Manager, shutdown_watchdog), 0),
2429 SD_BUS_WRITABLE_PROPERTY("ServiceWatchdogs", "b", bus_property_get_bool, bus_property_set_bool, offsetof(Manager, service_watchdogs), 0),
2430 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
2431 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
2432 SD_BUS_PROPERTY("ExitCode", "y", bus_property_get_unsigned, offsetof(Manager, return_value), 0),
2433 SD_BUS_PROPERTY("DefaultTimerAccuracyUSec", "t", bus_property_get_usec, offsetof(Manager, default_timer_accuracy_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2434 SD_BUS_PROPERTY("DefaultTimeoutStartUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_start_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2435 SD_BUS_PROPERTY("DefaultTimeoutStopUSec", "t", bus_property_get_usec, offsetof(Manager, default_timeout_stop_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2436 SD_BUS_PROPERTY("DefaultRestartUSec", "t", bus_property_get_usec, offsetof(Manager, default_restart_usec), SD_BUS_VTABLE_PROPERTY_CONST),
2437 SD_BUS_PROPERTY("DefaultStartLimitIntervalUSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST),
2438 /* The following two items are obsolete alias */
2439 SD_BUS_PROPERTY("DefaultStartLimitIntervalSec", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
2440 SD_BUS_PROPERTY("DefaultStartLimitInterval", "t", bus_property_get_usec, offsetof(Manager, default_start_limit_interval), SD_BUS_VTABLE_PROPERTY_CONST|SD_BUS_VTABLE_HIDDEN),
2441 SD_BUS_PROPERTY("DefaultStartLimitBurst", "u", bus_property_get_unsigned, offsetof(Manager, default_start_limit_burst), SD_BUS_VTABLE_PROPERTY_CONST),
2442 SD_BUS_PROPERTY("DefaultCPUAccounting", "b", bus_property_get_bool, offsetof(Manager, default_cpu_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2443 SD_BUS_PROPERTY("DefaultBlockIOAccounting", "b", bus_property_get_bool, offsetof(Manager, default_blockio_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2444 SD_BUS_PROPERTY("DefaultMemoryAccounting", "b", bus_property_get_bool, offsetof(Manager, default_memory_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2445 SD_BUS_PROPERTY("DefaultTasksAccounting", "b", bus_property_get_bool, offsetof(Manager, default_tasks_accounting), SD_BUS_VTABLE_PROPERTY_CONST),
2446 SD_BUS_PROPERTY("DefaultLimitCPU", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
2447 SD_BUS_PROPERTY("DefaultLimitCPUSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CPU]), SD_BUS_VTABLE_PROPERTY_CONST),
2448 SD_BUS_PROPERTY("DefaultLimitFSIZE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
2449 SD_BUS_PROPERTY("DefaultLimitFSIZESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_FSIZE]), SD_BUS_VTABLE_PROPERTY_CONST),
2450 SD_BUS_PROPERTY("DefaultLimitDATA", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
2451 SD_BUS_PROPERTY("DefaultLimitDATASoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_DATA]), SD_BUS_VTABLE_PROPERTY_CONST),
2452 SD_BUS_PROPERTY("DefaultLimitSTACK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
2453 SD_BUS_PROPERTY("DefaultLimitSTACKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_STACK]), SD_BUS_VTABLE_PROPERTY_CONST),
2454 SD_BUS_PROPERTY("DefaultLimitCORE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
2455 SD_BUS_PROPERTY("DefaultLimitCORESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_CORE]), SD_BUS_VTABLE_PROPERTY_CONST),
2456 SD_BUS_PROPERTY("DefaultLimitRSS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
2457 SD_BUS_PROPERTY("DefaultLimitRSSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RSS]), SD_BUS_VTABLE_PROPERTY_CONST),
2458 SD_BUS_PROPERTY("DefaultLimitNOFILE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
2459 SD_BUS_PROPERTY("DefaultLimitNOFILESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NOFILE]), SD_BUS_VTABLE_PROPERTY_CONST),
2460 SD_BUS_PROPERTY("DefaultLimitAS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
2461 SD_BUS_PROPERTY("DefaultLimitASSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_AS]), SD_BUS_VTABLE_PROPERTY_CONST),
2462 SD_BUS_PROPERTY("DefaultLimitNPROC", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
2463 SD_BUS_PROPERTY("DefaultLimitNPROCSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NPROC]), SD_BUS_VTABLE_PROPERTY_CONST),
2464 SD_BUS_PROPERTY("DefaultLimitMEMLOCK", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
2465 SD_BUS_PROPERTY("DefaultLimitMEMLOCKSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MEMLOCK]), SD_BUS_VTABLE_PROPERTY_CONST),
2466 SD_BUS_PROPERTY("DefaultLimitLOCKS", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
2467 SD_BUS_PROPERTY("DefaultLimitLOCKSSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_LOCKS]), SD_BUS_VTABLE_PROPERTY_CONST),
2468 SD_BUS_PROPERTY("DefaultLimitSIGPENDING", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
2469 SD_BUS_PROPERTY("DefaultLimitSIGPENDINGSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_SIGPENDING]), SD_BUS_VTABLE_PROPERTY_CONST),
2470 SD_BUS_PROPERTY("DefaultLimitMSGQUEUE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
2471 SD_BUS_PROPERTY("DefaultLimitMSGQUEUESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_MSGQUEUE]), SD_BUS_VTABLE_PROPERTY_CONST),
2472 SD_BUS_PROPERTY("DefaultLimitNICE", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
2473 SD_BUS_PROPERTY("DefaultLimitNICESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_NICE]), SD_BUS_VTABLE_PROPERTY_CONST),
2474 SD_BUS_PROPERTY("DefaultLimitRTPRIO", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
2475 SD_BUS_PROPERTY("DefaultLimitRTPRIOSoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTPRIO]), SD_BUS_VTABLE_PROPERTY_CONST),
2476 SD_BUS_PROPERTY("DefaultLimitRTTIME", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
2477 SD_BUS_PROPERTY("DefaultLimitRTTIMESoft", "t", bus_property_get_rlimit, offsetof(Manager, rlimit[RLIMIT_RTTIME]), SD_BUS_VTABLE_PROPERTY_CONST),
2478 SD_BUS_PROPERTY("DefaultTasksMax", "t", NULL, offsetof(Manager, default_tasks_max), SD_BUS_VTABLE_PROPERTY_CONST),
2479 SD_BUS_PROPERTY("TimerSlackNSec", "t", property_get_timer_slack_nsec, 0, SD_BUS_VTABLE_PROPERTY_CONST),
2480
2481 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2482 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
2483 SD_BUS_METHOD("GetUnitByInvocationID", "ay", "o", method_get_unit_by_invocation_id, SD_BUS_VTABLE_UNPRIVILEGED),
2484 SD_BUS_METHOD("GetUnitByControlGroup", "s", "o", method_get_unit_by_control_group, SD_BUS_VTABLE_UNPRIVILEGED),
2485 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2486 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2487 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace, SD_BUS_VTABLE_UNPRIVILEGED),
2488 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2489 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2490 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2491 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2492 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2493 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2494 SD_BUS_METHOD("KillUnit", "ssi", NULL, method_kill_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2495 SD_BUS_METHOD("ResetFailedUnit", "s", NULL, method_reset_failed_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2496 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL, method_set_unit_properties, SD_BUS_VTABLE_UNPRIVILEGED),
2497 SD_BUS_METHOD("RefUnit", "s", NULL, method_ref_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2498 SD_BUS_METHOD("UnrefUnit", "s", NULL, method_unref_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2499 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2500 SD_BUS_METHOD("GetUnitProcesses", "s", "a(sus)", method_get_unit_processes, SD_BUS_VTABLE_UNPRIVILEGED),
2501 SD_BUS_METHOD("AttachProcessesToUnit", "ssau", NULL, method_attach_processes_to_unit, SD_BUS_VTABLE_UNPRIVILEGED),
2502 SD_BUS_METHOD("GetJob", "u", "o", method_get_job, SD_BUS_VTABLE_UNPRIVILEGED),
2503 SD_BUS_METHOD("GetJobAfter", "u", "a(usssoo)", method_get_job_waiting, SD_BUS_VTABLE_UNPRIVILEGED),
2504 SD_BUS_METHOD("GetJobBefore", "u", "a(usssoo)", method_get_job_waiting, SD_BUS_VTABLE_UNPRIVILEGED),
2505 SD_BUS_METHOD("CancelJob", "u", NULL, method_cancel_job, SD_BUS_VTABLE_UNPRIVILEGED),
2506 SD_BUS_METHOD("ClearJobs", NULL, NULL, method_clear_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
2507 SD_BUS_METHOD("ResetFailed", NULL, NULL, method_reset_failed, SD_BUS_VTABLE_UNPRIVILEGED),
2508 SD_BUS_METHOD("ListUnits", NULL, "a(ssssssouso)", method_list_units, SD_BUS_VTABLE_UNPRIVILEGED),
2509 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered, SD_BUS_VTABLE_UNPRIVILEGED),
2510 SD_BUS_METHOD("ListUnitsByPatterns", "asas", "a(ssssssouso)", method_list_units_by_patterns, SD_BUS_VTABLE_UNPRIVILEGED),
2511 SD_BUS_METHOD("ListUnitsByNames", "as", "a(ssssssouso)", method_list_units_by_names, SD_BUS_VTABLE_UNPRIVILEGED),
2512 SD_BUS_METHOD("ListJobs", NULL, "a(usssoo)", method_list_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
2513 SD_BUS_METHOD("Subscribe", NULL, NULL, method_subscribe, SD_BUS_VTABLE_UNPRIVILEGED),
2514 SD_BUS_METHOD("Unsubscribe", NULL, NULL, method_unsubscribe, SD_BUS_VTABLE_UNPRIVILEGED),
2515 SD_BUS_METHOD("Dump", NULL, "s", method_dump, SD_BUS_VTABLE_UNPRIVILEGED),
2516 SD_BUS_METHOD("DumpByFileDescriptor", NULL, "h", method_dump_by_fd, SD_BUS_VTABLE_UNPRIVILEGED),
2517 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_refuse_snapshot, SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
2518 SD_BUS_METHOD("RemoveSnapshot", "s", NULL, method_refuse_snapshot, SD_BUS_VTABLE_UNPRIVILEGED|SD_BUS_VTABLE_HIDDEN),
2519 SD_BUS_METHOD("Reload", NULL, NULL, method_reload, SD_BUS_VTABLE_UNPRIVILEGED),
2520 SD_BUS_METHOD("Reexecute", NULL, NULL, method_reexecute, SD_BUS_VTABLE_UNPRIVILEGED),
2521 SD_BUS_METHOD("Exit", NULL, NULL, method_exit, 0),
2522 SD_BUS_METHOD("Reboot", NULL, NULL, method_reboot, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2523 SD_BUS_METHOD("PowerOff", NULL, NULL, method_poweroff, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2524 SD_BUS_METHOD("Halt", NULL, NULL, method_halt, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2525 SD_BUS_METHOD("KExec", NULL, NULL, method_kexec, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2526 SD_BUS_METHOD("SwitchRoot", "ss", NULL, method_switch_root, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2527 SD_BUS_METHOD("SetEnvironment", "as", NULL, method_set_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2528 SD_BUS_METHOD("UnsetEnvironment", "as", NULL, method_unset_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2529 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL, method_unset_and_set_environment, SD_BUS_VTABLE_UNPRIVILEGED),
2530 SD_BUS_METHOD("ListUnitFiles", NULL, "a(ss)", method_list_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2531 SD_BUS_METHOD("ListUnitFilesByPatterns", "asas", "a(ss)", method_list_unit_files_by_patterns, SD_BUS_VTABLE_UNPRIVILEGED),
2532 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state, SD_BUS_VTABLE_UNPRIVILEGED),
2533 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2534 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2535 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2536 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2537 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2538 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode, SD_BUS_VTABLE_UNPRIVILEGED),
2539 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2540 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2541 SD_BUS_METHOD("RevertUnitFiles", "as", "a(sss)", method_revert_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2542 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2543 SD_BUS_METHOD("GetDefaultTarget", NULL, "s", method_get_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2544 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2545 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2546 SD_BUS_METHOD("GetUnitFileLinks", "sb", "as", method_get_unit_file_links, SD_BUS_VTABLE_UNPRIVILEGED),
2547 SD_BUS_METHOD("SetExitCode", "y", NULL, method_set_exit_code, SD_BUS_VTABLE_UNPRIVILEGED),
2548 SD_BUS_METHOD("LookupDynamicUserByName", "s", "u", method_lookup_dynamic_user_by_name, SD_BUS_VTABLE_UNPRIVILEGED),
2549 SD_BUS_METHOD("LookupDynamicUserByUID", "u", "s", method_lookup_dynamic_user_by_uid, SD_BUS_VTABLE_UNPRIVILEGED),
2550 SD_BUS_METHOD("GetDynamicUsers", NULL, "a(us)", method_get_dynamic_users, SD_BUS_VTABLE_UNPRIVILEGED),
2551
2552 SD_BUS_SIGNAL("UnitNew", "so", 0),
2553 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2554 SD_BUS_SIGNAL("JobNew", "uos", 0),
2555 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2556 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2557 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
2558 SD_BUS_SIGNAL("Reloading", "b", 0),
2559
2560 SD_BUS_VTABLE_END
2561 };
2562
2563 static int send_finished(sd_bus *bus, void *userdata) {
2564 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
2565 usec_t *times = userdata;
2566 int r;
2567
2568 assert(bus);
2569 assert(times);
2570
2571 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2572 if (r < 0)
2573 return r;
2574
2575 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
2576 if (r < 0)
2577 return r;
2578
2579 return sd_bus_send(bus, message, NULL);
2580 }
2581
2582 void bus_manager_send_finished(
2583 Manager *m,
2584 usec_t firmware_usec,
2585 usec_t loader_usec,
2586 usec_t kernel_usec,
2587 usec_t initrd_usec,
2588 usec_t userspace_usec,
2589 usec_t total_usec) {
2590
2591 int r;
2592
2593 assert(m);
2594
2595 r = bus_foreach_bus(
2596 m,
2597 NULL,
2598 send_finished,
2599 (usec_t[6]) {
2600 firmware_usec,
2601 loader_usec,
2602 kernel_usec,
2603 initrd_usec,
2604 userspace_usec,
2605 total_usec
2606 });
2607 if (r < 0)
2608 log_debug_errno(r, "Failed to send finished signal: %m");
2609 }
2610
2611 static int send_reloading(sd_bus *bus, void *userdata) {
2612 _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
2613 int r;
2614
2615 assert(bus);
2616
2617 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2618 if (r < 0)
2619 return r;
2620
2621 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
2622 if (r < 0)
2623 return r;
2624
2625 return sd_bus_send(bus, message, NULL);
2626 }
2627
2628 void bus_manager_send_reloading(Manager *m, bool active) {
2629 int r;
2630
2631 assert(m);
2632
2633 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
2634 if (r < 0)
2635 log_debug_errno(r, "Failed to send reloading signal: %m");
2636 }
2637
2638 static int send_changed_signal(sd_bus *bus, void *userdata) {
2639 assert(bus);
2640
2641 return sd_bus_emit_properties_changed_strv(bus,
2642 "/org/freedesktop/systemd1",
2643 "org.freedesktop.systemd1.Manager",
2644 NULL);
2645 }
2646
2647 void bus_manager_send_change_signal(Manager *m) {
2648 int r;
2649
2650 assert(m);
2651
2652 r = bus_foreach_bus(m, NULL, send_changed_signal, NULL);
2653 if (r < 0)
2654 log_debug_errno(r, "Failed to send manager change signal: %m");
2655 }