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