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