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