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