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