]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/systemctl/systemctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
timer: support timers that can resume the system from suspend
[thirdparty/systemd.git] / src / systemctl / systemctl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2010 Lennart Poettering
7 Copyright 2013 Marc-Antoine Perennou
8
9 systemd is free software; you can redistribute it and/or modify it
10 under the terms of the GNU Lesser General Public License as published by
11 the Free Software Foundation; either version 2.1 of the License, or
12 (at your option) any later version.
13
14 systemd is distributed in the hope that it will be useful, but
15 WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 Lesser General Public License for more details.
18
19 You should have received a copy of the GNU Lesser General Public License
20 along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <sys/reboot.h>
24 #include <linux/reboot.h>
25 #include <sys/syscall.h>
26 #include <stdio.h>
27 #include <getopt.h>
28 #include <locale.h>
29 #include <stdbool.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <sys/ioctl.h>
33 #include <termios.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <sys/socket.h>
37 #include <sys/stat.h>
38 #include <stddef.h>
39 #include <sys/prctl.h>
40 #include <fnmatch.h>
41
42 #include "sd-daemon.h"
43 #include "sd-shutdown.h"
44 #include "sd-login.h"
45 #include "sd-bus.h"
46 #include "log.h"
47 #include "util.h"
48 #include "macro.h"
49 #include "set.h"
50 #include "utmp-wtmp.h"
51 #include "special.h"
52 #include "initreq.h"
53 #include "path-util.h"
54 #include "strv.h"
55 #include "cgroup-show.h"
56 #include "cgroup-util.h"
57 #include "list.h"
58 #include "path-lookup.h"
59 #include "conf-parser.h"
60 #include "exit-status.h"
61 #include "build.h"
62 #include "unit-name.h"
63 #include "pager.h"
64 #include "spawn-ask-password-agent.h"
65 #include "spawn-polkit-agent.h"
66 #include "install.h"
67 #include "logs-show.h"
68 #include "socket-util.h"
69 #include "fileio.h"
70 #include "env-util.h"
71 #include "bus-util.h"
72 #include "bus-message.h"
73 #include "bus-error.h"
74 #include "bus-errors.h"
75
76 static char **arg_types = NULL;
77 static char **arg_states = NULL;
78 static char **arg_properties = NULL;
79 static bool arg_all = false;
80 static enum dependency {
81 DEPENDENCY_FORWARD,
82 DEPENDENCY_REVERSE,
83 DEPENDENCY_AFTER,
84 DEPENDENCY_BEFORE,
85 _DEPENDENCY_MAX
86 } arg_dependency = DEPENDENCY_FORWARD;
87 static const char *arg_job_mode = "replace";
88 static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
89 static bool arg_no_block = false;
90 static bool arg_no_legend = false;
91 static bool arg_no_pager = false;
92 static bool arg_no_wtmp = false;
93 static bool arg_no_wall = false;
94 static bool arg_no_reload = false;
95 static bool arg_show_types = false;
96 static bool arg_ignore_inhibitors = false;
97 static bool arg_dry = false;
98 static bool arg_quiet = false;
99 static bool arg_full = false;
100 static bool arg_recursive = false;
101 static int arg_force = 0;
102 static bool arg_ask_password = true;
103 static bool arg_runtime = false;
104 static char **arg_wall = NULL;
105 static const char *arg_kill_who = NULL;
106 static int arg_signal = SIGTERM;
107 static const char *arg_root = NULL;
108 static usec_t arg_when = 0;
109 static enum action {
110 _ACTION_INVALID,
111 ACTION_SYSTEMCTL,
112 ACTION_HALT,
113 ACTION_POWEROFF,
114 ACTION_REBOOT,
115 ACTION_KEXEC,
116 ACTION_EXIT,
117 ACTION_SUSPEND,
118 ACTION_HIBERNATE,
119 ACTION_HYBRID_SLEEP,
120 ACTION_RUNLEVEL2,
121 ACTION_RUNLEVEL3,
122 ACTION_RUNLEVEL4,
123 ACTION_RUNLEVEL5,
124 ACTION_RESCUE,
125 ACTION_EMERGENCY,
126 ACTION_DEFAULT,
127 ACTION_RELOAD,
128 ACTION_REEXEC,
129 ACTION_RUNLEVEL,
130 ACTION_CANCEL_SHUTDOWN,
131 _ACTION_MAX
132 } arg_action = ACTION_SYSTEMCTL;
133 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
134 static char *arg_host = NULL;
135 static unsigned arg_lines = 10;
136 static OutputMode arg_output = OUTPUT_SHORT;
137 static bool arg_plain = false;
138
139 static const struct {
140 const char *verb;
141 const char *method;
142 } unit_actions[] = {
143 { "start", "StartUnit" },
144 { "stop", "StopUnit" },
145 { "condstop", "StopUnit" },
146 { "reload", "ReloadUnit" },
147 { "restart", "RestartUnit" },
148 { "try-restart", "TryRestartUnit" },
149 { "condrestart", "TryRestartUnit" },
150 { "reload-or-restart", "ReloadOrRestartUnit" },
151 { "reload-or-try-restart", "ReloadOrTryRestartUnit" },
152 { "condreload", "ReloadOrTryRestartUnit" },
153 { "force-reload", "ReloadOrTryRestartUnit" }
154 };
155
156 static bool original_stdout_is_tty;
157
158 static int daemon_reload(sd_bus *bus, char **args);
159 static int halt_now(enum action a);
160 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet);
161
162 static char** strv_skip_first(char **strv) {
163 if (strv_length(strv) > 0)
164 return strv + 1;
165 return NULL;
166 }
167
168 static void pager_open_if_enabled(void) {
169
170 if (arg_no_pager)
171 return;
172
173 pager_open(false);
174 }
175
176 static void ask_password_agent_open_if_enabled(void) {
177
178 /* Open the password agent as a child process if necessary */
179
180 if (!arg_ask_password)
181 return;
182
183 if (arg_scope != UNIT_FILE_SYSTEM)
184 return;
185
186 if (arg_transport != BUS_TRANSPORT_LOCAL)
187 return;
188
189 ask_password_agent_open();
190 }
191
192 #ifdef HAVE_LOGIND
193 static void polkit_agent_open_if_enabled(void) {
194
195 /* Open the polkit agent as a child process if necessary */
196
197 if (!arg_ask_password)
198 return;
199
200 if (arg_scope != UNIT_FILE_SYSTEM)
201 return;
202
203 if (arg_transport != BUS_TRANSPORT_LOCAL)
204 return;
205
206 polkit_agent_open();
207 }
208 #endif
209
210 static int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {
211 assert(error);
212
213 if (!sd_bus_error_is_set(error))
214 return r;
215
216 if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||
217 sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
218 sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
219 sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
220 return EXIT_NOPERMISSION;
221
222 if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
223 return EXIT_NOTINSTALLED;
224
225 if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
226 sd_bus_error_has_name(error, SD_BUS_ERROR_NOT_SUPPORTED))
227 return EXIT_NOTIMPLEMENTED;
228
229 if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
230 return EXIT_NOTCONFIGURED;
231
232 if (r != 0)
233 return r;
234
235 return EXIT_FAILURE;
236 }
237
238 static void warn_wall(enum action a) {
239 static const char *table[_ACTION_MAX] = {
240 [ACTION_HALT] = "The system is going down for system halt NOW!",
241 [ACTION_REBOOT] = "The system is going down for reboot NOW!",
242 [ACTION_POWEROFF] = "The system is going down for power-off NOW!",
243 [ACTION_KEXEC] = "The system is going down for kexec reboot NOW!",
244 [ACTION_RESCUE] = "The system is going down to rescue mode NOW!",
245 [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!",
246 [ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"
247 };
248
249 if (arg_no_wall)
250 return;
251
252 if (arg_wall) {
253 _cleanup_free_ char *p;
254
255 p = strv_join(arg_wall, " ");
256 if (!p) {
257 log_oom();
258 return;
259 }
260
261 if (*p) {
262 utmp_wall(p, NULL, NULL);
263 return;
264 }
265 }
266
267 if (!table[a])
268 return;
269
270 utmp_wall(table[a], NULL, NULL);
271 }
272
273 static bool avoid_bus(void) {
274
275 if (running_in_chroot() > 0)
276 return true;
277
278 if (sd_booted() <= 0)
279 return true;
280
281 if (!isempty(arg_root))
282 return true;
283
284 if (arg_scope == UNIT_FILE_GLOBAL)
285 return true;
286
287 return false;
288 }
289
290 static int compare_unit_info(const void *a, const void *b) {
291 const UnitInfo *u = a, *v = b;
292 const char *d1, *d2;
293 int r;
294
295 /* First, order by machine */
296 if (!u->machine && v->machine)
297 return -1;
298 if (u->machine && !v->machine)
299 return 1;
300 if (u->machine && v->machine) {
301 r = strcasecmp(u->machine, v->machine);
302 if (r != 0)
303 return r;
304 }
305
306 /* Second, order by unit type */
307 d1 = strrchr(u->id, '.');
308 d2 = strrchr(v->id, '.');
309 if (d1 && d2) {
310 r = strcasecmp(d1, d2);
311 if (r != 0)
312 return r;
313 }
314
315 /* Third, order by name */
316 return strcasecmp(u->id, v->id);
317 }
318
319 static bool output_show_unit(const UnitInfo *u, char **patterns) {
320 const char *dot;
321
322 if (!strv_isempty(arg_states))
323 return
324 strv_contains(arg_states, u->load_state) ||
325 strv_contains(arg_states, u->sub_state) ||
326 strv_contains(arg_states, u->active_state);
327
328 if (!strv_isempty(patterns)) {
329 char **pattern;
330
331 STRV_FOREACH(pattern, patterns)
332 if (fnmatch(*pattern, u->id, FNM_NOESCAPE) == 0)
333 return true;
334 return false;
335 }
336
337 return (!arg_types || ((dot = strrchr(u->id, '.')) &&
338 strv_find(arg_types, dot+1))) &&
339 (arg_all || !(streq(u->active_state, "inactive")
340 || u->following[0]) || u->job_id > 0);
341 }
342
343 static int output_units_list(const UnitInfo *unit_infos, unsigned c) {
344 unsigned circle_len = 0, id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
345 const UnitInfo *u;
346 unsigned n_shown = 0;
347 int job_count = 0;
348
349 max_id_len = strlen("UNIT");
350 load_len = strlen("LOAD");
351 active_len = strlen("ACTIVE");
352 sub_len = strlen("SUB");
353 job_len = strlen("JOB");
354 desc_len = 0;
355
356 for (u = unit_infos; u < unit_infos + c; u++) {
357 max_id_len = MAX(max_id_len, strlen(u->id) + (u->machine ? strlen(u->machine)+1 : 0));
358 load_len = MAX(load_len, strlen(u->load_state));
359 active_len = MAX(active_len, strlen(u->active_state));
360 sub_len = MAX(sub_len, strlen(u->sub_state));
361
362 if (u->job_id != 0) {
363 job_len = MAX(job_len, strlen(u->job_type));
364 job_count++;
365 }
366
367 if (!arg_no_legend &&
368 (streq(u->active_state, "failed") ||
369 STR_IN_SET(u->load_state, "error", "not-found", "masked")))
370 circle_len = 2;
371 }
372
373 if (!arg_full && original_stdout_is_tty) {
374 unsigned basic_len;
375
376 id_len = MIN(max_id_len, 25u);
377 basic_len = circle_len + 5 + id_len + 5 + active_len + sub_len;
378
379 if (job_count)
380 basic_len += job_len + 1;
381
382 if (basic_len < (unsigned) columns()) {
383 unsigned extra_len, incr;
384 extra_len = columns() - basic_len;
385
386 /* Either UNIT already got 25, or is fully satisfied.
387 * Grant up to 25 to DESC now. */
388 incr = MIN(extra_len, 25u);
389 desc_len += incr;
390 extra_len -= incr;
391
392 /* split the remaining space between UNIT and DESC,
393 * but do not give UNIT more than it needs. */
394 if (extra_len > 0) {
395 incr = MIN(extra_len / 2, max_id_len - id_len);
396 id_len += incr;
397 desc_len += extra_len - incr;
398 }
399 }
400 } else
401 id_len = max_id_len;
402
403 for (u = unit_infos; u < unit_infos + c; u++) {
404 _cleanup_free_ char *e = NULL, *j = NULL;
405 const char *on_loaded = "", *off_loaded = "";
406 const char *on_active = "", *off_active = "";
407 const char *on_circle = "", *off_circle = "";
408 const char *id;
409 bool circle = false;
410
411 if (!n_shown && !arg_no_legend) {
412
413 if (circle_len > 0)
414 fputs(" ", stdout);
415
416 printf("%-*s %-*s %-*s %-*s ",
417 id_len, "UNIT",
418 load_len, "LOAD",
419 active_len, "ACTIVE",
420 sub_len, "SUB");
421
422 if (job_count)
423 printf("%-*s ", job_len, "JOB");
424
425 if (!arg_full && arg_no_pager)
426 printf("%.*s\n", desc_len, "DESCRIPTION");
427 else
428 printf("%s\n", "DESCRIPTION");
429 }
430
431 n_shown++;
432
433 if (STR_IN_SET(u->load_state, "error", "not-found", "masked")) {
434 on_loaded = ansi_highlight_red();
435 on_circle = ansi_highlight_yellow();
436 off_loaded = off_circle = ansi_highlight_off();
437 circle = true;
438 }
439
440 if (streq(u->active_state, "failed")) {
441 on_circle = on_active = ansi_highlight_red();
442 off_circle = off_active = ansi_highlight_off();
443 circle = true;
444 }
445
446 if (u->machine) {
447 j = strjoin(u->machine, ":", u->id, NULL);
448 if (!j)
449 return log_oom();
450
451 id = j;
452 } else
453 id = u->id;
454
455 if (arg_full) {
456 e = ellipsize(id, id_len, 33);
457 if (!e)
458 return log_oom();
459
460 id = e;
461 }
462
463 if (circle_len > 0)
464 printf("%s%s%s", on_circle, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_circle);
465
466 printf("%s%-*s%s %s%-*s%s %s%-*s %-*s%s %-*s",
467 on_active, id_len, id, off_active,
468 on_loaded, load_len, u->load_state, off_loaded,
469 on_active, active_len, u->active_state,
470 sub_len, u->sub_state, off_active,
471 job_count ? job_len + 1 : 0, u->job_id ? u->job_type : "");
472
473 if (desc_len > 0)
474 printf("%.*s\n", desc_len, u->description);
475 else
476 printf("%s\n", u->description);
477 }
478
479 if (!arg_no_legend) {
480 const char *on, *off;
481
482 if (n_shown) {
483 puts("\n"
484 "LOAD = Reflects whether the unit definition was properly loaded.\n"
485 "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
486 "SUB = The low-level unit activation state, values depend on unit type.");
487 puts(job_count ? "JOB = Pending job for the unit.\n" : "");
488 on = ansi_highlight();
489 off = ansi_highlight_off();
490 } else {
491 on = ansi_highlight_red();
492 off = ansi_highlight_off();
493 }
494
495 if (arg_all)
496 printf("%s%u loaded units listed.%s\n"
497 "To show all installed unit files use 'systemctl list-unit-files'.\n",
498 on, n_shown, off);
499 else
500 printf("%s%u loaded units listed.%s Pass --all to see loaded but inactive units, too.\n"
501 "To show all installed unit files use 'systemctl list-unit-files'.\n",
502 on, n_shown, off);
503 }
504
505 return 0;
506 }
507
508 static int get_unit_list(
509 sd_bus *bus,
510 const char *machine,
511 char **patterns,
512 UnitInfo **unit_infos,
513 int c,
514 sd_bus_message **_reply) {
515
516 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
517 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
518 size_t size;
519 int r;
520 UnitInfo u;
521
522 assert(bus);
523 assert(unit_infos);
524 assert(_reply);
525
526 size = sizeof(UnitInfo) * c;
527
528 r = sd_bus_call_method(
529 bus,
530 "org.freedesktop.systemd1",
531 "/org/freedesktop/systemd1",
532 "org.freedesktop.systemd1.Manager",
533 "ListUnits",
534 &error,
535 &reply,
536 NULL);
537 if (r < 0) {
538 log_error("Failed to list units: %s", bus_error_message(&error, r));
539 return r;
540 }
541
542 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
543 if (r < 0)
544 return bus_log_parse_error(r);
545
546 while ((r = bus_parse_unit_info(reply, &u)) > 0) {
547 u.machine = machine;
548
549 if (!output_show_unit(&u, patterns))
550 continue;
551
552 if (!GREEDY_REALLOC(*unit_infos, size, c+1))
553 return log_oom();
554
555 (*unit_infos)[c++] = u;
556 }
557 if (r < 0)
558 return bus_log_parse_error(r);
559
560 r = sd_bus_message_exit_container(reply);
561 if (r < 0)
562 return bus_log_parse_error(r);
563
564 *_reply = reply;
565 reply = NULL;
566
567 return c;
568 }
569
570 static void message_set_freep(Set **set) {
571 sd_bus_message *m;
572
573 while ((m = set_steal_first(*set)))
574 sd_bus_message_unref(m);
575
576 set_free(*set);
577 }
578
579 static int get_unit_list_recursive(
580 sd_bus *bus,
581 char **patterns,
582 UnitInfo **_unit_infos,
583 Set **_replies,
584 char ***_machines) {
585
586 _cleanup_free_ UnitInfo *unit_infos = NULL;
587 _cleanup_(message_set_freep) Set *replies;
588 sd_bus_message *reply;
589 int c, r;
590
591 assert(bus);
592 assert(_replies);
593 assert(_unit_infos);
594 assert(_machines);
595
596 replies = set_new(NULL, NULL);
597 if (!replies)
598 return log_oom();
599
600 c = get_unit_list(bus, NULL, patterns, &unit_infos, 0, &reply);
601 if (c < 0)
602 return c;
603
604 r = set_put(replies, reply);
605 if (r < 0) {
606 sd_bus_message_unref(reply);
607 return r;
608 }
609
610 if (arg_recursive) {
611 _cleanup_strv_free_ char **machines = NULL;
612 char **i;
613
614 r = sd_get_machine_names(&machines);
615 if (r < 0)
616 return r;
617
618 STRV_FOREACH(i, machines) {
619 _cleanup_bus_unref_ sd_bus *container = NULL;
620 int k;
621
622 r = sd_bus_open_system_container(&container, *i);
623 if (r < 0) {
624 log_error("Failed to connect to container %s: %s", *i, strerror(-r));
625 continue;
626 }
627
628 k = get_unit_list(container, *i, patterns, &unit_infos, c, &reply);
629 if (k < 0)
630 return k;
631
632 c = k;
633
634 r = set_put(replies, reply);
635 if (r < 0) {
636 sd_bus_message_unref(reply);
637 return r;
638 }
639 }
640
641 *_machines = machines;
642 machines = NULL;
643 } else
644 *_machines = NULL;
645
646 *_unit_infos = unit_infos;
647 unit_infos = NULL;
648
649 *_replies = replies;
650 replies = NULL;
651
652 return c;
653 }
654
655 static int list_units(sd_bus *bus, char **args) {
656 _cleanup_free_ UnitInfo *unit_infos = NULL;
657 _cleanup_(message_set_freep) Set *replies = NULL;
658 _cleanup_strv_free_ char **machines = NULL;
659 int r;
660
661 pager_open_if_enabled();
662
663 r = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
664 if (r < 0)
665 return r;
666
667 qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);
668 return output_units_list(unit_infos, r);
669 }
670
671 static int get_triggered_units(
672 sd_bus *bus,
673 const char* path,
674 char*** ret) {
675
676 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
677 int r;
678
679 r = sd_bus_get_property_strv(
680 bus,
681 "org.freedesktop.systemd1",
682 path,
683 "org.freedesktop.systemd1.Unit",
684 "Triggers",
685 &error,
686 ret);
687
688 if (r < 0)
689 log_error("Failed to determine triggers: %s", bus_error_message(&error, r));
690
691 return 0;
692 }
693
694 static int get_listening(
695 sd_bus *bus,
696 const char* unit_path,
697 char*** listening) {
698
699 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
700 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
701 const char *type, *path;
702 int r, n = 0;
703
704 r = sd_bus_get_property(
705 bus,
706 "org.freedesktop.systemd1",
707 unit_path,
708 "org.freedesktop.systemd1.Socket",
709 "Listen",
710 &error,
711 &reply,
712 "a(ss)");
713 if (r < 0) {
714 log_error("Failed to get list of listening sockets: %s", bus_error_message(&error, r));
715 return r;
716 }
717
718 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
719 if (r < 0)
720 return bus_log_parse_error(r);
721
722 while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
723
724 r = strv_extend(listening, type);
725 if (r < 0)
726 return log_oom();
727
728 r = strv_extend(listening, path);
729 if (r < 0)
730 return log_oom();
731
732 n++;
733 }
734 if (r < 0)
735 return bus_log_parse_error(r);
736
737 r = sd_bus_message_exit_container(reply);
738 if (r < 0)
739 return bus_log_parse_error(r);
740
741 return n;
742 }
743
744 struct socket_info {
745 const char* id;
746
747 char* type;
748 char* path;
749
750 /* Note: triggered is a list here, although it almost certainly
751 * will always be one unit. Nevertheless, dbus API allows for multiple
752 * values, so let's follow that.*/
753 char** triggered;
754
755 /* The strv above is shared. free is set only in the first one. */
756 bool own_triggered;
757 };
758
759 static int socket_info_compare(const struct socket_info *a, const struct socket_info *b) {
760 int o;
761
762 assert(a);
763 assert(b);
764
765 o = strcmp(a->path, b->path);
766 if (o == 0)
767 o = strcmp(a->type, b->type);
768
769 return o;
770 }
771
772 static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {
773 struct socket_info *s;
774 unsigned pathlen = strlen("LISTEN"),
775 typelen = strlen("TYPE") * arg_show_types,
776 socklen = strlen("UNIT"),
777 servlen = strlen("ACTIVATES");
778 const char *on, *off;
779
780 for (s = socket_infos; s < socket_infos + cs; s++) {
781 unsigned tmp = 0;
782 char **a;
783
784 socklen = MAX(socklen, strlen(s->id));
785 if (arg_show_types)
786 typelen = MAX(typelen, strlen(s->type));
787 pathlen = MAX(pathlen, strlen(s->path));
788
789 STRV_FOREACH(a, s->triggered)
790 tmp += strlen(*a) + 2*(a != s->triggered);
791 servlen = MAX(servlen, tmp);
792 }
793
794 if (cs) {
795 if (!arg_no_legend)
796 printf("%-*s %-*.*s%-*s %s\n",
797 pathlen, "LISTEN",
798 typelen + arg_show_types, typelen + arg_show_types, "TYPE ",
799 socklen, "UNIT",
800 "ACTIVATES");
801
802 for (s = socket_infos; s < socket_infos + cs; s++) {
803 char **a;
804
805 if (arg_show_types)
806 printf("%-*s %-*s %-*s",
807 pathlen, s->path, typelen, s->type, socklen, s->id);
808 else
809 printf("%-*s %-*s",
810 pathlen, s->path, socklen, s->id);
811 STRV_FOREACH(a, s->triggered)
812 printf("%s %s",
813 a == s->triggered ? "" : ",", *a);
814 printf("\n");
815 }
816
817 on = ansi_highlight();
818 off = ansi_highlight_off();
819 if (!arg_no_legend)
820 printf("\n");
821 } else {
822 on = ansi_highlight_red();
823 off = ansi_highlight_off();
824 }
825
826 if (!arg_no_legend) {
827 printf("%s%u sockets listed.%s\n", on, cs, off);
828 if (!arg_all)
829 printf("Pass --all to see loaded but inactive sockets, too.\n");
830 }
831
832 return 0;
833 }
834
835 static int list_sockets(sd_bus *bus, char **args) {
836 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
837 _cleanup_free_ UnitInfo *unit_infos = NULL;
838 _cleanup_free_ struct socket_info *socket_infos = NULL;
839 const UnitInfo *u;
840 struct socket_info *s;
841 unsigned cs = 0;
842 size_t size = 0;
843 int r = 0, n;
844
845 pager_open_if_enabled();
846
847 n = get_unit_list(bus, NULL, strv_skip_first(args), &unit_infos, 0, &reply);
848 if (n < 0)
849 return n;
850
851 for (u = unit_infos; u < unit_infos + n; u++) {
852 _cleanup_strv_free_ char **listening = NULL, **triggered = NULL;
853 int i, c;
854
855 if (!endswith(u->id, ".socket"))
856 continue;
857
858 r = get_triggered_units(bus, u->unit_path, &triggered);
859 if (r < 0)
860 goto cleanup;
861
862 c = get_listening(bus, u->unit_path, &listening);
863 if (c < 0) {
864 r = c;
865 goto cleanup;
866 }
867
868 if (!GREEDY_REALLOC(socket_infos, size, cs + c)) {
869 r = log_oom();
870 goto cleanup;
871 }
872
873 for (i = 0; i < c; i++)
874 socket_infos[cs + i] = (struct socket_info) {
875 .id = u->id,
876 .type = listening[i*2],
877 .path = listening[i*2 + 1],
878 .triggered = triggered,
879 .own_triggered = i==0,
880 };
881
882 /* from this point on we will cleanup those socket_infos */
883 cs += c;
884 free(listening);
885 listening = triggered = NULL; /* avoid cleanup */
886 }
887
888 qsort_safe(socket_infos, cs, sizeof(struct socket_info),
889 (__compar_fn_t) socket_info_compare);
890
891 output_sockets_list(socket_infos, cs);
892
893 cleanup:
894 assert(cs == 0 || socket_infos);
895 for (s = socket_infos; s < socket_infos + cs; s++) {
896 free(s->type);
897 free(s->path);
898 if (s->own_triggered)
899 strv_free(s->triggered);
900 }
901
902 return r;
903 }
904
905 static int get_next_elapse(
906 sd_bus *bus,
907 const char *path,
908 dual_timestamp *next) {
909
910 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
911 dual_timestamp t;
912 int r;
913
914 assert(bus);
915 assert(path);
916 assert(next);
917
918 r = sd_bus_get_property_trivial(
919 bus,
920 "org.freedesktop.systemd1",
921 path,
922 "org.freedesktop.systemd1.Timer",
923 "NextElapseUSecMonotonic",
924 &error,
925 't',
926 &t.monotonic);
927 if (r < 0) {
928 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
929 return r;
930 }
931
932 r = sd_bus_get_property_trivial(
933 bus,
934 "org.freedesktop.systemd1",
935 path,
936 "org.freedesktop.systemd1.Timer",
937 "NextElapseUSecRealtime",
938 &error,
939 't',
940 &t.realtime);
941 if (r < 0) {
942 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
943 return r;
944 }
945
946 *next = t;
947 return 0;
948 }
949
950 static int get_last_trigger(
951 sd_bus *bus,
952 const char *path,
953 usec_t *last) {
954
955 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
956 int r;
957
958 assert(bus);
959 assert(path);
960 assert(last);
961
962 r = sd_bus_get_property_trivial(
963 bus,
964 "org.freedesktop.systemd1",
965 path,
966 "org.freedesktop.systemd1.Timer",
967 "LastTriggerUSec",
968 &error,
969 't',
970 last);
971 if (r < 0) {
972 log_error("Failed to get last trigger time: %s", bus_error_message(&error, r));
973 return r;
974 }
975
976 return 0;
977 }
978
979 struct timer_info {
980 const char* id;
981 usec_t next_elapse;
982 usec_t last_trigger;
983 char** triggered;
984 };
985
986 static int timer_info_compare(const struct timer_info *a, const struct timer_info *b) {
987 assert(a);
988 assert(b);
989
990 if (a->next_elapse < b->next_elapse)
991 return -1;
992 if (a->next_elapse > b->next_elapse)
993 return 1;
994
995 return strcmp(a->id, b->id);
996 }
997
998 static int output_timers_list(struct timer_info *timer_infos, unsigned n) {
999 struct timer_info *t;
1000 unsigned
1001 nextlen = strlen("NEXT"),
1002 leftlen = strlen("LEFT"),
1003 lastlen = strlen("LAST"),
1004 passedlen = strlen("PASSED"),
1005 unitlen = strlen("UNIT"),
1006 activatelen = strlen("ACTIVATES");
1007
1008 const char *on, *off;
1009
1010 assert(timer_infos || n == 0);
1011
1012 for (t = timer_infos; t < timer_infos + n; t++) {
1013 unsigned ul = 0;
1014 char **a;
1015
1016 if (t->next_elapse > 0) {
1017 char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
1018
1019 format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);
1020 nextlen = MAX(nextlen, strlen(tstamp) + 1);
1021
1022 format_timestamp_relative(trel, sizeof(trel), t->next_elapse);
1023 leftlen = MAX(leftlen, strlen(trel));
1024 }
1025
1026 if (t->last_trigger > 0) {
1027 char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
1028
1029 format_timestamp(tstamp, sizeof(tstamp), t->last_trigger);
1030 lastlen = MAX(lastlen, strlen(tstamp) + 1);
1031
1032 format_timestamp_relative(trel, sizeof(trel), t->last_trigger);
1033 passedlen = MAX(passedlen, strlen(trel));
1034 }
1035
1036 unitlen = MAX(unitlen, strlen(t->id));
1037
1038 STRV_FOREACH(a, t->triggered)
1039 ul += strlen(*a) + 2*(a != t->triggered);
1040
1041 activatelen = MAX(activatelen, ul);
1042 }
1043
1044 if (n > 0) {
1045 if (!arg_no_legend)
1046 printf("%-*s %-*s %-*s %-*s %-*s %s\n",
1047 nextlen, "NEXT",
1048 leftlen, "LEFT",
1049 lastlen, "LAST",
1050 passedlen, "PASSED",
1051 unitlen, "UNIT",
1052 "ACTIVATES");
1053
1054 for (t = timer_infos; t < timer_infos + n; t++) {
1055 char tstamp1[FORMAT_TIMESTAMP_MAX] = "n/a", trel1[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
1056 char tstamp2[FORMAT_TIMESTAMP_MAX] = "n/a", trel2[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
1057 char **a;
1058
1059 format_timestamp(tstamp1, sizeof(tstamp1), t->next_elapse);
1060 format_timestamp_relative(trel1, sizeof(trel1), t->next_elapse);
1061
1062 format_timestamp(tstamp2, sizeof(tstamp2), t->last_trigger);
1063 format_timestamp_relative(trel2, sizeof(trel2), t->last_trigger);
1064
1065 printf("%-*s %-*s %-*s %-*s %-*s",
1066 nextlen, tstamp1, leftlen, trel1, lastlen, tstamp2, passedlen, trel2, unitlen, t->id);
1067
1068 STRV_FOREACH(a, t->triggered)
1069 printf("%s %s",
1070 a == t->triggered ? "" : ",", *a);
1071 printf("\n");
1072 }
1073
1074 on = ansi_highlight();
1075 off = ansi_highlight_off();
1076 if (!arg_no_legend)
1077 printf("\n");
1078 } else {
1079 on = ansi_highlight_red();
1080 off = ansi_highlight_off();
1081 }
1082
1083 if (!arg_no_legend) {
1084 printf("%s%u timers listed.%s\n", on, n, off);
1085 if (!arg_all)
1086 printf("Pass --all to see loaded but inactive timers, too.\n");
1087 }
1088
1089 return 0;
1090 }
1091
1092 static usec_t calc_next_elapse(dual_timestamp *nw, dual_timestamp *next) {
1093 usec_t next_elapse;
1094
1095 assert(nw);
1096 assert(next);
1097
1098 if (next->monotonic != (usec_t) -1 && next->monotonic > 0) {
1099 usec_t converted;
1100
1101 if (next->monotonic > nw->monotonic)
1102 converted = nw->realtime + (next->monotonic - nw->monotonic);
1103 else
1104 converted = nw->realtime - (nw->monotonic - next->monotonic);
1105
1106 if (next->realtime != (usec_t) -1 && next->realtime > 0)
1107 next_elapse = MIN(converted, next->realtime);
1108 else
1109 next_elapse = converted;
1110
1111 } else
1112 next_elapse = next->realtime;
1113
1114 return next_elapse;
1115 }
1116
1117 static int list_timers(sd_bus *bus, char **args) {
1118
1119 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1120 _cleanup_free_ struct timer_info *timer_infos = NULL;
1121 _cleanup_free_ UnitInfo *unit_infos = NULL;
1122 struct timer_info *t;
1123 const UnitInfo *u;
1124 size_t size = 0;
1125 int n, c = 0;
1126 dual_timestamp nw;
1127 int r = 0;
1128
1129 pager_open_if_enabled();
1130
1131 n = get_unit_list(bus, NULL, strv_skip_first(args), &unit_infos, 0, &reply);
1132 if (n < 0)
1133 return n;
1134
1135 dual_timestamp_get(&nw);
1136
1137 for (u = unit_infos; u < unit_infos + n; u++) {
1138 _cleanup_strv_free_ char **triggered = NULL;
1139 dual_timestamp next = {};
1140 usec_t m, last = 0;
1141
1142 if (!endswith(u->id, ".timer"))
1143 continue;
1144
1145 r = get_triggered_units(bus, u->unit_path, &triggered);
1146 if (r < 0)
1147 goto cleanup;
1148
1149 r = get_next_elapse(bus, u->unit_path, &next);
1150 if (r < 0)
1151 goto cleanup;
1152
1153 get_last_trigger(bus, u->unit_path, &last);
1154
1155 if (!GREEDY_REALLOC(timer_infos, size, c+1)) {
1156 r = log_oom();
1157 goto cleanup;
1158 }
1159
1160 m = calc_next_elapse(&nw, &next);
1161
1162 timer_infos[c++] = (struct timer_info) {
1163 .id = u->id,
1164 .next_elapse = m,
1165 .last_trigger = last,
1166 .triggered = triggered,
1167 };
1168
1169 triggered = NULL; /* avoid cleanup */
1170 }
1171
1172 qsort_safe(timer_infos, c, sizeof(struct timer_info),
1173 (__compar_fn_t) timer_info_compare);
1174
1175 output_timers_list(timer_infos, c);
1176
1177 cleanup:
1178 for (t = timer_infos; t < timer_infos + c; t++)
1179 strv_free(t->triggered);
1180
1181 return r;
1182 }
1183
1184 static int compare_unit_file_list(const void *a, const void *b) {
1185 const char *d1, *d2;
1186 const UnitFileList *u = a, *v = b;
1187
1188 d1 = strrchr(u->path, '.');
1189 d2 = strrchr(v->path, '.');
1190
1191 if (d1 && d2) {
1192 int r;
1193
1194 r = strcasecmp(d1, d2);
1195 if (r != 0)
1196 return r;
1197 }
1198
1199 return strcasecmp(basename(u->path), basename(v->path));
1200 }
1201
1202 static bool output_show_unit_file(const UnitFileList *u, char **patterns) {
1203 const char *dot;
1204
1205 if (!strv_isempty(patterns)) {
1206 char **pattern;
1207
1208 STRV_FOREACH(pattern, patterns)
1209 if (fnmatch(*pattern, basename(u->path), FNM_NOESCAPE) == 0)
1210 return true;
1211 return false;
1212 }
1213
1214 return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1));
1215 }
1216
1217 static void output_unit_file_list(const UnitFileList *units, unsigned c) {
1218 unsigned max_id_len, id_cols, state_cols;
1219 const UnitFileList *u;
1220
1221 max_id_len = strlen("UNIT FILE");
1222 state_cols = strlen("STATE");
1223
1224 for (u = units; u < units + c; u++) {
1225 max_id_len = MAX(max_id_len, strlen(basename(u->path)));
1226 state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));
1227 }
1228
1229 if (!arg_full) {
1230 unsigned basic_cols;
1231
1232 id_cols = MIN(max_id_len, 25u);
1233 basic_cols = 1 + id_cols + state_cols;
1234 if (basic_cols < (unsigned) columns())
1235 id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);
1236 } else
1237 id_cols = max_id_len;
1238
1239 if (!arg_no_legend)
1240 printf("%-*s %-*s\n",
1241 id_cols, "UNIT FILE",
1242 state_cols, "STATE");
1243
1244 for (u = units; u < units + c; u++) {
1245 _cleanup_free_ char *e = NULL;
1246 const char *on, *off;
1247 const char *id;
1248
1249 if (u->state == UNIT_FILE_MASKED ||
1250 u->state == UNIT_FILE_MASKED_RUNTIME ||
1251 u->state == UNIT_FILE_DISABLED ||
1252 u->state == UNIT_FILE_INVALID) {
1253 on = ansi_highlight_red();
1254 off = ansi_highlight_off();
1255 } else if (u->state == UNIT_FILE_ENABLED) {
1256 on = ansi_highlight_green();
1257 off = ansi_highlight_off();
1258 } else
1259 on = off = "";
1260
1261 id = basename(u->path);
1262
1263 e = arg_full ? NULL : ellipsize(id, id_cols, 33);
1264
1265 printf("%-*s %s%-*s%s\n",
1266 id_cols, e ? e : id,
1267 on, state_cols, unit_file_state_to_string(u->state), off);
1268 }
1269
1270 if (!arg_no_legend)
1271 printf("\n%u unit files listed.\n", c);
1272 }
1273
1274 static int list_unit_files(sd_bus *bus, char **args) {
1275 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1276 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1277 _cleanup_free_ UnitFileList *units = NULL;
1278 UnitFileList *unit;
1279 size_t size = 0;
1280 unsigned c = 0;
1281 const char *state;
1282 char *path;
1283 int r;
1284
1285 pager_open_if_enabled();
1286
1287 if (avoid_bus()) {
1288 Hashmap *h;
1289 UnitFileList *u;
1290 Iterator i;
1291 unsigned n_units;
1292
1293 h = hashmap_new(string_hash_func, string_compare_func);
1294 if (!h)
1295 return log_oom();
1296
1297 r = unit_file_get_list(arg_scope, arg_root, h);
1298 if (r < 0) {
1299 unit_file_list_free(h);
1300 log_error("Failed to get unit file list: %s", strerror(-r));
1301 return r;
1302 }
1303
1304 n_units = hashmap_size(h);
1305 units = new(UnitFileList, n_units);
1306 if (!units) {
1307 unit_file_list_free(h);
1308 return log_oom();
1309 }
1310
1311 HASHMAP_FOREACH(u, h, i) {
1312 if (!output_show_unit_file(u, strv_skip_first(args)))
1313 continue;
1314
1315 units[c++] = *u;
1316 free(u);
1317 }
1318
1319 assert(c <= n_units);
1320 hashmap_free(h);
1321 } else {
1322 r = sd_bus_call_method(
1323 bus,
1324 "org.freedesktop.systemd1",
1325 "/org/freedesktop/systemd1",
1326 "org.freedesktop.systemd1.Manager",
1327 "ListUnitFiles",
1328 &error,
1329 &reply,
1330 NULL);
1331 if (r < 0) {
1332 log_error("Failed to list unit files: %s", bus_error_message(&error, r));
1333 return r;
1334 }
1335
1336 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
1337 if (r < 0)
1338 return bus_log_parse_error(r);
1339
1340 while ((r = sd_bus_message_read(reply, "(ss)", &path, &state)) > 0) {
1341
1342 if (!GREEDY_REALLOC(units, size, c + 1))
1343 return log_oom();
1344
1345 units[c] = (struct UnitFileList) {
1346 path,
1347 unit_file_state_from_string(state)
1348 };
1349
1350 if (output_show_unit_file(&units[c], strv_skip_first(args)))
1351 c ++;
1352
1353 }
1354 if (r < 0)
1355 return bus_log_parse_error(r);
1356
1357 r = sd_bus_message_exit_container(reply);
1358 if (r < 0)
1359 return bus_log_parse_error(r);
1360 }
1361
1362 if (c > 0) {
1363 qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);
1364 output_unit_file_list(units, c);
1365 }
1366
1367 if (avoid_bus())
1368 for (unit = units; unit < units + c; unit++)
1369 free(unit->path);
1370
1371 return 0;
1372 }
1373
1374 static int list_dependencies_print(const char *name, int level, unsigned int branches, bool last) {
1375 _cleanup_free_ char *n = NULL;
1376 size_t max_len = MAX(columns(),20u);
1377 size_t len = 0;
1378 int i;
1379
1380 if (!arg_plain) {
1381
1382 for (i = level - 1; i >= 0; i--) {
1383 len += 2;
1384 if (len > max_len - 3 && !arg_full) {
1385 printf("%s...\n",max_len % 2 ? "" : " ");
1386 return 0;
1387 }
1388 printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERT : DRAW_TREE_SPACE));
1389 }
1390 len += 2;
1391
1392 if (len > max_len - 3 && !arg_full) {
1393 printf("%s...\n",max_len % 2 ? "" : " ");
1394 return 0;
1395 }
1396
1397 printf("%s", draw_special_char(last ? DRAW_TREE_RIGHT : DRAW_TREE_BRANCH));
1398 }
1399
1400 if (arg_full){
1401 printf("%s\n", name);
1402 return 0;
1403 }
1404
1405 n = ellipsize(name, max_len-len, 100);
1406 if (!n)
1407 return log_oom();
1408
1409 printf("%s\n", n);
1410 return 0;
1411 }
1412
1413 static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
1414
1415 static const char *dependencies[_DEPENDENCY_MAX] = {
1416 [DEPENDENCY_FORWARD] = "Requires\0"
1417 "RequiresOverridable\0"
1418 "Requisite\0"
1419 "RequisiteOverridable\0"
1420 "Wants\0",
1421 [DEPENDENCY_REVERSE] = "RequiredBy\0"
1422 "RequiredByOverridable\0"
1423 "WantedBy\0"
1424 "PartOf\0",
1425 [DEPENDENCY_AFTER] = "After\0",
1426 [DEPENDENCY_BEFORE] = "Before\0",
1427 };
1428
1429 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1430 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1431 _cleanup_strv_free_ char **ret = NULL;
1432 _cleanup_free_ char *path = NULL;
1433 int r;
1434
1435 assert(bus);
1436 assert(name);
1437 assert(deps);
1438 assert_cc(ELEMENTSOF(dependencies) == _DEPENDENCY_MAX);
1439
1440 path = unit_dbus_path_from_name(name);
1441 if (!path)
1442 return log_oom();
1443
1444 r = sd_bus_call_method(
1445 bus,
1446 "org.freedesktop.systemd1",
1447 path,
1448 "org.freedesktop.DBus.Properties",
1449 "GetAll",
1450 &error,
1451 &reply,
1452 "s", "org.freedesktop.systemd1.Unit");
1453 if (r < 0) {
1454 log_error("Failed to get properties of %s: %s", name, bus_error_message(&error, r));
1455 return r;
1456 }
1457
1458 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
1459 if (r < 0)
1460 return bus_log_parse_error(r);
1461
1462 while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1463 const char *prop;
1464
1465 r = sd_bus_message_read(reply, "s", &prop);
1466 if (r < 0)
1467 return bus_log_parse_error(r);
1468
1469 if (!nulstr_contains(dependencies[arg_dependency], prop)) {
1470 r = sd_bus_message_skip(reply, "v");
1471 if (r < 0)
1472 return bus_log_parse_error(r);
1473 } else {
1474
1475 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as");
1476 if (r < 0)
1477 return bus_log_parse_error(r);
1478
1479 r = bus_message_read_strv_extend(reply, &ret);
1480 if (r < 0)
1481 return bus_log_parse_error(r);
1482
1483 r = sd_bus_message_exit_container(reply);
1484 if (r < 0)
1485 return bus_log_parse_error(r);
1486 }
1487
1488 r = sd_bus_message_exit_container(reply);
1489 if (r < 0)
1490 return bus_log_parse_error(r);
1491
1492 }
1493 if (r < 0)
1494 return bus_log_parse_error(r);
1495
1496 r = sd_bus_message_exit_container(reply);
1497 if (r < 0)
1498 return bus_log_parse_error(r);
1499
1500 *deps = ret;
1501 ret = NULL;
1502
1503 return 0;
1504 }
1505
1506 static int list_dependencies_compare(const void *_a, const void *_b) {
1507 const char **a = (const char**) _a, **b = (const char**) _b;
1508
1509 if (unit_name_to_type(*a) == UNIT_TARGET && unit_name_to_type(*b) != UNIT_TARGET)
1510 return 1;
1511 if (unit_name_to_type(*a) != UNIT_TARGET && unit_name_to_type(*b) == UNIT_TARGET)
1512 return -1;
1513
1514 return strcasecmp(*a, *b);
1515 }
1516
1517 static int list_dependencies_one(
1518 sd_bus *bus,
1519 const char *name,
1520 int level,
1521 char ***units,
1522 unsigned int branches) {
1523
1524 _cleanup_strv_free_ char **deps = NULL;
1525 char **c;
1526 int r = 0;
1527
1528 assert(bus);
1529 assert(name);
1530 assert(units);
1531
1532 r = strv_extend(units, name);
1533 if (r < 0)
1534 return log_oom();
1535
1536 r = list_dependencies_get_dependencies(bus, name, &deps);
1537 if (r < 0)
1538 return r;
1539
1540 qsort_safe(deps, strv_length(deps), sizeof (char*), list_dependencies_compare);
1541
1542 STRV_FOREACH(c, deps) {
1543 int state;
1544
1545 if (strv_contains(*units, *c)) {
1546 if (!arg_plain) {
1547 r = list_dependencies_print("...", level + 1, (branches << 1) | (c[1] == NULL ? 0 : 1), 1);
1548 if (r < 0)
1549 return r;
1550 }
1551 continue;
1552 }
1553
1554 state = check_one_unit(bus, *c, "activating\0active\0reloading\0", true);
1555 if (state > 0)
1556 printf("%s%s%s", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1557 else
1558 printf("%s%s%s", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1559
1560 r = list_dependencies_print(*c, level, branches, c[1] == NULL);
1561 if (r < 0)
1562 return r;
1563
1564 if (arg_all || unit_name_to_type(*c) == UNIT_TARGET) {
1565 r = list_dependencies_one(bus, *c, level + 1, units, (branches << 1) | (c[1] == NULL ? 0 : 1));
1566 if (r < 0)
1567 return r;
1568 }
1569 }
1570
1571 if (!arg_plain)
1572 strv_remove(*units, name);
1573
1574 return 0;
1575 }
1576
1577 static int list_dependencies(sd_bus *bus, char **args) {
1578 _cleanup_strv_free_ char **units = NULL;
1579 _cleanup_free_ char *unit = NULL;
1580 const char *u;
1581
1582 assert(bus);
1583
1584 if (args[1]) {
1585 unit = unit_name_mangle(args[1], MANGLE_NOGLOB);
1586 if (!unit)
1587 return log_oom();
1588 u = unit;
1589 } else
1590 u = SPECIAL_DEFAULT_TARGET;
1591
1592 pager_open_if_enabled();
1593
1594 puts(u);
1595
1596 return list_dependencies_one(bus, u, 0, &units, 0);
1597 }
1598
1599 struct machine_info {
1600 bool is_host;
1601 char *name;
1602 char *state;
1603 char *control_group;
1604 uint32_t n_failed_units;
1605 uint32_t n_jobs;
1606 usec_t timestamp;
1607 };
1608
1609 static const struct bus_properties_map machine_info_property_map[] = {
1610 { "SystemState", "s", NULL, offsetof(struct machine_info, state) },
1611 { "NJobs", "u", NULL, offsetof(struct machine_info, n_jobs) },
1612 { "NFailedUnits", "u", NULL, offsetof(struct machine_info, n_failed_units) },
1613 { "ControlGroup", "s", NULL, offsetof(struct machine_info, control_group) },
1614 { "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp) },
1615 {}
1616 };
1617
1618 static void free_machines_list(struct machine_info *machine_infos, int n) {
1619 int i;
1620
1621 if (!machine_infos)
1622 return;
1623
1624 for (i = 0; i < n; i++) {
1625 free(machine_infos[i].name);
1626 free(machine_infos[i].state);
1627 free(machine_infos[i].control_group);
1628 }
1629
1630 free(machine_infos);
1631 }
1632
1633 static int compare_machine_info(const void *a, const void *b) {
1634 const struct machine_info *u = a, *v = b;
1635
1636 if (u->is_host != v->is_host)
1637 return u->is_host > v->is_host ? -1 : 1;
1638
1639 return strcasecmp(u->name, v->name);
1640 }
1641
1642 static int get_machine_properties(sd_bus *bus, struct machine_info *mi) {
1643 _cleanup_bus_unref_ sd_bus *container = NULL;
1644 int r;
1645
1646 assert(mi);
1647
1648 if (!bus) {
1649 r = sd_bus_open_system_container(&container, mi->name);
1650 if (r < 0)
1651 return r;
1652
1653 bus = container;
1654 }
1655
1656 r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, mi);
1657 if (r < 0)
1658 return r;
1659
1660 return 0;
1661 }
1662
1663 static bool output_show_machine(const char *name, char **patterns) {
1664 char **i;
1665
1666 assert(name);
1667
1668 if (strv_isempty(patterns))
1669 return true;
1670
1671 STRV_FOREACH(i, patterns)
1672 if (fnmatch(*i, name, FNM_NOESCAPE) == 0)
1673 return true;
1674
1675 return false;
1676 }
1677
1678 static int get_machine_list(
1679 sd_bus *bus,
1680 struct machine_info **_machine_infos,
1681 char **patterns) {
1682
1683 struct machine_info *machine_infos = NULL;
1684 _cleanup_strv_free_ char **m = NULL;
1685 _cleanup_free_ char *hn = NULL;
1686 size_t sz = 0;
1687 char **i;
1688 int c = 0;
1689
1690 hn = gethostname_malloc();
1691 if (!hn)
1692 return log_oom();
1693
1694 if (output_show_machine(hn, patterns)) {
1695 if (!GREEDY_REALLOC0(machine_infos, sz, c+1))
1696 return log_oom();
1697
1698 machine_infos[c].is_host = true;
1699 machine_infos[c].name = hn;
1700 hn = NULL;
1701
1702 get_machine_properties(bus, &machine_infos[c]);
1703 c++;
1704 }
1705
1706 sd_get_machine_names(&m);
1707 STRV_FOREACH(i, m) {
1708 _cleanup_free_ char *class = NULL;
1709
1710 if (!output_show_machine(*i, patterns))
1711 continue;
1712
1713 sd_machine_get_class(*i, &class);
1714 if (!streq_ptr(class, "container"))
1715 continue;
1716
1717 if (!GREEDY_REALLOC0(machine_infos, sz, c+1)) {
1718 free_machines_list(machine_infos, c);
1719 return log_oom();
1720 }
1721
1722 machine_infos[c].is_host = false;
1723 machine_infos[c].name = strdup(*i);
1724 if (!machine_infos[c].name) {
1725 free_machines_list(machine_infos, c);
1726 return log_oom();
1727 }
1728
1729 get_machine_properties(NULL, &machine_infos[c]);
1730 c++;
1731 }
1732
1733 *_machine_infos = machine_infos;
1734 return c;
1735 }
1736
1737 static void output_machines_list(struct machine_info *machine_infos, unsigned n) {
1738 struct machine_info *m;
1739 unsigned
1740 circle_len = 0,
1741 namelen = sizeof("NAME") - 1,
1742 statelen = sizeof("STATE") - 1,
1743 failedlen = sizeof("FAILED") - 1,
1744 jobslen = sizeof("JOBS") - 1;
1745
1746 assert(machine_infos || n == 0);
1747
1748 for (m = machine_infos; m < machine_infos + n; m++) {
1749 namelen = MAX(namelen, strlen(m->name) + (m->is_host ? sizeof(" (host)") - 1 : 0));
1750 statelen = MAX(statelen, m->state ? strlen(m->state) : 0);
1751 failedlen = MAX(failedlen, DECIMAL_STR_WIDTH(m->n_failed_units));
1752 jobslen = MAX(jobslen, DECIMAL_STR_WIDTH(m->n_jobs));
1753
1754 if (!arg_no_legend && !streq_ptr(m->state, "running"))
1755 circle_len = 2;
1756 }
1757
1758 if (!arg_no_legend) {
1759 if (circle_len > 0)
1760 fputs(" ", stdout);
1761
1762 printf("%-*s %-*s %-*s %-*s\n",
1763 namelen, "NAME",
1764 statelen, "STATE",
1765 failedlen, "FAILED",
1766 jobslen, "JOBS");
1767 }
1768
1769 for (m = machine_infos; m < machine_infos + n; m++) {
1770 const char *on_state = "", *off_state = "";
1771 const char *on_failed = "", *off_failed = "";
1772 bool circle = false;
1773
1774 if (streq_ptr(m->state, "degraded")) {
1775 on_state = ansi_highlight_red();
1776 off_state = ansi_highlight_off();
1777 circle = true;
1778 } else if (!streq_ptr(m->state, "running")) {
1779 on_state = ansi_highlight_yellow();
1780 off_state = ansi_highlight_off();
1781 circle = true;
1782 }
1783
1784 if (m->n_failed_units > 0) {
1785 on_failed = ansi_highlight_red();
1786 off_failed = ansi_highlight_off();
1787 } else
1788 on_failed = off_failed = "";
1789
1790 if (circle_len > 0)
1791 printf("%s%s%s", on_state, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_state);
1792
1793 if (m->is_host)
1794 printf("%-*s (host) %s%-*s%s %s%*u%s %*u\n",
1795 (int) (namelen - (sizeof(" (host)")-1)), strna(m->name),
1796 on_state, statelen, strna(m->state), off_state,
1797 on_failed, failedlen, m->n_failed_units, off_failed,
1798 jobslen, m->n_jobs);
1799 else
1800 printf("%-*s %s%-*s%s %s%*u%s %*u\n",
1801 namelen, strna(m->name),
1802 on_state, statelen, strna(m->state), off_state,
1803 on_failed, failedlen, m->n_failed_units, off_failed,
1804 jobslen, m->n_jobs);
1805 }
1806
1807 if (!arg_no_legend)
1808 printf("\n%u machines listed.\n", n);
1809 }
1810
1811 static int list_machines(sd_bus *bus, char **args) {
1812 struct machine_info *machine_infos = NULL;
1813 int r;
1814
1815 assert(bus);
1816
1817 if (geteuid() != 0) {
1818 log_error("Must be root.");
1819 return -EPERM;
1820 }
1821
1822 pager_open_if_enabled();
1823
1824 r = get_machine_list(bus, &machine_infos, strv_skip_first(args));
1825 if (r < 0)
1826 return r;
1827
1828 qsort_safe(machine_infos, r, sizeof(struct machine_info), compare_machine_info);
1829 output_machines_list(machine_infos, r);
1830 free_machines_list(machine_infos, r);
1831
1832 return 0;
1833 }
1834
1835 static int get_default(sd_bus *bus, char **args) {
1836 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1837 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1838 _cleanup_free_ char *_path = NULL;
1839 const char *path;
1840 int r;
1841
1842 if (!bus || avoid_bus()) {
1843 r = unit_file_get_default(arg_scope, arg_root, &_path);
1844 if (r < 0) {
1845 log_error("Failed to get default target: %s", strerror(-r));
1846 return r;
1847 }
1848 path = _path;
1849
1850 } else {
1851 r = sd_bus_call_method(
1852 bus,
1853 "org.freedesktop.systemd1",
1854 "/org/freedesktop/systemd1",
1855 "org.freedesktop.systemd1.Manager",
1856 "GetDefaultTarget",
1857 &error,
1858 &reply,
1859 NULL);
1860 if (r < 0) {
1861 log_error("Failed to get default target: %s", bus_error_message(&error, -r));
1862 return r;
1863 }
1864
1865 r = sd_bus_message_read(reply, "s", &path);
1866 if (r < 0)
1867 return bus_log_parse_error(r);
1868 }
1869
1870 if (path)
1871 printf("%s\n", path);
1872
1873 return 0;
1874 }
1875
1876 static void dump_unit_file_changes(const UnitFileChange *changes, unsigned n_changes) {
1877 unsigned i;
1878
1879 assert(changes || n_changes == 0);
1880
1881 for (i = 0; i < n_changes; i++) {
1882 if (changes[i].type == UNIT_FILE_SYMLINK)
1883 log_info("ln -s '%s' '%s'", changes[i].source, changes[i].path);
1884 else
1885 log_info("rm '%s'", changes[i].path);
1886 }
1887 }
1888
1889 static int deserialize_and_dump_unit_file_changes(sd_bus_message *m) {
1890 const char *type, *path, *source;
1891 int r;
1892
1893 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
1894 if (r < 0)
1895 return bus_log_parse_error(r);
1896
1897 while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
1898 if (!arg_quiet) {
1899 if (streq(type, "symlink"))
1900 log_info("ln -s '%s' '%s'", source, path);
1901 else
1902 log_info("rm '%s'", path);
1903 }
1904 }
1905 if (r < 0)
1906 return bus_log_parse_error(r);
1907
1908 r = sd_bus_message_exit_container(m);
1909 if (r < 0)
1910 return bus_log_parse_error(r);
1911
1912 return 0;
1913 }
1914
1915 static int set_default(sd_bus *bus, char **args) {
1916 _cleanup_free_ char *unit = NULL;
1917 UnitFileChange *changes = NULL;
1918 unsigned n_changes = 0;
1919 int r;
1920
1921 unit = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");
1922 if (!unit)
1923 return log_oom();
1924
1925 if (!bus || avoid_bus()) {
1926 r = unit_file_set_default(arg_scope, arg_root, unit, arg_force, &changes, &n_changes);
1927 if (r < 0) {
1928 log_error("Failed to set default target: %s", strerror(-r));
1929 return r;
1930 }
1931
1932 if (!arg_quiet)
1933 dump_unit_file_changes(changes, n_changes);
1934
1935 r = 0;
1936 } else {
1937 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1938 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1939
1940 r = sd_bus_call_method(
1941 bus,
1942 "org.freedesktop.systemd1",
1943 "/org/freedesktop/systemd1",
1944 "org.freedesktop.systemd1.Manager",
1945 "SetDefaultTarget",
1946 &error,
1947 &reply,
1948 "sb", unit, arg_force);
1949 if (r < 0) {
1950 log_error("Failed to set default target: %s", bus_error_message(&error, -r));
1951 return r;
1952 }
1953
1954 r = deserialize_and_dump_unit_file_changes(reply);
1955 if (r < 0)
1956 return r;
1957
1958 /* Try to reload if enabeld */
1959 if (!arg_no_reload)
1960 r = daemon_reload(bus, args);
1961 else
1962 r = 0;
1963 }
1964
1965 unit_file_changes_free(changes, n_changes);
1966
1967 return r;
1968 }
1969
1970 struct job_info {
1971 uint32_t id;
1972 const char *name, *type, *state;
1973 };
1974
1975 static void output_jobs_list(const struct job_info* jobs, unsigned n, bool skipped) {
1976 unsigned id_len, unit_len, type_len, state_len;
1977 const struct job_info *j;
1978 const char *on, *off;
1979 bool shorten = false;
1980
1981 assert(n == 0 || jobs);
1982
1983 if (n == 0) {
1984 on = ansi_highlight_green();
1985 off = ansi_highlight_off();
1986
1987 printf("%sNo jobs %s.%s\n", on, skipped ? "listed" : "running", off);
1988 return;
1989 }
1990
1991 pager_open_if_enabled();
1992
1993 id_len = strlen("JOB");
1994 unit_len = strlen("UNIT");
1995 type_len = strlen("TYPE");
1996 state_len = strlen("STATE");
1997
1998 for (j = jobs; j < jobs + n; j++) {
1999 uint32_t id = j->id;
2000 assert(j->name && j->type && j->state);
2001
2002 id_len = MAX(id_len, DECIMAL_STR_WIDTH(id));
2003 unit_len = MAX(unit_len, strlen(j->name));
2004 type_len = MAX(type_len, strlen(j->type));
2005 state_len = MAX(state_len, strlen(j->state));
2006 }
2007
2008 if (!arg_full && id_len + 1 + unit_len + type_len + 1 + state_len > columns()) {
2009 unit_len = MAX(33u, columns() - id_len - type_len - state_len - 3);
2010 shorten = true;
2011 }
2012
2013 if (!arg_no_legend)
2014 printf("%*s %-*s %-*s %-*s\n",
2015 id_len, "JOB",
2016 unit_len, "UNIT",
2017 type_len, "TYPE",
2018 state_len, "STATE");
2019
2020 for (j = jobs; j < jobs + n; j++) {
2021 _cleanup_free_ char *e = NULL;
2022
2023 if (streq(j->state, "running")) {
2024 on = ansi_highlight();
2025 off = ansi_highlight_off();
2026 } else
2027 on = off = "";
2028
2029 e = shorten ? ellipsize(j->name, unit_len, 33) : NULL;
2030 printf("%*u %s%-*s%s %-*s %s%-*s%s\n",
2031 id_len, j->id,
2032 on, unit_len, e ? e : j->name, off,
2033 type_len, j->type,
2034 on, state_len, j->state, off);
2035 }
2036
2037 if (!arg_no_legend) {
2038 on = ansi_highlight();
2039 off = ansi_highlight_off();
2040
2041 printf("\n%s%u jobs listed%s.\n", on, n, off);
2042 }
2043 }
2044
2045 static bool output_show_job(struct job_info *job, char **patterns) {
2046 char **pattern;
2047
2048 assert(job);
2049
2050 if (strv_isempty(patterns))
2051 return true;
2052
2053 STRV_FOREACH(pattern, patterns)
2054 if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)
2055 return true;
2056 return false;
2057 }
2058
2059 static int list_jobs(sd_bus *bus, char **args) {
2060 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2061 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2062 const char *name, *type, *state, *job_path, *unit_path;
2063 _cleanup_free_ struct job_info *jobs = NULL;
2064 size_t size = 0;
2065 unsigned c = 0;
2066 uint32_t id;
2067 int r;
2068 bool skipped = false;
2069
2070 r = sd_bus_call_method(
2071 bus,
2072 "org.freedesktop.systemd1",
2073 "/org/freedesktop/systemd1",
2074 "org.freedesktop.systemd1.Manager",
2075 "ListJobs",
2076 &error,
2077 &reply,
2078 NULL);
2079 if (r < 0) {
2080 log_error("Failed to list jobs: %s", bus_error_message(&error, r));
2081 return r;
2082 }
2083
2084 r = sd_bus_message_enter_container(reply, 'a', "(usssoo)");
2085 if (r < 0)
2086 return bus_log_parse_error(r);
2087
2088 while ((r = sd_bus_message_read(reply, "(usssoo)", &id, &name, &type, &state, &job_path, &unit_path)) > 0) {
2089 struct job_info job = { id, name, type, state };
2090
2091 if (!output_show_job(&job, strv_skip_first(args))) {
2092 skipped = true;
2093 continue;
2094 }
2095
2096 if (!GREEDY_REALLOC(jobs, size, c + 1))
2097 return log_oom();
2098
2099 jobs[c++] = job;
2100 }
2101 if (r < 0)
2102 return bus_log_parse_error(r);
2103
2104 r = sd_bus_message_exit_container(reply);
2105 if (r < 0)
2106 return bus_log_parse_error(r);
2107
2108 output_jobs_list(jobs, c, skipped);
2109 return r;
2110 }
2111
2112 static int cancel_job(sd_bus *bus, char **args) {
2113 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2114 char **name;
2115
2116 assert(args);
2117
2118 if (strv_length(args) <= 1)
2119 return daemon_reload(bus, args);
2120
2121 STRV_FOREACH(name, args+1) {
2122 uint32_t id;
2123 int r;
2124
2125 r = safe_atou32(*name, &id);
2126 if (r < 0) {
2127 log_error("Failed to parse job id \"%s\": %s", *name, strerror(-r));
2128 return r;
2129 }
2130
2131 r = sd_bus_call_method(
2132 bus,
2133 "org.freedesktop.systemd1",
2134 "/org/freedesktop/systemd1",
2135 "org.freedesktop.systemd1.Manager",
2136 "CancelJob",
2137 &error,
2138 NULL,
2139 "u", id);
2140 if (r < 0) {
2141 log_error("Failed to cancel job %u: %s", (unsigned) id, bus_error_message(&error, r));
2142 return r;
2143 }
2144 }
2145
2146 return 0;
2147 }
2148
2149 static int need_daemon_reload(sd_bus *bus, const char *unit) {
2150 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2151 const char *path;
2152 int b, r;
2153
2154 /* We ignore all errors here, since this is used to show a
2155 * warning only */
2156
2157 /* We don't use unit_dbus_path_from_name() directly since we
2158 * don't want to load the unit if it isn't loaded. */
2159
2160 r = sd_bus_call_method(
2161 bus,
2162 "org.freedesktop.systemd1",
2163 "/org/freedesktop/systemd1",
2164 "org.freedesktop.systemd1.Manager",
2165 "GetUnit",
2166 NULL,
2167 &reply,
2168 "s", unit);
2169 if (r < 0)
2170 return r;
2171
2172 r = sd_bus_message_read(reply, "o", &path);
2173 if (r < 0)
2174 return r;
2175
2176 r = sd_bus_get_property_trivial(
2177 bus,
2178 "org.freedesktop.systemd1",
2179 path,
2180 "org.freedesktop.systemd1.Unit",
2181 "NeedDaemonReload",
2182 NULL,
2183 'b', &b);
2184 if (r < 0)
2185 return r;
2186
2187 return b;
2188 }
2189
2190 typedef struct WaitData {
2191 Set *set;
2192
2193 char *name;
2194 char *result;
2195 } WaitData;
2196
2197 static int wait_filter(sd_bus *bus, sd_bus_message *m, void *data, sd_bus_error *error) {
2198 WaitData *d = data;
2199
2200 assert(bus);
2201 assert(m);
2202 assert(d);
2203
2204 log_debug("Got D-Bus request: %s.%s() on %s",
2205 sd_bus_message_get_interface(m),
2206 sd_bus_message_get_member(m),
2207 sd_bus_message_get_path(m));
2208
2209 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
2210 log_error("Warning! D-Bus connection terminated.");
2211 sd_bus_close(bus);
2212 } else if (sd_bus_message_is_signal(m, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
2213 uint32_t id;
2214 const char *path, *result, *unit;
2215 char *ret;
2216 int r;
2217
2218 r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
2219 if (r >= 0) {
2220 ret = set_remove(d->set, (char*) path);
2221 if (!ret)
2222 return 0;
2223
2224 free(ret);
2225
2226 if (!isempty(result))
2227 d->result = strdup(result);
2228
2229 if (!isempty(unit))
2230 d->name = strdup(unit);
2231
2232 return 0;
2233 }
2234 #ifndef NOLEGACY
2235 r = sd_bus_message_read(m, "uos", &id, &path, &result);
2236 if (r >= 0) {
2237 ret = set_remove(d->set, (char*) path);
2238 if (!ret)
2239 return 0;
2240
2241 free(ret);
2242
2243 if (*result)
2244 d->result = strdup(result);
2245
2246 return 0;
2247 }
2248 #endif
2249
2250 bus_log_parse_error(r);
2251 }
2252
2253 return 0;
2254 }
2255
2256 static int enable_wait_for_jobs(sd_bus *bus) {
2257 int r;
2258
2259 assert(bus);
2260
2261 r = sd_bus_add_match(
2262 bus,
2263 "type='signal',"
2264 "sender='org.freedesktop.systemd1',"
2265 "interface='org.freedesktop.systemd1.Manager',"
2266 "member='JobRemoved',"
2267 "path='/org/freedesktop/systemd1'",
2268 NULL, NULL);
2269 if (r < 0) {
2270 log_error("Failed to add match");
2271 return -EIO;
2272 }
2273
2274 /* This is slightly dirty, since we don't undo the match registrations. */
2275 return 0;
2276 }
2277
2278 static int bus_process_wait(sd_bus *bus) {
2279 int r;
2280
2281 for (;;) {
2282 r = sd_bus_process(bus, NULL);
2283 if (r < 0)
2284 return r;
2285 if (r > 0)
2286 return 0;
2287 r = sd_bus_wait(bus, (uint64_t) -1);
2288 if (r < 0)
2289 return r;
2290 }
2291 }
2292
2293 static int check_wait_response(WaitData *d) {
2294 int r = 0;
2295
2296 assert(d->result);
2297
2298 if (!arg_quiet) {
2299 if (streq(d->result, "timeout"))
2300 log_error("Job for %s timed out.", strna(d->name));
2301 else if (streq(d->result, "canceled"))
2302 log_error("Job for %s canceled.", strna(d->name));
2303 else if (streq(d->result, "dependency"))
2304 log_error("A dependency job for %s failed. See 'journalctl -xn' for details.", strna(d->name));
2305 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2306 log_error("Job for %s failed. See 'systemctl status %s' and 'journalctl -xn' for details.", strna(d->name), strna(d->name));
2307 }
2308
2309 if (streq(d->result, "timeout"))
2310 r = -ETIME;
2311 else if (streq(d->result, "canceled"))
2312 r = -ECANCELED;
2313 else if (streq(d->result, "dependency"))
2314 r = -EIO;
2315 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2316 r = -EIO;
2317
2318 return r;
2319 }
2320
2321 static int wait_for_jobs(sd_bus *bus, Set *s) {
2322 WaitData d = { .set = s };
2323 int r = 0, q;
2324
2325 assert(bus);
2326 assert(s);
2327
2328 q = sd_bus_add_filter(bus, wait_filter, &d);
2329 if (q < 0)
2330 return log_oom();
2331
2332 while (!set_isempty(s)) {
2333 q = bus_process_wait(bus);
2334 if (q < 0) {
2335 log_error("Failed to wait for response: %s", strerror(-r));
2336 return q;
2337 }
2338
2339 if (d.result) {
2340 q = check_wait_response(&d);
2341 /* Return the first error as it is most likely to be
2342 * meaningful. */
2343 if (q < 0 && r == 0)
2344 r = q;
2345 log_debug("Got result %s/%s for job %s",
2346 strna(d.result), strerror(-q), strna(d.name));
2347 }
2348
2349 free(d.name);
2350 d.name = NULL;
2351
2352 free(d.result);
2353 d.result = NULL;
2354 }
2355
2356 q = sd_bus_remove_filter(bus, wait_filter, &d);
2357 if (q < 0 && r == 0)
2358 r = q;
2359
2360 return r;
2361 }
2362
2363 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet) {
2364 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2365 _cleanup_free_ char *n = NULL, *state = NULL;
2366 const char *path;
2367 int r;
2368
2369 assert(name);
2370
2371 n = unit_name_mangle(name, MANGLE_NOGLOB);
2372 if (!n)
2373 return log_oom();
2374
2375 /* We don't use unit_dbus_path_from_name() directly since we
2376 * don't want to load the unit if it isn't loaded. */
2377
2378 r = sd_bus_call_method(
2379 bus,
2380 "org.freedesktop.systemd1",
2381 "/org/freedesktop/systemd1",
2382 "org.freedesktop.systemd1.Manager",
2383 "GetUnit",
2384 NULL,
2385 &reply,
2386 "s", n);
2387 if (r < 0) {
2388 if (!quiet)
2389 puts("unknown");
2390 return 0;
2391 }
2392
2393 r = sd_bus_message_read(reply, "o", &path);
2394 if (r < 0)
2395 return bus_log_parse_error(r);
2396
2397 r = sd_bus_get_property_string(
2398 bus,
2399 "org.freedesktop.systemd1",
2400 path,
2401 "org.freedesktop.systemd1.Unit",
2402 "ActiveState",
2403 NULL,
2404 &state);
2405 if (r < 0) {
2406 if (!quiet)
2407 puts("unknown");
2408 return 0;
2409 }
2410
2411 if (!quiet)
2412 puts(state);
2413
2414 return nulstr_contains(good_states, state);
2415 }
2416
2417 static int check_triggering_units(
2418 sd_bus *bus,
2419 const char *name) {
2420
2421 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2422 _cleanup_free_ char *path = NULL, *n = NULL, *state = NULL;
2423 _cleanup_strv_free_ char **triggered_by = NULL;
2424 bool print_warning_label = true;
2425 char **i;
2426 int r;
2427
2428 n = unit_name_mangle(name, MANGLE_NOGLOB);
2429 if (!n)
2430 return log_oom();
2431
2432 path = unit_dbus_path_from_name(n);
2433 if (!path)
2434 return log_oom();
2435
2436 r = sd_bus_get_property_string(
2437 bus,
2438 "org.freedesktop.systemd1",
2439 path,
2440 "org.freedesktop.systemd1.Unit",
2441 "LoadState",
2442 &error,
2443 &state);
2444 if (r < 0) {
2445 log_error("Failed to get load state of %s: %s", n, bus_error_message(&error, r));
2446 return r;
2447 }
2448
2449 if (streq(state, "masked"))
2450 return 0;
2451
2452 r = sd_bus_get_property_strv(
2453 bus,
2454 "org.freedesktop.systemd1",
2455 path,
2456 "org.freedesktop.systemd1.Unit",
2457 "TriggeredBy",
2458 &error,
2459 &triggered_by);
2460 if (r < 0) {
2461 log_error("Failed to get triggered by array of %s: %s", n, bus_error_message(&error, r));
2462 return r;
2463 }
2464
2465 STRV_FOREACH(i, triggered_by) {
2466 r = check_one_unit(bus, *i, "active\0reloading\0", true);
2467 if (r < 0) {
2468 log_error("Failed to check unit: %s", strerror(-r));
2469 return r;
2470 }
2471
2472 if (r == 0)
2473 continue;
2474
2475 if (print_warning_label) {
2476 log_warning("Warning: Stopping %s, but it can still be activated by:", n);
2477 print_warning_label = false;
2478 }
2479
2480 log_warning(" %s", *i);
2481 }
2482
2483 return 0;
2484 }
2485
2486 static const char *verb_to_method(const char *verb) {
2487 uint i;
2488
2489 for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2490 if (streq_ptr(unit_actions[i].verb, verb))
2491 return unit_actions[i].method;
2492
2493 return "StartUnit";
2494 }
2495
2496 static const char *method_to_verb(const char *method) {
2497 uint i;
2498
2499 for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2500 if (streq_ptr(unit_actions[i].method, method))
2501 return unit_actions[i].verb;
2502
2503 return "n/a";
2504 }
2505
2506 static int start_unit_one(
2507 sd_bus *bus,
2508 const char *method,
2509 const char *name,
2510 const char *mode,
2511 sd_bus_error *error,
2512 Set *s) {
2513
2514 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2515 const char *path;
2516 int r;
2517
2518 assert(method);
2519 assert(name);
2520 assert(mode);
2521 assert(error);
2522
2523 log_debug("Calling manager for %s on %s, %s", method, name, mode);
2524 r = sd_bus_call_method(
2525 bus,
2526 "org.freedesktop.systemd1",
2527 "/org/freedesktop/systemd1",
2528 "org.freedesktop.systemd1.Manager",
2529 method,
2530 error,
2531 &reply,
2532 "ss", name, mode);
2533 if (r < 0) {
2534 const char *verb;
2535
2536 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
2537 /* There's always a fallback possible for
2538 * legacy actions. */
2539 return -EADDRNOTAVAIL;
2540
2541 verb = method_to_verb(method);
2542
2543 log_error("Failed to %s %s: %s", verb, name, bus_error_message(error, r));
2544 return r;
2545 }
2546
2547 r = sd_bus_message_read(reply, "o", &path);
2548 if (r < 0)
2549 return bus_log_parse_error(r);
2550
2551 if (need_daemon_reload(bus, name) > 0)
2552 log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
2553 name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
2554
2555 if (s) {
2556 char *p;
2557
2558 p = strdup(path);
2559 if (!p)
2560 return log_oom();
2561
2562 log_debug("Adding %s to the set", p);
2563 r = set_consume(s, p);
2564 if (r < 0)
2565 return log_oom();
2566 }
2567
2568 return 0;
2569 }
2570
2571 static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
2572
2573 _cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
2574 char **name;
2575 int r = 0, i;
2576
2577 STRV_FOREACH(name, names) {
2578 char *t;
2579
2580 if (suffix)
2581 t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);
2582 else
2583 t = unit_name_mangle(*name, MANGLE_GLOB);
2584 if (!t)
2585 return log_oom();
2586
2587 if (string_is_glob(t))
2588 r = strv_consume(&globs, t);
2589 else
2590 r = strv_consume(&mangled, t);
2591 if (r < 0)
2592 return log_oom();
2593 }
2594
2595 /* Query the manager only if any of the names are a glob, since
2596 * this is fairly expensive */
2597 if (!strv_isempty(globs)) {
2598 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2599 _cleanup_free_ UnitInfo *unit_infos = NULL;
2600
2601 r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
2602 if (r < 0)
2603 return r;
2604
2605 for (i = 0; i < r; i++)
2606 if (strv_extend(&mangled, unit_infos[i].id) < 0)
2607 return log_oom();
2608 }
2609
2610 *ret = mangled;
2611 mangled = NULL; /* do not free */
2612
2613 return 0;
2614 }
2615
2616 static const struct {
2617 const char *target;
2618 const char *verb;
2619 const char *mode;
2620 } action_table[_ACTION_MAX] = {
2621 [ACTION_HALT] = { SPECIAL_HALT_TARGET, "halt", "replace-irreversibly" },
2622 [ACTION_POWEROFF] = { SPECIAL_POWEROFF_TARGET, "poweroff", "replace-irreversibly" },
2623 [ACTION_REBOOT] = { SPECIAL_REBOOT_TARGET, "reboot", "replace-irreversibly" },
2624 [ACTION_KEXEC] = { SPECIAL_KEXEC_TARGET, "kexec", "replace-irreversibly" },
2625 [ACTION_RUNLEVEL2] = { SPECIAL_RUNLEVEL2_TARGET, NULL, "isolate" },
2626 [ACTION_RUNLEVEL3] = { SPECIAL_RUNLEVEL3_TARGET, NULL, "isolate" },
2627 [ACTION_RUNLEVEL4] = { SPECIAL_RUNLEVEL4_TARGET, NULL, "isolate" },
2628 [ACTION_RUNLEVEL5] = { SPECIAL_RUNLEVEL5_TARGET, NULL, "isolate" },
2629 [ACTION_RESCUE] = { SPECIAL_RESCUE_TARGET, "rescue", "isolate" },
2630 [ACTION_EMERGENCY] = { SPECIAL_EMERGENCY_TARGET, "emergency", "isolate" },
2631 [ACTION_DEFAULT] = { SPECIAL_DEFAULT_TARGET, "default", "isolate" },
2632 [ACTION_EXIT] = { SPECIAL_EXIT_TARGET, "exit", "replace-irreversibly" },
2633 [ACTION_SUSPEND] = { SPECIAL_SUSPEND_TARGET, "suspend", "replace-irreversibly" },
2634 [ACTION_HIBERNATE] = { SPECIAL_HIBERNATE_TARGET, "hibernate", "replace-irreversibly" },
2635 [ACTION_HYBRID_SLEEP] = { SPECIAL_HYBRID_SLEEP_TARGET, "hybrid-sleep", "replace-irreversibly" },
2636 };
2637
2638 static enum action verb_to_action(const char *verb) {
2639 enum action i;
2640
2641 for (i = _ACTION_INVALID; i < _ACTION_MAX; i++)
2642 if (streq_ptr(action_table[i].verb, verb))
2643 return i;
2644
2645 return _ACTION_INVALID;
2646 }
2647
2648 static int start_unit(sd_bus *bus, char **args) {
2649 _cleanup_set_free_free_ Set *s = NULL;
2650 _cleanup_strv_free_ char **names = NULL;
2651 const char *method, *mode, *one_name;
2652 char **name;
2653 int r = 0;
2654
2655 assert(bus);
2656
2657 ask_password_agent_open_if_enabled();
2658
2659 if (arg_action == ACTION_SYSTEMCTL) {
2660 enum action action;
2661 method = verb_to_method(args[0]);
2662 action = verb_to_action(args[0]);
2663
2664 mode = streq(args[0], "isolate") ? "isolate" :
2665 action_table[action].mode ?: arg_job_mode;
2666
2667 one_name = action_table[action].target;
2668 } else {
2669 assert(arg_action < ELEMENTSOF(action_table));
2670 assert(action_table[arg_action].target);
2671
2672 method = "StartUnit";
2673
2674 mode = action_table[arg_action].mode;
2675 one_name = action_table[arg_action].target;
2676 }
2677
2678 if (one_name)
2679 names = strv_new(one_name, NULL);
2680 else {
2681 r = expand_names(bus, args + 1, NULL, &names);
2682 if (r < 0)
2683 log_error("Failed to expand names: %s", strerror(-r));
2684 }
2685
2686 if (!arg_no_block) {
2687 r = enable_wait_for_jobs(bus);
2688 if (r < 0) {
2689 log_error("Could not watch jobs: %s", strerror(-r));
2690 return r;
2691 }
2692
2693 s = set_new(string_hash_func, string_compare_func);
2694 if (!s)
2695 return log_oom();
2696 }
2697
2698 STRV_FOREACH(name, names) {
2699 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2700 int q;
2701
2702 q = start_unit_one(bus, method, *name, mode, &error, s);
2703 if (r >= 0 && q < 0)
2704 r = translate_bus_error_to_exit_status(q, &error);
2705 }
2706
2707 if (!arg_no_block) {
2708 int q;
2709
2710 q = wait_for_jobs(bus, s);
2711 if (q < 0)
2712 return q;
2713
2714 /* When stopping units, warn if they can still be triggered by
2715 * another active unit (socket, path, timer) */
2716 if (!arg_quiet && streq(method, "StopUnit"))
2717 STRV_FOREACH(name, names)
2718 check_triggering_units(bus, *name);
2719 }
2720
2721 return r;
2722 }
2723
2724 /* Ask systemd-logind, which might grant access to unprivileged users
2725 * through PolicyKit */
2726 static int reboot_with_logind(sd_bus *bus, enum action a) {
2727 #ifdef HAVE_LOGIND
2728 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2729 const char *method;
2730 int r;
2731
2732 if (!bus)
2733 return -EIO;
2734
2735 polkit_agent_open_if_enabled();
2736
2737 switch (a) {
2738
2739 case ACTION_REBOOT:
2740 method = "Reboot";
2741 break;
2742
2743 case ACTION_POWEROFF:
2744 method = "PowerOff";
2745 break;
2746
2747 case ACTION_SUSPEND:
2748 method = "Suspend";
2749 break;
2750
2751 case ACTION_HIBERNATE:
2752 method = "Hibernate";
2753 break;
2754
2755 case ACTION_HYBRID_SLEEP:
2756 method = "HybridSleep";
2757 break;
2758
2759 default:
2760 return -EINVAL;
2761 }
2762
2763 r = sd_bus_call_method(
2764 bus,
2765 "org.freedesktop.login1",
2766 "/org/freedesktop/login1",
2767 "org.freedesktop.login1.Manager",
2768 method,
2769 &error,
2770 NULL,
2771 "b", true);
2772 if (r < 0)
2773 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
2774
2775 return r;
2776 #else
2777 return -ENOSYS;
2778 #endif
2779 }
2780
2781 static int check_inhibitors(sd_bus *bus, enum action a) {
2782 #ifdef HAVE_LOGIND
2783 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2784 _cleanup_strv_free_ char **sessions = NULL;
2785 const char *what, *who, *why, *mode;
2786 uint32_t uid, pid;
2787 unsigned c = 0;
2788 char **s;
2789 int r;
2790
2791 if (!bus)
2792 return 0;
2793
2794 if (arg_ignore_inhibitors || arg_force > 0)
2795 return 0;
2796
2797 if (arg_when > 0)
2798 return 0;
2799
2800 if (geteuid() == 0)
2801 return 0;
2802
2803 if (!on_tty())
2804 return 0;
2805
2806 r = sd_bus_call_method(
2807 bus,
2808 "org.freedesktop.login1",
2809 "/org/freedesktop/login1",
2810 "org.freedesktop.login1.Manager",
2811 "ListInhibitors",
2812 NULL,
2813 &reply,
2814 NULL);
2815 if (r < 0)
2816 /* If logind is not around, then there are no inhibitors... */
2817 return 0;
2818
2819 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
2820 if (r < 0)
2821 return bus_log_parse_error(r);
2822
2823 while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
2824 _cleanup_free_ char *comm = NULL, *user = NULL;
2825 _cleanup_strv_free_ char **sv = NULL;
2826
2827 if (!streq(mode, "block"))
2828 continue;
2829
2830 sv = strv_split(what, ":");
2831 if (!sv)
2832 return log_oom();
2833
2834 if (!strv_contains(sv,
2835 a == ACTION_HALT ||
2836 a == ACTION_POWEROFF ||
2837 a == ACTION_REBOOT ||
2838 a == ACTION_KEXEC ? "shutdown" : "sleep"))
2839 continue;
2840
2841 get_process_comm(pid, &comm);
2842 user = uid_to_name(uid);
2843
2844 log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", user %s), reason is \"%s\".",
2845 who, (unsigned long) pid, strna(comm), strna(user), why);
2846
2847 c++;
2848 }
2849 if (r < 0)
2850 return bus_log_parse_error(r);
2851
2852 r = sd_bus_message_exit_container(reply);
2853 if (r < 0)
2854 return bus_log_parse_error(r);
2855
2856 /* Check for current sessions */
2857 sd_get_sessions(&sessions);
2858 STRV_FOREACH(s, sessions) {
2859 _cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;
2860
2861 if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())
2862 continue;
2863
2864 if (sd_session_get_class(*s, &class) < 0 || !streq(class, "user"))
2865 continue;
2866
2867 if (sd_session_get_type(*s, &type) < 0 || (!streq(type, "x11") && !streq(type, "tty")))
2868 continue;
2869
2870 sd_session_get_tty(*s, &tty);
2871 sd_session_get_seat(*s, &seat);
2872 sd_session_get_service(*s, &service);
2873 user = uid_to_name(uid);
2874
2875 log_warning("User %s is logged in on %s.", strna(user), isempty(tty) ? (isempty(seat) ? strna(service) : seat) : tty);
2876 c++;
2877 }
2878
2879 if (c <= 0)
2880 return 0;
2881
2882 log_error("Please retry operation after closing inhibitors and logging out other users.\nAlternatively, ignore inhibitors and users with 'systemctl %s -i'.",
2883 action_table[a].verb);
2884
2885 return -EPERM;
2886 #else
2887 return 0;
2888 #endif
2889 }
2890
2891 static int start_special(sd_bus *bus, char **args) {
2892 enum action a;
2893 int r;
2894
2895 assert(args);
2896
2897 a = verb_to_action(args[0]);
2898
2899 r = check_inhibitors(bus, a);
2900 if (r < 0)
2901 return r;
2902
2903 if (arg_force >= 2 && geteuid() != 0) {
2904 log_error("Must be root.");
2905 return -EPERM;
2906 }
2907
2908 if (arg_force >= 2 &&
2909 (a == ACTION_HALT ||
2910 a == ACTION_POWEROFF ||
2911 a == ACTION_REBOOT))
2912 return halt_now(a);
2913
2914 if (arg_force >= 1 &&
2915 (a == ACTION_HALT ||
2916 a == ACTION_POWEROFF ||
2917 a == ACTION_REBOOT ||
2918 a == ACTION_KEXEC ||
2919 a == ACTION_EXIT))
2920 return daemon_reload(bus, args);
2921
2922 /* first try logind, to allow authentication with polkit */
2923 if (geteuid() != 0 &&
2924 (a == ACTION_POWEROFF ||
2925 a == ACTION_REBOOT ||
2926 a == ACTION_SUSPEND ||
2927 a == ACTION_HIBERNATE ||
2928 a == ACTION_HYBRID_SLEEP)) {
2929 r = reboot_with_logind(bus, a);
2930 if (r >= 0)
2931 return r;
2932 }
2933
2934 r = start_unit(bus, args);
2935 if (r == EXIT_SUCCESS)
2936 warn_wall(a);
2937
2938 return r;
2939 }
2940
2941 static int check_unit_generic(sd_bus *bus, int code, const char *good_states, char **args) {
2942 _cleanup_strv_free_ char **names = NULL;
2943 char **name;
2944 int r;
2945
2946 assert(bus);
2947 assert(args);
2948
2949 r = expand_names(bus, args, NULL, &names);
2950 if (r < 0) {
2951 log_error("Failed to expand names: %s", strerror(-r));
2952 return r;
2953 }
2954
2955 STRV_FOREACH(name, names) {
2956 int state;
2957
2958 state = check_one_unit(bus, *name, good_states, arg_quiet);
2959 if (state < 0)
2960 return state;
2961 if (state == 0)
2962 r = code;
2963 }
2964
2965 return r;
2966 }
2967
2968 static int check_unit_active(sd_bus *bus, char **args) {
2969 /* According to LSB: 3, "program is not running" */
2970 return check_unit_generic(bus, 3, "active\0reloading\0", args + 1);
2971 }
2972
2973 static int check_unit_failed(sd_bus *bus, char **args) {
2974 return check_unit_generic(bus, 1, "failed\0", args + 1);
2975 }
2976
2977 static int kill_unit(sd_bus *bus, char **args) {
2978 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2979 _cleanup_strv_free_ char **names = NULL;
2980 char **name;
2981 int r, q;
2982
2983 assert(bus);
2984 assert(args);
2985
2986 if (!arg_kill_who)
2987 arg_kill_who = "all";
2988
2989 r = expand_names(bus, args + 1, NULL, &names);
2990 if (r < 0)
2991 log_error("Failed to expand names: %s", strerror(-r));
2992
2993 STRV_FOREACH(name, names) {
2994 q = sd_bus_call_method(
2995 bus,
2996 "org.freedesktop.systemd1",
2997 "/org/freedesktop/systemd1",
2998 "org.freedesktop.systemd1.Manager",
2999 "KillUnit",
3000 &error,
3001 NULL,
3002 "ssi", *names, arg_kill_who, arg_signal);
3003 if (q < 0) {
3004 log_error("Failed to kill unit %s: %s",
3005 *names, bus_error_message(&error, r));
3006 if (r == 0)
3007 r = q;
3008 }
3009 }
3010
3011 return r;
3012 }
3013
3014 typedef struct ExecStatusInfo {
3015 char *name;
3016
3017 char *path;
3018 char **argv;
3019
3020 bool ignore;
3021
3022 usec_t start_timestamp;
3023 usec_t exit_timestamp;
3024 pid_t pid;
3025 int code;
3026 int status;
3027
3028 LIST_FIELDS(struct ExecStatusInfo, exec);
3029 } ExecStatusInfo;
3030
3031 static void exec_status_info_free(ExecStatusInfo *i) {
3032 assert(i);
3033
3034 free(i->name);
3035 free(i->path);
3036 strv_free(i->argv);
3037 free(i);
3038 }
3039
3040 static int exec_status_info_deserialize(sd_bus_message *m, ExecStatusInfo *i) {
3041 uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
3042 const char *path;
3043 uint32_t pid;
3044 int32_t code, status;
3045 int ignore, r;
3046
3047 assert(m);
3048 assert(i);
3049
3050 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
3051 if (r < 0)
3052 return bus_log_parse_error(r);
3053 else if (r == 0)
3054 return 0;
3055
3056 r = sd_bus_message_read(m, "s", &path);
3057 if (r < 0)
3058 return bus_log_parse_error(r);
3059
3060 i->path = strdup(path);
3061 if (!i->path)
3062 return log_oom();
3063
3064 r = sd_bus_message_read_strv(m, &i->argv);
3065 if (r < 0)
3066 return bus_log_parse_error(r);
3067
3068 r = sd_bus_message_read(m,
3069 "bttttuii",
3070 &ignore,
3071 &start_timestamp, &start_timestamp_monotonic,
3072 &exit_timestamp, &exit_timestamp_monotonic,
3073 &pid,
3074 &code, &status);
3075 if (r < 0)
3076 return bus_log_parse_error(r);
3077
3078 i->ignore = ignore;
3079 i->start_timestamp = (usec_t) start_timestamp;
3080 i->exit_timestamp = (usec_t) exit_timestamp;
3081 i->pid = (pid_t) pid;
3082 i->code = code;
3083 i->status = status;
3084
3085 r = sd_bus_message_exit_container(m);
3086 if (r < 0)
3087 return bus_log_parse_error(r);
3088
3089 return 1;
3090 }
3091
3092 typedef struct UnitStatusInfo {
3093 const char *id;
3094 const char *load_state;
3095 const char *active_state;
3096 const char *sub_state;
3097 const char *unit_file_state;
3098
3099 const char *description;
3100 const char *following;
3101
3102 char **documentation;
3103
3104 const char *fragment_path;
3105 const char *source_path;
3106 const char *control_group;
3107
3108 char **dropin_paths;
3109
3110 const char *load_error;
3111 const char *result;
3112
3113 usec_t inactive_exit_timestamp;
3114 usec_t inactive_exit_timestamp_monotonic;
3115 usec_t active_enter_timestamp;
3116 usec_t active_exit_timestamp;
3117 usec_t inactive_enter_timestamp;
3118
3119 bool need_daemon_reload;
3120
3121 /* Service */
3122 pid_t main_pid;
3123 pid_t control_pid;
3124 const char *status_text;
3125 const char *pid_file;
3126 bool running:1;
3127
3128 usec_t start_timestamp;
3129 usec_t exit_timestamp;
3130
3131 int exit_code, exit_status;
3132
3133 usec_t condition_timestamp;
3134 bool condition_result;
3135 bool failed_condition_trigger;
3136 bool failed_condition_negate;
3137 const char *failed_condition;
3138 const char *failed_condition_param;
3139
3140 /* Socket */
3141 unsigned n_accepted;
3142 unsigned n_connections;
3143 bool accept;
3144
3145 /* Pairs of type, path */
3146 char **listen;
3147
3148 /* Device */
3149 const char *sysfs_path;
3150
3151 /* Mount, Automount */
3152 const char *where;
3153
3154 /* Swap */
3155 const char *what;
3156
3157 LIST_HEAD(ExecStatusInfo, exec);
3158 } UnitStatusInfo;
3159
3160 static void print_status_info(
3161 UnitStatusInfo *i,
3162 bool *ellipsized) {
3163
3164 ExecStatusInfo *p;
3165 const char *active_on, *active_off, *on, *off, *ss;
3166 usec_t timestamp;
3167 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
3168 char since2[FORMAT_TIMESTAMP_MAX], *s2;
3169 const char *path;
3170 int flags =
3171 arg_all * OUTPUT_SHOW_ALL |
3172 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
3173 on_tty() * OUTPUT_COLOR |
3174 !arg_quiet * OUTPUT_WARN_CUTOFF |
3175 arg_full * OUTPUT_FULL_WIDTH;
3176 char **t, **t2;
3177
3178 assert(i);
3179
3180 /* This shows pretty information about a unit. See
3181 * print_property() for a low-level property printer */
3182
3183 if (streq_ptr(i->active_state, "failed")) {
3184 active_on = ansi_highlight_red();
3185 active_off = ansi_highlight_off();
3186 } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
3187 active_on = ansi_highlight_green();
3188 active_off = ansi_highlight_off();
3189 } else
3190 active_on = active_off = "";
3191
3192 printf("%s%s%s%s", active_on, draw_special_char(DRAW_BLACK_CIRCLE), active_off, strna(i->id));
3193
3194 if (i->description && !streq_ptr(i->id, i->description))
3195 printf(" - %s", i->description);
3196
3197 printf("\n");
3198
3199 if (i->following)
3200 printf(" Follow: unit currently follows state of %s\n", i->following);
3201
3202 if (streq_ptr(i->load_state, "error")) {
3203 on = ansi_highlight_red();
3204 off = ansi_highlight_off();
3205 } else
3206 on = off = "";
3207
3208 path = i->source_path ? i->source_path : i->fragment_path;
3209
3210 if (i->load_error)
3211 printf(" Loaded: %s%s%s (Reason: %s)\n",
3212 on, strna(i->load_state), off, i->load_error);
3213 else if (path && i->unit_file_state)
3214 printf(" Loaded: %s%s%s (%s; %s)\n",
3215 on, strna(i->load_state), off, path, i->unit_file_state);
3216 else if (path)
3217 printf(" Loaded: %s%s%s (%s)\n",
3218 on, strna(i->load_state), off, path);
3219 else
3220 printf(" Loaded: %s%s%s\n",
3221 on, strna(i->load_state), off);
3222
3223 if (!strv_isempty(i->dropin_paths)) {
3224 _cleanup_free_ char *dir = NULL;
3225 bool last = false;
3226 char ** dropin;
3227
3228 STRV_FOREACH(dropin, i->dropin_paths) {
3229 if (! dir || last) {
3230 printf(dir ? " " : " Drop-In: ");
3231
3232 free(dir);
3233 dir = NULL;
3234
3235 if (path_get_parent(*dropin, &dir) < 0) {
3236 log_oom();
3237 return;
3238 }
3239
3240 printf("%s\n %s", dir,
3241 draw_special_char(DRAW_TREE_RIGHT));
3242 }
3243
3244 last = ! (*(dropin + 1) && startswith(*(dropin + 1), dir));
3245
3246 printf("%s%s", basename(*dropin), last ? "\n" : ", ");
3247 }
3248 }
3249
3250 ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
3251 if (ss)
3252 printf(" Active: %s%s (%s)%s",
3253 active_on, strna(i->active_state), ss, active_off);
3254 else
3255 printf(" Active: %s%s%s",
3256 active_on, strna(i->active_state), active_off);
3257
3258 if (!isempty(i->result) && !streq(i->result, "success"))
3259 printf(" (Result: %s)", i->result);
3260
3261 timestamp = (streq_ptr(i->active_state, "active") ||
3262 streq_ptr(i->active_state, "reloading")) ? i->active_enter_timestamp :
3263 (streq_ptr(i->active_state, "inactive") ||
3264 streq_ptr(i->active_state, "failed")) ? i->inactive_enter_timestamp :
3265 streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp :
3266 i->active_exit_timestamp;
3267
3268 s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);
3269 s2 = format_timestamp(since2, sizeof(since2), timestamp);
3270
3271 if (s1)
3272 printf(" since %s; %s\n", s2, s1);
3273 else if (s2)
3274 printf(" since %s\n", s2);
3275 else
3276 printf("\n");
3277
3278 if (!i->condition_result && i->condition_timestamp > 0) {
3279 s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);
3280 s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
3281
3282 printf(" start condition failed at %s%s%s\n",
3283 s2, s1 ? "; " : "", s1 ? s1 : "");
3284 if (i->failed_condition_trigger)
3285 printf(" none of the trigger conditions were met\n");
3286 else if (i->failed_condition)
3287 printf(" %s=%s%s was not met\n",
3288 i->failed_condition,
3289 i->failed_condition_negate ? "!" : "",
3290 i->failed_condition_param);
3291 }
3292
3293 if (i->sysfs_path)
3294 printf(" Device: %s\n", i->sysfs_path);
3295 if (i->where)
3296 printf(" Where: %s\n", i->where);
3297 if (i->what)
3298 printf(" What: %s\n", i->what);
3299
3300 STRV_FOREACH(t, i->documentation)
3301 printf(" %*s %s\n", 9, t == i->documentation ? "Docs:" : "", *t);
3302
3303 STRV_FOREACH_PAIR(t, t2, i->listen)
3304 printf(" %*s %s (%s)\n", 9, t == i->listen ? "Listen:" : "", *t2, *t);
3305
3306 if (i->accept)
3307 printf(" Accepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
3308
3309 LIST_FOREACH(exec, p, i->exec) {
3310 _cleanup_free_ char *argv = NULL;
3311 bool good;
3312
3313 /* Only show exited processes here */
3314 if (p->code == 0)
3315 continue;
3316
3317 argv = strv_join(p->argv, " ");
3318 printf(" Process: %u %s=%s ", p->pid, p->name, strna(argv));
3319
3320 good = is_clean_exit_lsb(p->code, p->status, NULL);
3321 if (!good) {
3322 on = ansi_highlight_red();
3323 off = ansi_highlight_off();
3324 } else
3325 on = off = "";
3326
3327 printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));
3328
3329 if (p->code == CLD_EXITED) {
3330 const char *c;
3331
3332 printf("status=%i", p->status);
3333
3334 c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD);
3335 if (c)
3336 printf("/%s", c);
3337
3338 } else
3339 printf("signal=%s", signal_to_string(p->status));
3340
3341 printf(")%s\n", off);
3342
3343 if (i->main_pid == p->pid &&
3344 i->start_timestamp == p->start_timestamp &&
3345 i->exit_timestamp == p->start_timestamp)
3346 /* Let's not show this twice */
3347 i->main_pid = 0;
3348
3349 if (p->pid == i->control_pid)
3350 i->control_pid = 0;
3351 }
3352
3353 if (i->main_pid > 0 || i->control_pid > 0) {
3354 if (i->main_pid > 0) {
3355 printf(" Main PID: %u", (unsigned) i->main_pid);
3356
3357 if (i->running) {
3358 _cleanup_free_ char *comm = NULL;
3359 get_process_comm(i->main_pid, &comm);
3360 if (comm)
3361 printf(" (%s)", comm);
3362 } else if (i->exit_code > 0) {
3363 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
3364
3365 if (i->exit_code == CLD_EXITED) {
3366 const char *c;
3367
3368 printf("status=%i", i->exit_status);
3369
3370 c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD);
3371 if (c)
3372 printf("/%s", c);
3373
3374 } else
3375 printf("signal=%s", signal_to_string(i->exit_status));
3376 printf(")");
3377 }
3378
3379 if (i->control_pid > 0)
3380 printf(";");
3381 }
3382
3383 if (i->control_pid > 0) {
3384 _cleanup_free_ char *c = NULL;
3385
3386 printf(" %8s: %u", i->main_pid ? "" : " Control", (unsigned) i->control_pid);
3387
3388 get_process_comm(i->control_pid, &c);
3389 if (c)
3390 printf(" (%s)", c);
3391 }
3392
3393 printf("\n");
3394 }
3395
3396 if (i->status_text)
3397 printf(" Status: \"%s\"\n", i->status_text);
3398
3399 if (i->control_group &&
3400 (i->main_pid > 0 || i->control_pid > 0 ||
3401 ((arg_transport != BUS_TRANSPORT_LOCAL && arg_transport != BUS_TRANSPORT_CONTAINER) || cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, i->control_group, false) == 0))) {
3402 unsigned c;
3403
3404 printf(" CGroup: %s\n", i->control_group);
3405
3406 if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
3407 unsigned k = 0;
3408 pid_t extra[2];
3409 static const char prefix[] = " ";
3410
3411 c = columns();
3412 if (c > sizeof(prefix) - 1)
3413 c -= sizeof(prefix) - 1;
3414 else
3415 c = 0;
3416
3417 if (i->main_pid > 0)
3418 extra[k++] = i->main_pid;
3419
3420 if (i->control_pid > 0)
3421 extra[k++] = i->control_pid;
3422
3423 show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix, c, false, extra, k, flags);
3424 }
3425 }
3426
3427 if (i->id && arg_transport == BUS_TRANSPORT_LOCAL) {
3428 show_journal_by_unit(stdout,
3429 i->id,
3430 arg_output,
3431 0,
3432 i->inactive_exit_timestamp_monotonic,
3433 arg_lines,
3434 getuid(),
3435 flags | OUTPUT_BEGIN_NEWLINE,
3436 arg_scope == UNIT_FILE_SYSTEM,
3437 ellipsized);
3438 }
3439
3440 if (i->need_daemon_reload)
3441 printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %sdaemon-reload' recommended.\n",
3442 ansi_highlight_red(),
3443 ansi_highlight_off(),
3444 arg_scope == UNIT_FILE_SYSTEM ? "" : "--user ");
3445 }
3446
3447 static void show_unit_help(UnitStatusInfo *i) {
3448 char **p;
3449
3450 assert(i);
3451
3452 if (!i->documentation) {
3453 log_info("Documentation for %s not known.", i->id);
3454 return;
3455 }
3456
3457 STRV_FOREACH(p, i->documentation) {
3458
3459 if (startswith(*p, "man:")) {
3460 const char *args[4] = { "man", NULL, NULL, NULL };
3461 _cleanup_free_ char *page = NULL, *section = NULL;
3462 char *e = NULL;
3463 pid_t pid;
3464 size_t k;
3465
3466 k = strlen(*p);
3467
3468 if ((*p)[k-1] == ')')
3469 e = strrchr(*p, '(');
3470
3471 if (e) {
3472 page = strndup((*p) + 4, e - *p - 4);
3473 section = strndup(e + 1, *p + k - e - 2);
3474 if (!page || !section) {
3475 log_oom();
3476 return;
3477 }
3478
3479 args[1] = section;
3480 args[2] = page;
3481 } else
3482 args[1] = *p + 4;
3483
3484 pid = fork();
3485 if (pid < 0) {
3486 log_error("Failed to fork: %m");
3487 continue;
3488 }
3489
3490 if (pid == 0) {
3491 /* Child */
3492 execvp(args[0], (char**) args);
3493 log_error("Failed to execute man: %m");
3494 _exit(EXIT_FAILURE);
3495 }
3496
3497 wait_for_terminate(pid, NULL);
3498 } else
3499 log_info("Can't show: %s", *p);
3500 }
3501 }
3502
3503 static int status_property(const char *name, sd_bus_message *m, UnitStatusInfo *i, const char *contents) {
3504 int r;
3505
3506 assert(name);
3507 assert(m);
3508 assert(i);
3509
3510 switch (contents[0]) {
3511
3512 case SD_BUS_TYPE_STRING: {
3513 const char *s;
3514
3515 r = sd_bus_message_read(m, "s", &s);
3516 if (r < 0)
3517 return bus_log_parse_error(r);
3518
3519 if (!isempty(s)) {
3520 if (streq(name, "Id"))
3521 i->id = s;
3522 else if (streq(name, "LoadState"))
3523 i->load_state = s;
3524 else if (streq(name, "ActiveState"))
3525 i->active_state = s;
3526 else if (streq(name, "SubState"))
3527 i->sub_state = s;
3528 else if (streq(name, "Description"))
3529 i->description = s;
3530 else if (streq(name, "FragmentPath"))
3531 i->fragment_path = s;
3532 else if (streq(name, "SourcePath"))
3533 i->source_path = s;
3534 #ifndef NOLEGACY
3535 else if (streq(name, "DefaultControlGroup")) {
3536 const char *e;
3537 e = startswith(s, SYSTEMD_CGROUP_CONTROLLER ":");
3538 if (e)
3539 i->control_group = e;
3540 }
3541 #endif
3542 else if (streq(name, "ControlGroup"))
3543 i->control_group = s;
3544 else if (streq(name, "StatusText"))
3545 i->status_text = s;
3546 else if (streq(name, "PIDFile"))
3547 i->pid_file = s;
3548 else if (streq(name, "SysFSPath"))
3549 i->sysfs_path = s;
3550 else if (streq(name, "Where"))
3551 i->where = s;
3552 else if (streq(name, "What"))
3553 i->what = s;
3554 else if (streq(name, "Following"))
3555 i->following = s;
3556 else if (streq(name, "UnitFileState"))
3557 i->unit_file_state = s;
3558 else if (streq(name, "Result"))
3559 i->result = s;
3560 }
3561
3562 break;
3563 }
3564
3565 case SD_BUS_TYPE_BOOLEAN: {
3566 int b;
3567
3568 r = sd_bus_message_read(m, "b", &b);
3569 if (r < 0)
3570 return bus_log_parse_error(r);
3571
3572 if (streq(name, "Accept"))
3573 i->accept = b;
3574 else if (streq(name, "NeedDaemonReload"))
3575 i->need_daemon_reload = b;
3576 else if (streq(name, "ConditionResult"))
3577 i->condition_result = b;
3578
3579 break;
3580 }
3581
3582 case SD_BUS_TYPE_UINT32: {
3583 uint32_t u;
3584
3585 r = sd_bus_message_read(m, "u", &u);
3586 if (r < 0)
3587 return bus_log_parse_error(r);
3588
3589 if (streq(name, "MainPID")) {
3590 if (u > 0) {
3591 i->main_pid = (pid_t) u;
3592 i->running = true;
3593 }
3594 } else if (streq(name, "ControlPID"))
3595 i->control_pid = (pid_t) u;
3596 else if (streq(name, "ExecMainPID")) {
3597 if (u > 0)
3598 i->main_pid = (pid_t) u;
3599 } else if (streq(name, "NAccepted"))
3600 i->n_accepted = u;
3601 else if (streq(name, "NConnections"))
3602 i->n_connections = u;
3603
3604 break;
3605 }
3606
3607 case SD_BUS_TYPE_INT32: {
3608 int32_t j;
3609
3610 r = sd_bus_message_read(m, "i", &j);
3611 if (r < 0)
3612 return bus_log_parse_error(r);
3613
3614 if (streq(name, "ExecMainCode"))
3615 i->exit_code = (int) j;
3616 else if (streq(name, "ExecMainStatus"))
3617 i->exit_status = (int) j;
3618
3619 break;
3620 }
3621
3622 case SD_BUS_TYPE_UINT64: {
3623 uint64_t u;
3624
3625 r = sd_bus_message_read(m, "t", &u);
3626 if (r < 0)
3627 return bus_log_parse_error(r);
3628
3629 if (streq(name, "ExecMainStartTimestamp"))
3630 i->start_timestamp = (usec_t) u;
3631 else if (streq(name, "ExecMainExitTimestamp"))
3632 i->exit_timestamp = (usec_t) u;
3633 else if (streq(name, "ActiveEnterTimestamp"))
3634 i->active_enter_timestamp = (usec_t) u;
3635 else if (streq(name, "InactiveEnterTimestamp"))
3636 i->inactive_enter_timestamp = (usec_t) u;
3637 else if (streq(name, "InactiveExitTimestamp"))
3638 i->inactive_exit_timestamp = (usec_t) u;
3639 else if (streq(name, "InactiveExitTimestampMonotonic"))
3640 i->inactive_exit_timestamp_monotonic = (usec_t) u;
3641 else if (streq(name, "ActiveExitTimestamp"))
3642 i->active_exit_timestamp = (usec_t) u;
3643 else if (streq(name, "ConditionTimestamp"))
3644 i->condition_timestamp = (usec_t) u;
3645
3646 break;
3647 }
3648
3649 case SD_BUS_TYPE_ARRAY:
3650
3651 if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
3652 _cleanup_free_ ExecStatusInfo *info = NULL;
3653
3654 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
3655 if (r < 0)
3656 return bus_log_parse_error(r);
3657
3658 info = new0(ExecStatusInfo, 1);
3659 if (!info)
3660 return log_oom();
3661
3662 while ((r = exec_status_info_deserialize(m, info)) > 0) {
3663
3664 info->name = strdup(name);
3665 if (!info->name)
3666 log_oom();
3667
3668 LIST_PREPEND(exec, i->exec, info);
3669
3670 info = new0(ExecStatusInfo, 1);
3671 if (!info)
3672 log_oom();
3673 }
3674
3675 if (r < 0)
3676 return bus_log_parse_error(r);
3677
3678 r = sd_bus_message_exit_container(m);
3679 if (r < 0)
3680 return bus_log_parse_error(r);
3681
3682 return 0;
3683
3684 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
3685 const char *type, *path;
3686
3687 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
3688 if (r < 0)
3689 return bus_log_parse_error(r);
3690
3691 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0) {
3692
3693 r = strv_extend(&i->listen, type);
3694 if (r < 0)
3695 return r;
3696
3697 r = strv_extend(&i->listen, path);
3698 if (r < 0)
3699 return r;
3700 }
3701 if (r < 0)
3702 return bus_log_parse_error(r);
3703
3704 r = sd_bus_message_exit_container(m);
3705 if (r < 0)
3706 return bus_log_parse_error(r);
3707
3708 return 0;
3709
3710 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "DropInPaths")) {
3711
3712 r = sd_bus_message_read_strv(m, &i->dropin_paths);
3713 if (r < 0)
3714 return bus_log_parse_error(r);
3715
3716 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Documentation")) {
3717
3718 r = sd_bus_message_read_strv(m, &i->documentation);
3719 if (r < 0)
3720 return bus_log_parse_error(r);
3721
3722 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Conditions")) {
3723 const char *cond, *param;
3724 int trigger, negate;
3725 int32_t state;
3726
3727 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
3728 if (r < 0)
3729 return bus_log_parse_error(r);
3730
3731 while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
3732 log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
3733 if (state < 0 && (!trigger || !i->failed_condition)) {
3734 i->failed_condition = cond;
3735 i->failed_condition_trigger = trigger;
3736 i->failed_condition_negate = negate;
3737 i->failed_condition_param = param;
3738 }
3739 }
3740 if (r < 0)
3741 return bus_log_parse_error(r);
3742
3743 r = sd_bus_message_exit_container(m);
3744 if (r < 0)
3745 return bus_log_parse_error(r);
3746
3747 } else
3748 goto skip;
3749
3750 break;
3751
3752 case SD_BUS_TYPE_STRUCT_BEGIN:
3753
3754 if (streq(name, "LoadError")) {
3755 const char *n, *message;
3756
3757 r = sd_bus_message_read(m, "(ss)", &n, &message);
3758 if (r < 0)
3759 return bus_log_parse_error(r);
3760
3761 if (!isempty(message))
3762 i->load_error = message;
3763 } else
3764 goto skip;
3765
3766 break;
3767
3768 default:
3769 goto skip;
3770 }
3771
3772 return 0;
3773
3774 skip:
3775 r = sd_bus_message_skip(m, contents);
3776 if (r < 0)
3777 return bus_log_parse_error(r);
3778
3779 return 0;
3780 }
3781
3782 static int print_property(const char *name, sd_bus_message *m, const char *contents) {
3783 int r;
3784
3785 assert(name);
3786 assert(m);
3787
3788 /* This is a low-level property printer, see
3789 * print_status_info() for the nicer output */
3790
3791 if (arg_properties && !strv_find(arg_properties, name)) {
3792 /* skip what we didn't read */
3793 r = sd_bus_message_skip(m, contents);
3794 return r;
3795 }
3796
3797 switch (contents[0]) {
3798
3799 case SD_BUS_TYPE_STRUCT_BEGIN:
3800
3801 if (contents[1] == SD_BUS_TYPE_UINT32 && streq(name, "Job")) {
3802 uint32_t u;
3803
3804 r = sd_bus_message_read(m, "(uo)", &u, NULL);
3805 if (r < 0)
3806 return bus_log_parse_error(r);
3807
3808 if (u > 0)
3809 printf("%s=%u\n", name, (unsigned) u);
3810 else if (arg_all)
3811 printf("%s=\n", name);
3812
3813 return 0;
3814
3815 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Unit")) {
3816 const char *s;
3817
3818 r = sd_bus_message_read(m, "(so)", &s, NULL);
3819 if (r < 0)
3820 return bus_log_parse_error(r);
3821
3822 if (arg_all || !isempty(s))
3823 printf("%s=%s\n", name, s);
3824
3825 return 0;
3826
3827 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "LoadError")) {
3828 const char *a = NULL, *b = NULL;
3829
3830 r = sd_bus_message_read(m, "(ss)", &a, &b);
3831 if (r < 0)
3832 return bus_log_parse_error(r);
3833
3834 if (arg_all || !isempty(a) || !isempty(b))
3835 printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
3836
3837 return 0;
3838 } else if (streq_ptr(name, "SystemCallFilter")) {
3839 _cleanup_strv_free_ char **l = NULL;
3840 int whitelist;
3841
3842 r = sd_bus_message_enter_container(m, 'r', "bas");
3843 if (r < 0)
3844 return bus_log_parse_error(r);
3845
3846 r = sd_bus_message_read(m, "b", &whitelist);
3847 if (r < 0)
3848 return bus_log_parse_error(r);
3849
3850 r = sd_bus_message_read_strv(m, &l);
3851 if (r < 0)
3852 return bus_log_parse_error(r);
3853
3854 r = sd_bus_message_exit_container(m);
3855 if (r < 0)
3856 return bus_log_parse_error(r);
3857
3858 if (arg_all || whitelist || !strv_isempty(l)) {
3859 bool first = true;
3860 char **i;
3861
3862 fputs(name, stdout);
3863 fputc('=', stdout);
3864
3865 if (!whitelist)
3866 fputc('~', stdout);
3867
3868 STRV_FOREACH(i, l) {
3869 if (first)
3870 first = false;
3871 else
3872 fputc(' ', stdout);
3873
3874 fputs(*i, stdout);
3875 }
3876 fputc('\n', stdout);
3877 }
3878
3879 return 0;
3880 }
3881
3882 break;
3883
3884 case SD_BUS_TYPE_ARRAY:
3885
3886 if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "EnvironmentFiles")) {
3887 const char *path;
3888 int ignore;
3889
3890 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sb)");
3891 if (r < 0)
3892 return bus_log_parse_error(r);
3893
3894 while ((r = sd_bus_message_read(m, "(sb)", &path, &ignore)) > 0)
3895 printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
3896
3897 if (r < 0)
3898 return bus_log_parse_error(r);
3899
3900 r = sd_bus_message_exit_container(m);
3901 if (r < 0)
3902 return bus_log_parse_error(r);
3903
3904 return 0;
3905
3906 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Paths")) {
3907 const char *type, *path;
3908
3909 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
3910 if (r < 0)
3911 return bus_log_parse_error(r);
3912
3913 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
3914 printf("%s=%s\n", type, path);
3915 if (r < 0)
3916 return bus_log_parse_error(r);
3917
3918 r = sd_bus_message_exit_container(m);
3919 if (r < 0)
3920 return bus_log_parse_error(r);
3921
3922 return 0;
3923
3924 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
3925 const char *type, *path;
3926
3927 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
3928 if (r < 0)
3929 return bus_log_parse_error(r);
3930
3931 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
3932 printf("Listen%s=%s\n", type, path);
3933 if (r < 0)
3934 return bus_log_parse_error(r);
3935
3936 r = sd_bus_message_exit_container(m);
3937 if (r < 0)
3938 return bus_log_parse_error(r);
3939
3940 return 0;
3941
3942 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Timers")) {
3943 const char *base;
3944 uint64_t value, next_elapse;
3945
3946 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(stt)");
3947 if (r < 0)
3948 return bus_log_parse_error(r);
3949
3950 while ((r = sd_bus_message_read(m, "(stt)", &base, &value, &next_elapse)) > 0) {
3951 char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
3952
3953 printf("%s={ value=%s ; next_elapse=%s }\n",
3954 base,
3955 format_timespan(timespan1, sizeof(timespan1), value, 0),
3956 format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
3957 }
3958 if (r < 0)
3959 return bus_log_parse_error(r);
3960
3961 r = sd_bus_message_exit_container(m);
3962 if (r < 0)
3963 return bus_log_parse_error(r);
3964
3965 return 0;
3966
3967 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
3968 ExecStatusInfo info = {};
3969
3970 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
3971 if (r < 0)
3972 return bus_log_parse_error(r);
3973
3974 while ((r = exec_status_info_deserialize(m, &info)) > 0) {
3975 char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
3976 _cleanup_free_ char *tt;
3977
3978 tt = strv_join(info.argv, " ");
3979
3980 printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",
3981 name,
3982 strna(info.path),
3983 strna(tt),
3984 yes_no(info.ignore),
3985 strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
3986 strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
3987 (unsigned) info. pid,
3988 sigchld_code_to_string(info.code),
3989 info.status,
3990 info.code == CLD_EXITED ? "" : "/",
3991 strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
3992
3993 free(info.path);
3994 strv_free(info.argv);
3995 zero(info);
3996 }
3997
3998 r = sd_bus_message_exit_container(m);
3999 if (r < 0)
4000 return bus_log_parse_error(r);
4001
4002 return 0;
4003
4004 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "DeviceAllow")) {
4005 const char *path, *rwm;
4006
4007 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
4008 if (r < 0)
4009 return bus_log_parse_error(r);
4010
4011 while ((r = sd_bus_message_read(m, "(ss)", &path, &rwm)) > 0)
4012 printf("%s=%s %s\n", name, strna(path), strna(rwm));
4013 if (r < 0)
4014 return bus_log_parse_error(r);
4015
4016 r = sd_bus_message_exit_container(m);
4017 if (r < 0)
4018 return bus_log_parse_error(r);
4019
4020 return 0;
4021
4022 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "BlockIODeviceWeight")) {
4023 const char *path;
4024 uint64_t weight;
4025
4026 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
4027 if (r < 0)
4028 return bus_log_parse_error(r);
4029
4030 while ((r = sd_bus_message_read(m, "(st)", &path, &weight)) > 0)
4031 printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
4032 if (r < 0)
4033 return bus_log_parse_error(r);
4034
4035 r = sd_bus_message_exit_container(m);
4036 if (r < 0)
4037 return bus_log_parse_error(r);
4038
4039 return 0;
4040
4041 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth"))) {
4042 const char *path;
4043 uint64_t bandwidth;
4044
4045 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
4046 if (r < 0)
4047 return bus_log_parse_error(r);
4048
4049 while ((r = sd_bus_message_read(m, "(st)", &path, &bandwidth)) > 0)
4050 printf("%s=%s %" PRIu64 "\n", name, strna(path), bandwidth);
4051 if (r < 0)
4052 return bus_log_parse_error(r);
4053
4054 r = sd_bus_message_exit_container(m);
4055 if (r < 0)
4056 return bus_log_parse_error(r);
4057
4058 return 0;
4059 }
4060
4061 break;
4062 }
4063
4064 r = bus_print_property(name, m, arg_all);
4065 if (r < 0)
4066 return bus_log_parse_error(r);
4067
4068 if (r == 0) {
4069 r = sd_bus_message_skip(m, contents);
4070 if (r < 0)
4071 return bus_log_parse_error(r);
4072
4073 if (arg_all)
4074 printf("%s=[unprintable]\n", name);
4075 }
4076
4077 return 0;
4078 }
4079
4080 static int show_one(
4081 const char *verb,
4082 sd_bus *bus,
4083 const char *path,
4084 bool show_properties,
4085 bool *new_line,
4086 bool *ellipsized) {
4087
4088 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4089 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4090 UnitStatusInfo info = {};
4091 ExecStatusInfo *p;
4092 int r;
4093
4094 assert(path);
4095 assert(new_line);
4096
4097 log_debug("Showing one %s", path);
4098
4099 r = sd_bus_call_method(
4100 bus,
4101 "org.freedesktop.systemd1",
4102 path,
4103 "org.freedesktop.DBus.Properties",
4104 "GetAll",
4105 &error,
4106 &reply,
4107 "s", "");
4108 if (r < 0) {
4109 log_error("Failed to get properties: %s", bus_error_message(&error, r));
4110 return r;
4111 }
4112
4113 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
4114 if (r < 0)
4115 return bus_log_parse_error(r);
4116
4117 if (*new_line)
4118 printf("\n");
4119
4120 *new_line = true;
4121
4122 while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
4123 const char *name, *contents;
4124
4125 r = sd_bus_message_read(reply, "s", &name);
4126 if (r < 0)
4127 return bus_log_parse_error(r);
4128
4129 r = sd_bus_message_peek_type(reply, NULL, &contents);
4130 if (r < 0)
4131 return bus_log_parse_error(r);
4132
4133 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
4134 if (r < 0)
4135 return bus_log_parse_error(r);
4136
4137 if (show_properties)
4138 r = print_property(name, reply, contents);
4139 else
4140 r = status_property(name, reply, &info, contents);
4141 if (r < 0)
4142 return r;
4143
4144 r = sd_bus_message_exit_container(reply);
4145 if (r < 0)
4146 return bus_log_parse_error(r);
4147
4148 r = sd_bus_message_exit_container(reply);
4149 if (r < 0)
4150 return bus_log_parse_error(r);
4151 }
4152 if (r < 0)
4153 return bus_log_parse_error(r);
4154
4155 r = sd_bus_message_exit_container(reply);
4156 if (r < 0)
4157 return bus_log_parse_error(r);
4158
4159 r = 0;
4160
4161 if (!show_properties) {
4162 if (streq(verb, "help"))
4163 show_unit_help(&info);
4164 else
4165 print_status_info(&info, ellipsized);
4166 }
4167
4168 strv_free(info.documentation);
4169 strv_free(info.dropin_paths);
4170 strv_free(info.listen);
4171
4172 if (!streq_ptr(info.active_state, "active") &&
4173 !streq_ptr(info.active_state, "reloading") &&
4174 streq(verb, "status")) {
4175 /* According to LSB: "program not running" */
4176 /* 0: program is running or service is OK
4177 * 1: program is dead and /run PID file exists
4178 * 2: program is dead and /run/lock lock file exists
4179 * 3: program is not running
4180 * 4: program or service status is unknown
4181 */
4182 if (info.pid_file && access(info.pid_file, F_OK) == 0)
4183 r = 1;
4184 else
4185 r = 3;
4186 }
4187
4188 while ((p = info.exec)) {
4189 LIST_REMOVE(exec, info.exec, p);
4190 exec_status_info_free(p);
4191 }
4192
4193 return r;
4194 }
4195
4196 static int get_unit_dbus_path_by_pid(
4197 sd_bus *bus,
4198 uint32_t pid,
4199 char **unit) {
4200
4201 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4202 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4203 char *u;
4204 int r;
4205
4206 r = sd_bus_call_method(
4207 bus,
4208 "org.freedesktop.systemd1",
4209 "/org/freedesktop/systemd1",
4210 "org.freedesktop.systemd1.Manager",
4211 "GetUnitByPID",
4212 &error,
4213 &reply,
4214 "u", pid);
4215 if (r < 0) {
4216 log_error("Failed to get unit for PID %lu: %s", (unsigned long) pid, bus_error_message(&error, r));
4217 return r;
4218 }
4219
4220 r = sd_bus_message_read(reply, "o", &u);
4221 if (r < 0)
4222 return bus_log_parse_error(r);
4223
4224 u = strdup(u);
4225 if (!u)
4226 return log_oom();
4227
4228 *unit = u;
4229 return 0;
4230 }
4231
4232 static int show_all(
4233 const char* verb,
4234 sd_bus *bus,
4235 bool show_properties,
4236 bool *new_line,
4237 bool *ellipsized) {
4238
4239 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4240 _cleanup_free_ UnitInfo *unit_infos = NULL;
4241 const UnitInfo *u;
4242 unsigned c;
4243 int r;
4244
4245 r = get_unit_list(bus, NULL, NULL, &unit_infos, 0, &reply);
4246 if (r < 0)
4247 return r;
4248
4249 pager_open_if_enabled();
4250
4251 c = (unsigned) r;
4252
4253 qsort_safe(unit_infos, c, sizeof(UnitInfo), compare_unit_info);
4254
4255 for (u = unit_infos; u < unit_infos + c; u++) {
4256 _cleanup_free_ char *p = NULL;
4257
4258 p = unit_dbus_path_from_name(u->id);
4259 if (!p)
4260 return log_oom();
4261
4262 r = show_one(verb, bus, p, show_properties, new_line, ellipsized);
4263 if (r < 0)
4264 return r;
4265 }
4266
4267 return 0;
4268 }
4269
4270 static int show_system_status(sd_bus *bus) {
4271 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], since2[FORMAT_TIMESTAMP_MAX];
4272 _cleanup_free_ char *hn = NULL;
4273 struct machine_info mi = {};
4274 const char *on, *off;
4275 int r;
4276
4277 hn = gethostname_malloc();
4278 if (!hn)
4279 return log_oom();
4280
4281 r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, &mi);
4282 if (r < 0) {
4283 log_error("Failed to read server status: %s", strerror(-r));
4284 return r;
4285 }
4286
4287 if (streq_ptr(mi.state, "degraded")) {
4288 on = ansi_highlight_red();
4289 off = ansi_highlight_off();
4290 } else if (!streq_ptr(mi.state, "running")) {
4291 on = ansi_highlight_yellow();
4292 off = ansi_highlight_off();
4293 } else
4294 on = off = "";
4295
4296 printf("%s%s%s%s\n", on, draw_special_char(DRAW_BLACK_CIRCLE), off, arg_host ? arg_host : hn);
4297
4298 printf(" State: %s%s%s\n",
4299 on, strna(mi.state), off);
4300
4301 printf(" Jobs: %u queued\n", mi.n_jobs);
4302 printf(" Failed: %u units\n", mi.n_failed_units);
4303
4304 printf(" Since: %s; %s\n",
4305 format_timestamp(since2, sizeof(since2), mi.timestamp),
4306 format_timestamp_relative(since1, sizeof(since1), mi.timestamp));
4307
4308 printf(" CGroup: %s\n", mi.control_group ?: "/");
4309 if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
4310 int flags =
4311 arg_all * OUTPUT_SHOW_ALL |
4312 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
4313 on_tty() * OUTPUT_COLOR |
4314 !arg_quiet * OUTPUT_WARN_CUTOFF |
4315 arg_full * OUTPUT_FULL_WIDTH;
4316
4317 static const char prefix[] = " ";
4318 unsigned c;
4319
4320 c = columns();
4321 if (c > sizeof(prefix) - 1)
4322 c -= sizeof(prefix) - 1;
4323 else
4324 c = 0;
4325
4326 show_cgroup(SYSTEMD_CGROUP_CONTROLLER, strempty(mi.control_group), prefix, c, false, flags);
4327 }
4328
4329 free(mi.state);
4330 free(mi.control_group);
4331
4332 return 0;
4333 }
4334
4335 static int show(sd_bus *bus, char **args) {
4336 bool show_properties, show_status, new_line = false;
4337 bool ellipsized = false;
4338 int r, ret = 0;
4339
4340 assert(bus);
4341 assert(args);
4342
4343 show_properties = streq(args[0], "show");
4344 show_status = streq(args[0], "status");
4345
4346 if (show_properties)
4347 pager_open_if_enabled();
4348
4349 /* If no argument is specified inspect the manager itself */
4350
4351 if (show_properties && strv_length(args) <= 1)
4352 return show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line, &ellipsized);
4353
4354 if (show_status && strv_length(args) <= 1) {
4355
4356 pager_open_if_enabled();
4357 show_system_status(bus);
4358 new_line = true;
4359
4360 if (arg_all)
4361 ret = show_all(args[0], bus, false, &new_line, &ellipsized);
4362 } else {
4363 _cleanup_free_ char **patterns = NULL;
4364 char **name;
4365
4366 STRV_FOREACH(name, args + 1) {
4367 _cleanup_free_ char *unit = NULL;
4368 uint32_t id;
4369
4370 if (safe_atou32(*name, &id) < 0) {
4371 if (strv_push(&patterns, *name) < 0)
4372 return log_oom();
4373
4374 continue;
4375 } else if (show_properties) {
4376 /* Interpret as job id */
4377 if (asprintf(&unit, "/org/freedesktop/systemd1/job/%u", id) < 0)
4378 return log_oom();
4379
4380 } else {
4381 /* Interpret as PID */
4382 r = get_unit_dbus_path_by_pid(bus, id, &unit);
4383 if (r < 0) {
4384 ret = r;
4385 continue;
4386 }
4387 }
4388
4389 show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
4390 }
4391
4392 if (!strv_isempty(patterns)) {
4393 _cleanup_strv_free_ char **names = NULL;
4394
4395 r = expand_names(bus, patterns, NULL, &names);
4396 if (r < 0)
4397 log_error("Failed to expand names: %s", strerror(-r));
4398
4399 STRV_FOREACH(name, names) {
4400 _cleanup_free_ char *unit;
4401
4402 unit = unit_dbus_path_from_name(*name);
4403 if (!unit)
4404 return log_oom();
4405
4406 show_one(args[0], bus, unit, show_properties, &new_line, &ellipsized);
4407 }
4408 }
4409 }
4410
4411 if (ellipsized && !arg_quiet)
4412 printf("Hint: Some lines were ellipsized, use -l to show in full.\n");
4413
4414 return ret;
4415 }
4416
4417 static int cat(sd_bus *bus, char **args) {
4418 _cleanup_free_ char *unit = NULL;
4419 _cleanup_strv_free_ char **names = NULL;
4420 char **name;
4421 bool first = true;
4422 int r = 0;
4423
4424 assert(bus);
4425 assert(args);
4426
4427 r = expand_names(bus, args + 1, NULL, &names);
4428 if (r < 0)
4429 log_error("Failed to expand names: %s", strerror(-r));
4430
4431 pager_open_if_enabled();
4432
4433 STRV_FOREACH(name, names) {
4434 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4435 _cleanup_strv_free_ char **dropin_paths = NULL;
4436 _cleanup_free_ char *fragment_path = NULL;
4437 char **path;
4438
4439 unit = unit_dbus_path_from_name(*name);
4440 if (!unit)
4441 return log_oom();
4442
4443 if (need_daemon_reload(bus, *name) > 0)
4444 log_warning("Unit file of %s changed on disk. Run 'systemctl%s daemon-reload'.",
4445 *name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
4446
4447 r = sd_bus_get_property_string(
4448 bus,
4449 "org.freedesktop.systemd1",
4450 unit,
4451 "org.freedesktop.systemd1.Unit",
4452 "FragmentPath",
4453 &error,
4454 &fragment_path);
4455 if (r < 0) {
4456 log_warning("Failed to get FragmentPath: %s", bus_error_message(&error, r));
4457 continue;
4458 }
4459
4460 r = sd_bus_get_property_strv(
4461 bus,
4462 "org.freedesktop.systemd1",
4463 unit,
4464 "org.freedesktop.systemd1.Unit",
4465 "DropInPaths",
4466 &error,
4467 &dropin_paths);
4468 if (r < 0) {
4469 log_warning("Failed to get DropInPaths: %s", bus_error_message(&error, r));
4470 continue;
4471 }
4472
4473 if (first)
4474 first = false;
4475 else
4476 puts("");
4477
4478 if (!isempty(fragment_path)) {
4479 printf("%s# %s%s\n",
4480 ansi_highlight_blue(),
4481 fragment_path,
4482 ansi_highlight_off());
4483 fflush(stdout);
4484
4485 r = sendfile_full(STDOUT_FILENO, fragment_path);
4486 if (r < 0) {
4487 log_warning("Failed to cat %s: %s", fragment_path, strerror(-r));
4488 continue;
4489 }
4490 }
4491
4492 STRV_FOREACH(path, dropin_paths) {
4493 printf("%s%s# %s%s\n",
4494 isempty(fragment_path) && path == dropin_paths ? "" : "\n",
4495 ansi_highlight_blue(),
4496 *path,
4497 ansi_highlight_off());
4498 fflush(stdout);
4499
4500 r = sendfile_full(STDOUT_FILENO, *path);
4501 if (r < 0) {
4502 log_warning("Failed to cat %s: %s", *path, strerror(-r));
4503 continue;
4504 }
4505 }
4506 }
4507
4508 return r < 0 ? r : 0;
4509 }
4510
4511 static int set_property(sd_bus *bus, char **args) {
4512 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4513 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4514 _cleanup_free_ char *n = NULL;
4515 char **i;
4516 int r;
4517
4518 r = sd_bus_message_new_method_call(
4519 bus,
4520 &m,
4521 "org.freedesktop.systemd1",
4522 "/org/freedesktop/systemd1",
4523 "org.freedesktop.systemd1.Manager",
4524 "SetUnitProperties");
4525 if (r < 0)
4526 return bus_log_create_error(r);
4527
4528 n = unit_name_mangle(args[1], MANGLE_NOGLOB);
4529 if (!n)
4530 return log_oom();
4531
4532 r = sd_bus_message_append(m, "sb", n, arg_runtime);
4533 if (r < 0)
4534 return bus_log_create_error(r);
4535
4536 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(sv)");
4537 if (r < 0)
4538 return bus_log_create_error(r);
4539
4540 STRV_FOREACH(i, args + 2) {
4541 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
4542 if (r < 0)
4543 return bus_log_create_error(r);
4544
4545 r = bus_append_unit_property_assignment(m, *i);
4546 if (r < 0)
4547 return r;
4548
4549 r = sd_bus_message_close_container(m);
4550 if (r < 0)
4551 return bus_log_create_error(r);
4552 }
4553
4554 r = sd_bus_message_close_container(m);
4555 if (r < 0)
4556 return bus_log_create_error(r);
4557
4558 r = sd_bus_call(bus, m, 0, &error, NULL);
4559 if (r < 0) {
4560 log_error("Failed to set unit properties on %s: %s", n, bus_error_message(&error, r));
4561 return r;
4562 }
4563
4564 return 0;
4565 }
4566
4567 static int snapshot(sd_bus *bus, char **args) {
4568 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4569 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4570 _cleanup_free_ char *n = NULL, *id = NULL;
4571 const char *path;
4572 int r;
4573
4574 if (strv_length(args) > 1)
4575 n = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".snapshot");
4576 else
4577 n = strdup("");
4578 if (!n)
4579 return log_oom();
4580
4581 r = sd_bus_call_method(
4582 bus,
4583 "org.freedesktop.systemd1",
4584 "/org/freedesktop/systemd1",
4585 "org.freedesktop.systemd1.Manager",
4586 "CreateSnapshot",
4587 &error,
4588 &reply,
4589 "sb", n, false);
4590 if (r < 0) {
4591 log_error("Failed to create snapshot: %s", bus_error_message(&error, r));
4592 return r;
4593 }
4594
4595 r = sd_bus_message_read(reply, "o", &path);
4596 if (r < 0)
4597 return bus_log_parse_error(r);
4598
4599 r = sd_bus_get_property_string(
4600 bus,
4601 "org.freedesktop.systemd1",
4602 path,
4603 "org.freedesktop.systemd1.Unit",
4604 "Id",
4605 &error,
4606 &id);
4607 if (r < 0) {
4608 log_error("Failed to get ID of snapshot: %s", bus_error_message(&error, r));
4609 return r;
4610 }
4611
4612 if (!arg_quiet)
4613 puts(id);
4614
4615 return 0;
4616 }
4617
4618 static int delete_snapshot(sd_bus *bus, char **args) {
4619 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4620 _cleanup_strv_free_ char **names = NULL;
4621 char **name;
4622 int r, q;
4623
4624 assert(args);
4625
4626 r = expand_names(bus, args + 1, ".snapshot", &names);
4627 if (r < 0)
4628 log_error("Failed to expand names: %s", strerror(-r));
4629
4630 STRV_FOREACH(name, names) {
4631 q = sd_bus_call_method(
4632 bus,
4633 "org.freedesktop.systemd1",
4634 "/org/freedesktop/systemd1",
4635 "org.freedesktop.systemd1.Manager",
4636 "RemoveSnapshot",
4637 &error,
4638 NULL,
4639 "s", *name);
4640 if (q < 0) {
4641 log_error("Failed to remove snapshot %s: %s",
4642 *name, bus_error_message(&error, r));
4643 if (r == 0)
4644 r = q;
4645 }
4646 }
4647
4648 return r;
4649 }
4650
4651 static int daemon_reload(sd_bus *bus, char **args) {
4652 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4653 const char *method;
4654 int r;
4655
4656 if (arg_action == ACTION_RELOAD)
4657 method = "Reload";
4658 else if (arg_action == ACTION_REEXEC)
4659 method = "Reexecute";
4660 else {
4661 assert(arg_action == ACTION_SYSTEMCTL);
4662
4663 method =
4664 streq(args[0], "clear-jobs") ||
4665 streq(args[0], "cancel") ? "ClearJobs" :
4666 streq(args[0], "daemon-reexec") ? "Reexecute" :
4667 streq(args[0], "reset-failed") ? "ResetFailed" :
4668 streq(args[0], "halt") ? "Halt" :
4669 streq(args[0], "poweroff") ? "PowerOff" :
4670 streq(args[0], "reboot") ? "Reboot" :
4671 streq(args[0], "kexec") ? "KExec" :
4672 streq(args[0], "exit") ? "Exit" :
4673 /* "daemon-reload" */ "Reload";
4674 }
4675
4676 r = sd_bus_call_method(
4677 bus,
4678 "org.freedesktop.systemd1",
4679 "/org/freedesktop/systemd1",
4680 "org.freedesktop.systemd1.Manager",
4681 method,
4682 &error,
4683 NULL,
4684 NULL);
4685
4686 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
4687 /* There's always a fallback possible for
4688 * legacy actions. */
4689 r = -EADDRNOTAVAIL;
4690 else if ((r == -ETIMEDOUT || r == -ECONNRESET) && streq(method, "Reexecute"))
4691 /* On reexecution, we expect a disconnect, not a
4692 * reply */
4693 r = 0;
4694 else if (r < 0)
4695 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
4696
4697 return r < 0 ? r : 0;
4698 }
4699
4700 static int reset_failed(sd_bus *bus, char **args) {
4701 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4702 _cleanup_strv_free_ char **names = NULL;
4703 char **name;
4704 int r, q;
4705
4706 if (strv_length(args) <= 1)
4707 return daemon_reload(bus, args);
4708
4709 r = expand_names(bus, args + 1, NULL, &names);
4710 if (r < 0)
4711 log_error("Failed to expand names: %s", strerror(-r));
4712
4713 STRV_FOREACH(name, names) {
4714 q = sd_bus_call_method(
4715 bus,
4716 "org.freedesktop.systemd1",
4717 "/org/freedesktop/systemd1",
4718 "org.freedesktop.systemd1.Manager",
4719 "ResetFailedUnit",
4720 &error,
4721 NULL,
4722 "s", *name);
4723 if (q < 0) {
4724 log_error("Failed to reset failed state of unit %s: %s",
4725 *name, bus_error_message(&error, r));
4726 if (r == 0)
4727 r = q;
4728 }
4729 }
4730
4731 return r;
4732 }
4733
4734 static int show_environment(sd_bus *bus, char **args) {
4735 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4736 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4737 const char *text;
4738 int r;
4739
4740 pager_open_if_enabled();
4741
4742 r = sd_bus_get_property(
4743 bus,
4744 "org.freedesktop.systemd1",
4745 "/org/freedesktop/systemd1",
4746 "org.freedesktop.systemd1.Manager",
4747 "Environment",
4748 &error,
4749 &reply,
4750 "as");
4751 if (r < 0) {
4752 log_error("Failed to get environment: %s", bus_error_message(&error, r));
4753 return r;
4754 }
4755
4756 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "s");
4757 if (r < 0)
4758 return bus_log_parse_error(r);
4759
4760 while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0)
4761 puts(text);
4762 if (r < 0)
4763 return bus_log_parse_error(r);
4764
4765 r = sd_bus_message_exit_container(reply);
4766 if (r < 0)
4767 return bus_log_parse_error(r);
4768
4769 return 0;
4770 }
4771
4772 static int switch_root(sd_bus *bus, char **args) {
4773 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4774 _cleanup_free_ char *cmdline_init = NULL;
4775 const char *root, *init;
4776 unsigned l;
4777 int r;
4778
4779 l = strv_length(args);
4780 if (l < 2 || l > 3) {
4781 log_error("Wrong number of arguments.");
4782 return -EINVAL;
4783 }
4784
4785 root = args[1];
4786
4787 if (l >= 3)
4788 init = args[2];
4789 else {
4790 r = parse_env_file("/proc/cmdline", WHITESPACE,
4791 "init", &cmdline_init,
4792 NULL);
4793 if (r < 0)
4794 log_debug("Failed to parse /proc/cmdline: %s", strerror(-r));
4795
4796 init = cmdline_init;
4797 }
4798
4799 if (isempty(init))
4800 init = NULL;
4801
4802 if (init) {
4803 const char *root_systemd_path = NULL, *root_init_path = NULL;
4804
4805 root_systemd_path = strappenda(root, "/" SYSTEMD_BINARY_PATH);
4806 root_init_path = strappenda3(root, "/", init);
4807
4808 /* If the passed init is actually the same as the
4809 * systemd binary, then let's suppress it. */
4810 if (files_same(root_init_path, root_systemd_path) > 0)
4811 init = NULL;
4812 }
4813
4814 log_debug("Switching root - root: %s; init: %s", root, strna(init));
4815
4816 r = sd_bus_call_method(
4817 bus,
4818 "org.freedesktop.systemd1",
4819 "/org/freedesktop/systemd1",
4820 "org.freedesktop.systemd1.Manager",
4821 "SwitchRoot",
4822 &error,
4823 NULL,
4824 "ss", root, init);
4825 if (r < 0) {
4826 log_error("Failed to switch root: %s", bus_error_message(&error, r));
4827 return r;
4828 }
4829
4830 return 0;
4831 }
4832
4833 static int set_environment(sd_bus *bus, char **args) {
4834 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4835 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4836 const char *method;
4837 int r;
4838
4839 assert(bus);
4840 assert(args);
4841
4842 method = streq(args[0], "set-environment")
4843 ? "SetEnvironment"
4844 : "UnsetEnvironment";
4845
4846 r = sd_bus_message_new_method_call(
4847 bus,
4848 &m,
4849 "org.freedesktop.systemd1",
4850 "/org/freedesktop/systemd1",
4851 "org.freedesktop.systemd1.Manager",
4852 method);
4853 if (r < 0)
4854 return bus_log_create_error(r);
4855
4856 r = sd_bus_message_append_strv(m, args + 1);
4857 if (r < 0)
4858 return bus_log_create_error(r);
4859
4860 r = sd_bus_call(bus, m, 0, &error, NULL);
4861 if (r < 0) {
4862 log_error("Failed to set environment: %s", bus_error_message(&error, r));
4863 return r;
4864 }
4865
4866 return 0;
4867 }
4868
4869 static int import_environment(sd_bus *bus, char **args) {
4870 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4871 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4872 int r;
4873
4874 assert(bus);
4875 assert(args);
4876
4877 r = sd_bus_message_new_method_call(
4878 bus,
4879 &m,
4880 "org.freedesktop.systemd1",
4881 "/org/freedesktop/systemd1",
4882 "org.freedesktop.systemd1.Manager",
4883 "SetEnvironment");
4884 if (r < 0)
4885 return bus_log_create_error(r);
4886
4887 if (strv_isempty(args + 1))
4888 r = sd_bus_message_append_strv(m, environ);
4889 else {
4890 char **a, **b;
4891
4892 r = sd_bus_message_open_container(m, 'a', "s");
4893 if (r < 0)
4894 return bus_log_create_error(r);
4895
4896 STRV_FOREACH(a, args + 1) {
4897
4898 if (!env_name_is_valid(*a)) {
4899 log_error("Not a valid environment variable name: %s", *a);
4900 return -EINVAL;
4901 }
4902
4903 STRV_FOREACH(b, environ) {
4904 const char *eq;
4905
4906 eq = startswith(*b, *a);
4907 if (eq && *eq == '=') {
4908
4909 r = sd_bus_message_append(m, "s", *b);
4910 if (r < 0)
4911 return bus_log_create_error(r);
4912
4913 break;
4914 }
4915 }
4916 }
4917
4918 r = sd_bus_message_close_container(m);
4919 }
4920 if (r < 0)
4921 return bus_log_create_error(r);
4922
4923 r = sd_bus_call(bus, m, 0, &error, NULL);
4924 if (r < 0) {
4925 log_error("Failed to import environment: %s", bus_error_message(&error, r));
4926 return r;
4927 }
4928
4929 return 0;
4930 }
4931
4932 static int enable_sysv_units(const char *verb, char **args) {
4933 int r = 0;
4934
4935 #if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG)
4936 unsigned f = 1, t = 1;
4937 _cleanup_lookup_paths_free_ LookupPaths paths = {};
4938
4939 if (arg_scope != UNIT_FILE_SYSTEM)
4940 return 0;
4941
4942 if (!streq(verb, "enable") &&
4943 !streq(verb, "disable") &&
4944 !streq(verb, "is-enabled"))
4945 return 0;
4946
4947 /* Processes all SysV units, and reshuffles the array so that
4948 * afterwards only the native units remain */
4949
4950 r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, NULL, NULL, NULL);
4951 if (r < 0)
4952 return r;
4953
4954 r = 0;
4955 for (f = 0; args[f]; f++) {
4956 const char *name;
4957 _cleanup_free_ char *p = NULL, *q = NULL;
4958 bool found_native = false, found_sysv;
4959 unsigned c = 1;
4960 const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL };
4961 char **k, *l;
4962 int j;
4963 pid_t pid;
4964 siginfo_t status;
4965
4966 name = args[f];
4967
4968 if (!endswith(name, ".service"))
4969 continue;
4970
4971 if (path_is_absolute(name))
4972 continue;
4973
4974 STRV_FOREACH(k, paths.unit_path) {
4975 if (!isempty(arg_root))
4976 asprintf(&p, "%s/%s/%s", arg_root, *k, name);
4977 else
4978 asprintf(&p, "%s/%s", *k, name);
4979
4980 if (!p) {
4981 r = log_oom();
4982 goto finish;
4983 }
4984
4985 found_native = access(p, F_OK) >= 0;
4986 free(p);
4987 p = NULL;
4988
4989 if (found_native)
4990 break;
4991 }
4992
4993 if (found_native)
4994 continue;
4995
4996 if (!isempty(arg_root))
4997 asprintf(&p, "%s/" SYSTEM_SYSVINIT_PATH "/%s", arg_root, name);
4998 else
4999 asprintf(&p, SYSTEM_SYSVINIT_PATH "/%s", name);
5000 if (!p) {
5001 r = log_oom();
5002 goto finish;
5003 }
5004
5005 p[strlen(p) - sizeof(".service") + 1] = 0;
5006 found_sysv = access(p, F_OK) >= 0;
5007
5008 if (!found_sysv)
5009 continue;
5010
5011 /* Mark this entry, so that we don't try enabling it as native unit */
5012 args[f] = (char*) "";
5013
5014 log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name);
5015
5016 if (!isempty(arg_root))
5017 argv[c++] = q = strappend("--root=", arg_root);
5018
5019 argv[c++] = basename(p);
5020 argv[c++] =
5021 streq(verb, "enable") ? "on" :
5022 streq(verb, "disable") ? "off" : "--level=5";
5023 argv[c] = NULL;
5024
5025 l = strv_join((char**)argv, " ");
5026 if (!l) {
5027 r = log_oom();
5028 goto finish;
5029 }
5030
5031 log_info("Executing %s", l);
5032 free(l);
5033
5034 pid = fork();
5035 if (pid < 0) {
5036 log_error("Failed to fork: %m");
5037 r = -errno;
5038 goto finish;
5039 } else if (pid == 0) {
5040 /* Child */
5041
5042 execv(argv[0], (char**) argv);
5043 _exit(EXIT_FAILURE);
5044 }
5045
5046 j = wait_for_terminate(pid, &status);
5047 if (j < 0) {
5048 log_error("Failed to wait for child: %s", strerror(-r));
5049 r = j;
5050 goto finish;
5051 }
5052
5053 if (status.si_code == CLD_EXITED) {
5054 if (streq(verb, "is-enabled")) {
5055 if (status.si_status == 0) {
5056 if (!arg_quiet)
5057 puts("enabled");
5058 r = 1;
5059 } else {
5060 if (!arg_quiet)
5061 puts("disabled");
5062 }
5063
5064 } else if (status.si_status != 0) {
5065 r = -EINVAL;
5066 goto finish;
5067 }
5068 } else {
5069 r = -EPROTO;
5070 goto finish;
5071 }
5072 }
5073
5074 finish:
5075 /* Drop all SysV units */
5076 for (f = 0, t = 0; args[f]; f++) {
5077
5078 if (isempty(args[f]))
5079 continue;
5080
5081 args[t++] = args[f];
5082 }
5083
5084 args[t] = NULL;
5085
5086 #endif
5087 return r;
5088 }
5089
5090 static int mangle_names(char **original_names, char ***mangled_names) {
5091 char **i, **l, **name;
5092
5093 l = new(char*, strv_length(original_names) + 1);
5094 if (!l)
5095 return log_oom();
5096
5097 i = l;
5098 STRV_FOREACH(name, original_names) {
5099
5100 /* When enabling units qualified path names are OK,
5101 * too, hence allow them explicitly. */
5102
5103 if (is_path(*name))
5104 *i = strdup(*name);
5105 else
5106 *i = unit_name_mangle(*name, MANGLE_NOGLOB);
5107
5108 if (!*i) {
5109 strv_free(l);
5110 return log_oom();
5111 }
5112
5113 i++;
5114 }
5115
5116 *i = NULL;
5117 *mangled_names = l;
5118
5119 return 0;
5120 }
5121
5122 static int enable_unit(sd_bus *bus, char **args) {
5123 _cleanup_strv_free_ char **names = NULL;
5124 const char *verb = args[0];
5125 UnitFileChange *changes = NULL;
5126 unsigned n_changes = 0;
5127 int carries_install_info = -1;
5128 int r;
5129
5130 if (!args[1])
5131 return 0;
5132
5133 r = mangle_names(args+1, &names);
5134 if (r < 0)
5135 return r;
5136
5137 r = enable_sysv_units(verb, names);
5138 if (r < 0)
5139 return r;
5140
5141 /* If the operation was fully executed by the SysV compat,
5142 * let's finish early */
5143 if (strv_isempty(names))
5144 return 0;
5145
5146 if (!bus || avoid_bus()) {
5147 if (streq(verb, "enable")) {
5148 r = unit_file_enable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5149 carries_install_info = r;
5150 } else if (streq(verb, "disable"))
5151 r = unit_file_disable(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
5152 else if (streq(verb, "reenable")) {
5153 r = unit_file_reenable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5154 carries_install_info = r;
5155 } else if (streq(verb, "link"))
5156 r = unit_file_link(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5157 else if (streq(verb, "preset")) {
5158 r = unit_file_preset(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5159 carries_install_info = r;
5160 } else if (streq(verb, "mask"))
5161 r = unit_file_mask(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5162 else if (streq(verb, "unmask"))
5163 r = unit_file_unmask(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
5164 else
5165 assert_not_reached("Unknown verb");
5166
5167 if (r < 0) {
5168 log_error("Operation failed: %s", strerror(-r));
5169 goto finish;
5170 }
5171
5172 if (!arg_quiet)
5173 dump_unit_file_changes(changes, n_changes);
5174
5175 r = 0;
5176 } else {
5177 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
5178 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5179 int expect_carries_install_info = false;
5180 bool send_force = true;
5181 const char *method;
5182
5183 if (streq(verb, "enable")) {
5184 method = "EnableUnitFiles";
5185 expect_carries_install_info = true;
5186 } else if (streq(verb, "disable")) {
5187 method = "DisableUnitFiles";
5188 send_force = false;
5189 } else if (streq(verb, "reenable")) {
5190 method = "ReenableUnitFiles";
5191 expect_carries_install_info = true;
5192 } else if (streq(verb, "link"))
5193 method = "LinkUnitFiles";
5194 else if (streq(verb, "preset")) {
5195 method = "PresetUnitFiles";
5196 expect_carries_install_info = true;
5197 } else if (streq(verb, "mask"))
5198 method = "MaskUnitFiles";
5199 else if (streq(verb, "unmask")) {
5200 method = "UnmaskUnitFiles";
5201 send_force = false;
5202 } else
5203 assert_not_reached("Unknown verb");
5204
5205 r = sd_bus_message_new_method_call(
5206 bus,
5207 &m,
5208 "org.freedesktop.systemd1",
5209 "/org/freedesktop/systemd1",
5210 "org.freedesktop.systemd1.Manager",
5211 method);
5212 if (r < 0)
5213 return bus_log_create_error(r);
5214
5215 r = sd_bus_message_append_strv(m, names);
5216 if (r < 0)
5217 return bus_log_create_error(r);
5218
5219 r = sd_bus_message_append(m, "b", arg_runtime);
5220 if (r < 0)
5221 return bus_log_create_error(r);
5222
5223 if (send_force) {
5224 r = sd_bus_message_append(m, "b", arg_force);
5225 if (r < 0)
5226 return bus_log_create_error(r);
5227 }
5228
5229 r = sd_bus_call(bus, m, 0, &error, &reply);
5230 if (r < 0) {
5231 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
5232 return r;
5233 }
5234
5235 if (expect_carries_install_info) {
5236 r = sd_bus_message_read(reply, "b", &carries_install_info);
5237 if (r < 0)
5238 return bus_log_parse_error(r);
5239 }
5240
5241 r = deserialize_and_dump_unit_file_changes(reply);
5242 if (r < 0)
5243 return r;
5244
5245 /* Try to reload if enabeld */
5246 if (!arg_no_reload)
5247 r = daemon_reload(bus, args);
5248 else
5249 r = 0;
5250 }
5251
5252 if (carries_install_info == 0)
5253 log_warning("The unit files have no [Install] section. They are not meant to be enabled\n"
5254 "using systemctl.\n"
5255 "Possible reasons for having this kind of units are:\n"
5256 "1) A unit may be statically enabled by being symlinked from another unit's\n"
5257 " .wants/ or .requires/ directory.\n"
5258 "2) A unit's purpose may be to act as a helper for some other unit which has\n"
5259 " a requirement dependency on it.\n"
5260 "3) A unit may be started when needed via activation (socket, path, timer,\n"
5261 " D-Bus, udev, scripted systemctl call, ...).\n");
5262
5263 finish:
5264 unit_file_changes_free(changes, n_changes);
5265
5266 return r;
5267 }
5268
5269 static int unit_is_enabled(sd_bus *bus, char **args) {
5270
5271 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5272 _cleanup_strv_free_ char **names = NULL;
5273 bool enabled;
5274 char **name;
5275 int r;
5276
5277 r = mangle_names(args+1, &names);
5278 if (r < 0)
5279 return r;
5280
5281 r = enable_sysv_units(args[0], names);
5282 if (r < 0)
5283 return r;
5284
5285 enabled = r > 0;
5286
5287 if (!bus || avoid_bus()) {
5288
5289 STRV_FOREACH(name, names) {
5290 UnitFileState state;
5291
5292 state = unit_file_get_state(arg_scope, arg_root, *name);
5293 if (state < 0) {
5294 log_error("Failed to get unit file state for %s: %s", *name, strerror(-state));
5295 return state;
5296 }
5297
5298 if (state == UNIT_FILE_ENABLED ||
5299 state == UNIT_FILE_ENABLED_RUNTIME ||
5300 state == UNIT_FILE_STATIC)
5301 enabled = true;
5302
5303 if (!arg_quiet)
5304 puts(unit_file_state_to_string(state));
5305 }
5306
5307 } else {
5308 STRV_FOREACH(name, names) {
5309 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
5310 const char *s;
5311
5312 r = sd_bus_call_method(
5313 bus,
5314 "org.freedesktop.systemd1",
5315 "/org/freedesktop/systemd1",
5316 "org.freedesktop.systemd1.Manager",
5317 "GetUnitFileState",
5318 &error,
5319 &reply,
5320 "s", *name);
5321 if (r < 0) {
5322 log_error("Failed to get unit file state for %s: %s", *name, bus_error_message(&error, r));
5323 return r;
5324 }
5325
5326 r = sd_bus_message_read(reply, "s", &s);
5327 if (r < 0)
5328 return bus_log_parse_error(r);
5329
5330 if (streq(s, "enabled") ||
5331 streq(s, "enabled-runtime") ||
5332 streq(s, "static"))
5333 enabled = true;
5334
5335 if (!arg_quiet)
5336 puts(s);
5337 }
5338 }
5339
5340 return !enabled;
5341 }
5342
5343 static int systemctl_help(void) {
5344
5345 pager_open_if_enabled();
5346
5347 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
5348 "Query or send control commands to the systemd manager.\n\n"
5349 " -h --help Show this help\n"
5350 " --version Show package version\n"
5351 " --system Connect to system manager\n"
5352 " --user Connect to user service manager\n"
5353 " -H --host=[USER@]HOST\n"
5354 " Operate on remote host\n"
5355 " -M --machine=CONTAINER\n"
5356 " Operate on local container\n"
5357 " -t --type=TYPE List only units of a particular type\n"
5358 " --state=STATE List only units with particular LOAD or SUB or ACTIVE state\n"
5359 " -p --property=NAME Show only properties by this name\n"
5360 " -a --all Show all loaded units/properties, including dead/empty\n"
5361 " ones. To list all units installed on the system, use\n"
5362 " the 'list-unit-files' command instead.\n"
5363 " -l --full Don't ellipsize unit names on output\n"
5364 " -r --recursive Show unit list of host and local containers\n"
5365 " --reverse Show reverse dependencies with 'list-dependencies'\n"
5366 " --job-mode=MODE Specify how to deal with already queued jobs, when\n"
5367 " queueing a new job\n"
5368 " --show-types When showing sockets, explicitly show their type\n"
5369 " -i --ignore-inhibitors\n"
5370 " When shutting down or sleeping, ignore inhibitors\n"
5371 " --kill-who=WHO Who to send signal to\n"
5372 " -s --signal=SIGNAL Which signal to send\n"
5373 " -q --quiet Suppress output\n"
5374 " --no-block Do not wait until operation finished\n"
5375 " --no-wall Don't send wall message before halt/power-off/reboot\n"
5376 " --no-reload When enabling/disabling unit files, don't reload daemon\n"
5377 " configuration\n"
5378 " --no-legend Do not print a legend (column headers and hints)\n"
5379 " --no-pager Do not pipe output into a pager\n"
5380 " --no-ask-password\n"
5381 " Do not ask for system passwords\n"
5382 " --global Enable/disable unit files globally\n"
5383 " --runtime Enable unit files only temporarily until next reboot\n"
5384 " -f --force When enabling unit files, override existing symlinks\n"
5385 " When shutting down, execute action immediately\n"
5386 " --root=PATH Enable unit files in the specified root directory\n"
5387 " -n --lines=INTEGER Number of journal entries to show\n"
5388 " -o --output=STRING Change journal output mode (short, short-monotonic,\n"
5389 " verbose, export, json, json-pretty, json-sse, cat)\n"
5390 " --plain Print unit dependencies as a list instead of a tree\n\n"
5391 "Unit Commands:\n"
5392 " list-units [PATTERN...] List loaded units\n"
5393 " list-sockets [PATTERN...] List loaded sockets ordered by address\n"
5394 " list-timers [PATTERN...] List loaded timers ordered by next elapse\n"
5395 " start NAME... Start (activate) one or more units\n"
5396 " stop NAME... Stop (deactivate) one or more units\n"
5397 " reload NAME... Reload one or more units\n"
5398 " restart NAME... Start or restart one or more units\n"
5399 " try-restart NAME... Restart one or more units if active\n"
5400 " reload-or-restart NAME... Reload one or more units if possible,\n"
5401 " otherwise start or restart\n"
5402 " reload-or-try-restart NAME... Reload one or more units if possible,\n"
5403 " otherwise restart if active\n"
5404 " isolate NAME Start one unit and stop all others\n"
5405 " kill NAME... Send signal to processes of a unit\n"
5406 " is-active NAME... Check whether units are active\n"
5407 " is-failed NAME... Check whether units are failed\n"
5408 " status [NAME...|PID...] Show runtime status of one or more units\n"
5409 " show [NAME...|JOB...] Show properties of one or more\n"
5410 " units/jobs or the manager\n"
5411 " cat NAME... Show files and drop-ins of one or more units\n"
5412 " set-property NAME ASSIGNMENT... Sets one or more properties of a unit\n"
5413 " help NAME...|PID... Show manual for one or more units\n"
5414 " reset-failed [NAME...] Reset failed state for all, one, or more\n"
5415 " units\n"
5416 " list-dependencies [NAME] Recursively show units which are required\n"
5417 " or wanted by this unit or by which this\n"
5418 " unit is required or wanted\n\n"
5419 "Unit File Commands:\n"
5420 " list-unit-files [PATTERN...] List installed unit files\n"
5421 " enable NAME... Enable one or more unit files\n"
5422 " disable NAME... Disable one or more unit files\n"
5423 " reenable NAME... Reenable one or more unit files\n"
5424 " preset NAME... Enable/disable one or more unit files\n"
5425 " based on preset configuration\n"
5426 " is-enabled NAME... Check whether unit files are enabled\n\n"
5427 " mask NAME... Mask one or more units\n"
5428 " unmask NAME... Unmask one or more units\n"
5429 " link PATH... Link one or more units files into\n"
5430 " the search path\n"
5431 " get-default Get the name of the default target\n"
5432 " set-default NAME Set the default target\n\n"
5433 "Machine Commands:\n"
5434 " list-machines [PATTERN...] List local containers and host\n\n"
5435 "Job Commands:\n"
5436 " list-jobs [PATTERN...] List jobs\n"
5437 " cancel [JOB...] Cancel all, one, or more jobs\n\n"
5438 "Snapshot Commands:\n"
5439 " snapshot [NAME] Create a snapshot\n"
5440 " delete NAME... Remove one or more snapshots\n\n"
5441 "Environment Commands:\n"
5442 " show-environment Dump environment\n"
5443 " set-environment NAME=VALUE... Set one or more environment variables\n"
5444 " unset-environment NAME... Unset one or more environment variables\n"
5445 " import-environment NAME... Import all, one or more environment variables\n\n"
5446 "Manager Lifecycle Commands:\n"
5447 " daemon-reload Reload systemd manager configuration\n"
5448 " daemon-reexec Reexecute systemd manager\n\n"
5449 "System Commands:\n"
5450 " default Enter system default mode\n"
5451 " rescue Enter system rescue mode\n"
5452 " emergency Enter system emergency mode\n"
5453 " halt Shut down and halt the system\n"
5454 " poweroff Shut down and power-off the system\n"
5455 " reboot [ARG] Shut down and reboot the system\n"
5456 " kexec Shut down and reboot the system with kexec\n"
5457 " exit Request user instance exit\n"
5458 " switch-root ROOT [INIT] Change to a different root file system\n"
5459 " suspend Suspend the system\n"
5460 " hibernate Hibernate the system\n"
5461 " hybrid-sleep Hibernate and suspend the system\n",
5462 program_invocation_short_name);
5463
5464 return 0;
5465 }
5466
5467 static int halt_help(void) {
5468
5469 printf("%s [OPTIONS...]%s\n\n"
5470 "%s the system.\n\n"
5471 " --help Show this help\n"
5472 " --halt Halt the machine\n"
5473 " -p --poweroff Switch off the machine\n"
5474 " --reboot Reboot the machine\n"
5475 " -f --force Force immediate halt/power-off/reboot\n"
5476 " -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
5477 " -d --no-wtmp Don't write wtmp record\n"
5478 " --no-wall Don't send wall message before halt/power-off/reboot\n",
5479 program_invocation_short_name,
5480 arg_action == ACTION_REBOOT ? " [ARG]" : "",
5481 arg_action == ACTION_REBOOT ? "Reboot" :
5482 arg_action == ACTION_POWEROFF ? "Power off" :
5483 "Halt");
5484
5485 return 0;
5486 }
5487
5488 static int shutdown_help(void) {
5489
5490 printf("%s [OPTIONS...] [TIME] [WALL...]\n\n"
5491 "Shut down the system.\n\n"
5492 " --help Show this help\n"
5493 " -H --halt Halt the machine\n"
5494 " -P --poweroff Power-off the machine\n"
5495 " -r --reboot Reboot the machine\n"
5496 " -h Equivalent to --poweroff, overridden by --halt\n"
5497 " -k Don't halt/power-off/reboot, just send warnings\n"
5498 " --no-wall Don't send wall message before halt/power-off/reboot\n"
5499 " -c Cancel a pending shutdown\n",
5500 program_invocation_short_name);
5501
5502 return 0;
5503 }
5504
5505 static int telinit_help(void) {
5506
5507 printf("%s [OPTIONS...] {COMMAND}\n\n"
5508 "Send control commands to the init daemon.\n\n"
5509 " --help Show this help\n"
5510 " --no-wall Don't send wall message before halt/power-off/reboot\n\n"
5511 "Commands:\n"
5512 " 0 Power-off the machine\n"
5513 " 6 Reboot the machine\n"
5514 " 2, 3, 4, 5 Start runlevelX.target unit\n"
5515 " 1, s, S Enter rescue mode\n"
5516 " q, Q Reload init daemon configuration\n"
5517 " u, U Reexecute init daemon\n",
5518 program_invocation_short_name);
5519
5520 return 0;
5521 }
5522
5523 static int runlevel_help(void) {
5524
5525 printf("%s [OPTIONS...]\n\n"
5526 "Prints the previous and current runlevel of the init system.\n\n"
5527 " --help Show this help\n",
5528 program_invocation_short_name);
5529
5530 return 0;
5531 }
5532
5533 static int help_types(void) {
5534 int i;
5535 const char *t;
5536
5537 puts("Available unit types:");
5538 for (i = 0; i < _UNIT_TYPE_MAX; i++) {
5539 t = unit_type_to_string(i);
5540 if (t)
5541 puts(t);
5542 }
5543
5544 return 0;
5545 }
5546
5547 static int systemctl_parse_argv(int argc, char *argv[]) {
5548
5549 enum {
5550 ARG_FAIL = 0x100,
5551 ARG_REVERSE,
5552 ARG_AFTER,
5553 ARG_BEFORE,
5554 ARG_SHOW_TYPES,
5555 ARG_IRREVERSIBLE,
5556 ARG_IGNORE_DEPENDENCIES,
5557 ARG_VERSION,
5558 ARG_USER,
5559 ARG_SYSTEM,
5560 ARG_GLOBAL,
5561 ARG_NO_BLOCK,
5562 ARG_NO_LEGEND,
5563 ARG_NO_PAGER,
5564 ARG_NO_WALL,
5565 ARG_ROOT,
5566 ARG_NO_RELOAD,
5567 ARG_KILL_WHO,
5568 ARG_NO_ASK_PASSWORD,
5569 ARG_FAILED,
5570 ARG_RUNTIME,
5571 ARG_FORCE,
5572 ARG_PLAIN,
5573 ARG_STATE,
5574 ARG_JOB_MODE
5575 };
5576
5577 static const struct option options[] = {
5578 { "help", no_argument, NULL, 'h' },
5579 { "version", no_argument, NULL, ARG_VERSION },
5580 { "type", required_argument, NULL, 't' },
5581 { "property", required_argument, NULL, 'p' },
5582 { "all", no_argument, NULL, 'a' },
5583 { "reverse", no_argument, NULL, ARG_REVERSE },
5584 { "after", no_argument, NULL, ARG_AFTER },
5585 { "before", no_argument, NULL, ARG_BEFORE },
5586 { "show-types", no_argument, NULL, ARG_SHOW_TYPES },
5587 { "failed", no_argument, NULL, ARG_FAILED }, /* compatibility only */
5588 { "full", no_argument, NULL, 'l' },
5589 { "job-mode", required_argument, NULL, ARG_JOB_MODE },
5590 { "fail", no_argument, NULL, ARG_FAIL }, /* compatibility only */
5591 { "irreversible", no_argument, NULL, ARG_IRREVERSIBLE }, /* compatibility only */
5592 { "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES }, /* compatibility only */
5593 { "ignore-inhibitors", no_argument, NULL, 'i' },
5594 { "user", no_argument, NULL, ARG_USER },
5595 { "system", no_argument, NULL, ARG_SYSTEM },
5596 { "global", no_argument, NULL, ARG_GLOBAL },
5597 { "no-block", no_argument, NULL, ARG_NO_BLOCK },
5598 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
5599 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
5600 { "no-wall", no_argument, NULL, ARG_NO_WALL },
5601 { "quiet", no_argument, NULL, 'q' },
5602 { "root", required_argument, NULL, ARG_ROOT },
5603 { "force", no_argument, NULL, ARG_FORCE },
5604 { "no-reload", no_argument, NULL, ARG_NO_RELOAD },
5605 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
5606 { "signal", required_argument, NULL, 's' },
5607 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
5608 { "host", required_argument, NULL, 'H' },
5609 { "machine", required_argument, NULL, 'M' },
5610 { "runtime", no_argument, NULL, ARG_RUNTIME },
5611 { "lines", required_argument, NULL, 'n' },
5612 { "output", required_argument, NULL, 'o' },
5613 { "plain", no_argument, NULL, ARG_PLAIN },
5614 { "state", required_argument, NULL, ARG_STATE },
5615 { "recursive", no_argument, NULL, 'r' },
5616 {}
5617 };
5618
5619 int c;
5620
5621 assert(argc >= 0);
5622 assert(argv);
5623
5624 while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:M:n:o:ir", options, NULL)) >= 0) {
5625
5626 switch (c) {
5627
5628 case 'h':
5629 return systemctl_help();
5630
5631 case ARG_VERSION:
5632 puts(PACKAGE_STRING);
5633 puts(SYSTEMD_FEATURES);
5634 return 0;
5635
5636 case 't': {
5637 char *word, *state;
5638 size_t size;
5639
5640 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
5641 _cleanup_free_ char *type;
5642
5643 type = strndup(word, size);
5644 if (!type)
5645 return -ENOMEM;
5646
5647 if (streq(type, "help")) {
5648 help_types();
5649 return 0;
5650 }
5651
5652 if (unit_type_from_string(type) >= 0) {
5653 if (strv_push(&arg_types, type))
5654 return log_oom();
5655 type = NULL;
5656 continue;
5657 }
5658
5659 /* It's much nicer to use --state= for
5660 * load states, but let's support this
5661 * in --types= too for compatibility
5662 * with old versions */
5663 if (unit_load_state_from_string(optarg) >= 0) {
5664 if (strv_push(&arg_states, type) < 0)
5665 return log_oom();
5666 type = NULL;
5667 continue;
5668 }
5669
5670 log_error("Unknown unit type or load state '%s'.", type);
5671 log_info("Use -t help to see a list of allowed values.");
5672 return -EINVAL;
5673 }
5674
5675 break;
5676 }
5677
5678 case 'p': {
5679 /* Make sure that if the empty property list
5680 was specified, we won't show any properties. */
5681 if (isempty(optarg) && !arg_properties) {
5682 arg_properties = new0(char*, 1);
5683 if (!arg_properties)
5684 return log_oom();
5685 } else {
5686 char *word, *state;
5687 size_t size;
5688
5689 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
5690 char *prop;
5691
5692 prop = strndup(word, size);
5693 if (!prop)
5694 return log_oom();
5695
5696 if (strv_consume(&arg_properties, prop) < 0)
5697 return log_oom();
5698 }
5699 }
5700
5701 /* If the user asked for a particular
5702 * property, show it to him, even if it is
5703 * empty. */
5704 arg_all = true;
5705
5706 break;
5707 }
5708
5709 case 'a':
5710 arg_all = true;
5711 break;
5712
5713 case ARG_REVERSE:
5714 arg_dependency = DEPENDENCY_REVERSE;
5715 break;
5716
5717 case ARG_AFTER:
5718 arg_dependency = DEPENDENCY_AFTER;
5719 break;
5720
5721 case ARG_BEFORE:
5722 arg_dependency = DEPENDENCY_BEFORE;
5723 break;
5724
5725 case ARG_SHOW_TYPES:
5726 arg_show_types = true;
5727 break;
5728
5729 case ARG_JOB_MODE:
5730 arg_job_mode = optarg;
5731 break;
5732
5733 case ARG_FAIL:
5734 arg_job_mode = "fail";
5735 break;
5736
5737 case ARG_IRREVERSIBLE:
5738 arg_job_mode = "replace-irreversibly";
5739 break;
5740
5741 case ARG_IGNORE_DEPENDENCIES:
5742 arg_job_mode = "ignore-dependencies";
5743 break;
5744
5745 case ARG_USER:
5746 arg_scope = UNIT_FILE_USER;
5747 break;
5748
5749 case ARG_SYSTEM:
5750 arg_scope = UNIT_FILE_SYSTEM;
5751 break;
5752
5753 case ARG_GLOBAL:
5754 arg_scope = UNIT_FILE_GLOBAL;
5755 break;
5756
5757 case ARG_NO_BLOCK:
5758 arg_no_block = true;
5759 break;
5760
5761 case ARG_NO_LEGEND:
5762 arg_no_legend = true;
5763 break;
5764
5765 case ARG_NO_PAGER:
5766 arg_no_pager = true;
5767 break;
5768
5769 case ARG_NO_WALL:
5770 arg_no_wall = true;
5771 break;
5772
5773 case ARG_ROOT:
5774 arg_root = optarg;
5775 break;
5776
5777 case 'l':
5778 arg_full = true;
5779 break;
5780
5781 case ARG_FAILED:
5782 if (strv_extend(&arg_states, "failed") < 0)
5783 return log_oom();
5784
5785 break;
5786
5787 case 'q':
5788 arg_quiet = true;
5789 break;
5790
5791 case ARG_FORCE:
5792 arg_force ++;
5793 break;
5794
5795 case 'f':
5796 arg_force ++;
5797 break;
5798
5799 case ARG_NO_RELOAD:
5800 arg_no_reload = true;
5801 break;
5802
5803 case ARG_KILL_WHO:
5804 arg_kill_who = optarg;
5805 break;
5806
5807 case 's':
5808 if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) {
5809 log_error("Failed to parse signal string %s.", optarg);
5810 return -EINVAL;
5811 }
5812 break;
5813
5814 case ARG_NO_ASK_PASSWORD:
5815 arg_ask_password = false;
5816 break;
5817
5818 case 'H':
5819 arg_transport = BUS_TRANSPORT_REMOTE;
5820 arg_host = optarg;
5821 break;
5822
5823 case 'M':
5824 arg_transport = BUS_TRANSPORT_CONTAINER;
5825 arg_host = optarg;
5826 break;
5827
5828 case ARG_RUNTIME:
5829 arg_runtime = true;
5830 break;
5831
5832 case 'n':
5833 if (safe_atou(optarg, &arg_lines) < 0) {
5834 log_error("Failed to parse lines '%s'", optarg);
5835 return -EINVAL;
5836 }
5837 break;
5838
5839 case 'o':
5840 arg_output = output_mode_from_string(optarg);
5841 if (arg_output < 0) {
5842 log_error("Unknown output '%s'.", optarg);
5843 return -EINVAL;
5844 }
5845 break;
5846
5847 case 'i':
5848 arg_ignore_inhibitors = true;
5849 break;
5850
5851 case ARG_PLAIN:
5852 arg_plain = true;
5853 break;
5854
5855 case ARG_STATE: {
5856 char *word, *state;
5857 size_t size;
5858
5859 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
5860 char *s;
5861
5862 s = strndup(word, size);
5863 if (!s)
5864 return log_oom();
5865
5866 if (strv_consume(&arg_states, s) < 0)
5867 return log_oom();
5868 }
5869 break;
5870 }
5871
5872 case 'r':
5873 if (geteuid() != 0) {
5874 log_error("--recursive requires root priviliges.");
5875 return -EPERM;
5876 }
5877
5878 arg_recursive = true;
5879 break;
5880
5881 case '?':
5882 return -EINVAL;
5883
5884 default:
5885 assert_not_reached("Unhandled option");
5886 }
5887 }
5888
5889 if (arg_transport != BUS_TRANSPORT_LOCAL && arg_scope != UNIT_FILE_SYSTEM) {
5890 log_error("Cannot access user instance remotely.");
5891 return -EINVAL;
5892 }
5893
5894 return 1;
5895 }
5896
5897 static int halt_parse_argv(int argc, char *argv[]) {
5898
5899 enum {
5900 ARG_HELP = 0x100,
5901 ARG_HALT,
5902 ARG_REBOOT,
5903 ARG_NO_WALL
5904 };
5905
5906 static const struct option options[] = {
5907 { "help", no_argument, NULL, ARG_HELP },
5908 { "halt", no_argument, NULL, ARG_HALT },
5909 { "poweroff", no_argument, NULL, 'p' },
5910 { "reboot", no_argument, NULL, ARG_REBOOT },
5911 { "force", no_argument, NULL, 'f' },
5912 { "wtmp-only", no_argument, NULL, 'w' },
5913 { "no-wtmp", no_argument, NULL, 'd' },
5914 { "no-wall", no_argument, NULL, ARG_NO_WALL },
5915 {}
5916 };
5917
5918 int c, r, runlevel;
5919
5920 assert(argc >= 0);
5921 assert(argv);
5922
5923 if (utmp_get_runlevel(&runlevel, NULL) >= 0)
5924 if (runlevel == '0' || runlevel == '6')
5925 arg_force = 2;
5926
5927 while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) {
5928 switch (c) {
5929
5930 case ARG_HELP:
5931 return halt_help();
5932
5933 case ARG_HALT:
5934 arg_action = ACTION_HALT;
5935 break;
5936
5937 case 'p':
5938 if (arg_action != ACTION_REBOOT)
5939 arg_action = ACTION_POWEROFF;
5940 break;
5941
5942 case ARG_REBOOT:
5943 arg_action = ACTION_REBOOT;
5944 break;
5945
5946 case 'f':
5947 arg_force = 2;
5948 break;
5949
5950 case 'w':
5951 arg_dry = true;
5952 break;
5953
5954 case 'd':
5955 arg_no_wtmp = true;
5956 break;
5957
5958 case ARG_NO_WALL:
5959 arg_no_wall = true;
5960 break;
5961
5962 case 'i':
5963 case 'h':
5964 case 'n':
5965 /* Compatibility nops */
5966 break;
5967
5968 case '?':
5969 return -EINVAL;
5970
5971 default:
5972 assert_not_reached("Unhandled option");
5973 }
5974 }
5975
5976 if (arg_action == ACTION_REBOOT && argc == optind + 1) {
5977 r = write_string_file(REBOOT_PARAM_FILE, argv[optind]);
5978 if (r < 0) {
5979 log_error("Failed to write reboot param to "
5980 REBOOT_PARAM_FILE": %s", strerror(-r));
5981 return r;
5982 }
5983 } else if (optind < argc) {
5984 log_error("Too many arguments.");
5985 return -EINVAL;
5986 }
5987
5988 return 1;
5989 }
5990
5991 static int parse_time_spec(const char *t, usec_t *_u) {
5992 assert(t);
5993 assert(_u);
5994
5995 if (streq(t, "now"))
5996 *_u = 0;
5997 else if (!strchr(t, ':')) {
5998 uint64_t u;
5999
6000 if (safe_atou64(t, &u) < 0)
6001 return -EINVAL;
6002
6003 *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u;
6004 } else {
6005 char *e = NULL;
6006 long hour, minute;
6007 struct tm tm = {};
6008 time_t s;
6009 usec_t n;
6010
6011 errno = 0;
6012 hour = strtol(t, &e, 10);
6013 if (errno > 0 || *e != ':' || hour < 0 || hour > 23)
6014 return -EINVAL;
6015
6016 minute = strtol(e+1, &e, 10);
6017 if (errno > 0 || *e != 0 || minute < 0 || minute > 59)
6018 return -EINVAL;
6019
6020 n = now(CLOCK_REALTIME);
6021 s = (time_t) (n / USEC_PER_SEC);
6022
6023 assert_se(localtime_r(&s, &tm));
6024
6025 tm.tm_hour = (int) hour;
6026 tm.tm_min = (int) minute;
6027 tm.tm_sec = 0;
6028
6029 assert_se(s = mktime(&tm));
6030
6031 *_u = (usec_t) s * USEC_PER_SEC;
6032
6033 while (*_u <= n)
6034 *_u += USEC_PER_DAY;
6035 }
6036
6037 return 0;
6038 }
6039
6040 static int shutdown_parse_argv(int argc, char *argv[]) {
6041
6042 enum {
6043 ARG_HELP = 0x100,
6044 ARG_NO_WALL
6045 };
6046
6047 static const struct option options[] = {
6048 { "help", no_argument, NULL, ARG_HELP },
6049 { "halt", no_argument, NULL, 'H' },
6050 { "poweroff", no_argument, NULL, 'P' },
6051 { "reboot", no_argument, NULL, 'r' },
6052 { "kexec", no_argument, NULL, 'K' }, /* not documented extension */
6053 { "no-wall", no_argument, NULL, ARG_NO_WALL },
6054 {}
6055 };
6056
6057 int c, r;
6058
6059 assert(argc >= 0);
6060 assert(argv);
6061
6062 while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0) {
6063 switch (c) {
6064
6065 case ARG_HELP:
6066 return shutdown_help();
6067
6068 case 'H':
6069 arg_action = ACTION_HALT;
6070 break;
6071
6072 case 'P':
6073 arg_action = ACTION_POWEROFF;
6074 break;
6075
6076 case 'r':
6077 if (kexec_loaded())
6078 arg_action = ACTION_KEXEC;
6079 else
6080 arg_action = ACTION_REBOOT;
6081 break;
6082
6083 case 'K':
6084 arg_action = ACTION_KEXEC;
6085 break;
6086
6087 case 'h':
6088 if (arg_action != ACTION_HALT)
6089 arg_action = ACTION_POWEROFF;
6090 break;
6091
6092 case 'k':
6093 arg_dry = true;
6094 break;
6095
6096 case ARG_NO_WALL:
6097 arg_no_wall = true;
6098 break;
6099
6100 case 't':
6101 case 'a':
6102 /* Compatibility nops */
6103 break;
6104
6105 case 'c':
6106 arg_action = ACTION_CANCEL_SHUTDOWN;
6107 break;
6108
6109 case '?':
6110 return -EINVAL;
6111
6112 default:
6113 assert_not_reached("Unhandled option");
6114 }
6115 }
6116
6117 if (argc > optind && arg_action != ACTION_CANCEL_SHUTDOWN) {
6118 r = parse_time_spec(argv[optind], &arg_when);
6119 if (r < 0) {
6120 log_error("Failed to parse time specification: %s", argv[optind]);
6121 return r;
6122 }
6123 } else
6124 arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
6125
6126 if (argc > optind && arg_action == ACTION_CANCEL_SHUTDOWN)
6127 /* No time argument for shutdown cancel */
6128 arg_wall = argv + optind;
6129 else if (argc > optind + 1)
6130 /* We skip the time argument */
6131 arg_wall = argv + optind + 1;
6132
6133 optind = argc;
6134
6135 return 1;
6136 }
6137
6138 static int telinit_parse_argv(int argc, char *argv[]) {
6139
6140 enum {
6141 ARG_HELP = 0x100,
6142 ARG_NO_WALL
6143 };
6144
6145 static const struct option options[] = {
6146 { "help", no_argument, NULL, ARG_HELP },
6147 { "no-wall", no_argument, NULL, ARG_NO_WALL },
6148 {}
6149 };
6150
6151 static const struct {
6152 char from;
6153 enum action to;
6154 } table[] = {
6155 { '0', ACTION_POWEROFF },
6156 { '6', ACTION_REBOOT },
6157 { '1', ACTION_RESCUE },
6158 { '2', ACTION_RUNLEVEL2 },
6159 { '3', ACTION_RUNLEVEL3 },
6160 { '4', ACTION_RUNLEVEL4 },
6161 { '5', ACTION_RUNLEVEL5 },
6162 { 's', ACTION_RESCUE },
6163 { 'S', ACTION_RESCUE },
6164 { 'q', ACTION_RELOAD },
6165 { 'Q', ACTION_RELOAD },
6166 { 'u', ACTION_REEXEC },
6167 { 'U', ACTION_REEXEC }
6168 };
6169
6170 unsigned i;
6171 int c;
6172
6173 assert(argc >= 0);
6174 assert(argv);
6175
6176 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
6177 switch (c) {
6178
6179 case ARG_HELP:
6180 return telinit_help();
6181
6182 case ARG_NO_WALL:
6183 arg_no_wall = true;
6184 break;
6185
6186 case '?':
6187 return -EINVAL;
6188
6189 default:
6190 assert_not_reached("Unhandled option");
6191 }
6192 }
6193
6194 if (optind >= argc) {
6195 telinit_help();
6196 return -EINVAL;
6197 }
6198
6199 if (optind + 1 < argc) {
6200 log_error("Too many arguments.");
6201 return -EINVAL;
6202 }
6203
6204 if (strlen(argv[optind]) != 1) {
6205 log_error("Expected single character argument.");
6206 return -EINVAL;
6207 }
6208
6209 for (i = 0; i < ELEMENTSOF(table); i++)
6210 if (table[i].from == argv[optind][0])
6211 break;
6212
6213 if (i >= ELEMENTSOF(table)) {
6214 log_error("Unknown command '%s'.", argv[optind]);
6215 return -EINVAL;
6216 }
6217
6218 arg_action = table[i].to;
6219
6220 optind ++;
6221
6222 return 1;
6223 }
6224
6225 static int runlevel_parse_argv(int argc, char *argv[]) {
6226
6227 enum {
6228 ARG_HELP = 0x100,
6229 };
6230
6231 static const struct option options[] = {
6232 { "help", no_argument, NULL, ARG_HELP },
6233 {}
6234 };
6235
6236 int c;
6237
6238 assert(argc >= 0);
6239 assert(argv);
6240
6241 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
6242 switch (c) {
6243
6244 case ARG_HELP:
6245 return runlevel_help();
6246
6247 case '?':
6248 return -EINVAL;
6249
6250 default:
6251 assert_not_reached("Unhandled option");
6252 }
6253 }
6254
6255 if (optind < argc) {
6256 log_error("Too many arguments.");
6257 return -EINVAL;
6258 }
6259
6260 return 1;
6261 }
6262
6263 static int parse_argv(int argc, char *argv[]) {
6264 assert(argc >= 0);
6265 assert(argv);
6266
6267 if (program_invocation_short_name) {
6268
6269 if (strstr(program_invocation_short_name, "halt")) {
6270 arg_action = ACTION_HALT;
6271 return halt_parse_argv(argc, argv);
6272 } else if (strstr(program_invocation_short_name, "poweroff")) {
6273 arg_action = ACTION_POWEROFF;
6274 return halt_parse_argv(argc, argv);
6275 } else if (strstr(program_invocation_short_name, "reboot")) {
6276 if (kexec_loaded())
6277 arg_action = ACTION_KEXEC;
6278 else
6279 arg_action = ACTION_REBOOT;
6280 return halt_parse_argv(argc, argv);
6281 } else if (strstr(program_invocation_short_name, "shutdown")) {
6282 arg_action = ACTION_POWEROFF;
6283 return shutdown_parse_argv(argc, argv);
6284 } else if (strstr(program_invocation_short_name, "init")) {
6285
6286 if (sd_booted() > 0) {
6287 arg_action = _ACTION_INVALID;
6288 return telinit_parse_argv(argc, argv);
6289 } else {
6290 /* Hmm, so some other init system is
6291 * running, we need to forward this
6292 * request to it. For now we simply
6293 * guess that it is Upstart. */
6294
6295 execv(TELINIT, argv);
6296
6297 log_error("Couldn't find an alternative telinit implementation to spawn.");
6298 return -EIO;
6299 }
6300
6301 } else if (strstr(program_invocation_short_name, "runlevel")) {
6302 arg_action = ACTION_RUNLEVEL;
6303 return runlevel_parse_argv(argc, argv);
6304 }
6305 }
6306
6307 arg_action = ACTION_SYSTEMCTL;
6308 return systemctl_parse_argv(argc, argv);
6309 }
6310
6311 _pure_ static int action_to_runlevel(void) {
6312
6313 static const char table[_ACTION_MAX] = {
6314 [ACTION_HALT] = '0',
6315 [ACTION_POWEROFF] = '0',
6316 [ACTION_REBOOT] = '6',
6317 [ACTION_RUNLEVEL2] = '2',
6318 [ACTION_RUNLEVEL3] = '3',
6319 [ACTION_RUNLEVEL4] = '4',
6320 [ACTION_RUNLEVEL5] = '5',
6321 [ACTION_RESCUE] = '1'
6322 };
6323
6324 assert(arg_action < _ACTION_MAX);
6325
6326 return table[arg_action];
6327 }
6328
6329 static int talk_initctl(void) {
6330
6331 struct init_request request = {
6332 .magic = INIT_MAGIC,
6333 .sleeptime = 0,
6334 .cmd = INIT_CMD_RUNLVL
6335 };
6336
6337 _cleanup_close_ int fd = -1;
6338 char rl;
6339 int r;
6340
6341 rl = action_to_runlevel();
6342 if (!rl)
6343 return 0;
6344
6345 request.runlevel = rl;
6346
6347 fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY);
6348 if (fd < 0) {
6349 if (errno == ENOENT)
6350 return 0;
6351
6352 log_error("Failed to open "INIT_FIFO": %m");
6353 return -errno;
6354 }
6355
6356 errno = 0;
6357 r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
6358 if (r) {
6359 log_error("Failed to write to "INIT_FIFO": %m");
6360 return errno > 0 ? -errno : -EIO;
6361 }
6362
6363 return 1;
6364 }
6365
6366 static int systemctl_main(sd_bus *bus, int argc, char *argv[], int bus_error) {
6367
6368 static const struct {
6369 const char* verb;
6370 const enum {
6371 MORE,
6372 LESS,
6373 EQUAL
6374 } argc_cmp;
6375 const int argc;
6376 int (* const dispatch)(sd_bus *bus, char **args);
6377 const enum {
6378 NOBUS = 1,
6379 FORCE,
6380 } bus;
6381 } verbs[] = {
6382 { "list-units", MORE, 0, list_units },
6383 { "list-unit-files", MORE, 1, list_unit_files, NOBUS },
6384 { "list-sockets", MORE, 1, list_sockets },
6385 { "list-timers", MORE, 1, list_timers },
6386 { "list-jobs", MORE, 1, list_jobs },
6387 { "list-machines", MORE, 1, list_machines },
6388 { "clear-jobs", EQUAL, 1, daemon_reload },
6389 { "cancel", MORE, 2, cancel_job },
6390 { "start", MORE, 2, start_unit },
6391 { "stop", MORE, 2, start_unit },
6392 { "condstop", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
6393 { "reload", MORE, 2, start_unit },
6394 { "restart", MORE, 2, start_unit },
6395 { "try-restart", MORE, 2, start_unit },
6396 { "reload-or-restart", MORE, 2, start_unit },
6397 { "reload-or-try-restart", MORE, 2, start_unit },
6398 { "force-reload", MORE, 2, start_unit }, /* For compatibility with SysV */
6399 { "condreload", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
6400 { "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */
6401 { "isolate", EQUAL, 2, start_unit },
6402 { "kill", MORE, 2, kill_unit },
6403 { "is-active", MORE, 2, check_unit_active },
6404 { "check", MORE, 2, check_unit_active },
6405 { "is-failed", MORE, 2, check_unit_failed },
6406 { "show", MORE, 1, show },
6407 { "cat", MORE, 2, cat },
6408 { "status", MORE, 1, show },
6409 { "help", MORE, 2, show },
6410 { "snapshot", LESS, 2, snapshot },
6411 { "delete", MORE, 2, delete_snapshot },
6412 { "daemon-reload", EQUAL, 1, daemon_reload },
6413 { "daemon-reexec", EQUAL, 1, daemon_reload },
6414 { "show-environment", EQUAL, 1, show_environment },
6415 { "set-environment", MORE, 2, set_environment },
6416 { "unset-environment", MORE, 2, set_environment },
6417 { "import-environment", MORE, 1, import_environment},
6418 { "halt", EQUAL, 1, start_special, FORCE },
6419 { "poweroff", EQUAL, 1, start_special, FORCE },
6420 { "reboot", EQUAL, 1, start_special, FORCE },
6421 { "kexec", EQUAL, 1, start_special },
6422 { "suspend", EQUAL, 1, start_special },
6423 { "hibernate", EQUAL, 1, start_special },
6424 { "hybrid-sleep", EQUAL, 1, start_special },
6425 { "default", EQUAL, 1, start_special },
6426 { "rescue", EQUAL, 1, start_special },
6427 { "emergency", EQUAL, 1, start_special },
6428 { "exit", EQUAL, 1, start_special },
6429 { "reset-failed", MORE, 1, reset_failed },
6430 { "enable", MORE, 2, enable_unit, NOBUS },
6431 { "disable", MORE, 2, enable_unit, NOBUS },
6432 { "is-enabled", MORE, 2, unit_is_enabled, NOBUS },
6433 { "reenable", MORE, 2, enable_unit, NOBUS },
6434 { "preset", MORE, 2, enable_unit, NOBUS },
6435 { "mask", MORE, 2, enable_unit, NOBUS },
6436 { "unmask", MORE, 2, enable_unit, NOBUS },
6437 { "link", MORE, 2, enable_unit, NOBUS },
6438 { "switch-root", MORE, 2, switch_root },
6439 { "list-dependencies", LESS, 2, list_dependencies },
6440 { "set-default", EQUAL, 2, set_default, NOBUS },
6441 { "get-default", EQUAL, 1, get_default, NOBUS },
6442 { "set-property", MORE, 3, set_property },
6443 {}
6444 }, *verb = verbs;
6445
6446 int left;
6447
6448 assert(argc >= 0);
6449 assert(argv);
6450
6451 left = argc - optind;
6452
6453 /* Special rule: no arguments (left == 0) means "list-units" */
6454 if (left > 0) {
6455 if (streq(argv[optind], "help") && !argv[optind+1]) {
6456 log_error("This command expects one or more "
6457 "unit names. Did you mean --help?");
6458 return -EINVAL;
6459 }
6460
6461 for (; verb->verb; verb++)
6462 if (streq(argv[optind], verb->verb))
6463 goto found;
6464
6465 log_error("Unknown operation '%s'.", argv[optind]);
6466 return -EINVAL;
6467 }
6468 found:
6469
6470 switch (verb->argc_cmp) {
6471
6472 case EQUAL:
6473 if (left != verb->argc) {
6474 log_error("Invalid number of arguments.");
6475 return -EINVAL;
6476 }
6477
6478 break;
6479
6480 case MORE:
6481 if (left < verb->argc) {
6482 log_error("Too few arguments.");
6483 return -EINVAL;
6484 }
6485
6486 break;
6487
6488 case LESS:
6489 if (left > verb->argc) {
6490 log_error("Too many arguments.");
6491 return -EINVAL;
6492 }
6493
6494 break;
6495
6496 default:
6497 assert_not_reached("Unknown comparison operator.");
6498 }
6499
6500 /* Require a bus connection for all operations but
6501 * enable/disable */
6502 if (verb->bus == NOBUS) {
6503 if (!bus && !avoid_bus()) {
6504 log_error("Failed to get D-Bus connection: %s", strerror(-bus_error));
6505 return -EIO;
6506 }
6507
6508 } else {
6509 if (running_in_chroot() > 0) {
6510 log_info("Running in chroot, ignoring request.");
6511 return 0;
6512 }
6513
6514 if ((verb->bus != FORCE || arg_force <= 0) && !bus) {
6515 log_error("Failed to get D-Bus connection: %s", strerror(-bus_error));
6516 return -EIO;
6517 }
6518 }
6519
6520 return verb->dispatch(bus, argv + optind);
6521 }
6522
6523 static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) {
6524
6525 struct sd_shutdown_command c = {
6526 .usec = t,
6527 .mode = mode,
6528 .dry_run = dry_run,
6529 .warn_wall = warn,
6530 };
6531
6532 union sockaddr_union sockaddr = {
6533 .un.sun_family = AF_UNIX,
6534 .un.sun_path = "/run/systemd/shutdownd",
6535 };
6536
6537 struct iovec iovec[2] = {{
6538 .iov_base = (char*) &c,
6539 .iov_len = offsetof(struct sd_shutdown_command, wall_message),
6540 }};
6541
6542 struct msghdr msghdr = {
6543 .msg_name = &sockaddr,
6544 .msg_namelen = offsetof(struct sockaddr_un, sun_path)
6545 + strlen("/run/systemd/shutdownd"),
6546 .msg_iov = iovec,
6547 .msg_iovlen = 1,
6548 };
6549
6550 _cleanup_close_ int fd;
6551
6552 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
6553 if (fd < 0)
6554 return -errno;
6555
6556 if (!isempty(message)) {
6557 iovec[1].iov_base = (char*) message;
6558 iovec[1].iov_len = strlen(message);
6559 msghdr.msg_iovlen++;
6560 }
6561
6562 if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0)
6563 return -errno;
6564
6565 return 0;
6566 }
6567
6568 static int reload_with_fallback(sd_bus *bus) {
6569
6570 if (bus) {
6571 /* First, try systemd via D-Bus. */
6572 if (daemon_reload(bus, NULL) >= 0)
6573 return 0;
6574 }
6575
6576 /* Nothing else worked, so let's try signals */
6577 assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC);
6578
6579 if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0) {
6580 log_error("kill() failed: %m");
6581 return -errno;
6582 }
6583
6584 return 0;
6585 }
6586
6587 static int start_with_fallback(sd_bus *bus) {
6588
6589 if (bus) {
6590 /* First, try systemd via D-Bus. */
6591 if (start_unit(bus, NULL) >= 0)
6592 goto done;
6593 }
6594
6595 /* Nothing else worked, so let's try
6596 * /dev/initctl */
6597 if (talk_initctl() > 0)
6598 goto done;
6599
6600 log_error("Failed to talk to init daemon.");
6601 return -EIO;
6602
6603 done:
6604 warn_wall(arg_action);
6605 return 0;
6606 }
6607
6608 static int halt_now(enum action a) {
6609
6610 /* Make sure C-A-D is handled by the kernel from this
6611 * point on... */
6612 reboot(RB_ENABLE_CAD);
6613
6614 switch (a) {
6615
6616 case ACTION_HALT:
6617 log_info("Halting.");
6618 reboot(RB_HALT_SYSTEM);
6619 return -errno;
6620
6621 case ACTION_POWEROFF:
6622 log_info("Powering off.");
6623 reboot(RB_POWER_OFF);
6624 return -errno;
6625
6626 case ACTION_REBOOT: {
6627 _cleanup_free_ char *param = NULL;
6628
6629 if (read_one_line_file(REBOOT_PARAM_FILE, &param) >= 0) {
6630 log_info("Rebooting with argument '%s'.", param);
6631 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
6632 LINUX_REBOOT_CMD_RESTART2, param);
6633 }
6634
6635 log_info("Rebooting.");
6636 reboot(RB_AUTOBOOT);
6637 return -errno;
6638 }
6639
6640 default:
6641 assert_not_reached("Unknown action.");
6642 }
6643 }
6644
6645 static int halt_main(sd_bus *bus) {
6646 int r;
6647
6648 r = check_inhibitors(bus, arg_action);
6649 if (r < 0)
6650 return r;
6651
6652 if (geteuid() != 0) {
6653 /* Try logind if we are a normal user and no special
6654 * mode applies. Maybe PolicyKit allows us to shutdown
6655 * the machine. */
6656
6657 if (arg_when <= 0 &&
6658 !arg_dry &&
6659 arg_force <= 0 &&
6660 (arg_action == ACTION_POWEROFF ||
6661 arg_action == ACTION_REBOOT)) {
6662 r = reboot_with_logind(bus, arg_action);
6663 if (r >= 0)
6664 return r;
6665 }
6666
6667 log_error("Must be root.");
6668 return -EPERM;
6669 }
6670
6671 if (arg_when > 0) {
6672 _cleanup_free_ char *m;
6673
6674 m = strv_join(arg_wall, " ");
6675 if (!m)
6676 return log_oom();
6677
6678 r = send_shutdownd(arg_when,
6679 arg_action == ACTION_HALT ? 'H' :
6680 arg_action == ACTION_POWEROFF ? 'P' :
6681 arg_action == ACTION_KEXEC ? 'K' :
6682 'r',
6683 arg_dry,
6684 !arg_no_wall,
6685 m);
6686
6687 if (r < 0)
6688 log_warning("Failed to talk to shutdownd, proceeding with immediate shutdown: %s", strerror(-r));
6689 else {
6690 char date[FORMAT_TIMESTAMP_MAX];
6691
6692 log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.",
6693 format_timestamp(date, sizeof(date), arg_when));
6694 return 0;
6695 }
6696 }
6697
6698 if (!arg_dry && !arg_force)
6699 return start_with_fallback(bus);
6700
6701 if (!arg_no_wtmp) {
6702 if (sd_booted() > 0)
6703 log_debug("Not writing utmp record, assuming that systemd-update-utmp is used.");
6704 else {
6705 r = utmp_put_shutdown();
6706 if (r < 0)
6707 log_warning("Failed to write utmp record: %s", strerror(-r));
6708 }
6709 }
6710
6711 if (arg_dry)
6712 return 0;
6713
6714 r = halt_now(arg_action);
6715 log_error("Failed to reboot: %s", strerror(-r));
6716
6717 return r;
6718 }
6719
6720 static int runlevel_main(void) {
6721 int r, runlevel, previous;
6722
6723 r = utmp_get_runlevel(&runlevel, &previous);
6724 if (r < 0) {
6725 puts("unknown");
6726 return r;
6727 }
6728
6729 printf("%c %c\n",
6730 previous <= 0 ? 'N' : previous,
6731 runlevel <= 0 ? 'N' : runlevel);
6732
6733 return 0;
6734 }
6735
6736 int main(int argc, char*argv[]) {
6737 _cleanup_bus_unref_ sd_bus *bus = NULL;
6738 int r;
6739
6740 setlocale(LC_ALL, "");
6741 log_parse_environment();
6742 log_open();
6743
6744 /* Explicitly not on_tty() to avoid setting cached value.
6745 * This becomes relevant for piping output which might be
6746 * ellipsized. */
6747 original_stdout_is_tty = isatty(STDOUT_FILENO);
6748
6749 r = parse_argv(argc, argv);
6750 if (r <= 0)
6751 goto finish;
6752
6753 /* /sbin/runlevel doesn't need to communicate via D-Bus, so
6754 * let's shortcut this */
6755 if (arg_action == ACTION_RUNLEVEL) {
6756 r = runlevel_main();
6757 goto finish;
6758 }
6759
6760 if (running_in_chroot() > 0 && arg_action != ACTION_SYSTEMCTL) {
6761 log_info("Running in chroot, ignoring request.");
6762 r = 0;
6763 goto finish;
6764 }
6765
6766 if (!avoid_bus())
6767 r = bus_open_transport_systemd(arg_transport, arg_host, arg_scope != UNIT_FILE_SYSTEM, &bus);
6768
6769 /* systemctl_main() will print an error message for the bus
6770 * connection, but only if it needs to */
6771
6772 switch (arg_action) {
6773
6774 case ACTION_SYSTEMCTL:
6775 r = systemctl_main(bus, argc, argv, r);
6776 break;
6777
6778 case ACTION_HALT:
6779 case ACTION_POWEROFF:
6780 case ACTION_REBOOT:
6781 case ACTION_KEXEC:
6782 r = halt_main(bus);
6783 break;
6784
6785 case ACTION_RUNLEVEL2:
6786 case ACTION_RUNLEVEL3:
6787 case ACTION_RUNLEVEL4:
6788 case ACTION_RUNLEVEL5:
6789 case ACTION_RESCUE:
6790 case ACTION_EMERGENCY:
6791 case ACTION_DEFAULT:
6792 r = start_with_fallback(bus);
6793 break;
6794
6795 case ACTION_RELOAD:
6796 case ACTION_REEXEC:
6797 r = reload_with_fallback(bus);
6798 break;
6799
6800 case ACTION_CANCEL_SHUTDOWN: {
6801 _cleanup_free_ char *m = NULL;
6802
6803 if (arg_wall) {
6804 m = strv_join(arg_wall, " ");
6805 if (!m) {
6806 r = log_oom();
6807 goto finish;
6808 }
6809 }
6810
6811 r = send_shutdownd(arg_when, SD_SHUTDOWN_NONE, false, !arg_no_wall, m);
6812 if (r < 0)
6813 log_warning("Failed to talk to shutdownd, shutdown hasn't been cancelled: %s", strerror(-r));
6814 break;
6815 }
6816
6817 case ACTION_RUNLEVEL:
6818 case _ACTION_INVALID:
6819 default:
6820 assert_not_reached("Unknown action");
6821 }
6822
6823 finish:
6824 pager_close();
6825 ask_password_agent_close();
6826 polkit_agent_close();
6827
6828 strv_free(arg_types);
6829 strv_free(arg_states);
6830 strv_free(arg_properties);
6831
6832 return r < 0 ? EXIT_FAILURE : r;
6833 }
Unnamed repository; edit this file 'description' to name the repository.