chiark / gitweb /
systemctl: check if iterator was initialized succesfully
[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();
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, 25);
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, 25);
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, 16);
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, 25);
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, 16);
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(),20);
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 *m = NULL, *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         /* Device */
2259         const char *sysfs_path;
2260
2261         /* Mount, Automount */
2262         const char *where;
2263
2264         /* Swap */
2265         const char *what;
2266
2267         LIST_HEAD(ExecStatusInfo, exec);
2268 } UnitStatusInfo;
2269
2270 static void print_status_info(UnitStatusInfo *i) {
2271         ExecStatusInfo *p;
2272         const char *on, *off, *ss;
2273         usec_t timestamp;
2274         char since1[FORMAT_TIMESTAMP_RELATIVE_MAX], *s1;
2275         char since2[FORMAT_TIMESTAMP_MAX], *s2;
2276         const char *path;
2277         int flags =
2278                 arg_all * OUTPUT_SHOW_ALL |
2279                 (!on_tty() || pager_have()) * OUTPUT_FULL_WIDTH |
2280                 on_tty() * OUTPUT_COLOR |
2281                 !arg_quiet * OUTPUT_WARN_CUTOFF |
2282                 arg_full * OUTPUT_FULL_WIDTH;
2283
2284         assert(i);
2285
2286         /* This shows pretty information about a unit. See
2287          * print_property() for a low-level property printer */
2288
2289         printf("%s", strna(i->id));
2290
2291         if (i->description && !streq_ptr(i->id, i->description))
2292                 printf(" - %s", i->description);
2293
2294         printf("\n");
2295
2296         if (i->following)
2297                 printf("\t  Follow: unit currently follows state of %s\n", i->following);
2298
2299         if (streq_ptr(i->load_state, "error")) {
2300                 on = ansi_highlight_red(true);
2301                 off = ansi_highlight_red(false);
2302         } else
2303                 on = off = "";
2304
2305         path = i->source_path ? i->source_path : i->fragment_path;
2306
2307         if (i->load_error)
2308                 printf("\t  Loaded: %s%s%s (Reason: %s)\n", on, strna(i->load_state), off, i->load_error);
2309         else if (path && i->unit_file_state)
2310                 printf("\t  Loaded: %s%s%s (%s; %s)\n", on, strna(i->load_state), off, path, i->unit_file_state);
2311         else if (path)
2312                 printf("\t  Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, path);
2313         else
2314                 printf("\t  Loaded: %s%s%s\n", on, strna(i->load_state), off);
2315
2316         ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
2317
2318         if (streq_ptr(i->active_state, "failed")) {
2319                 on = ansi_highlight_red(true);
2320                 off = ansi_highlight_red(false);
2321         } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
2322                 on = ansi_highlight_green(true);
2323                 off = ansi_highlight_green(false);
2324         } else
2325                 on = off = "";
2326
2327         if (ss)
2328                 printf("\t  Active: %s%s (%s)%s",
2329                        on,
2330                        strna(i->active_state),
2331                        ss,
2332                        off);
2333         else
2334                 printf("\t  Active: %s%s%s",
2335                        on,
2336                        strna(i->active_state),
2337                        off);
2338
2339         if (!isempty(i->result) && !streq(i->result, "success"))
2340                 printf(" (Result: %s)", i->result);
2341
2342         timestamp = (streq_ptr(i->active_state, "active")      ||
2343                      streq_ptr(i->active_state, "reloading"))   ? i->active_enter_timestamp :
2344                     (streq_ptr(i->active_state, "inactive")    ||
2345                      streq_ptr(i->active_state, "failed"))      ? i->inactive_enter_timestamp :
2346                     streq_ptr(i->active_state, "activating")    ? i->inactive_exit_timestamp :
2347                                                                   i->active_exit_timestamp;
2348
2349         s1 = format_timestamp_relative(since1, sizeof(since1), timestamp);
2350         s2 = format_timestamp(since2, sizeof(since2), timestamp);
2351
2352         if (s1)
2353                 printf(" since %s; %s\n", s2, s1);
2354         else if (s2)
2355                 printf(" since %s\n", s2);
2356         else
2357                 printf("\n");
2358
2359         if (!i->condition_result && i->condition_timestamp > 0) {
2360                 s1 = format_timestamp_relative(since1, sizeof(since1), i->condition_timestamp);
2361                 s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
2362
2363                 if (s1)
2364                         printf("\t          start condition failed at %s; %s\n", s2, s1);
2365                 else if (s2)
2366                         printf("\t          start condition failed at %s\n", s2);
2367         }
2368
2369         if (i->sysfs_path)
2370                 printf("\t  Device: %s\n", i->sysfs_path);
2371         if (i->where)
2372                 printf("\t   Where: %s\n", i->where);
2373         if (i->what)
2374                 printf("\t    What: %s\n", i->what);
2375
2376         if (!strv_isempty(i->documentation)) {
2377                 char **t;
2378                 bool first = true;
2379
2380                 STRV_FOREACH(t, i->documentation) {
2381                         if (first) {
2382                                 printf("\t    Docs: %s\n", *t);
2383                                 first = false;
2384                         } else
2385                                 printf("\t          %s\n", *t);
2386                 }
2387         }
2388
2389         if (i->accept)
2390                 printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
2391
2392         LIST_FOREACH(exec, p, i->exec) {
2393                 _cleanup_free_ char *t = NULL;
2394                 bool good;
2395
2396                 /* Only show exited processes here */
2397                 if (p->code == 0)
2398                         continue;
2399
2400                 t = strv_join(p->argv, " ");
2401                 printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t));
2402
2403                 good = is_clean_exit_lsb(p->code, p->status, NULL);
2404                 if (!good) {
2405                         on = ansi_highlight_red(true);
2406                         off = ansi_highlight_red(false);
2407                 } else
2408                         on = off = "";
2409
2410                 printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));
2411
2412                 if (p->code == CLD_EXITED) {
2413                         const char *c;
2414
2415                         printf("status=%i", p->status);
2416
2417                         c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD);
2418                         if (c)
2419                                 printf("/%s", c);
2420
2421                 } else
2422                         printf("signal=%s", signal_to_string(p->status));
2423
2424                 printf(")%s\n", off);
2425
2426                 if (i->main_pid == p->pid &&
2427                     i->start_timestamp == p->start_timestamp &&
2428                     i->exit_timestamp == p->start_timestamp)
2429                         /* Let's not show this twice */
2430                         i->main_pid = 0;
2431
2432                 if (p->pid == i->control_pid)
2433                         i->control_pid = 0;
2434         }
2435
2436         if (i->main_pid > 0 || i->control_pid > 0) {
2437                 printf("\t");
2438
2439                 if (i->main_pid > 0) {
2440                         printf("Main PID: %u", (unsigned) i->main_pid);
2441
2442                         if (i->running) {
2443                                 _cleanup_free_ char *t = NULL;
2444                                 get_process_comm(i->main_pid, &t);
2445                                 if (t)
2446                                         printf(" (%s)", t);
2447                         } else if (i->exit_code > 0) {
2448                                 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
2449
2450                                 if (i->exit_code == CLD_EXITED) {
2451                                         const char *c;
2452
2453                                         printf("status=%i", i->exit_status);
2454
2455                                         c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD);
2456                                         if (c)
2457                                                 printf("/%s", c);
2458
2459                                 } else
2460                                         printf("signal=%s", signal_to_string(i->exit_status));
2461                                 printf(")");
2462                         }
2463                 }
2464
2465                 if (i->main_pid > 0 && i->control_pid > 0)
2466                         printf(";");
2467
2468                 if (i->control_pid > 0) {
2469                         _cleanup_free_ char *t = NULL;
2470
2471                         printf(" Control: %u", (unsigned) i->control_pid);
2472
2473                         get_process_comm(i->control_pid, &t);
2474                         if (t)
2475                                 printf(" (%s)", t);
2476                 }
2477
2478                 printf("\n");
2479         }
2480
2481         if (i->status_text)
2482                 printf("\t  Status: \"%s\"\n", i->status_text);
2483
2484         if (i->default_control_group &&
2485             (i->main_pid > 0 || i->control_pid > 0 || cg_is_empty_by_spec(i->default_control_group, false) == 0)) {
2486                 unsigned c;
2487
2488                 printf("\t  CGroup: %s\n", i->default_control_group);
2489
2490                 if (arg_transport != TRANSPORT_SSH) {
2491                         unsigned k = 0;
2492                         pid_t extra[2];
2493
2494                         c = columns();
2495                         if (c > 18)
2496                                 c -= 18;
2497                         else
2498                                 c = 0;
2499
2500                         if (i->main_pid > 0)
2501                                 extra[k++] = i->main_pid;
2502
2503                         if (i->control_pid > 0)
2504                                 extra[k++] = i->control_pid;
2505
2506                         show_cgroup_and_extra_by_spec(i->default_control_group, "\t\t  ", c, false, extra, k, flags);
2507                 }
2508         }
2509
2510         if (i->id && arg_transport != TRANSPORT_SSH) {
2511                 printf("\n");
2512                 if(arg_scope == UNIT_FILE_SYSTEM)
2513                         show_journal_by_unit(stdout,
2514                                              i->id,
2515                                              arg_output,
2516                                              0,
2517                                              i->inactive_exit_timestamp_monotonic,
2518                                              arg_lines,
2519                                              flags);
2520                 else
2521                         show_journal_by_user_unit(stdout,
2522                                                   i->id,
2523                                                   arg_output,
2524                                                   0,
2525                                                   i->inactive_exit_timestamp_monotonic,
2526                                                   arg_lines,
2527                                                   getuid(),
2528                                                   flags);
2529         }
2530
2531         if (i->need_daemon_reload)
2532                 printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %s daemon-reload' recommended.\n",
2533                        ansi_highlight_red(true),
2534                        ansi_highlight_red(false),
2535                        arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");
2536 }
2537
2538 static void show_unit_help(UnitStatusInfo *i) {
2539         char **p;
2540
2541         assert(i);
2542
2543         if (!i->documentation) {
2544                 log_info("Documentation for %s not known.", i->id);
2545                 return;
2546         }
2547
2548         STRV_FOREACH(p, i->documentation) {
2549
2550                 if (startswith(*p, "man:")) {
2551                         size_t k;
2552                         char *e = NULL;
2553                         char _cleanup_free_ *page = NULL, *section = NULL;
2554                         const char *args[4] = { "man", NULL, NULL, NULL };
2555                         pid_t pid;
2556
2557                         k = strlen(*p);
2558
2559                         if ((*p)[k-1] == ')')
2560                                 e = strrchr(*p, '(');
2561
2562                         if (e) {
2563                                 page = strndup((*p) + 4, e - *p - 4);
2564                                 section = strndup(e + 1, *p + k - e - 2);
2565                                 if (!page || !section) {
2566                                         log_oom();
2567                                         return;
2568                                 }
2569
2570                                 args[1] = section;
2571                                 args[2] = page;
2572                         } else
2573                                 args[1] = *p + 4;
2574
2575                         pid = fork();
2576                         if (pid < 0) {
2577                                 log_error("Failed to fork: %m");
2578                                 continue;
2579                         }
2580
2581                         if (pid == 0) {
2582                                 /* Child */
2583                                 execvp(args[0], (char**) args);
2584                                 log_error("Failed to execute man: %m");
2585                                 _exit(EXIT_FAILURE);
2586                         }
2587
2588                         wait_for_terminate(pid, NULL);
2589                 } else
2590                         log_info("Can't show: %s", *p);
2591         }
2592 }
2593
2594 static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) {
2595
2596         assert(name);
2597         assert(iter);
2598         assert(i);
2599
2600         switch (dbus_message_iter_get_arg_type(iter)) {
2601
2602         case DBUS_TYPE_STRING: {
2603                 const char *s;
2604
2605                 dbus_message_iter_get_basic(iter, &s);
2606
2607                 if (!isempty(s)) {
2608                         if (streq(name, "Id"))
2609                                 i->id = s;
2610                         else if (streq(name, "LoadState"))
2611                                 i->load_state = s;
2612                         else if (streq(name, "ActiveState"))
2613                                 i->active_state = s;
2614                         else if (streq(name, "SubState"))
2615                                 i->sub_state = s;
2616                         else if (streq(name, "Description"))
2617                                 i->description = s;
2618                         else if (streq(name, "FragmentPath"))
2619                                 i->fragment_path = s;
2620                         else if (streq(name, "SourcePath"))
2621                                 i->source_path = s;
2622                         else if (streq(name, "DefaultControlGroup"))
2623                                 i->default_control_group = s;
2624                         else if (streq(name, "StatusText"))
2625                                 i->status_text = s;
2626                         else if (streq(name, "SysFSPath"))
2627                                 i->sysfs_path = s;
2628                         else if (streq(name, "Where"))
2629                                 i->where = s;
2630                         else if (streq(name, "What"))
2631                                 i->what = s;
2632                         else if (streq(name, "Following"))
2633                                 i->following = s;
2634                         else if (streq(name, "UnitFileState"))
2635                                 i->unit_file_state = s;
2636                         else if (streq(name, "Result"))
2637                                 i->result = s;
2638                 }
2639
2640                 break;
2641         }
2642
2643         case DBUS_TYPE_BOOLEAN: {
2644                 dbus_bool_t b;
2645
2646                 dbus_message_iter_get_basic(iter, &b);
2647
2648                 if (streq(name, "Accept"))
2649                         i->accept = b;
2650                 else if (streq(name, "NeedDaemonReload"))
2651                         i->need_daemon_reload = b;
2652                 else if (streq(name, "ConditionResult"))
2653                         i->condition_result = b;
2654
2655                 break;
2656         }
2657
2658         case DBUS_TYPE_UINT32: {
2659                 uint32_t u;
2660
2661                 dbus_message_iter_get_basic(iter, &u);
2662
2663                 if (streq(name, "MainPID")) {
2664                         if (u > 0) {
2665                                 i->main_pid = (pid_t) u;
2666                                 i->running = true;
2667                         }
2668                 } else if (streq(name, "ControlPID"))
2669                         i->control_pid = (pid_t) u;
2670                 else if (streq(name, "ExecMainPID")) {
2671                         if (u > 0)
2672                                 i->main_pid = (pid_t) u;
2673                 } else if (streq(name, "NAccepted"))
2674                         i->n_accepted = u;
2675                 else if (streq(name, "NConnections"))
2676                         i->n_connections = u;
2677
2678                 break;
2679         }
2680
2681         case DBUS_TYPE_INT32: {
2682                 int32_t j;
2683
2684                 dbus_message_iter_get_basic(iter, &j);
2685
2686                 if (streq(name, "ExecMainCode"))
2687                         i->exit_code = (int) j;
2688                 else if (streq(name, "ExecMainStatus"))
2689                         i->exit_status = (int) j;
2690
2691                 break;
2692         }
2693
2694         case DBUS_TYPE_UINT64: {
2695                 uint64_t u;
2696
2697                 dbus_message_iter_get_basic(iter, &u);
2698
2699                 if (streq(name, "ExecMainStartTimestamp"))
2700                         i->start_timestamp = (usec_t) u;
2701                 else if (streq(name, "ExecMainExitTimestamp"))
2702                         i->exit_timestamp = (usec_t) u;
2703                 else if (streq(name, "ActiveEnterTimestamp"))
2704                         i->active_enter_timestamp = (usec_t) u;
2705                 else if (streq(name, "InactiveEnterTimestamp"))
2706                         i->inactive_enter_timestamp = (usec_t) u;
2707                 else if (streq(name, "InactiveExitTimestamp"))
2708                         i->inactive_exit_timestamp = (usec_t) u;
2709                 else if (streq(name, "InactiveExitTimestampMonotonic"))
2710                         i->inactive_exit_timestamp_monotonic = (usec_t) u;
2711                 else if (streq(name, "ActiveExitTimestamp"))
2712                         i->active_exit_timestamp = (usec_t) u;
2713                 else if (streq(name, "ConditionTimestamp"))
2714                         i->condition_timestamp = (usec_t) u;
2715
2716                 break;
2717         }
2718
2719         case DBUS_TYPE_ARRAY: {
2720
2721                 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&
2722                     startswith(name, "Exec")) {
2723                         DBusMessageIter sub;
2724
2725                         dbus_message_iter_recurse(iter, &sub);
2726                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2727                                 ExecStatusInfo *info;
2728                                 int r;
2729
2730                                 if (!(info = new0(ExecStatusInfo, 1)))
2731                                         return -ENOMEM;
2732
2733                                 if (!(info->name = strdup(name))) {
2734                                         free(info);
2735                                         return -ENOMEM;
2736                                 }
2737
2738                                 if ((r = exec_status_info_deserialize(&sub, info)) < 0) {
2739                                         free(info);
2740                                         return r;
2741                                 }
2742
2743                                 LIST_PREPEND(ExecStatusInfo, exec, i->exec, info);
2744
2745                                 dbus_message_iter_next(&sub);
2746                         }
2747                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING &&
2748                            streq(name, "Documentation")) {
2749
2750                         DBusMessageIter sub;
2751
2752                         dbus_message_iter_recurse(iter, &sub);
2753                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING) {
2754                                 const char *s;
2755                                 char **l;
2756
2757                                 dbus_message_iter_get_basic(&sub, &s);
2758
2759                                 l = strv_append(i->documentation, s);
2760                                 if (!l)
2761                                         return -ENOMEM;
2762
2763                                 strv_free(i->documentation);
2764                                 i->documentation = l;
2765
2766                                 dbus_message_iter_next(&sub);
2767                         }
2768                 }
2769
2770                 break;
2771         }
2772
2773         case DBUS_TYPE_STRUCT: {
2774
2775                 if (streq(name, "LoadError")) {
2776                         DBusMessageIter sub;
2777                         const char *n, *message;
2778                         int r;
2779
2780                         dbus_message_iter_recurse(iter, &sub);
2781
2782                         r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &n, true);
2783                         if (r < 0)
2784                                 return r;
2785
2786                         r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false);
2787                         if (r < 0)
2788                                 return r;
2789
2790                         if (!isempty(message))
2791                                 i->load_error = message;
2792                 }
2793
2794                 break;
2795         }
2796         }
2797
2798         return 0;
2799 }
2800
2801 static int print_property(const char *name, DBusMessageIter *iter) {
2802         assert(name);
2803         assert(iter);
2804
2805         /* This is a low-level property printer, see
2806          * print_status_info() for the nicer output */
2807
2808         if (arg_property && !strv_find(arg_property, name))
2809                 return 0;
2810
2811         switch (dbus_message_iter_get_arg_type(iter)) {
2812
2813         case DBUS_TYPE_STRUCT: {
2814                 DBusMessageIter sub;
2815                 dbus_message_iter_recurse(iter, &sub);
2816
2817                 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "Job")) {
2818                         uint32_t u;
2819
2820                         dbus_message_iter_get_basic(&sub, &u);
2821
2822                         if (u)
2823                                 printf("%s=%u\n", name, (unsigned) u);
2824                         else if (arg_all)
2825                                 printf("%s=\n", name);
2826
2827                         return 0;
2828                 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {
2829                         const char *s;
2830
2831                         dbus_message_iter_get_basic(&sub, &s);
2832
2833                         if (arg_all || s[0])
2834                                 printf("%s=%s\n", name, s);
2835
2836                         return 0;
2837                 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "LoadError")) {
2838                         const char *a = NULL, *b = NULL;
2839
2840                         if (bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &a, true) >= 0)
2841                                 bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &b, false);
2842
2843                         if (arg_all || !isempty(a) || !isempty(b))
2844                                 printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
2845
2846                         return 0;
2847                 }
2848
2849                 break;
2850         }
2851
2852         case DBUS_TYPE_ARRAY:
2853
2854                 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "EnvironmentFiles")) {
2855                         DBusMessageIter sub, sub2;
2856
2857                         dbus_message_iter_recurse(iter, &sub);
2858                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2859                                 const char *path;
2860                                 dbus_bool_t ignore;
2861
2862                                 dbus_message_iter_recurse(&sub, &sub2);
2863
2864                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
2865                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, false) >= 0)
2866                                         printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
2867
2868                                 dbus_message_iter_next(&sub);
2869                         }
2870
2871                         return 0;
2872
2873                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) {
2874                         DBusMessageIter sub, sub2;
2875
2876                         dbus_message_iter_recurse(iter, &sub);
2877                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2878                                 const char *type, *path;
2879
2880                                 dbus_message_iter_recurse(&sub, &sub2);
2881
2882                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
2883                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)
2884                                         printf("%s=%s\n", type, path);
2885
2886                                 dbus_message_iter_next(&sub);
2887                         }
2888
2889                         return 0;
2890
2891                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {
2892                         DBusMessageIter sub, sub2;
2893
2894                         dbus_message_iter_recurse(iter, &sub);
2895                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2896                                 const char *base;
2897                                 uint64_t value, next_elapse;
2898
2899                                 dbus_message_iter_recurse(&sub, &sub2);
2900
2901                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 &&
2902                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 &&
2903                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) {
2904                                         char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
2905
2906                                         printf("%s={ value=%s ; next_elapse=%s }\n",
2907                                                base,
2908                                                format_timespan(timespan1, sizeof(timespan1), value),
2909                                                format_timespan(timespan2, sizeof(timespan2), next_elapse));
2910                                 }
2911
2912                                 dbus_message_iter_next(&sub);
2913                         }
2914
2915                         return 0;
2916
2917                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "ControlGroupAttributes")) {
2918                         DBusMessageIter sub, sub2;
2919
2920                         dbus_message_iter_recurse(iter, &sub);
2921                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2922                                 const char *controller, *attr, *value;
2923
2924                                 dbus_message_iter_recurse(&sub, &sub2);
2925
2926                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &controller, true) >= 0 &&
2927                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &attr, true) >= 0 &&
2928                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &value, false) >= 0) {
2929
2930                                         printf("ControlGroupAttributes={ controller=%s ; attribute=%s ; value=\"%s\" }\n",
2931                                                controller,
2932                                                attr,
2933                                                value);
2934                                 }
2935
2936                                 dbus_message_iter_next(&sub);
2937                         }
2938
2939                         return 0;
2940
2941                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) {
2942                         DBusMessageIter sub;
2943
2944                         dbus_message_iter_recurse(iter, &sub);
2945                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2946                                 ExecStatusInfo info;
2947
2948                                 zero(info);
2949                                 if (exec_status_info_deserialize(&sub, &info) >= 0) {
2950                                         char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
2951                                         char _cleanup_free_ *t;
2952
2953                                         t = strv_join(info.argv, " ");
2954
2955                                         printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",
2956                                                name,
2957                                                strna(info.path),
2958                                                strna(t),
2959                                                yes_no(info.ignore),
2960                                                strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
2961                                                strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
2962                                                (unsigned) info. pid,
2963                                                sigchld_code_to_string(info.code),
2964                                                info.status,
2965                                                info.code == CLD_EXITED ? "" : "/",
2966                                                strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
2967                                 }
2968
2969                                 free(info.path);
2970                                 strv_free(info.argv);
2971
2972                                 dbus_message_iter_next(&sub);
2973                         }
2974
2975                         return 0;
2976                 }
2977
2978                 break;
2979         }
2980
2981         if (generic_print_property(name, iter, arg_all) > 0)
2982                 return 0;
2983
2984         if (arg_all)
2985                 printf("%s=[unprintable]\n", name);
2986
2987         return 0;
2988 }
2989
2990 static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
2991         _cleanup_free_ DBusMessage *reply = NULL;
2992         const char *interface = "";
2993         int r;
2994         DBusMessageIter iter, sub, sub2, sub3;
2995         UnitStatusInfo info;
2996         ExecStatusInfo *p;
2997
2998         assert(path);
2999         assert(new_line);
3000
3001         zero(info);
3002
3003         r = bus_method_call_with_reply(
3004                         bus,
3005                         "org.freedesktop.systemd1",
3006                         path,
3007                         "org.freedesktop.DBus.Properties",
3008                         "GetAll",
3009                         &reply,
3010                         NULL,
3011                         DBUS_TYPE_STRING, &interface,
3012                         DBUS_TYPE_INVALID);
3013         if (r < 0)
3014                 return r;
3015
3016         if (!dbus_message_iter_init(reply, &iter) ||
3017             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
3018             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)  {
3019                 log_error("Failed to parse reply.");
3020                 return -EIO;
3021         }
3022
3023         dbus_message_iter_recurse(&iter, &sub);
3024
3025         if (*new_line)
3026                 printf("\n");
3027
3028         *new_line = true;
3029
3030         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
3031                 const char *name;
3032
3033                 assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_DICT_ENTRY);
3034                 dbus_message_iter_recurse(&sub, &sub2);
3035
3036                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
3037                     dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
3038                         log_error("Failed to parse reply.");
3039                         return -EIO;
3040                 }
3041
3042                 dbus_message_iter_recurse(&sub2, &sub3);
3043
3044                 if (show_properties)
3045                         r = print_property(name, &sub3);
3046                 else
3047                         r = status_property(name, &sub3, &info);
3048                 if (r < 0) {
3049                         log_error("Failed to parse reply.");
3050                         return -EIO;
3051                 }
3052
3053                 dbus_message_iter_next(&sub);
3054         }
3055
3056         r = 0;
3057
3058         if (!show_properties) {
3059                 if (streq(verb, "help"))
3060                         show_unit_help(&info);
3061                 else
3062                         print_status_info(&info);
3063         }
3064
3065         strv_free(info.documentation);
3066
3067         if (!streq_ptr(info.active_state, "active") &&
3068             !streq_ptr(info.active_state, "reloading") &&
3069             streq(verb, "status"))
3070                 /* According to LSB: "program not running" */
3071                 r = 3;
3072
3073         while ((p = info.exec)) {
3074                 LIST_REMOVE(ExecStatusInfo, exec, info.exec, p);
3075                 exec_status_info_free(p);
3076         }
3077
3078         return r;
3079 }
3080
3081 static int show_one_by_pid(const char *verb, DBusConnection *bus, uint32_t pid, bool *new_line) {
3082         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
3083         const char *path = NULL;
3084         DBusError _cleanup_dbus_error_free_ error;
3085         int r;
3086
3087         dbus_error_init(&error);
3088
3089         r = bus_method_call_with_reply(
3090                         bus,
3091                         "org.freedesktop.systemd1",
3092                         "/org/freedesktop/systemd1",
3093                         "org.freedesktop.systemd1.Manager",
3094                         "GetUnitByPID",
3095                         &reply,
3096                         NULL,
3097                         DBUS_TYPE_UINT32, &pid,
3098                         DBUS_TYPE_INVALID);
3099         if (r < 0)
3100                 return r;
3101
3102         if (!dbus_message_get_args(reply, &error,
3103                                    DBUS_TYPE_OBJECT_PATH, &path,
3104                                    DBUS_TYPE_INVALID)) {
3105                 log_error("Failed to parse reply: %s", bus_error_message(&error));
3106                 return -EIO;
3107         }
3108
3109         r = show_one(verb, bus, path, false, new_line);
3110         return r;
3111 }
3112
3113 static int show_all(const char* verb, DBusConnection *bus, bool show_properties, bool *new_line) {
3114         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
3115         _cleanup_free_ struct unit_info *unit_infos = NULL;
3116         unsigned c = 0;
3117         const struct unit_info *u;
3118         int r;
3119
3120         r = get_unit_list(bus, &reply, &unit_infos, &c);
3121         if (r < 0)
3122                 return r;
3123
3124         for (u = unit_infos; u < unit_infos + c; u++) {
3125                 char _cleanup_free_ *p = NULL;
3126
3127                 if (!output_show_unit(u))
3128                         continue;
3129
3130                 p = unit_dbus_path_from_name(u->id);
3131                 if (!p)
3132                         return log_oom();
3133
3134                 printf("%s -> '%s'\n", u->id, p);
3135
3136                 r = show_one(verb, bus, p, show_properties, new_line);
3137                 if (r != 0)
3138                         return r;
3139         }
3140
3141         return 0;
3142 }
3143
3144 static int show(DBusConnection *bus, char **args) {
3145         int r, ret = 0;
3146         bool show_properties, show_status, new_line = false;
3147         char **name;
3148
3149         assert(bus);
3150         assert(args);
3151
3152         show_properties = streq(args[0], "show");
3153         show_status = streq(args[0], "status");
3154
3155         if (show_properties)
3156                 pager_open_if_enabled();
3157
3158         /* If no argument is specified inspect the manager itself */
3159
3160         if (show_properties && strv_length(args) <= 1)
3161                 return show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line);
3162
3163         if (show_status && strv_length(args) <= 1)
3164                 return show_all(args[0], bus, false, &new_line);
3165
3166         STRV_FOREACH(name, args+1) {
3167                 uint32_t id;
3168
3169                 if (safe_atou32(*name, &id) < 0) {
3170                         _cleanup_free_ char *p = NULL, *n = NULL;
3171                         /* Interpret as unit name */
3172
3173                         n = unit_name_mangle(*name);
3174                         if (!n)
3175                                 return log_oom();
3176
3177                         p = unit_dbus_path_from_name(n);
3178                         if (!p)
3179                                 return log_oom();
3180
3181                         r = show_one(args[0], bus, p, show_properties, &new_line);
3182                         if (r != 0)
3183                                 ret = r;
3184
3185                 } else if (show_properties) {
3186                         _cleanup_free_ char *p = NULL;
3187
3188                         /* Interpret as job id */
3189                         if (asprintf(&p, "/org/freedesktop/systemd1/job/%u", id) < 0)
3190                                 return log_oom();
3191
3192                         r = show_one(args[0], bus, p, show_properties, &new_line);
3193                         if (r != 0)
3194                                 ret = r;
3195
3196                 } else {
3197                         /* Interpret as PID */
3198                         r = show_one_by_pid(args[0], bus, id, &new_line);
3199                         if (r != 0)
3200                                 ret = r;
3201                 }
3202         }
3203
3204         return ret;
3205 }
3206
3207 static int dump(DBusConnection *bus, char **args) {
3208         _cleanup_free_ DBusMessage *reply = NULL;
3209         DBusError error;
3210         int r;
3211         const char *text;
3212
3213         dbus_error_init(&error);
3214
3215         pager_open_if_enabled();
3216
3217         r = bus_method_call_with_reply(
3218                         bus,
3219                         "org.freedesktop.systemd1",
3220                         "/org/freedesktop/systemd1",
3221                         "org.freedesktop.systemd1.Manager",
3222                         "Dump",
3223                         &reply,
3224                         NULL,
3225                         DBUS_TYPE_INVALID);
3226         if (r < 0)
3227                 return r;
3228
3229         if (!dbus_message_get_args(reply, &error,
3230                                    DBUS_TYPE_STRING, &text,
3231                                    DBUS_TYPE_INVALID)) {
3232                 log_error("Failed to parse reply: %s", bus_error_message(&error));
3233                 dbus_error_free(&error);
3234                 return  -EIO;
3235         }
3236
3237         fputs(text, stdout);
3238         return 0;
3239 }
3240
3241 static int snapshot(DBusConnection *bus, char **args) {
3242         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
3243         DBusError error;
3244         int r;
3245         dbus_bool_t cleanup = FALSE;
3246         DBusMessageIter iter, sub;
3247         const char
3248                 *path, *id,
3249                 *interface = "org.freedesktop.systemd1.Unit",
3250                 *property = "Id";
3251         _cleanup_free_ char *n = NULL;
3252
3253         dbus_error_init(&error);
3254
3255         if (strv_length(args) > 1)
3256                 n = snapshot_name_mangle(args[1]);
3257         else
3258                 n = strdup("");
3259         if (!n)
3260                 return log_oom();
3261
3262         r = bus_method_call_with_reply (
3263                         bus,
3264                         "org.freedesktop.systemd1",
3265                         "/org/freedesktop/systemd1",
3266                         "org.freedesktop.systemd1.Manager",
3267                         "CreateSnapshot",
3268                         &reply,
3269                         NULL,
3270                         DBUS_TYPE_STRING, &n,
3271                         DBUS_TYPE_BOOLEAN, &cleanup,
3272                         DBUS_TYPE_INVALID);
3273         if (r < 0)
3274                 return r;
3275
3276         if (!dbus_message_get_args(reply, &error,
3277                                    DBUS_TYPE_OBJECT_PATH, &path,
3278                                    DBUS_TYPE_INVALID)) {
3279                 log_error("Failed to parse reply: %s", bus_error_message(&error));
3280                 dbus_error_free(&error);
3281                 return -EIO;
3282         }
3283
3284         dbus_message_unref(reply);
3285         reply = NULL;
3286
3287         r = bus_method_call_with_reply (
3288                         bus,
3289                         "org.freedesktop.systemd1",
3290                         path,
3291                         "org.freedesktop.DBus.Properties",
3292                         "Get",
3293                         &reply,
3294                         NULL,
3295                         DBUS_TYPE_STRING, &interface,
3296                         DBUS_TYPE_STRING, &property,
3297                         DBUS_TYPE_INVALID);
3298         if (r < 0)
3299                 return r;
3300
3301         if (!dbus_message_iter_init(reply, &iter) ||
3302             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
3303                 log_error("Failed to parse reply.");
3304                 return -EIO;
3305         }
3306
3307         dbus_message_iter_recurse(&iter, &sub);
3308
3309         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
3310                 log_error("Failed to parse reply.");
3311                 return -EIO;
3312         }
3313
3314         dbus_message_iter_get_basic(&sub, &id);
3315
3316         if (!arg_quiet)
3317                 puts(id);
3318
3319         return 0;
3320 }
3321
3322 static int delete_snapshot(DBusConnection *bus, char **args) {
3323         char **name;
3324
3325         assert(args);
3326
3327         STRV_FOREACH(name, args+1) {
3328                 _cleanup_free_ char *n = NULL;
3329                 int r;
3330
3331                 n = snapshot_name_mangle(*name);
3332                 if (!n)
3333                         return log_oom();
3334
3335                 r = bus_method_call_with_reply(
3336                                 bus,
3337                                 "org.freedesktop.systemd1",
3338                                 "/org/freedesktop/systemd1",
3339                                 "org.freedesktop.systemd1.Manager",
3340                                 "RemoveSnapshot",
3341                                 NULL,
3342                                 NULL,
3343                                 DBUS_TYPE_STRING, &n,
3344                                 DBUS_TYPE_INVALID);
3345                 if (r < 0)
3346                         return r;
3347         }
3348
3349         return 0;
3350 }
3351
3352 static int daemon_reload(DBusConnection *bus, char **args) {
3353         int r;
3354         const char *method;
3355         DBusError error;
3356
3357         if (arg_action == ACTION_RELOAD)
3358                 method = "Reload";
3359         else if (arg_action == ACTION_REEXEC)
3360                 method = "Reexecute";
3361         else {
3362                 assert(arg_action == ACTION_SYSTEMCTL);
3363
3364                 method =
3365                         streq(args[0], "clear-jobs")    ||
3366                         streq(args[0], "cancel")        ? "ClearJobs" :
3367                         streq(args[0], "daemon-reexec") ? "Reexecute" :
3368                         streq(args[0], "reset-failed")  ? "ResetFailed" :
3369                         streq(args[0], "halt")          ? "Halt" :
3370                         streq(args[0], "poweroff")      ? "PowerOff" :
3371                         streq(args[0], "reboot")        ? "Reboot" :
3372                         streq(args[0], "kexec")         ? "KExec" :
3373                         streq(args[0], "exit")          ? "Exit" :
3374                                     /* "daemon-reload" */ "Reload";
3375         }
3376
3377         r = bus_method_call_with_reply(
3378                         bus,
3379                         "org.freedesktop.systemd1",
3380                         "/org/freedesktop/systemd1",
3381                         "org.freedesktop.systemd1.Manager",
3382                         method,
3383                         NULL,
3384                         &error,
3385                         DBUS_TYPE_INVALID);
3386
3387         if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
3388                 /* There's always a fallback possible for
3389                  * legacy actions. */
3390                 r = -EADDRNOTAVAIL;
3391         else if (r == -ETIMEDOUT && streq(method, "Reexecute"))
3392                 /* On reexecution, we expect a disconnect, not
3393                  * a reply */
3394                 r = 0;
3395         else if (r < 0)
3396                 log_error("Failed to issue method call: %s", bus_error_message(&error));
3397
3398         dbus_error_free(&error);
3399         return r;
3400 }
3401
3402 static int reset_failed(DBusConnection *bus, char **args) {
3403         int r = 0;
3404         char **name;
3405
3406         if (strv_length(args) <= 1)
3407                 return daemon_reload(bus, args);
3408
3409         STRV_FOREACH(name, args+1) {
3410                 _cleanup_free_ char *n;
3411
3412                 n = unit_name_mangle(*name);
3413                 if (!n)
3414                         return log_oom();
3415
3416                 r = bus_method_call_with_reply(
3417                                 bus,
3418                                 "org.freedesktop.systemd1",
3419                                 "/org/freedesktop/systemd1",
3420                                 "org.freedesktop.systemd1.Manager",
3421                                 "ResetFailedUnit",
3422                                 NULL,
3423                                 NULL,
3424                                 DBUS_TYPE_STRING, &n,
3425                                 DBUS_TYPE_INVALID);
3426                 if (r < 0)
3427                         return r;
3428         }
3429
3430         return 0;
3431 }
3432
3433 static int show_enviroment(DBusConnection *bus, char **args) {
3434         _cleanup_dbus_message_unref_ DBusMessage *reply = NULL;
3435         DBusMessageIter iter, sub, sub2;
3436         int r;
3437         const char
3438                 *interface = "org.freedesktop.systemd1.Manager",
3439                 *property = "Environment";
3440
3441         pager_open_if_enabled();
3442
3443         r = bus_method_call_with_reply(
3444                         bus,
3445                         "org.freedesktop.systemd1",
3446                         "/org/freedesktop/systemd1",
3447                         "org.freedesktop.DBus.Properties",
3448                         "Get",
3449                         &reply,
3450                         NULL,
3451                         DBUS_TYPE_STRING, &interface,
3452                         DBUS_TYPE_STRING, &property,
3453                         DBUS_TYPE_INVALID);
3454         if (r < 0)
3455                 return r;
3456
3457         if (!dbus_message_iter_init(reply, &iter) ||
3458             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
3459                 log_error("Failed to parse reply.");
3460                 return -EIO;
3461         }
3462
3463         dbus_message_iter_recurse(&iter, &sub);
3464
3465         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY ||
3466             dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING)  {
3467                 log_error("Failed to parse reply.");
3468                 return -EIO;
3469         }
3470
3471         dbus_message_iter_recurse(&sub, &sub2);
3472
3473         while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) {
3474                 const char *text;
3475
3476                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
3477                         log_error("Failed to parse reply.");
3478                         return -EIO;
3479                 }
3480
3481                 dbus_message_iter_get_basic(&sub2, &text);
3482                 puts(text);
3483
3484                 dbus_message_iter_next(&sub2);
3485         }
3486
3487         return 0;
3488 }
3489
3490 static int switch_root(DBusConnection *bus, char **args) {
3491         unsigned l;
3492         const char *root;
3493         _cleanup_free_ char *init = NULL;
3494
3495         l = strv_length(args);
3496         if (l < 2 || l > 3) {
3497                 log_error("Wrong number of arguments.");
3498                 return -EINVAL;
3499         }
3500
3501         root = args[1];
3502
3503         if (l >= 3)
3504                 init = strdup(args[2]);
3505         else {
3506                 parse_env_file("/proc/cmdline", WHITESPACE,
3507                                "init", &init,
3508                                NULL);
3509
3510                 if (!init)
3511                         init = strdup("");
3512         }
3513         if (!init)
3514                 return log_oom();
3515
3516         log_debug("switching root - root: %s; init: %s", root, init);
3517
3518         return bus_method_call_with_reply(
3519                         bus,
3520                         "org.freedesktop.systemd1",
3521                         "/org/freedesktop/systemd1",
3522                         "org.freedesktop.systemd1.Manager",
3523                         "SwitchRoot",
3524                         NULL,
3525                         NULL,
3526                         DBUS_TYPE_STRING, &root,
3527                         DBUS_TYPE_STRING, &init,
3528                         DBUS_TYPE_INVALID);
3529 }
3530
3531 static int set_environment(DBusConnection *bus, char **args) {
3532         _cleanup_dbus_message_unref_ DBusMessage *m = NULL, *reply = NULL;
3533         DBusError error;
3534         const char *method;
3535         DBusMessageIter iter;
3536         int r;
3537
3538         assert(bus);
3539         assert(args);
3540
3541         dbus_error_init(&error);
3542
3543         method = streq(args[0], "set-environment")
3544                 ? "SetEnvironment"
3545                 : "UnsetEnvironment";
3546
3547         m = dbus_message_new_method_call(
3548                         "org.freedesktop.systemd1",
3549                         "/org/freedesktop/systemd1",
3550                         "org.freedesktop.systemd1.Manager",
3551                         method);
3552         if (!m)
3553                 return log_oom();
3554
3555         dbus_message_iter_init_append(m, &iter);
3556
3557         r = bus_append_strv_iter(&iter, args + 1);
3558         if (r < 0)
3559                 return log_oom();
3560
3561         reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
3562         if (!reply) {
3563                 log_error("Failed to issue method call: %s", bus_error_message(&error));
3564                 dbus_error_free(&error);
3565                 return -EIO;
3566         }
3567
3568         return 0;
3569 }
3570
3571 static int enable_sysv_units(char **args) {
3572         int r = 0;
3573
3574 #if defined(HAVE_SYSV_COMPAT) && defined(HAVE_CHKCONFIG)
3575         const char *verb = args[0];
3576         unsigned f = 1, t = 1;
3577         LookupPaths paths;
3578
3579         if (arg_scope != UNIT_FILE_SYSTEM)
3580                 return 0;
3581
3582         if (!streq(verb, "enable") &&
3583             !streq(verb, "disable") &&
3584             !streq(verb, "is-enabled"))
3585                 return 0;
3586
3587         /* Processes all SysV units, and reshuffles the array so that
3588          * afterwards only the native units remain */
3589
3590         zero(paths);
3591         r = lookup_paths_init(&paths, SYSTEMD_SYSTEM, false, NULL, NULL, NULL);
3592         if (r < 0)
3593                 return r;
3594
3595         r = 0;
3596         for (f = 1; args[f]; f++) {
3597                 const char *name;
3598                 char *p;
3599                 bool found_native = false, found_sysv;
3600                 unsigned c = 1;
3601                 const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL };
3602                 char **k, *l, *q = NULL;
3603                 int j;
3604                 pid_t pid;
3605                 siginfo_t status;
3606
3607                 name = args[f];
3608
3609                 if (!endswith(name, ".service"))
3610                         continue;
3611
3612                 if (path_is_absolute(name))
3613                         continue;
3614
3615                 STRV_FOREACH(k, paths.unit_path) {
3616                         p = NULL;
3617
3618                         if (!isempty(arg_root))
3619                                 asprintf(&p, "%s/%s/%s", arg_root, *k, name);
3620                         else
3621                                 asprintf(&p, "%s/%s", *k, name);
3622
3623                         if (!p) {
3624                                 r = log_oom();
3625                                 goto finish;
3626                         }
3627
3628                         found_native = access(p, F_OK) >= 0;
3629                         free(p);
3630
3631                         if (found_native)
3632                                 break;
3633                 }
3634
3635                 if (found_native)
3636                         continue;
3637
3638                 p = NULL;
3639                 if (!isempty(arg_root))
3640                         asprintf(&p, "%s/" SYSTEM_SYSVINIT_PATH "/%s", arg_root, name);
3641                 else
3642                         asprintf(&p, SYSTEM_SYSVINIT_PATH "/%s", name);
3643                 if (!p) {
3644                         r = log_oom();
3645                         goto finish;
3646                 }
3647
3648                 p[strlen(p) - sizeof(".service") + 1] = 0;
3649                 found_sysv = access(p, F_OK) >= 0;
3650
3651                 if (!found_sysv) {
3652                         free(p);
3653                         continue;
3654                 }
3655
3656                 /* Mark this entry, so that we don't try enabling it as native unit */
3657                 args[f] = (char*) "";
3658
3659                 log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name);
3660
3661                 if (!isempty(arg_root))
3662                         argv[c++] = q = strappend("--root=", arg_root);
3663
3664                 argv[c++] = path_get_file_name(p);
3665                 argv[c++] =
3666                         streq(verb, "enable") ? "on" :
3667                         streq(verb, "disable") ? "off" : "--level=5";
3668                 argv[c] = NULL;
3669
3670                 l = strv_join((char**)argv, " ");
3671                 if (!l) {
3672                         free(q);
3673                         free(p);
3674                         r = log_oom();
3675                         goto finish;
3676                 }
3677
3678                 log_info("Executing %s", l);
3679                 free(l);
3680
3681                 pid = fork();
3682                 if (pid < 0) {
3683                         log_error("Failed to fork: %m");
3684                         free(p);
3685                         free(q);
3686                         r = -errno;
3687                         goto finish;
3688                 } else if (pid == 0) {
3689                         /* Child */
3690
3691                         execv(argv[0], (char**) argv);
3692                         _exit(EXIT_FAILURE);
3693                 }
3694
3695                 free(p);
3696                 free(q);
3697
3698                 j = wait_for_terminate(pid, &status);
3699                 if (j < 0) {
3700                         log_error("Failed to wait for child: %s", strerror(-r));
3701                         r = j;
3702                         goto finish;
3703                 }
3704
3705                 if (status.si_code == CLD_EXITED) {
3706                         if (streq(verb, "is-enabled")) {
3707                                 if (status.si_status == 0) {
3708                                         if (!arg_quiet)
3709                                                 puts("enabled");
3710                                         r = 1;
3711                                 } else {
3712                                         if (!arg_quiet)
3713                                                 puts("disabled");
3714                                 }
3715
3716                         } else if (status.si_status != 0) {
3717                                 r = -EINVAL;
3718                                 goto finish;
3719                         }
3720                 } else {
3721                         r = -EPROTO;
3722                         goto finish;
3723                 }
3724         }
3725
3726 finish:
3727         lookup_paths_free(&paths);
3728
3729         /* Drop all SysV units */
3730         for (f = 1, t = 1; args[f]; f++) {
3731
3732                 if (isempty(args[f]))
3733                         continue;
3734
3735                 args[t++] = args[f];
3736         }
3737
3738         args[t] = NULL;
3739
3740 #endif
3741         return r;
3742 }
3743
3744 static int mangle_names(char **original_names, char ***mangled_names) {
3745         char **i, **l, **name;
3746
3747         l = new(char*, strv_length(original_names) + 1);
3748         if (!l)
3749                 return log_oom();
3750
3751         i = l;
3752         STRV_FOREACH(name, original_names) {
3753
3754                 /* When enabling units qualified path names are OK,
3755                  * too, hence allow them explicitly. */
3756
3757                 if (is_path(*name))
3758                         *i = strdup(*name);
3759                 else
3760                         *i = unit_name_mangle(*name);
3761
3762                 if (!*i) {
3763                         strv_free(l);
3764                         return log_oom();
3765                 }
3766
3767                 i++;
3768         }
3769
3770         *i = NULL;
3771         *mangled_names = l;
3772
3773         return 0;
3774 }
3775
3776 static int enable_unit(DBusConnection *bus, char **args) {
3777         const char *verb = args[0];
3778         UnitFileChange *changes = NULL;
3779         unsigned n_changes = 0, i;
3780         int carries_install_info = -1;
3781         DBusMessage _cleanup_dbus_message_unref_ *m = NULL, *reply = NULL;
3782         int r;
3783         DBusError _cleanup_dbus_error_free_ error;
3784         char _cleanup_strv_free_ **mangled_names = NULL;
3785
3786         dbus_error_init(&error);
3787
3788         r = enable_sysv_units(args);
3789         if (r < 0)
3790                 return r;
3791
3792         if (!args[1])
3793                 return 0;
3794
3795         if (!bus || avoid_bus()) {
3796                 if (streq(verb, "enable")) {
3797                         r = unit_file_enable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3798                         carries_install_info = r;
3799                 } else if (streq(verb, "disable"))
3800                         r = unit_file_disable(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes);
3801                 else if (streq(verb, "reenable")) {
3802                         r = unit_file_reenable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3803                         carries_install_info = r;
3804                 } else if (streq(verb, "link"))
3805                         r = unit_file_link(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3806                 else if (streq(verb, "preset")) {
3807                         r = unit_file_preset(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3808                         carries_install_info = r;
3809                 } else if (streq(verb, "mask"))
3810                         r = unit_file_mask(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3811                 else if (streq(verb, "unmask"))
3812                         r = unit_file_unmask(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes);
3813                 else
3814                         assert_not_reached("Unknown verb");
3815
3816                 if (r < 0) {
3817                         log_error("Operation failed: %s", strerror(-r));
3818                         goto finish;
3819                 }
3820
3821                 if (!arg_quiet) {
3822                         for (i = 0; i < n_changes; i++) {
3823                                 if (changes[i].type == UNIT_FILE_SYMLINK)
3824                                         log_info("ln -s '%s' '%s'", changes[i].source, changes[i].path);
3825                                 else
3826                                         log_info("rm '%s'", changes[i].path);
3827                         }
3828                 }
3829
3830                 r = 0;
3831         } else {
3832                 const char *method;
3833                 bool send_force = true, expect_carries_install_info = false;
3834                 dbus_bool_t a, b;
3835                 DBusMessageIter iter, sub, sub2;
3836
3837                 if (streq(verb, "enable")) {
3838                         method = "EnableUnitFiles";
3839                         expect_carries_install_info = true;
3840                 } else if (streq(verb, "disable")) {
3841                         method = "DisableUnitFiles";
3842                         send_force = false;
3843                 } else if (streq(verb, "reenable")) {
3844                         method = "ReenableUnitFiles";
3845                         expect_carries_install_info = true;
3846                 } else if (streq(verb, "link"))
3847                         method = "LinkUnitFiles";
3848                 else if (streq(verb, "preset")) {
3849                         method = "PresetUnitFiles";
3850                         expect_carries_install_info = true;
3851                 } else if (streq(verb, "mask"))
3852                         method = "MaskUnitFiles";
3853                 else if (streq(verb, "unmask")) {
3854                         method = "UnmaskUnitFiles";
3855                         send_force = false;
3856                 } else
3857                         assert_not_reached("Unknown verb");
3858
3859                 m = dbus_message_new_method_call(
3860                                 "org.freedesktop.systemd1",
3861                                 "/org/freedesktop/systemd1",
3862                                 "org.freedesktop.systemd1.Manager",
3863                                 method);
3864                 if (!m) {
3865                         r = log_oom();
3866                         goto finish;
3867                 }
3868
3869                 dbus_message_iter_init_append(m, &iter);
3870
3871                 r = mangle_names(args+1, &mangled_names);
3872                 if(r < 0)
3873                         goto finish;
3874
3875                 r = bus_append_strv_iter(&iter, mangled_names);
3876                 if (r < 0) {
3877                         log_error("Failed to append unit files.");
3878                         goto finish;
3879                 }
3880
3881                 a = arg_runtime;
3882                 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &a)) {
3883                         log_error("Failed to append runtime boolean.");
3884                         r = -ENOMEM;
3885                         goto finish;
3886                 }
3887
3888                 if (send_force) {
3889                         b = arg_force;
3890
3891                         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b)) {
3892                                 log_error("Failed to append force boolean.");
3893                                 r = -ENOMEM;
3894                                 goto finish;
3895                         }
3896                 }
3897
3898                 reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
3899                 if (!reply) {
3900                         log_error("Failed to issue method call: %s", bus_error_message(&error));
3901                         r = -EIO;
3902                         goto finish;
3903                 }
3904
3905                 if (!dbus_message_iter_init(reply, &iter)) {
3906                         log_error("Failed to initialize iterator.");
3907                         goto finish;
3908                 }
3909
3910                 if (expect_carries_install_info) {
3911                         r = bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &b, true);
3912                         if (r < 0) {
3913                                 log_error("Failed to parse reply.");
3914                                 goto finish;
3915                         }
3916
3917                         carries_install_info = b;
3918                 }
3919
3920                 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
3921                     dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
3922                         log_error("Failed to parse reply.");
3923                         r = -EIO;
3924                         goto finish;
3925                 }
3926
3927                 dbus_message_iter_recurse(&iter, &sub);
3928                 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
3929                         const char *type, *path, *source;
3930
3931                         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
3932                                 log_error("Failed to parse reply.");
3933                                 r = -EIO;
3934                                 goto finish;
3935                         }
3936
3937                         dbus_message_iter_recurse(&sub, &sub2);
3938
3939                         if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
3940                             bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0 ||
3941                             bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &source, false) < 0) {
3942                                 log_error("Failed to parse reply.");
3943                                 r = -EIO;
3944                                 goto finish;
3945                         }
3946
3947                         if (!arg_quiet) {
3948                                 if (streq(type, "symlink"))
3949                                         log_info("ln -s '%s' '%s'", source, path);
3950                                 else
3951                                         log_info("rm '%s'", path);
3952                         }
3953
3954                         dbus_message_iter_next(&sub);
3955                 }
3956
3957                 /* Try to reload if enabeld */
3958                 if (!arg_no_reload)
3959                         r = daemon_reload(bus, args);
3960         }
3961
3962         if (carries_install_info == 0)
3963                 log_warning("The unit files have no [Install] section. They are not meant to be enabled\n"
3964                             "using systemctl.\n"
3965                             "Possible reasons for having this kind of units are:\n"
3966                             "1) A unit may be statically enabled by being symlinked from another unit's\n"
3967                             "   .wants/ or .requires/ directory.\n"
3968                             "2) A unit's purpose may be to act as a helper for some other unit which has\n"
3969                             "   a requirement dependency on it.\n"
3970                             "3) A unit may be started when needed via activation (socket, path, timer,\n"
3971                             "   D-Bus, udev, scripted systemctl call, ...).\n");
3972
3973 finish:
3974         unit_file_changes_free(changes, n_changes);
3975
3976         return r;
3977 }
3978
3979 static int unit_is_enabled(DBusConnection *bus, char **args) {
3980         DBusError _cleanup_dbus_error_free_ error;
3981         int r;
3982         DBusMessage _cleanup_dbus_message_unref_ *reply = NULL;
3983         bool enabled;
3984         char **name;
3985
3986         dbus_error_init(&error);
3987
3988         r = enable_sysv_units(args);
3989         if (r < 0)
3990                 return r;
3991
3992         enabled = r > 0;
3993
3994         if (!bus || avoid_bus()) {
3995
3996                 STRV_FOREACH(name, args+1) {
3997                         UnitFileState state;
3998
3999                         state = unit_file_get_state(arg_scope, arg_root, *name);
4000                         if (state < 0)
4001                                 return state;
4002
4003                         if (state == UNIT_FILE_ENABLED ||
4004                             state == UNIT_FILE_ENABLED_RUNTIME ||
4005                             state == UNIT_FILE_STATIC)
4006                                 enabled = true;
4007
4008                         if (!arg_quiet)
4009                                 puts(unit_file_state_to_string(state));
4010                 }
4011
4012         } else {
4013                 STRV_FOREACH(name, args+1) {
4014                         const char *s;
4015
4016                         r = bus_method_call_with_reply (
4017                                         bus,
4018                                         "org.freedesktop.systemd1",
4019                                         "/org/freedesktop/systemd1",
4020                                         "org.freedesktop.systemd1.Manager",
4021                                         "GetUnitFileState",
4022                                         &reply,
4023                                         NULL,
4024                                         DBUS_TYPE_STRING, name,
4025                                         DBUS_TYPE_INVALID);
4026                         if (r)
4027                                 return r;
4028
4029                         if (!dbus_message_get_args(reply, &error,
4030                                                    DBUS_TYPE_STRING, &s,
4031                                                    DBUS_TYPE_INVALID)) {
4032                                 log_error("Failed to parse reply: %s", bus_error_message(&error));
4033                                 return -EIO;
4034                         }
4035
4036                         dbus_message_unref(reply);
4037                         reply = NULL;
4038
4039                         if (streq(s, "enabled") ||
4040                             streq(s, "enabled-runtime") ||
4041                             streq(s, "static"))
4042                                 enabled = true;
4043
4044                         if (!arg_quiet)
4045                                 puts(s);
4046                 }
4047         }
4048
4049         return enabled ? 0 : 1;
4050 }
4051
4052 static int systemctl_help(void) {
4053
4054         pager_open_if_enabled();
4055
4056         printf("%s [OPTIONS...] {COMMAND} ...\n\n"
4057                "Query or send control commands to the systemd manager.\n\n"
4058                "  -h --help           Show this help\n"
4059                "     --version        Show package version\n"
4060                "  -t --type=TYPE      List only units of a particular type\n"
4061                "  -p --property=NAME  Show only properties by this name\n"
4062                "  -a --all            Show all units/properties, including dead/empty ones\n"
4063                "     --failed         Show only failed units\n"
4064                "     --full           Don't ellipsize unit names on output\n"
4065                "     --fail           When queueing a new job, fail if conflicting jobs are\n"
4066                "                      pending\n"
4067                "     --ignore-dependencies\n"
4068                "                      When queueing a new job, ignore all its dependencies\n"
4069                "  -i --ignore-inhibitors\n"
4070                "                      When shutting down or sleeping, ignore inhibitors\n"
4071                "     --kill-who=WHO   Who to send signal to\n"
4072                "  -s --signal=SIGNAL  Which signal to send\n"
4073                "  -H --host=[USER@]HOST\n"
4074                "                      Show information for remote host\n"
4075                "  -P --privileged     Acquire privileges before execution\n"
4076                "  -q --quiet          Suppress output\n"
4077                "     --no-block       Do not wait until operation finished\n"
4078                "     --no-wall        Don't send wall message before halt/power-off/reboot\n"
4079                "     --no-reload      When enabling/disabling unit files, don't reload daemon\n"
4080                "                      configuration\n"
4081                "     --no-legend      Do not print a legend (column headers and hints)\n"
4082                "     --no-pager       Do not pipe output into a pager\n"
4083                "     --no-ask-password\n"
4084                "                      Do not ask for system passwords\n"
4085                "     --system         Connect to system manager\n"
4086                "     --user           Connect to user service manager\n"
4087                "     --global         Enable/disable unit files globally\n"
4088                "  -f --force          When enabling unit files, override existing symlinks\n"
4089                "                      When shutting down, execute action immediately\n"
4090                "     --root=PATH      Enable unit files in the specified root directory\n"
4091                "     --runtime        Enable unit files only temporarily until next reboot\n"
4092                "  -n --lines=INTEGER  Journal entries to show\n"
4093                "  -o --output=STRING  Change journal output mode (short, short-monotonic,\n"
4094                "                      verbose, export, json, json-pretty, json-sse, cat)\n\n"
4095                "Unit Commands:\n"
4096                "  list-units                      List loaded units\n"
4097                "  start [NAME...]                 Start (activate) one or more units\n"
4098                "  stop [NAME...]                  Stop (deactivate) one or more units\n"
4099                "  reload [NAME...]                Reload one or more units\n"
4100                "  restart [NAME...]               Start or restart one or more units\n"
4101                "  try-restart [NAME...]           Restart one or more units if active\n"
4102                "  reload-or-restart [NAME...]     Reload one or more units if possible,\n"
4103                "                                  otherwise start or restart\n"
4104                "  reload-or-try-restart [NAME...] Reload one or more units if possible,\n"
4105                "                                  otherwise restart if active\n"
4106                "  isolate [NAME]                  Start one unit and stop all others\n"
4107                "  kill [NAME...]                  Send signal to processes of a unit\n"
4108                "  is-active [NAME...]             Check whether units are active\n"
4109                "  is-failed [NAME...]             Check whether units are failed\n"
4110                "  status [NAME...|PID...]         Show runtime status of one or more units\n"
4111                "  show [NAME...|JOB...]           Show properties of one or more\n"
4112                "                                  units/jobs or the manager\n"
4113                "  help [NAME...|PID...]           Show manual for one or more units\n"
4114                "  reset-failed [NAME...]          Reset failed state for all, one, or more\n"
4115                "                                  units\n"
4116                "  get-cgroup-attr [NAME] [ATTR] ...\n"
4117                "                                  Get control group attrubute\n"
4118                "  set-cgroup-attr [NAME] [ATTR] [VALUE] ...\n"
4119                "                                  Set control group attribute\n"
4120                "  unset-cgroup-attr [NAME] [ATTR...]\n"
4121                "                                  Unset control group attribute\n"
4122                "  set-cgroup [NAME] [CGROUP...]   Add unit to a control group\n"
4123                "  unset-cgroup [NAME] [CGROUP...] Remove unit from a control group\n"
4124                "  load [NAME...]                  Load one or more units\n"
4125                "  list-dependencies [NAME]        Recursively show units which are required\n"
4126                "                                  or wanted by this unit\n\n"
4127                "Unit File Commands:\n"
4128                "  list-unit-files                 List installed unit files\n"
4129                "  enable [NAME...]                Enable one or more unit files\n"
4130                "  disable [NAME...]               Disable one or more unit files\n"
4131                "  reenable [NAME...]              Reenable one or more unit files\n"
4132                "  preset [NAME...]                Enable/disable one or more unit files\n"
4133                "                                  based on preset configuration\n"
4134                "  mask [NAME...]                  Mask one or more units\n"
4135                "  unmask [NAME...]                Unmask one or more units\n"
4136                "  link [PATH...]                  Link one or more units files into\n"
4137                "                                  the search path\n"
4138                "  is-enabled [NAME...]            Check whether unit files are enabled\n\n"
4139                "Job Commands:\n"
4140                "  list-jobs                       List jobs\n"
4141                "  cancel [JOB...]                 Cancel all, one, or more jobs\n\n"
4142                "Status Commands:\n"
4143                "  dump                            Dump server status\n"
4144                "Snapshot Commands:\n"
4145                "  snapshot [NAME]                 Create a snapshot\n"
4146                "  delete [NAME...]                Remove one or more snapshots\n\n"
4147                "Environment Commands:\n"
4148                "  show-environment                Dump environment\n"
4149                "  set-environment [NAME=VALUE...] Set one or more environment variables\n"
4150                "  unset-environment [NAME...]     Unset one or more environment variables\n\n"
4151                "Manager Lifecycle Commands:\n"
4152                "  daemon-reload                   Reload systemd manager configuration\n"
4153                "  daemon-reexec                   Reexecute systemd manager\n\n"
4154                "System Commands:\n"
4155                "  default                         Enter system default mode\n"
4156                "  rescue                          Enter system rescue mode\n"
4157                "  emergency                       Enter system emergency mode\n"
4158                "  halt                            Shut down and halt the system\n"
4159                "  poweroff                        Shut down and power-off the system\n"
4160                "  reboot                          Shut down and reboot the system\n"
4161                "  kexec                           Shut down and reboot the system with kexec\n"
4162                "  exit                            Request user instance exit\n"
4163                "  switch-root [ROOT] [INIT]       Change to a different root file system\n"
4164                "  suspend                         Suspend the system\n"
4165                "  hibernate                       Hibernate the system\n"
4166                "  hybrid-sleep                    Hibernate and suspend the system\n",
4167                program_invocation_short_name);
4168
4169         return 0;
4170 }
4171
4172 static int halt_help(void) {
4173
4174         printf("%s [OPTIONS...]\n\n"
4175                "%s the system.\n\n"
4176                "     --help      Show this help\n"
4177                "     --halt      Halt the machine\n"
4178                "  -p --poweroff  Switch off the machine\n"
4179                "     --reboot    Reboot the machine\n"
4180                "  -f --force     Force immediate halt/power-off/reboot\n"
4181                "  -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
4182                "  -d --no-wtmp   Don't write wtmp record\n"
4183                "     --no-wall   Don't send wall message before halt/power-off/reboot\n",
4184                program_invocation_short_name,
4185                arg_action == ACTION_REBOOT   ? "Reboot" :
4186                arg_action == ACTION_POWEROFF ? "Power off" :
4187                                                "Halt");
4188
4189         return 0;
4190 }
4191
4192 static int shutdown_help(void) {
4193
4194         printf("%s [OPTIONS...] [TIME] [WALL...]\n\n"
4195                "Shut down the system.\n\n"
4196                "     --help      Show this help\n"
4197                "  -H --halt      Halt the machine\n"
4198                "  -P --poweroff  Power-off the machine\n"
4199                "  -r --reboot    Reboot the machine\n"
4200                "  -h             Equivalent to --poweroff, overridden by --halt\n"
4201                "  -k             Don't halt/power-off/reboot, just send warnings\n"
4202                "     --no-wall   Don't send wall message before halt/power-off/reboot\n"
4203                "  -c             Cancel a pending shutdown\n",
4204                program_invocation_short_name);
4205
4206         return 0;
4207 }
4208
4209 static int telinit_help(void) {
4210
4211         printf("%s [OPTIONS...] {COMMAND}\n\n"
4212                "Send control commands to the init daemon.\n\n"
4213                "     --help      Show this help\n"
4214                "     --no-wall   Don't send wall message before halt/power-off/reboot\n\n"
4215                "Commands:\n"
4216                "  0              Power-off the machine\n"
4217                "  6              Reboot the machine\n"
4218                "  2, 3, 4, 5     Start runlevelX.target unit\n"
4219                "  1, s, S        Enter rescue mode\n"
4220                "  q, Q           Reload init daemon configuration\n"
4221                "  u, U           Reexecute init daemon\n",
4222                program_invocation_short_name);
4223
4224         return 0;
4225 }
4226
4227 static int runlevel_help(void) {
4228
4229         printf("%s [OPTIONS...]\n\n"
4230                "Prints the previous and current runlevel of the init system.\n\n"
4231                "     --help      Show this help\n",
4232                program_invocation_short_name);
4233
4234         return 0;
4235 }
4236
4237 static int help_types(void) {
4238         int i;
4239
4240         puts("Available unit types:");
4241         for(i = UNIT_SERVICE; i < _UNIT_TYPE_MAX; i++)
4242                 if (unit_type_table[i])
4243                         puts(unit_type_table[i]);
4244
4245         puts("\nAvailable unit load states: ");
4246         for(i = UNIT_STUB; i < _UNIT_LOAD_STATE_MAX; i++)
4247                 if (unit_type_table[i])
4248                         puts(unit_load_state_table[i]);
4249
4250         return 0;
4251 }
4252
4253 static int systemctl_parse_argv(int argc, char *argv[]) {
4254
4255         enum {
4256                 ARG_FAIL = 0x100,
4257                 ARG_IRREVERSIBLE,
4258                 ARG_IGNORE_DEPENDENCIES,
4259                 ARG_VERSION,
4260                 ARG_USER,
4261                 ARG_SYSTEM,
4262                 ARG_GLOBAL,
4263                 ARG_NO_BLOCK,
4264                 ARG_NO_LEGEND,
4265                 ARG_NO_PAGER,
4266                 ARG_NO_WALL,
4267                 ARG_ROOT,
4268                 ARG_FULL,
4269                 ARG_NO_RELOAD,
4270                 ARG_KILL_WHO,
4271                 ARG_NO_ASK_PASSWORD,
4272                 ARG_FAILED,
4273                 ARG_RUNTIME,
4274                 ARG_FORCE
4275         };
4276
4277         static const struct option options[] = {
4278                 { "help",      no_argument,       NULL, 'h'           },
4279                 { "version",   no_argument,       NULL, ARG_VERSION   },
4280                 { "type",      required_argument, NULL, 't'           },
4281                 { "property",  required_argument, NULL, 'p'           },
4282                 { "all",       no_argument,       NULL, 'a'           },
4283                 { "failed",    no_argument,       NULL, ARG_FAILED    },
4284                 { "full",      no_argument,       NULL, ARG_FULL      },
4285                 { "fail",      no_argument,       NULL, ARG_FAIL      },
4286                 { "irreversible", no_argument,    NULL, ARG_IRREVERSIBLE },
4287                 { "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES },
4288                 { "ignore-inhibitors", no_argument, NULL, 'i'         },
4289                 { "user",      no_argument,       NULL, ARG_USER      },
4290                 { "system",    no_argument,       NULL, ARG_SYSTEM    },
4291                 { "global",    no_argument,       NULL, ARG_GLOBAL    },
4292                 { "no-block",  no_argument,       NULL, ARG_NO_BLOCK  },
4293                 { "no-legend", no_argument,       NULL, ARG_NO_LEGEND },
4294                 { "no-pager",  no_argument,       NULL, ARG_NO_PAGER  },
4295                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL   },
4296                 { "quiet",     no_argument,       NULL, 'q'           },
4297                 { "root",      required_argument, NULL, ARG_ROOT      },
4298                 { "force",     no_argument,       NULL, ARG_FORCE     },
4299                 { "no-reload", no_argument,       NULL, ARG_NO_RELOAD },
4300                 { "kill-who",  required_argument, NULL, ARG_KILL_WHO  },
4301                 { "signal",    required_argument, NULL, 's'           },
4302                 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
4303                 { "host",      required_argument, NULL, 'H'           },
4304                 { "privileged",no_argument,       NULL, 'P'           },
4305                 { "runtime",   no_argument,       NULL, ARG_RUNTIME   },
4306                 { "lines",     required_argument, NULL, 'n'           },
4307                 { "output",    required_argument, NULL, 'o'           },
4308                 { NULL,        0,                 NULL, 0             }
4309         };
4310
4311         int c;
4312
4313         assert(argc >= 0);
4314         assert(argv);
4315
4316         while ((c = getopt_long(argc, argv, "ht:p:aqfs:H:Pn:o:i", options, NULL)) >= 0) {
4317
4318                 switch (c) {
4319
4320                 case 'h':
4321                         systemctl_help();
4322                         return 0;
4323
4324                 case ARG_VERSION:
4325                         puts(PACKAGE_STRING);
4326                         puts(SYSTEMD_FEATURES);
4327                         return 0;
4328
4329                 case 't':
4330                         if (streq(optarg, "help")) {
4331                                 help_types();
4332                                 return 0;
4333                         }
4334
4335                         if (unit_type_from_string(optarg) >= 0) {
4336                                 arg_type = optarg;
4337                                 break;
4338                         }
4339                         if (unit_load_state_from_string(optarg) >= 0) {
4340                                 arg_load_state = optarg;
4341                                 break;
4342                         }
4343                         log_error("Unkown unit type or load state '%s'.",
4344                                   optarg);
4345                         log_info("Use -t help to see a list of allowed values.");
4346                         return -EINVAL;
4347                 case 'p': {
4348                         char *word, *state;
4349                         size_t size;
4350                         /* Make sure that if the empty property list
4351                            was specified, we won't show any properties. */
4352                         const char *source = isempty(optarg) ? " " : optarg;
4353
4354                         FOREACH_WORD_SEPARATOR(word, size, source, ",", state) {
4355                                 char _cleanup_free_ *prop;
4356                                 char **tmp;
4357
4358                                 prop = strndup(word, size);
4359                                 if (!prop)
4360                                         return -ENOMEM;
4361
4362                                 tmp = strv_append(arg_property, prop);
4363                                 if (!tmp)
4364                                         return -ENOMEM;
4365
4366                                 strv_free(arg_property);
4367                                 arg_property = tmp;
4368                         }
4369
4370                         /* If the user asked for a particular
4371                          * property, show it to him, even if it is
4372                          * empty. */
4373                         arg_all = true;
4374
4375                         break;
4376                 }
4377
4378                 case 'a':
4379                         arg_all = true;
4380                         break;
4381
4382                 case ARG_FAIL:
4383                         arg_job_mode = "fail";
4384                         break;
4385
4386                 case ARG_IRREVERSIBLE:
4387                         arg_job_mode = "replace-irreversibly";
4388                         break;
4389
4390                 case ARG_IGNORE_DEPENDENCIES:
4391                         arg_job_mode = "ignore-dependencies";
4392                         break;
4393
4394                 case ARG_USER:
4395                         arg_scope = UNIT_FILE_USER;
4396                         break;
4397
4398                 case ARG_SYSTEM:
4399                         arg_scope = UNIT_FILE_SYSTEM;
4400                         break;
4401
4402                 case ARG_GLOBAL:
4403                         arg_scope = UNIT_FILE_GLOBAL;
4404                         break;
4405
4406                 case ARG_NO_BLOCK:
4407                         arg_no_block = true;
4408                         break;
4409
4410                 case ARG_NO_LEGEND:
4411                         arg_no_legend = true;
4412                         break;
4413
4414                 case ARG_NO_PAGER:
4415                         arg_no_pager = true;
4416                         break;
4417
4418                 case ARG_NO_WALL:
4419                         arg_no_wall = true;
4420                         break;
4421
4422                 case ARG_ROOT:
4423                         arg_root = optarg;
4424                         break;
4425
4426                 case ARG_FULL:
4427                         arg_full = true;
4428                         break;
4429
4430                 case ARG_FAILED:
4431                         arg_failed = true;
4432                         break;
4433
4434                 case 'q':
4435                         arg_quiet = true;
4436                         break;
4437
4438                 case ARG_FORCE:
4439                         arg_force ++;
4440                         break;
4441
4442                 case 'f':
4443                         arg_force ++;
4444                         break;
4445
4446                 case ARG_NO_RELOAD:
4447                         arg_no_reload = true;
4448                         break;
4449
4450                 case ARG_KILL_WHO:
4451                         arg_kill_who = optarg;
4452                         break;
4453
4454                 case 's':
4455                         if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) {
4456                                 log_error("Failed to parse signal string %s.", optarg);
4457                                 return -EINVAL;
4458                         }
4459                         break;
4460
4461                 case ARG_NO_ASK_PASSWORD:
4462                         arg_ask_password = false;
4463                         break;
4464
4465                 case 'P':
4466                         arg_transport = TRANSPORT_POLKIT;
4467                         break;
4468
4469                 case 'H':
4470                         arg_transport = TRANSPORT_SSH;
4471                         arg_host = optarg;
4472                         break;
4473
4474                 case ARG_RUNTIME:
4475                         arg_runtime = true;
4476                         break;
4477
4478                 case 'n':
4479                         if (safe_atou(optarg, &arg_lines) < 0) {
4480                                 log_error("Failed to parse lines '%s'", optarg);
4481                                 return -EINVAL;
4482                         }
4483                         break;
4484
4485                 case 'o':
4486                         arg_output = output_mode_from_string(optarg);
4487                         if (arg_output < 0) {
4488                                 log_error("Unknown output '%s'.", optarg);
4489                                 return -EINVAL;
4490                         }
4491                         break;
4492
4493                 case 'i':
4494                         arg_ignore_inhibitors = true;
4495                         break;
4496
4497                 case '?':
4498                         return -EINVAL;
4499
4500                 default:
4501                         log_error("Unknown option code '%c'.", c);
4502                         return -EINVAL;
4503                 }
4504         }
4505
4506         if (arg_transport != TRANSPORT_NORMAL && arg_scope != UNIT_FILE_SYSTEM) {
4507                 log_error("Cannot access user instance remotely.");
4508                 return -EINVAL;
4509         }
4510
4511         return 1;
4512 }
4513
4514 static int halt_parse_argv(int argc, char *argv[]) {
4515
4516         enum {
4517                 ARG_HELP = 0x100,
4518                 ARG_HALT,
4519                 ARG_REBOOT,
4520                 ARG_NO_WALL
4521         };
4522
4523         static const struct option options[] = {
4524                 { "help",      no_argument,       NULL, ARG_HELP    },
4525                 { "halt",      no_argument,       NULL, ARG_HALT    },
4526                 { "poweroff",  no_argument,       NULL, 'p'         },
4527                 { "reboot",    no_argument,       NULL, ARG_REBOOT  },
4528                 { "force",     no_argument,       NULL, 'f'         },
4529                 { "wtmp-only", no_argument,       NULL, 'w'         },
4530                 { "no-wtmp",   no_argument,       NULL, 'd'         },
4531                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
4532                 { NULL,        0,                 NULL, 0           }
4533         };
4534
4535         int c, runlevel;
4536
4537         assert(argc >= 0);
4538         assert(argv);
4539
4540         if (utmp_get_runlevel(&runlevel, NULL) >= 0)
4541                 if (runlevel == '0' || runlevel == '6')
4542                         arg_force = 2;
4543
4544         while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) {
4545                 switch (c) {
4546
4547                 case ARG_HELP:
4548                         halt_help();
4549                         return 0;
4550
4551                 case ARG_HALT:
4552                         arg_action = ACTION_HALT;
4553                         break;
4554
4555                 case 'p':
4556                         if (arg_action != ACTION_REBOOT)
4557                                 arg_action = ACTION_POWEROFF;
4558                         break;
4559
4560                 case ARG_REBOOT:
4561                         arg_action = ACTION_REBOOT;
4562                         break;
4563
4564                 case 'f':
4565                         arg_force = 2;
4566                         break;
4567
4568                 case 'w':
4569                         arg_dry = true;
4570                         break;
4571
4572                 case 'd':
4573                         arg_no_wtmp = true;
4574                         break;
4575
4576                 case ARG_NO_WALL:
4577                         arg_no_wall = true;
4578                         break;
4579
4580                 case 'i':
4581                 case 'h':
4582                 case 'n':
4583                         /* Compatibility nops */
4584                         break;
4585
4586                 case '?':
4587                         return -EINVAL;
4588
4589                 default:
4590                         log_error("Unknown option code '%c'.", c);
4591                         return -EINVAL;
4592                 }
4593         }
4594
4595         if (optind < argc) {
4596                 log_error("Too many arguments.");
4597                 return -EINVAL;
4598         }
4599
4600         return 1;
4601 }
4602
4603 static int parse_time_spec(const char *t, usec_t *_u) {
4604         assert(t);
4605         assert(_u);
4606
4607         if (streq(t, "now"))
4608                 *_u = 0;
4609         else if (!strchr(t, ':')) {
4610                 uint64_t u;
4611
4612                 if (safe_atou64(t, &u) < 0)
4613                         return -EINVAL;
4614
4615                 *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u;
4616         } else {
4617                 char *e = NULL;
4618                 long hour, minute;
4619                 struct tm tm;
4620                 time_t s;
4621                 usec_t n;
4622
4623                 errno = 0;
4624                 hour = strtol(t, &e, 10);
4625                 if (errno != 0 || *e != ':' || hour < 0 || hour > 23)
4626                         return -EINVAL;
4627
4628                 minute = strtol(e+1, &e, 10);
4629                 if (errno != 0 || *e != 0 || minute < 0 || minute > 59)
4630                         return -EINVAL;
4631
4632                 n = now(CLOCK_REALTIME);
4633                 s = (time_t) (n / USEC_PER_SEC);
4634
4635                 zero(tm);
4636                 assert_se(localtime_r(&s, &tm));
4637
4638                 tm.tm_hour = (int) hour;
4639                 tm.tm_min = (int) minute;
4640                 tm.tm_sec = 0;
4641
4642                 assert_se(s = mktime(&tm));
4643
4644                 *_u = (usec_t) s * USEC_PER_SEC;
4645
4646                 while (*_u <= n)
4647                         *_u += USEC_PER_DAY;
4648         }
4649
4650         return 0;
4651 }
4652
4653 static int shutdown_parse_argv(int argc, char *argv[]) {
4654
4655         enum {
4656                 ARG_HELP = 0x100,
4657                 ARG_NO_WALL
4658         };
4659
4660         static const struct option options[] = {
4661                 { "help",      no_argument,       NULL, ARG_HELP    },
4662                 { "halt",      no_argument,       NULL, 'H'         },
4663                 { "poweroff",  no_argument,       NULL, 'P'         },
4664                 { "reboot",    no_argument,       NULL, 'r'         },
4665                 { "kexec",     no_argument,       NULL, 'K'         }, /* not documented extension */
4666                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
4667                 { NULL,        0,                 NULL, 0           }
4668         };
4669
4670         int c, r;
4671
4672         assert(argc >= 0);
4673         assert(argv);
4674
4675         while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0) {
4676                 switch (c) {
4677
4678                 case ARG_HELP:
4679                         shutdown_help();
4680                         return 0;
4681
4682                 case 'H':
4683                         arg_action = ACTION_HALT;
4684                         break;
4685
4686                 case 'P':
4687                         arg_action = ACTION_POWEROFF;
4688                         break;
4689
4690                 case 'r':
4691                         if (kexec_loaded())
4692                                 arg_action = ACTION_KEXEC;
4693                         else
4694                                 arg_action = ACTION_REBOOT;
4695                         break;
4696
4697                 case 'K':
4698                         arg_action = ACTION_KEXEC;
4699                         break;
4700
4701                 case 'h':
4702                         if (arg_action != ACTION_HALT)
4703                                 arg_action = ACTION_POWEROFF;
4704                         break;
4705
4706                 case 'k':
4707                         arg_dry = true;
4708                         break;
4709
4710                 case ARG_NO_WALL:
4711                         arg_no_wall = true;
4712                         break;
4713
4714                 case 't':
4715                 case 'a':
4716                         /* Compatibility nops */
4717                         break;
4718
4719                 case 'c':
4720                         arg_action = ACTION_CANCEL_SHUTDOWN;
4721                         break;
4722
4723                 case '?':
4724                         return -EINVAL;
4725
4726                 default:
4727                         log_error("Unknown option code '%c'.", c);
4728                         return -EINVAL;
4729                 }
4730         }
4731
4732         if (argc > optind && arg_action != ACTION_CANCEL_SHUTDOWN) {
4733                 r = parse_time_spec(argv[optind], &arg_when);
4734                 if (r < 0) {
4735                         log_error("Failed to parse time specification: %s", argv[optind]);
4736                         return r;
4737                 }
4738         } else
4739                 arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
4740
4741         if (argc > optind && arg_action == ACTION_CANCEL_SHUTDOWN)
4742                 /* No time argument for shutdown cancel */
4743                 arg_wall = argv + optind;
4744         else if (argc > optind + 1)
4745                 /* We skip the time argument */
4746                 arg_wall = argv + optind + 1;
4747
4748         optind = argc;
4749
4750         return 1;
4751 }
4752
4753 static int telinit_parse_argv(int argc, char *argv[]) {
4754
4755         enum {
4756                 ARG_HELP = 0x100,
4757                 ARG_NO_WALL
4758         };
4759
4760         static const struct option options[] = {
4761                 { "help",      no_argument,       NULL, ARG_HELP    },
4762                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
4763                 { NULL,        0,                 NULL, 0           }
4764         };
4765
4766         static const struct {
4767                 char from;
4768                 enum action to;
4769         } table[] = {
4770                 { '0', ACTION_POWEROFF },
4771                 { '6', ACTION_REBOOT },
4772                 { '1', ACTION_RESCUE },
4773                 { '2', ACTION_RUNLEVEL2 },
4774                 { '3', ACTION_RUNLEVEL3 },
4775                 { '4', ACTION_RUNLEVEL4 },
4776                 { '5', ACTION_RUNLEVEL5 },
4777                 { 's', ACTION_RESCUE },
4778                 { 'S', ACTION_RESCUE },
4779                 { 'q', ACTION_RELOAD },
4780                 { 'Q', ACTION_RELOAD },
4781                 { 'u', ACTION_REEXEC },
4782                 { 'U', ACTION_REEXEC }
4783         };
4784
4785         unsigned i;
4786         int c;
4787
4788         assert(argc >= 0);
4789         assert(argv);
4790
4791         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
4792                 switch (c) {
4793
4794                 case ARG_HELP:
4795                         telinit_help();
4796                         return 0;
4797
4798                 case ARG_NO_WALL:
4799                         arg_no_wall = true;
4800                         break;
4801
4802                 case '?':
4803                         return -EINVAL;
4804
4805                 default:
4806                         log_error("Unknown option code '%c'.", c);
4807                         return -EINVAL;
4808                 }
4809         }
4810
4811         if (optind >= argc) {
4812                 telinit_help();
4813                 return -EINVAL;
4814         }
4815
4816         if (optind + 1 < argc) {
4817                 log_error("Too many arguments.");
4818                 return -EINVAL;
4819         }
4820
4821         if (strlen(argv[optind]) != 1) {
4822                 log_error("Expected single character argument.");
4823                 return -EINVAL;
4824         }
4825
4826         for (i = 0; i < ELEMENTSOF(table); i++)
4827                 if (table[i].from == argv[optind][0])
4828                         break;
4829
4830         if (i >= ELEMENTSOF(table)) {
4831                 log_error("Unknown command '%s'.", argv[optind]);
4832                 return -EINVAL;
4833         }
4834
4835         arg_action = table[i].to;
4836
4837         optind ++;
4838
4839         return 1;
4840 }
4841
4842 static int runlevel_parse_argv(int argc, char *argv[]) {
4843
4844         enum {
4845                 ARG_HELP = 0x100,
4846         };
4847
4848         static const struct option options[] = {
4849                 { "help",      no_argument,       NULL, ARG_HELP    },
4850                 { NULL,        0,                 NULL, 0           }
4851         };
4852
4853         int c;
4854
4855         assert(argc >= 0);
4856         assert(argv);
4857
4858         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
4859                 switch (c) {
4860
4861                 case ARG_HELP:
4862                         runlevel_help();
4863                         return 0;
4864
4865                 case '?':
4866                         return -EINVAL;
4867
4868                 default:
4869                         log_error("Unknown option code '%c'.", c);
4870                         return -EINVAL;
4871                 }
4872         }
4873
4874         if (optind < argc) {
4875                 log_error("Too many arguments.");
4876                 return -EINVAL;
4877         }
4878
4879         return 1;
4880 }
4881
4882 static int parse_argv(int argc, char *argv[]) {
4883         assert(argc >= 0);
4884         assert(argv);
4885
4886         if (program_invocation_short_name) {
4887
4888                 if (strstr(program_invocation_short_name, "halt")) {
4889                         arg_action = ACTION_HALT;
4890                         return halt_parse_argv(argc, argv);
4891                 } else if (strstr(program_invocation_short_name, "poweroff")) {
4892                         arg_action = ACTION_POWEROFF;
4893                         return halt_parse_argv(argc, argv);
4894                 } else if (strstr(program_invocation_short_name, "reboot")) {
4895                         if (kexec_loaded())
4896                                 arg_action = ACTION_KEXEC;
4897                         else
4898                                 arg_action = ACTION_REBOOT;
4899                         return halt_parse_argv(argc, argv);
4900                 } else if (strstr(program_invocation_short_name, "shutdown")) {
4901                         arg_action = ACTION_POWEROFF;
4902                         return shutdown_parse_argv(argc, argv);
4903                 } else if (strstr(program_invocation_short_name, "init")) {
4904
4905                         if (sd_booted() > 0) {
4906                                 arg_action = ACTION_INVALID;
4907                                 return telinit_parse_argv(argc, argv);
4908                         } else {
4909                                 /* Hmm, so some other init system is
4910                                  * running, we need to forward this
4911                                  * request to it. For now we simply
4912                                  * guess that it is Upstart. */
4913
4914                                 execv("/lib/upstart/telinit", argv);
4915
4916                                 log_error("Couldn't find an alternative telinit implementation to spawn.");
4917                                 return -EIO;
4918                         }
4919
4920                 } else if (strstr(program_invocation_short_name, "runlevel")) {
4921                         arg_action = ACTION_RUNLEVEL;
4922                         return runlevel_parse_argv(argc, argv);
4923                 }
4924         }
4925
4926         arg_action = ACTION_SYSTEMCTL;
4927         return systemctl_parse_argv(argc, argv);
4928 }
4929
4930 static int action_to_runlevel(void) {
4931
4932         static const char table[_ACTION_MAX] = {
4933                 [ACTION_HALT] =      '0',
4934                 [ACTION_POWEROFF] =  '0',
4935                 [ACTION_REBOOT] =    '6',
4936                 [ACTION_RUNLEVEL2] = '2',
4937                 [ACTION_RUNLEVEL3] = '3',
4938                 [ACTION_RUNLEVEL4] = '4',
4939                 [ACTION_RUNLEVEL5] = '5',
4940                 [ACTION_RESCUE] =    '1'
4941         };
4942
4943         assert(arg_action < _ACTION_MAX);
4944
4945         return table[arg_action];
4946 }
4947
4948 static int talk_upstart(void) {
4949         DBusMessage _cleanup_dbus_message_unref_ *m = NULL, *reply = NULL;
4950         DBusError _cleanup_dbus_error_free_ error;
4951         int previous, rl, r;
4952         char
4953                 env1_buf[] = "RUNLEVEL=X",
4954                 env2_buf[] = "PREVLEVEL=X";
4955         char *env1 = env1_buf, *env2 = env2_buf;
4956         const char *emit = "runlevel";
4957         dbus_bool_t b_false = FALSE;
4958         DBusMessageIter iter, sub;
4959         DBusConnection *bus;
4960
4961         dbus_error_init(&error);
4962
4963         if (!(rl = action_to_runlevel()))
4964                 return 0;
4965
4966         if (utmp_get_runlevel(&previous, NULL) < 0)
4967                 previous = 'N';
4968
4969         if (!(bus = dbus_connection_open_private("unix:abstract=/com/ubuntu/upstart", &error))) {
4970                 if (dbus_error_has_name(&error, DBUS_ERROR_NO_SERVER)) {
4971                         r = 0;
4972                         goto finish;
4973                 }
4974
4975                 log_error("Failed to connect to Upstart bus: %s", bus_error_message(&error));
4976                 r = -EIO;
4977                 goto finish;
4978         }
4979
4980         if ((r = bus_check_peercred(bus)) < 0) {
4981                 log_error("Failed to verify owner of bus.");
4982                 goto finish;
4983         }
4984
4985         if (!(m = dbus_message_new_method_call(
4986                               "com.ubuntu.Upstart",
4987                               "/com/ubuntu/Upstart",
4988                               "com.ubuntu.Upstart0_6",
4989                               "EmitEvent"))) {
4990
4991                 log_error("Could not allocate message.");
4992                 r = -ENOMEM;
4993                 goto finish;
4994         }
4995
4996         dbus_message_iter_init_append(m, &iter);
4997
4998         env1_buf[sizeof(env1_buf)-2] = rl;
4999         env2_buf[sizeof(env2_buf)-2] = previous;
5000
5001         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &emit) ||
5002             !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub) ||
5003             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env1) ||
5004             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env2) ||
5005             !dbus_message_iter_close_container(&iter, &sub) ||
5006             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b_false)) {
5007                 log_error("Could not append arguments to message.");
5008                 r = -ENOMEM;
5009                 goto finish;
5010         }
5011
5012         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
5013
5014                 if (bus_error_is_no_service(&error)) {
5015                         r = -EADDRNOTAVAIL;
5016                         goto finish;
5017                 }
5018
5019                 log_error("Failed to issue method call: %s", bus_error_message(&error));
5020                 r = -EIO;
5021                 goto finish;
5022         }
5023
5024         r = 1;
5025
5026 finish:
5027         if (bus) {
5028                 dbus_connection_flush(bus);
5029                 dbus_connection_close(bus);
5030                 dbus_connection_unref(bus);
5031         }
5032
5033         return r;
5034 }
5035
5036 static int talk_initctl(void) {
5037         struct init_request request;
5038         int r, fd;
5039         char rl;
5040
5041         if (!(rl = action_to_runlevel()))
5042                 return 0;
5043
5044         zero(request);
5045         request.magic = INIT_MAGIC;
5046         request.sleeptime = 0;
5047         request.cmd = INIT_CMD_RUNLVL;
5048         request.runlevel = rl;
5049
5050         if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) {
5051
5052                 if (errno == ENOENT)
5053                         return 0;
5054
5055                 log_error("Failed to open "INIT_FIFO": %m");
5056                 return -errno;
5057         }
5058
5059         errno = 0;
5060         r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
5061         close_nointr_nofail(fd);
5062
5063         if (r < 0) {
5064                 log_error("Failed to write to "INIT_FIFO": %m");
5065                 return errno ? -errno : -EIO;
5066         }
5067
5068         return 1;
5069 }
5070
5071 static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
5072
5073         static const struct {
5074                 const char* verb;
5075                 const enum {
5076                         MORE,
5077                         LESS,
5078                         EQUAL
5079                 } argc_cmp;
5080                 const int argc;
5081                 int (* const dispatch)(DBusConnection *bus, char **args);
5082         } verbs[] = {
5083                 { "list-units",            LESS,  1, list_units        },
5084                 { "list-unit-files",       EQUAL, 1, list_unit_files   },
5085                 { "list-jobs",             EQUAL, 1, list_jobs         },
5086                 { "clear-jobs",            EQUAL, 1, daemon_reload     },
5087                 { "load",                  MORE,  2, load_unit         },
5088                 { "cancel",                MORE,  2, cancel_job        },
5089                 { "start",                 MORE,  2, start_unit        },
5090                 { "stop",                  MORE,  2, start_unit        },
5091                 { "condstop",              MORE,  2, start_unit        }, /* For compatibility with ALTLinux */
5092                 { "reload",                MORE,  2, start_unit        },
5093                 { "restart",               MORE,  2, start_unit        },
5094                 { "try-restart",           MORE,  2, start_unit        },
5095                 { "reload-or-restart",     MORE,  2, start_unit        },
5096                 { "reload-or-try-restart", MORE,  2, start_unit        },
5097                 { "force-reload",          MORE,  2, start_unit        }, /* For compatibility with SysV */
5098                 { "condreload",            MORE,  2, start_unit        }, /* For compatibility with ALTLinux */
5099                 { "condrestart",           MORE,  2, start_unit        }, /* For compatibility with RH */
5100                 { "isolate",               EQUAL, 2, start_unit        },
5101                 { "set-cgroup",            MORE,  3, set_cgroup        },
5102                 { "unset-cgroup",          MORE,  3, set_cgroup        },
5103                 { "get-cgroup-attr",       MORE,  3, get_cgroup_attr   },
5104                 { "set-cgroup-attr",       MORE,  4, set_cgroup_attr   },
5105                 { "unset-cgroup-attr",     MORE,  3, set_cgroup        },
5106                 { "kill",                  MORE,  2, kill_unit         },
5107                 { "is-active",             MORE,  2, check_unit_active },
5108                 { "check",                 MORE,  2, check_unit_active },
5109                 { "is-failed",             MORE,  2, check_unit_failed },
5110                 { "show",                  MORE,  1, show              },
5111                 { "status",                MORE,  1, show              },
5112                 { "help",                  MORE,  2, show              },
5113                 { "dump",                  EQUAL, 1, dump              },
5114                 { "snapshot",              LESS,  2, snapshot          },
5115                 { "delete",                MORE,  2, delete_snapshot   },
5116                 { "daemon-reload",         EQUAL, 1, daemon_reload     },
5117                 { "daemon-reexec",         EQUAL, 1, daemon_reload     },
5118                 { "show-environment",      EQUAL, 1, show_enviroment   },
5119                 { "set-environment",       MORE,  2, set_environment   },
5120                 { "unset-environment",     MORE,  2, set_environment   },
5121                 { "halt",                  EQUAL, 1, start_special     },
5122                 { "poweroff",              EQUAL, 1, start_special     },
5123                 { "reboot",                EQUAL, 1, start_special     },
5124                 { "kexec",                 EQUAL, 1, start_special     },
5125                 { "suspend",               EQUAL, 1, start_special     },
5126                 { "hibernate",             EQUAL, 1, start_special     },
5127                 { "hybrid-sleep",          EQUAL, 1, start_special     },
5128                 { "default",               EQUAL, 1, start_special     },
5129                 { "rescue",                EQUAL, 1, start_special     },
5130                 { "emergency",             EQUAL, 1, start_special     },
5131                 { "exit",                  EQUAL, 1, start_special     },
5132                 { "reset-failed",          MORE,  1, reset_failed      },
5133                 { "enable",                MORE,  2, enable_unit       },
5134                 { "disable",               MORE,  2, enable_unit       },
5135                 { "is-enabled",            MORE,  2, unit_is_enabled   },
5136                 { "reenable",              MORE,  2, enable_unit       },
5137                 { "preset",                MORE,  2, enable_unit       },
5138                 { "mask",                  MORE,  2, enable_unit       },
5139                 { "unmask",                MORE,  2, enable_unit       },
5140                 { "link",                  MORE,  2, enable_unit       },
5141                 { "switch-root",           MORE,  2, switch_root       },
5142                 { "list-dependencies",     LESS,  2, list_dependencies },
5143         };
5144
5145         int left;
5146         unsigned i;
5147
5148         assert(argc >= 0);
5149         assert(argv);
5150         assert(error);
5151
5152         left = argc - optind;
5153
5154         if (left <= 0)
5155                 /* Special rule: no arguments means "list-units" */
5156                 i = 0;
5157         else {
5158                 if (streq(argv[optind], "help") && !argv[optind+1]) {
5159                         log_error("This command expects one or more "
5160                                   "unit names. Did you mean --help?");
5161                         return -EINVAL;
5162                 }
5163
5164                 for (i = 0; i < ELEMENTSOF(verbs); i++)
5165                         if (streq(argv[optind], verbs[i].verb))
5166                                 break;
5167
5168                 if (i >= ELEMENTSOF(verbs)) {
5169                         log_error("Unknown operation '%s'.", argv[optind]);
5170                         return -EINVAL;
5171                 }
5172         }
5173
5174         switch (verbs[i].argc_cmp) {
5175
5176         case EQUAL:
5177                 if (left != verbs[i].argc) {
5178                         log_error("Invalid number of arguments.");
5179                         return -EINVAL;
5180                 }
5181
5182                 break;
5183
5184         case MORE:
5185                 if (left < verbs[i].argc) {
5186                         log_error("Too few arguments.");
5187                         return -EINVAL;
5188                 }
5189
5190                 break;
5191
5192         case LESS:
5193                 if (left > verbs[i].argc) {
5194                         log_error("Too many arguments.");
5195                         return -EINVAL;
5196                 }
5197
5198                 break;
5199
5200         default:
5201                 assert_not_reached("Unknown comparison operator.");
5202         }
5203
5204         /* Require a bus connection for all operations but
5205          * enable/disable */
5206         if (!streq(verbs[i].verb, "enable") &&
5207             !streq(verbs[i].verb, "disable") &&
5208             !streq(verbs[i].verb, "is-enabled") &&
5209             !streq(verbs[i].verb, "list-unit-files") &&
5210             !streq(verbs[i].verb, "reenable") &&
5211             !streq(verbs[i].verb, "preset") &&
5212             !streq(verbs[i].verb, "mask") &&
5213             !streq(verbs[i].verb, "unmask") &&
5214             !streq(verbs[i].verb, "link")) {
5215
5216                 if (running_in_chroot() > 0) {
5217                         log_info("Running in chroot, ignoring request.");
5218                         return 0;
5219                 }
5220
5221                 if (((!streq(verbs[i].verb, "reboot") &&
5222                       !streq(verbs[i].verb, "halt") &&
5223                       !streq(verbs[i].verb, "poweroff")) || arg_force <= 0) && !bus) {
5224                         log_error("Failed to get D-Bus connection: %s",
5225                                   dbus_error_is_set(error) ? error->message : "No connection to service manager.");
5226                         return -EIO;
5227                 }
5228
5229         } else {
5230
5231                 if (!bus && !avoid_bus()) {
5232                         log_error("Failed to get D-Bus connection: %s",
5233                                   dbus_error_is_set(error) ? error->message : "No connection to service manager.");
5234                         return -EIO;
5235                 }
5236         }
5237
5238         return verbs[i].dispatch(bus, argv + optind);
5239 }
5240
5241 static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) {
5242         int _cleanup_close_ fd;
5243         struct msghdr msghdr;
5244         struct iovec iovec[2];
5245         union sockaddr_union sockaddr;
5246         struct sd_shutdown_command c;
5247
5248         fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
5249         if (fd < 0)
5250                 return -errno;
5251
5252         zero(c);
5253         c.usec = t;
5254         c.mode = mode;
5255         c.dry_run = dry_run;
5256         c.warn_wall = warn;
5257
5258         zero(sockaddr);
5259         sockaddr.sa.sa_family = AF_UNIX;
5260         strncpy(sockaddr.un.sun_path, "/run/systemd/shutdownd", sizeof(sockaddr.un.sun_path));
5261
5262         zero(msghdr);
5263         msghdr.msg_name = &sockaddr;
5264         msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/systemd/shutdownd") - 1;
5265
5266         zero(iovec);
5267         iovec[0].iov_base = (char*) &c;
5268         iovec[0].iov_len = offsetof(struct sd_shutdown_command, wall_message);
5269
5270         if (isempty(message))
5271                 msghdr.msg_iovlen = 1;
5272         else {
5273                 iovec[1].iov_base = (char*) message;
5274                 iovec[1].iov_len = strlen(message);
5275                 msghdr.msg_iovlen = 2;
5276         }
5277         msghdr.msg_iov = iovec;
5278
5279         if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0)
5280                 return -errno;
5281
5282         return 0;
5283 }
5284
5285 static int reload_with_fallback(DBusConnection *bus) {
5286
5287         if (bus) {
5288                 /* First, try systemd via D-Bus. */
5289                 if (daemon_reload(bus, NULL) >= 0)
5290                         return 0;
5291         }
5292
5293         /* Nothing else worked, so let's try signals */
5294         assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC);
5295
5296         if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0) {
5297                 log_error("kill() failed: %m");
5298                 return -errno;
5299         }
5300
5301         return 0;
5302 }
5303
5304 static int start_with_fallback(DBusConnection *bus) {
5305
5306         if (bus) {
5307                 /* First, try systemd via D-Bus. */
5308                 if (start_unit(bus, NULL) >= 0)
5309                         goto done;
5310         }
5311
5312         /* Hmm, talking to systemd via D-Bus didn't work. Then
5313          * let's try to talk to Upstart via D-Bus. */
5314         if (talk_upstart() > 0)
5315                 goto done;
5316
5317         /* Nothing else worked, so let's try
5318          * /dev/initctl */
5319         if (talk_initctl() > 0)
5320                 goto done;
5321
5322         log_error("Failed to talk to init daemon.");
5323         return -EIO;
5324
5325 done:
5326         warn_wall(arg_action);
5327         return 0;
5328 }
5329
5330 static _noreturn_ void halt_now(enum action a) {
5331
5332        /* Make sure C-A-D is handled by the kernel from this
5333          * point on... */
5334         reboot(RB_ENABLE_CAD);
5335
5336         switch (a) {
5337
5338         case ACTION_HALT:
5339                 log_info("Halting.");
5340                 reboot(RB_HALT_SYSTEM);
5341                 break;
5342
5343         case ACTION_POWEROFF:
5344                 log_info("Powering off.");
5345                 reboot(RB_POWER_OFF);
5346                 break;
5347
5348         case ACTION_REBOOT:
5349                 log_info("Rebooting.");
5350                 reboot(RB_AUTOBOOT);
5351                 break;
5352
5353         default:
5354                 assert_not_reached("Unknown halt action.");
5355         }
5356
5357         assert_not_reached("Uh? This shouldn't happen.");
5358 }
5359
5360 static int halt_main(DBusConnection *bus) {
5361         int r;
5362
5363         r = check_inhibitors(bus, arg_action);
5364         if (r < 0)
5365                 return r;
5366
5367         if (geteuid() != 0) {
5368                 /* Try logind if we are a normal user and no special
5369                  * mode applies. Maybe PolicyKit allows us to shutdown
5370                  * the machine. */
5371
5372                 if (arg_when <= 0 &&
5373                     !arg_dry &&
5374                     arg_force <= 0 &&
5375                     (arg_action == ACTION_POWEROFF ||
5376                      arg_action == ACTION_REBOOT)) {
5377                         r = reboot_with_logind(bus, arg_action);
5378                         if (r >= 0)
5379                                 return r;
5380                 }
5381
5382                 log_error("Must be root.");
5383                 return -EPERM;
5384         }
5385
5386         if (arg_when > 0) {
5387                 char _cleanup_free_ *m;
5388
5389                 m = strv_join(arg_wall, " ");
5390                 r = send_shutdownd(arg_when,
5391                                    arg_action == ACTION_HALT     ? 'H' :
5392                                    arg_action == ACTION_POWEROFF ? 'P' :
5393                                    arg_action == ACTION_KEXEC    ? 'K' :
5394                                                                    'r',
5395                                    arg_dry,
5396                                    !arg_no_wall,
5397                                    m);
5398
5399                 if (r < 0)
5400                         log_warning("Failed to talk to shutdownd, proceeding with immediate shutdown: %s", strerror(-r));
5401                 else {
5402                         char date[FORMAT_TIMESTAMP_MAX];
5403
5404                         log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.",
5405                                  format_timestamp(date, sizeof(date), arg_when));
5406                         return 0;
5407                 }
5408         }
5409
5410         if (!arg_dry && !arg_force)
5411                 return start_with_fallback(bus);
5412
5413         if (!arg_no_wtmp) {
5414                 if (sd_booted() > 0)
5415                         log_debug("Not writing utmp record, assuming that systemd-update-utmp is used.");
5416                 else {
5417                         r = utmp_put_shutdown();
5418                         if (r < 0)
5419                                 log_warning("Failed to write utmp record: %s", strerror(-r));
5420                 }
5421         }
5422
5423         if (arg_dry)
5424                 return 0;
5425
5426         halt_now(arg_action);
5427         /* We should never reach this. */
5428         return -ENOSYS;
5429 }
5430
5431 static int runlevel_main(void) {
5432         int r, runlevel, previous;
5433
5434         r = utmp_get_runlevel(&runlevel, &previous);
5435         if (r < 0) {
5436                 puts("unknown");
5437                 return r;
5438         }
5439
5440         printf("%c %c\n",
5441                previous <= 0 ? 'N' : previous,
5442                runlevel <= 0 ? 'N' : runlevel);
5443
5444         return 0;
5445 }
5446
5447 int main(int argc, char*argv[]) {
5448         int r, retval = EXIT_FAILURE;
5449         DBusConnection *bus = NULL;
5450         DBusError _cleanup_dbus_error_free_ error;
5451
5452         dbus_error_init(&error);
5453
5454         setlocale(LC_ALL, "");
5455         log_parse_environment();
5456         log_open();
5457
5458         r = parse_argv(argc, argv);
5459         if (r < 0)
5460                 goto finish;
5461         else if (r == 0) {
5462                 retval = EXIT_SUCCESS;
5463                 goto finish;
5464         }
5465
5466         /* /sbin/runlevel doesn't need to communicate via D-Bus, so
5467          * let's shortcut this */
5468         if (arg_action == ACTION_RUNLEVEL) {
5469                 r = runlevel_main();
5470                 retval = r < 0 ? EXIT_FAILURE : r;
5471                 goto finish;
5472         }
5473
5474         if (running_in_chroot() > 0 && arg_action != ACTION_SYSTEMCTL) {
5475                 log_info("Running in chroot, ignoring request.");
5476                 retval = 0;
5477                 goto finish;
5478         }
5479
5480         if (!avoid_bus()) {
5481                 if (arg_transport == TRANSPORT_NORMAL)
5482                         bus_connect(arg_scope == UNIT_FILE_SYSTEM ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &bus, &private_bus, &error);
5483                 else if (arg_transport == TRANSPORT_POLKIT) {
5484                         bus_connect_system_polkit(&bus, &error);
5485                         private_bus = false;
5486                 } else if (arg_transport == TRANSPORT_SSH) {
5487                         bus_connect_system_ssh(NULL, arg_host, &bus, &error);
5488                         private_bus = false;
5489                 } else
5490                         assert_not_reached("Uh, invalid transport...");
5491         }
5492
5493         switch (arg_action) {
5494
5495         case ACTION_SYSTEMCTL:
5496                 r = systemctl_main(bus, argc, argv, &error);
5497                 break;
5498
5499         case ACTION_HALT:
5500         case ACTION_POWEROFF:
5501         case ACTION_REBOOT:
5502         case ACTION_KEXEC:
5503                 r = halt_main(bus);
5504                 break;
5505
5506         case ACTION_RUNLEVEL2:
5507         case ACTION_RUNLEVEL3:
5508         case ACTION_RUNLEVEL4:
5509         case ACTION_RUNLEVEL5:
5510         case ACTION_RESCUE:
5511         case ACTION_EMERGENCY:
5512         case ACTION_DEFAULT:
5513                 r = start_with_fallback(bus);
5514                 break;
5515
5516         case ACTION_RELOAD:
5517         case ACTION_REEXEC:
5518                 r = reload_with_fallback(bus);
5519                 break;
5520
5521         case ACTION_CANCEL_SHUTDOWN: {
5522                 char *m = NULL;
5523
5524                 if (arg_wall) {
5525                         m = strv_join(arg_wall, " ");
5526                         if (!m) {
5527                                 retval = EXIT_FAILURE;
5528                                 goto finish;
5529                         }
5530                 }
5531                 r = send_shutdownd(arg_when, SD_SHUTDOWN_NONE, false, !arg_no_wall, m);
5532                 if (r < 0)
5533                         log_warning("Failed to talk to shutdownd, shutdown hasn't been cancelled: %s", strerror(-r));
5534                 free(m);
5535                 break;
5536         }
5537
5538         case ACTION_INVALID:
5539         case ACTION_RUNLEVEL:
5540         default:
5541                 assert_not_reached("Unknown action");
5542         }
5543
5544         retval = r < 0 ? EXIT_FAILURE : r;
5545
5546 finish:
5547         if (bus) {
5548                 dbus_connection_flush(bus);
5549                 dbus_connection_close(bus);
5550                 dbus_connection_unref(bus);
5551         }
5552
5553         dbus_shutdown();
5554
5555         strv_free(arg_property);
5556
5557         pager_close();
5558         ask_password_agent_close();
5559         polkit_agent_close();
5560
5561         return retval;
5562 }