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