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