]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/systemctl/systemctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
systemctl: add edit verb
[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-errors.h"
76 #include "copy.h"
77 #include "mkdir.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_container(&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_container(&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 typedef struct WaitData {
2275 Set *set;
2276
2277 char *name;
2278 char *result;
2279 } WaitData;
2280
2281 static int wait_filter(sd_bus *bus, sd_bus_message *m, void *data, sd_bus_error *error) {
2282 WaitData *d = data;
2283
2284 assert(bus);
2285 assert(m);
2286 assert(d);
2287
2288 log_debug("Got D-Bus request: %s.%s() on %s",
2289 sd_bus_message_get_interface(m),
2290 sd_bus_message_get_member(m),
2291 sd_bus_message_get_path(m));
2292
2293 if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
2294 log_error("Warning! D-Bus connection terminated.");
2295 sd_bus_close(bus);
2296 } else if (sd_bus_message_is_signal(m, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
2297 uint32_t id;
2298 const char *path, *result, *unit;
2299 char *ret;
2300 int r;
2301
2302 r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
2303 if (r >= 0) {
2304 ret = set_remove(d->set, (char*) path);
2305 if (!ret)
2306 return 0;
2307
2308 free(ret);
2309
2310 if (!isempty(result))
2311 d->result = strdup(result);
2312
2313 if (!isempty(unit))
2314 d->name = strdup(unit);
2315
2316 return 0;
2317 }
2318 #ifndef NOLEGACY
2319 r = sd_bus_message_read(m, "uos", &id, &path, &result);
2320 if (r >= 0) {
2321 ret = set_remove(d->set, (char*) path);
2322 if (!ret)
2323 return 0;
2324
2325 free(ret);
2326
2327 if (*result)
2328 d->result = strdup(result);
2329
2330 return 0;
2331 }
2332 #endif
2333
2334 bus_log_parse_error(r);
2335 }
2336
2337 return 0;
2338 }
2339
2340 static int enable_wait_for_jobs(sd_bus *bus) {
2341 int r;
2342
2343 assert(bus);
2344
2345 r = sd_bus_add_match(
2346 bus,
2347 NULL,
2348 "type='signal',"
2349 "sender='org.freedesktop.systemd1',"
2350 "interface='org.freedesktop.systemd1.Manager',"
2351 "member='JobRemoved',"
2352 "path='/org/freedesktop/systemd1'",
2353 NULL, NULL);
2354 if (r < 0) {
2355 log_error("Failed to add match");
2356 return -EIO;
2357 }
2358
2359 /* This is slightly dirty, since we don't undo the match registrations. */
2360 return 0;
2361 }
2362
2363 static int bus_process_wait(sd_bus *bus) {
2364 int r;
2365
2366 for (;;) {
2367 r = sd_bus_process(bus, NULL);
2368 if (r < 0)
2369 return r;
2370 if (r > 0)
2371 return 0;
2372 r = sd_bus_wait(bus, (uint64_t) -1);
2373 if (r < 0)
2374 return r;
2375 }
2376 }
2377
2378 static int check_wait_response(WaitData *d) {
2379 int r = 0;
2380
2381 assert(d->result);
2382
2383 if (!arg_quiet) {
2384 if (streq(d->result, "timeout"))
2385 log_error("Job for %s timed out.", strna(d->name));
2386 else if (streq(d->result, "canceled"))
2387 log_error("Job for %s canceled.", strna(d->name));
2388 else if (streq(d->result, "dependency"))
2389 log_error("A dependency job for %s failed. See 'journalctl -xe' for details.", strna(d->name));
2390 else if (!streq(d->result, "done") && !streq(d->result, "skipped")) {
2391 if (d->name) {
2392 bool quotes;
2393
2394 quotes = chars_intersect(d->name, SHELL_NEED_QUOTES);
2395
2396 log_error("Job for %s failed. See \"systemctl status %s%s%s\" and \"journalctl -xe\" for details.",
2397 d->name,
2398 quotes ? "'" : "", d->name, quotes ? "'" : "");
2399 } else
2400 log_error("Job failed. See \"journalctl -xe\" for details.");
2401 }
2402 }
2403
2404 if (streq(d->result, "timeout"))
2405 r = -ETIME;
2406 else if (streq(d->result, "canceled"))
2407 r = -ECANCELED;
2408 else if (streq(d->result, "dependency"))
2409 r = -EIO;
2410 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2411 r = -EIO;
2412
2413 return r;
2414 }
2415
2416 static int wait_for_jobs(sd_bus *bus, Set *s) {
2417 _cleanup_bus_slot_unref_ sd_bus_slot *slot = NULL;
2418 WaitData d = { .set = s };
2419 int r = 0, q;
2420
2421 assert(bus);
2422 assert(s);
2423
2424 q = sd_bus_add_filter(bus, &slot, wait_filter, &d);
2425 if (q < 0)
2426 return log_oom();
2427
2428 while (!set_isempty(s)) {
2429 q = bus_process_wait(bus);
2430 if (q < 0)
2431 return log_error_errno(q, "Failed to wait for response: %m");
2432
2433 if (d.result) {
2434 q = check_wait_response(&d);
2435 /* Return the first error as it is most likely to be
2436 * meaningful. */
2437 if (q < 0 && r == 0)
2438 r = q;
2439 log_debug("Got result %s/%s for job %s",
2440 strna(d.result), strerror(-q), strna(d.name));
2441 }
2442
2443 free(d.name);
2444 d.name = NULL;
2445
2446 free(d.result);
2447 d.result = NULL;
2448 }
2449
2450 return r;
2451 }
2452
2453 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet) {
2454 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2455 _cleanup_free_ char *n = NULL, *state = NULL;
2456 const char *path;
2457 int r;
2458
2459 assert(name);
2460
2461 n = unit_name_mangle(name, MANGLE_NOGLOB);
2462 if (!n)
2463 return log_oom();
2464
2465 /* We don't use unit_dbus_path_from_name() directly since we
2466 * don't want to load the unit if it isn't loaded. */
2467
2468 r = sd_bus_call_method(
2469 bus,
2470 "org.freedesktop.systemd1",
2471 "/org/freedesktop/systemd1",
2472 "org.freedesktop.systemd1.Manager",
2473 "GetUnit",
2474 NULL,
2475 &reply,
2476 "s", n);
2477 if (r < 0) {
2478 if (!quiet)
2479 puts("unknown");
2480 return 0;
2481 }
2482
2483 r = sd_bus_message_read(reply, "o", &path);
2484 if (r < 0)
2485 return bus_log_parse_error(r);
2486
2487 r = sd_bus_get_property_string(
2488 bus,
2489 "org.freedesktop.systemd1",
2490 path,
2491 "org.freedesktop.systemd1.Unit",
2492 "ActiveState",
2493 NULL,
2494 &state);
2495 if (r < 0) {
2496 if (!quiet)
2497 puts("unknown");
2498 return 0;
2499 }
2500
2501 if (!quiet)
2502 puts(state);
2503
2504 return nulstr_contains(good_states, state);
2505 }
2506
2507 static int check_triggering_units(
2508 sd_bus *bus,
2509 const char *name) {
2510
2511 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2512 _cleanup_free_ char *path = NULL, *n = NULL, *state = NULL;
2513 _cleanup_strv_free_ char **triggered_by = NULL;
2514 bool print_warning_label = true;
2515 char **i;
2516 int r;
2517
2518 n = unit_name_mangle(name, MANGLE_NOGLOB);
2519 if (!n)
2520 return log_oom();
2521
2522 path = unit_dbus_path_from_name(n);
2523 if (!path)
2524 return log_oom();
2525
2526 r = sd_bus_get_property_string(
2527 bus,
2528 "org.freedesktop.systemd1",
2529 path,
2530 "org.freedesktop.systemd1.Unit",
2531 "LoadState",
2532 &error,
2533 &state);
2534 if (r < 0) {
2535 log_error("Failed to get load state of %s: %s", n, bus_error_message(&error, r));
2536 return r;
2537 }
2538
2539 if (streq(state, "masked"))
2540 return 0;
2541
2542 r = sd_bus_get_property_strv(
2543 bus,
2544 "org.freedesktop.systemd1",
2545 path,
2546 "org.freedesktop.systemd1.Unit",
2547 "TriggeredBy",
2548 &error,
2549 &triggered_by);
2550 if (r < 0) {
2551 log_error("Failed to get triggered by array of %s: %s", n, bus_error_message(&error, r));
2552 return r;
2553 }
2554
2555 STRV_FOREACH(i, triggered_by) {
2556 r = check_one_unit(bus, *i, "active\0reloading\0", true);
2557 if (r < 0)
2558 return log_error_errno(r, "Failed to check unit: %m");
2559
2560 if (r == 0)
2561 continue;
2562
2563 if (print_warning_label) {
2564 log_warning("Warning: Stopping %s, but it can still be activated by:", n);
2565 print_warning_label = false;
2566 }
2567
2568 log_warning(" %s", *i);
2569 }
2570
2571 return 0;
2572 }
2573
2574 static const struct {
2575 const char *verb;
2576 const char *method;
2577 } unit_actions[] = {
2578 { "start", "StartUnit" },
2579 { "stop", "StopUnit" },
2580 { "condstop", "StopUnit" },
2581 { "reload", "ReloadUnit" },
2582 { "restart", "RestartUnit" },
2583 { "try-restart", "TryRestartUnit" },
2584 { "condrestart", "TryRestartUnit" },
2585 { "reload-or-restart", "ReloadOrRestartUnit" },
2586 { "reload-or-try-restart", "ReloadOrTryRestartUnit" },
2587 { "condreload", "ReloadOrTryRestartUnit" },
2588 { "force-reload", "ReloadOrTryRestartUnit" }
2589 };
2590
2591 static const char *verb_to_method(const char *verb) {
2592 uint i;
2593
2594 for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2595 if (streq_ptr(unit_actions[i].verb, verb))
2596 return unit_actions[i].method;
2597
2598 return "StartUnit";
2599 }
2600
2601 static const char *method_to_verb(const char *method) {
2602 uint i;
2603
2604 for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2605 if (streq_ptr(unit_actions[i].method, method))
2606 return unit_actions[i].verb;
2607
2608 return "n/a";
2609 }
2610
2611 static int start_unit_one(
2612 sd_bus *bus,
2613 const char *method,
2614 const char *name,
2615 const char *mode,
2616 sd_bus_error *error,
2617 Set *s) {
2618
2619 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
2620 const char *path;
2621 int r;
2622
2623 assert(method);
2624 assert(name);
2625 assert(mode);
2626 assert(error);
2627
2628 log_debug("Calling manager for %s on %s, %s", method, name, mode);
2629
2630 r = sd_bus_message_new_method_call(
2631 bus,
2632 &m,
2633 "org.freedesktop.systemd1",
2634 "/org/freedesktop/systemd1",
2635 "org.freedesktop.systemd1.Manager",
2636 method);
2637 if (r < 0)
2638 return bus_log_create_error(r);
2639
2640 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
2641 if (r < 0)
2642 return bus_log_create_error(r);
2643
2644 r = sd_bus_message_append(m, "ss", name, mode);
2645 if (r < 0)
2646 return bus_log_create_error(r);
2647
2648 r = sd_bus_call(bus, m, 0, error, &reply);
2649 if (r < 0) {
2650 const char *verb;
2651
2652 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
2653 /* There's always a fallback possible for
2654 * legacy actions. */
2655 return -EADDRNOTAVAIL;
2656
2657 verb = method_to_verb(method);
2658
2659 log_error("Failed to %s %s: %s", verb, name, bus_error_message(error, r));
2660 return r;
2661 }
2662
2663 r = sd_bus_message_read(reply, "o", &path);
2664 if (r < 0)
2665 return bus_log_parse_error(r);
2666
2667 if (need_daemon_reload(bus, name) > 0)
2668 log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
2669 name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
2670
2671 if (s) {
2672 char *p;
2673
2674 p = strdup(path);
2675 if (!p)
2676 return log_oom();
2677
2678 log_debug("Adding %s to the set", p);
2679 r = set_consume(s, p);
2680 if (r < 0)
2681 return log_oom();
2682 }
2683
2684 return 0;
2685 }
2686
2687 static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
2688
2689 _cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
2690 char **name;
2691 int r = 0, i;
2692
2693 STRV_FOREACH(name, names) {
2694 char *t;
2695
2696 if (suffix)
2697 t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);
2698 else
2699 t = unit_name_mangle(*name, MANGLE_GLOB);
2700 if (!t)
2701 return log_oom();
2702
2703 if (string_is_glob(t))
2704 r = strv_consume(&globs, t);
2705 else
2706 r = strv_consume(&mangled, t);
2707 if (r < 0)
2708 return log_oom();
2709 }
2710
2711 /* Query the manager only if any of the names are a glob, since
2712 * this is fairly expensive */
2713 if (!strv_isempty(globs)) {
2714 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2715 _cleanup_free_ UnitInfo *unit_infos = NULL;
2716
2717 r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
2718 if (r < 0)
2719 return r;
2720
2721 for (i = 0; i < r; i++)
2722 if (strv_extend(&mangled, unit_infos[i].id) < 0)
2723 return log_oom();
2724 }
2725
2726 *ret = mangled;
2727 mangled = NULL; /* do not free */
2728
2729 return 0;
2730 }
2731
2732 static const struct {
2733 const char *target;
2734 const char *verb;
2735 const char *mode;
2736 } action_table[_ACTION_MAX] = {
2737 [ACTION_HALT] = { SPECIAL_HALT_TARGET, "halt", "replace-irreversibly" },
2738 [ACTION_POWEROFF] = { SPECIAL_POWEROFF_TARGET, "poweroff", "replace-irreversibly" },
2739 [ACTION_REBOOT] = { SPECIAL_REBOOT_TARGET, "reboot", "replace-irreversibly" },
2740 [ACTION_KEXEC] = { SPECIAL_KEXEC_TARGET, "kexec", "replace-irreversibly" },
2741 [ACTION_RUNLEVEL2] = { SPECIAL_RUNLEVEL2_TARGET, NULL, "isolate" },
2742 [ACTION_RUNLEVEL3] = { SPECIAL_RUNLEVEL3_TARGET, NULL, "isolate" },
2743 [ACTION_RUNLEVEL4] = { SPECIAL_RUNLEVEL4_TARGET, NULL, "isolate" },
2744 [ACTION_RUNLEVEL5] = { SPECIAL_RUNLEVEL5_TARGET, NULL, "isolate" },
2745 [ACTION_RESCUE] = { SPECIAL_RESCUE_TARGET, "rescue", "isolate" },
2746 [ACTION_EMERGENCY] = { SPECIAL_EMERGENCY_TARGET, "emergency", "isolate" },
2747 [ACTION_DEFAULT] = { SPECIAL_DEFAULT_TARGET, "default", "isolate" },
2748 [ACTION_EXIT] = { SPECIAL_EXIT_TARGET, "exit", "replace-irreversibly" },
2749 [ACTION_SUSPEND] = { SPECIAL_SUSPEND_TARGET, "suspend", "replace-irreversibly" },
2750 [ACTION_HIBERNATE] = { SPECIAL_HIBERNATE_TARGET, "hibernate", "replace-irreversibly" },
2751 [ACTION_HYBRID_SLEEP] = { SPECIAL_HYBRID_SLEEP_TARGET, "hybrid-sleep", "replace-irreversibly" },
2752 };
2753
2754 static enum action verb_to_action(const char *verb) {
2755 enum action i;
2756
2757 for (i = _ACTION_INVALID; i < _ACTION_MAX; i++)
2758 if (streq_ptr(action_table[i].verb, verb))
2759 return i;
2760
2761 return _ACTION_INVALID;
2762 }
2763
2764 static int start_unit(sd_bus *bus, char **args) {
2765 _cleanup_set_free_free_ Set *s = NULL;
2766 _cleanup_strv_free_ char **names = NULL;
2767 const char *method, *mode, *one_name, *suffix = NULL;
2768 char **name;
2769 int r = 0;
2770
2771 assert(bus);
2772
2773 ask_password_agent_open_if_enabled();
2774
2775 if (arg_action == ACTION_SYSTEMCTL) {
2776 enum action action;
2777 method = verb_to_method(args[0]);
2778 action = verb_to_action(args[0]);
2779
2780 if (streq(args[0], "isolate")) {
2781 mode = "isolate";
2782 suffix = ".target";
2783 } else
2784 mode = action_table[action].mode ?: arg_job_mode;
2785
2786 one_name = action_table[action].target;
2787 } else {
2788 assert(arg_action < ELEMENTSOF(action_table));
2789 assert(action_table[arg_action].target);
2790
2791 method = "StartUnit";
2792
2793 mode = action_table[arg_action].mode;
2794 one_name = action_table[arg_action].target;
2795 }
2796
2797 if (one_name)
2798 names = strv_new(one_name, NULL);
2799 else {
2800 r = expand_names(bus, args + 1, suffix, &names);
2801 if (r < 0)
2802 log_error_errno(r, "Failed to expand names: %m");
2803 }
2804
2805 if (!arg_no_block) {
2806 r = enable_wait_for_jobs(bus);
2807 if (r < 0)
2808 return log_error_errno(r, "Could not watch jobs: %m");
2809
2810 s = set_new(&string_hash_ops);
2811 if (!s)
2812 return log_oom();
2813 }
2814
2815 STRV_FOREACH(name, names) {
2816 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2817 int q;
2818
2819 q = start_unit_one(bus, method, *name, mode, &error, s);
2820 if (r >= 0 && q < 0)
2821 r = translate_bus_error_to_exit_status(q, &error);
2822 }
2823
2824 if (!arg_no_block) {
2825 int q;
2826
2827 q = wait_for_jobs(bus, s);
2828 if (q < 0)
2829 return q;
2830
2831 /* When stopping units, warn if they can still be triggered by
2832 * another active unit (socket, path, timer) */
2833 if (!arg_quiet && streq(method, "StopUnit"))
2834 STRV_FOREACH(name, names)
2835 check_triggering_units(bus, *name);
2836 }
2837
2838 return r;
2839 }
2840
2841 /* Ask systemd-logind, which might grant access to unprivileged users
2842 * through PolicyKit */
2843 static int reboot_with_logind(sd_bus *bus, enum action a) {
2844 #ifdef HAVE_LOGIND
2845 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2846 const char *method;
2847 int r;
2848
2849 if (!bus)
2850 return -EIO;
2851
2852 polkit_agent_open_if_enabled();
2853
2854 switch (a) {
2855
2856 case ACTION_REBOOT:
2857 method = "Reboot";
2858 break;
2859
2860 case ACTION_POWEROFF:
2861 method = "PowerOff";
2862 break;
2863
2864 case ACTION_SUSPEND:
2865 method = "Suspend";
2866 break;
2867
2868 case ACTION_HIBERNATE:
2869 method = "Hibernate";
2870 break;
2871
2872 case ACTION_HYBRID_SLEEP:
2873 method = "HybridSleep";
2874 break;
2875
2876 default:
2877 return -EINVAL;
2878 }
2879
2880 r = sd_bus_call_method(
2881 bus,
2882 "org.freedesktop.login1",
2883 "/org/freedesktop/login1",
2884 "org.freedesktop.login1.Manager",
2885 method,
2886 &error,
2887 NULL,
2888 "b", arg_ask_password);
2889 if (r < 0)
2890 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
2891
2892 return r;
2893 #else
2894 return -ENOSYS;
2895 #endif
2896 }
2897
2898 static int check_inhibitors(sd_bus *bus, enum action a) {
2899 #ifdef HAVE_LOGIND
2900 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2901 _cleanup_strv_free_ char **sessions = NULL;
2902 const char *what, *who, *why, *mode;
2903 uint32_t uid, pid;
2904 unsigned c = 0;
2905 char **s;
2906 int r;
2907
2908 if (!bus)
2909 return 0;
2910
2911 if (arg_ignore_inhibitors || arg_force > 0)
2912 return 0;
2913
2914 if (arg_when > 0)
2915 return 0;
2916
2917 if (geteuid() == 0)
2918 return 0;
2919
2920 if (!on_tty())
2921 return 0;
2922
2923 r = sd_bus_call_method(
2924 bus,
2925 "org.freedesktop.login1",
2926 "/org/freedesktop/login1",
2927 "org.freedesktop.login1.Manager",
2928 "ListInhibitors",
2929 NULL,
2930 &reply,
2931 NULL);
2932 if (r < 0)
2933 /* If logind is not around, then there are no inhibitors... */
2934 return 0;
2935
2936 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
2937 if (r < 0)
2938 return bus_log_parse_error(r);
2939
2940 while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
2941 _cleanup_free_ char *comm = NULL, *user = NULL;
2942 _cleanup_strv_free_ char **sv = NULL;
2943
2944 if (!streq(mode, "block"))
2945 continue;
2946
2947 sv = strv_split(what, ":");
2948 if (!sv)
2949 return log_oom();
2950
2951 if (!strv_contains(sv,
2952 a == ACTION_HALT ||
2953 a == ACTION_POWEROFF ||
2954 a == ACTION_REBOOT ||
2955 a == ACTION_KEXEC ? "shutdown" : "sleep"))
2956 continue;
2957
2958 get_process_comm(pid, &comm);
2959 user = uid_to_name(uid);
2960
2961 log_warning("Operation inhibited by \"%s\" (PID "PID_FMT" \"%s\", user %s), reason is \"%s\".",
2962 who, pid, strna(comm), strna(user), why);
2963
2964 c++;
2965 }
2966 if (r < 0)
2967 return bus_log_parse_error(r);
2968
2969 r = sd_bus_message_exit_container(reply);
2970 if (r < 0)
2971 return bus_log_parse_error(r);
2972
2973 /* Check for current sessions */
2974 sd_get_sessions(&sessions);
2975 STRV_FOREACH(s, sessions) {
2976 _cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;
2977
2978 if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())
2979 continue;
2980
2981 if (sd_session_get_class(*s, &class) < 0 || !streq(class, "user"))
2982 continue;
2983
2984 if (sd_session_get_type(*s, &type) < 0 || (!streq(type, "x11") && !streq(type, "tty")))
2985 continue;
2986
2987 sd_session_get_tty(*s, &tty);
2988 sd_session_get_seat(*s, &seat);
2989 sd_session_get_service(*s, &service);
2990 user = uid_to_name(uid);
2991
2992 log_warning("User %s is logged in on %s.", strna(user), isempty(tty) ? (isempty(seat) ? strna(service) : seat) : tty);
2993 c++;
2994 }
2995
2996 if (c <= 0)
2997 return 0;
2998
2999 log_error("Please retry operation after closing inhibitors and logging out other users.\nAlternatively, ignore inhibitors and users with 'systemctl %s -i'.",
3000 action_table[a].verb);
3001
3002 return -EPERM;
3003 #else
3004 return 0;
3005 #endif
3006 }
3007
3008 static int start_special(sd_bus *bus, char **args) {
3009 enum action a;
3010 int r;
3011
3012 assert(args);
3013
3014 a = verb_to_action(args[0]);
3015
3016 r = check_inhibitors(bus, a);
3017 if (r < 0)
3018 return r;
3019
3020 if (arg_force >= 2 && geteuid() != 0) {
3021 log_error("Must be root.");
3022 return -EPERM;
3023 }
3024
3025 if (arg_force >= 2 &&
3026 (a == ACTION_HALT ||
3027 a == ACTION_POWEROFF ||
3028 a == ACTION_REBOOT))
3029 return halt_now(a);
3030
3031 if (arg_force >= 1 &&
3032 (a == ACTION_HALT ||
3033 a == ACTION_POWEROFF ||
3034 a == ACTION_REBOOT ||
3035 a == ACTION_KEXEC ||
3036 a == ACTION_EXIT))
3037 return daemon_reload(bus, args);
3038
3039 /* first try logind, to allow authentication with polkit */
3040 if (geteuid() != 0 &&
3041 (a == ACTION_POWEROFF ||
3042 a == ACTION_REBOOT ||
3043 a == ACTION_SUSPEND ||
3044 a == ACTION_HIBERNATE ||
3045 a == ACTION_HYBRID_SLEEP)) {
3046 r = reboot_with_logind(bus, a);
3047 if (r >= 0)
3048 return r;
3049 }
3050
3051 r = start_unit(bus, args);
3052 if (r == EXIT_SUCCESS)
3053 warn_wall(a);
3054
3055 return r;
3056 }
3057
3058 static int check_unit_generic(sd_bus *bus, int code, const char *good_states, char **args) {
3059 _cleanup_strv_free_ char **names = NULL;
3060 char **name;
3061 int r;
3062
3063 assert(bus);
3064 assert(args);
3065
3066 r = expand_names(bus, args, NULL, &names);
3067 if (r < 0)
3068 return log_error_errno(r, "Failed to expand names: %m");
3069
3070 STRV_FOREACH(name, names) {
3071 int state;
3072
3073 state = check_one_unit(bus, *name, good_states, arg_quiet);
3074 if (state < 0)
3075 return state;
3076 if (state == 0)
3077 r = code;
3078 }
3079
3080 return r;
3081 }
3082
3083 static int check_unit_active(sd_bus *bus, char **args) {
3084 /* According to LSB: 3, "program is not running" */
3085 return check_unit_generic(bus, 3, "active\0reloading\0", args + 1);
3086 }
3087
3088 static int check_unit_failed(sd_bus *bus, char **args) {
3089 return check_unit_generic(bus, 1, "failed\0", args + 1);
3090 }
3091
3092 static int kill_unit(sd_bus *bus, char **args) {
3093 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
3094 _cleanup_strv_free_ char **names = NULL;
3095 char **name;
3096 int r, q;
3097
3098 assert(bus);
3099 assert(args);
3100
3101 if (!arg_kill_who)
3102 arg_kill_who = "all";
3103
3104 r = expand_names(bus, args + 1, NULL, &names);
3105 if (r < 0)
3106 log_error_errno(r, "Failed to expand names: %m");
3107
3108 STRV_FOREACH(name, names) {
3109 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
3110
3111 q = sd_bus_message_new_method_call(
3112 bus,
3113 &m,
3114 "org.freedesktop.systemd1",
3115 "/org/freedesktop/systemd1",
3116 "org.freedesktop.systemd1.Manager",
3117 "KillUnit");
3118 if (q < 0)
3119 return bus_log_create_error(q);
3120
3121 q = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
3122 if (q < 0)
3123 return bus_log_create_error(q);
3124
3125 q = sd_bus_message_append(m, "ssi", *names, arg_kill_who, arg_signal);
3126 if (q < 0)
3127 return bus_log_create_error(q);
3128
3129 q = sd_bus_call(bus, m, 0, &error, NULL);
3130 if (q < 0) {
3131 log_error("Failed to kill unit %s: %s", *names, bus_error_message(&error, q));
3132 if (r == 0)
3133 r = q;
3134 }
3135 }
3136
3137 return r;
3138 }
3139
3140 typedef struct ExecStatusInfo {
3141 char *name;
3142
3143 char *path;
3144 char **argv;
3145
3146 bool ignore;
3147
3148 usec_t start_timestamp;
3149 usec_t exit_timestamp;
3150 pid_t pid;
3151 int code;
3152 int status;
3153
3154 LIST_FIELDS(struct ExecStatusInfo, exec);
3155 } ExecStatusInfo;
3156
3157 static void exec_status_info_free(ExecStatusInfo *i) {
3158 assert(i);
3159
3160 free(i->name);
3161 free(i->path);
3162 strv_free(i->argv);
3163 free(i);
3164 }
3165
3166 static int exec_status_info_deserialize(sd_bus_message *m, ExecStatusInfo *i) {
3167 uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
3168 const char *path;
3169 uint32_t pid;
3170 int32_t code, status;
3171 int ignore, r;
3172
3173 assert(m);
3174 assert(i);
3175
3176 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
3177 if (r < 0)
3178 return bus_log_parse_error(r);
3179 else if (r == 0)
3180 return 0;
3181
3182 r = sd_bus_message_read(m, "s", &path);
3183 if (r < 0)
3184 return bus_log_parse_error(r);
3185
3186 i->path = strdup(path);
3187 if (!i->path)
3188 return log_oom();
3189
3190 r = sd_bus_message_read_strv(m, &i->argv);
3191 if (r < 0)
3192 return bus_log_parse_error(r);
3193
3194 r = sd_bus_message_read(m,
3195 "bttttuii",
3196 &ignore,
3197 &start_timestamp, &start_timestamp_monotonic,
3198 &exit_timestamp, &exit_timestamp_monotonic,
3199 &pid,
3200 &code, &status);
3201 if (r < 0)
3202 return bus_log_parse_error(r);
3203
3204 i->ignore = ignore;
3205 i->start_timestamp = (usec_t) start_timestamp;
3206 i->exit_timestamp = (usec_t) exit_timestamp;
3207 i->pid = (pid_t) pid;
3208 i->code = code;
3209 i->status = status;
3210
3211 r = sd_bus_message_exit_container(m);
3212 if (r < 0)
3213 return bus_log_parse_error(r);
3214
3215 return 1;
3216 }
3217
3218 typedef struct UnitStatusInfo {
3219 const char *id;
3220 const char *load_state;
3221 const char *active_state;
3222 const char *sub_state;
3223 const char *unit_file_state;
3224
3225 const char *description;
3226 const char *following;
3227
3228 char **documentation;
3229
3230 const char *fragment_path;
3231 const char *source_path;
3232 const char *control_group;
3233
3234 char **dropin_paths;
3235
3236 const char *load_error;
3237 const char *result;
3238
3239 usec_t inactive_exit_timestamp;
3240 usec_t inactive_exit_timestamp_monotonic;
3241 usec_t active_enter_timestamp;
3242 usec_t active_exit_timestamp;
3243 usec_t inactive_enter_timestamp;
3244
3245 bool need_daemon_reload;
3246
3247 /* Service */
3248 pid_t main_pid;
3249 pid_t control_pid;
3250 const char *status_text;
3251 const char *pid_file;
3252 bool running:1;
3253 int status_errno;
3254
3255 usec_t start_timestamp;
3256 usec_t exit_timestamp;
3257
3258 int exit_code, exit_status;
3259
3260 usec_t condition_timestamp;
3261 bool condition_result;
3262 bool failed_condition_trigger;
3263 bool failed_condition_negate;
3264 const char *failed_condition;
3265 const char *failed_condition_parameter;
3266
3267 usec_t assert_timestamp;
3268 bool assert_result;
3269 bool failed_assert_trigger;
3270 bool failed_assert_negate;
3271 const char *failed_assert;
3272 const char *failed_assert_parameter;
3273
3274 /* Socket */
3275 unsigned n_accepted;
3276 unsigned n_connections;
3277 bool accept;
3278
3279 /* Pairs of type, path */
3280 char **listen;
3281
3282 /* Device */
3283 const char *sysfs_path;
3284
3285 /* Mount, Automount */
3286 const char *where;
3287
3288 /* Swap */
3289 const char *what;
3290
3291 LIST_HEAD(ExecStatusInfo, exec);
3292 } UnitStatusInfo;
3293
3294 static void print_status_info(
3295 UnitStatusInfo *i,
3296 bool *ellipsized) {
3297
3298 ExecStatusInfo *p;
3299 const char *active_on, *active_off, *on, *off, *ss;
3300 usec_t timestamp;
3301 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
3302 char since2[FORMAT_TIMESTAMP_MAX], *s2;
3303 const char *path;
3304 int flags =
3305 arg_all * OUTPUT_SHOW_ALL |
3306 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
3307 on_tty() * OUTPUT_COLOR |
3308 !arg_quiet * OUTPUT_WARN_CUTOFF |
3309 arg_full * OUTPUT_FULL_WIDTH;
3310 char **t, **t2;
3311
3312 assert(i);
3313
3314 /* This shows pretty information about a unit. See
3315 * print_property() for a low-level property printer */
3316
3317 if (streq_ptr(i->active_state, "failed")) {
3318 active_on = ansi_highlight_red();
3319 active_off = ansi_highlight_off();
3320 } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
3321 active_on = ansi_highlight_green();
3322 active_off = ansi_highlight_off();
3323 } else
3324 active_on = active_off = "";
3325
3326 printf("%s%s%s %s", active_on, draw_special_char(DRAW_BLACK_CIRCLE), active_off, strna(i->id));
3327
3328 if (i->description && !streq_ptr(i->id, i->description))
3329 printf(" - %s", i->description);
3330
3331 printf("\n");
3332
3333 if (i->following)
3334 printf(" Follow: unit currently follows state of %s\n", i->following);
3335
3336 if (streq_ptr(i->load_state, "error")) {
3337 on = ansi_highlight_red();
3338 off = ansi_highlight_off();
3339 } else
3340 on = off = "";
3341
3342 path = i->source_path ? i->source_path : i->fragment_path;
3343
3344 if (i->load_error)
3345 printf(" Loaded: %s%s%s (Reason: %s)\n",
3346 on, strna(i->load_state), off, i->load_error);
3347 else if (path && i->unit_file_state)
3348 printf(" Loaded: %s%s%s (%s; %s)\n",
3349 on, strna(i->load_state), off, path, i->unit_file_state);
3350 else if (path)
3351 printf(" Loaded: %s%s%s (%s)\n",
3352 on, strna(i->load_state), off, path);
3353 else
3354 printf(" Loaded: %s%s%s\n",
3355 on, strna(i->load_state), off);
3356
3357 if (!strv_isempty(i->dropin_paths)) {
3358 _cleanup_free_ char *dir = NULL;
3359 bool last = false;
3360 char ** dropin;
3361
3362 STRV_FOREACH(dropin, i->dropin_paths) {
3363 if (! dir || last) {
3364 printf(dir ? " " : " Drop-In: ");
3365
3366 free(dir);
3367 dir = NULL;
3368
3369 if (path_get_parent(*dropin, &dir) < 0) {
3370 log_oom();
3371 return;
3372 }
3373
3374 printf("%s\n %s", dir,
3375 draw_special_char(DRAW_TREE_RIGHT));
3376 }
3377
3378 last = ! (*(dropin + 1) && startswith(*(dropin + 1), dir));
3379
3380 printf("%s%s", basename(*dropin), last ? "\n" : ", ");
3381 }
3382 }
3383
3384 ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
3385 if (ss)
3386 printf(" Active: %s%s (%s)%s",
3387 active_on, strna(i->active_state), ss, active_off);
3388 else
3389 printf(" Active: %s%s%s",
3390 active_on, strna(i->active_state), active_off);
3391
3392 if (!isempty(i->result) && !streq(i->result, "success"))
3393 printf(" (Result: %s)", i->result);
3394
3395 timestamp = (streq_ptr(i->active_state, "active") ||
3396 streq_ptr(i->active_state, "reloading")) ? i->active_enter_timestamp :
3397 (streq_ptr(i->active_state, "inactive") ||
3398 streq_ptr(i->active_state, "failed")) ? i->inactive_enter_timestamp :
3399 streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp :
3400 i->active_exit_timestamp;
3401
3402 s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);
3403 s2 = format_timestamp(since2, sizeof(since2), timestamp);
3404
3405 if (s1)
3406 printf(" since %s; %s\n", s2, s1);
3407 else if (s2)
3408 printf(" since %s\n", s2);
3409 else
3410 printf("\n");
3411
3412 if (!i->condition_result && i->condition_timestamp > 0) {
3413 s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);
3414 s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
3415
3416 printf("Condition: start %scondition failed%s at %s%s%s\n",
3417 ansi_highlight_yellow(), ansi_highlight_off(),
3418 s2, s1 ? "; " : "", s1 ? s1 : "");
3419 if (i->failed_condition_trigger)
3420 printf(" none of the trigger conditions were met\n");
3421 else if (i->failed_condition)
3422 printf(" %s=%s%s was not met\n",
3423 i->failed_condition,
3424 i->failed_condition_negate ? "!" : "",
3425 i->failed_condition_parameter);
3426 }
3427
3428 if (!i->assert_result && i->assert_timestamp > 0) {
3429 s1 = format_timestamp_relative(since1, sizeof(since1), i->assert_timestamp);
3430 s2 = format_timestamp(since2, sizeof(since2), i->assert_timestamp);
3431
3432 printf(" Assert: start %sassertion failed%s at %s%s%s\n",
3433 ansi_highlight_red(), ansi_highlight_off(),
3434 s2, s1 ? "; " : "", s1 ? s1 : "");
3435 if (i->failed_assert_trigger)
3436 printf(" none of the trigger assertions were met\n");
3437 else if (i->failed_assert)
3438 printf(" %s=%s%s was not met\n",
3439 i->failed_assert,
3440 i->failed_assert_negate ? "!" : "",
3441 i->failed_assert_parameter);
3442 }
3443
3444 if (i->sysfs_path)
3445 printf(" Device: %s\n", i->sysfs_path);
3446 if (i->where)
3447 printf(" Where: %s\n", i->where);
3448 if (i->what)
3449 printf(" What: %s\n", i->what);
3450
3451 STRV_FOREACH(t, i->documentation)
3452 printf(" %*s %s\n", 9, t == i->documentation ? "Docs:" : "", *t);
3453
3454 STRV_FOREACH_PAIR(t, t2, i->listen)
3455 printf(" %*s %s (%s)\n", 9, t == i->listen ? "Listen:" : "", *t2, *t);
3456
3457 if (i->accept)
3458 printf(" Accepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
3459
3460 LIST_FOREACH(exec, p, i->exec) {
3461 _cleanup_free_ char *argv = NULL;
3462 bool good;
3463
3464 /* Only show exited processes here */
3465 if (p->code == 0)
3466 continue;
3467
3468 argv = strv_join(p->argv, " ");
3469 printf(" Process: %u %s=%s ", p->pid, p->name, strna(argv));
3470
3471 good = is_clean_exit_lsb(p->code, p->status, NULL);
3472 if (!good) {
3473 on = ansi_highlight_red();
3474 off = ansi_highlight_off();
3475 } else
3476 on = off = "";
3477
3478 printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));
3479
3480 if (p->code == CLD_EXITED) {
3481 const char *c;
3482
3483 printf("status=%i", p->status);
3484
3485 c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD);
3486 if (c)
3487 printf("/%s", c);
3488
3489 } else
3490 printf("signal=%s", signal_to_string(p->status));
3491
3492 printf(")%s\n", off);
3493
3494 if (i->main_pid == p->pid &&
3495 i->start_timestamp == p->start_timestamp &&
3496 i->exit_timestamp == p->start_timestamp)
3497 /* Let's not show this twice */
3498 i->main_pid = 0;
3499
3500 if (p->pid == i->control_pid)
3501 i->control_pid = 0;
3502 }
3503
3504 if (i->main_pid > 0 || i->control_pid > 0) {
3505 if (i->main_pid > 0) {
3506 printf(" Main PID: "PID_FMT, i->main_pid);
3507
3508 if (i->running) {
3509 _cleanup_free_ char *comm = NULL;
3510 get_process_comm(i->main_pid, &comm);
3511 if (comm)
3512 printf(" (%s)", comm);
3513 } else if (i->exit_code > 0) {
3514 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
3515
3516 if (i->exit_code == CLD_EXITED) {
3517 const char *c;
3518
3519 printf("status=%i", i->exit_status);
3520
3521 c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD);
3522 if (c)
3523 printf("/%s", c);
3524
3525 } else
3526 printf("signal=%s", signal_to_string(i->exit_status));
3527 printf(")");
3528 }
3529
3530 if (i->control_pid > 0)
3531 printf(";");
3532 }
3533
3534 if (i->control_pid > 0) {
3535 _cleanup_free_ char *c = NULL;
3536
3537 printf(" %8s: "PID_FMT, i->main_pid ? "" : " Control", i->control_pid);
3538
3539 get_process_comm(i->control_pid, &c);
3540 if (c)
3541 printf(" (%s)", c);
3542 }
3543
3544 printf("\n");
3545 }
3546
3547 if (i->status_text)
3548 printf(" Status: \"%s\"\n", i->status_text);
3549 if (i->status_errno > 0)
3550 printf(" Error: %i (%s)\n", i->status_errno, strerror(i->status_errno));
3551
3552 if (i->control_group &&
3553 (i->main_pid > 0 || i->control_pid > 0 ||
3554 ((arg_transport != BUS_TRANSPORT_LOCAL && arg_transport != BUS_TRANSPORT_CONTAINER) || cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, i->control_group, false) == 0))) {
3555 unsigned c;
3556
3557 printf(" CGroup: %s\n", i->control_group);
3558
3559 if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
3560 unsigned k = 0;
3561 pid_t extra[2];
3562 static const char prefix[] = " ";
3563
3564 c = columns();
3565 if (c > sizeof(prefix) - 1)
3566 c -= sizeof(prefix) - 1;
3567 else
3568 c = 0;
3569
3570 if (i->main_pid > 0)
3571 extra[k++] = i->main_pid;
3572
3573 if (i->control_pid > 0)
3574 extra[k++] = i->control_pid;
3575
3576 show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix, c, false, extra, k, flags);
3577 }
3578 }
3579
3580 if (i->id && arg_transport == BUS_TRANSPORT_LOCAL) {
3581 show_journal_by_unit(stdout,
3582 i->id,
3583 arg_output,
3584 0,
3585 i->inactive_exit_timestamp_monotonic,
3586 arg_lines,
3587 getuid(),
3588 flags | OUTPUT_BEGIN_NEWLINE,
3589 arg_scope == UNIT_FILE_SYSTEM,
3590 ellipsized);
3591 }
3592
3593 if (i->need_daemon_reload)
3594 printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %sdaemon-reload' recommended.\n",
3595 ansi_highlight_red(),
3596 ansi_highlight_off(),
3597 arg_scope == UNIT_FILE_SYSTEM ? "" : "--user ");
3598 }
3599
3600 static void show_unit_help(UnitStatusInfo *i) {
3601 char **p;
3602
3603 assert(i);
3604
3605 if (!i->documentation) {
3606 log_info("Documentation for %s not known.", i->id);
3607 return;
3608 }
3609
3610 STRV_FOREACH(p, i->documentation)
3611 if (startswith(*p, "man:"))
3612 show_man_page(*p + 4, false);
3613 else
3614 log_info("Can't show: %s", *p);
3615 }
3616
3617 static int status_property(const char *name, sd_bus_message *m, UnitStatusInfo *i, const char *contents) {
3618 int r;
3619
3620 assert(name);
3621 assert(m);
3622 assert(i);
3623
3624 switch (contents[0]) {
3625
3626 case SD_BUS_TYPE_STRING: {
3627 const char *s;
3628
3629 r = sd_bus_message_read(m, "s", &s);
3630 if (r < 0)
3631 return bus_log_parse_error(r);
3632
3633 if (!isempty(s)) {
3634 if (streq(name, "Id"))
3635 i->id = s;
3636 else if (streq(name, "LoadState"))
3637 i->load_state = s;
3638 else if (streq(name, "ActiveState"))
3639 i->active_state = s;
3640 else if (streq(name, "SubState"))
3641 i->sub_state = s;
3642 else if (streq(name, "Description"))
3643 i->description = s;
3644 else if (streq(name, "FragmentPath"))
3645 i->fragment_path = s;
3646 else if (streq(name, "SourcePath"))
3647 i->source_path = s;
3648 #ifndef NOLEGACY
3649 else if (streq(name, "DefaultControlGroup")) {
3650 const char *e;
3651 e = startswith(s, SYSTEMD_CGROUP_CONTROLLER ":");
3652 if (e)
3653 i->control_group = e;
3654 }
3655 #endif
3656 else if (streq(name, "ControlGroup"))
3657 i->control_group = s;
3658 else if (streq(name, "StatusText"))
3659 i->status_text = s;
3660 else if (streq(name, "PIDFile"))
3661 i->pid_file = s;
3662 else if (streq(name, "SysFSPath"))
3663 i->sysfs_path = s;
3664 else if (streq(name, "Where"))
3665 i->where = s;
3666 else if (streq(name, "What"))
3667 i->what = s;
3668 else if (streq(name, "Following"))
3669 i->following = s;
3670 else if (streq(name, "UnitFileState"))
3671 i->unit_file_state = s;
3672 else if (streq(name, "Result"))
3673 i->result = s;
3674 }
3675
3676 break;
3677 }
3678
3679 case SD_BUS_TYPE_BOOLEAN: {
3680 int b;
3681
3682 r = sd_bus_message_read(m, "b", &b);
3683 if (r < 0)
3684 return bus_log_parse_error(r);
3685
3686 if (streq(name, "Accept"))
3687 i->accept = b;
3688 else if (streq(name, "NeedDaemonReload"))
3689 i->need_daemon_reload = b;
3690 else if (streq(name, "ConditionResult"))
3691 i->condition_result = b;
3692 else if (streq(name, "AssertResult"))
3693 i->assert_result = b;
3694
3695 break;
3696 }
3697
3698 case SD_BUS_TYPE_UINT32: {
3699 uint32_t u;
3700
3701 r = sd_bus_message_read(m, "u", &u);
3702 if (r < 0)
3703 return bus_log_parse_error(r);
3704
3705 if (streq(name, "MainPID")) {
3706 if (u > 0) {
3707 i->main_pid = (pid_t) u;
3708 i->running = true;
3709 }
3710 } else if (streq(name, "ControlPID"))
3711 i->control_pid = (pid_t) u;
3712 else if (streq(name, "ExecMainPID")) {
3713 if (u > 0)
3714 i->main_pid = (pid_t) u;
3715 } else if (streq(name, "NAccepted"))
3716 i->n_accepted = u;
3717 else if (streq(name, "NConnections"))
3718 i->n_connections = u;
3719
3720 break;
3721 }
3722
3723 case SD_BUS_TYPE_INT32: {
3724 int32_t j;
3725
3726 r = sd_bus_message_read(m, "i", &j);
3727 if (r < 0)
3728 return bus_log_parse_error(r);
3729
3730 if (streq(name, "ExecMainCode"))
3731 i->exit_code = (int) j;
3732 else if (streq(name, "ExecMainStatus"))
3733 i->exit_status = (int) j;
3734 else if (streq(name, "StatusErrno"))
3735 i->status_errno = (int) j;
3736
3737 break;
3738 }
3739
3740 case SD_BUS_TYPE_UINT64: {
3741 uint64_t u;
3742
3743 r = sd_bus_message_read(m, "t", &u);
3744 if (r < 0)
3745 return bus_log_parse_error(r);
3746
3747 if (streq(name, "ExecMainStartTimestamp"))
3748 i->start_timestamp = (usec_t) u;
3749 else if (streq(name, "ExecMainExitTimestamp"))
3750 i->exit_timestamp = (usec_t) u;
3751 else if (streq(name, "ActiveEnterTimestamp"))
3752 i->active_enter_timestamp = (usec_t) u;
3753 else if (streq(name, "InactiveEnterTimestamp"))
3754 i->inactive_enter_timestamp = (usec_t) u;
3755 else if (streq(name, "InactiveExitTimestamp"))
3756 i->inactive_exit_timestamp = (usec_t) u;
3757 else if (streq(name, "InactiveExitTimestampMonotonic"))
3758 i->inactive_exit_timestamp_monotonic = (usec_t) u;
3759 else if (streq(name, "ActiveExitTimestamp"))
3760 i->active_exit_timestamp = (usec_t) u;
3761 else if (streq(name, "ConditionTimestamp"))
3762 i->condition_timestamp = (usec_t) u;
3763 else if (streq(name, "AssertTimestamp"))
3764 i->assert_timestamp = (usec_t) u;
3765
3766 break;
3767 }
3768
3769 case SD_BUS_TYPE_ARRAY:
3770
3771 if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
3772 _cleanup_free_ ExecStatusInfo *info = NULL;
3773
3774 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
3775 if (r < 0)
3776 return bus_log_parse_error(r);
3777
3778 info = new0(ExecStatusInfo, 1);
3779 if (!info)
3780 return log_oom();
3781
3782 while ((r = exec_status_info_deserialize(m, info)) > 0) {
3783
3784 info->name = strdup(name);
3785 if (!info->name)
3786 log_oom();
3787
3788 LIST_PREPEND(exec, i->exec, info);
3789
3790 info = new0(ExecStatusInfo, 1);
3791 if (!info)
3792 log_oom();
3793 }
3794
3795 if (r < 0)
3796 return bus_log_parse_error(r);
3797
3798 r = sd_bus_message_exit_container(m);
3799 if (r < 0)
3800 return bus_log_parse_error(r);
3801
3802 return 0;
3803
3804 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
3805 const char *type, *path;
3806
3807 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
3808 if (r < 0)
3809 return bus_log_parse_error(r);
3810
3811 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0) {
3812
3813 r = strv_extend(&i->listen, type);
3814 if (r < 0)
3815 return r;
3816
3817 r = strv_extend(&i->listen, path);
3818 if (r < 0)
3819 return r;
3820 }
3821 if (r < 0)
3822 return bus_log_parse_error(r);
3823
3824 r = sd_bus_message_exit_container(m);
3825 if (r < 0)
3826 return bus_log_parse_error(r);
3827
3828 return 0;
3829
3830 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "DropInPaths")) {
3831
3832 r = sd_bus_message_read_strv(m, &i->dropin_paths);
3833 if (r < 0)
3834 return bus_log_parse_error(r);
3835
3836 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Documentation")) {
3837
3838 r = sd_bus_message_read_strv(m, &i->documentation);
3839 if (r < 0)
3840 return bus_log_parse_error(r);
3841
3842 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Conditions")) {
3843 const char *cond, *param;
3844 int trigger, negate;
3845 int32_t state;
3846
3847 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
3848 if (r < 0)
3849 return bus_log_parse_error(r);
3850
3851 while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
3852 log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
3853 if (state < 0 && (!trigger || !i->failed_condition)) {
3854 i->failed_condition = cond;
3855 i->failed_condition_trigger = trigger;
3856 i->failed_condition_negate = negate;
3857 i->failed_condition_parameter = param;
3858 }
3859 }
3860 if (r < 0)
3861 return bus_log_parse_error(r);
3862
3863 r = sd_bus_message_exit_container(m);
3864 if (r < 0)
3865 return bus_log_parse_error(r);
3866
3867 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Asserts")) {
3868 const char *cond, *param;
3869 int trigger, negate;
3870 int32_t state;
3871
3872 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
3873 if (r < 0)
3874 return bus_log_parse_error(r);
3875
3876 while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
3877 log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
3878 if (state < 0 && (!trigger || !i->failed_assert)) {
3879 i->failed_assert = cond;
3880 i->failed_assert_trigger = trigger;
3881 i->failed_assert_negate = negate;
3882 i->failed_assert_parameter = param;
3883 }
3884 }
3885 if (r < 0)
3886 return bus_log_parse_error(r);
3887
3888 r = sd_bus_message_exit_container(m);
3889 if (r < 0)
3890 return bus_log_parse_error(r);
3891
3892 } else
3893 goto skip;
3894
3895 break;
3896
3897 case SD_BUS_TYPE_STRUCT_BEGIN:
3898
3899 if (streq(name, "LoadError")) {
3900 const char *n, *message;
3901
3902 r = sd_bus_message_read(m, "(ss)", &n, &message);
3903 if (r < 0)
3904 return bus_log_parse_error(r);
3905
3906 if (!isempty(message))
3907 i->load_error = message;
3908 } else
3909 goto skip;
3910
3911 break;
3912
3913 default:
3914 goto skip;
3915 }
3916
3917 return 0;
3918
3919 skip:
3920 r = sd_bus_message_skip(m, contents);
3921 if (r < 0)
3922 return bus_log_parse_error(r);
3923
3924 return 0;
3925 }
3926
3927 static int print_property(const char *name, sd_bus_message *m, const char *contents) {
3928 int r;
3929
3930 assert(name);
3931 assert(m);
3932
3933 /* This is a low-level property printer, see
3934 * print_status_info() for the nicer output */
3935
3936 if (arg_properties && !strv_find(arg_properties, name)) {
3937 /* skip what we didn't read */
3938 r = sd_bus_message_skip(m, contents);
3939 return r;
3940 }
3941
3942 switch (contents[0]) {
3943
3944 case SD_BUS_TYPE_STRUCT_BEGIN:
3945
3946 if (contents[1] == SD_BUS_TYPE_UINT32 && streq(name, "Job")) {
3947 uint32_t u;
3948
3949 r = sd_bus_message_read(m, "(uo)", &u, NULL);
3950 if (r < 0)
3951 return bus_log_parse_error(r);
3952
3953 if (u > 0)
3954 printf("%s=%"PRIu32"\n", name, u);
3955 else if (arg_all)
3956 printf("%s=\n", name);
3957
3958 return 0;
3959
3960 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Unit")) {
3961 const char *s;
3962
3963 r = sd_bus_message_read(m, "(so)", &s, NULL);
3964 if (r < 0)
3965 return bus_log_parse_error(r);
3966
3967 if (arg_all || !isempty(s))
3968 printf("%s=%s\n", name, s);
3969
3970 return 0;
3971
3972 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "LoadError")) {
3973 const char *a = NULL, *b = NULL;
3974
3975 r = sd_bus_message_read(m, "(ss)", &a, &b);
3976 if (r < 0)
3977 return bus_log_parse_error(r);
3978
3979 if (arg_all || !isempty(a) || !isempty(b))
3980 printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
3981
3982 return 0;
3983 } else if (streq_ptr(name, "SystemCallFilter")) {
3984 _cleanup_strv_free_ char **l = NULL;
3985 int whitelist;
3986
3987 r = sd_bus_message_enter_container(m, 'r', "bas");
3988 if (r < 0)
3989 return bus_log_parse_error(r);
3990
3991 r = sd_bus_message_read(m, "b", &whitelist);
3992 if (r < 0)
3993 return bus_log_parse_error(r);
3994
3995 r = sd_bus_message_read_strv(m, &l);
3996 if (r < 0)
3997 return bus_log_parse_error(r);
3998
3999 r = sd_bus_message_exit_container(m);
4000 if (r < 0)
4001 return bus_log_parse_error(r);
4002
4003 if (arg_all || whitelist || !strv_isempty(l)) {
4004 bool first = true;
4005 char **i;
4006
4007 fputs(name, stdout);
4008 fputc('=', stdout);
4009
4010 if (!whitelist)
4011 fputc('~', stdout);
4012
4013 STRV_FOREACH(i, l) {
4014 if (first)
4015 first = false;
4016 else
4017 fputc(' ', stdout);
4018
4019 fputs(*i, stdout);
4020 }
4021 fputc('\n', stdout);
4022 }
4023
4024 return 0;
4025 }
4026
4027 break;
4028
4029 case SD_BUS_TYPE_ARRAY:
4030
4031 if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "EnvironmentFiles")) {
4032 const char *path;
4033 int ignore;
4034
4035 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sb)");
4036 if (r < 0)
4037 return bus_log_parse_error(r);
4038
4039 while ((r = sd_bus_message_read(m, "(sb)", &path, &ignore)) > 0)
4040 printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
4041
4042 if (r < 0)
4043 return bus_log_parse_error(r);
4044
4045 r = sd_bus_message_exit_container(m);
4046 if (r < 0)
4047 return bus_log_parse_error(r);
4048
4049 return 0;
4050
4051 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Paths")) {
4052 const char *type, *path;
4053
4054 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
4055 if (r < 0)
4056 return bus_log_parse_error(r);
4057
4058 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
4059 printf("%s=%s\n", type, path);
4060 if (r < 0)
4061 return bus_log_parse_error(r);
4062
4063 r = sd_bus_message_exit_container(m);
4064 if (r < 0)
4065 return bus_log_parse_error(r);
4066
4067 return 0;
4068
4069 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
4070 const char *type, *path;
4071
4072 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
4073 if (r < 0)
4074 return bus_log_parse_error(r);
4075
4076 while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0)
4077 printf("Listen%s=%s\n", type, path);
4078 if (r < 0)
4079 return bus_log_parse_error(r);
4080
4081 r = sd_bus_message_exit_container(m);
4082 if (r < 0)
4083 return bus_log_parse_error(r);
4084
4085 return 0;
4086
4087 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Timers")) {
4088 const char *base;
4089 uint64_t value, next_elapse;
4090
4091 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(stt)");
4092 if (r < 0)
4093 return bus_log_parse_error(r);
4094
4095 while ((r = sd_bus_message_read(m, "(stt)", &base, &value, &next_elapse)) > 0) {
4096 char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
4097
4098 printf("%s={ value=%s ; next_elapse=%s }\n",
4099 base,
4100 format_timespan(timespan1, sizeof(timespan1), value, 0),
4101 format_timespan(timespan2, sizeof(timespan2), next_elapse, 0));
4102 }
4103 if (r < 0)
4104 return bus_log_parse_error(r);
4105
4106 r = sd_bus_message_exit_container(m);
4107 if (r < 0)
4108 return bus_log_parse_error(r);
4109
4110 return 0;
4111
4112 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
4113 ExecStatusInfo info = {};
4114
4115 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
4116 if (r < 0)
4117 return bus_log_parse_error(r);
4118
4119 while ((r = exec_status_info_deserialize(m, &info)) > 0) {
4120 char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
4121 _cleanup_free_ char *tt;
4122
4123 tt = strv_join(info.argv, " ");
4124
4125 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",
4126 name,
4127 strna(info.path),
4128 strna(tt),
4129 yes_no(info.ignore),
4130 strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
4131 strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
4132 info.pid,
4133 sigchld_code_to_string(info.code),
4134 info.status,
4135 info.code == CLD_EXITED ? "" : "/",
4136 strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
4137
4138 free(info.path);
4139 strv_free(info.argv);
4140 zero(info);
4141 }
4142
4143 r = sd_bus_message_exit_container(m);
4144 if (r < 0)
4145 return bus_log_parse_error(r);
4146
4147 return 0;
4148
4149 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "DeviceAllow")) {
4150 const char *path, *rwm;
4151
4152 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
4153 if (r < 0)
4154 return bus_log_parse_error(r);
4155
4156 while ((r = sd_bus_message_read(m, "(ss)", &path, &rwm)) > 0)
4157 printf("%s=%s %s\n", name, strna(path), strna(rwm));
4158 if (r < 0)
4159 return bus_log_parse_error(r);
4160
4161 r = sd_bus_message_exit_container(m);
4162 if (r < 0)
4163 return bus_log_parse_error(r);
4164
4165 return 0;
4166
4167 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "BlockIODeviceWeight")) {
4168 const char *path;
4169 uint64_t weight;
4170
4171 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
4172 if (r < 0)
4173 return bus_log_parse_error(r);
4174
4175 while ((r = sd_bus_message_read(m, "(st)", &path, &weight)) > 0)
4176 printf("%s=%s %" PRIu64 "\n", name, strna(path), weight);
4177 if (r < 0)
4178 return bus_log_parse_error(r);
4179
4180 r = sd_bus_message_exit_container(m);
4181 if (r < 0)
4182 return bus_log_parse_error(r);
4183
4184 return 0;
4185
4186 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && (streq(name, "BlockIOReadBandwidth") || streq(name, "BlockIOWriteBandwidth"))) {
4187 const char *path;
4188 uint64_t bandwidth;
4189
4190 r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(st)");
4191 if (r < 0)
4192 return bus_log_parse_error(r);
4193
4194 while ((r = sd_bus_message_read(m, "(st)", &path, &bandwidth)) > 0)
4195 printf("%s=%s %" PRIu64 "\n", name, strna(path), bandwidth);
4196 if (r < 0)
4197 return bus_log_parse_error(r);
4198
4199 r = sd_bus_message_exit_container(m);
4200 if (r < 0)
4201 return bus_log_parse_error(r);
4202
4203 return 0;
4204 }
4205
4206 break;
4207 }
4208
4209 r = bus_print_property(name, m, arg_all);
4210 if (r < 0)
4211 return bus_log_parse_error(r);
4212
4213 if (r == 0) {
4214 r = sd_bus_message_skip(m, contents);
4215 if (r < 0)
4216 return bus_log_parse_error(r);
4217
4218 if (arg_all)
4219 printf("%s=[unprintable]\n", name);
4220 }
4221
4222 return 0;
4223 }
4224
4225 static int show_one(
4226 const char *verb,
4227 sd_bus *bus,
4228 const char *path,
4229 bool show_properties,
4230 bool *new_line,
4231 bool *ellipsized) {
4232
4233 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4234 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4235 UnitStatusInfo info = {};
4236 ExecStatusInfo *p;
4237 int r;
4238
4239 assert(path);
4240 assert(new_line);
4241
4242 log_debug("Showing one %s", path);
4243
4244 r = sd_bus_call_method(
4245 bus,
4246 "org.freedesktop.systemd1",
4247 path,
4248 "org.freedesktop.DBus.Properties",
4249 "GetAll",
4250 &error,
4251 &reply,
4252 "s", "");
4253 if (r < 0) {
4254 log_error("Failed to get properties: %s", bus_error_message(&error, r));
4255 return r;
4256 }
4257
4258 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
4259 if (r < 0)
4260 return bus_log_parse_error(r);
4261
4262 if (*new_line)
4263 printf("\n");
4264
4265 *new_line = true;
4266
4267 while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
4268 const char *name, *contents;
4269
4270 r = sd_bus_message_read(reply, "s", &name);
4271 if (r < 0)
4272 return bus_log_parse_error(r);
4273
4274 r = sd_bus_message_peek_type(reply, NULL, &contents);
4275 if (r < 0)
4276 return bus_log_parse_error(r);
4277
4278 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, contents);
4279 if (r < 0)
4280 return bus_log_parse_error(r);
4281
4282 if (show_properties)
4283 r = print_property(name, reply, contents);
4284 else
4285 r = status_property(name, reply, &info, contents);
4286 if (r < 0)
4287 return r;
4288
4289 r = sd_bus_message_exit_container(reply);
4290 if (r < 0)
4291 return bus_log_parse_error(r);
4292
4293 r = sd_bus_message_exit_container(reply);
4294 if (r < 0)
4295 return bus_log_parse_error(r);
4296 }
4297 if (r < 0)
4298 return bus_log_parse_error(r);
4299
4300 r = sd_bus_message_exit_container(reply);
4301 if (r < 0)
4302 return bus_log_parse_error(r);
4303
4304 r = 0;
4305
4306 if (!show_properties) {
4307 if (streq(verb, "help"))
4308 show_unit_help(&info);
4309 else
4310 print_status_info(&info, ellipsized);
4311 }
4312
4313 strv_free(info.documentation);
4314 strv_free(info.dropin_paths);
4315 strv_free(info.listen);
4316
4317 if (!streq_ptr(info.active_state, "active") &&
4318 !streq_ptr(info.active_state, "reloading") &&
4319 streq(verb, "status")) {
4320 /* According to LSB: "program not running" */
4321 /* 0: program is running or service is OK
4322 * 1: program is dead and /run PID file exists
4323 * 2: program is dead and /run/lock lock file exists
4324 * 3: program is not running
4325 * 4: program or service status is unknown
4326 */
4327 if (info.pid_file && access(info.pid_file, F_OK) == 0)
4328 r = 1;
4329 else
4330 r = 3;
4331 }
4332
4333 while ((p = info.exec)) {
4334 LIST_REMOVE(exec, info.exec, p);
4335 exec_status_info_free(p);
4336 }
4337
4338 return r;
4339 }
4340
4341 static int get_unit_dbus_path_by_pid(
4342 sd_bus *bus,
4343 uint32_t pid,
4344 char **unit) {
4345
4346 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4347 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4348 char *u;
4349 int r;
4350
4351 r = sd_bus_call_method(
4352 bus,
4353 "org.freedesktop.systemd1",
4354 "/org/freedesktop/systemd1",
4355 "org.freedesktop.systemd1.Manager",
4356 "GetUnitByPID",
4357 &error,
4358 &reply,
4359 "u", pid);
4360 if (r < 0) {
4361 log_error("Failed to get unit for PID "PID_FMT": %s", pid, bus_error_message(&error, r));
4362 return r;
4363 }
4364
4365 r = sd_bus_message_read(reply, "o", &u);
4366 if (r < 0)
4367 return bus_log_parse_error(r);
4368
4369 u = strdup(u);
4370 if (!u)
4371 return log_oom();
4372
4373 *unit = u;
4374 return 0;
4375 }
4376
4377 static int show_all(
4378 const char* verb,
4379 sd_bus *bus,
4380 bool show_properties,
4381 bool *new_line,
4382 bool *ellipsized) {
4383
4384 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4385 _cleanup_free_ UnitInfo *unit_infos = NULL;
4386 const UnitInfo *u;
4387 unsigned c;
4388 int r, ret = 0;
4389
4390 r = get_unit_list(bus, NULL, NULL, &unit_infos, 0, &reply);
4391 if (r < 0)
4392 return r;
4393
4394 pager_open_if_enabled();
4395
4396 c = (unsigned) r;
4397
4398 qsort_safe(unit_infos, c, sizeof(UnitInfo), compare_unit_info);
4399
4400 for (u = unit_infos; u < unit_infos + c; u++) {
4401 _cleanup_free_ char *p = NULL;
4402
4403 p = unit_dbus_path_from_name(u->id);
4404 if (!p)
4405 return log_oom();
4406
4407 r = show_one(verb, bus, p, show_properties, new_line, ellipsized);
4408 if (r < 0)
4409 return r;
4410 else if (r > 0 && ret == 0)
4411 ret = r;
4412 }
4413
4414 return ret;
4415 }
4416
4417 static int show_system_status(sd_bus *bus) {
4418 char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], since2[FORMAT_TIMESTAMP_MAX];
4419 _cleanup_free_ char *hn = NULL;
4420 struct machine_info mi = {};
4421 const char *on, *off;
4422 int r;
4423
4424 hn = gethostname_malloc();
4425 if (!hn)
4426 return log_oom();
4427
4428 r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, &mi);
4429 if (r < 0)
4430 return log_error_errno(r, "Failed to read server status: %m");
4431
4432 if (streq_ptr(mi.state, "degraded")) {
4433 on = ansi_highlight_red();
4434 off = ansi_highlight_off();
4435 } else if (!streq_ptr(mi.state, "running")) {
4436 on = ansi_highlight_yellow();
4437 off = ansi_highlight_off();
4438 } else
4439 on = off = "";
4440
4441 printf("%s%s%s %s\n", on, draw_special_char(DRAW_BLACK_CIRCLE), off, arg_host ? arg_host : hn);
4442
4443 printf(" State: %s%s%s\n",
4444 on, strna(mi.state), off);
4445
4446 printf(" Jobs: %u queued\n", mi.n_jobs);
4447 printf(" Failed: %u units\n", mi.n_failed_units);
4448
4449 printf(" Since: %s; %s\n",
4450 format_timestamp(since2, sizeof(since2), mi.timestamp),
4451 format_timestamp_relative(since1, sizeof(since1), mi.timestamp));
4452
4453 printf(" CGroup: %s\n", mi.control_group ?: "/");
4454 if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
4455 int flags =
4456 arg_all * OUTPUT_SHOW_ALL |
4457 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
4458 on_tty() * OUTPUT_COLOR |
4459 !arg_quiet * OUTPUT_WARN_CUTOFF |
4460 arg_full * OUTPUT_FULL_WIDTH;
4461
4462 static const char prefix[] = " ";
4463 unsigned c;
4464
4465 c = columns();
4466 if (c > sizeof(prefix) - 1)
4467 c -= sizeof(prefix) - 1;
4468 else
4469 c = 0;
4470
4471 show_cgroup(SYSTEMD_CGROUP_CONTROLLER, strempty(mi.control_group), prefix, c, false, flags);
4472 }
4473
4474 free(mi.state);
4475 free(mi.control_group);
4476
4477 return 0;
4478 }
4479
4480 static int show(sd_bus *bus, char **args) {
4481 bool show_properties, show_status, new_line = false;
4482 bool ellipsized = false;
4483 int r, ret = 0;
4484
4485 assert(bus);
4486 assert(args);
4487
4488 show_properties = streq(args[0], "show");
4489 show_status = streq(args[0], "status");
4490
4491 if (show_properties)
4492 pager_open_if_enabled();
4493
4494 /* If no argument is specified inspect the manager itself */
4495
4496 if (show_properties && strv_length(args) <= 1)
4497 return show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line, &ellipsized);
4498
4499 if (show_status && strv_length(args) <= 1) {
4500
4501 pager_open_if_enabled();
4502 show_system_status(bus);
4503 new_line = true;
4504
4505 if (arg_all)
4506 ret = show_all(args[0], bus, false, &new_line, &ellipsized);
4507 } else {
4508 _cleanup_free_ char **patterns = NULL;
4509 char **name;
4510
4511 STRV_FOREACH(name, args + 1) {
4512 _cleanup_free_ char *unit = NULL;
4513 uint32_t id;
4514
4515 if (safe_atou32(*name, &id) < 0) {
4516 if (strv_push(&patterns, *name) < 0)
4517 return log_oom();
4518
4519 continue;
4520 } else if (show_properties) {
4521 /* Interpret as job id */
4522 if (asprintf(&unit, "/org/freedesktop/systemd1/job/%u", id) < 0)
4523 return log_oom();
4524
4525 } else {
4526 /* Interpret as PID */
4527 r = get_unit_dbus_path_by_pid(bus, id, &unit);
4528 if (r < 0) {
4529 ret = r;
4530 continue;
4531 }
4532 }
4533
4534 r = show_one(args[0], bus, unit, show_properties,
4535 &new_line, &ellipsized);
4536 if (r < 0)
4537 return r;
4538 else if (r > 0 && ret == 0)
4539 ret = r;
4540 }
4541
4542 if (!strv_isempty(patterns)) {
4543 _cleanup_strv_free_ char **names = NULL;
4544
4545 r = expand_names(bus, patterns, NULL, &names);
4546 if (r < 0)
4547 log_error_errno(r, "Failed to expand names: %m");
4548
4549 STRV_FOREACH(name, names) {
4550 _cleanup_free_ char *unit;
4551
4552 unit = unit_dbus_path_from_name(*name);
4553 if (!unit)
4554 return log_oom();
4555
4556 r = show_one(args[0], bus, unit, show_properties,
4557 &new_line, &ellipsized);
4558 if (r < 0)
4559 return r;
4560 else if (r > 0 && ret == 0)
4561 ret = r;
4562 }
4563 }
4564 }
4565
4566 if (ellipsized && !arg_quiet)
4567 printf("Hint: Some lines were ellipsized, use -l to show in full.\n");
4568
4569 return ret;
4570 }
4571
4572 static int cat(sd_bus *bus, char **args) {
4573 _cleanup_strv_free_ char **names = NULL;
4574 char **name;
4575 bool first = true;
4576 int r = 0;
4577
4578 assert(bus);
4579 assert(args);
4580
4581 r = expand_names(bus, args + 1, NULL, &names);
4582 if (r < 0)
4583 log_error_errno(r, "Failed to expand names: %m");
4584
4585 pager_open_if_enabled();
4586
4587 STRV_FOREACH(name, names) {
4588 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4589 _cleanup_strv_free_ char **dropin_paths = NULL;
4590 _cleanup_free_ char *fragment_path = NULL, *unit = NULL;
4591 char **path;
4592
4593 unit = unit_dbus_path_from_name(*name);
4594 if (!unit)
4595 return log_oom();
4596
4597 if (need_daemon_reload(bus, *name) > 0)
4598 log_warning("Unit file of %s changed on disk. Run 'systemctl%s daemon-reload'.",
4599 *name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
4600
4601 r = sd_bus_get_property_string(
4602 bus,
4603 "org.freedesktop.systemd1",
4604 unit,
4605 "org.freedesktop.systemd1.Unit",
4606 "FragmentPath",
4607 &error,
4608 &fragment_path);
4609 if (r < 0) {
4610 log_warning("Failed to get FragmentPath: %s", bus_error_message(&error, r));
4611 continue;
4612 }
4613
4614 r = sd_bus_get_property_strv(
4615 bus,
4616 "org.freedesktop.systemd1",
4617 unit,
4618 "org.freedesktop.systemd1.Unit",
4619 "DropInPaths",
4620 &error,
4621 &dropin_paths);
4622 if (r < 0) {
4623 log_warning("Failed to get DropInPaths: %s", bus_error_message(&error, r));
4624 continue;
4625 }
4626
4627 if (first)
4628 first = false;
4629 else
4630 puts("");
4631
4632 if (!isempty(fragment_path)) {
4633 printf("%s# %s%s\n",
4634 ansi_highlight_blue(),
4635 fragment_path,
4636 ansi_highlight_off());
4637 fflush(stdout);
4638
4639 r = copy_file_fd(fragment_path, STDOUT_FILENO);
4640 if (r < 0) {
4641 log_warning_errno(r, "Failed to cat %s: %m", fragment_path);
4642 continue;
4643 }
4644 }
4645
4646 STRV_FOREACH(path, dropin_paths) {
4647 printf("%s%s# %s%s\n",
4648 isempty(fragment_path) && path == dropin_paths ? "" : "\n",
4649 ansi_highlight_blue(),
4650 *path,
4651 ansi_highlight_off());
4652 fflush(stdout);
4653
4654 r = copy_file_fd(*path, STDOUT_FILENO);
4655 if (r < 0) {
4656 log_warning_errno(r, "Failed to cat %s: %m", *path);
4657 continue;
4658 }
4659 }
4660 }
4661
4662 return r < 0 ? r : 0;
4663 }
4664
4665 static int set_property(sd_bus *bus, char **args) {
4666 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4667 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4668 _cleanup_free_ char *n = NULL;
4669 char **i;
4670 int r;
4671
4672 r = sd_bus_message_new_method_call(
4673 bus,
4674 &m,
4675 "org.freedesktop.systemd1",
4676 "/org/freedesktop/systemd1",
4677 "org.freedesktop.systemd1.Manager",
4678 "SetUnitProperties");
4679 if (r < 0)
4680 return bus_log_create_error(r);
4681
4682 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
4683 if (r < 0)
4684 return bus_log_create_error(r);
4685
4686 n = unit_name_mangle(args[1], MANGLE_NOGLOB);
4687 if (!n)
4688 return log_oom();
4689
4690 r = sd_bus_message_append(m, "sb", n, arg_runtime);
4691 if (r < 0)
4692 return bus_log_create_error(r);
4693
4694 r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, "(sv)");
4695 if (r < 0)
4696 return bus_log_create_error(r);
4697
4698 STRV_FOREACH(i, args + 2) {
4699 r = sd_bus_message_open_container(m, SD_BUS_TYPE_STRUCT, "sv");
4700 if (r < 0)
4701 return bus_log_create_error(r);
4702
4703 r = bus_append_unit_property_assignment(m, *i);
4704 if (r < 0)
4705 return r;
4706
4707 r = sd_bus_message_close_container(m);
4708 if (r < 0)
4709 return bus_log_create_error(r);
4710 }
4711
4712 r = sd_bus_message_close_container(m);
4713 if (r < 0)
4714 return bus_log_create_error(r);
4715
4716 r = sd_bus_call(bus, m, 0, &error, NULL);
4717 if (r < 0) {
4718 log_error("Failed to set unit properties on %s: %s", n, bus_error_message(&error, r));
4719 return r;
4720 }
4721
4722 return 0;
4723 }
4724
4725 static int snapshot(sd_bus *bus, char **args) {
4726 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4727 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
4728 _cleanup_free_ char *n = NULL, *id = NULL;
4729 const char *path;
4730 int r;
4731
4732 if (strv_length(args) > 1)
4733 n = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".snapshot");
4734 else
4735 n = strdup("");
4736 if (!n)
4737 return log_oom();
4738
4739 r = sd_bus_message_new_method_call(
4740 bus,
4741 &m,
4742 "org.freedesktop.systemd1",
4743 "/org/freedesktop/systemd1",
4744 "org.freedesktop.systemd1.Manager",
4745 "CreateSnapshot");
4746 if (r < 0)
4747 return bus_log_create_error(r);
4748
4749 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
4750 if (r < 0)
4751 return bus_log_create_error(r);
4752
4753 r = sd_bus_message_append(m, "sb", n, false);
4754 if (r < 0)
4755 return bus_log_create_error(r);
4756
4757 r = sd_bus_call(bus, m, 0, &error, &reply);
4758 if (r < 0) {
4759 log_error("Failed to create snapshot: %s", bus_error_message(&error, r));
4760 return r;
4761 }
4762
4763 r = sd_bus_message_read(reply, "o", &path);
4764 if (r < 0)
4765 return bus_log_parse_error(r);
4766
4767 r = sd_bus_get_property_string(
4768 bus,
4769 "org.freedesktop.systemd1",
4770 path,
4771 "org.freedesktop.systemd1.Unit",
4772 "Id",
4773 &error,
4774 &id);
4775 if (r < 0) {
4776 log_error("Failed to get ID of snapshot: %s", bus_error_message(&error, r));
4777 return r;
4778 }
4779
4780 if (!arg_quiet)
4781 puts(id);
4782
4783 return 0;
4784 }
4785
4786 static int delete_snapshot(sd_bus *bus, char **args) {
4787 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4788 _cleanup_strv_free_ char **names = NULL;
4789 char **name;
4790 int r;
4791
4792 assert(args);
4793
4794 r = expand_names(bus, args + 1, ".snapshot", &names);
4795 if (r < 0)
4796 log_error_errno(r, "Failed to expand names: %m");
4797
4798 STRV_FOREACH(name, names) {
4799 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4800 int q;
4801
4802 q = sd_bus_message_new_method_call(
4803 bus,
4804 &m,
4805 "org.freedesktop.systemd1",
4806 "/org/freedesktop/systemd1",
4807 "org.freedesktop.systemd1.Manager",
4808 "RemoveSnapshot");
4809 if (q < 0)
4810 return bus_log_create_error(q);
4811
4812 q = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
4813 if (q < 0)
4814 return bus_log_create_error(q);
4815
4816 q = sd_bus_message_append(m, "s", *name);
4817 if (q < 0)
4818 return bus_log_create_error(q);
4819
4820 q = sd_bus_call(bus, m, 0, &error, NULL);
4821 if (q < 0) {
4822 log_error("Failed to remove snapshot %s: %s", *name, bus_error_message(&error, q));
4823 if (r == 0)
4824 r = q;
4825 }
4826 }
4827
4828 return r;
4829 }
4830
4831 static int daemon_reload(sd_bus *bus, char **args) {
4832 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4833 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4834 const char *method;
4835 int r;
4836
4837 if (arg_action == ACTION_RELOAD)
4838 method = "Reload";
4839 else if (arg_action == ACTION_REEXEC)
4840 method = "Reexecute";
4841 else {
4842 assert(arg_action == ACTION_SYSTEMCTL);
4843
4844 method =
4845 streq(args[0], "clear-jobs") ||
4846 streq(args[0], "cancel") ? "ClearJobs" :
4847 streq(args[0], "daemon-reexec") ? "Reexecute" :
4848 streq(args[0], "reset-failed") ? "ResetFailed" :
4849 streq(args[0], "halt") ? "Halt" :
4850 streq(args[0], "poweroff") ? "PowerOff" :
4851 streq(args[0], "reboot") ? "Reboot" :
4852 streq(args[0], "kexec") ? "KExec" :
4853 streq(args[0], "exit") ? "Exit" :
4854 /* "daemon-reload" */ "Reload";
4855 }
4856
4857 r = sd_bus_message_new_method_call(
4858 bus,
4859 &m,
4860 "org.freedesktop.systemd1",
4861 "/org/freedesktop/systemd1",
4862 "org.freedesktop.systemd1.Manager",
4863 method);
4864 if (r < 0)
4865 return bus_log_create_error(r);
4866
4867 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
4868 if (r < 0)
4869 return bus_log_create_error(r);
4870
4871 r = sd_bus_call(bus, m, 0, &error, NULL);
4872 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
4873 /* There's always a fallback possible for
4874 * legacy actions. */
4875 r = -EADDRNOTAVAIL;
4876 else if ((r == -ETIMEDOUT || r == -ECONNRESET) && streq(method, "Reexecute"))
4877 /* On reexecution, we expect a disconnect, not a
4878 * reply */
4879 r = 0;
4880 else if (r < 0)
4881 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
4882
4883 return r < 0 ? r : 0;
4884 }
4885
4886 static int reset_failed(sd_bus *bus, char **args) {
4887 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4888 _cleanup_strv_free_ char **names = NULL;
4889 char **name;
4890 int r, q;
4891
4892 if (strv_length(args) <= 1)
4893 return daemon_reload(bus, args);
4894
4895 r = expand_names(bus, args + 1, NULL, &names);
4896 if (r < 0)
4897 log_error_errno(r, "Failed to expand names: %m");
4898
4899 STRV_FOREACH(name, names) {
4900 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
4901
4902 q = sd_bus_message_new_method_call(
4903 bus,
4904 &m,
4905 "org.freedesktop.systemd1",
4906 "/org/freedesktop/systemd1",
4907 "org.freedesktop.systemd1.Manager",
4908 "ResetFailedUnit");
4909 if (q < 0)
4910 return bus_log_create_error(q);
4911
4912 q = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
4913 if (q < 0)
4914 return bus_log_create_error(q);
4915
4916 q = sd_bus_message_append(m, "s", *name);
4917 if (q < 0)
4918 return bus_log_create_error(q);
4919
4920 q = sd_bus_call(bus, m, 0, &error, NULL);
4921 if (q < 0) {
4922 log_error("Failed to reset failed state of unit %s: %s", *name, bus_error_message(&error, q));
4923 if (r == 0)
4924 r = q;
4925 }
4926 }
4927
4928 return r;
4929 }
4930
4931 static int show_environment(sd_bus *bus, char **args) {
4932 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4933 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
4934 const char *text;
4935 int r;
4936
4937 pager_open_if_enabled();
4938
4939 r = sd_bus_get_property(
4940 bus,
4941 "org.freedesktop.systemd1",
4942 "/org/freedesktop/systemd1",
4943 "org.freedesktop.systemd1.Manager",
4944 "Environment",
4945 &error,
4946 &reply,
4947 "as");
4948 if (r < 0) {
4949 log_error("Failed to get environment: %s", bus_error_message(&error, r));
4950 return r;
4951 }
4952
4953 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "s");
4954 if (r < 0)
4955 return bus_log_parse_error(r);
4956
4957 while ((r = sd_bus_message_read_basic(reply, SD_BUS_TYPE_STRING, &text)) > 0)
4958 puts(text);
4959 if (r < 0)
4960 return bus_log_parse_error(r);
4961
4962 r = sd_bus_message_exit_container(reply);
4963 if (r < 0)
4964 return bus_log_parse_error(r);
4965
4966 return 0;
4967 }
4968
4969 static int switch_root(sd_bus *bus, char **args) {
4970 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
4971 _cleanup_free_ char *cmdline_init = NULL;
4972 const char *root, *init;
4973 unsigned l;
4974 int r;
4975
4976 l = strv_length(args);
4977 if (l < 2 || l > 3) {
4978 log_error("Wrong number of arguments.");
4979 return -EINVAL;
4980 }
4981
4982 root = args[1];
4983
4984 if (l >= 3)
4985 init = args[2];
4986 else {
4987 r = parse_env_file("/proc/cmdline", WHITESPACE,
4988 "init", &cmdline_init,
4989 NULL);
4990 if (r < 0)
4991 log_debug_errno(r, "Failed to parse /proc/cmdline: %m");
4992
4993 init = cmdline_init;
4994 }
4995
4996 if (isempty(init))
4997 init = NULL;
4998
4999 if (init) {
5000 const char *root_systemd_path = NULL, *root_init_path = NULL;
5001
5002 root_systemd_path = strappenda(root, "/" SYSTEMD_BINARY_PATH);
5003 root_init_path = strappenda(root, "/", init);
5004
5005 /* If the passed init is actually the same as the
5006 * systemd binary, then let's suppress it. */
5007 if (files_same(root_init_path, root_systemd_path) > 0)
5008 init = NULL;
5009 }
5010
5011 log_debug("Switching root - root: %s; init: %s", root, strna(init));
5012
5013 r = sd_bus_call_method(
5014 bus,
5015 "org.freedesktop.systemd1",
5016 "/org/freedesktop/systemd1",
5017 "org.freedesktop.systemd1.Manager",
5018 "SwitchRoot",
5019 &error,
5020 NULL,
5021 "ss", root, init);
5022 if (r < 0) {
5023 log_error("Failed to switch root: %s", bus_error_message(&error, r));
5024 return r;
5025 }
5026
5027 return 0;
5028 }
5029
5030 static int set_environment(sd_bus *bus, char **args) {
5031 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5032 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
5033 const char *method;
5034 int r;
5035
5036 assert(bus);
5037 assert(args);
5038
5039 method = streq(args[0], "set-environment")
5040 ? "SetEnvironment"
5041 : "UnsetEnvironment";
5042
5043 r = sd_bus_message_new_method_call(
5044 bus,
5045 &m,
5046 "org.freedesktop.systemd1",
5047 "/org/freedesktop/systemd1",
5048 "org.freedesktop.systemd1.Manager",
5049 method);
5050 if (r < 0)
5051 return bus_log_create_error(r);
5052
5053 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
5054 if (r < 0)
5055 return bus_log_create_error(r);
5056
5057 r = sd_bus_message_append_strv(m, args + 1);
5058 if (r < 0)
5059 return bus_log_create_error(r);
5060
5061 r = sd_bus_call(bus, m, 0, &error, NULL);
5062 if (r < 0) {
5063 log_error("Failed to set environment: %s", bus_error_message(&error, r));
5064 return r;
5065 }
5066
5067 return 0;
5068 }
5069
5070 static int import_environment(sd_bus *bus, char **args) {
5071 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5072 _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
5073 int r;
5074
5075 assert(bus);
5076 assert(args);
5077
5078 r = sd_bus_message_new_method_call(
5079 bus,
5080 &m,
5081 "org.freedesktop.systemd1",
5082 "/org/freedesktop/systemd1",
5083 "org.freedesktop.systemd1.Manager",
5084 "SetEnvironment");
5085 if (r < 0)
5086 return bus_log_create_error(r);
5087
5088 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
5089 if (r < 0)
5090 return bus_log_create_error(r);
5091
5092 if (strv_isempty(args + 1))
5093 r = sd_bus_message_append_strv(m, environ);
5094 else {
5095 char **a, **b;
5096
5097 r = sd_bus_message_open_container(m, 'a', "s");
5098 if (r < 0)
5099 return bus_log_create_error(r);
5100
5101 STRV_FOREACH(a, args + 1) {
5102
5103 if (!env_name_is_valid(*a)) {
5104 log_error("Not a valid environment variable name: %s", *a);
5105 return -EINVAL;
5106 }
5107
5108 STRV_FOREACH(b, environ) {
5109 const char *eq;
5110
5111 eq = startswith(*b, *a);
5112 if (eq && *eq == '=') {
5113
5114 r = sd_bus_message_append(m, "s", *b);
5115 if (r < 0)
5116 return bus_log_create_error(r);
5117
5118 break;
5119 }
5120 }
5121 }
5122
5123 r = sd_bus_message_close_container(m);
5124 }
5125 if (r < 0)
5126 return bus_log_create_error(r);
5127
5128 r = sd_bus_call(bus, m, 0, &error, NULL);
5129 if (r < 0) {
5130 log_error("Failed to import environment: %s", bus_error_message(&error, r));
5131 return r;
5132 }
5133
5134 return 0;
5135 }
5136
5137 static int enable_sysv_units(const char *verb, char **args) {
5138 int r = 0;
5139
5140 #if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG)
5141 unsigned f = 1, t = 1;
5142 _cleanup_lookup_paths_free_ LookupPaths paths = {};
5143
5144 if (arg_scope != UNIT_FILE_SYSTEM)
5145 return 0;
5146
5147 if (!streq(verb, "enable") &&
5148 !streq(verb, "disable") &&
5149 !streq(verb, "is-enabled"))
5150 return 0;
5151
5152 /* Processes all SysV units, and reshuffles the array so that
5153 * afterwards only the native units remain */
5154
5155 r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, arg_root, NULL, NULL, NULL);
5156 if (r < 0)
5157 return r;
5158
5159 r = 0;
5160 for (f = 0; args[f]; f++) {
5161 const char *name;
5162 _cleanup_free_ char *p = NULL, *q = NULL, *l = NULL;
5163 bool found_native = false, found_sysv;
5164 unsigned c = 1;
5165 const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL };
5166 char **k;
5167 int j;
5168 pid_t pid;
5169 siginfo_t status;
5170
5171 name = args[f];
5172
5173 if (!endswith(name, ".service"))
5174 continue;
5175
5176 if (path_is_absolute(name))
5177 continue;
5178
5179 STRV_FOREACH(k, paths.unit_path) {
5180 _cleanup_free_ char *path = NULL;
5181
5182 path = path_join(arg_root, *k, name);
5183 if (!path)
5184 return log_oom();
5185
5186 found_native = access(path, F_OK) >= 0;
5187 if (found_native)
5188 break;
5189 }
5190
5191 if (found_native)
5192 continue;
5193
5194 p = path_join(arg_root, SYSTEM_SYSVINIT_PATH, name);
5195 if (!p)
5196 return log_oom();
5197
5198 p[strlen(p) - strlen(".service")] = 0;
5199 found_sysv = access(p, F_OK) >= 0;
5200 if (!found_sysv)
5201 continue;
5202
5203 /* Mark this entry, so that we don't try enabling it as native unit */
5204 args[f] = (char*) "";
5205
5206 log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name);
5207
5208 if (!isempty(arg_root))
5209 argv[c++] = q = strappend("--root=", arg_root);
5210
5211 argv[c++] = basename(p);
5212 argv[c++] =
5213 streq(verb, "enable") ? "on" :
5214 streq(verb, "disable") ? "off" : "--level=5";
5215 argv[c] = NULL;
5216
5217 l = strv_join((char**)argv, " ");
5218 if (!l)
5219 return log_oom();
5220
5221 log_info("Executing %s", l);
5222
5223 pid = fork();
5224 if (pid < 0)
5225 return log_error_errno(errno, "Failed to fork: %m");
5226 else if (pid == 0) {
5227 /* Child */
5228
5229 execv(argv[0], (char**) argv);
5230 _exit(EXIT_FAILURE);
5231 }
5232
5233 j = wait_for_terminate(pid, &status);
5234 if (j < 0) {
5235 log_error_errno(r, "Failed to wait for child: %m");
5236 return j;
5237 }
5238
5239 if (status.si_code == CLD_EXITED) {
5240 if (streq(verb, "is-enabled")) {
5241 if (status.si_status == 0) {
5242 if (!arg_quiet)
5243 puts("enabled");
5244 r = 1;
5245 } else {
5246 if (!arg_quiet)
5247 puts("disabled");
5248 }
5249
5250 } else if (status.si_status != 0)
5251 return -EINVAL;
5252 } else
5253 return -EPROTO;
5254 }
5255
5256 /* Drop all SysV units */
5257 for (f = 0, t = 0; args[f]; f++) {
5258
5259 if (isempty(args[f]))
5260 continue;
5261
5262 args[t++] = args[f];
5263 }
5264
5265 args[t] = NULL;
5266
5267 #endif
5268 return r;
5269 }
5270
5271 static int mangle_names(char **original_names, char ***mangled_names) {
5272 char **i, **l, **name;
5273
5274 l = new(char*, strv_length(original_names) + 1);
5275 if (!l)
5276 return log_oom();
5277
5278 i = l;
5279 STRV_FOREACH(name, original_names) {
5280
5281 /* When enabling units qualified path names are OK,
5282 * too, hence allow them explicitly. */
5283
5284 if (is_path(*name))
5285 *i = strdup(*name);
5286 else
5287 *i = unit_name_mangle(*name, MANGLE_NOGLOB);
5288
5289 if (!*i) {
5290 strv_free(l);
5291 return log_oom();
5292 }
5293
5294 i++;
5295 }
5296
5297 *i = NULL;
5298 *mangled_names = l;
5299
5300 return 0;
5301 }
5302
5303 static int enable_unit(sd_bus *bus, char **args) {
5304 _cleanup_strv_free_ char **names = NULL;
5305 const char *verb = args[0];
5306 UnitFileChange *changes = NULL;
5307 unsigned n_changes = 0;
5308 int carries_install_info = -1;
5309 int r;
5310
5311 if (!args[1])
5312 return 0;
5313
5314 r = mangle_names(args+1, &names);
5315 if (r < 0)
5316 return r;
5317
5318 r = enable_sysv_units(verb, names);
5319 if (r < 0)
5320 return r;
5321
5322 /* If the operation was fully executed by the SysV compat,
5323 * let's finish early */
5324 if (strv_isempty(names))
5325 return 0;
5326
5327 if (!bus || avoid_bus()) {
5328 if (streq(verb, "enable")) {
5329 r = unit_file_enable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5330 carries_install_info = r;
5331 } else if (streq(verb, "disable"))
5332 r = unit_file_disable(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
5333 else if (streq(verb, "reenable")) {
5334 r = unit_file_reenable(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5335 carries_install_info = r;
5336 } else if (streq(verb, "link"))
5337 r = unit_file_link(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5338 else if (streq(verb, "preset")) {
5339 r = unit_file_preset(arg_scope, arg_runtime, arg_root, names, arg_preset_mode, arg_force, &changes, &n_changes);
5340 carries_install_info = r;
5341 } else if (streq(verb, "mask"))
5342 r = unit_file_mask(arg_scope, arg_runtime, arg_root, names, arg_force, &changes, &n_changes);
5343 else if (streq(verb, "unmask"))
5344 r = unit_file_unmask(arg_scope, arg_runtime, arg_root, names, &changes, &n_changes);
5345 else
5346 assert_not_reached("Unknown verb");
5347
5348 if (r < 0) {
5349 log_error_errno(r, "Operation failed: %m");
5350 goto finish;
5351 }
5352
5353 if (!arg_quiet)
5354 dump_unit_file_changes(changes, n_changes);
5355
5356 r = 0;
5357 } else {
5358 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
5359 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5360 int expect_carries_install_info = false;
5361 bool send_force = true, send_preset_mode = false;
5362 const char *method;
5363
5364 if (streq(verb, "enable")) {
5365 method = "EnableUnitFiles";
5366 expect_carries_install_info = true;
5367 } else if (streq(verb, "disable")) {
5368 method = "DisableUnitFiles";
5369 send_force = false;
5370 } else if (streq(verb, "reenable")) {
5371 method = "ReenableUnitFiles";
5372 expect_carries_install_info = true;
5373 } else if (streq(verb, "link"))
5374 method = "LinkUnitFiles";
5375 else if (streq(verb, "preset")) {
5376
5377 if (arg_preset_mode != UNIT_FILE_PRESET_FULL) {
5378 method = "PresetUnitFilesWithMode";
5379 send_preset_mode = true;
5380 } else
5381 method = "PresetUnitFiles";
5382
5383 expect_carries_install_info = true;
5384 } else if (streq(verb, "mask"))
5385 method = "MaskUnitFiles";
5386 else if (streq(verb, "unmask")) {
5387 method = "UnmaskUnitFiles";
5388 send_force = false;
5389 } else
5390 assert_not_reached("Unknown verb");
5391
5392 r = sd_bus_message_new_method_call(
5393 bus,
5394 &m,
5395 "org.freedesktop.systemd1",
5396 "/org/freedesktop/systemd1",
5397 "org.freedesktop.systemd1.Manager",
5398 method);
5399 if (r < 0)
5400 return bus_log_create_error(r);
5401
5402 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
5403 if (r < 0)
5404 return bus_log_create_error(r);
5405
5406 r = sd_bus_message_append_strv(m, names);
5407 if (r < 0)
5408 return bus_log_create_error(r);
5409
5410 if (send_preset_mode) {
5411 r = sd_bus_message_append(m, "s", unit_file_preset_mode_to_string(arg_preset_mode));
5412 if (r < 0)
5413 return bus_log_create_error(r);
5414 }
5415
5416 r = sd_bus_message_append(m, "b", arg_runtime);
5417 if (r < 0)
5418 return bus_log_create_error(r);
5419
5420 if (send_force) {
5421 r = sd_bus_message_append(m, "b", arg_force);
5422 if (r < 0)
5423 return bus_log_create_error(r);
5424 }
5425
5426 r = sd_bus_call(bus, m, 0, &error, &reply);
5427 if (r < 0) {
5428 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
5429 return r;
5430 }
5431
5432 if (expect_carries_install_info) {
5433 r = sd_bus_message_read(reply, "b", &carries_install_info);
5434 if (r < 0)
5435 return bus_log_parse_error(r);
5436 }
5437
5438 r = deserialize_and_dump_unit_file_changes(reply);
5439 if (r < 0)
5440 return r;
5441
5442 /* Try to reload if enabled */
5443 if (!arg_no_reload)
5444 r = daemon_reload(bus, args);
5445 else
5446 r = 0;
5447 }
5448
5449 if (carries_install_info == 0)
5450 log_warning("The unit files have no [Install] section. They are not meant to be enabled\n"
5451 "using systemctl.\n"
5452 "Possible reasons for having this kind of units are:\n"
5453 "1) A unit may be statically enabled by being symlinked from another unit's\n"
5454 " .wants/ or .requires/ directory.\n"
5455 "2) A unit's purpose may be to act as a helper for some other unit which has\n"
5456 " a requirement dependency on it.\n"
5457 "3) A unit may be started when needed via activation (socket, path, timer,\n"
5458 " D-Bus, udev, scripted systemctl call, ...).\n");
5459
5460 finish:
5461 unit_file_changes_free(changes, n_changes);
5462
5463 return r;
5464 }
5465
5466 static int add_dependency(sd_bus *bus, char **args) {
5467 _cleanup_strv_free_ char **names = NULL;
5468 _cleanup_free_ char *target = NULL;
5469 const char *verb = args[0];
5470 UnitDependency dep;
5471 int r = 0;
5472
5473 if (!args[1])
5474 return 0;
5475
5476 target = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");
5477 if (!target)
5478 return log_oom();
5479
5480 r = mangle_names(args+2, &names);
5481 if (r < 0)
5482 return r;
5483
5484 if (streq(verb, "add-wants"))
5485 dep = UNIT_WANTS;
5486 else if (streq(verb, "add-requires"))
5487 dep = UNIT_REQUIRES;
5488 else
5489 assert_not_reached("Unknown verb");
5490
5491 if (!bus || avoid_bus()) {
5492 UnitFileChange *changes = NULL;
5493 unsigned n_changes = 0;
5494
5495 r = unit_file_add_dependency(arg_scope, arg_runtime, arg_root, names, target, dep, arg_force, &changes, &n_changes);
5496
5497 if (r < 0)
5498 return log_error_errno(r, "Can't add dependency: %m");
5499
5500 if (!arg_quiet)
5501 dump_unit_file_changes(changes, n_changes);
5502
5503 unit_file_changes_free(changes, n_changes);
5504
5505 } else {
5506 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL, *m = NULL;
5507 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5508
5509 r = sd_bus_message_new_method_call(
5510 bus,
5511 &m,
5512 "org.freedesktop.systemd1",
5513 "/org/freedesktop/systemd1",
5514 "org.freedesktop.systemd1.Manager",
5515 "AddDependencyUnitFiles");
5516 if (r < 0)
5517 return bus_log_create_error(r);
5518
5519 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
5520 if (r < 0)
5521 return bus_log_create_error(r);
5522
5523 r = sd_bus_message_append_strv(m, names);
5524 if (r < 0)
5525 return bus_log_create_error(r);
5526
5527 r = sd_bus_message_append(m, "ssbb", target, unit_dependency_to_string(dep), arg_runtime, arg_force);
5528 if (r < 0)
5529 return bus_log_create_error(r);
5530
5531 r = sd_bus_call(bus, m, 0, &error, &reply);
5532 if (r < 0) {
5533 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
5534 return r;
5535 }
5536
5537 r = deserialize_and_dump_unit_file_changes(reply);
5538 if (r < 0)
5539 return r;
5540
5541 if (!arg_no_reload)
5542 r = daemon_reload(bus, args);
5543 else
5544 r = 0;
5545 }
5546
5547 return r;
5548 }
5549
5550 static int preset_all(sd_bus *bus, char **args) {
5551 UnitFileChange *changes = NULL;
5552 unsigned n_changes = 0;
5553 int r;
5554
5555 if (!bus || avoid_bus()) {
5556
5557 r = unit_file_preset_all(arg_scope, arg_runtime, arg_root, arg_preset_mode, arg_force, &changes, &n_changes);
5558 if (r < 0) {
5559 log_error_errno(r, "Operation failed: %m");
5560 goto finish;
5561 }
5562
5563 if (!arg_quiet)
5564 dump_unit_file_changes(changes, n_changes);
5565
5566 r = 0;
5567
5568 } else {
5569 _cleanup_bus_message_unref_ sd_bus_message *m = NULL, *reply = NULL;
5570 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5571
5572 r = sd_bus_message_new_method_call(
5573 bus,
5574 &m,
5575 "org.freedesktop.systemd1",
5576 "/org/freedesktop/systemd1",
5577 "org.freedesktop.systemd1.Manager",
5578 "PresetAllUnitFiles");
5579 if (r < 0)
5580 return bus_log_create_error(r);
5581
5582 r = sd_bus_message_set_allow_interactive_authorization(m, arg_ask_password);
5583 if (r < 0)
5584 return bus_log_create_error(r);
5585
5586 r = sd_bus_message_append(
5587 m,
5588 "sbb",
5589 unit_file_preset_mode_to_string(arg_preset_mode),
5590 arg_runtime,
5591 arg_force);
5592 if (r < 0)
5593 return bus_log_create_error(r);
5594
5595 r = sd_bus_call(bus, m, 0, &error, &reply);
5596 if (r < 0) {
5597 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
5598 return r;
5599 }
5600
5601 r = deserialize_and_dump_unit_file_changes(reply);
5602 if (r < 0)
5603 return r;
5604
5605 if (!arg_no_reload)
5606 r = daemon_reload(bus, args);
5607 else
5608 r = 0;
5609 }
5610
5611 finish:
5612 unit_file_changes_free(changes, n_changes);
5613
5614 return r;
5615 }
5616
5617 static int unit_is_enabled(sd_bus *bus, char **args) {
5618
5619 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
5620 _cleanup_strv_free_ char **names = NULL;
5621 bool enabled;
5622 char **name;
5623 int r;
5624
5625 r = mangle_names(args+1, &names);
5626 if (r < 0)
5627 return r;
5628
5629 r = enable_sysv_units(args[0], names);
5630 if (r < 0)
5631 return r;
5632
5633 enabled = r > 0;
5634
5635 if (!bus || avoid_bus()) {
5636
5637 STRV_FOREACH(name, names) {
5638 UnitFileState state;
5639
5640 state = unit_file_get_state(arg_scope, arg_root, *name);
5641 if (state < 0)
5642 return log_error_errno(state, "Failed to get unit file state for %s: %m", *name);
5643
5644 if (state == UNIT_FILE_ENABLED ||
5645 state == UNIT_FILE_ENABLED_RUNTIME ||
5646 state == UNIT_FILE_STATIC ||
5647 state == UNIT_FILE_INDIRECT)
5648 enabled = true;
5649
5650 if (!arg_quiet)
5651 puts(unit_file_state_to_string(state));
5652 }
5653
5654 } else {
5655 STRV_FOREACH(name, names) {
5656 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
5657 const char *s;
5658
5659 r = sd_bus_call_method(
5660 bus,
5661 "org.freedesktop.systemd1",
5662 "/org/freedesktop/systemd1",
5663 "org.freedesktop.systemd1.Manager",
5664 "GetUnitFileState",
5665 &error,
5666 &reply,
5667 "s", *name);
5668 if (r < 0) {
5669 log_error("Failed to get unit file state for %s: %s", *name, bus_error_message(&error, r));
5670 return r;
5671 }
5672
5673 r = sd_bus_message_read(reply, "s", &s);
5674 if (r < 0)
5675 return bus_log_parse_error(r);
5676
5677 if (STR_IN_SET(s, "enabled", "enabled-runtime", "static", "indirect"))
5678 enabled = true;
5679
5680 if (!arg_quiet)
5681 puts(s);
5682 }
5683 }
5684
5685 return !enabled;
5686 }
5687
5688 static int is_system_running(sd_bus *bus, char **args) {
5689 _cleanup_free_ char *state = NULL;
5690 int r;
5691
5692 r = sd_bus_get_property_string(
5693 bus,
5694 "org.freedesktop.systemd1",
5695 "/org/freedesktop/systemd1",
5696 "org.freedesktop.systemd1.Manager",
5697 "SystemState",
5698 NULL,
5699 &state);
5700 if (r < 0) {
5701 if (!arg_quiet)
5702 puts("unknown");
5703 return 0;
5704 }
5705
5706 if (!arg_quiet)
5707 puts(state);
5708
5709 return streq(state, "running") ? EXIT_SUCCESS : EXIT_FAILURE;
5710 }
5711
5712 static int unit_file_find_path(LookupPaths *lp, const char *unit_name, char **unit_path) {
5713 char **p;
5714
5715 assert(lp);
5716 assert(unit_name);
5717 assert(unit_path);
5718
5719 STRV_FOREACH(p, lp->unit_path) {
5720 char *path;
5721
5722 path = path_join(arg_root, *p, unit_name);
5723 if (!path)
5724 return log_oom();
5725
5726 if (access(path, F_OK) == 0) {
5727 *unit_path = path;
5728 return 1;
5729 }
5730
5731 free(path);
5732 }
5733
5734 return 0;
5735 }
5736
5737 static int create_edit_temp_file(const char *new_path, const char *original_path, char **ret_tmp_fn) {
5738 _cleanup_close_ int fd = -1;
5739 int r;
5740 char *t;
5741
5742 assert(new_path);
5743 assert(original_path);
5744 assert(ret_tmp_fn);
5745
5746 t = tempfn_random(new_path);
5747 if (!t)
5748 return log_oom();
5749
5750 r = mkdir_parents(new_path, 0755);
5751 if (r < 0)
5752 return log_error_errno(r, "Failed to create directories for %s: %m", new_path);
5753
5754 r = copy_file(original_path, t, 0, 0644);
5755 if (r == -ENOENT) {
5756 r = touch(t);
5757 if (r < 0) {
5758 log_error_errno(r, "Failed to create temporary file %s: %m", t);
5759 free(t);
5760 return r;
5761 }
5762 } else if (r < 0) {
5763 log_error_errno(r, "Failed to copy %s to %s: %m", original_path, t);
5764 free(t);
5765 return r;
5766 }
5767
5768 *ret_tmp_fn = t;
5769
5770 return 0;
5771 }
5772
5773 static int get_drop_in_to_edit(const char *unit_name, const char *user_home, const char *user_runtime, char **ret_path) {
5774 char *tmp_new_path;
5775 char *tmp;
5776
5777 assert(unit_name);
5778 assert(ret_path);
5779
5780 switch (arg_scope) {
5781 case UNIT_FILE_SYSTEM:
5782 tmp = strappenda(arg_runtime ? "/run/systemd/system/" : SYSTEM_CONFIG_UNIT_PATH "/", unit_name, ".d/override.conf");
5783 break;
5784 case UNIT_FILE_GLOBAL:
5785 tmp = strappenda(arg_runtime ? "/run/systemd/user/" : USER_CONFIG_UNIT_PATH "/", unit_name, ".d/override.conf");
5786 break;
5787 case UNIT_FILE_USER:
5788 assert(user_home);
5789 assert(user_runtime);
5790
5791 tmp = strappenda(arg_runtime ? user_runtime : user_home, "/", unit_name, ".d/override.conf");
5792 break;
5793 default:
5794 assert_not_reached("Invalid scope");
5795 }
5796
5797 tmp_new_path = path_join(arg_root, tmp, NULL);
5798 if (!tmp_new_path)
5799 return log_oom();
5800
5801 *ret_path = tmp_new_path;
5802
5803 return 0;
5804 }
5805
5806 static int unit_file_create_drop_in(const char *unit_name, const char *user_home, const char *user_runtime, char **ret_new_path, char **ret_tmp_path) {
5807 char *tmp_new_path;
5808 char *tmp_tmp_path;
5809 int r;
5810
5811 assert(unit_name);
5812 assert(ret_new_path);
5813 assert(ret_tmp_path);
5814
5815 r = get_drop_in_to_edit(unit_name, user_home, user_runtime, &tmp_new_path);
5816 if (r < 0)
5817 return r;
5818
5819 r = create_edit_temp_file(tmp_new_path, tmp_new_path, &tmp_tmp_path);
5820 if (r < 0) {
5821 free(tmp_new_path);
5822 return r;
5823 }
5824
5825 *ret_new_path = tmp_new_path;
5826 *ret_tmp_path = tmp_tmp_path;
5827
5828 return 0;
5829 }
5830
5831 static bool unit_is_editable(const char *unit_name, const char *fragment_path, const char *user_home) {
5832 bool editable = true;
5833 const char *invalid_path;
5834
5835 assert(unit_name);
5836
5837 if (!arg_runtime)
5838 return true;
5839
5840 switch (arg_scope) {
5841 case UNIT_FILE_SYSTEM:
5842 if (path_startswith(fragment_path, "/etc/systemd/system")) {
5843 editable = false;
5844 invalid_path = "/etc/systemd/system";
5845 } else if (path_startswith(fragment_path, SYSTEM_CONFIG_UNIT_PATH)) {
5846 editable = false;
5847 invalid_path = SYSTEM_CONFIG_UNIT_PATH;
5848 }
5849 break;
5850 case UNIT_FILE_GLOBAL:
5851 if (path_startswith(fragment_path, "/etc/systemd/user")) {
5852 editable = false;
5853 invalid_path = "/etc/systemd/user";
5854 } else if (path_startswith(fragment_path, USER_CONFIG_UNIT_PATH)) {
5855 editable = false;
5856 invalid_path = USER_CONFIG_UNIT_PATH;
5857 }
5858 break;
5859 case UNIT_FILE_USER:
5860 assert(user_home);
5861
5862 if (path_startswith(fragment_path, "/etc/systemd/user")) {
5863 editable = false;
5864 invalid_path = "/etc/systemd/user";
5865 } else if (path_startswith(fragment_path, USER_CONFIG_UNIT_PATH)) {
5866 editable = false;
5867 invalid_path = USER_CONFIG_UNIT_PATH;
5868 } else if (path_startswith(fragment_path, user_home)) {
5869 editable = false;
5870 invalid_path = user_home;
5871 }
5872 break;
5873 default:
5874 assert_not_reached("Invalid scope");
5875 }
5876
5877 if (!editable)
5878 log_error("%s ignored: cannot temporarily edit units from %s", unit_name, invalid_path);
5879
5880 return editable;
5881 }
5882
5883 static int get_copy_to_edit(const char *unit_name, const char *fragment_path, const char *user_home, const char *user_runtime, char **ret_path) {
5884 char *tmp_new_path;
5885
5886 assert(unit_name);
5887 assert(ret_path);
5888
5889 if (!unit_is_editable(unit_name, fragment_path, user_home))
5890 return -EINVAL;
5891
5892 switch (arg_scope) {
5893 case UNIT_FILE_SYSTEM:
5894 tmp_new_path = path_join(arg_root, arg_runtime ? "/run/systemd/system/" : SYSTEM_CONFIG_UNIT_PATH, unit_name);
5895 break;
5896 case UNIT_FILE_GLOBAL:
5897 tmp_new_path = path_join(arg_root, arg_runtime ? "/run/systemd/user/" : USER_CONFIG_UNIT_PATH, unit_name);
5898 break;
5899 case UNIT_FILE_USER:
5900 assert(user_home);
5901 assert(user_runtime);
5902
5903 tmp_new_path = path_join(arg_root, arg_runtime ? user_runtime : user_home, unit_name);
5904 break;
5905 default:
5906 assert_not_reached("Invalid scope");
5907 }
5908 if (!tmp_new_path)
5909 return log_oom();
5910
5911 *ret_path = tmp_new_path;
5912
5913 return 0;
5914 }
5915
5916 static int unit_file_create_copy(const char *unit_name,
5917 const char *fragment_path,
5918 const char *user_home,
5919 const char *user_runtime,
5920 char **ret_new_path,
5921 char **ret_tmp_path) {
5922 char *tmp_new_path;
5923 char *tmp_tmp_path;
5924 int r;
5925
5926 assert(fragment_path);
5927 assert(unit_name);
5928 assert(ret_new_path);
5929 assert(ret_tmp_path);
5930
5931 r = get_copy_to_edit(unit_name, fragment_path, user_home, user_runtime, &tmp_new_path);
5932 if (r < 0)
5933 return r;
5934
5935 if (!path_equal(fragment_path, tmp_new_path) && access(tmp_new_path, F_OK) == 0) {
5936 char response;
5937
5938 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);
5939 if (r < 0) {
5940 free(tmp_new_path);
5941 return r;
5942 }
5943 if (response != 'y') {
5944 log_warning("%s ignored", unit_name);
5945 free(tmp_new_path);
5946 return -1;
5947 }
5948 }
5949
5950 r = create_edit_temp_file(tmp_new_path, fragment_path, &tmp_tmp_path);
5951 if (r < 0) {
5952 log_error_errno(r, "Failed to create temporary file for %s: %m", tmp_new_path);
5953 free(tmp_new_path);
5954 return r;
5955 }
5956
5957 *ret_new_path = tmp_new_path;
5958 *ret_tmp_path = tmp_tmp_path;
5959
5960 return 0;
5961 }
5962
5963 static int run_editor(char **paths) {
5964 pid_t pid;
5965 int r;
5966
5967 assert(paths);
5968
5969 pid = fork();
5970 if (pid < 0) {
5971 log_error_errno(errno, "Failed to fork: %m");
5972 return -errno;
5973 }
5974
5975 if (pid == 0) {
5976 const char **args;
5977 char **backup_editors = STRV_MAKE("nano", "vim", "vi");
5978 char *editor;
5979 char **tmp_path, **original_path, **p;
5980 unsigned i = 1;
5981 size_t argc;
5982
5983 argc = strv_length(paths)/2 + 1;
5984 args = newa(const char*, argc + 1);
5985
5986 args[0] = NULL;
5987 STRV_FOREACH_PAIR(original_path, tmp_path, paths) {
5988 args[i] = *tmp_path;
5989 i++;
5990 }
5991 args[argc] = NULL;
5992
5993 /* SYSTEMD_EDITOR takes precedence over EDITOR which takes precedence over VISUAL
5994 * If neither SYSTEMD_EDITOR nor EDITOR nor VISUAL are present,
5995 * we try to execute well known editors
5996 */
5997 editor = getenv("SYSTEMD_EDITOR");
5998 if (!editor)
5999 editor = getenv("EDITOR");
6000 if (!editor)
6001 editor = getenv("VISUAL");
6002
6003 if (!isempty(editor)) {
6004 args[0] = editor;
6005 execvp(editor, (char* const*) args);
6006 }
6007
6008 STRV_FOREACH(p, backup_editors) {
6009 args[0] = *p;
6010 execvp(*p, (char* const*) args);
6011 /* We do not fail if the editor doesn't exist
6012 * because we want to try each one of them before
6013 * failing.
6014 */
6015 if (errno != ENOENT) {
6016 log_error("Failed to execute %s: %m", editor);
6017 _exit(EXIT_FAILURE);
6018 }
6019 }
6020
6021 log_error("Cannot edit unit(s): No editor available. Please set either SYSTEMD_EDITOR or EDITOR or VISUAL environment variable");
6022 _exit(EXIT_FAILURE);
6023 }
6024
6025 r = wait_for_terminate_and_warn("editor", pid, true);
6026 if (r < 0)
6027 return log_error_errno(r, "Failed to wait for child: %m");
6028
6029 return r;
6030 }
6031
6032 static int find_paths_to_edit(sd_bus *bus, char **names, char ***paths) {
6033 _cleanup_free_ char *user_home = NULL;
6034 _cleanup_free_ char *user_runtime = NULL;
6035 char **name;
6036 int r;
6037
6038 assert(names);
6039 assert(paths);
6040
6041 if (arg_scope == UNIT_FILE_USER) {
6042 r = user_config_home(&user_home);
6043 if (r < 0)
6044 return log_oom();
6045 else if (r == 0) {
6046 log_error("Cannot edit units for the user instance: home directory unknown");
6047 return -1;
6048 }
6049
6050 r = user_runtime_dir(&user_runtime);
6051 if (r < 0)
6052 return log_oom();
6053 else if (r == 0) {
6054 log_error("Cannot edit units for the user instance: runtime directory unknown");
6055 return -1;
6056 }
6057 }
6058
6059 if (!bus || avoid_bus()) {
6060 _cleanup_lookup_paths_free_ LookupPaths lp = {};
6061
6062 /* If there is no bus, we try to find the units by testing each available directory
6063 * according to the scope.
6064 */
6065 r = lookup_paths_init(&lp,
6066 arg_scope == UNIT_FILE_SYSTEM ? SYSTEMD_SYSTEM : SYSTEMD_USER,
6067 arg_scope == UNIT_FILE_USER,
6068 arg_root,
6069 NULL, NULL, NULL);
6070 if (r < 0) {
6071 log_error_errno(r, "Failed get lookup paths: %m");
6072 return r;
6073 }
6074
6075 STRV_FOREACH(name, names) {
6076 _cleanup_free_ char *path = NULL;
6077 char *new_path, *tmp_path;
6078
6079 r = unit_file_find_path(&lp, *name, &path);
6080 if (r < 0)
6081 return r;
6082 if (r == 0) {
6083 log_warning("%s ignored: not found", *name);
6084 continue;
6085 }
6086
6087 if (arg_full)
6088 r = unit_file_create_copy(*name, path, user_home, user_runtime, &new_path, &tmp_path);
6089 else
6090 r = unit_file_create_drop_in(*name, user_home, user_runtime, &new_path, &tmp_path);
6091
6092 if (r < 0)
6093 continue;
6094
6095 r = strv_push(paths, new_path);
6096 if (r < 0)
6097 return log_oom();
6098
6099 r = strv_push(paths, tmp_path);
6100 if (r < 0)
6101 return log_oom();
6102 }
6103 } else {
6104 STRV_FOREACH(name, names) {
6105 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
6106 _cleanup_free_ char *fragment_path = NULL;
6107 _cleanup_free_ char *unit = NULL;
6108 char *new_path, *tmp_path;
6109
6110 unit = unit_dbus_path_from_name(*name);
6111 if (!unit)
6112 return log_oom();
6113
6114 if (need_daemon_reload(bus, *name) > 0) {
6115 log_warning("%s ignored: unit file changed on disk. Run 'systemctl%s daemon-reload'.",
6116 *name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
6117 continue;
6118 }
6119
6120 r = sd_bus_get_property_string(
6121 bus,
6122 "org.freedesktop.systemd1",
6123 unit,
6124 "org.freedesktop.systemd1.Unit",
6125 "FragmentPath",
6126 &error,
6127 &fragment_path);
6128 if (r < 0) {
6129 log_warning("Failed to get FragmentPath: %s", bus_error_message(&error, r));
6130 continue;
6131 }
6132
6133 if (isempty(fragment_path)) {
6134 log_warning("%s ignored: not found", *name);
6135 continue;
6136 }
6137
6138 if (arg_full)
6139 r = unit_file_create_copy(*name, fragment_path, user_home, user_runtime, &new_path, &tmp_path);
6140 else
6141 r = unit_file_create_drop_in(*name, user_home, user_runtime, &new_path, &tmp_path);
6142 if (r < 0)
6143 continue;
6144
6145 r = strv_push(paths, new_path);
6146 if (r < 0)
6147 return log_oom();
6148
6149 r = strv_push(paths, tmp_path);
6150 if (r < 0)
6151 return log_oom();
6152 }
6153 }
6154
6155 return 0;
6156 }
6157
6158 static int edit(sd_bus *bus, char **args) {
6159 _cleanup_strv_free_ char **names = NULL;
6160 _cleanup_strv_free_ char **paths = NULL;
6161 char **original, **tmp;
6162 int r;
6163
6164 assert(args);
6165
6166 if (!on_tty()) {
6167 log_error("Cannot edit units if we are not on a tty");
6168 return -EINVAL;
6169 }
6170
6171 if (arg_transport != BUS_TRANSPORT_LOCAL) {
6172 log_error("Cannot remotely edit units");
6173 return -EINVAL;
6174 }
6175
6176 r = expand_names(bus, args + 1, NULL, &names);
6177 if (r < 0)
6178 return log_error_errno(r, "Failed to expand names: %m");
6179
6180 if (!names) {
6181 log_error("No unit name found by expanding names");
6182 return -ENOENT;
6183 }
6184
6185 r = find_paths_to_edit(bus, names, &paths);
6186 if (r < 0)
6187 return r;
6188
6189 if (strv_isempty(paths)) {
6190 log_error("Cannot find any units to edit");
6191 return -ENOENT;
6192 }
6193
6194 r = run_editor(paths);
6195 if (r < 0)
6196 goto end;
6197
6198 STRV_FOREACH_PAIR(original, tmp, paths) {
6199 /* If the temporary file is empty we ignore it.
6200 * It's useful if the user wants to cancel its modification
6201 */
6202 if (null_or_empty_path(*tmp)) {
6203 log_warning("Edition of %s canceled: temporary file empty", *original);
6204 continue;
6205 }
6206 r = rename(*tmp, *original);
6207 if (r < 0) {
6208 r = log_error_errno(errno, "Failed to rename %s to %s: %m", *tmp, *original);
6209 goto end;
6210 }
6211 }
6212
6213 if (!arg_no_reload && bus && !avoid_bus())
6214 r = daemon_reload(bus, args);
6215
6216 end:
6217 STRV_FOREACH_PAIR(original, tmp, paths)
6218 unlink_noerrno(*tmp);
6219
6220 return r;
6221 }
6222
6223 static void systemctl_help(void) {
6224
6225 pager_open_if_enabled();
6226
6227 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
6228 "Query or send control commands to the systemd manager.\n\n"
6229 " -h --help Show this help\n"
6230 " --version Show package version\n"
6231 " --system Connect to system manager\n"
6232 " --user Connect to user service manager\n"
6233 " -H --host=[USER@]HOST\n"
6234 " Operate on remote host\n"
6235 " -M --machine=CONTAINER\n"
6236 " Operate on local container\n"
6237 " -t --type=TYPE List only units of a particular type\n"
6238 " --state=STATE List only units with particular LOAD or SUB or ACTIVE state\n"
6239 " -p --property=NAME Show only properties by this name\n"
6240 " -a --all Show all loaded units/properties, including dead/empty\n"
6241 " ones. To list all units installed on the system, use\n"
6242 " the 'list-unit-files' command instead.\n"
6243 " -l --full Don't ellipsize unit names on output\n"
6244 " -r --recursive Show unit list of host and local containers\n"
6245 " --reverse Show reverse dependencies with 'list-dependencies'\n"
6246 " --job-mode=MODE Specify how to deal with already queued jobs, when\n"
6247 " queueing a new job\n"
6248 " --show-types When showing sockets, explicitly show their type\n"
6249 " -i --ignore-inhibitors\n"
6250 " When shutting down or sleeping, ignore inhibitors\n"
6251 " --kill-who=WHO Who to send signal to\n"
6252 " -s --signal=SIGNAL Which signal to send\n"
6253 " -q --quiet Suppress output\n"
6254 " --no-block Do not wait until operation finished\n"
6255 " --no-wall Don't send wall message before halt/power-off/reboot\n"
6256 " --no-reload When enabling/disabling unit files, don't reload daemon\n"
6257 " configuration\n"
6258 " --no-legend Do not print a legend (column headers and hints)\n"
6259 " --no-pager Do not pipe output into a pager\n"
6260 " --no-ask-password\n"
6261 " Do not ask for system passwords\n"
6262 " --global Enable/disable unit files globally\n"
6263 " --runtime Enable unit files only temporarily until next reboot\n"
6264 " -f --force When enabling unit files, override existing symlinks\n"
6265 " When shutting down, execute action immediately\n"
6266 " --preset-mode= Specifies whether fully apply presets, or only enable,\n"
6267 " or only disable\n"
6268 " --root=PATH Enable unit files in the specified root directory\n"
6269 " -n --lines=INTEGER Number of journal entries to show\n"
6270 " -o --output=STRING Change journal output mode (short, short-monotonic,\n"
6271 " verbose, export, json, json-pretty, json-sse, cat)\n"
6272 " --plain Print unit dependencies as a list instead of a tree\n\n"
6273 "Unit Commands:\n"
6274 " list-units [PATTERN...] List loaded units\n"
6275 " list-sockets [PATTERN...] List loaded sockets ordered by address\n"
6276 " list-timers [PATTERN...] List loaded timers ordered by next elapse\n"
6277 " start NAME... Start (activate) one or more units\n"
6278 " stop NAME... Stop (deactivate) one or more units\n"
6279 " reload NAME... Reload one or more units\n"
6280 " restart NAME... Start or restart one or more units\n"
6281 " try-restart NAME... Restart one or more units if active\n"
6282 " reload-or-restart NAME... Reload one or more units if possible,\n"
6283 " otherwise start or restart\n"
6284 " reload-or-try-restart NAME... Reload one or more units if possible,\n"
6285 " otherwise restart if active\n"
6286 " isolate NAME Start one unit and stop all others\n"
6287 " kill NAME... Send signal to processes of a unit\n"
6288 " is-active PATTERN... Check whether units are active\n"
6289 " is-failed PATTERN... Check whether units are failed\n"
6290 " status [PATTERN...|PID...] Show runtime status of one or more units\n"
6291 " show [PATTERN...|JOB...] Show properties of one or more\n"
6292 " units/jobs or the manager\n"
6293 " cat PATTERN... Show files and drop-ins of one or more units\n"
6294 " set-property NAME ASSIGNMENT... Sets one or more properties of a unit\n"
6295 " help PATTERN...|PID... Show manual for one or more units\n"
6296 " reset-failed [PATTERN...] Reset failed state for all, one, or more\n"
6297 " units\n"
6298 " list-dependencies [NAME] Recursively show units which are required\n"
6299 " or wanted by this unit or by which this\n"
6300 " unit is required or wanted\n\n"
6301 "Unit File Commands:\n"
6302 " list-unit-files [PATTERN...] List installed unit files\n"
6303 " enable NAME... Enable one or more unit files\n"
6304 " disable NAME... Disable one or more unit files\n"
6305 " reenable NAME... Reenable one or more unit files\n"
6306 " preset NAME... Enable/disable one or more unit files\n"
6307 " based on preset configuration\n"
6308 " preset-all Enable/disable all unit files based on\n"
6309 " preset configuration\n"
6310 " is-enabled NAME... Check whether unit files are enabled\n\n"
6311 " mask NAME... Mask one or more units\n"
6312 " unmask NAME... Unmask one or more units\n"
6313 " link PATH... Link one or more units files into\n"
6314 " the search path\n"
6315 " add-wants TARGET NAME... Add 'Wants' dependency for the target\n"
6316 " on specified one or more units\n"
6317 " add-requires TARGET NAME... Add 'Requires' dependency for the target\n"
6318 " on specified one or more units\n"
6319 " get-default Get the name of the default target\n"
6320 " set-default NAME Set the default target\n"
6321 " edit NAME... Edit one or more unit files\n"
6322 "\n"
6323 "Machine Commands:\n"
6324 " list-machines [PATTERN...] List local containers and host\n\n"
6325 "Job Commands:\n"
6326 " list-jobs [PATTERN...] List jobs\n"
6327 " cancel [JOB...] Cancel all, one, or more jobs\n\n"
6328 "Snapshot Commands:\n"
6329 " snapshot [NAME] Create a snapshot\n"
6330 " delete NAME... Remove one or more snapshots\n\n"
6331 "Environment Commands:\n"
6332 " show-environment Dump environment\n"
6333 " set-environment NAME=VALUE... Set one or more environment variables\n"
6334 " unset-environment NAME... Unset one or more environment variables\n"
6335 " import-environment NAME... Import all, one or more environment variables\n\n"
6336 "Manager Lifecycle Commands:\n"
6337 " daemon-reload Reload systemd manager configuration\n"
6338 " daemon-reexec Reexecute systemd manager\n\n"
6339 "System Commands:\n"
6340 " is-system-running Check whether system is fully running\n"
6341 " default Enter system default mode\n"
6342 " rescue Enter system rescue mode\n"
6343 " emergency Enter system emergency mode\n"
6344 " halt Shut down and halt the system\n"
6345 " poweroff Shut down and power-off the system\n"
6346 " reboot [ARG] Shut down and reboot the system\n"
6347 " kexec Shut down and reboot the system with kexec\n"
6348 " exit Request user instance exit\n"
6349 " switch-root ROOT [INIT] Change to a different root file system\n"
6350 " suspend Suspend the system\n"
6351 " hibernate Hibernate the system\n"
6352 " hybrid-sleep Hibernate and suspend the system\n",
6353 program_invocation_short_name);
6354 }
6355
6356 static void halt_help(void) {
6357 printf("%s [OPTIONS...]%s\n\n"
6358 "%s the system.\n\n"
6359 " --help Show this help\n"
6360 " --halt Halt the machine\n"
6361 " -p --poweroff Switch off the machine\n"
6362 " --reboot Reboot the machine\n"
6363 " -f --force Force immediate halt/power-off/reboot\n"
6364 " -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
6365 " -d --no-wtmp Don't write wtmp record\n"
6366 " --no-wall Don't send wall message before halt/power-off/reboot\n",
6367 program_invocation_short_name,
6368 arg_action == ACTION_REBOOT ? " [ARG]" : "",
6369 arg_action == ACTION_REBOOT ? "Reboot" :
6370 arg_action == ACTION_POWEROFF ? "Power off" :
6371 "Halt");
6372 }
6373
6374 static void shutdown_help(void) {
6375 printf("%s [OPTIONS...] [TIME] [WALL...]\n\n"
6376 "Shut down the system.\n\n"
6377 " --help Show this help\n"
6378 " -H --halt Halt the machine\n"
6379 " -P --poweroff Power-off the machine\n"
6380 " -r --reboot Reboot the machine\n"
6381 " -h Equivalent to --poweroff, overridden by --halt\n"
6382 " -k Don't halt/power-off/reboot, just send warnings\n"
6383 " --no-wall Don't send wall message before halt/power-off/reboot\n"
6384 " -c Cancel a pending shutdown\n",
6385 program_invocation_short_name);
6386 }
6387
6388 static void telinit_help(void) {
6389 printf("%s [OPTIONS...] {COMMAND}\n\n"
6390 "Send control commands to the init daemon.\n\n"
6391 " --help Show this help\n"
6392 " --no-wall Don't send wall message before halt/power-off/reboot\n\n"
6393 "Commands:\n"
6394 " 0 Power-off the machine\n"
6395 " 6 Reboot the machine\n"
6396 " 2, 3, 4, 5 Start runlevelX.target unit\n"
6397 " 1, s, S Enter rescue mode\n"
6398 " q, Q Reload init daemon configuration\n"
6399 " u, U Reexecute init daemon\n",
6400 program_invocation_short_name);
6401 }
6402
6403 static void runlevel_help(void) {
6404 printf("%s [OPTIONS...]\n\n"
6405 "Prints the previous and current runlevel of the init system.\n\n"
6406 " --help Show this help\n",
6407 program_invocation_short_name);
6408 }
6409
6410 static void help_types(void) {
6411 int i;
6412 const char *t;
6413
6414 if (!arg_no_legend)
6415 puts("Available unit types:");
6416 for (i = 0; i < _UNIT_TYPE_MAX; i++) {
6417 t = unit_type_to_string(i);
6418 if (t)
6419 puts(t);
6420 }
6421 }
6422
6423 static int systemctl_parse_argv(int argc, char *argv[]) {
6424
6425 enum {
6426 ARG_FAIL = 0x100,
6427 ARG_REVERSE,
6428 ARG_AFTER,
6429 ARG_BEFORE,
6430 ARG_SHOW_TYPES,
6431 ARG_IRREVERSIBLE,
6432 ARG_IGNORE_DEPENDENCIES,
6433 ARG_VERSION,
6434 ARG_USER,
6435 ARG_SYSTEM,
6436 ARG_GLOBAL,
6437 ARG_NO_BLOCK,
6438 ARG_NO_LEGEND,
6439 ARG_NO_PAGER,
6440 ARG_NO_WALL,
6441 ARG_ROOT,
6442 ARG_NO_RELOAD,
6443 ARG_KILL_WHO,
6444 ARG_NO_ASK_PASSWORD,
6445 ARG_FAILED,
6446 ARG_RUNTIME,
6447 ARG_FORCE,
6448 ARG_PLAIN,
6449 ARG_STATE,
6450 ARG_JOB_MODE,
6451 ARG_PRESET_MODE,
6452 };
6453
6454 static const struct option options[] = {
6455 { "help", no_argument, NULL, 'h' },
6456 { "version", no_argument, NULL, ARG_VERSION },
6457 { "type", required_argument, NULL, 't' },
6458 { "property", required_argument, NULL, 'p' },
6459 { "all", no_argument, NULL, 'a' },
6460 { "reverse", no_argument, NULL, ARG_REVERSE },
6461 { "after", no_argument, NULL, ARG_AFTER },
6462 { "before", no_argument, NULL, ARG_BEFORE },
6463 { "show-types", no_argument, NULL, ARG_SHOW_TYPES },
6464 { "failed", no_argument, NULL, ARG_FAILED }, /* compatibility only */
6465 { "full", no_argument, NULL, 'l' },
6466 { "job-mode", required_argument, NULL, ARG_JOB_MODE },
6467 { "fail", no_argument, NULL, ARG_FAIL }, /* compatibility only */
6468 { "irreversible", no_argument, NULL, ARG_IRREVERSIBLE }, /* compatibility only */
6469 { "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES }, /* compatibility only */
6470 { "ignore-inhibitors", no_argument, NULL, 'i' },
6471 { "user", no_argument, NULL, ARG_USER },
6472 { "system", no_argument, NULL, ARG_SYSTEM },
6473 { "global", no_argument, NULL, ARG_GLOBAL },
6474 { "no-block", no_argument, NULL, ARG_NO_BLOCK },
6475 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
6476 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
6477 { "no-wall", no_argument, NULL, ARG_NO_WALL },
6478 { "quiet", no_argument, NULL, 'q' },
6479 { "root", required_argument, NULL, ARG_ROOT },
6480 { "force", no_argument, NULL, ARG_FORCE },
6481 { "no-reload", no_argument, NULL, ARG_NO_RELOAD },
6482 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
6483 { "signal", required_argument, NULL, 's' },
6484 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
6485 { "host", required_argument, NULL, 'H' },
6486 { "machine", required_argument, NULL, 'M' },
6487 { "runtime", no_argument, NULL, ARG_RUNTIME },
6488 { "lines", required_argument, NULL, 'n' },
6489 { "output", required_argument, NULL, 'o' },
6490 { "plain", no_argument, NULL, ARG_PLAIN },
6491 { "state", required_argument, NULL, ARG_STATE },
6492 { "recursive", no_argument, NULL, 'r' },
6493 { "preset-mode", required_argument, NULL, ARG_PRESET_MODE },
6494 {}
6495 };
6496
6497 int c;
6498
6499 assert(argc >= 0);
6500 assert(argv);
6501
6502 while ((c = getopt_long(argc, argv, "ht:p:alqfs:H:M:n:o:ir", options, NULL)) >= 0)
6503
6504 switch (c) {
6505
6506 case 'h':
6507 systemctl_help();
6508 return 0;
6509
6510 case ARG_VERSION:
6511 puts(PACKAGE_STRING);
6512 puts(SYSTEMD_FEATURES);
6513 return 0;
6514
6515 case 't': {
6516 const char *word, *state;
6517 size_t size;
6518
6519 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
6520 _cleanup_free_ char *type;
6521
6522 type = strndup(word, size);
6523 if (!type)
6524 return -ENOMEM;
6525
6526 if (streq(type, "help")) {
6527 help_types();
6528 return 0;
6529 }
6530
6531 if (unit_type_from_string(type) >= 0) {
6532 if (strv_push(&arg_types, type))
6533 return log_oom();
6534 type = NULL;
6535 continue;
6536 }
6537
6538 /* It's much nicer to use --state= for
6539 * load states, but let's support this
6540 * in --types= too for compatibility
6541 * with old versions */
6542 if (unit_load_state_from_string(optarg) >= 0) {
6543 if (strv_push(&arg_states, type) < 0)
6544 return log_oom();
6545 type = NULL;
6546 continue;
6547 }
6548
6549 log_error("Unknown unit type or load state '%s'.", type);
6550 log_info("Use -t help to see a list of allowed values.");
6551 return -EINVAL;
6552 }
6553
6554 break;
6555 }
6556
6557 case 'p': {
6558 /* Make sure that if the empty property list
6559 was specified, we won't show any properties. */
6560 if (isempty(optarg) && !arg_properties) {
6561 arg_properties = new0(char*, 1);
6562 if (!arg_properties)
6563 return log_oom();
6564 } else {
6565 const char *word, *state;
6566 size_t size;
6567
6568 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
6569 char *prop;
6570
6571 prop = strndup(word, size);
6572 if (!prop)
6573 return log_oom();
6574
6575 if (strv_consume(&arg_properties, prop) < 0)
6576 return log_oom();
6577 }
6578 }
6579
6580 /* If the user asked for a particular
6581 * property, show it to him, even if it is
6582 * empty. */
6583 arg_all = true;
6584
6585 break;
6586 }
6587
6588 case 'a':
6589 arg_all = true;
6590 break;
6591
6592 case ARG_REVERSE:
6593 arg_dependency = DEPENDENCY_REVERSE;
6594 break;
6595
6596 case ARG_AFTER:
6597 arg_dependency = DEPENDENCY_AFTER;
6598 break;
6599
6600 case ARG_BEFORE:
6601 arg_dependency = DEPENDENCY_BEFORE;
6602 break;
6603
6604 case ARG_SHOW_TYPES:
6605 arg_show_types = true;
6606 break;
6607
6608 case ARG_JOB_MODE:
6609 arg_job_mode = optarg;
6610 break;
6611
6612 case ARG_FAIL:
6613 arg_job_mode = "fail";
6614 break;
6615
6616 case ARG_IRREVERSIBLE:
6617 arg_job_mode = "replace-irreversibly";
6618 break;
6619
6620 case ARG_IGNORE_DEPENDENCIES:
6621 arg_job_mode = "ignore-dependencies";
6622 break;
6623
6624 case ARG_USER:
6625 arg_scope = UNIT_FILE_USER;
6626 break;
6627
6628 case ARG_SYSTEM:
6629 arg_scope = UNIT_FILE_SYSTEM;
6630 break;
6631
6632 case ARG_GLOBAL:
6633 arg_scope = UNIT_FILE_GLOBAL;
6634 break;
6635
6636 case ARG_NO_BLOCK:
6637 arg_no_block = true;
6638 break;
6639
6640 case ARG_NO_LEGEND:
6641 arg_no_legend = true;
6642 break;
6643
6644 case ARG_NO_PAGER:
6645 arg_no_pager = true;
6646 break;
6647
6648 case ARG_NO_WALL:
6649 arg_no_wall = true;
6650 break;
6651
6652 case ARG_ROOT:
6653 arg_root = optarg;
6654 break;
6655
6656 case 'l':
6657 arg_full = true;
6658 break;
6659
6660 case ARG_FAILED:
6661 if (strv_extend(&arg_states, "failed") < 0)
6662 return log_oom();
6663
6664 break;
6665
6666 case 'q':
6667 arg_quiet = true;
6668 break;
6669
6670 case ARG_FORCE:
6671 arg_force ++;
6672 break;
6673
6674 case 'f':
6675 arg_force ++;
6676 break;
6677
6678 case ARG_NO_RELOAD:
6679 arg_no_reload = true;
6680 break;
6681
6682 case ARG_KILL_WHO:
6683 arg_kill_who = optarg;
6684 break;
6685
6686 case 's':
6687 if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) {
6688 log_error("Failed to parse signal string %s.", optarg);
6689 return -EINVAL;
6690 }
6691 break;
6692
6693 case ARG_NO_ASK_PASSWORD:
6694 arg_ask_password = false;
6695 break;
6696
6697 case 'H':
6698 arg_transport = BUS_TRANSPORT_REMOTE;
6699 arg_host = optarg;
6700 break;
6701
6702 case 'M':
6703 arg_transport = BUS_TRANSPORT_CONTAINER;
6704 arg_host = optarg;
6705 break;
6706
6707 case ARG_RUNTIME:
6708 arg_runtime = true;
6709 break;
6710
6711 case 'n':
6712 if (safe_atou(optarg, &arg_lines) < 0) {
6713 log_error("Failed to parse lines '%s'", optarg);
6714 return -EINVAL;
6715 }
6716 break;
6717
6718 case 'o':
6719 arg_output = output_mode_from_string(optarg);
6720 if (arg_output < 0) {
6721 log_error("Unknown output '%s'.", optarg);
6722 return -EINVAL;
6723 }
6724 break;
6725
6726 case 'i':
6727 arg_ignore_inhibitors = true;
6728 break;
6729
6730 case ARG_PLAIN:
6731 arg_plain = true;
6732 break;
6733
6734 case ARG_STATE: {
6735 const char *word, *state;
6736 size_t size;
6737
6738 FOREACH_WORD_SEPARATOR(word, size, optarg, ",", state) {
6739 char *s;
6740
6741 s = strndup(word, size);
6742 if (!s)
6743 return log_oom();
6744
6745 if (strv_consume(&arg_states, s) < 0)
6746 return log_oom();
6747 }
6748 break;
6749 }
6750
6751 case 'r':
6752 if (geteuid() != 0) {
6753 log_error("--recursive requires root privileges.");
6754 return -EPERM;
6755 }
6756
6757 arg_recursive = true;
6758 break;
6759
6760 case ARG_PRESET_MODE:
6761
6762 arg_preset_mode = unit_file_preset_mode_from_string(optarg);
6763 if (arg_preset_mode < 0) {
6764 log_error("Failed to parse preset mode: %s.", optarg);
6765 return -EINVAL;
6766 }
6767
6768 break;
6769
6770 case '?':
6771 return -EINVAL;
6772
6773 default:
6774 assert_not_reached("Unhandled option");
6775 }
6776
6777 if (arg_transport != BUS_TRANSPORT_LOCAL && arg_scope != UNIT_FILE_SYSTEM) {
6778 log_error("Cannot access user instance remotely.");
6779 return -EINVAL;
6780 }
6781
6782 return 1;
6783 }
6784
6785 static int halt_parse_argv(int argc, char *argv[]) {
6786
6787 enum {
6788 ARG_HELP = 0x100,
6789 ARG_HALT,
6790 ARG_REBOOT,
6791 ARG_NO_WALL
6792 };
6793
6794 static const struct option options[] = {
6795 { "help", no_argument, NULL, ARG_HELP },
6796 { "halt", no_argument, NULL, ARG_HALT },
6797 { "poweroff", no_argument, NULL, 'p' },
6798 { "reboot", no_argument, NULL, ARG_REBOOT },
6799 { "force", no_argument, NULL, 'f' },
6800 { "wtmp-only", no_argument, NULL, 'w' },
6801 { "no-wtmp", no_argument, NULL, 'd' },
6802 { "no-wall", no_argument, NULL, ARG_NO_WALL },
6803 {}
6804 };
6805
6806 int c, r, runlevel;
6807
6808 assert(argc >= 0);
6809 assert(argv);
6810
6811 if (utmp_get_runlevel(&runlevel, NULL) >= 0)
6812 if (runlevel == '0' || runlevel == '6')
6813 arg_force = 2;
6814
6815 while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0)
6816 switch (c) {
6817
6818 case ARG_HELP:
6819 halt_help();
6820 return 0;
6821
6822 case ARG_HALT:
6823 arg_action = ACTION_HALT;
6824 break;
6825
6826 case 'p':
6827 if (arg_action != ACTION_REBOOT)
6828 arg_action = ACTION_POWEROFF;
6829 break;
6830
6831 case ARG_REBOOT:
6832 arg_action = ACTION_REBOOT;
6833 break;
6834
6835 case 'f':
6836 arg_force = 2;
6837 break;
6838
6839 case 'w':
6840 arg_dry = true;
6841 break;
6842
6843 case 'd':
6844 arg_no_wtmp = true;
6845 break;
6846
6847 case ARG_NO_WALL:
6848 arg_no_wall = true;
6849 break;
6850
6851 case 'i':
6852 case 'h':
6853 case 'n':
6854 /* Compatibility nops */
6855 break;
6856
6857 case '?':
6858 return -EINVAL;
6859
6860 default:
6861 assert_not_reached("Unhandled option");
6862 }
6863
6864 if (arg_action == ACTION_REBOOT && (argc == optind || argc == optind + 1)) {
6865 r = update_reboot_param_file(argc == optind + 1 ? argv[optind] : NULL);
6866 if (r < 0)
6867 return r;
6868 } else if (optind < argc) {
6869 log_error("Too many arguments.");
6870 return -EINVAL;
6871 }
6872
6873 return 1;
6874 }
6875
6876 static int parse_time_spec(const char *t, usec_t *_u) {
6877 assert(t);
6878 assert(_u);
6879
6880 if (streq(t, "now"))
6881 *_u = 0;
6882 else if (!strchr(t, ':')) {
6883 uint64_t u;
6884
6885 if (safe_atou64(t, &u) < 0)
6886 return -EINVAL;
6887
6888 *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u;
6889 } else {
6890 char *e = NULL;
6891 long hour, minute;
6892 struct tm tm = {};
6893 time_t s;
6894 usec_t n;
6895
6896 errno = 0;
6897 hour = strtol(t, &e, 10);
6898 if (errno > 0 || *e != ':' || hour < 0 || hour > 23)
6899 return -EINVAL;
6900
6901 minute = strtol(e+1, &e, 10);
6902 if (errno > 0 || *e != 0 || minute < 0 || minute > 59)
6903 return -EINVAL;
6904
6905 n = now(CLOCK_REALTIME);
6906 s = (time_t) (n / USEC_PER_SEC);
6907
6908 assert_se(localtime_r(&s, &tm));
6909
6910 tm.tm_hour = (int) hour;
6911 tm.tm_min = (int) minute;
6912 tm.tm_sec = 0;
6913
6914 assert_se(s = mktime(&tm));
6915
6916 *_u = (usec_t) s * USEC_PER_SEC;
6917
6918 while (*_u <= n)
6919 *_u += USEC_PER_DAY;
6920 }
6921
6922 return 0;
6923 }
6924
6925 static int shutdown_parse_argv(int argc, char *argv[]) {
6926
6927 enum {
6928 ARG_HELP = 0x100,
6929 ARG_NO_WALL
6930 };
6931
6932 static const struct option options[] = {
6933 { "help", no_argument, NULL, ARG_HELP },
6934 { "halt", no_argument, NULL, 'H' },
6935 { "poweroff", no_argument, NULL, 'P' },
6936 { "reboot", no_argument, NULL, 'r' },
6937 { "kexec", no_argument, NULL, 'K' }, /* not documented extension */
6938 { "no-wall", no_argument, NULL, ARG_NO_WALL },
6939 {}
6940 };
6941
6942 int c, r;
6943
6944 assert(argc >= 0);
6945 assert(argv);
6946
6947 while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0)
6948 switch (c) {
6949
6950 case ARG_HELP:
6951 shutdown_help();
6952 return 0;
6953
6954 case 'H':
6955 arg_action = ACTION_HALT;
6956 break;
6957
6958 case 'P':
6959 arg_action = ACTION_POWEROFF;
6960 break;
6961
6962 case 'r':
6963 if (kexec_loaded())
6964 arg_action = ACTION_KEXEC;
6965 else
6966 arg_action = ACTION_REBOOT;
6967 break;
6968
6969 case 'K':
6970 arg_action = ACTION_KEXEC;
6971 break;
6972
6973 case 'h':
6974 if (arg_action != ACTION_HALT)
6975 arg_action = ACTION_POWEROFF;
6976 break;
6977
6978 case 'k':
6979 arg_dry = true;
6980 break;
6981
6982 case ARG_NO_WALL:
6983 arg_no_wall = true;
6984 break;
6985
6986 case 't':
6987 case 'a':
6988 /* Compatibility nops */
6989 break;
6990
6991 case 'c':
6992 arg_action = ACTION_CANCEL_SHUTDOWN;
6993 break;
6994
6995 case '?':
6996 return -EINVAL;
6997
6998 default:
6999 assert_not_reached("Unhandled option");
7000 }
7001
7002 if (argc > optind && arg_action != ACTION_CANCEL_SHUTDOWN) {
7003 r = parse_time_spec(argv[optind], &arg_when);
7004 if (r < 0) {
7005 log_error("Failed to parse time specification: %s", argv[optind]);
7006 return r;
7007 }
7008 } else
7009 arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
7010
7011 if (argc > optind && arg_action == ACTION_CANCEL_SHUTDOWN)
7012 /* No time argument for shutdown cancel */
7013 arg_wall = argv + optind;
7014 else if (argc > optind + 1)
7015 /* We skip the time argument */
7016 arg_wall = argv + optind + 1;
7017
7018 optind = argc;
7019
7020 return 1;
7021 }
7022
7023 static int telinit_parse_argv(int argc, char *argv[]) {
7024
7025 enum {
7026 ARG_HELP = 0x100,
7027 ARG_NO_WALL
7028 };
7029
7030 static const struct option options[] = {
7031 { "help", no_argument, NULL, ARG_HELP },
7032 { "no-wall", no_argument, NULL, ARG_NO_WALL },
7033 {}
7034 };
7035
7036 static const struct {
7037 char from;
7038 enum action to;
7039 } table[] = {
7040 { '0', ACTION_POWEROFF },
7041 { '6', ACTION_REBOOT },
7042 { '1', ACTION_RESCUE },
7043 { '2', ACTION_RUNLEVEL2 },
7044 { '3', ACTION_RUNLEVEL3 },
7045 { '4', ACTION_RUNLEVEL4 },
7046 { '5', ACTION_RUNLEVEL5 },
7047 { 's', ACTION_RESCUE },
7048 { 'S', ACTION_RESCUE },
7049 { 'q', ACTION_RELOAD },
7050 { 'Q', ACTION_RELOAD },
7051 { 'u', ACTION_REEXEC },
7052 { 'U', ACTION_REEXEC }
7053 };
7054
7055 unsigned i;
7056 int c;
7057
7058 assert(argc >= 0);
7059 assert(argv);
7060
7061 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0)
7062 switch (c) {
7063
7064 case ARG_HELP:
7065 telinit_help();
7066 return 0;
7067
7068 case ARG_NO_WALL:
7069 arg_no_wall = true;
7070 break;
7071
7072 case '?':
7073 return -EINVAL;
7074
7075 default:
7076 assert_not_reached("Unhandled option");
7077 }
7078
7079 if (optind >= argc) {
7080 log_error("%s: required argument missing.",
7081 program_invocation_short_name);
7082 return -EINVAL;
7083 }
7084
7085 if (optind + 1 < argc) {
7086 log_error("Too many arguments.");
7087 return -EINVAL;
7088 }
7089
7090 if (strlen(argv[optind]) != 1) {
7091 log_error("Expected single character argument.");
7092 return -EINVAL;
7093 }
7094
7095 for (i = 0; i < ELEMENTSOF(table); i++)
7096 if (table[i].from == argv[optind][0])
7097 break;
7098
7099 if (i >= ELEMENTSOF(table)) {
7100 log_error("Unknown command '%s'.", argv[optind]);
7101 return -EINVAL;
7102 }
7103
7104 arg_action = table[i].to;
7105
7106 optind ++;
7107
7108 return 1;
7109 }
7110
7111 static int runlevel_parse_argv(int argc, char *argv[]) {
7112
7113 enum {
7114 ARG_HELP = 0x100,
7115 };
7116
7117 static const struct option options[] = {
7118 { "help", no_argument, NULL, ARG_HELP },
7119 {}
7120 };
7121
7122 int c;
7123
7124 assert(argc >= 0);
7125 assert(argv);
7126
7127 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0)
7128 switch (c) {
7129
7130 case ARG_HELP:
7131 runlevel_help();
7132 return 0;
7133
7134 case '?':
7135 return -EINVAL;
7136
7137 default:
7138 assert_not_reached("Unhandled option");
7139 }
7140
7141 if (optind < argc) {
7142 log_error("Too many arguments.");
7143 return -EINVAL;
7144 }
7145
7146 return 1;
7147 }
7148
7149 static int parse_argv(int argc, char *argv[]) {
7150 assert(argc >= 0);
7151 assert(argv);
7152
7153 if (program_invocation_short_name) {
7154
7155 if (strstr(program_invocation_short_name, "halt")) {
7156 arg_action = ACTION_HALT;
7157 return halt_parse_argv(argc, argv);
7158 } else if (strstr(program_invocation_short_name, "poweroff")) {
7159 arg_action = ACTION_POWEROFF;
7160 return halt_parse_argv(argc, argv);
7161 } else if (strstr(program_invocation_short_name, "reboot")) {
7162 if (kexec_loaded())
7163 arg_action = ACTION_KEXEC;
7164 else
7165 arg_action = ACTION_REBOOT;
7166 return halt_parse_argv(argc, argv);
7167 } else if (strstr(program_invocation_short_name, "shutdown")) {
7168 arg_action = ACTION_POWEROFF;
7169 return shutdown_parse_argv(argc, argv);
7170 } else if (strstr(program_invocation_short_name, "init")) {
7171
7172 if (sd_booted() > 0) {
7173 arg_action = _ACTION_INVALID;
7174 return telinit_parse_argv(argc, argv);
7175 } else {
7176 /* Hmm, so some other init system is
7177 * running, we need to forward this
7178 * request to it. For now we simply
7179 * guess that it is Upstart. */
7180
7181 execv(TELINIT, argv);
7182
7183 log_error("Couldn't find an alternative telinit implementation to spawn.");
7184 return -EIO;
7185 }
7186
7187 } else if (strstr(program_invocation_short_name, "runlevel")) {
7188 arg_action = ACTION_RUNLEVEL;
7189 return runlevel_parse_argv(argc, argv);
7190 }
7191 }
7192
7193 arg_action = ACTION_SYSTEMCTL;
7194 return systemctl_parse_argv(argc, argv);
7195 }
7196
7197 _pure_ static int action_to_runlevel(void) {
7198
7199 static const char table[_ACTION_MAX] = {
7200 [ACTION_HALT] = '0',
7201 [ACTION_POWEROFF] = '0',
7202 [ACTION_REBOOT] = '6',
7203 [ACTION_RUNLEVEL2] = '2',
7204 [ACTION_RUNLEVEL3] = '3',
7205 [ACTION_RUNLEVEL4] = '4',
7206 [ACTION_RUNLEVEL5] = '5',
7207 [ACTION_RESCUE] = '1'
7208 };
7209
7210 assert(arg_action < _ACTION_MAX);
7211
7212 return table[arg_action];
7213 }
7214
7215 static int talk_initctl(void) {
7216
7217 struct init_request request = {
7218 .magic = INIT_MAGIC,
7219 .sleeptime = 0,
7220 .cmd = INIT_CMD_RUNLVL
7221 };
7222
7223 _cleanup_close_ int fd = -1;
7224 char rl;
7225 int r;
7226
7227 rl = action_to_runlevel();
7228 if (!rl)
7229 return 0;
7230
7231 request.runlevel = rl;
7232
7233 fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY);
7234 if (fd < 0) {
7235 if (errno == ENOENT)
7236 return 0;
7237
7238 log_error_errno(errno, "Failed to open "INIT_FIFO": %m");
7239 return -errno;
7240 }
7241
7242 errno = 0;
7243 r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
7244 if (r) {
7245 log_error_errno(errno, "Failed to write to "INIT_FIFO": %m");
7246 return errno > 0 ? -errno : -EIO;
7247 }
7248
7249 return 1;
7250 }
7251
7252 static int systemctl_main(sd_bus *bus, int argc, char *argv[], int bus_error) {
7253
7254 static const struct {
7255 const char* verb;
7256 const enum {
7257 MORE,
7258 LESS,
7259 EQUAL
7260 } argc_cmp;
7261 const int argc;
7262 int (* const dispatch)(sd_bus *bus, char **args);
7263 const enum {
7264 NOBUS = 1,
7265 FORCE,
7266 } bus;
7267 } verbs[] = {
7268 { "list-units", MORE, 0, list_units },
7269 { "list-unit-files", MORE, 1, list_unit_files, NOBUS },
7270 { "list-sockets", MORE, 1, list_sockets },
7271 { "list-timers", MORE, 1, list_timers },
7272 { "list-jobs", MORE, 1, list_jobs },
7273 { "list-machines", MORE, 1, list_machines },
7274 { "clear-jobs", EQUAL, 1, daemon_reload },
7275 { "cancel", MORE, 2, cancel_job },
7276 { "start", MORE, 2, start_unit },
7277 { "stop", MORE, 2, start_unit },
7278 { "condstop", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
7279 { "reload", MORE, 2, start_unit },
7280 { "restart", MORE, 2, start_unit },
7281 { "try-restart", MORE, 2, start_unit },
7282 { "reload-or-restart", MORE, 2, start_unit },
7283 { "reload-or-try-restart", MORE, 2, start_unit },
7284 { "force-reload", MORE, 2, start_unit }, /* For compatibility with SysV */
7285 { "condreload", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
7286 { "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */
7287 { "isolate", EQUAL, 2, start_unit },
7288 { "kill", MORE, 2, kill_unit },
7289 { "is-active", MORE, 2, check_unit_active },
7290 { "check", MORE, 2, check_unit_active },
7291 { "is-failed", MORE, 2, check_unit_failed },
7292 { "show", MORE, 1, show },
7293 { "cat", MORE, 2, cat },
7294 { "status", MORE, 1, show },
7295 { "help", MORE, 2, show },
7296 { "snapshot", LESS, 2, snapshot },
7297 { "delete", MORE, 2, delete_snapshot },
7298 { "daemon-reload", EQUAL, 1, daemon_reload },
7299 { "daemon-reexec", EQUAL, 1, daemon_reload },
7300 { "show-environment", EQUAL, 1, show_environment },
7301 { "set-environment", MORE, 2, set_environment },
7302 { "unset-environment", MORE, 2, set_environment },
7303 { "import-environment", MORE, 1, import_environment},
7304 { "halt", EQUAL, 1, start_special, FORCE },
7305 { "poweroff", EQUAL, 1, start_special, FORCE },
7306 { "reboot", EQUAL, 1, start_special, FORCE },
7307 { "kexec", EQUAL, 1, start_special },
7308 { "suspend", EQUAL, 1, start_special },
7309 { "hibernate", EQUAL, 1, start_special },
7310 { "hybrid-sleep", EQUAL, 1, start_special },
7311 { "default", EQUAL, 1, start_special },
7312 { "rescue", EQUAL, 1, start_special },
7313 { "emergency", EQUAL, 1, start_special },
7314 { "exit", EQUAL, 1, start_special },
7315 { "reset-failed", MORE, 1, reset_failed },
7316 { "enable", MORE, 2, enable_unit, NOBUS },
7317 { "disable", MORE, 2, enable_unit, NOBUS },
7318 { "is-enabled", MORE, 2, unit_is_enabled, NOBUS },
7319 { "reenable", MORE, 2, enable_unit, NOBUS },
7320 { "preset", MORE, 2, enable_unit, NOBUS },
7321 { "preset-all", EQUAL, 1, preset_all, NOBUS },
7322 { "mask", MORE, 2, enable_unit, NOBUS },
7323 { "unmask", MORE, 2, enable_unit, NOBUS },
7324 { "link", MORE, 2, enable_unit, NOBUS },
7325 { "switch-root", MORE, 2, switch_root },
7326 { "list-dependencies", LESS, 2, list_dependencies },
7327 { "set-default", EQUAL, 2, set_default, NOBUS },
7328 { "get-default", EQUAL, 1, get_default, NOBUS },
7329 { "set-property", MORE, 3, set_property },
7330 { "is-system-running", EQUAL, 1, is_system_running },
7331 { "add-wants", MORE, 3, add_dependency, NOBUS },
7332 { "add-requires", MORE, 3, add_dependency, NOBUS },
7333 { "edit", MORE, 2, edit, NOBUS },
7334 {}
7335 }, *verb = verbs;
7336
7337 int left;
7338
7339 assert(argc >= 0);
7340 assert(argv);
7341
7342 left = argc - optind;
7343
7344 /* Special rule: no arguments (left == 0) means "list-units" */
7345 if (left > 0) {
7346 if (streq(argv[optind], "help") && !argv[optind+1]) {
7347 log_error("This command expects one or more "
7348 "unit names. Did you mean --help?");
7349 return -EINVAL;
7350 }
7351
7352 for (; verb->verb; verb++)
7353 if (streq(argv[optind], verb->verb))
7354 goto found;
7355
7356 log_error("Unknown operation '%s'.", argv[optind]);
7357 return -EINVAL;
7358 }
7359 found:
7360
7361 switch (verb->argc_cmp) {
7362
7363 case EQUAL:
7364 if (left != verb->argc) {
7365 log_error("Invalid number of arguments.");
7366 return -EINVAL;
7367 }
7368
7369 break;
7370
7371 case MORE:
7372 if (left < verb->argc) {
7373 log_error("Too few arguments.");
7374 return -EINVAL;
7375 }
7376
7377 break;
7378
7379 case LESS:
7380 if (left > verb->argc) {
7381 log_error("Too many arguments.");
7382 return -EINVAL;
7383 }
7384
7385 break;
7386
7387 default:
7388 assert_not_reached("Unknown comparison operator.");
7389 }
7390
7391 /* Require a bus connection for all operations but
7392 * enable/disable */
7393 if (verb->bus == NOBUS) {
7394 if (!bus && !avoid_bus()) {
7395 log_error_errno(bus_error, "Failed to get D-Bus connection: %m");
7396 return -EIO;
7397 }
7398
7399 } else {
7400 if (running_in_chroot() > 0) {
7401 log_info("Running in chroot, ignoring request.");
7402 return 0;
7403 }
7404
7405 if ((verb->bus != FORCE || arg_force <= 0) && !bus) {
7406 log_error_errno(bus_error, "Failed to get D-Bus connection: %m");
7407 return -EIO;
7408 }
7409 }
7410
7411 return verb->dispatch(bus, argv + optind);
7412 }
7413
7414 static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) {
7415
7416 struct sd_shutdown_command c = {
7417 .usec = t,
7418 .mode = mode,
7419 .dry_run = dry_run,
7420 .warn_wall = warn,
7421 };
7422
7423 union sockaddr_union sockaddr = {
7424 .un.sun_family = AF_UNIX,
7425 .un.sun_path = "/run/systemd/shutdownd",
7426 };
7427
7428 struct iovec iovec[2] = {{
7429 .iov_base = (char*) &c,
7430 .iov_len = offsetof(struct sd_shutdown_command, wall_message),
7431 }};
7432
7433 struct msghdr msghdr = {
7434 .msg_name = &sockaddr,
7435 .msg_namelen = offsetof(struct sockaddr_un, sun_path)
7436 + strlen("/run/systemd/shutdownd"),
7437 .msg_iov = iovec,
7438 .msg_iovlen = 1,
7439 };
7440
7441 _cleanup_close_ int fd;
7442
7443 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
7444 if (fd < 0)
7445 return -errno;
7446
7447 if (!isempty(message)) {
7448 iovec[1].iov_base = (char*) message;
7449 iovec[1].iov_len = strlen(message);
7450 msghdr.msg_iovlen++;
7451 }
7452
7453 if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0)
7454 return -errno;
7455
7456 return 0;
7457 }
7458
7459 static int reload_with_fallback(sd_bus *bus) {
7460
7461 if (bus) {
7462 /* First, try systemd via D-Bus. */
7463 if (daemon_reload(bus, NULL) >= 0)
7464 return 0;
7465 }
7466
7467 /* Nothing else worked, so let's try signals */
7468 assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC);
7469
7470 if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0)
7471 return log_error_errno(errno, "kill() failed: %m");
7472
7473 return 0;
7474 }
7475
7476 static int start_with_fallback(sd_bus *bus) {
7477
7478 if (bus) {
7479 /* First, try systemd via D-Bus. */
7480 if (start_unit(bus, NULL) >= 0)
7481 goto done;
7482 }
7483
7484 /* Nothing else worked, so let's try
7485 * /dev/initctl */
7486 if (talk_initctl() > 0)
7487 goto done;
7488
7489 log_error("Failed to talk to init daemon.");
7490 return -EIO;
7491
7492 done:
7493 warn_wall(arg_action);
7494 return 0;
7495 }
7496
7497 static int halt_now(enum action a) {
7498
7499 /* The kernel will automaticall flush ATA disks and suchlike
7500 * on reboot(), but the file systems need to be synce'd
7501 * explicitly in advance. */
7502 sync();
7503
7504 /* Make sure C-A-D is handled by the kernel from this point
7505 * on... */
7506 reboot(RB_ENABLE_CAD);
7507
7508 switch (a) {
7509
7510 case ACTION_HALT:
7511 log_info("Halting.");
7512 reboot(RB_HALT_SYSTEM);
7513 return -errno;
7514
7515 case ACTION_POWEROFF:
7516 log_info("Powering off.");
7517 reboot(RB_POWER_OFF);
7518 return -errno;
7519
7520 case ACTION_REBOOT: {
7521 _cleanup_free_ char *param = NULL;
7522
7523 if (read_one_line_file(REBOOT_PARAM_FILE, &param) >= 0) {
7524 log_info("Rebooting with argument '%s'.", param);
7525 syscall(SYS_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2,
7526 LINUX_REBOOT_CMD_RESTART2, param);
7527 }
7528
7529 log_info("Rebooting.");
7530 reboot(RB_AUTOBOOT);
7531 return -errno;
7532 }
7533
7534 default:
7535 assert_not_reached("Unknown action.");
7536 }
7537 }
7538
7539 static int halt_main(sd_bus *bus) {
7540 int r;
7541
7542 r = check_inhibitors(bus, arg_action);
7543 if (r < 0)
7544 return r;
7545
7546 if (geteuid() != 0) {
7547 /* Try logind if we are a normal user and no special
7548 * mode applies. Maybe PolicyKit allows us to shutdown
7549 * the machine. */
7550
7551 if (arg_when <= 0 &&
7552 !arg_dry &&
7553 arg_force <= 0 &&
7554 (arg_action == ACTION_POWEROFF ||
7555 arg_action == ACTION_REBOOT)) {
7556 r = reboot_with_logind(bus, arg_action);
7557 if (r >= 0)
7558 return r;
7559 }
7560
7561 log_error("Must be root.");
7562 return -EPERM;
7563 }
7564
7565 if (arg_when > 0) {
7566 _cleanup_free_ char *m;
7567
7568 m = strv_join(arg_wall, " ");
7569 if (!m)
7570 return log_oom();
7571
7572 r = send_shutdownd(arg_when,
7573 arg_action == ACTION_HALT ? 'H' :
7574 arg_action == ACTION_POWEROFF ? 'P' :
7575 arg_action == ACTION_KEXEC ? 'K' :
7576 'r',
7577 arg_dry,
7578 !arg_no_wall,
7579 m);
7580
7581 if (r < 0)
7582 log_warning_errno(r, "Failed to talk to shutdownd, proceeding with immediate shutdown: %m");
7583 else {
7584 char date[FORMAT_TIMESTAMP_MAX];
7585
7586 log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.",
7587 format_timestamp(date, sizeof(date), arg_when));
7588 return 0;
7589 }
7590 }
7591
7592 if (!arg_dry && !arg_force)
7593 return start_with_fallback(bus);
7594
7595 if (!arg_no_wtmp) {
7596 if (sd_booted() > 0)
7597 log_debug("Not writing utmp record, assuming that systemd-update-utmp is used.");
7598 else {
7599 r = utmp_put_shutdown();
7600 if (r < 0)
7601 log_warning_errno(r, "Failed to write utmp record: %m");
7602 }
7603 }
7604
7605 if (arg_dry)
7606 return 0;
7607
7608 r = halt_now(arg_action);
7609 log_error_errno(r, "Failed to reboot: %m");
7610
7611 return r;
7612 }
7613
7614 static int runlevel_main(void) {
7615 int r, runlevel, previous;
7616
7617 r = utmp_get_runlevel(&runlevel, &previous);
7618 if (r < 0) {
7619 puts("unknown");
7620 return r;
7621 }
7622
7623 printf("%c %c\n",
7624 previous <= 0 ? 'N' : previous,
7625 runlevel <= 0 ? 'N' : runlevel);
7626
7627 return 0;
7628 }
7629
7630 int main(int argc, char*argv[]) {
7631 _cleanup_bus_close_unref_ sd_bus *bus = NULL;
7632 int r;
7633
7634 setlocale(LC_ALL, "");
7635 log_parse_environment();
7636 log_open();
7637
7638 /* Explicitly not on_tty() to avoid setting cached value.
7639 * This becomes relevant for piping output which might be
7640 * ellipsized. */
7641 original_stdout_is_tty = isatty(STDOUT_FILENO);
7642
7643 r = parse_argv(argc, argv);
7644 if (r <= 0)
7645 goto finish;
7646
7647 /* /sbin/runlevel doesn't need to communicate via D-Bus, so
7648 * let's shortcut this */
7649 if (arg_action == ACTION_RUNLEVEL) {
7650 r = runlevel_main();
7651 goto finish;
7652 }
7653
7654 if (running_in_chroot() > 0 && arg_action != ACTION_SYSTEMCTL) {
7655 log_info("Running in chroot, ignoring request.");
7656 r = 0;
7657 goto finish;
7658 }
7659
7660 if (!avoid_bus())
7661 r = bus_open_transport_systemd(arg_transport, arg_host, arg_scope != UNIT_FILE_SYSTEM, &bus);
7662
7663 /* systemctl_main() will print an error message for the bus
7664 * connection, but only if it needs to */
7665
7666 switch (arg_action) {
7667
7668 case ACTION_SYSTEMCTL:
7669 r = systemctl_main(bus, argc, argv, r);
7670 break;
7671
7672 case ACTION_HALT:
7673 case ACTION_POWEROFF:
7674 case ACTION_REBOOT:
7675 case ACTION_KEXEC:
7676 r = halt_main(bus);
7677 break;
7678
7679 case ACTION_RUNLEVEL2:
7680 case ACTION_RUNLEVEL3:
7681 case ACTION_RUNLEVEL4:
7682 case ACTION_RUNLEVEL5:
7683 case ACTION_RESCUE:
7684 case ACTION_EMERGENCY:
7685 case ACTION_DEFAULT:
7686 r = start_with_fallback(bus);
7687 break;
7688
7689 case ACTION_RELOAD:
7690 case ACTION_REEXEC:
7691 r = reload_with_fallback(bus);
7692 break;
7693
7694 case ACTION_CANCEL_SHUTDOWN: {
7695 _cleanup_free_ char *m = NULL;
7696
7697 if (arg_wall) {
7698 m = strv_join(arg_wall, " ");
7699 if (!m) {
7700 r = log_oom();
7701 goto finish;
7702 }
7703 }
7704
7705 r = send_shutdownd(arg_when, SD_SHUTDOWN_NONE, false, !arg_no_wall, m);
7706 if (r < 0)
7707 log_warning_errno(r, "Failed to talk to shutdownd, shutdown hasn't been cancelled: %m");
7708 break;
7709 }
7710
7711 case ACTION_RUNLEVEL:
7712 case _ACTION_INVALID:
7713 default:
7714 assert_not_reached("Unknown action");
7715 }
7716
7717 finish:
7718 pager_close();
7719 ask_password_agent_close();
7720 polkit_agent_close();
7721
7722 strv_free(arg_types);
7723 strv_free(arg_states);
7724 strv_free(arg_properties);
7725
7726 return r < 0 ? EXIT_FAILURE : r;
7727 }
Unnamed repository; edit this file 'description' to name the repository.