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