1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2010 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include "selinux-access.h"
31 #include "clock-util.h"
32 #include "path-util.h"
34 #include "architecture.h"
38 #include "dbus-manager.h"
39 #include "dbus-unit.h"
40 #include "dbus-snapshot.h"
41 #include "dbus-execute.h"
42 #include "bus-errors.h"
44 static int property_get_version(
47 const char *interface,
49 sd_bus_message *reply,
51 sd_bus_error *error) {
56 return sd_bus_message_append(reply, "s", PACKAGE_VERSION);
59 static int property_get_features(
62 const char *interface,
64 sd_bus_message *reply,
66 sd_bus_error *error) {
71 return sd_bus_message_append(reply, "s", SYSTEMD_FEATURES);
74 static int property_get_virtualization(
77 const char *interface,
79 sd_bus_message *reply,
81 sd_bus_error *error) {
83 const char *id = NULL;
88 detect_virtualization(&id);
90 return sd_bus_message_append(reply, "s", id);
93 static int property_get_architecture(
96 const char *interface,
98 sd_bus_message *reply,
100 sd_bus_error *error) {
105 return sd_bus_message_append(reply, "s", architecture_to_string(uname_architecture()));
108 static int property_get_tainted(
111 const char *interface,
112 const char *property,
113 sd_bus_message *reply,
115 sd_bus_error *error) {
117 char buf[sizeof("split-usr:mtab-not-symlink:cgroups-missing:local-hwclock:")] = "", *e = buf;
118 _cleanup_free_ char *p = NULL;
119 Manager *m = userdata;
126 e = stpcpy(e, "split-usr:");
128 if (readlink_malloc("/etc/mtab", &p) < 0)
129 e = stpcpy(e, "mtab-not-symlink:");
131 if (access("/proc/cgroups", F_OK) < 0)
132 e = stpcpy(e, "cgroups-missing:");
134 if (clock_is_localtime() > 0)
135 e = stpcpy(e, "local-hwclock:");
137 /* remove the last ':' */
141 return sd_bus_message_append(reply, "s", buf);
144 static int property_get_log_target(
147 const char *interface,
148 const char *property,
149 sd_bus_message *reply,
151 sd_bus_error *error) {
156 return sd_bus_message_append(reply, "s", log_target_to_string(log_get_target()));
159 static int property_set_log_target(
162 const char *interface,
163 const char *property,
164 sd_bus_message *value,
166 sd_bus_error *error) {
174 r = sd_bus_message_read(value, "s", &t);
178 return log_set_target_from_string(t);
181 static int property_get_log_level(
184 const char *interface,
185 const char *property,
186 sd_bus_message *reply,
188 sd_bus_error *error) {
190 _cleanup_free_ char *t = NULL;
196 r = log_level_to_string_alloc(log_get_max_level(), &t);
200 return sd_bus_message_append(reply, "s", t);
203 static int property_set_log_level(
206 const char *interface,
207 const char *property,
208 sd_bus_message *value,
210 sd_bus_error *error) {
218 r = sd_bus_message_read(value, "s", &t);
222 return log_set_max_level_from_string(t);
225 static int property_get_n_names(
228 const char *interface,
229 const char *property,
230 sd_bus_message *reply,
232 sd_bus_error *error) {
234 Manager *m = userdata;
240 return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->units));
243 static int property_get_n_failed_units(
246 const char *interface,
247 const char *property,
248 sd_bus_message *reply,
250 sd_bus_error *error) {
252 Manager *m = userdata;
258 return sd_bus_message_append(reply, "u", (uint32_t) set_size(m->failed_units));
261 static int property_get_n_jobs(
264 const char *interface,
265 const char *property,
266 sd_bus_message *reply,
268 sd_bus_error *error) {
270 Manager *m = userdata;
276 return sd_bus_message_append(reply, "u", (uint32_t) hashmap_size(m->jobs));
279 static int property_get_progress(
282 const char *interface,
283 const char *property,
284 sd_bus_message *reply,
286 sd_bus_error *error) {
288 Manager *m = userdata;
295 if (dual_timestamp_is_set(&m->finish_timestamp))
298 d = 1.0 - ((double) hashmap_size(m->jobs) / (double) m->n_installed_jobs);
300 return sd_bus_message_append(reply, "d", d);
303 static int property_get_system_state(
306 const char *interface,
307 const char *property,
308 sd_bus_message *reply,
310 sd_bus_error *error) {
312 Manager *m = userdata;
318 return sd_bus_message_append(reply, "s", manager_state_to_string(manager_state(m)));
321 static int property_set_runtime_watchdog(
324 const char *interface,
325 const char *property,
326 sd_bus_message *value,
328 sd_bus_error *error) {
330 usec_t *t = userdata;
336 assert_cc(sizeof(usec_t) == sizeof(uint64_t));
338 r = sd_bus_message_read(value, "t", t);
342 return watchdog_set_timeout(t);
345 static int method_get_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
346 _cleanup_free_ char *path = NULL;
347 Manager *m = userdata;
356 /* Anyone can call this method */
358 r = sd_bus_message_read(message, "s", &name);
362 u = manager_get_unit(m, name);
364 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s not loaded.", name);
366 r = mac_selinux_unit_access_check(u, message, "status", error);
370 path = unit_dbus_path(u);
374 return sd_bus_reply_method_return(message, "o", path);
377 static int method_get_unit_by_pid(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
378 _cleanup_free_ char *path = NULL;
379 Manager *m = userdata;
388 assert_cc(sizeof(pid_t) == sizeof(uint32_t));
390 /* Anyone can call this method */
392 r = sd_bus_message_read(message, "u", &pid);
397 _cleanup_bus_creds_unref_ sd_bus_creds *creds = NULL;
399 r = sd_bus_query_sender_creds(message, SD_BUS_CREDS_PID, &creds);
403 r = sd_bus_creds_get_pid(creds, &pid);
408 u = manager_get_unit_by_pid(m, pid);
410 return sd_bus_error_setf(error, BUS_ERROR_NO_UNIT_FOR_PID, "PID %u does not belong to any loaded unit.", pid);
412 r = mac_selinux_unit_access_check(u, message, "status", error);
416 path = unit_dbus_path(u);
420 return sd_bus_reply_method_return(message, "o", path);
423 static int method_load_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
424 _cleanup_free_ char *path = NULL;
425 Manager *m = userdata;
434 /* Anyone can call this method */
436 r = sd_bus_message_read(message, "s", &name);
440 r = manager_load_unit(m, name, NULL, error, &u);
444 r = mac_selinux_unit_access_check(u, message, "status", error);
448 path = unit_dbus_path(u);
452 return sd_bus_reply_method_return(message, "o", path);
455 static int method_start_unit_generic(sd_bus *bus, sd_bus_message *message, Manager *m, JobType job_type, bool reload_if_possible, sd_bus_error *error) {
464 r = bus_verify_manage_unit_async(m, message, error);
468 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
470 r = sd_bus_message_read(message, "s", &name);
474 r = manager_load_unit(m, name, NULL, error, &u);
478 return bus_unit_method_start_generic(bus, message, u, job_type, reload_if_possible, error);
481 static int method_start_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
482 return method_start_unit_generic(bus, message, userdata, JOB_START, false, error);
485 static int method_stop_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
486 return method_start_unit_generic(bus, message, userdata, JOB_STOP, false, error);
489 static int method_reload_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
490 return method_start_unit_generic(bus, message, userdata, JOB_RELOAD, false, error);
493 static int method_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
494 return method_start_unit_generic(bus, message, userdata, JOB_RESTART, false, error);
497 static int method_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
498 return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, false, error);
501 static int method_reload_or_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
502 return method_start_unit_generic(bus, message, userdata, JOB_RESTART, true, error);
505 static int method_reload_or_try_restart_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
506 return method_start_unit_generic(bus, message, userdata, JOB_TRY_RESTART, true, error);
509 static int method_start_unit_replace(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
510 Manager *m = userdata;
511 const char *old_name;
519 r = bus_verify_manage_unit_async(m, message, error);
523 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
525 r = sd_bus_message_read(message, "s", &old_name);
529 u = manager_get_unit(m, old_name);
530 if (!u || !u->job || u->job->type != JOB_START)
531 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "No job queued for unit %s", old_name);
533 return method_start_unit_generic(bus, message, m, JOB_START, false, error);
536 static int method_kill_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
537 Manager *m = userdata;
546 /* Like bus_verify_manage_unit_async(), but uses CAP_SYS_KILL */
547 r = bus_verify_manage_unit_async_for_kill(m, message, error);
551 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
553 r = sd_bus_message_read(message, "s", &name);
557 u = manager_get_unit(m, name);
559 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
561 return bus_unit_method_kill(bus, message, u, error);
564 static int method_reset_failed_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
565 Manager *m = userdata;
574 r = bus_verify_manage_unit_async(m, message, error);
578 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
580 r = sd_bus_message_read(message, "s", &name);
584 u = manager_get_unit(m, name);
586 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
588 return bus_unit_method_reset_failed(bus, message, u, error);
591 static int method_set_unit_properties(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
592 Manager *m = userdata;
601 r = bus_verify_manage_unit_async(m, message, error);
605 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
607 r = sd_bus_message_read(message, "s", &name);
611 u = manager_get_unit(m, name);
613 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not loaded.", name);
615 return bus_unit_method_set_properties(bus, message, u, error);
618 static int transient_unit_from_message(
620 sd_bus_message *message,
623 sd_bus_error *error) {
632 r = manager_load_unit(m, name, NULL, error, &u);
636 if (u->load_state != UNIT_NOT_FOUND ||
637 set_size(u->dependencies[UNIT_REFERENCED_BY]) > 0)
638 return sd_bus_error_setf(error, BUS_ERROR_UNIT_EXISTS, "Unit %s already exists.", name);
640 /* OK, the unit failed to load and is unreferenced, now let's
641 * fill in the transient data instead */
642 r = unit_make_transient(u);
646 /* Set our properties */
647 r = bus_unit_set_properties(u, message, UNIT_RUNTIME, false, error);
656 static int transient_aux_units_from_message(
658 sd_bus_message *message,
659 sd_bus_error *error) {
668 r = sd_bus_message_enter_container(message, 'a', "(sa(sv))");
672 while ((r = sd_bus_message_enter_container(message, 'r', "sa(sv)")) > 0) {
676 r = sd_bus_message_read(message, "s", &name);
680 r = transient_unit_from_message(m, message, name, &u, error);
681 if (r < 0 && r != -EEXIST)
688 r = sd_bus_message_exit_container(message);
695 r = sd_bus_message_exit_container(message);
702 static int method_start_transient_unit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
703 const char *name, *smode;
704 Manager *m = userdata;
714 r = bus_verify_manage_unit_async(m, message, error);
718 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
720 r = sd_bus_message_read(message, "ss", &name, &smode);
724 t = unit_name_to_type(name);
726 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid unit type.");
728 if (!unit_vtable[t]->can_transient)
729 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Unit type %s does not support transient units.", unit_type_to_string(t));
731 mode = job_mode_from_string(smode);
733 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Job mode %s is invalid.", smode);
735 r = mac_selinux_access_check(message, "start", error);
739 r = transient_unit_from_message(m, message, name, &u, error);
743 r = transient_aux_units_from_message(m, message, error);
747 /* And load this stub fully */
752 manager_dispatch_load_queue(m);
754 /* Finally, start it */
755 return bus_unit_queue_job(bus, message, u, JOB_START, mode, false, error);
758 static int method_get_job(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
759 _cleanup_free_ char *path = NULL;
760 Manager *m = userdata;
769 /* Anyone can call this method */
771 r = sd_bus_message_read(message, "u", &id);
775 j = manager_get_job(m, id);
777 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
779 r = mac_selinux_unit_access_check(j->unit, message, "status", error);
783 path = job_dbus_path(j);
787 return sd_bus_reply_method_return(message, "o", path);
790 static int method_cancel_job(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
791 Manager *m = userdata;
800 r = sd_bus_message_read(message, "u", &id);
804 j = manager_get_job(m, id);
806 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_JOB, "Job %u does not exist.", (unsigned) id);
808 return bus_job_method_cancel(bus, message, j, error);
811 static int method_clear_jobs(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
812 Manager *m = userdata;
819 r = mac_selinux_access_check(message, "reboot", error);
823 manager_clear_jobs(m);
825 return sd_bus_reply_method_return(message, NULL);
828 static int method_reset_failed(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
829 Manager *m = userdata;
836 r = mac_selinux_access_check(message, "reload", error);
840 manager_reset_failed(m);
842 return sd_bus_reply_method_return(message, NULL);
845 static int list_units_filtered(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error, char **states) {
846 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
847 Manager *m = userdata;
857 /* Anyone can call this method */
859 r = mac_selinux_access_check(message, "status", error);
863 r = sd_bus_message_new_method_return(message, &reply);
867 r = sd_bus_message_open_container(reply, 'a', "(ssssssouso)");
871 HASHMAP_FOREACH_KEY(u, k, m->units, i) {
872 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
878 following = unit_following(u);
880 if (!strv_isempty(states) &&
881 !strv_contains(states, unit_load_state_to_string(u->load_state)) &&
882 !strv_contains(states, unit_active_state_to_string(unit_active_state(u))) &&
883 !strv_contains(states, unit_sub_state_to_string(u)))
886 unit_path = unit_dbus_path(u);
891 job_path = job_dbus_path(u->job);
896 r = sd_bus_message_append(
897 reply, "(ssssssouso)",
900 unit_load_state_to_string(u->load_state),
901 unit_active_state_to_string(unit_active_state(u)),
902 unit_sub_state_to_string(u),
903 following ? following->id : "",
905 u->job ? u->job->id : 0,
906 u->job ? job_type_to_string(u->job->type) : "",
907 job_path ? job_path : "/");
912 r = sd_bus_message_close_container(reply);
916 return sd_bus_send(bus, reply, NULL);
919 static int method_list_units(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
920 return list_units_filtered(bus, message, userdata, error, NULL);
923 static int method_list_units_filtered(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
924 _cleanup_strv_free_ char **states = NULL;
927 r = sd_bus_message_read_strv(message, &states);
931 return list_units_filtered(bus, message, userdata, error, states);
934 static int method_list_jobs(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
935 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
936 Manager *m = userdata;
945 /* Anyone can call this method */
947 r = mac_selinux_access_check(message, "status", error);
951 r = sd_bus_message_new_method_return(message, &reply);
955 r = sd_bus_message_open_container(reply, 'a', "(usssoo)");
959 HASHMAP_FOREACH(j, m->jobs, i) {
960 _cleanup_free_ char *unit_path = NULL, *job_path = NULL;
962 job_path = job_dbus_path(j);
966 unit_path = unit_dbus_path(j->unit);
970 r = sd_bus_message_append(
974 job_type_to_string(j->type),
975 job_state_to_string(j->state),
982 r = sd_bus_message_close_container(reply);
986 return sd_bus_send(bus, reply, NULL);
989 static int method_subscribe(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
990 Manager *m = userdata;
997 /* Anyone can call this method */
999 r = mac_selinux_access_check(message, "status", error);
1003 if (bus == m->api_bus) {
1005 /* Note that direct bus connection subscribe by
1006 * default, we only track peers on the API bus here */
1008 if (!m->subscribed) {
1009 r = sd_bus_track_new(bus, &m->subscribed, NULL, NULL);
1014 r = sd_bus_track_add_sender(m->subscribed, message);
1018 return sd_bus_error_setf(error, BUS_ERROR_ALREADY_SUBSCRIBED, "Client is already subscribed.");
1021 return sd_bus_reply_method_return(message, NULL);
1024 static int method_unsubscribe(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1025 Manager *m = userdata;
1032 /* Anyone can call this method */
1034 r = mac_selinux_access_check(message, "status", error);
1038 if (bus == m->api_bus) {
1039 r = sd_bus_track_remove_sender(m->subscribed, message);
1043 return sd_bus_error_setf(error, BUS_ERROR_NOT_SUBSCRIBED, "Client is not subscribed.");
1046 return sd_bus_reply_method_return(message, NULL);
1049 static int method_dump(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1050 _cleanup_free_ char *dump = NULL;
1051 _cleanup_fclose_ FILE *f = NULL;
1052 Manager *m = userdata;
1060 /* Anyone can call this method */
1062 r = mac_selinux_access_check(message, "status", error);
1066 f = open_memstream(&dump, &size);
1070 manager_dump_units(m, f, NULL);
1071 manager_dump_jobs(m, f, NULL);
1078 return sd_bus_reply_method_return(message, "s", dump);
1081 static int method_create_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1082 _cleanup_free_ char *path = NULL;
1083 Manager *m = userdata;
1093 r = mac_selinux_access_check(message, "start", error);
1097 r = sd_bus_message_read(message, "sb", &name, &cleanup);
1104 r = snapshot_create(m, name, cleanup, error, &s);
1108 path = unit_dbus_path(UNIT(s));
1112 return sd_bus_reply_method_return(message, "o", path);
1115 static int method_remove_snapshot(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1116 Manager *m = userdata;
1125 r = mac_selinux_access_check(message, "stop", error);
1129 r = sd_bus_message_read(message, "s", &name);
1133 u = manager_get_unit(m, name);
1135 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s does not exist.", name);
1137 if (u->type != UNIT_SNAPSHOT)
1138 return sd_bus_error_setf(error, BUS_ERROR_NO_SUCH_UNIT, "Unit %s is not a snapshot", name);
1140 return bus_snapshot_method_remove(bus, message, u, error);
1143 static int method_reload(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1144 Manager *m = userdata;
1151 r = bus_verify_reload_daemon_async(m, message, error);
1155 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1157 r = mac_selinux_access_check(message, "reload", error);
1161 /* Instead of sending the reply back right away, we just
1162 * remember that we need to and then send it after the reload
1163 * is finished. That way the caller knows when the reload
1166 assert(!m->queued_message);
1167 r = sd_bus_message_new_method_return(message, &m->queued_message);
1171 m->queued_message_bus = sd_bus_ref(bus);
1172 m->exit_code = MANAGER_RELOAD;
1177 static int method_reexecute(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1178 Manager *m = userdata;
1185 r = bus_verify_reload_daemon_async(m, message, error);
1189 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1191 r = mac_selinux_access_check(message, "reload", error);
1195 /* We don't send a reply back here, the client should
1196 * just wait for us disconnecting. */
1198 m->exit_code = MANAGER_REEXECUTE;
1202 static int method_exit(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1203 Manager *m = userdata;
1210 r = mac_selinux_access_check(message, "halt", error);
1214 if (m->running_as == SYSTEMD_SYSTEM)
1215 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Exit is only supported for user service managers.");
1217 m->exit_code = MANAGER_EXIT;
1219 return sd_bus_reply_method_return(message, NULL);
1222 static int method_reboot(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1223 Manager *m = userdata;
1230 r = mac_selinux_access_check(message, "reboot", error);
1234 if (m->running_as != SYSTEMD_SYSTEM)
1235 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Reboot is only supported for system managers.");
1237 m->exit_code = MANAGER_REBOOT;
1239 return sd_bus_reply_method_return(message, NULL);
1243 static int method_poweroff(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1244 Manager *m = userdata;
1251 r = mac_selinux_access_check(message, "halt", error);
1255 if (m->running_as != SYSTEMD_SYSTEM)
1256 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Powering off is only supported for system managers.");
1258 m->exit_code = MANAGER_POWEROFF;
1260 return sd_bus_reply_method_return(message, NULL);
1263 static int method_halt(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1264 Manager *m = userdata;
1271 r = mac_selinux_access_check(message, "halt", error);
1275 if (m->running_as != SYSTEMD_SYSTEM)
1276 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Halt is only supported for system managers.");
1278 m->exit_code = MANAGER_HALT;
1280 return sd_bus_reply_method_return(message, NULL);
1283 static int method_kexec(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1284 Manager *m = userdata;
1291 r = mac_selinux_access_check(message, "reboot", error);
1295 if (m->running_as != SYSTEMD_SYSTEM)
1296 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "KExec is only supported for system managers.");
1298 m->exit_code = MANAGER_KEXEC;
1300 return sd_bus_reply_method_return(message, NULL);
1303 static int method_switch_root(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1304 char *ri = NULL, *rt = NULL;
1305 const char *root, *init;
1306 Manager *m = userdata;
1313 r = mac_selinux_access_check(message, "reboot", error);
1317 if (m->running_as != SYSTEMD_SYSTEM)
1318 return sd_bus_error_setf(error, SD_BUS_ERROR_NOT_SUPPORTED, "Root switching is only supported by system manager.");
1320 r = sd_bus_message_read(message, "ss", &root, &init);
1324 if (path_equal(root, "/") || !path_is_absolute(root))
1325 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid switch root path %s", root);
1328 if (isempty(init)) {
1329 if (!path_is_os_tree(root))
1330 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);
1332 _cleanup_free_ char *p = NULL;
1334 if (!path_is_absolute(init))
1335 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid init path %s", init);
1337 p = strappend(root, init);
1341 if (access(p, X_OK) < 0)
1342 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Specified init binary %s does not exist.", p);
1349 if (!isempty(init)) {
1357 free(m->switch_root);
1358 m->switch_root = rt;
1360 free(m->switch_root_init);
1361 m->switch_root_init = ri;
1363 m->exit_code = MANAGER_SWITCH_ROOT;
1365 return sd_bus_reply_method_return(message, NULL);
1368 static int method_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1369 _cleanup_strv_free_ char **plus = NULL;
1370 Manager *m = userdata;
1377 r = mac_selinux_access_check(message, "reload", error);
1381 r = sd_bus_message_read_strv(message, &plus);
1384 if (!strv_env_is_valid(plus))
1385 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1387 r = manager_environment_add(m, NULL, plus);
1391 return sd_bus_reply_method_return(message, NULL);
1394 static int method_unset_environment(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1395 _cleanup_strv_free_ char **minus = NULL;
1396 Manager *m = userdata;
1403 r = mac_selinux_access_check(message, "reload", error);
1407 r = sd_bus_message_read_strv(message, &minus);
1411 if (!strv_env_name_or_assignment_is_valid(minus))
1412 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1414 r = manager_environment_add(m, minus, NULL);
1418 return sd_bus_reply_method_return(message, NULL);
1421 static int method_unset_and_set_environment(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1422 _cleanup_strv_free_ char **minus = NULL, **plus = NULL;
1423 Manager *m = userdata;
1430 r = mac_selinux_access_check(message, "reload", error);
1434 r = sd_bus_message_read_strv(message, &minus);
1438 r = sd_bus_message_read_strv(message, &plus);
1442 if (!strv_env_name_or_assignment_is_valid(minus))
1443 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment variable names or assignments");
1444 if (!strv_env_is_valid(plus))
1445 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid environment assignments");
1447 r = manager_environment_add(m, minus, plus);
1451 return sd_bus_reply_method_return(message, NULL);
1454 static int method_list_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1455 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1456 Manager *m = userdata;
1466 /* Anyone can call this method */
1468 r = mac_selinux_access_check(message, "status", error);
1472 r = sd_bus_message_new_method_return(message, &reply);
1476 h = hashmap_new(&string_hash_ops);
1480 r = unit_file_get_list(m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER, NULL, h);
1484 r = sd_bus_message_open_container(reply, 'a', "(ss)");
1488 HASHMAP_FOREACH(item, h, i) {
1490 r = sd_bus_message_append(reply, "(ss)", item->path, unit_file_state_to_string(item->state));
1495 unit_file_list_free(h);
1497 r = sd_bus_message_close_container(reply);
1501 return sd_bus_send(bus, reply, NULL);
1504 unit_file_list_free(h);
1508 static int method_get_unit_file_state(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1509 Manager *m = userdata;
1511 UnitFileState state;
1512 UnitFileScope scope;
1519 /* Anyone can call this method */
1521 r = mac_selinux_access_check(message, "status", error);
1525 r = sd_bus_message_read(message, "s", &name);
1529 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1531 state = unit_file_get_state(scope, NULL, name);
1535 return sd_bus_reply_method_return(message, "s", unit_file_state_to_string(state));
1538 static int method_get_default_target(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1539 _cleanup_free_ char *default_target = NULL;
1540 Manager *m = userdata;
1541 UnitFileScope scope;
1548 /* Anyone can call this method */
1550 r = mac_selinux_access_check(message, "status", error);
1554 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1556 r = unit_file_get_default(scope, NULL, &default_target);
1560 return sd_bus_reply_method_return(message, "s", default_target);
1563 static int send_unit_files_changed(sd_bus *bus, void *userdata) {
1564 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
1569 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "UnitFilesChanged");
1573 return sd_bus_send(bus, message, NULL);
1576 static int reply_unit_file_changes_and_free(
1579 sd_bus_message *message,
1580 int carries_install_info,
1581 UnitFileChange *changes,
1582 unsigned n_changes) {
1584 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1588 if (n_changes > 0) {
1589 r = bus_foreach_bus(m, NULL, send_unit_files_changed, NULL);
1591 log_debug_errno(r, "Failed to send UnitFilesChanged signal: %m");
1594 r = sd_bus_message_new_method_return(message, &reply);
1598 if (carries_install_info >= 0) {
1599 r = sd_bus_message_append(reply, "b", carries_install_info);
1604 r = sd_bus_message_open_container(reply, 'a', "(sss)");
1608 for (i = 0; i < n_changes; i++) {
1609 r = sd_bus_message_append(
1611 unit_file_change_type_to_string(changes[i].type),
1618 r = sd_bus_message_close_container(reply);
1622 return sd_bus_send(bus, reply, NULL);
1625 unit_file_changes_free(changes, n_changes);
1629 static int method_enable_unit_files_generic(
1631 sd_bus_message *message,
1634 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], bool force, UnitFileChange **changes, unsigned *n_changes),
1635 bool carries_install_info,
1636 sd_bus_error *error) {
1638 _cleanup_strv_free_ char **l = NULL;
1639 UnitFileChange *changes = NULL;
1640 unsigned n_changes = 0;
1641 UnitFileScope scope;
1642 int runtime, force, r;
1648 r = bus_verify_manage_unit_files_async(m, message, error);
1652 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1654 r = sd_bus_message_read_strv(message, &l);
1658 r = sd_bus_message_read(message, "bb", &runtime, &force);
1662 r = mac_selinux_unit_access_check_strv(l, message, m, verb, error);
1666 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1668 r = call(scope, runtime, NULL, l, force, &changes, &n_changes);
1672 return reply_unit_file_changes_and_free(m, bus, message, carries_install_info ? r : -1, changes, n_changes);
1675 static int method_enable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1676 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_enable, true, error);
1679 static int method_reenable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1680 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_reenable, true, error);
1683 static int method_link_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1684 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_link, false, error);
1687 static int unit_file_preset_without_mode(UnitFileScope scope, bool runtime, const char *root_dir, char **files, bool force, UnitFileChange **changes, unsigned *n_changes) {
1688 return unit_file_preset(scope, runtime, root_dir, files, UNIT_FILE_PRESET_FULL, force, changes, n_changes);
1691 static int method_preset_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1692 return method_enable_unit_files_generic(bus, message, userdata, "enable", unit_file_preset_without_mode, true, error);
1695 static int method_mask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1696 return method_enable_unit_files_generic(bus, message, userdata, "disable", unit_file_mask, false, error);
1699 static int method_preset_unit_files_with_mode(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1701 _cleanup_strv_free_ char **l = NULL;
1702 UnitFileChange *changes = NULL;
1703 unsigned n_changes = 0;
1704 Manager *m = userdata;
1705 UnitFilePresetMode mm;
1706 UnitFileScope scope;
1707 int runtime, force, r;
1714 r = bus_verify_manage_unit_files_async(m, message, error);
1718 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1720 r = sd_bus_message_read_strv(message, &l);
1724 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
1729 mm = UNIT_FILE_PRESET_FULL;
1731 mm = unit_file_preset_mode_from_string(mode);
1736 r = mac_selinux_unit_access_check_strv(l, message, m, "enable", error);
1740 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1742 r = unit_file_preset(scope, runtime, NULL, l, mm, force, &changes, &n_changes);
1746 return reply_unit_file_changes_and_free(m, bus, message, r, changes, n_changes);
1749 static int method_disable_unit_files_generic(
1751 sd_bus_message *message,
1754 int (*call)(UnitFileScope scope, bool runtime, const char *root_dir, char *files[], UnitFileChange **changes, unsigned *n_changes),
1755 sd_bus_error *error) {
1757 _cleanup_strv_free_ char **l = NULL;
1758 UnitFileChange *changes = NULL;
1759 unsigned n_changes = 0;
1760 UnitFileScope scope;
1767 r = bus_verify_manage_unit_files_async(m, message, error);
1771 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1773 r = mac_selinux_access_check(message, verb, error);
1777 r = sd_bus_message_read_strv(message, &l);
1781 r = sd_bus_message_read(message, "b", &runtime);
1785 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1787 r = call(scope, runtime, NULL, l, &changes, &n_changes);
1791 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1794 static int method_disable_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1795 return method_disable_unit_files_generic(bus, message, userdata, "disable", unit_file_disable, error);
1798 static int method_unmask_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1799 return method_disable_unit_files_generic(bus, message, userdata, "enable", unit_file_unmask, error);
1802 static int method_set_default_target(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1803 UnitFileChange *changes = NULL;
1804 unsigned n_changes = 0;
1805 Manager *m = userdata;
1806 UnitFileScope scope;
1814 r = bus_verify_manage_unit_files_async(m, message, error);
1818 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1820 r = mac_selinux_access_check(message, "enable", error);
1824 r = sd_bus_message_read(message, "sb", &name, &force);
1828 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1830 r = unit_file_set_default(scope, NULL, name, force, &changes, &n_changes);
1834 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1837 static int method_preset_all_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1838 UnitFileChange *changes = NULL;
1839 unsigned n_changes = 0;
1840 Manager *m = userdata;
1841 UnitFilePresetMode mm;
1842 UnitFileScope scope;
1844 int force, runtime, r;
1850 r = bus_verify_manage_unit_files_async(m, message, error);
1854 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1856 r = mac_selinux_access_check(message, "enable", error);
1860 r = sd_bus_message_read(message, "sbb", &mode, &runtime, &force);
1865 mm = UNIT_FILE_PRESET_FULL;
1867 mm = unit_file_preset_mode_from_string(mode);
1872 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1874 r = unit_file_preset_all(scope, runtime, NULL, mm, force, &changes, &n_changes);
1878 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1881 static int method_add_dependency_unit_files(sd_bus *bus, sd_bus_message *message, void *userdata, sd_bus_error *error) {
1882 _cleanup_strv_free_ char **l = NULL;
1883 Manager *m = userdata;
1884 UnitFileChange *changes = NULL;
1885 unsigned n_changes = 0;
1886 UnitFileScope scope;
1887 int runtime, force, r;
1896 r = bus_verify_manage_unit_files_async(m, message, error);
1900 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
1902 r = sd_bus_message_read_strv(message, &l);
1906 r = sd_bus_message_read(message, "ssbb", &target, &type, &runtime, &force);
1910 dep = unit_dependency_from_string(type);
1914 r = mac_selinux_unit_access_check_strv(l, message, m, "enable", error);
1918 scope = m->running_as == SYSTEMD_SYSTEM ? UNIT_FILE_SYSTEM : UNIT_FILE_USER;
1920 r = unit_file_add_dependency(scope, runtime, NULL, l, target, dep, force, &changes, &n_changes);
1924 return reply_unit_file_changes_and_free(m, bus, message, -1, changes, n_changes);
1927 const sd_bus_vtable bus_manager_vtable[] = {
1928 SD_BUS_VTABLE_START(0),
1930 SD_BUS_PROPERTY("Version", "s", property_get_version, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1931 SD_BUS_PROPERTY("Features", "s", property_get_features, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1932 SD_BUS_PROPERTY("Virtualization", "s", property_get_virtualization, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1933 SD_BUS_PROPERTY("Architecture", "s", property_get_architecture, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1934 SD_BUS_PROPERTY("Tainted", "s", property_get_tainted, 0, SD_BUS_VTABLE_PROPERTY_CONST),
1935 BUS_PROPERTY_DUAL_TIMESTAMP("FirmwareTimestamp", offsetof(Manager, firmware_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1936 BUS_PROPERTY_DUAL_TIMESTAMP("LoaderTimestamp", offsetof(Manager, loader_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1937 BUS_PROPERTY_DUAL_TIMESTAMP("KernelTimestamp", offsetof(Manager, kernel_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1938 BUS_PROPERTY_DUAL_TIMESTAMP("InitRDTimestamp", offsetof(Manager, initrd_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1939 BUS_PROPERTY_DUAL_TIMESTAMP("UserspaceTimestamp", offsetof(Manager, userspace_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1940 BUS_PROPERTY_DUAL_TIMESTAMP("FinishTimestamp", offsetof(Manager, finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1941 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityStartTimestamp", offsetof(Manager, security_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1942 BUS_PROPERTY_DUAL_TIMESTAMP("SecurityFinishTimestamp", offsetof(Manager, security_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1943 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsStartTimestamp", offsetof(Manager, generators_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1944 BUS_PROPERTY_DUAL_TIMESTAMP("GeneratorsFinishTimestamp", offsetof(Manager, generators_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1945 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadStartTimestamp", offsetof(Manager, units_load_start_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1946 BUS_PROPERTY_DUAL_TIMESTAMP("UnitsLoadFinishTimestamp", offsetof(Manager, units_load_finish_timestamp), SD_BUS_VTABLE_PROPERTY_CONST),
1947 SD_BUS_WRITABLE_PROPERTY("LogLevel", "s", property_get_log_level, property_set_log_level, 0, 0),
1948 SD_BUS_WRITABLE_PROPERTY("LogTarget", "s", property_get_log_target, property_set_log_target, 0, 0),
1949 SD_BUS_PROPERTY("NNames", "u", property_get_n_names, 0, 0),
1950 SD_BUS_PROPERTY("NFailedUnits", "u", property_get_n_failed_units, 0, 0),
1951 SD_BUS_PROPERTY("NJobs", "u", property_get_n_jobs, 0, 0),
1952 SD_BUS_PROPERTY("NInstalledJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_installed_jobs), 0),
1953 SD_BUS_PROPERTY("NFailedJobs", "u", bus_property_get_unsigned, offsetof(Manager, n_failed_jobs), 0),
1954 SD_BUS_PROPERTY("Progress", "d", property_get_progress, 0, 0),
1955 SD_BUS_PROPERTY("Environment", "as", NULL, offsetof(Manager, environment), 0),
1956 SD_BUS_PROPERTY("ConfirmSpawn", "b", bus_property_get_bool, offsetof(Manager, confirm_spawn), SD_BUS_VTABLE_PROPERTY_CONST),
1957 SD_BUS_PROPERTY("ShowStatus", "b", bus_property_get_bool, offsetof(Manager, show_status), SD_BUS_VTABLE_PROPERTY_CONST),
1958 SD_BUS_PROPERTY("UnitPath", "as", NULL, offsetof(Manager, lookup_paths.unit_path), SD_BUS_VTABLE_PROPERTY_CONST),
1959 SD_BUS_PROPERTY("DefaultStandardOutput", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
1960 SD_BUS_PROPERTY("DefaultStandardError", "s", bus_property_get_exec_output, offsetof(Manager, default_std_output), SD_BUS_VTABLE_PROPERTY_CONST),
1961 SD_BUS_WRITABLE_PROPERTY("RuntimeWatchdogUSec", "t", bus_property_get_usec, property_set_runtime_watchdog, offsetof(Manager, runtime_watchdog), 0),
1962 SD_BUS_WRITABLE_PROPERTY("ShutdownWatchdogUSec", "t", bus_property_get_usec, bus_property_set_usec, offsetof(Manager, shutdown_watchdog), 0),
1963 SD_BUS_PROPERTY("ControlGroup", "s", NULL, offsetof(Manager, cgroup_root), 0),
1964 SD_BUS_PROPERTY("SystemState", "s", property_get_system_state, 0, 0),
1966 SD_BUS_METHOD("GetUnit", "s", "o", method_get_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1967 SD_BUS_METHOD("GetUnitByPID", "u", "o", method_get_unit_by_pid, SD_BUS_VTABLE_UNPRIVILEGED),
1968 SD_BUS_METHOD("LoadUnit", "s", "o", method_load_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1969 SD_BUS_METHOD("StartUnit", "ss", "o", method_start_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1970 SD_BUS_METHOD("StartUnitReplace", "sss", "o", method_start_unit_replace, SD_BUS_VTABLE_UNPRIVILEGED),
1971 SD_BUS_METHOD("StopUnit", "ss", "o", method_stop_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1972 SD_BUS_METHOD("ReloadUnit", "ss", "o", method_reload_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1973 SD_BUS_METHOD("RestartUnit", "ss", "o", method_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1974 SD_BUS_METHOD("TryRestartUnit", "ss", "o", method_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1975 SD_BUS_METHOD("ReloadOrRestartUnit", "ss", "o", method_reload_or_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1976 SD_BUS_METHOD("ReloadOrTryRestartUnit", "ss", "o", method_reload_or_try_restart_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1977 SD_BUS_METHOD("KillUnit", "ssi", NULL, method_kill_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1978 SD_BUS_METHOD("ResetFailedUnit", "s", NULL, method_reset_failed_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1979 SD_BUS_METHOD("SetUnitProperties", "sba(sv)", NULL, method_set_unit_properties, SD_BUS_VTABLE_UNPRIVILEGED),
1980 SD_BUS_METHOD("StartTransientUnit", "ssa(sv)a(sa(sv))", "o", method_start_transient_unit, SD_BUS_VTABLE_UNPRIVILEGED),
1981 SD_BUS_METHOD("GetJob", "u", "o", method_get_job, SD_BUS_VTABLE_UNPRIVILEGED),
1982 SD_BUS_METHOD("CancelJob", "u", NULL, method_cancel_job, SD_BUS_VTABLE_UNPRIVILEGED),
1983 SD_BUS_METHOD("ClearJobs", NULL, NULL, method_clear_jobs, 0),
1984 SD_BUS_METHOD("ResetFailed", NULL, NULL, method_reset_failed, 0),
1985 SD_BUS_METHOD("ListUnits", NULL, "a(ssssssouso)", method_list_units, SD_BUS_VTABLE_UNPRIVILEGED),
1986 SD_BUS_METHOD("ListUnitsFiltered", "as", "a(ssssssouso)", method_list_units_filtered, SD_BUS_VTABLE_UNPRIVILEGED),
1987 SD_BUS_METHOD("ListJobs", NULL, "a(usssoo)", method_list_jobs, SD_BUS_VTABLE_UNPRIVILEGED),
1988 SD_BUS_METHOD("Subscribe", NULL, NULL, method_subscribe, SD_BUS_VTABLE_UNPRIVILEGED),
1989 SD_BUS_METHOD("Unsubscribe", NULL, NULL, method_unsubscribe, SD_BUS_VTABLE_UNPRIVILEGED),
1990 SD_BUS_METHOD("Dump", NULL, "s", method_dump, SD_BUS_VTABLE_UNPRIVILEGED),
1991 SD_BUS_METHOD("CreateSnapshot", "sb", "o", method_create_snapshot, 0),
1992 SD_BUS_METHOD("RemoveSnapshot", "s", NULL, method_remove_snapshot, 0),
1993 SD_BUS_METHOD("Reload", NULL, NULL, method_reload, SD_BUS_VTABLE_UNPRIVILEGED),
1994 SD_BUS_METHOD("Reexecute", NULL, NULL, method_reexecute, SD_BUS_VTABLE_UNPRIVILEGED),
1995 SD_BUS_METHOD("Exit", NULL, NULL, method_exit, 0),
1996 SD_BUS_METHOD("Reboot", NULL, NULL, method_reboot, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
1997 SD_BUS_METHOD("PowerOff", NULL, NULL, method_poweroff, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
1998 SD_BUS_METHOD("Halt", NULL, NULL, method_halt, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
1999 SD_BUS_METHOD("KExec", NULL, NULL, method_kexec, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2000 SD_BUS_METHOD("SwitchRoot", "ss", NULL, method_switch_root, SD_BUS_VTABLE_CAPABILITY(CAP_SYS_BOOT)),
2001 SD_BUS_METHOD("SetEnvironment", "as", NULL, method_set_environment, 0),
2002 SD_BUS_METHOD("UnsetEnvironment", "as", NULL, method_unset_environment, 0),
2003 SD_BUS_METHOD("UnsetAndSetEnvironment", "asas", NULL, method_unset_and_set_environment, 0),
2004 SD_BUS_METHOD("ListUnitFiles", NULL, "a(ss)", method_list_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2005 SD_BUS_METHOD("GetUnitFileState", "s", "s", method_get_unit_file_state, SD_BUS_VTABLE_UNPRIVILEGED),
2006 SD_BUS_METHOD("EnableUnitFiles", "asbb", "ba(sss)", method_enable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2007 SD_BUS_METHOD("DisableUnitFiles", "asb", "a(sss)", method_disable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2008 SD_BUS_METHOD("ReenableUnitFiles", "asbb", "ba(sss)", method_reenable_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2009 SD_BUS_METHOD("LinkUnitFiles", "asbb", "a(sss)", method_link_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2010 SD_BUS_METHOD("PresetUnitFiles", "asbb", "ba(sss)", method_preset_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2011 SD_BUS_METHOD("PresetUnitFilesWithMode", "assbb", "ba(sss)", method_preset_unit_files_with_mode, SD_BUS_VTABLE_UNPRIVILEGED),
2012 SD_BUS_METHOD("MaskUnitFiles", "asbb", "a(sss)", method_mask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2013 SD_BUS_METHOD("UnmaskUnitFiles", "asb", "a(sss)", method_unmask_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2014 SD_BUS_METHOD("SetDefaultTarget", "sb", "a(sss)", method_set_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2015 SD_BUS_METHOD("GetDefaultTarget", NULL, "s", method_get_default_target, SD_BUS_VTABLE_UNPRIVILEGED),
2016 SD_BUS_METHOD("PresetAllUnitFiles", "sbb", "a(sss)", method_preset_all_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2017 SD_BUS_METHOD("AddDependencyUnitFiles", "asssbb", "a(sss)", method_add_dependency_unit_files, SD_BUS_VTABLE_UNPRIVILEGED),
2019 SD_BUS_SIGNAL("UnitNew", "so", 0),
2020 SD_BUS_SIGNAL("UnitRemoved", "so", 0),
2021 SD_BUS_SIGNAL("JobNew", "uos", 0),
2022 SD_BUS_SIGNAL("JobRemoved", "uoss", 0),
2023 SD_BUS_SIGNAL("StartupFinished", "tttttt", 0),
2024 SD_BUS_SIGNAL("UnitFilesChanged", NULL, 0),
2025 SD_BUS_SIGNAL("Reloading", "b", 0),
2030 static int send_finished(sd_bus *bus, void *userdata) {
2031 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
2032 usec_t *times = userdata;
2038 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "StartupFinished");
2042 r = sd_bus_message_append(message, "tttttt", times[0], times[1], times[2], times[3], times[4], times[5]);
2046 return sd_bus_send(bus, message, NULL);
2049 void bus_manager_send_finished(
2051 usec_t firmware_usec,
2055 usec_t userspace_usec,
2056 usec_t total_usec) {
2062 r = bus_foreach_bus(
2075 log_debug_errno(r, "Failed to send finished signal: %m");
2078 static int send_reloading(sd_bus *bus, void *userdata) {
2079 _cleanup_bus_message_unref_ sd_bus_message *message = NULL;
2084 r = sd_bus_message_new_signal(bus, &message, "/org/freedesktop/systemd1", "org.freedesktop.systemd1.Manager", "Reloading");
2088 r = sd_bus_message_append(message, "b", PTR_TO_INT(userdata));
2092 return sd_bus_send(bus, message, NULL);
2095 void bus_manager_send_reloading(Manager *m, bool active) {
2100 r = bus_foreach_bus(m, NULL, send_reloading, INT_TO_PTR(active));
2102 log_debug_errno(r, "Failed to send reloading signal: %m");