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