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