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