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