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