chiark / gitweb /
fc872bda9655c1f617cd0497bd33059dc956c8f4
[elogind.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 "env-util.h"
71 #include "bus-util.h"
72 #include "bus-message.h"
73 #include "bus-error.h"
74 #include "bus-errors.h"
75
76 static char **arg_types = NULL;
77 static char **arg_states = NULL;
78 static char **arg_properties = NULL;
79 static bool arg_all = false;
80 static bool original_stdout_is_tty;
81 static enum dependency {
82         DEPENDENCY_FORWARD,
83         DEPENDENCY_REVERSE,
84         DEPENDENCY_AFTER,
85         DEPENDENCY_BEFORE,
86         _DEPENDENCY_MAX
87 } arg_dependency = DEPENDENCY_FORWARD;
88 static const char *arg_job_mode = "replace";
89 static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
90 static bool arg_no_block = false;
91 static bool arg_no_legend = false;
92 static bool arg_no_pager = false;
93 static bool arg_no_wtmp = false;
94 static bool arg_no_wall = false;
95 static bool arg_no_reload = false;
96 static bool arg_show_types = false;
97 static bool arg_ignore_inhibitors = false;
98 static bool arg_dry = false;
99 static bool arg_quiet = false;
100 static bool arg_full = false;
101 static int arg_force = 0;
102 static bool arg_ask_password = true;
103 static bool arg_runtime = false;
104 static char **arg_wall = NULL;
105 static const char *arg_kill_who = NULL;
106 static int arg_signal = SIGTERM;
107 static const char *arg_root = NULL;
108 static usec_t arg_when = 0;
109 static enum action {
110         _ACTION_INVALID,
111         ACTION_SYSTEMCTL,
112         ACTION_HALT,
113         ACTION_POWEROFF,
114         ACTION_REBOOT,
115         ACTION_KEXEC,
116         ACTION_EXIT,
117         ACTION_SUSPEND,
118         ACTION_HIBERNATE,
119         ACTION_HYBRID_SLEEP,
120         ACTION_RUNLEVEL2,
121         ACTION_RUNLEVEL3,
122         ACTION_RUNLEVEL4,
123         ACTION_RUNLEVEL5,
124         ACTION_RESCUE,
125         ACTION_EMERGENCY,
126         ACTION_DEFAULT,
127         ACTION_RELOAD,
128         ACTION_REEXEC,
129         ACTION_RUNLEVEL,
130         ACTION_CANCEL_SHUTDOWN,
131         _ACTION_MAX
132 } arg_action = ACTION_SYSTEMCTL;
133 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
134 static char *arg_host = NULL;
135 static unsigned arg_lines = 10;
136 static OutputMode arg_output = OUTPUT_SHORT;
137 static bool arg_plain = false;
138 static const struct {
139         const char *verb;
140         const char *method;
141 } unit_actions[] = {
142         { "start",                 "StartUnit" },
143         { "stop",                  "StopUnit" },
144         { "condstop",              "StopUnit" },
145         { "reload",                "ReloadUnit" },
146         { "restart",               "RestartUnit" },
147         { "try-restart",           "TryRestartUnit" },
148         { "condrestart",           "TryRestartUnit" },
149         { "reload-or-restart",     "ReloadOrRestartUnit" },
150         { "reload-or-try-restart", "ReloadOrTryRestartUnit" },
151         { "condreload",            "ReloadOrTryRestartUnit" },
152         { "force-reload",          "ReloadOrTryRestartUnit" }
153 };
154
155 static int daemon_reload(sd_bus *bus, char **args);
156 static int halt_now(enum action a);
157
158 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet);
159
160 static char** strv_skip_first(char **strv) {
161         if (strv_length(strv) > 0)
162                 return strv + 1;
163         return NULL;
164 }
165
166 static void pager_open_if_enabled(void) {
167
168         if (arg_no_pager)
169                 return;
170
171         pager_open(false);
172 }
173
174 static void ask_password_agent_open_if_enabled(void) {
175
176         /* Open the password agent as a child process if necessary */
177
178         if (!arg_ask_password)
179                 return;
180
181         if (arg_scope != UNIT_FILE_SYSTEM)
182                 return;
183
184         if (arg_transport != BUS_TRANSPORT_LOCAL)
185                 return;
186
187         ask_password_agent_open();
188 }
189
190 #ifdef HAVE_LOGIND
191 static void polkit_agent_open_if_enabled(void) {
192
193         /* Open the polkit agent as a child process if necessary */
194
195         if (!arg_ask_password)
196                 return;
197
198         if (arg_scope != UNIT_FILE_SYSTEM)
199                 return;
200
201         if (arg_transport != BUS_TRANSPORT_LOCAL)
202                 return;
203
204         polkit_agent_open();
205 }
206 #endif
207
208 static int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {
209         assert(error);
210
211         if (!sd_bus_error_is_set(error))
212                 return r;
213
214         if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||
215             sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
216             sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
217             sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
218                 return EXIT_NOPERMISSION;
219
220         if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
221                 return EXIT_NOTINSTALLED;
222
223         if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
224             sd_bus_error_has_name(error, SD_BUS_ERROR_NOT_SUPPORTED))
225                 return EXIT_NOTIMPLEMENTED;
226
227         if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
228                 return EXIT_NOTCONFIGURED;
229
230         if (r != 0)
231                 return r;
232
233         return EXIT_FAILURE;
234 }
235
236 static void warn_wall(enum action a) {
237         static const char *table[_ACTION_MAX] = {
238                 [ACTION_HALT]            = "The system is going down for system halt NOW!",
239                 [ACTION_REBOOT]          = "The system is going down for reboot NOW!",
240                 [ACTION_POWEROFF]        = "The system is going down for power-off NOW!",
241                 [ACTION_KEXEC]           = "The system is going down for kexec reboot NOW!",
242                 [ACTION_RESCUE]          = "The system is going down to rescue mode NOW!",
243                 [ACTION_EMERGENCY]       = "The system is going down to emergency mode NOW!",
244                 [ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"
245         };
246
247         if (arg_no_wall)
248                 return;
249
250         if (arg_wall) {
251                 _cleanup_free_ char *p;
252
253                 p = strv_join(arg_wall, " ");
254                 if (!p) {
255                         log_oom();
256                         return;
257                 }
258
259                 if (*p) {
260                         utmp_wall(p, NULL, NULL);
261                         return;
262                 }
263         }
264
265         if (!table[a])
266                 return;
267
268         utmp_wall(table[a], NULL, NULL);
269 }
270
271 static bool avoid_bus(void) {
272
273         if (running_in_chroot() > 0)
274                 return true;
275
276         if (sd_booted() <= 0)
277                 return true;
278
279         if (!isempty(arg_root))
280                 return true;
281
282         if (arg_scope == UNIT_FILE_GLOBAL)
283                 return true;
284
285         return false;
286 }
287
288 static int compare_unit_info(const void *a, const void *b) {
289         const UnitInfo *u = a, *v = b;
290         const char *d1, *d2;
291
292         d1 = strrchr(u->id, '.');
293         d2 = strrchr(v->id, '.');
294
295         if (d1 && d2) {
296                 int r;
297
298                 r = strcasecmp(d1, d2);
299                 if (r != 0)
300                         return r;
301         }
302
303         return strcasecmp(u->id, v->id);
304 }
305
306 static bool output_show_unit(const UnitInfo *u, char **patterns) {
307         const char *dot;
308
309         if (!strv_isempty(arg_states))
310                 return
311                         strv_contains(arg_states, u->load_state) ||
312                         strv_contains(arg_states, u->sub_state) ||
313                         strv_contains(arg_states, u->active_state);
314
315         if (!strv_isempty(patterns)) {
316                 char **pattern;
317
318                 STRV_FOREACH(pattern, patterns)
319                         if (fnmatch(*pattern, u->id, FNM_NOESCAPE) == 0)
320                                 return true;
321                 return false;
322         }
323
324         return (!arg_types || ((dot = strrchr(u->id, '.')) &&
325                                strv_find(arg_types, dot+1))) &&
326                 (arg_all || !(streq(u->active_state, "inactive")
327                               || u->following[0]) || u->job_id > 0);
328 }
329
330 static void output_units_list(const UnitInfo *unit_infos, unsigned c) {
331         unsigned id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
332         const UnitInfo *u;
333         unsigned n_shown = 0;
334         int job_count = 0;
335
336         max_id_len = strlen("UNIT");
337         load_len = strlen("LOAD");
338         active_len = strlen("ACTIVE");
339         sub_len = strlen("SUB");
340         job_len = strlen("JOB");
341         desc_len = 0;
342
343         for (u = unit_infos; u < unit_infos + c; u++) {
344                 max_id_len = MAX(max_id_len, strlen(u->id));
345                 load_len = MAX(load_len, strlen(u->load_state));
346                 active_len = MAX(active_len, strlen(u->active_state));
347                 sub_len = MAX(sub_len, strlen(u->sub_state));
348
349                 if (u->job_id != 0) {
350                         job_len = MAX(job_len, strlen(u->job_type));
351                         job_count++;
352                 }
353         }
354
355         if (!arg_full && original_stdout_is_tty) {
356                 unsigned basic_len;
357
358                 id_len = MIN(max_id_len, 25u);
359                 basic_len = 5 + id_len + 5 + active_len + sub_len;
360
361                 if (job_count)
362                         basic_len += job_len + 1;
363
364                 if (basic_len < (unsigned) columns()) {
365                         unsigned extra_len, incr;
366                         extra_len = columns() - basic_len;
367
368                         /* Either UNIT already got 25, or is fully satisfied.
369                          * Grant up to 25 to DESC now. */
370                         incr = MIN(extra_len, 25u);
371                         desc_len += incr;
372                         extra_len -= incr;
373
374                         /* split the remaining space between UNIT and DESC,
375                          * but do not give UNIT more than it needs. */
376                         if (extra_len > 0) {
377                                 incr = MIN(extra_len / 2, max_id_len - id_len);
378                                 id_len += incr;
379                                 desc_len += extra_len - incr;
380                         }
381                 }
382         } else
383                 id_len = max_id_len;
384
385         for (u = unit_infos; u < unit_infos + c; u++) {
386                 _cleanup_free_ char *e = NULL;
387                 const char *on_loaded, *off_loaded, *on = "";
388                 const char *on_active, *off_active, *off = "";
389
390                 if (!n_shown && !arg_no_legend) {
391                         printf("%-*s %-*s %-*s %-*s ",
392                                id_len, "UNIT",
393                                load_len, "LOAD",
394                                active_len, "ACTIVE",
395                                sub_len, "SUB");
396
397                         if (job_count)
398                                 printf("%-*s ", job_len, "JOB");
399
400                         if (!arg_full && arg_no_pager)
401                                 printf("%.*s\n", desc_len, "DESCRIPTION");
402                         else
403                                 printf("%s\n", "DESCRIPTION");
404                 }
405
406                 n_shown++;
407
408                 if (streq(u->load_state, "error") ||
409                     streq(u->load_state, "not-found")) {
410                         on_loaded = on = ansi_highlight_red();
411                         off_loaded = off = ansi_highlight_off();
412                 } else
413                         on_loaded = off_loaded = "";
414
415                 if (streq(u->active_state, "failed")) {
416                         on_active = on = ansi_highlight_red();
417                         off_active = off = ansi_highlight_off();
418                 } else
419                         on_active = off_active = "";
420
421                 e = arg_full ? NULL : ellipsize(u->id, id_len, 33);
422
423                 printf("%s%-*s%s %s%-*s%s %s%-*s %-*s%s %-*s",
424                        on, id_len, e ? e : u->id, off,
425                        on_loaded, load_len, u->load_state, off_loaded,
426                        on_active, active_len, u->active_state,
427                        sub_len, u->sub_state, off_active,
428                        job_count ? job_len + 1 : 0, u->job_id ? u->job_type : "");
429
430                 if (desc_len > 0)
431                         printf("%.*s\n", desc_len, u->description);
432                 else
433                         printf("%s\n", u->description);
434         }
435
436         if (!arg_no_legend) {
437                 const char *on, *off;
438
439                 if (n_shown) {
440                         puts("\nLOAD   = Reflects whether the unit definition was properly loaded.\n"
441                              "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
442                              "SUB    = The low-level unit activation state, values depend on unit type.");
443                         puts(job_count ? "JOB    = Pending job for the unit.\n" : "");
444                         on = ansi_highlight();
445                         off = ansi_highlight_off();
446                 } else {
447                         on = ansi_highlight_red();
448                         off = ansi_highlight_off();
449                 }
450
451                 if (arg_all)
452                         printf("%s%u loaded units listed.%s\n"
453                                "To show all installed unit files use 'systemctl list-unit-files'.\n",
454                                on, n_shown, off);
455                 else
456                         printf("%s%u loaded units listed.%s Pass --all to see loaded but inactive units, too.\n"
457                                "To show all installed unit files use 'systemctl list-unit-files'.\n",
458                                on, n_shown, off);
459         }
460 }
461
462 static int get_unit_list(
463                 sd_bus *bus,
464                 sd_bus_message **_reply,
465                 UnitInfo **_unit_infos,
466                 char **patterns) {
467
468         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
469         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
470         _cleanup_free_ UnitInfo *unit_infos = NULL;
471         size_t size = 0;
472         int r, c = 0;
473         UnitInfo u;
474
475         assert(bus);
476         assert(_reply);
477         assert(_unit_infos);
478
479         r = sd_bus_call_method(
480                         bus,
481                         "org.freedesktop.systemd1",
482                         "/org/freedesktop/systemd1",
483                         "org.freedesktop.systemd1.Manager",
484                         "ListUnits",
485                         &error,
486                         &reply,
487                         NULL);
488         if (r < 0) {
489                 log_error("Failed to list units: %s", bus_error_message(&error, r));
490                 return r;
491         }
492
493         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
494         if (r < 0)
495                 return bus_log_parse_error(r);
496
497         while ((r = bus_parse_unit_info(reply, &u)) > 0) {
498                 if (!output_show_unit(&u, patterns))
499                         continue;
500
501                 if (!GREEDY_REALLOC(unit_infos, size, c+1))
502                         return log_oom();
503
504                 unit_infos[c++] = u;
505         }
506         if (r < 0)
507                 return bus_log_parse_error(r);
508
509         r = sd_bus_message_exit_container(reply);
510         if (r < 0)
511                 return bus_log_parse_error(r);
512
513         *_reply = reply;
514         reply = NULL;
515
516         *_unit_infos = unit_infos;
517         unit_infos = NULL;
518
519         return c;
520 }
521
522 static int list_units(sd_bus *bus, char **args) {
523         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
524         _cleanup_free_ UnitInfo *unit_infos = NULL;
525         int r;
526
527         pager_open_if_enabled();
528
529         r = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
530         if (r < 0)
531                 return r;
532
533         qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);
534         output_units_list(unit_infos, r);
535
536         return 0;
537 }
538
539 static int get_triggered_units(
540                 sd_bus *bus,
541                 const char* path,
542                 char*** ret) {
543
544         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
545         int r;
546
547         r = sd_bus_get_property_strv(
548                         bus,
549                         "org.freedesktop.systemd1",
550                         path,
551                         "org.freedesktop.systemd1.Unit",
552                         "Triggers",
553                         &error,
554                         ret);
555
556         if (r < 0)
557                 log_error("Failed to determine triggers: %s", bus_error_message(&error, r));
558
559         return 0;
560 }
561
562 static int get_listening(
563                 sd_bus *bus,
564                 const char* unit_path,
565                 char*** listening) {
566
567         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
568         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
569         const char *type, *path;
570         int r, n = 0;
571
572         r = sd_bus_get_property(
573                         bus,
574                         "org.freedesktop.systemd1",
575                         unit_path,
576                         "org.freedesktop.systemd1.Socket",
577                         "Listen",
578                         &error,
579                         &reply,
580                         "a(ss)");
581         if (r < 0) {
582                 log_error("Failed to get list of listening sockets: %s", bus_error_message(&error, r));
583                 return r;
584         }
585
586         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
587         if (r < 0)
588                 return bus_log_parse_error(r);
589
590         while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
591
592                 r = strv_extend(listening, type);
593                 if (r < 0)
594                         return log_oom();
595
596                 r = strv_extend(listening, path);
597                 if (r < 0)
598                         return log_oom();
599
600                 n++;
601         }
602         if (r < 0)
603                 return bus_log_parse_error(r);
604
605         r = sd_bus_message_exit_container(reply);
606         if (r < 0)
607                 return bus_log_parse_error(r);
608
609         return n;
610 }
611
612 struct socket_info {
613         const char* id;
614
615         char* type;
616         char* path;
617
618         /* Note: triggered is a list here, although it almost certainly
619          * will always be one unit. Nevertheless, dbus API allows for multiple
620          * values, so let's follow that.*/
621         char** triggered;
622
623         /* The strv above is shared. free is set only in the first one. */
624         bool own_triggered;
625 };
626
627 static int socket_info_compare(const struct socket_info *a, const struct socket_info *b) {
628         int o;
629
630         assert(a);
631         assert(b);
632
633         o = strcmp(a->path, b->path);
634         if (o == 0)
635                 o = strcmp(a->type, b->type);
636
637         return o;
638 }
639
640 static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {
641         struct socket_info *s;
642         unsigned pathlen = strlen("LISTEN"),
643                 typelen = strlen("TYPE") * arg_show_types,
644                 socklen = strlen("UNIT"),
645                 servlen = strlen("ACTIVATES");
646         const char *on, *off;
647
648         for (s = socket_infos; s < socket_infos + cs; s++) {
649                 unsigned tmp = 0;
650                 char **a;
651
652                 socklen = MAX(socklen, strlen(s->id));
653                 if (arg_show_types)
654                         typelen = MAX(typelen, strlen(s->type));
655                 pathlen = MAX(pathlen, strlen(s->path));
656
657                 STRV_FOREACH(a, s->triggered)
658                         tmp += strlen(*a) + 2*(a != s->triggered);
659                 servlen = MAX(servlen, tmp);
660         }
661
662         if (cs) {
663                 if (!arg_no_legend)
664                         printf("%-*s %-*.*s%-*s %s\n",
665                                pathlen, "LISTEN",
666                                typelen + arg_show_types, typelen + arg_show_types, "TYPE ",
667                                socklen, "UNIT",
668                                "ACTIVATES");
669
670                 for (s = socket_infos; s < socket_infos + cs; s++) {
671                         char **a;
672
673                         if (arg_show_types)
674                                 printf("%-*s %-*s %-*s",
675                                        pathlen, s->path, typelen, s->type, socklen, s->id);
676                         else
677                                 printf("%-*s %-*s",
678                                        pathlen, s->path, socklen, s->id);
679                         STRV_FOREACH(a, s->triggered)
680                                 printf("%s %s",
681                                        a == s->triggered ? "" : ",", *a);
682                         printf("\n");
683                 }
684
685                 on = ansi_highlight();
686                 off = ansi_highlight_off();
687                 if (!arg_no_legend)
688                         printf("\n");
689         } else {
690                 on = ansi_highlight_red();
691                 off = ansi_highlight_off();
692         }
693
694         if (!arg_no_legend) {
695                 printf("%s%u sockets listed.%s\n", on, cs, off);
696                 if (!arg_all)
697                         printf("Pass --all to see loaded but inactive sockets, too.\n");
698         }
699
700         return 0;
701 }
702
703 static int list_sockets(sd_bus *bus, char **args) {
704         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
705         _cleanup_free_ UnitInfo *unit_infos = NULL;
706         _cleanup_free_ struct socket_info *socket_infos = NULL;
707         const UnitInfo *u;
708         struct socket_info *s;
709         unsigned cs = 0;
710         size_t size = 0;
711         int r = 0, n;
712
713         pager_open_if_enabled();
714
715         n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
716         if (n < 0)
717                 return n;
718
719         for (u = unit_infos; u < unit_infos + n; u++) {
720                 _cleanup_strv_free_ char **listening = NULL, **triggered = NULL;
721                 int i, c;
722
723                 if (!endswith(u->id, ".socket"))
724                         continue;
725
726                 r = get_triggered_units(bus, u->unit_path, &triggered);
727                 if (r < 0)
728                         goto cleanup;
729
730                 c = get_listening(bus, u->unit_path, &listening);
731                 if (c < 0) {
732                         r = c;
733                         goto cleanup;
734                 }
735
736                 if (!GREEDY_REALLOC(socket_infos, size, cs + c)) {
737                         r = log_oom();
738                         goto cleanup;
739                 }
740
741                 for (i = 0; i < c; i++)
742                         socket_infos[cs + i] = (struct socket_info) {
743                                 .id = u->id,
744                                 .type = listening[i*2],
745                                 .path = listening[i*2 + 1],
746                                 .triggered = triggered,
747                                 .own_triggered = i==0,
748                         };
749
750                 /* from this point on we will cleanup those socket_infos */
751                 cs += c;
752                 free(listening);
753                 listening = triggered = NULL; /* avoid cleanup */
754         }
755
756         qsort_safe(socket_infos, cs, sizeof(struct socket_info),
757                    (__compar_fn_t) socket_info_compare);
758
759         output_sockets_list(socket_infos, cs);
760
761  cleanup:
762         assert(cs == 0 || socket_infos);
763         for (s = socket_infos; s < socket_infos + cs; s++) {
764                 free(s->type);
765                 free(s->path);
766                 if (s->own_triggered)
767                         strv_free(s->triggered);
768         }
769
770         return r;
771 }
772
773 static int get_next_elapse(
774                 sd_bus *bus,
775                 const char *path,
776                 dual_timestamp *next) {
777
778         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
779         dual_timestamp t;
780         int r;
781
782         assert(bus);
783         assert(path);
784         assert(next);
785
786         r = sd_bus_get_property_trivial(
787                         bus,
788                         "org.freedesktop.systemd1",
789                         path,
790                         "org.freedesktop.systemd1.Timer",
791                         "NextElapseUSecMonotonic",
792                         &error,
793                         't',
794                         &t.monotonic);
795         if (r < 0) {
796                 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
797                 return r;
798         }
799
800         r = sd_bus_get_property_trivial(
801                         bus,
802                         "org.freedesktop.systemd1",
803                         path,
804                         "org.freedesktop.systemd1.Timer",
805                         "NextElapseUSecRealtime",
806                         &error,
807                         't',
808                         &t.realtime);
809         if (r < 0) {
810                 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
811                 return r;
812         }
813
814         *next = t;
815         return 0;
816 }
817
818 struct timer_info {
819         const char* id;
820         usec_t next_elapse;
821         char** triggered;
822 };
823
824 static int timer_info_compare(const struct timer_info *a, const struct timer_info *b) {
825         assert(a);
826         assert(b);
827
828         if (a->next_elapse < b->next_elapse)
829                 return -1;
830         if (a->next_elapse > b->next_elapse)
831                 return 1;
832
833         return strcmp(a->id, b->id);
834 }
835
836 static int output_timers_list(struct timer_info *timer_infos, unsigned n) {
837         struct timer_info *t;
838         unsigned
839                 nextlen = strlen("NEXT"),
840                 leftlen = strlen("LEFT"),
841                 unitlen = strlen("UNIT"),
842                 activatelen = strlen("ACTIVATES");
843
844         const char *on, *off;
845
846         assert(timer_infos || n == 0);
847
848         for (t = timer_infos; t < timer_infos + n; t++) {
849                 unsigned ul = 0;
850                 char **a;
851
852                 if (t->next_elapse > 0) {
853                         char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
854
855                         format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);
856                         nextlen = MAX(nextlen, strlen(tstamp) + 1);
857
858                         format_timestamp_relative(trel, sizeof(trel), t->next_elapse);
859                         leftlen = MAX(leftlen, strlen(trel));
860                 }
861
862                 unitlen = MAX(unitlen, strlen(t->id));
863
864                 STRV_FOREACH(a, t->triggered)
865                         ul += strlen(*a) + 2*(a != t->triggered);
866                 activatelen = MAX(activatelen, ul);
867         }
868
869         if (n > 0) {
870                 if (!arg_no_legend)
871                         printf("%-*s %-*s %-*s %s\n",
872                                nextlen, "NEXT",
873                                leftlen, "LEFT",
874                                unitlen, "UNIT",
875                                         "ACTIVATES");
876
877                 for (t = timer_infos; t < timer_infos + n; t++) {
878                         char tstamp[FORMAT_TIMESTAMP_MAX] = "n/a", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
879                         char **a;
880
881                         format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);
882                         format_timestamp_relative(trel, sizeof(trel), t->next_elapse);
883
884                         printf("%-*s %-*s %-*s",
885                                nextlen, tstamp, leftlen, trel, unitlen, t->id);
886
887                         STRV_FOREACH(a, t->triggered)
888                                 printf("%s %s",
889                                        a == t->triggered ? "" : ",", *a);
890                         printf("\n");
891                 }
892
893                 on = ansi_highlight();
894                 off = ansi_highlight_off();
895                 if (!arg_no_legend)
896                         printf("\n");
897         } else {
898                 on = ansi_highlight_red();
899                 off = ansi_highlight_off();
900         }
901
902         if (!arg_no_legend) {
903                 printf("%s%u timers listed.%s\n", on, n, off);
904                 if (!arg_all)
905                         printf("Pass --all to see loaded but inactive timers, too.\n");
906         }
907
908         return 0;
909 }
910
911 static usec_t calc_next_elapse(dual_timestamp *nw, dual_timestamp *next) {
912         usec_t next_elapse;
913
914         assert(nw);
915         assert(next);
916
917         if (next->monotonic != (usec_t) -1 && next->monotonic > 0) {
918                 usec_t converted;
919
920                 if (next->monotonic > nw->monotonic)
921                         converted = nw->realtime + (next->monotonic - nw->monotonic);
922                 else
923                         converted = nw->realtime - (nw->monotonic - next->monotonic);
924
925                 if (next->realtime != (usec_t) -1 && next->realtime > 0)
926                         next_elapse = MIN(converted, next->realtime);
927                 else
928                         next_elapse = converted;
929
930         } else
931                 next_elapse = next->realtime;
932
933         return next_elapse;
934 }
935
936 static int list_timers(sd_bus *bus, char **args) {
937
938         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
939         _cleanup_free_ struct timer_info *timer_infos = NULL;
940         _cleanup_free_ UnitInfo *unit_infos = NULL;
941         struct timer_info *t;
942         const UnitInfo *u;
943         size_t size = 0;
944         int n, c = 0;
945         dual_timestamp nw;
946         int r = 0;
947
948         pager_open_if_enabled();
949
950         n = get_unit_list(bus, &reply, &unit_infos, strv_skip_first(args));
951         if (n < 0)
952                 return n;
953
954         dual_timestamp_get(&nw);
955
956         for (u = unit_infos; u < unit_infos + n; u++) {
957                 _cleanup_strv_free_ char **triggered = NULL;
958                 dual_timestamp next = {};
959                 usec_t m;
960
961                 if (!endswith(u->id, ".timer"))
962                         continue;
963
964                 r = get_triggered_units(bus, u->unit_path, &triggered);
965                 if (r < 0)
966                         goto cleanup;
967
968                 r = get_next_elapse(bus, u->unit_path, &next);
969                 if (r < 0)
970                         goto cleanup;
971
972                 if (!GREEDY_REALLOC(timer_infos, size, c+1)) {
973                         r = log_oom();
974                         goto cleanup;
975                 }
976
977                 m = calc_next_elapse(&nw, &next);
978
979                 timer_infos[c++] = (struct timer_info) {
980                         .id = u->id,
981                         .next_elapse = m,
982                         .triggered = triggered,
983                 };
984
985                 triggered = NULL; /* avoid cleanup */
986         }
987
988         qsort_safe(timer_infos, c, sizeof(struct timer_info),
989                    (__compar_fn_t) timer_info_compare);
990
991         output_timers_list(timer_infos, c);
992
993  cleanup:
994         for (t = timer_infos; t < timer_infos + c; t++)
995                 strv_free(t->triggered);
996
997         return r;
998 }
999
1000 static int compare_unit_file_list(const void *a, const void *b) {
1001         const char *d1, *d2;
1002         const UnitFileList *u = a, *v = b;
1003
1004         d1 = strrchr(u->path, '.');
1005         d2 = strrchr(v->path, '.');
1006
1007         if (d1 && d2) {
1008                 int r;
1009
1010                 r = strcasecmp(d1, d2);
1011                 if (r != 0)
1012                         return r;
1013         }
1014
1015         return strcasecmp(basename(u->path), basename(v->path));
1016 }
1017
1018 static bool output_show_unit_file(const UnitFileList *u, char **patterns) {
1019         const char *dot;
1020
1021         if (!strv_isempty(patterns)) {
1022                 char **pattern;
1023
1024                 STRV_FOREACH(pattern, patterns)
1025                         if (fnmatch(*pattern, basename(u->path), FNM_NOESCAPE) == 0)
1026                                 return true;
1027                 return false;
1028         }
1029
1030         return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1));
1031 }
1032
1033 static void output_unit_file_list(const UnitFileList *units, unsigned c) {
1034         unsigned max_id_len, id_cols, state_cols;
1035         const UnitFileList *u;
1036
1037         max_id_len = strlen("UNIT FILE");
1038         state_cols = strlen("STATE");
1039
1040         for (u = units; u < units + c; u++) {
1041                 max_id_len = MAX(max_id_len, strlen(basename(u->path)));
1042                 state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));
1043         }
1044
1045         if (!arg_full) {
1046                 unsigned basic_cols;
1047
1048                 id_cols = MIN(max_id_len, 25u);
1049                 basic_cols = 1 + id_cols + state_cols;
1050                 if (basic_cols < (unsigned) columns())
1051                         id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);
1052         } else
1053                 id_cols = max_id_len;
1054
1055         if (!arg_no_legend)
1056                 printf("%-*s %-*s\n",
1057                        id_cols, "UNIT FILE",
1058                        state_cols, "STATE");
1059
1060         for (u = units; u < units + c; u++) {
1061                 _cleanup_free_ char *e = NULL;
1062                 const char *on, *off;
1063                 const char *id;
1064
1065                 if (u->state == UNIT_FILE_MASKED ||
1066                     u->state == UNIT_FILE_MASKED_RUNTIME ||
1067                     u->state == UNIT_FILE_DISABLED ||
1068                     u->state == UNIT_FILE_INVALID) {
1069                         on  = ansi_highlight_red();
1070                         off = ansi_highlight_off();
1071                 } else if (u->state == UNIT_FILE_ENABLED) {
1072                         on  = ansi_highlight_green();
1073                         off = ansi_highlight_off();
1074                 } else
1075                         on = off = "";
1076
1077                 id = basename(u->path);
1078
1079                 e = arg_full ? NULL : ellipsize(id, id_cols, 33);
1080
1081                 printf("%-*s %s%-*s%s\n",
1082                        id_cols, e ? e : id,
1083                        on, state_cols, unit_file_state_to_string(u->state), off);
1084         }
1085
1086         if (!arg_no_legend)
1087                 printf("\n%u unit files listed.\n", c);
1088 }
1089
1090 static int list_unit_files(sd_bus *bus, char **args) {
1091         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1092         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1093         _cleanup_free_ UnitFileList *units = NULL;
1094         UnitFileList *unit;
1095         size_t size = 0;
1096         unsigned c = 0;
1097         const char *state;
1098         char *path;
1099         int r;
1100
1101         pager_open_if_enabled();
1102
1103         if (avoid_bus()) {
1104                 Hashmap *h;
1105                 UnitFileList *u;
1106                 Iterator i;
1107                 unsigned n_units;
1108
1109                 h = hashmap_new(string_hash_func, string_compare_func);
1110                 if (!h)
1111                         return log_oom();
1112
1113                 r = unit_file_get_list(arg_scope, arg_root, h);
1114                 if (r < 0) {
1115                         unit_file_list_free(h);
1116                         log_error("Failed to get unit file list: %s", strerror(-r));
1117                         return r;
1118                 }
1119
1120                 n_units = hashmap_size(h);
1121                 units = new(UnitFileList, n_units);
1122                 if (!units) {
1123                         unit_file_list_free(h);
1124                         return log_oom();
1125                 }
1126
1127                 HASHMAP_FOREACH(u, h, i) {
1128                         if (!output_show_unit_file(u, strv_skip_first(args)))
1129                                 continue;
1130
1131                         units[c++] = *u;
1132                         free(u);
1133                 }
1134
1135                 assert(c <= n_units);
1136                 hashmap_free(h);
1137         } else {
1138                 r = sd_bus_call_method(
1139                                 bus,
1140                                 "org.freedesktop.systemd1",
1141                                 "/org/freedesktop/systemd1",
1142                                 "org.freedesktop.systemd1.Manager",
1143                                 "ListUnitFiles",
1144                                 &error,
1145                                 &reply,
1146                                 NULL);
1147                 if (r < 0) {
1148                         log_error("Failed to list unit files: %s", bus_error_message(&error, r));
1149                         return r;
1150                 }
1151
1152                 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
1153                 if (r < 0)
1154                         return bus_log_parse_error(r);
1155
1156                 while ((r = sd_bus_message_read(reply, "(ss)", &path, &state)) > 0) {
1157
1158                         if (!GREEDY_REALLOC(units, size, c + 1))
1159                                 return log_oom();
1160
1161                         units[c] = (struct UnitFileList) {
1162                                 path,
1163                                 unit_file_state_from_string(state)
1164                         };
1165
1166                         if (output_show_unit_file(&units[c], strv_skip_first(args)))
1167                                 c ++;
1168
1169                 }
1170                 if (r < 0)
1171                         return bus_log_parse_error(r);
1172
1173                 r = sd_bus_message_exit_container(reply);
1174                 if (r < 0)
1175                         return bus_log_parse_error(r);
1176         }
1177
1178         if (c > 0) {
1179                 qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);
1180                 output_unit_file_list(units, c);
1181         }
1182
1183         if (avoid_bus())
1184                 for (unit = units; unit < units + c; unit++)
1185                         free(unit->path);
1186
1187         return 0;
1188 }
1189
1190 static int list_dependencies_print(const char *name, int level, unsigned int branches, bool last) {
1191         _cleanup_free_ char *n = NULL;
1192         size_t max_len = MAX(columns(),20u);
1193         size_t len = 0;
1194         int i;
1195
1196         if (!arg_plain) {
1197
1198                 for (i = level - 1; i >= 0; i--) {
1199                         len += 2;
1200                         if (len > max_len - 3 && !arg_full) {
1201                                 printf("%s...\n",max_len % 2 ? "" : " ");
1202                                 return 0;
1203                         }
1204                         printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERT : DRAW_TREE_SPACE));
1205                 }
1206                 len += 2;
1207
1208                 if (len > max_len - 3 && !arg_full) {
1209                         printf("%s...\n",max_len % 2 ? "" : " ");
1210                         return 0;
1211                 }
1212
1213                 printf("%s", draw_special_char(last ? DRAW_TREE_RIGHT : DRAW_TREE_BRANCH));
1214         }
1215
1216         if (arg_full){
1217                 printf("%s\n", name);
1218                 return 0;
1219         }
1220
1221         n = ellipsize(name, max_len-len, 100);
1222         if (!n)
1223                 return log_oom();
1224
1225         printf("%s\n", n);
1226         return 0;
1227 }
1228
1229 static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
1230
1231         static const char *dependencies[_DEPENDENCY_MAX] = {
1232                 [DEPENDENCY_FORWARD] = "Requires\0"
1233                                        "RequiresOverridable\0"
1234                                        "Requisite\0"
1235                                        "RequisiteOverridable\0"
1236                                        "Wants\0",
1237                 [DEPENDENCY_REVERSE] = "RequiredBy\0"
1238                                        "RequiredByOverridable\0"
1239                                        "WantedBy\0"
1240                                        "PartOf\0",
1241                 [DEPENDENCY_AFTER]   = "After\0",
1242                 [DEPENDENCY_BEFORE]  = "Before\0",
1243         };
1244
1245         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1246         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1247         _cleanup_strv_free_ char **ret = NULL;
1248         _cleanup_free_ char *path = NULL;
1249         int r;
1250
1251         assert(bus);
1252         assert(name);
1253         assert(deps);
1254         assert_cc(ELEMENTSOF(dependencies) == _DEPENDENCY_MAX);
1255
1256         path = unit_dbus_path_from_name(name);
1257         if (!path)
1258                 return log_oom();
1259
1260         r = sd_bus_call_method(
1261                         bus,
1262                         "org.freedesktop.systemd1",
1263                         path,
1264                         "org.freedesktop.DBus.Properties",
1265                         "GetAll",
1266                         &error,
1267                         &reply,
1268                         "s", "org.freedesktop.systemd1.Unit");
1269         if (r < 0) {
1270                 log_error("Failed to get properties of %s: %s", name, bus_error_message(&error, r));
1271                 return r;
1272         }
1273
1274         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
1275         if (r < 0)
1276                 return bus_log_parse_error(r);
1277
1278         while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1279                 const char *prop;
1280
1281                 r = sd_bus_message_read(reply, "s", &prop);
1282                 if (r < 0)
1283                         return bus_log_parse_error(r);
1284
1285                 if (!nulstr_contains(dependencies[arg_dependency], prop)) {
1286                         r = sd_bus_message_skip(reply, "v");
1287                         if (r < 0)
1288                                 return bus_log_parse_error(r);
1289                 } else {
1290
1291                         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as");
1292                         if (r < 0)
1293                                 return bus_log_parse_error(r);
1294
1295                         r = bus_message_read_strv_extend(reply, &ret);
1296                         if (r < 0)
1297                                 return bus_log_parse_error(r);
1298
1299                         r = sd_bus_message_exit_container(reply);
1300                         if (r < 0)
1301                                 return bus_log_parse_error(r);
1302                 }
1303
1304                 r = sd_bus_message_exit_container(reply);
1305                 if (r < 0)
1306                         return bus_log_parse_error(r);
1307
1308         }
1309         if (r < 0)
1310                 return bus_log_parse_error(r);
1311
1312         r = sd_bus_message_exit_container(reply);
1313         if (r < 0)
1314                 return bus_log_parse_error(r);
1315
1316         *deps = ret;
1317         ret = NULL;
1318
1319         return 0;
1320 }
1321
1322 static int list_dependencies_compare(const void *_a, const void *_b) {
1323         const char **a = (const char**) _a, **b = (const char**) _b;
1324
1325         if (unit_name_to_type(*a) == UNIT_TARGET && unit_name_to_type(*b) != UNIT_TARGET)
1326                 return 1;
1327         if (unit_name_to_type(*a) != UNIT_TARGET && unit_name_to_type(*b) == UNIT_TARGET)
1328                 return -1;
1329
1330         return strcasecmp(*a, *b);
1331 }
1332
1333 static int list_dependencies_one(
1334                 sd_bus *bus,
1335                 const char *name,
1336                 int level,
1337                 char ***units,
1338                 unsigned int branches) {
1339
1340         _cleanup_strv_free_ char **deps = NULL;
1341         char **c;
1342         int r = 0;
1343
1344         assert(bus);
1345         assert(name);
1346         assert(units);
1347
1348         r = strv_extend(units, name);
1349         if (r < 0)
1350                 return log_oom();
1351
1352         r = list_dependencies_get_dependencies(bus, name, &deps);
1353         if (r < 0)
1354                 return r;
1355
1356         qsort_safe(deps, strv_length(deps), sizeof (char*), list_dependencies_compare);
1357
1358         STRV_FOREACH(c, deps) {
1359                 int state;
1360
1361                 if (strv_contains(*units, *c)) {
1362                         if (!arg_plain) {
1363                                 r = list_dependencies_print("...", level + 1, (branches << 1) | (c[1] == NULL ? 0 : 1), 1);
1364                                 if (r < 0)
1365                                         return r;
1366                         }
1367                         continue;
1368                 }
1369
1370                 state = check_one_unit(bus, *c, "activating\0active\0reloading\0", true);
1371                 if (state > 0)
1372                         printf("%s%s%s", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1373                 else
1374                         printf("%s%s%s", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1375
1376                 r = list_dependencies_print(*c, level, branches, c[1] == NULL);
1377                 if (r < 0)
1378                         return r;
1379
1380                 if (arg_all || unit_name_to_type(*c) == UNIT_TARGET) {
1381                        r = list_dependencies_one(bus, *c, level + 1, units, (branches << 1) | (c[1] == NULL ? 0 : 1));
1382                        if (r < 0)
1383                                return r;
1384                 }
1385         }
1386
1387         if (!arg_plain)
1388                 strv_remove(*units, name);
1389
1390         return 0;
1391 }
1392
1393 static int list_dependencies(sd_bus *bus, char **args) {
1394         _cleanup_strv_free_ char **units = NULL;
1395         _cleanup_free_ char *unit = NULL;
1396         const char *u;
1397
1398         assert(bus);
1399
1400         if (args[1]) {
1401                 unit = unit_name_mangle(args[1], MANGLE_NOGLOB);
1402                 if (!unit)
1403                         return log_oom();
1404                 u = unit;
1405         } else
1406                 u = SPECIAL_DEFAULT_TARGET;
1407
1408         pager_open_if_enabled();
1409
1410         puts(u);
1411
1412         return list_dependencies_one(bus, u, 0, &units, 0);
1413 }
1414
1415 struct machine_info {
1416         bool is_host;
1417         char *name;
1418         char *state;
1419         char *control_group;
1420         uint32_t n_failed_units;
1421         uint32_t n_jobs;
1422         usec_t timestamp;
1423 };
1424
1425 static const struct bus_properties_map machine_info_property_map[] = {
1426         { "SystemState",        "s", NULL, offsetof(struct machine_info, state)          },
1427         { "NJobs",              "u", NULL, offsetof(struct machine_info, n_jobs)         },
1428         { "NFailedUnits",       "u", NULL, offsetof(struct machine_info, n_failed_units) },
1429         { "ControlGroup",       "s", NULL, offsetof(struct machine_info, control_group)  },
1430         { "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp)      },
1431         {}
1432 };
1433
1434 static void free_machines_list(struct machine_info *machine_infos, int n) {
1435         int i;
1436
1437         if (!machine_infos)
1438                 return;
1439
1440         for (i = 0; i < n; i++) {
1441                 free(machine_infos[i].name);
1442                 free(machine_infos[i].state);
1443                 free(machine_infos[i].control_group);
1444         }
1445
1446         free(machine_infos);
1447 }
1448
1449 static int compare_machine_info(const void *a, const void *b) {
1450         const struct machine_info *u = a, *v = b;
1451
1452         if (u->is_host != v->is_host)
1453                 return u->is_host > v->is_host ? 1 : -1;
1454
1455         return strcasecmp(u->name, v->name);
1456 }
1457
1458 static int get_machine_properties(sd_bus *bus, struct machine_info *mi) {
1459         _cleanup_bus_unref_ sd_bus *container = NULL;
1460         int r;
1461
1462         assert(mi);
1463
1464         if (!bus) {
1465                 r = sd_bus_open_system_container(&container, mi->name);
1466                 if (r < 0)
1467                         return r;
1468
1469                 bus = container;
1470         }
1471
1472         r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, mi);
1473         if (r < 0)
1474                 return r;
1475
1476         return 0;
1477 }
1478
1479 static bool output_show_machine(const char *name, char **patterns) {
1480         char **i;
1481
1482         assert(name);
1483
1484         if (strv_isempty(patterns))
1485                 return true;
1486
1487         STRV_FOREACH(i, patterns)
1488                 if (fnmatch(*i, name, FNM_NOESCAPE) == 0)
1489                         return true;
1490
1491         return false;
1492 }
1493
1494 static int get_machine_list(
1495                 sd_bus *bus,
1496                 struct machine_info **_machine_infos,
1497                 char **patterns) {
1498
1499         struct machine_info *machine_infos = NULL;
1500         _cleanup_strv_free_ char **m = NULL;
1501         _cleanup_free_ char *hn = NULL;
1502         size_t sz = 0;
1503         char **i;
1504         int c = 0;
1505
1506         hn = gethostname_malloc();
1507         if (!hn)
1508                 return log_oom();
1509
1510         if (output_show_machine(hn, patterns)) {
1511                 if (!GREEDY_REALLOC0(machine_infos, sz, c+1))
1512                         return log_oom();
1513
1514                 machine_infos[c].is_host = true;
1515                 machine_infos[c].name = hn;
1516                 hn = NULL;
1517
1518                 get_machine_properties(bus, &machine_infos[c]);
1519                 c++;
1520         }
1521
1522         sd_get_machine_names(&m);
1523         STRV_FOREACH(i, m) {
1524                 _cleanup_free_ char *class = NULL;
1525
1526                 if (!output_show_machine(*i, patterns))
1527                         continue;
1528
1529                 sd_machine_get_class(*i, &class);
1530                 if (!streq_ptr(class, "container"))
1531                         continue;
1532
1533                 if (!GREEDY_REALLOC0(machine_infos, sz, c+1)) {
1534                         free_machines_list(machine_infos, c);
1535                         return log_oom();
1536                 }
1537
1538                 machine_infos[c].is_host = false;
1539                 machine_infos[c].name = strdup(*i);
1540                 if (!machine_infos[c].name) {
1541                         free_machines_list(machine_infos, c);
1542                         return log_oom();
1543                 }
1544
1545                 get_machine_properties(NULL, &machine_infos[c]);
1546                 c++;
1547         }
1548
1549         *_machine_infos = machine_infos;
1550         return c;
1551 }
1552
1553 static void output_machines_list(struct machine_info *machine_infos, unsigned n) {
1554         struct machine_info *m;
1555         unsigned
1556                 namelen = sizeof("NAME") - 1,
1557                 statelen = sizeof("STATE") - 1,
1558                 failedlen = sizeof("FAILED") - 1,
1559                 jobslen = sizeof("JOBS") - 1;
1560
1561         assert(machine_infos || n == 0);
1562
1563         for (m = machine_infos; m < machine_infos + n; m++) {
1564                 namelen = MAX(namelen, strlen(m->name) + (m->is_host ? sizeof(" (host)") - 1 : 0));
1565                 statelen = MAX(statelen, m->state ? strlen(m->state) : 0);
1566                 failedlen = MAX(failedlen, DECIMAL_STR_WIDTH(m->n_failed_units));
1567                 jobslen = MAX(jobslen, DECIMAL_STR_WIDTH(m->n_jobs));
1568         }
1569
1570         if (!arg_no_legend)
1571                 printf("%-*s %-*s %-*s %-*s\n",
1572                          namelen, "NAME",
1573                         statelen, "STATE",
1574                        failedlen, "FAILED",
1575                          jobslen, "JOBS");
1576
1577         for (m = machine_infos; m < machine_infos + n; m++) {
1578                 const char *on_state, *off_state, *on_failed, *off_failed;
1579
1580                 if (streq_ptr(m->state, "degraded")) {
1581                         on_state = ansi_highlight_red();
1582                         off_state = ansi_highlight_off();
1583                 } else if (!streq_ptr(m->state, "running")) {
1584                         on_state = ansi_highlight_yellow();
1585                         off_state = ansi_highlight_off();
1586                 } else
1587                         on_state = off_state = "";
1588
1589                 if (m->n_failed_units > 0) {
1590                         on_failed = ansi_highlight_red();
1591                         off_failed = ansi_highlight_off();
1592                 } else
1593                         on_failed = off_failed = "";
1594
1595                 if (m->is_host)
1596                         printf("%-*s (host) %s%-*s%s %s%*u%s %*u\n",
1597                                (int) (namelen - (sizeof(" (host)")-1)), strna(m->name),
1598                                on_state, statelen, strna(m->state), off_state,
1599                                on_failed, failedlen, m->n_failed_units, off_failed,
1600                                jobslen, m->n_jobs);
1601                 else
1602                         printf("%-*s %s%-*s%s %s%*u%s %*u\n",
1603                                namelen, strna(m->name),
1604                                on_state, statelen, strna(m->state), off_state,
1605                                on_failed, failedlen, m->n_failed_units, off_failed,
1606                                jobslen, m->n_jobs);
1607         }
1608
1609         if (!arg_no_legend)
1610                 printf("\n%u machines listed.\n", n);
1611 }
1612
1613 static int list_machines(sd_bus *bus, char **args) {
1614         struct machine_info *machine_infos = NULL;
1615         int r;
1616
1617         assert(bus);
1618
1619         if (geteuid() != 0) {
1620                 log_error("Must be root.");
1621                 return -EPERM;
1622         }
1623
1624         pager_open_if_enabled();
1625
1626         r = get_machine_list(bus, &machine_infos, strv_skip_first(args));
1627         if (r < 0)
1628                 return r;
1629
1630         qsort_safe(machine_infos, r, sizeof(struct machine_info), compare_machine_info);
1631         output_machines_list(machine_infos, r);
1632         free_machines_list(machine_infos, r);
1633
1634         return 0;
1635 }
1636
1637 static int get_default(sd_bus *bus, char **args) {
1638         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1639         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1640         _cleanup_free_ char *_path = NULL;
1641         const char *path;
1642         int r;
1643
1644         if (!bus || avoid_bus()) {
1645                 r = unit_file_get_default(arg_scope, arg_root, &_path);
1646                 if (r < 0) {
1647                         log_error("Failed to get default target: %s", strerror(-r));
1648                         return r;
1649                 }
1650                 path = _path;
1651
1652         } else {
1653                 r = sd_bus_call_method(
1654                                 bus,
1655                                 "org.freedesktop.systemd1",
1656                                 "/org/freedesktop/systemd1",
1657                                 "org.freedesktop.systemd1.Manager",
1658                                 "GetDefaultTarget",
1659                                 &error,
1660                                 &reply,
1661                                 NULL);
1662                 if (r < 0) {
1663                         log_error("Failed to get default target: %s", bus_error_message(&error, -r));
1664                         return r;
1665                 }
1666
1667                 r = sd_bus_message_read(reply, "s", &path);
1668                 if (r < 0)
1669                         return bus_log_parse_error(r);
1670         }
1671
1672         if (path)
1673                 printf("%s\n", path);
1674
1675         return 0;
1676 }
1677
1678 static void dump_unit_file_changes(const UnitFileChange *changes, unsigned n_changes) {
1679         unsigned i;
1680
1681         assert(changes || n_changes == 0);
1682
1683         for (i = 0; i < n_changes; i++) {
1684                 if (changes[i].type == UNIT_FILE_SYMLINK)
1685                         log_info("ln -s '%s' '%s'", changes[i].source, changes[i].path);
1686                 else
1687                         log_info("rm '%s'", changes[i].path);
1688         }
1689 }
1690
1691 static int deserialize_and_dump_unit_file_changes(sd_bus_message *m) {
1692         const char *type, *path, *source;
1693         int r;
1694
1695         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
1696         if (r < 0)
1697                 return bus_log_parse_error(r);
1698
1699         while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
1700                 if (!arg_quiet) {
1701                         if (streq(type, "symlink"))
1702                                 log_info("ln -s '%s' '%s'", source, path);
1703                         else
1704                                 log_info("rm '%s'", path);
1705                 }
1706         }
1707         if (r < 0)
1708                 return bus_log_parse_error(r);
1709
1710         r = sd_bus_message_exit_container(m);
1711         if (r < 0)
1712                 return bus_log_parse_error(r);
1713
1714         return 0;
1715 }
1716
1717 static int set_default(sd_bus *bus, char **args) {
1718         _cleanup_free_ char *unit = NULL;
1719         UnitFileChange *changes = NULL;
1720         unsigned n_changes = 0;
1721         int r;
1722
1723         unit = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");
1724         if (!unit)
1725                 return log_oom();
1726
1727         if (!bus || avoid_bus()) {
1728                 r = unit_file_set_default(arg_scope, arg_root, unit, arg_force, &changes, &n_changes);
1729                 if (r < 0) {
1730                         log_error("Failed to set default target: %s", strerror(-r));
1731                         return r;
1732                 }
1733
1734                 if (!arg_quiet)
1735                         dump_unit_file_changes(changes, n_changes);
1736
1737                 r = 0;
1738         } else {
1739                 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1740                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1741
1742                 r = sd_bus_call_method(
1743                                 bus,
1744                                 "org.freedesktop.systemd1",
1745                                 "/org/freedesktop/systemd1",
1746                                 "org.freedesktop.systemd1.Manager",
1747                                 "SetDefaultTarget",
1748                                 &error,
1749                                 &reply,
1750                                 "sb", unit, arg_force);
1751                 if (r < 0) {
1752                         log_error("Failed to set default target: %s", bus_error_message(&error, -r));
1753                         return r;
1754                 }
1755
1756                 r = deserialize_and_dump_unit_file_changes(reply);
1757                 if (r < 0)
1758                         return r;
1759
1760                 /* Try to reload if enabeld */
1761                 if (!arg_no_reload)
1762                         r = daemon_reload(bus, args);
1763                 else
1764                         r = 0;
1765         }
1766
1767         unit_file_changes_free(changes, n_changes);
1768
1769         return r;
1770 }
1771
1772 struct job_info {
1773         uint32_t id;
1774         const char *name, *type, *state;
1775 };
1776
1777 static void output_jobs_list(const struct job_info* jobs, unsigned n, bool skipped) {
1778         unsigned id_len, unit_len, type_len, state_len;
1779         const struct job_info *j;
1780         const char *on, *off;
1781         bool shorten = false;
1782
1783         assert(n == 0 || jobs);
1784
1785         if (n == 0) {
1786                 on = ansi_highlight_green();
1787                 off = ansi_highlight_off();
1788
1789                 printf("%sNo jobs %s.%s\n", on, skipped ? "listed" : "running", off);
1790                 return;
1791         }
1792
1793         pager_open_if_enabled();
1794
1795         id_len = strlen("JOB");
1796         unit_len = strlen("UNIT");
1797         type_len = strlen("TYPE");
1798         state_len = strlen("STATE");
1799
1800         for (j = jobs; j < jobs + n; j++) {
1801                 uint32_t id = j->id;
1802                 assert(j->name && j->type && j->state);
1803
1804                 id_len = MAX(id_len, DECIMAL_STR_WIDTH(id));
1805                 unit_len = MAX(unit_len, strlen(j->name));
1806                 type_len = MAX(type_len, strlen(j->type));
1807                 state_len = MAX(state_len, strlen(j->state));
1808         }
1809
1810         if (!arg_full && id_len + 1 + unit_len + type_len + 1 + state_len > columns()) {
1811                 unit_len = MAX(33u, columns() - id_len - type_len - state_len - 3);
1812                 shorten = true;
1813         }
1814
1815         if (!arg_no_legend)
1816                 printf("%*s %-*s %-*s %-*s\n",
1817                        id_len, "JOB",
1818                        unit_len, "UNIT",
1819                        type_len, "TYPE",
1820                        state_len, "STATE");
1821
1822         for (j = jobs; j < jobs + n; j++) {
1823                 _cleanup_free_ char *e = NULL;
1824
1825                 if (streq(j->state, "running")) {
1826                         on = ansi_highlight();
1827                         off = ansi_highlight_off();
1828                 } else
1829                         on = off = "";
1830
1831                 e = shorten ? ellipsize(j->name, unit_len, 33) : NULL;
1832                 printf("%*u %s%-*s%s %-*s %s%-*s%s\n",
1833                        id_len, j->id,
1834                        on, unit_len, e ? e : j->name, off,
1835                        type_len, j->type,
1836                        on, state_len, j->state, off);
1837         }
1838
1839         if (!arg_no_legend) {
1840                 on = ansi_highlight();
1841                 off = ansi_highlight_off();
1842
1843                 printf("\n%s%u jobs listed%s.\n", on, n, off);
1844         }
1845 }
1846
1847 static bool output_show_job(struct job_info *job, char **patterns) {
1848         char **pattern;
1849
1850         assert(job);
1851
1852         if (strv_isempty(patterns))
1853                 return true;
1854
1855         STRV_FOREACH(pattern, patterns)
1856                 if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)
1857                         return true;
1858         return false;
1859 }
1860
1861 static int list_jobs(sd_bus *bus, char **args) {
1862         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1863         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1864         const char *name, *type, *state, *job_path, *unit_path;
1865         _cleanup_free_ struct job_info *jobs = NULL;
1866         size_t size = 0;
1867         unsigned c = 0;
1868         uint32_t id;
1869         int r;
1870         bool skipped = false;
1871
1872         r = sd_bus_call_method(
1873                         bus,
1874                         "org.freedesktop.systemd1",
1875                         "/org/freedesktop/systemd1",
1876                         "org.freedesktop.systemd1.Manager",
1877                         "ListJobs",
1878                         &error,
1879                         &reply,
1880                         NULL);
1881         if (r < 0) {
1882                 log_error("Failed to list jobs: %s", bus_error_message(&error, r));
1883                 return r;
1884         }
1885
1886         r = sd_bus_message_enter_container(reply, 'a', "(usssoo)");
1887         if (r < 0)
1888                 return bus_log_parse_error(r);
1889
1890         while ((r = sd_bus_message_read(reply, "(usssoo)", &id, &name, &type, &state, &job_path, &unit_path)) > 0) {
1891                 struct job_info job = { id, name, type, state };
1892
1893                 if (!output_show_job(&job, strv_skip_first(args))) {
1894                         skipped = true;
1895                         continue;
1896                 }
1897
1898                 if (!GREEDY_REALLOC(jobs, size, c + 1))
1899                         return log_oom();
1900
1901                 jobs[c++] = job;
1902         }
1903         if (r < 0)
1904                 return bus_log_parse_error(r);
1905
1906         r = sd_bus_message_exit_container(reply);
1907         if (r < 0)
1908                 return bus_log_parse_error(r);
1909
1910         output_jobs_list(jobs, c, skipped);
1911         return r;
1912 }
1913
1914 static int cancel_job(sd_bus *bus, char **args) {
1915         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1916         char **name;
1917
1918         assert(args);
1919
1920         if (strv_length(args) <= 1)
1921                 return daemon_reload(bus, args);
1922
1923         STRV_FOREACH(name, args+1) {
1924                 uint32_t id;
1925                 int r;
1926
1927                 r = safe_atou32(*name, &id);
1928                 if (r < 0) {
1929                         log_error("Failed to parse job id \"%s\": %s", *name, strerror(-r));
1930                         return r;
1931                 }
1932
1933                 r = sd_bus_call_method(
1934                                 bus,
1935                                 "org.freedesktop.systemd1",
1936                                 "/org/freedesktop/systemd1",
1937                                 "org.freedesktop.systemd1.Manager",
1938                                 "CancelJob",
1939                                 &error,
1940                                 NULL,
1941                                 "u", id);
1942                 if (r < 0) {
1943                         log_error("Failed to cancel job %u: %s", (unsigned) id, bus_error_message(&error, r));
1944                         return r;
1945                 }
1946         }
1947
1948         return 0;
1949 }
1950
1951 static int need_daemon_reload(sd_bus *bus, const char *unit) {
1952         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1953         const char *path;
1954         int b, r;
1955
1956         /* We ignore all errors here, since this is used to show a
1957          * warning only */
1958
1959         /* We don't use unit_dbus_path_from_name() directly since we
1960          * don't want to load the unit if it isn't loaded. */
1961
1962         r = sd_bus_call_method(
1963                         bus,
1964                         "org.freedesktop.systemd1",
1965                         "/org/freedesktop/systemd1",
1966                         "org.freedesktop.systemd1.Manager",
1967                         "GetUnit",
1968                         NULL,
1969                         &reply,
1970                         "s", unit);
1971         if (r < 0)
1972                 return r;
1973
1974         r = sd_bus_message_read(reply, "o", &path);
1975         if (r < 0)
1976                 return r;
1977
1978         r = sd_bus_get_property_trivial(
1979                         bus,
1980                         "org.freedesktop.systemd1",
1981                         path,
1982                         "org.freedesktop.systemd1.Unit",
1983                         "NeedDaemonReload",
1984                         NULL,
1985                         'b', &b);
1986         if (r < 0)
1987                 return r;
1988
1989         return b;
1990 }
1991
1992 typedef struct WaitData {
1993         Set *set;
1994
1995         char *name;
1996         char *result;
1997 } WaitData;
1998
1999 static int wait_filter(sd_bus *bus, sd_bus_message *m, void *data, sd_bus_error *error) {
2000         WaitData *d = data;
2001
2002         assert(bus);
2003         assert(m);
2004         assert(d);
2005
2006         log_debug("Got D-Bus request: %s.%s() on %s",
2007                   sd_bus_message_get_interface(m),
2008                   sd_bus_message_get_member(m),
2009                   sd_bus_message_get_path(m));
2010
2011         if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
2012                 log_error("Warning! D-Bus connection terminated.");
2013                 sd_bus_close(bus);
2014         } else if (sd_bus_message_is_signal(m, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
2015                 uint32_t id;
2016                 const char *path, *result, *unit;
2017                 char *ret;
2018                 int r;
2019
2020                 r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
2021                 if (r >= 0) {
2022                         ret = set_remove(d->set, (char*) path);
2023                         if (!ret)
2024                                 return 0;
2025
2026                         free(ret);
2027
2028                         if (!isempty(result))
2029                                 d->result = strdup(result);
2030
2031                         if (!isempty(unit))
2032                                 d->name = strdup(unit);
2033
2034                         return 0;
2035                 }
2036 #ifndef NOLEGACY
2037                 r = sd_bus_message_read(m, "uos", &id, &path, &result);
2038                 if (r >= 0) {
2039                         ret = set_remove(d->set, (char*) path);
2040                         if (!ret)
2041                                 return 0;
2042
2043                         free(ret);
2044
2045                         if (*result)
2046                                 d->result = strdup(result);
2047
2048                         return 0;
2049                 }
2050 #endif
2051
2052                 bus_log_parse_error(r);
2053         }
2054
2055         return 0;
2056 }
2057
2058 static int enable_wait_for_jobs(sd_bus *bus) {
2059         int r;
2060
2061         assert(bus);
2062
2063         r = sd_bus_add_match(
2064                         bus,
2065                         "type='signal',"
2066                         "sender='org.freedesktop.systemd1',"
2067                         "interface='org.freedesktop.systemd1.Manager',"
2068                         "member='JobRemoved',"
2069                         "path='/org/freedesktop/systemd1'",
2070                         NULL, NULL);
2071         if (r < 0) {
2072                 log_error("Failed to add match");
2073                 return -EIO;
2074         }
2075
2076         /* This is slightly dirty, since we don't undo the match registrations. */
2077         return 0;
2078 }
2079
2080 static int bus_process_wait(sd_bus *bus) {
2081         int r;
2082
2083         for (;;) {
2084                 r = sd_bus_process(bus, NULL);
2085                 if (r < 0)
2086                         return r;
2087                 if (r > 0)
2088                         return 0;
2089                 r = sd_bus_wait(bus, (uint64_t) -1);
2090                 if (r < 0)
2091                         return r;
2092         }
2093 }
2094
2095 static int check_wait_response(WaitData *d) {
2096         int r = 0;
2097
2098         assert(d->result);
2099
2100         if (!arg_quiet) {
2101                 if (streq(d->result, "timeout"))
2102                         log_error("Job for %s timed out.", strna(d->name));
2103                 else if (streq(d->result, "canceled"))
2104                         log_error("Job for %s canceled.", strna(d->name));
2105                 else if (streq(d->result, "dependency"))
2106                         log_error("A dependency job for %s failed. See 'journalctl -xn' for details.", strna(d->name));
2107                 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2108                         log_error("Job for %s failed. See 'systemctl status %s' and 'journalctl -xn' for details.", strna(d->name), strna(d->name));
2109         }
2110
2111         if (streq(d->result, "timeout"))
2112                 r = -ETIME;
2113         else if (streq(d->result, "canceled"))
2114                 r = -ECANCELED;
2115         else if (streq(d->result, "dependency"))
2116                 r = -EIO;
2117         else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2118                 r = -EIO;
2119
2120         return r;
2121 }
2122
2123 static int wait_for_jobs(sd_bus *bus, Set *s) {
2124         WaitData d = { .set = s };
2125         int r = 0, q;
2126
2127         assert(bus);
2128         assert(s);
2129
2130         q = sd_bus_add_filter(bus, wait_filter, &d);
2131         if (q < 0)
2132                 return log_oom();
2133
2134         while (!set_isempty(s)) {
2135                 q = bus_process_wait(bus);
2136                 if (q < 0) {
2137                         log_error("Failed to wait for response: %s", strerror(-r));
2138                         return q;
2139                 }
2140
2141                 if (d.result) {
2142                         q = check_wait_response(&d);
2143                         /* Return the first error as it is most likely to be
2144                          * meaningful. */
2145                         if (q < 0 && r == 0)
2146                                 r = q;
2147                         log_debug("Got result %s/%s for job %s",
2148                                   strna(d.result), strerror(-q), strna(d.name));
2149                 }
2150
2151                 free(d.name);
2152                 d.name = NULL;
2153
2154                 free(d.result);
2155                 d.result = NULL;
2156         }
2157
2158         q = sd_bus_remove_filter(bus, wait_filter, &d);
2159         if (q < 0 && r == 0)
2160                 r = q;
2161
2162         return r;
2163 }
2164
2165 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet) {
2166         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2167         _cleanup_free_ char *n = NULL, *state = NULL;
2168         const char *path;
2169         int r;
2170
2171         assert(name);
2172
2173         n = unit_name_mangle(name, MANGLE_NOGLOB);
2174         if (!n)
2175                 return log_oom();
2176
2177         /* We don't use unit_dbus_path_from_name() directly since we
2178          * don't want to load the unit if it isn't loaded. */
2179
2180         r = sd_bus_call_method(
2181                         bus,
2182                         "org.freedesktop.systemd1",
2183                         "/org/freedesktop/systemd1",
2184                         "org.freedesktop.systemd1.Manager",
2185                         "GetUnit",
2186                         NULL,
2187                         &reply,
2188                         "s", n);
2189         if (r < 0) {
2190                 if (!quiet)
2191                         puts("unknown");
2192                 return 0;
2193         }
2194
2195         r = sd_bus_message_read(reply, "o", &path);
2196         if (r < 0)
2197                 return bus_log_parse_error(r);
2198
2199         r = sd_bus_get_property_string(
2200                         bus,
2201                         "org.freedesktop.systemd1",
2202                         path,
2203                         "org.freedesktop.systemd1.Unit",
2204                         "ActiveState",
2205                         NULL,
2206                         &state);
2207         if (r < 0) {
2208                 if (!quiet)
2209                         puts("unknown");
2210                 return 0;
2211         }
2212
2213         if (!quiet)
2214                 puts(state);
2215
2216         return nulstr_contains(good_states, state);
2217 }
2218
2219 static int check_triggering_units(
2220                 sd_bus *bus,
2221                 const char *name) {
2222
2223         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2224         _cleanup_free_ char *path = NULL, *n = NULL, *state = NULL;
2225         _cleanup_strv_free_ char **triggered_by = NULL;
2226         bool print_warning_label = true;
2227         char **i;
2228         int r;
2229
2230         n = unit_name_mangle(name, MANGLE_NOGLOB);
2231         if (!n)
2232                 return log_oom();
2233
2234         path = unit_dbus_path_from_name(n);
2235         if (!path)
2236                 return log_oom();
2237
2238         r = sd_bus_get_property_string(
2239                         bus,
2240                         "org.freedesktop.systemd1",
2241                         path,
2242                         "org.freedesktop.systemd1.Unit",
2243                         "LoadState",
2244                         &error,
2245                         &state);
2246         if (r < 0) {
2247                 log_error("Failed to get load state of %s: %s", n, bus_error_message(&error, r));
2248                 return r;
2249         }
2250
2251         if (streq(state, "masked"))
2252                 return 0;
2253
2254         r = sd_bus_get_property_strv(
2255                         bus,
2256                         "org.freedesktop.systemd1",
2257                         path,
2258                         "org.freedesktop.systemd1.Unit",
2259                         "TriggeredBy",
2260                         &error,
2261                         &triggered_by);
2262         if (r < 0) {
2263                 log_error("Failed to get triggered by array of %s: %s", n, bus_error_message(&error, r));
2264                 return r;
2265         }
2266
2267         STRV_FOREACH(i, triggered_by) {
2268                 r = check_one_unit(bus, *i, "active\0reloading\0", true);
2269                 if (r < 0) {
2270                         log_error("Failed to check unit: %s", strerror(-r));
2271                         return r;
2272                 }
2273
2274                 if (r == 0)
2275                         continue;
2276
2277                 if (print_warning_label) {
2278                         log_warning("Warning: Stopping %s, but it can still be activated by:", n);
2279                         print_warning_label = false;
2280                 }
2281
2282                 log_warning("  %s", *i);
2283         }
2284
2285         return 0;
2286 }
2287
2288 static const char *verb_to_method(const char *verb) {
2289        uint i;
2290
2291        for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2292                 if (streq_ptr(unit_actions[i].verb, verb))
2293                         return unit_actions[i].method;
2294
2295        return "StartUnit";
2296 }
2297
2298 static const char *method_to_verb(const char *method) {
2299        uint i;
2300
2301        for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2302                 if (streq_ptr(unit_actions[i].method, method))
2303                         return unit_actions[i].verb;
2304
2305        return "n/a";
2306 }
2307
2308 static int start_unit_one(
2309                 sd_bus *bus,
2310                 const char *method,
2311                 const char *name,
2312                 const char *mode,
2313                 sd_bus_error *error,
2314                 Set *s) {
2315
2316         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2317         const char *path;
2318         int r;
2319
2320         assert(method);
2321         assert(name);
2322         assert(mode);
2323         assert(error);
2324
2325         log_debug("Calling manager for %s on %s, %s", method, name, mode);
2326         r = sd_bus_call_method(
2327                         bus,
2328                         "org.freedesktop.systemd1",
2329                         "/org/freedesktop/systemd1",
2330                         "org.freedesktop.systemd1.Manager",
2331                         method,
2332                         error,
2333                         &reply,
2334                         "ss", name, mode);
2335         if (r < 0) {
2336                 const char *verb;
2337
2338                 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
2339                         /* There's always a fallback possible for
2340                          * legacy actions. */
2341                         return -EADDRNOTAVAIL;
2342
2343                 verb = method_to_verb(method);
2344
2345                 log_error("Failed to %s %s: %s", verb, name, bus_error_message(error, r));
2346                 return r;
2347         }
2348
2349         r = sd_bus_message_read(reply, "o", &path);
2350         if (r < 0)
2351                 return bus_log_parse_error(r);
2352
2353         if (need_daemon_reload(bus, name) > 0)
2354                 log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
2355                             name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
2356
2357         if (s) {
2358                 char *p;
2359
2360                 p = strdup(path);
2361                 if (!p)
2362                         return log_oom();
2363
2364                 log_debug("Adding %s to the set", p);
2365                 r = set_consume(s, p);
2366                 if (r < 0)
2367                         return log_oom();
2368         }
2369
2370         return 0;
2371 }
2372
2373 static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
2374
2375         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2376         _cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
2377         char **name;
2378         int r = 0, i;
2379
2380         STRV_FOREACH(name, names) {
2381                 char *t;
2382
2383                 if (suffix)
2384                         t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);
2385                 else
2386                         t = unit_name_mangle(*name, MANGLE_GLOB);
2387                 if (!t)
2388                         return log_oom();
2389
2390                 if (string_is_glob(t))
2391                         r = strv_consume(&globs, t);
2392                 else
2393                         r = strv_consume(&mangled, t);
2394                 if (r < 0)
2395                         return log_oom();
2396         }
2397
2398         /* Query the manager only if any of the names are a glob, since
2399          * this is fairly expensive */
2400         if (!strv_isempty(globs)) {
2401                 _cleanup_free_ UnitInfo *unit_infos = NULL;
2402
2403                 r = get_unit_list(bus, &reply, &unit_infos, globs);
2404                 if (r < 0)
2405                         return r;
2406
2407                 for (i = 0; i < r; i++)
2408                         if (strv_extend(&mangled, unit_infos[i].id) < 0)
2409                                 return log_oom();
2410         }
2411
2412         *ret = mangled;
2413         mangled = NULL; /* do not free */
2414         return 0;
2415 }
2416
2417 static const struct {
2418         const char *target;
2419         const char *verb;
2420         const char *mode;
2421 } action_table[_ACTION_MAX] = {
2422         [ACTION_HALT]         = { SPECIAL_HALT_TARGET,         "halt",         "replace-irreversibly" },
2423         [ACTION_POWEROFF]     = { SPECIAL_POWEROFF_TARGET,     "poweroff",     "replace-irreversibly" },
2424         [ACTION_REBOOT]       = { SPECIAL_REBOOT_TARGET,       "reboot",       "replace-irreversibly" },
2425         [ACTION_KEXEC]        = { SPECIAL_KEXEC_TARGET,        "kexec",        "replace-irreversibly" },
2426         [ACTION_RUNLEVEL2]    = { SPECIAL_RUNLEVEL2_TARGET,    NULL,           "isolate" },
2427         [ACTION_RUNLEVEL3]    = { SPECIAL_RUNLEVEL3_TARGET,    NULL,           "isolate" },
2428         [ACTION_RUNLEVEL4]    = { SPECIAL_RUNLEVEL4_TARGET,    NULL,           "isolate" },
2429         [ACTION_RUNLEVEL5]    = { SPECIAL_RUNLEVEL5_TARGET,    NULL,           "isolate" },
2430         [ACTION_RESCUE]       = { SPECIAL_RESCUE_TARGET,       "rescue",       "isolate" },
2431         [ACTION_EMERGENCY]    = { SPECIAL_EMERGENCY_TARGET,    "emergency",    "isolate" },
2432         [ACTION_DEFAULT]      = { SPECIAL_DEFAULT_TARGET,      "default",      "isolate" },
2433         [ACTION_EXIT]         = { SPECIAL_EXIT_TARGET,         "exit",         "replace-irreversibly" },
2434         [ACTION_SUSPEND]      = { SPECIAL_SUSPEND_TARGET,      "suspend",      "replace-irreversibly" },
2435         [ACTION_HIBERNATE]    = { SPECIAL_HIBERNATE_TARGET,    "hibernate",    "replace-irreversibly" },
2436         [ACTION_HYBRID_SLEEP] = { SPECIAL_HYBRID_SLEEP_TARGET, "hybrid-sleep", "replace-irreversibly" },
2437 };
2438
2439 static enum action verb_to_action(const char *verb) {
2440         enum action i;
2441
2442         for (i = _ACTION_INVALID; i < _ACTION_MAX; i++)
2443                 if (streq_ptr(action_table[i].verb, verb))
2444                         return i;
2445
2446         return _ACTION_INVALID;
2447 }
2448
2449 static int start_unit(sd_bus *bus, char **args) {
2450         _cleanup_set_free_free_ Set *s = NULL;
2451         _cleanup_strv_free_ char **names = NULL;
2452         const char *method, *mode, *one_name;
2453         char **name;
2454         int r = 0;
2455
2456         assert(bus);
2457
2458         ask_password_agent_open_if_enabled();
2459
2460         if (arg_action == ACTION_SYSTEMCTL) {
2461                 enum action action;
2462                 method = verb_to_method(args[0]);
2463                 action = verb_to_action(args[0]);
2464
2465                 mode = streq(args[0], "isolate") ? "isolate" :
2466                        action_table[action].mode ?: arg_job_mode;
2467
2468                 one_name = action_table[action].target;
2469         } else {
2470                 assert(arg_action < ELEMENTSOF(action_table));
2471                 assert(action_table[arg_action].target);
2472
2473                 method = "StartUnit";
2474
2475                 mode = action_table[arg_action].mode;
2476                 one_name = action_table[arg_action].target;
2477         }
2478
2479         if (one_name)
2480                 names = strv_new(one_name, NULL);
2481         else {
2482                 r = expand_names(bus, args + 1, NULL, &names);
2483                 if (r < 0)
2484                         log_error("Failed to expand names: %s", strerror(-r));
2485         }
2486
2487         if (!arg_no_block) {
2488                 r = enable_wait_for_jobs(bus);
2489                 if (r < 0) {
2490                         log_error("Could not watch jobs: %s", strerror(-r));
2491                         return r;
2492                 }
2493
2494                 s = set_new(string_hash_func, string_compare_func);
2495                 if (!s)
2496                         return log_oom();
2497         }
2498
2499         STRV_FOREACH(name, names) {
2500                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2501                 int q;
2502
2503                 q = start_unit_one(bus, method, *name, mode, &error, s);
2504                 if (r >= 0 && q < 0)
2505                         r = translate_bus_error_to_exit_status(q, &error);
2506         }
2507
2508         if (!arg_no_block) {
2509                 int q;
2510
2511                 q = wait_for_jobs(bus, s);
2512                 if (q < 0)
2513                         return q;
2514
2515                 /* When stopping units, warn if they can still be triggered by
2516                  * another active unit (socket, path, timer) */
2517                 if (!arg_quiet && streq(method, "StopUnit"))
2518                         STRV_FOREACH(name, names)
2519                                 check_triggering_units(bus, *name);
2520         }
2521
2522         return r;
2523 }
2524
2525 /* Ask systemd-logind, which might grant access to unprivileged users
2526  * through PolicyKit */
2527 static int reboot_with_logind(sd_bus *bus, enum action a) {
2528 #ifdef HAVE_LOGIND
2529         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2530         const char *method;
2531         int r;
2532
2533         if (!bus)
2534                 return -EIO;
2535
2536         polkit_agent_open_if_enabled();
2537
2538         switch (a) {
2539
2540         case ACTION_REBOOT:
2541                 method = "Reboot";
2542                 break;
2543
2544         case ACTION_POWEROFF:
2545                 method = "PowerOff";
2546                 break;
2547
2548         case ACTION_SUSPEND:
2549                 method = "Suspend";
2550                 break;
2551
2552         case ACTION_HIBERNATE:
2553                 method = "Hibernate";
2554                 break;
2555
2556         case ACTION_HYBRID_SLEEP:
2557                 method = "HybridSleep";
2558                 break;
2559
2560         default:
2561                 return -EINVAL;
2562         }
2563
2564         r = sd_bus_call_method(
2565                         bus,
2566                         "org.freedesktop.login1",
2567                         "/org/freedesktop/login1",
2568                         "org.freedesktop.login1.Manager",
2569                         method,
2570                         &error,
2571                         NULL,
2572                         "b", true);
2573         if (r < 0)
2574                 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
2575
2576         return r;
2577 #else
2578         return -ENOSYS;
2579 #endif
2580 }
2581
2582 static int check_inhibitors(sd_bus *bus, enum action a) {
2583 #ifdef HAVE_LOGIND
2584         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2585         _cleanup_strv_free_ char **sessions = NULL;
2586         const char *what, *who, *why, *mode;
2587         uint32_t uid, pid;
2588         unsigned c = 0;
2589         char **s;
2590         int r;
2591
2592         if (!bus)
2593                 return 0;
2594
2595         if (arg_ignore_inhibitors || arg_force > 0)
2596                 return 0;
2597
2598         if (arg_when > 0)
2599                 return 0;
2600
2601         if (geteuid() == 0)
2602                 return 0;
2603
2604         if (!on_tty())
2605                 return 0;
2606
2607         r = sd_bus_call_method(
2608                         bus,
2609                         "org.freedesktop.login1",
2610                         "/org/freedesktop/login1",
2611                         "org.freedesktop.login1.Manager",
2612                         "ListInhibitors",
2613                         NULL,
2614                         &reply,
2615                         NULL);
2616         if (r < 0)
2617                 /* If logind is not around, then there are no inhibitors... */
2618                 return 0;
2619
2620         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
2621         if (r < 0)
2622                 return bus_log_parse_error(r);
2623
2624         while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
2625                 _cleanup_free_ char *comm = NULL, *user = NULL;
2626                 _cleanup_strv_free_ char **sv = NULL;
2627
2628                 if (!streq(mode, "block"))
2629                         continue;
2630
2631                 sv = strv_split(what, ":");
2632                 if (!sv)
2633                         return log_oom();
2634
2635                 if (!strv_contains(sv,
2636                                   a == ACTION_HALT ||
2637                                   a == ACTION_POWEROFF ||
2638                                   a == ACTION_REBOOT ||
2639                                   a == ACTION_KEXEC ? "shutdown" : "sleep"))
2640                         continue;
2641
2642                 get_process_comm(pid, &comm);
2643                 user = uid_to_name(uid);
2644
2645                 log_warning("Operation inhibited by \"%s\" (PID %lu \"%s\", user %s), reason is \"%s\".",
2646                             who, (unsigned long) pid, strna(comm), strna(user), why);
2647
2648                 c++;
2649         }
2650         if (r < 0)
2651                 return bus_log_parse_error(r);
2652
2653         r = sd_bus_message_exit_container(reply);
2654         if (r < 0)
2655                 return bus_log_parse_error(r);
2656
2657         /* Check for current sessions */
2658         sd_get_sessions(&sessions);
2659         STRV_FOREACH(s, sessions) {
2660                 _cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;
2661
2662                 if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())
2663                         continue;
2664
2665                 if (sd_session_get_class(*s, &class) < 0 || !streq(class, "user"))
2666                         continue;
2667
2668                 if (sd_session_get_type(*s, &type) < 0 || (!streq(type, "x11") && !streq(type, "tty")))
2669                         continue;
2670
2671                 sd_session_get_tty(*s, &tty);
2672                 sd_session_get_seat(*s, &seat);
2673                 sd_session_get_service(*s, &service);
2674                 user = uid_to_name(uid);
2675
2676                 log_warning("User %s is logged in on %s.", strna(user), isempty(tty) ? (isempty(seat) ? strna(service) : seat) : tty);
2677                 c++;
2678         }
2679
2680         if (c <= 0)
2681                 return 0;
2682
2683         log_error("Please retry operation after closing inhibitors and logging out other users.\nAlternatively, ignore inhibitors and users with 'systemctl %s -i'.",
2684                   action_table[a].verb);
2685
2686         return -EPERM;
2687 #else
2688         return 0;
2689 #endif
2690 }
2691
2692 static int start_special(sd_bus *bus, char **args) {
2693         enum action a;
2694         int r;
2695
2696         assert(args);
2697
2698         a = verb_to_action(args[0]);
2699
2700         r = check_inhibitors(bus, a);
2701         if (r < 0)
2702                 return r;
2703
2704         if (arg_force >= 2 && geteuid() != 0) {
2705                 log_error("Must be root.");
2706                 return -EPERM;
2707         }
2708
2709         if (arg_force >= 2 &&
2710             (a == ACTION_HALT ||
2711              a == ACTION_POWEROFF ||
2712              a == ACTION_REBOOT))
2713                 return halt_now(a);
2714
2715         if (arg_force >= 1 &&
2716             (a == ACTION_HALT ||
2717              a == ACTION_POWEROFF ||
2718              a == ACTION_REBOOT ||
2719              a == ACTION_KEXEC ||
2720              a == ACTION_EXIT))
2721                 return daemon_reload(bus, args);
2722
2723         /* first try logind, to allow authentication with polkit */
2724         if (geteuid() != 0 &&
2725             (a == ACTION_POWEROFF ||
2726              a == ACTION_REBOOT ||
2727              a == ACTION_SUSPEND ||
2728              a == ACTION_HIBERNATE ||
2729              a == ACTION_HYBRID_SLEEP)) {
2730                 r = reboot_with_logind(bus, a);
2731                 if (r >= 0)
2732                         return r;
2733         }
2734
2735         r = start_unit(bus, args);
2736         if (r == EXIT_SUCCESS)
2737                 warn_wall(a);
2738
2739         return r;
2740 }
2741
2742 static int check_unit_generic(sd_bus *bus, int code, const char *good_states, char **args) {
2743         _cleanup_strv_free_ char **names = NULL;
2744         char **name;
2745         int r;
2746
2747         assert(bus);
2748         assert(args);
2749
2750         r = expand_names(bus, args, NULL, &names);
2751         if (r < 0) {
2752                 log_error("Failed to expand names: %s", strerror(-r));
2753                 return r;
2754         }
2755
2756         STRV_FOREACH(name, names) {
2757                 int state;
2758
2759                 state = check_one_unit(bus, *name, good_states, arg_quiet);
2760                 if (state < 0)
2761                         return state;
2762                 if (state == 0)
2763                         r = code;
2764         }
2765
2766         return r;
2767 }
2768
2769 static int check_unit_active(sd_bus *bus, char **args) {
2770         /* According to LSB: 3, "program is not running" */
2771         return check_unit_generic(bus, 3, "active\0reloading\0", args + 1);
2772 }
2773
2774 static int check_unit_failed(sd_bus *bus, char **args) {
2775         return check_unit_generic(bus, 1, "failed\0", args + 1);
2776 }
2777
2778 static int kill_unit(sd_bus *bus, char **args) {
2779         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2780         _cleanup_strv_free_ char **names = NULL;
2781         char **name;
2782         int r, q;
2783
2784         assert(bus);
2785         assert(args);
2786
2787         if (!arg_kill_who)
2788                 arg_kill_who = "all";
2789
2790         r = expand_names(bus, args + 1, NULL, &names);
2791         if (r < 0)
2792                 log_error("Failed to expand names: %s", strerror(-r));
2793
2794         STRV_FOREACH(name, names) {
2795                 q = sd_bus_call_method(
2796                                 bus,
2797                                 "org.freedesktop.systemd1",
2798                                 "/org/freedesktop/systemd1",
2799                                 "org.freedesktop.systemd1.Manager",
2800                                 "KillUnit",
2801                                 &error,
2802                                 NULL,
2803                                 "ssi", *names, arg_kill_who, arg_signal);
2804                 if (q < 0) {
2805                         log_error("Failed to kill unit %s: %s",
2806                                   *names, bus_error_message(&error, r));
2807                         if (r == 0)
2808                                 r = q;
2809                 }
2810         }
2811
2812         return r;
2813 }
2814
2815 typedef struct ExecStatusInfo {
2816         char *name;
2817
2818         char *path;
2819         char **argv;
2820
2821         bool ignore;
2822
2823         usec_t start_timestamp;
2824         usec_t exit_timestamp;
2825         pid_t pid;
2826         int code;
2827         int status;
2828
2829         LIST_FIELDS(struct ExecStatusInfo, exec);
2830 } ExecStatusInfo;
2831
2832 static void exec_status_info_free(ExecStatusInfo *i) {
2833         assert(i);
2834
2835         free(i->name);
2836         free(i->path);
2837         strv_free(i->argv);
2838         free(i);
2839 }
2840
2841 static int exec_status_info_deserialize(sd_bus_message *m, ExecStatusInfo *i) {
2842         uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
2843         const char *path;
2844         uint32_t pid;
2845         int32_t code, status;
2846         int ignore, r;
2847
2848         assert(m);
2849         assert(i);
2850
2851         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
2852         if (r < 0)
2853                 return bus_log_parse_error(r);
2854         else if (r == 0)
2855                 return 0;
2856
2857         r = sd_bus_message_read(m, "s", &path);
2858         if (r < 0)
2859                 return bus_log_parse_error(r);
2860
2861         i->path = strdup(path);
2862         if (!i->path)
2863                 return log_oom();
2864
2865         r = sd_bus_message_read_strv(m, &i->argv);
2866         if (r < 0)
2867                 return bus_log_parse_error(r);
2868
2869         r = sd_bus_message_read(m,
2870                                 "bttttuii",
2871                                 &ignore,
2872                                 &start_timestamp, &start_timestamp_monotonic,
2873                                 &exit_timestamp, &exit_timestamp_monotonic,
2874                                 &pid,
2875                                 &code, &status);
2876         if (r < 0)
2877                 return bus_log_parse_error(r);
2878
2879         i->ignore = ignore;
2880         i->start_timestamp = (usec_t) start_timestamp;
2881         i->exit_timestamp = (usec_t) exit_timestamp;
2882         i->pid = (pid_t) pid;
2883         i->code = code;
2884         i->status = status;
2885
2886         r = sd_bus_message_exit_container(m);
2887         if (r < 0)
2888                 return bus_log_parse_error(r);
2889
2890         return 1;
2891 }
2892
2893 typedef struct UnitStatusInfo {
2894         const char *id;
2895         const char *load_state;
2896         const char *active_state;
2897         const char *sub_state;
2898         const char *unit_file_state;
2899
2900         const char *description;
2901         const char *following;
2902
2903         char **documentation;
2904
2905         const char *fragment_path;
2906         const char *source_path;
2907         const char *control_group;
2908
2909         char **dropin_paths;
2910
2911         const char *load_error;
2912         const char *result;
2913
2914         usec_t inactive_exit_timestamp;
2915         usec_t inactive_exit_timestamp_monotonic;
2916         usec_t active_enter_timestamp;
2917         usec_t active_exit_timestamp;
2918         usec_t inactive_enter_timestamp;
2919
2920         bool need_daemon_reload;
2921
2922         /* Service */
2923         pid_t main_pid;
2924         pid_t control_pid;
2925         const char *status_text;
2926         const char *pid_file;
2927         bool running:1;
2928
2929         usec_t start_timestamp;
2930         usec_t exit_timestamp;
2931
2932         int exit_code, exit_status;
2933
2934         usec_t condition_timestamp;
2935         bool condition_result;
2936         bool failed_condition_trigger;
2937         bool failed_condition_negate;
2938         const char *failed_condition;
2939         const char *failed_condition_param;
2940
2941         /* Socket */
2942         unsigned n_accepted;
2943         unsigned n_connections;
2944         bool accept;
2945
2946         /* Pairs of type, path */
2947         char **listen;
2948
2949         /* Device */
2950         const char *sysfs_path;
2951
2952         /* Mount, Automount */
2953         const char *where;
2954
2955         /* Swap */
2956         const char *what;
2957
2958         LIST_HEAD(ExecStatusInfo, exec);
2959 } UnitStatusInfo;
2960
2961 static void print_status_info(
2962                 UnitStatusInfo *i,
2963                 bool *ellipsized) {
2964
2965         ExecStatusInfo *p;
2966         const char *active_on, *active_off, *on, *off, *ss;
2967         usec_t timestamp;
2968         char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
2969         char since2[FORMAT_TIMESTAMP_MAX], *s2;
2970         const char *path;
2971         int flags =
2972                 arg_all * OUTPUT_SHOW_ALL |
2973                 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
2974                 on_tty() * OUTPUT_COLOR |
2975                 !arg_quiet * OUTPUT_WARN_CUTOFF |
2976                 arg_full * OUTPUT_FULL_WIDTH;
2977         char **t, **t2;
2978
2979         assert(i);
2980
2981         /* This shows pretty information about a unit. See
2982          * print_property() for a low-level property printer */
2983
2984         if (streq_ptr(i->active_state, "failed")) {
2985                 active_on = ansi_highlight_red();
2986                 active_off = ansi_highlight_off();
2987         } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
2988                 active_on = ansi_highlight_green();
2989                 active_off = ansi_highlight_off();
2990         } else
2991                 active_on = active_off = "";
2992
2993         printf("%s%s%s%s", active_on, draw_special_char(DRAW_BLACK_CIRCLE), active_off, strna(i->id));
2994
2995         if (i->description && !streq_ptr(i->id, i->description))
2996                 printf(" - %s", i->description);
2997
2998         printf("\n");
2999
3000         if (i->following)
3001                 printf("   Follow: unit currently follows state of %s\n", i->following);
3002
3003         if (streq_ptr(i->load_state, "error")) {
3004                 on = ansi_highlight_red();
3005                 off = ansi_highlight_off();
3006         } else
3007                 on = off = "";
3008
3009         path = i->source_path ? i->source_path : i->fragment_path;
3010
3011         if (i->load_error)
3012                 printf("   Loaded: %s%s%s (Reason: %s)\n",
3013                        on, strna(i->load_state), off, i->load_error);
3014         else if (path && i->unit_file_state)
3015                 printf("   Loaded: %s%s%s (%s; %s)\n",
3016                        on, strna(i->load_state), off, path, i->unit_file_state);
3017         else if (path)
3018                 printf("   Loaded: %s%s%s (%s)\n",
3019                        on, strna(i->load_state), off, path);
3020         else
3021                 printf("   Loaded: %s%s%s\n",
3022                        on, strna(i->load_state), off);
3023
3024         if (!strv_isempty(i->dropin_paths)) {
3025                 _cleanup_free_ char *dir = NULL;
3026                 bool last = false;
3027                 char ** dropin;
3028
3029                 STRV_FOREACH(dropin, i->dropin_paths) {
3030                         if (! dir || last) {
3031                                 printf(dir ? "        " : "  Drop-In: ");
3032
3033                                 free(dir);
3034                                 dir = NULL;
3035
3036                                 if (path_get_parent(*dropin, &dir) < 0) {
3037                                         log_oom();
3038                                         return;
3039                                 }
3040
3041                                 printf("%s\n           %s", dir,
3042                                        draw_special_char(DRAW_TREE_RIGHT));
3043                         }
3044
3045                         last = ! (*(dropin + 1) && startswith(*(dropin + 1), dir));
3046
3047                         printf("%s%s", basename(*dropin), last ? "\n" : ", ");
3048                 }
3049         }
3050
3051         ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
3052         if (ss)
3053                 printf("   Active: %s%s (%s)%s",
3054                        active_on, strna(i->active_state), ss, active_off);
3055         else
3056                 printf("   Active: %s%s%s",
3057                        active_on, strna(i->active_state), active_off);
3058
3059         if (!isempty(i->result) && !streq(i->result, "success"))
3060                 printf(" (Result: %s)", i->result);
3061
3062         timestamp = (streq_ptr(i->active_state, "active")      ||
3063                      streq_ptr(i->active_state, "reloading"))   ? i->active_enter_timestamp :
3064                     (streq_ptr(i->active_state, "inactive")    ||
3065                      streq_ptr(i->active_state, "failed"))      ? i->inactive_enter_timestamp :
3066                     streq_ptr(i->active_state, "activating")    ? i->inactive_exit_timestamp :
3067                                                                   i->active_exit_timestamp;
3068
3069         s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);
3070         s2 = format_timestamp(since2, sizeof(since2), timestamp);
3071
3072         if (s1)
3073                 printf(" since %s; %s\n", s2, s1);
3074         else if (s2)
3075                 printf(" since %s\n", s2);
3076         else
3077                 printf("\n");
3078
3079         if (!i->condition_result && i->condition_timestamp > 0) {
3080                 s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);
3081                 s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
3082
3083                 printf("           start condition failed at %s%s%s\n",
3084                        s2, s1 ? "; " : "", s1 ? s1 : "");
3085                 if (i->failed_condition_trigger)
3086                         printf("           none of the trigger conditions were met\n");
3087                 else if (i->failed_condition)
3088                         printf("           %s=%s%s was not met\n",
3089                                i->failed_condition,
3090                                i->failed_condition_negate ? "!" : "",
3091                                i->failed_condition_param);
3092         }
3093
3094         if (i->sysfs_path)
3095                 printf("   Device: %s\n", i->sysfs_path);
3096         if (i->where)
3097                 printf("    Where: %s\n", i->where);
3098         if (i->what)
3099                 printf("     What: %s\n", i->what);
3100
3101         STRV_FOREACH(t, i->documentation)
3102                 printf(" %*s %s\n", 9, t == i->documentation ? "Docs:" : "", *t);
3103
3104         STRV_FOREACH_PAIR(t, t2, i->listen)
3105                 printf(" %*s %s (%s)\n", 9, t == i->listen ? "Listen:" : "", *t2, *t);
3106
3107         if (i->accept)
3108                 printf(" Accepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
3109
3110         LIST_FOREACH(exec, p, i->exec) {
3111                 _cleanup_free_ char *argv = NULL;
3112                 bool good;
3113
3114                 /* Only show exited processes here */
3115                 if (p->code == 0)
3116                         continue;
3117
3118                 argv = strv_join(p->argv, " ");
3119                 printf("  Process: %u %s=%s ", p->pid, p->name, strna(argv));
3120
3121                 good = is_clean_exit_lsb(p->code, p->status, NULL);
3122                 if (!good) {
3123                         on = ansi_highlight_red();
3124                         off = ansi_highlight_off();
3125                 } else
3126                         on = off = "";
3127
3128                 printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));
3129
3130                 if (p->code == CLD_EXITED) {
3131                         const char *c;
3132
3133                         printf("status=%i", p->status);
3134
3135                         c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD);
3136                         if (c)
3137                                 printf("/%s", c);
3138
3139                 } else
3140                         printf("signal=%s", signal_to_string(p->status));
3141
3142                 printf(")%s\n", off);
3143
3144                 if (i->main_pid == p->pid &&
3145                     i->start_timestamp == p->start_timestamp &&
3146                     i->exit_timestamp == p->start_timestamp)
3147                         /* Let's not show this twice */
3148                         i->main_pid = 0;
3149
3150                 if (p->pid == i->control_pid)
3151                         i->control_pid = 0;
3152         }
3153
3154         if (i->main_pid > 0 || i->control_pid > 0) {
3155                 if (i->main_pid > 0) {
3156                         printf(" Main PID: %u", (unsigned) i->main_pid);
3157
3158                         if (i->running) {
3159                                 _cleanup_free_ char *comm = NULL;
3160                                 get_process_comm(i->main_pid, &comm);
3161                                 if (comm)
3162                                         printf(" (%s)", comm);
3163                         } else if (i->exit_code > 0) {
3164                                 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
3165
3166                                 if (i->exit_code == CLD_EXITED) {
3167                                         const char *c;
3168
3169                                         printf("status=%i", i->exit_status);
3170
3171                                         c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD);
3172                                         if (c)
3173                                                 printf("/%s", c);
3174
3175                                 } else
3176                                         printf("signal=%s", signal_to_string(i->exit_status));
3177                                 printf(")");
3178                         }
3179
3180                         if (i->control_pid > 0)
3181                                 printf(";");
3182                 }
3183
3184                 if (i->control_pid > 0) {
3185                         _cleanup_free_ char *c = NULL;
3186
3187                         printf(" %8s: %u", i->main_pid ? "" : " Control", (unsigned) i->control_pid);
3188
3189                         get_process_comm(i->control_pid, &c);
3190                         if (c)
3191                                 printf(" (%s)", c);
3192                 }
3193
3194                 printf("\n");
3195         }
3196
3197         if (i->status_text)
3198                 printf("   Status: \"%s\"\n", i->status_text);
3199
3200         if (i->control_group &&
3201             (i->main_pid > 0 || i->control_pid > 0 ||
3202              ((arg_transport != BUS_TRANSPORT_LOCAL && arg_transport != BUS_TRANSPORT_CONTAINER) || cg_is_empty_recursive(SYSTEMD_CGROUP_CONTROLLER, i->control_group, false) == 0))) {
3203                 unsigned c;
3204
3205                 printf("   CGroup: %s\n", i->control_group);
3206
3207                 if (arg_transport == BUS_TRANSPORT_LOCAL || arg_transport == BUS_TRANSPORT_CONTAINER) {
3208                         unsigned k = 0;
3209                         pid_t extra[2];
3210                         static const char prefix[] = "           ";
3211
3212                         c = columns();
3213                         if (c > sizeof(prefix) - 1)
3214                                 c -= sizeof(prefix) - 1;
3215                         else
3216                                 c = 0;
3217
3218                         if (i->main_pid > 0)
3219                                 extra[k++] = i->main_pid;
3220
3221                         if (i->control_pid > 0)
3222                                 extra[k++] = i->control_pid;
3223
3224                         show_cgroup_and_extra(SYSTEMD_CGROUP_CONTROLLER, i->control_group, prefix, c, false, extra, k, flags);
3225                 }
3226         }
3227
3228         if (i->id && arg_transport == BUS_TRANSPORT_LOCAL) {
3229                 show_journal_by_unit(stdout,
3230                                      i->id,
3231                                      arg_output,
3232                                      0,
3233                                      i->inactive_exit_timestamp_monotonic,
3234                                      arg_lines,
3235                                      getuid(),
3236                                      flags | OUTPUT_BEGIN_NEWLINE,
3237                                      arg_scope == UNIT_FILE_SYSTEM,
3238                                      ellipsized);
3239         }
3240
3241         if (i->need_daemon_reload)
3242                 printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %sdaemon-reload' recommended.\n",
3243                        ansi_highlight_red(),
3244                        ansi_highlight_off(),
3245                        arg_scope == UNIT_FILE_SYSTEM ? "" : "--user ");
3246 }
3247
3248 static void show_unit_help(UnitStatusInfo *i) {
3249         char **p;
3250
3251         assert(i);
3252
3253         if (!i->documentation) {
3254                 log_info("Documentation for %s not known.", i->id);
3255                 return;
3256         }
3257
3258         STRV_FOREACH(p, i->documentation) {
3259
3260                 if (startswith(*p, "man:")) {
3261                         const char *args[4] = { "man", NULL, NULL, NULL };
3262                         _cleanup_free_ char *page = NULL, *section = NULL;
3263                         char *e = NULL;
3264                         pid_t pid;
3265                         size_t k;
3266
3267                         k = strlen(*p);
3268
3269                         if ((*p)[k-1] == ')')
3270                                 e = strrchr(*p, '(');
3271
3272                         if (e) {
3273                                 page = strndup((*p) + 4, e - *p - 4);
3274                                 section = strndup(e + 1, *p + k - e - 2);
3275                                 if (!page || !section) {
3276                                         log_oom();
3277                                         return;
3278                                 }
3279
3280                                 args[1] = section;
3281                                 args[2] = page;
3282                         } else
3283                                 args[1] = *p + 4;
3284
3285                         pid = fork();
3286                         if (pid < 0) {
3287                                 log_error("Failed to fork: %m");
3288                                 continue;
3289                         }
3290
3291                         if (pid == 0) {
3292                                 /* Child */
3293                                 execvp(args[0], (char**) args);
3294                                 log_error("Failed to execute man: %m");
3295                                 _exit(EXIT_FAILURE);
3296                         }
3297
3298                         wait_for_terminate(pid, NULL);
3299                 } else
3300                         log_info("Can't show: %s", *p);
3301         }
3302 }
3303
3304 static int status_property(const char *name, sd_bus_message *m, UnitStatusInfo *i, const char *contents) {
3305         int r;
3306
3307         assert(name);
3308         assert(m);
3309         assert(i);
3310
3311         switch (contents[0]) {
3312
3313         case SD_BUS_TYPE_STRING: {
3314                 const char *s;
3315
3316                 r = sd_bus_message_read(m, "s", &s);
3317                 if (r < 0)
3318                         return bus_log_parse_error(r);
3319
3320                 if (!isempty(s)) {
3321                         if (streq(name, "Id"))
3322                                 i->id = s;
3323                         else if (streq(name, "LoadState"))
3324                                 i->load_state = s;
3325                         else if (streq(name, "ActiveState"))
3326                                 i->active_state = s;
3327                         else if (streq(name, "SubState"))
3328                                 i->sub_state = s;
3329                         else if (streq(name, "Description"))
3330                                 i->description = s;
3331                         else if (streq(name, "FragmentPath"))
3332                                 i->fragment_path = s;
3333                         else if (streq(name, "SourcePath"))
3334                                 i->source_path = s;
3335 #ifndef NOLEGACY
3336                         else if (streq(name, "DefaultControlGroup")) {
3337                                 const char *e;
3338                                 e = startswith(s, SYSTEMD_CGROUP_CONTROLLER ":");
3339                                 if (e)
3340                                         i->control_group = e;
3341                         }
3342 #endif
3343                         else if (streq(name, "ControlGroup"))
3344                                 i->control_group = s;
3345                         else if (streq(name, "StatusText"))
3346                                 i->status_text = s;
3347                         else if (streq(name, "PIDFile"))
3348                                 i->pid_file = s;
3349                         else if (streq(name, "SysFSPath"))
3350                                 i->sysfs_path = s;
3351                         else if (streq(name, "Where"))
3352                                 i->where = s;
3353                         else if (streq(name, "What"))
3354                                 i->what = s;
3355                         else if (streq(name, "Following"))
3356                                 i->following = s;
3357                         else if (streq(name, "UnitFileState"))
3358                                 i->unit_file_state = s;
3359                         else if (streq(name, "Result"))
3360                                 i->result = s;
3361                 }
3362
3363                 break;
3364         }
3365
3366         case SD_BUS_TYPE_BOOLEAN: {
3367                 int b;
3368
3369                 r = sd_bus_message_read(m, "b", &b);
3370                 if (r < 0)
3371                         return bus_log_parse_error(r);
3372
3373                 if (streq(name, "Accept"))
3374                         i->accept = b;
3375                 else if (streq(name, "NeedDaemonReload"))
3376                         i->need_daemon_reload = b;
3377                 else if (streq(name, "ConditionResult"))
3378                         i->condition_result = b;
3379
3380                 break;
3381         }
3382
3383         case SD_BUS_TYPE_UINT32: {
3384                 uint32_t u;
3385
3386                 r = sd_bus_message_read(m, "u", &u);
3387                 if (r < 0)
3388                         return bus_log_parse_error(r);
3389
3390                 if (streq(name, "MainPID")) {
3391                         if (u > 0) {
3392                                 i->main_pid = (pid_t) u;
3393                                 i->running = true;
3394                         }
3395                 } else if (streq(name, "ControlPID"))
3396                         i->control_pid = (pid_t) u;
3397                 else if (streq(name, "ExecMainPID")) {
3398                         if (u > 0)
3399                                 i->main_pid = (pid_t) u;
3400                 } else if (streq(name, "NAccepted"))
3401                         i->n_accepted = u;
3402                 else if (streq(name, "NConnections"))
3403                         i->n_connections = u;
3404
3405                 break;
3406         }
3407
3408         case SD_BUS_TYPE_INT32: {
3409                 int32_t j;
3410
3411                 r = sd_bus_message_read(m, "i", &j);
3412                 if (r < 0)
3413                         return bus_log_parse_error(r);
3414
3415                 if (streq(name, "ExecMainCode"))
3416                         i->exit_code = (int) j;
3417                 else if (streq(name, "ExecMainStatus"))
3418                         i->exit_status = (int) j;
3419
3420                 break;
3421         }
3422
3423         case SD_BUS_TYPE_UINT64: {
3424                 uint64_t u;
3425
3426                 r = sd_bus_message_read(m, "t", &u);
3427                 if (r < 0)
3428                         return bus_log_parse_error(r);
3429
3430                 if (streq(name, "ExecMainStartTimestamp"))
3431                         i->start_timestamp = (usec_t) u;
3432                 else if (streq(name, "ExecMainExitTimestamp"))
3433                         i->exit_timestamp = (usec_t) u;
3434                 else if (streq(name, "ActiveEnterTimestamp"))
3435                         i->active_enter_timestamp = (usec_t) u;
3436                 else if (streq(name, "InactiveEnterTimestamp"))
3437                         i->inactive_enter_timestamp = (usec_t) u;
3438                 else if (streq(name, "InactiveExitTimestamp"))
3439                         i->inactive_exit_timestamp = (usec_t) u;
3440                 else if (streq(name, "InactiveExitTimestampMonotonic"))
3441                         i->inactive_exit_timestamp_monotonic = (usec_t) u;
3442                 else if (streq(name, "ActiveExitTimestamp"))
3443                         i->active_exit_timestamp = (usec_t) u;
3444                 else if (streq(name, "ConditionTimestamp"))
3445                         i->condition_timestamp = (usec_t) u;
3446
3447                 break;
3448         }
3449
3450         case SD_BUS_TYPE_ARRAY:
3451
3452                 if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && startswith(name, "Exec")) {
3453                         _cleanup_free_ ExecStatusInfo *info = NULL;
3454
3455                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sasbttttuii)");
3456                         if (r < 0)
3457                                 return bus_log_parse_error(r);
3458
3459                         info = new0(ExecStatusInfo, 1);
3460                         if (!info)
3461                                 return log_oom();
3462
3463                         while ((r = exec_status_info_deserialize(m, info)) > 0) {
3464
3465                                 info->name = strdup(name);
3466                                 if (!info->name)
3467                                         log_oom();
3468
3469                                 LIST_PREPEND(exec, i->exec, info);
3470
3471                                 info = new0(ExecStatusInfo, 1);
3472                                 if (!info)
3473                                         log_oom();
3474                         }
3475
3476                         if (r < 0)
3477                                 return bus_log_parse_error(r);
3478
3479                         r = sd_bus_message_exit_container(m);
3480                         if (r < 0)
3481                                 return bus_log_parse_error(r);
3482
3483                         return 0;
3484
3485                 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Listen")) {
3486                         const char *type, *path;
3487
3488                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(ss)");
3489                         if (r < 0)
3490                                 return bus_log_parse_error(r);
3491
3492                         while ((r = sd_bus_message_read(m, "(ss)", &type, &path)) > 0) {
3493
3494                                 r = strv_extend(&i->listen, type);
3495                                 if (r < 0)
3496                                         return r;
3497
3498                                 r = strv_extend(&i->listen, path);
3499                                 if (r < 0)
3500                                         return r;
3501                         }
3502                         if (r < 0)
3503                                 return bus_log_parse_error(r);
3504
3505                         r = sd_bus_message_exit_container(m);
3506                         if (r < 0)
3507                                 return bus_log_parse_error(r);
3508
3509                         return 0;
3510
3511                 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "DropInPaths")) {
3512
3513                         r = sd_bus_message_read_strv(m, &i->dropin_paths);
3514                         if (r < 0)
3515                                 return bus_log_parse_error(r);
3516
3517                 } else if (contents[1] == SD_BUS_TYPE_STRING && streq(name, "Documentation")) {
3518
3519                         r = sd_bus_message_read_strv(m, &i->documentation);
3520                         if (r < 0)
3521                                 return bus_log_parse_error(r);
3522
3523                 } else if (contents[1] == SD_BUS_TYPE_STRUCT_BEGIN && streq(name, "Conditions")) {
3524                         const char *cond, *param;
3525                         int trigger, negate;
3526                         int32_t state;
3527
3528                         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sbbsi)");
3529                         if (r < 0)
3530                                 return bus_log_parse_error(r);
3531
3532                         while ((r = sd_bus_message_read(m, "(sbbsi)", &cond, &trigger, &negate, &param, &state)) > 0) {
3533                                 log_debug("%s %d %d %s %d", cond, trigger, negate, param, state);
3534                                 if (state < 0 && (!trigger || !i->failed_condition)) {
3535                                         i->failed_condition = cond;
3536                                         i->failed_condition_trigger = trigger;
3537                                         i->failed_condition_negate = negate;
3538                                         i->failed_condition_param = param;
3539                                 }
3540                         }
3541                         if (r < 0)
3542                                 return bus_log_parse_error(r);
3543
3544                         r = sd_bus_message_exit_container(m);
3545                         if (r < 0)
3546                                 return bus_log_parse_error(r);
3547
3548                 } else
3549                         goto skip;
3550
3551                 break;
3552
3553         case SD_BUS_TYPE_STRUCT_BEGIN:
3554
3555                 if (streq(name, "LoadError")) {
3556                         const char *n, *message;
3557
3558                         r = sd_bus_message_read(m, "(ss)", &n, &message);
3559                         if (r < 0)
3560                                 return bus_log_parse_error(r);
3561
3562                         if (!isempty(message))
3563                                 i->load_error = message;
3564                 } else
3565                         goto skip;
3566
3567                 break;
3568
3569         default:
3570                 goto skip;
3571         }
3572
3573         return 0;
3574
3575 skip:
3576         r = sd_bus_message_skip(m, contents);
3577         if (r < 0)
3578                 return bus_log_parse_error(r);
3579
3580         return 0;
3581 }
3582
3583 static int print_property(const char *name, sd_bus_message *m, const char *contents) {
3584         int r;
3585
3586         assert(name);
3587         assert(m);
3588
3589         /* This is a low-level property printer, see
3590          * print_status_info() for the nicer output */
3591
3592         if (arg_properties && !strv_find(arg_properties, name)) {
3593                 /* skip what we didn't read */
3594                 r = sd_bus_message_skip(m, contents);
3595                 return r;
3596         }
3597
3598         switch (contents[0]) {
3599
3600         case SD_BUS_TYPE_STRUCT_BEGIN:
3601
3602                 if (contents[1] == SD_BUS_TYPE_UINT32 && streq(name, "Job")) {