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