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