chiark / gitweb /
systemctl: show connection counters only for Accept=yes sockets
[elogind.git] / src / systemctl.c
1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
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 General Public License as published by
10   the Free Software Foundation; either version 2 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   General Public License for more details.
17
18   You should have received a copy of the GNU 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 <stdbool.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <sys/ioctl.h>
29 #include <termios.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <sys/socket.h>
33
34 #include <dbus/dbus.h>
35
36 #include "log.h"
37 #include "util.h"
38 #include "macro.h"
39 #include "set.h"
40 #include "utmp-wtmp.h"
41 #include "special.h"
42 #include "initreq.h"
43 #include "strv.h"
44 #include "dbus-common.h"
45 #include "cgroup-show.h"
46
47 static const char *arg_type = NULL;
48 static const char *arg_property = NULL;
49 static bool arg_all = false;
50 static bool arg_replace = false;
51 static bool arg_session = false;
52 static bool arg_no_block = false;
53 static bool arg_immediate = false;
54 static bool arg_no_wtmp = false;
55 static bool arg_no_sync = false;
56 static bool arg_no_wall = false;
57 static bool arg_dry = false;
58 static bool arg_quiet = false;
59 static char **arg_wall = NULL;
60 enum action {
61         ACTION_INVALID,
62         ACTION_SYSTEMCTL,
63         ACTION_HALT,
64         ACTION_POWEROFF,
65         ACTION_REBOOT,
66         ACTION_RUNLEVEL2,
67         ACTION_RUNLEVEL3,
68         ACTION_RUNLEVEL4,
69         ACTION_RUNLEVEL5,
70         ACTION_RESCUE,
71         ACTION_EMERGENCY,
72         ACTION_DEFAULT,
73         ACTION_RELOAD,
74         ACTION_REEXEC,
75         ACTION_RUNLEVEL,
76         _ACTION_MAX
77 } arg_action = ACTION_SYSTEMCTL;
78
79 static bool private_bus = false;
80
81 static bool error_is_no_service(DBusError *error) {
82
83         assert(error);
84
85         if (!dbus_error_is_set(error))
86                 return false;
87
88         if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))
89                 return true;
90
91         if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))
92                 return true;
93
94         return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");
95 }
96
97 static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next) {
98
99         assert(iter);
100         assert(data);
101
102         if (dbus_message_iter_get_arg_type(iter) != type)
103                 return -EIO;
104
105         dbus_message_iter_get_basic(iter, data);
106
107         if (!dbus_message_iter_next(iter) != !next)
108                 return -EIO;
109
110         return 0;
111 }
112
113 static void warn_wall(enum action action) {
114         static const char *table[_ACTION_MAX] = {
115                 [ACTION_HALT]      = "The system is going down for system halt NOW!",
116                 [ACTION_REBOOT]    = "The system is going down for reboot NOW!",
117                 [ACTION_POWEROFF]  = "The system is going down for power-off NOW!",
118                 [ACTION_RESCUE]    = "The system is going down to rescue mode NOW!",
119                 [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!"
120         };
121
122         if (arg_no_wall)
123                 return;
124
125         if (arg_wall) {
126                 char *p;
127
128                 if (!(p = strv_join(arg_wall, " "))) {
129                         log_error("Failed to join strings.");
130                         return;
131                 }
132
133                 if (*p) {
134                         utmp_wall(p);
135                         free(p);
136                         return;
137                 }
138
139                 free(p);
140         }
141
142         if (!table[action])
143                 return;
144
145         utmp_wall(table[action]);
146 }
147
148 static int list_units(DBusConnection *bus, char **args, unsigned n) {
149         DBusMessage *m = NULL, *reply = NULL;
150         DBusError error;
151         int r;
152         DBusMessageIter iter, sub, sub2;
153         unsigned k = 0;
154
155         dbus_error_init(&error);
156
157         assert(bus);
158
159         if (!(m = dbus_message_new_method_call(
160                               "org.freedesktop.systemd1",
161                               "/org/freedesktop/systemd1",
162                               "org.freedesktop.systemd1.Manager",
163                               "ListUnits"))) {
164                 log_error("Could not allocate message.");
165                 return -ENOMEM;
166         }
167
168         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
169                 log_error("Failed to issue method call: %s", error.message);
170                 r = -EIO;
171                 goto finish;
172         }
173
174         if (!dbus_message_iter_init(reply, &iter) ||
175             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
176             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
177                 log_error("Failed to parse reply.");
178                 r = -EIO;
179                 goto finish;
180         }
181
182         dbus_message_iter_recurse(&iter, &sub);
183
184         printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION");
185
186         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
187                 const char *id, *description, *load_state, *active_state, *sub_state, *unit_state, *job_type, *job_path, *dot;
188                 uint32_t job_id;
189
190                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
191                         log_error("Failed to parse reply.");
192                         r = -EIO;
193                         goto finish;
194                 }
195
196                 dbus_message_iter_recurse(&sub, &sub2);
197
198                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
199                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 ||
200                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 ||
201                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 ||
202                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 ||
203                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_state, true) < 0 ||
204                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &job_id, true) < 0 ||
205                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &job_type, true) < 0 ||
206                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, false) < 0) {
207                         log_error("Failed to parse reply.");
208                         r = -EIO;
209                         goto finish;
210                 }
211
212                 if ((!arg_type || ((dot = strrchr(id, '.')) &&
213                                    streq(dot+1, arg_type))) &&
214                     (arg_all || !streq(active_state, "inactive"))) {
215
216                         int a = 0, b = 0;
217
218                         if (streq(active_state, "maintenance"))
219                                 fputs(ANSI_HIGHLIGHT_ON, stdout);
220
221                         printf("%-45s %-6s %-12s %-12s%n", id, load_state, active_state, sub_state, &a);
222
223                         if (job_id != 0)
224                                 printf(" %-15s%n", job_type, &b);
225                         else
226                                 b = 1 + 15;
227
228                         if (a + b + 2 < columns()) {
229                                 if (job_id == 0)
230                                         printf("                ");
231
232                                 printf(" %.*s", columns() - a - b - 2, description);
233                         }
234
235                         if (streq(active_state, "maintenance"))
236                                 fputs(ANSI_HIGHLIGHT_OFF, stdout);
237
238                         fputs("\n", stdout);
239                         k++;
240                 }
241
242                 dbus_message_iter_next(&sub);
243         }
244
245         if (arg_all)
246                 printf("\n%u units listed.\n", k);
247         else
248                 printf("\n%u live units listed. Pass --all to see dead units, too.\n", k);
249
250         r = 0;
251
252 finish:
253         if (m)
254                 dbus_message_unref(m);
255
256         if (reply)
257                 dbus_message_unref(reply);
258
259         dbus_error_free(&error);
260
261         return r;
262 }
263
264 static int list_jobs(DBusConnection *bus, char **args, unsigned n) {
265         DBusMessage *m = NULL, *reply = NULL;
266         DBusError error;
267         int r;
268         DBusMessageIter iter, sub, sub2;
269         unsigned k = 0;
270
271         dbus_error_init(&error);
272
273         assert(bus);
274
275         if (!(m = dbus_message_new_method_call(
276                               "org.freedesktop.systemd1",
277                               "/org/freedesktop/systemd1",
278                               "org.freedesktop.systemd1.Manager",
279                               "ListJobs"))) {
280                 log_error("Could not allocate message.");
281                 return -ENOMEM;
282         }
283
284         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
285                 log_error("Failed to issue method call: %s", error.message);
286                 r = -EIO;
287                 goto finish;
288         }
289
290         if (!dbus_message_iter_init(reply, &iter) ||
291             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
292             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
293                 log_error("Failed to parse reply.");
294                 r = -EIO;
295                 goto finish;
296         }
297
298         dbus_message_iter_recurse(&iter, &sub);
299
300         printf("%4s %-45s %-17s %-7s\n", "JOB", "UNIT", "TYPE", "STATE");
301
302         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
303                 const char *name, *type, *state, *job_path, *unit_path;
304                 uint32_t id;
305
306                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
307                         log_error("Failed to parse reply.");
308                         r = -EIO;
309                         goto finish;
310                 }
311
312                 dbus_message_iter_recurse(&sub, &sub2);
313
314                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 ||
315                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
316                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
317                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 ||
318                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 ||
319                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) {
320                         log_error("Failed to parse reply.");
321                         r = -EIO;
322                         goto finish;
323                 }
324
325                 printf("%4u %-45s %-17s %-7s\n", id, name, type, state);
326                 k++;
327
328                 dbus_message_iter_next(&sub);
329         }
330
331         printf("\n%u jobs listed.\n", k);
332         r = 0;
333
334 finish:
335         if (m)
336                 dbus_message_unref(m);
337
338         if (reply)
339                 dbus_message_unref(reply);
340
341         dbus_error_free(&error);
342
343         return r;
344 }
345
346 static int load_unit(DBusConnection *bus, char **args, unsigned n) {
347         DBusMessage *m = NULL, *reply = NULL;
348         DBusError error;
349         int r;
350         unsigned i;
351
352         dbus_error_init(&error);
353
354         assert(bus);
355         assert(args);
356
357         for (i = 1; i < n; i++) {
358
359                 if (!(m = dbus_message_new_method_call(
360                                       "org.freedesktop.systemd1",
361                                       "/org/freedesktop/systemd1",
362                                       "org.freedesktop.systemd1.Manager",
363                                       "LoadUnit"))) {
364                         log_error("Could not allocate message.");
365                         r = -ENOMEM;
366                         goto finish;
367                 }
368
369                 if (!dbus_message_append_args(m,
370                                               DBUS_TYPE_STRING, &args[i],
371                                               DBUS_TYPE_INVALID)) {
372                         log_error("Could not append arguments to message.");
373                         r = -ENOMEM;
374                         goto finish;
375                 }
376
377                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
378                         log_error("Failed to issue method call: %s", error.message);
379                         r = -EIO;
380                         goto finish;
381                 }
382
383                 dbus_message_unref(m);
384                 dbus_message_unref(reply);
385
386                 m = reply = NULL;
387         }
388
389         r = 0;
390
391 finish:
392         if (m)
393                 dbus_message_unref(m);
394
395         if (reply)
396                 dbus_message_unref(reply);
397
398         dbus_error_free(&error);
399
400         return r;
401 }
402
403 static int cancel_job(DBusConnection *bus, char **args, unsigned n) {
404         DBusMessage *m = NULL, *reply = NULL;
405         DBusError error;
406         int r;
407         unsigned i;
408
409         dbus_error_init(&error);
410
411         assert(bus);
412         assert(args);
413
414         for (i = 1; i < n; i++) {
415                 unsigned id;
416                 const char *path;
417
418                 if (!(m = dbus_message_new_method_call(
419                                       "org.freedesktop.systemd1",
420                                       "/org/freedesktop/systemd1",
421                                       "org.freedesktop.systemd1.Manager",
422                                       "GetJob"))) {
423                         log_error("Could not allocate message.");
424                         r = -ENOMEM;
425                         goto finish;
426                 }
427
428                 if ((r = safe_atou(args[i], &id)) < 0) {
429                         log_error("Failed to parse job id: %s", strerror(-r));
430                         goto finish;
431                 }
432
433                 assert_cc(sizeof(uint32_t) == sizeof(id));
434                 if (!dbus_message_append_args(m,
435                                               DBUS_TYPE_UINT32, &id,
436                                               DBUS_TYPE_INVALID)) {
437                         log_error("Could not append arguments to message.");
438                         r = -ENOMEM;
439                         goto finish;
440                 }
441
442                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
443                         log_error("Failed to issue method call: %s", error.message);
444                         r = -EIO;
445                         goto finish;
446                 }
447
448                 if (!dbus_message_get_args(reply, &error,
449                                            DBUS_TYPE_OBJECT_PATH, &path,
450                                            DBUS_TYPE_INVALID)) {
451                         log_error("Failed to parse reply: %s", error.message);
452                         r = -EIO;
453                         goto finish;
454                 }
455
456                 dbus_message_unref(m);
457                 if (!(m = dbus_message_new_method_call(
458                                       "org.freedesktop.systemd1",
459                                       path,
460                                       "org.freedesktop.systemd1.Job",
461                                       "Cancel"))) {
462                         log_error("Could not allocate message.");
463                         r = -ENOMEM;
464                         goto finish;
465                 }
466
467                 dbus_message_unref(reply);
468                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
469                         log_error("Failed to issue method call: %s", error.message);
470                         r = -EIO;
471                         goto finish;
472                 }
473
474                 dbus_message_unref(m);
475                 dbus_message_unref(reply);
476                 m = reply = NULL;
477         }
478
479         r = 0;
480
481 finish:
482         if (m)
483                 dbus_message_unref(m);
484
485         if (reply)
486                 dbus_message_unref(reply);
487
488         dbus_error_free(&error);
489
490         return r;
491 }
492
493 typedef struct WaitData {
494         Set *set;
495         bool failed;
496 } WaitData;
497
498 static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) {
499         DBusError error;
500         WaitData *d = data;
501
502         assert(connection);
503         assert(message);
504         assert(d);
505
506         dbus_error_init(&error);
507
508         log_debug("Got D-Bus request: %s.%s() on %s",
509                   dbus_message_get_interface(message),
510                   dbus_message_get_member(message),
511                   dbus_message_get_path(message));
512
513         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
514                 log_error("Warning! D-Bus connection terminated.");
515                 dbus_connection_close(connection);
516
517         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
518                 uint32_t id;
519                 const char *path;
520                 dbus_bool_t success = true;
521
522                 if (!dbus_message_get_args(message, &error,
523                                            DBUS_TYPE_UINT32, &id,
524                                            DBUS_TYPE_OBJECT_PATH, &path,
525                                            DBUS_TYPE_BOOLEAN, &success,
526                                            DBUS_TYPE_INVALID))
527                         log_error("Failed to parse message: %s", error.message);
528                 else {
529                         char *p;
530
531                         if ((p = set_remove(d->set, (char*) path)))
532                                 free(p);
533
534                         if (!success)
535                                 d->failed = true;
536                 }
537         }
538
539         dbus_error_free(&error);
540         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
541 }
542
543 static int enable_wait_for_jobs(DBusConnection *bus) {
544         DBusError error;
545
546         assert(bus);
547
548         if (private_bus)
549                 return 0;
550
551         dbus_error_init(&error);
552         dbus_bus_add_match(bus,
553                            "type='signal',"
554                            "sender='org.freedesktop.systemd1',"
555                            "interface='org.freedesktop.systemd1.Manager',"
556                            "member='JobRemoved',"
557                            "path='/org/freedesktop/systemd1'",
558                            &error);
559
560         if (dbus_error_is_set(&error)) {
561                 log_error("Failed to add match: %s", error.message);
562                 dbus_error_free(&error);
563                 return -EIO;
564         }
565
566         /* This is slightly dirty, since we don't undo the match registrations. */
567         return 0;
568 }
569
570 static int wait_for_jobs(DBusConnection *bus, Set *s) {
571         int r;
572         WaitData d;
573
574         assert(bus);
575         assert(s);
576
577         zero(d);
578         d.set = s;
579         d.failed = false;
580
581         if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) {
582                 log_error("Failed to add filter.");
583                 r = -ENOMEM;
584                 goto finish;
585         }
586
587         while (!set_isempty(s) &&
588                dbus_connection_read_write_dispatch(bus, -1))
589                 ;
590
591         if (!arg_quiet && d.failed)
592                 log_error("Job failed, see logs for details.");
593
594         r = d.failed ? -EIO : 0;
595
596 finish:
597         /* This is slightly dirty, since we don't undo the filter registration. */
598
599         return r;
600 }
601
602 static int start_unit_one(
603                 DBusConnection *bus,
604                 const char *method,
605                 const char *name,
606                 const char *mode,
607                 Set *s) {
608
609         DBusMessage *m = NULL, *reply = NULL;
610         DBusError error;
611         int r;
612
613         assert(bus);
614         assert(method);
615         assert(name);
616         assert(mode);
617         assert(arg_no_block || s);
618
619         dbus_error_init(&error);
620
621         if (!(m = dbus_message_new_method_call(
622                               "org.freedesktop.systemd1",
623                               "/org/freedesktop/systemd1",
624                               "org.freedesktop.systemd1.Manager",
625                               method))) {
626                 log_error("Could not allocate message.");
627                 r = -ENOMEM;
628                 goto finish;
629         }
630
631         if (!dbus_message_append_args(m,
632                                       DBUS_TYPE_STRING, &name,
633                                       DBUS_TYPE_STRING, &mode,
634                                       DBUS_TYPE_INVALID)) {
635                 log_error("Could not append arguments to message.");
636                 r = -ENOMEM;
637                 goto finish;
638         }
639
640         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
641
642                 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
643                         /* There's always a fallback possible for
644                          * legacy actions. */
645                         r = 0;
646                         goto finish;
647                 }
648
649                 log_error("Failed to issue method call: %s", error.message);
650                 r = -EIO;
651                 goto finish;
652         }
653
654         if (!arg_no_block) {
655                 const char *path;
656                 char *p;
657
658                 if (!dbus_message_get_args(reply, &error,
659                                            DBUS_TYPE_OBJECT_PATH, &path,
660                                            DBUS_TYPE_INVALID)) {
661                         log_error("Failed to parse reply: %s", error.message);
662                         r = -EIO;
663                         goto finish;
664                 }
665
666                 if (!(p = strdup(path))) {
667                         log_error("Failed to duplicate path.");
668                         r = -ENOMEM;
669                         goto finish;
670                 }
671
672                 if ((r = set_put(s, p)) < 0) {
673                         free(p);
674                         log_error("Failed to add path to set.");
675                         goto finish;
676                 }
677         }
678
679         r = 1;
680
681 finish:
682         if (m)
683                 dbus_message_unref(m);
684
685         if (reply)
686                 dbus_message_unref(reply);
687
688         dbus_error_free(&error);
689
690         return r;
691 }
692
693 static enum action verb_to_action(const char *verb) {
694         if (streq(verb, "halt"))
695                 return ACTION_HALT;
696         else if (streq(verb, "poweroff"))
697                 return ACTION_POWEROFF;
698         else if (streq(verb, "reboot"))
699                 return ACTION_REBOOT;
700         else if (streq(verb, "rescue"))
701                 return ACTION_RESCUE;
702         else if (streq(verb, "emergency"))
703                 return ACTION_EMERGENCY;
704         else if (streq(verb, "default"))
705                 return ACTION_DEFAULT;
706         else
707                 return ACTION_INVALID;
708 }
709
710 static int start_unit(DBusConnection *bus, char **args, unsigned n) {
711
712         static const char * const table[_ACTION_MAX] = {
713                 [ACTION_HALT] = SPECIAL_HALT_TARGET,
714                 [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET,
715                 [ACTION_REBOOT] = SPECIAL_REBOOT_TARGET,
716                 [ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET,
717                 [ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET,
718                 [ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET,
719                 [ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET,
720                 [ACTION_RESCUE] = SPECIAL_RESCUE_TARGET,
721                 [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_SERVICE,
722                 [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET
723         };
724
725         int r;
726         unsigned i;
727         const char *method, *mode, *one_name;
728         Set *s = NULL;
729
730         assert(bus);
731
732         if (arg_action == ACTION_SYSTEMCTL) {
733                 method =
734                         streq(args[0], "stop")    ? "StopUnit" :
735                         streq(args[0], "reload")  ? "ReloadUnit" :
736                         streq(args[0], "restart") ? "RestartUnit" :
737                                                     "StartUnit";
738
739                 mode =
740                         (streq(args[0], "isolate") ||
741                          streq(args[0], "rescue")  ||
742                          streq(args[0], "emergency")) ? "isolate" :
743                                           arg_replace ? "replace" :
744                                                         "fail";
745
746                 one_name = table[verb_to_action(args[0])];
747
748         } else {
749                 assert(arg_action < ELEMENTSOF(table));
750                 assert(table[arg_action]);
751
752                 method = "StartUnit";
753
754                 mode = (arg_action == ACTION_EMERGENCY ||
755                         arg_action == ACTION_RESCUE) ? "isolate" : "replace";
756
757                 one_name = table[arg_action];
758         }
759
760         if (!arg_no_block) {
761                 if ((r = enable_wait_for_jobs(bus)) < 0) {
762                         log_error("Could not watch jobs: %s", strerror(-r));
763                         goto finish;
764                 }
765
766                 if (!(s = set_new(string_hash_func, string_compare_func))) {
767                         log_error("Failed to allocate set.");
768                         r = -ENOMEM;
769                         goto finish;
770                 }
771         }
772
773         r = 0;
774
775         if (one_name) {
776                 if ((r = start_unit_one(bus, method, one_name, mode, s)) <= 0)
777                         goto finish;
778         } else {
779                 for (i = 1; i < n; i++)
780                         if ((r = start_unit_one(bus, method, args[i], mode, s)) < 0)
781                                 goto finish;
782         }
783
784         if (!arg_no_block)
785                 r = wait_for_jobs(bus, s);
786
787 finish:
788         if (s)
789                 set_free_free(s);
790
791         return r;
792 }
793
794 static int start_special(DBusConnection *bus, char **args, unsigned n) {
795         assert(bus);
796         assert(args);
797
798         warn_wall(verb_to_action(args[0]));
799
800         return start_unit(bus, args, n);
801 }
802
803 static int check_unit(DBusConnection *bus, char **args, unsigned n) {
804         DBusMessage *m = NULL, *reply = NULL;
805         const char
806                 *interface = "org.freedesktop.systemd1.Unit",
807                 *property = "ActiveState";
808         int r = -EADDRNOTAVAIL;
809         DBusError error;
810         unsigned i;
811
812         assert(bus);
813         assert(args);
814
815         dbus_error_init(&error);
816
817         for (i = 1; i < n; i++) {
818                 const char *path = NULL;
819                 const char *state;
820                 DBusMessageIter iter, sub;
821
822                 if (!(m = dbus_message_new_method_call(
823                                       "org.freedesktop.systemd1",
824                                       "/org/freedesktop/systemd1",
825                                       "org.freedesktop.systemd1.Manager",
826                                       "GetUnit"))) {
827                         log_error("Could not allocate message.");
828                         r = -ENOMEM;
829                         goto finish;
830                 }
831
832                 if (!dbus_message_append_args(m,
833                                               DBUS_TYPE_STRING, &args[i],
834                                               DBUS_TYPE_INVALID)) {
835                         log_error("Could not append arguments to message.");
836                         r = -ENOMEM;
837                         goto finish;
838                 }
839
840                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
841
842                         /* Hmm, cannot figure out anything about this unit... */
843                         if (!arg_quiet)
844                                 puts("unknown");
845
846                         dbus_error_free(&error);
847                         continue;
848                 }
849
850                 if (!dbus_message_get_args(reply, &error,
851                                            DBUS_TYPE_OBJECT_PATH, &path,
852                                            DBUS_TYPE_INVALID)) {
853                         log_error("Failed to parse reply: %s", error.message);
854                         r = -EIO;
855                         goto finish;
856                 }
857
858                 dbus_message_unref(m);
859                 if (!(m = dbus_message_new_method_call(
860                                       "org.freedesktop.systemd1",
861                                       path,
862                                       "org.freedesktop.DBus.Properties",
863                                       "Get"))) {
864                         log_error("Could not allocate message.");
865                         r = -ENOMEM;
866                         goto finish;
867                 }
868
869                 if (!dbus_message_append_args(m,
870                                               DBUS_TYPE_STRING, &interface,
871                                               DBUS_TYPE_STRING, &property,
872                                               DBUS_TYPE_INVALID)) {
873                         log_error("Could not append arguments to message.");
874                         r = -ENOMEM;
875                         goto finish;
876                 }
877
878                 dbus_message_unref(reply);
879                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
880                         log_error("Failed to issue method call: %s", error.message);
881                         r = -EIO;
882                         goto finish;
883                 }
884
885                 if (!dbus_message_iter_init(reply, &iter) ||
886                     dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
887                         log_error("Failed to parse reply.");
888                         r = -EIO;
889                         goto finish;
890                 }
891
892                 dbus_message_iter_recurse(&iter, &sub);
893
894                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
895                         log_error("Failed to parse reply.");
896                         r = -EIO;
897                         goto finish;
898                 }
899
900                 dbus_message_iter_get_basic(&sub, &state);
901
902                 if (!arg_quiet)
903                         puts(state);
904
905                 if (streq(state, "active") || startswith(state, "reloading"))
906                         r = 0;
907
908                 dbus_message_unref(m);
909                 dbus_message_unref(reply);
910                 m = reply = NULL;
911         }
912
913 finish:
914         if (m)
915                 dbus_message_unref(m);
916
917         if (reply)
918                 dbus_message_unref(reply);
919
920         dbus_error_free(&error);
921
922         return r;
923 }
924
925 typedef struct UnitStatusInfo {
926         const char *id;
927         const char *load_state;
928         const char *active_state;
929         const char *sub_state;
930
931         const char *description;
932
933         const char *fragment_path;
934         const char *default_control_group;
935
936         /* Service */
937         pid_t main_pid;
938         pid_t control_pid;
939         const char *status_text;
940         bool running;
941
942         usec_t start_timestamp;
943         usec_t exit_timestamp;
944
945         int exit_code, exit_status;
946
947         /* Socket */
948         unsigned n_accepted;
949         unsigned n_connections;
950         bool accept;
951
952         /* Device */
953         const char *sysfs_path;
954
955         /* Mount, Automount */
956         const char *where;
957
958         /* Swap */
959         const char *what;
960 } UnitStatusInfo;
961
962 static void print_status_info(UnitStatusInfo *i) {
963         assert(i);
964
965         /* This shows pretty information about a unit. See
966          * print_property() for a low-level property printer */
967
968         printf("%s", strna(i->id));
969
970         if (i->description && !streq_ptr(i->id, i->description))
971                 printf(" - %s", i->description);
972
973         printf("\n");
974
975         if (i->fragment_path)
976                 printf("\t  Loaded: %s (%s)\n", strna(i->load_state), i->fragment_path);
977         else if (streq_ptr(i->load_state, "failed"))
978                 printf("\t  Loaded: " ANSI_HIGHLIGHT_ON "%s" ANSI_HIGHLIGHT_OFF "\n", strna(i->load_state));
979         else
980                 printf("\t  Loaded: %s\n", strna(i->load_state));
981
982         if (streq_ptr(i->active_state, "maintenance"))
983                 printf("\t  Active: " ANSI_HIGHLIGHT_ON "%s (%s)" ANSI_HIGHLIGHT_OFF "\n",
984                        strna(i->active_state),
985                        strna(i->sub_state));
986         else
987                 printf("\t  Active: %s (%s)\n",
988                        strna(i->active_state),
989                        strna(i->sub_state));
990
991         if (i->sysfs_path)
992                 printf("\t  Device: %s\n", i->sysfs_path);
993         else if (i->where)
994                 printf("\t   Where: %s\n", i->where);
995         else if (i->what)
996                 printf("\t    What: %s\n", i->what);
997
998         if (i->status_text)
999                 printf("\t  Status: \"%s\"\n", i->status_text);
1000
1001         if (i->accept)
1002                 printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
1003
1004         if (i->main_pid > 0 || i->control_pid > 0) {
1005                 printf("\t");
1006
1007                 if (i->main_pid > 0) {
1008                         printf(" Process: %u", (unsigned) i->main_pid);
1009
1010                         if (i->running) {
1011                                 char *t = NULL;
1012                                 get_process_name(i->main_pid, &t);
1013                                 if (t) {
1014                                         printf(" (%s)", t);
1015                                         free(t);
1016                                 }
1017                         } else {
1018                                 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
1019
1020                                 if (i->exit_code == CLD_EXITED)
1021                                         printf("status=%i", i->exit_status);
1022                                 else
1023                                         printf("signal=%s", strsignal(i->exit_status));
1024                                 printf(")");
1025                         }
1026                 }
1027
1028                 if (i->main_pid > 0 && i->control_pid > 0)
1029                         printf(";");
1030
1031                 if (i->control_pid > 0) {
1032                         char *t = NULL;
1033
1034                         printf(" Control: %u", (unsigned) i->control_pid);
1035
1036                         get_process_name(i->control_pid, &t);
1037                         if (t) {
1038                                 printf(" (%s)", t);
1039                                 free(t);
1040                         }
1041                 }
1042
1043                 printf("\n");
1044         }
1045
1046         if (i->default_control_group) {
1047                 unsigned c;
1048
1049                 printf("\t  CGroup: %s\n", i->default_control_group);
1050
1051                 if ((c = columns()) > 18)
1052                         c -= 18;
1053                 else
1054                         c = 0;
1055
1056                 show_cgroup_recursive(i->default_control_group, "\t\t  ", c);
1057         }
1058 }
1059
1060 static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) {
1061
1062         switch (dbus_message_iter_get_arg_type(iter)) {
1063
1064         case DBUS_TYPE_STRING: {
1065                 const char *s;
1066
1067                 dbus_message_iter_get_basic(iter, &s);
1068
1069                 if (s[0]) {
1070                         if (streq(name, "Id"))
1071                                 i->id = s;
1072                         else if (streq(name, "LoadState"))
1073                                 i->load_state = s;
1074                         else if (streq(name, "ActiveState"))
1075                                 i->active_state = s;
1076                         else if (streq(name, "SubState"))
1077                                 i->sub_state = s;
1078                         else if (streq(name, "Description"))
1079                                 i->description = s;
1080                         else if (streq(name, "FragmentPath"))
1081                                 i->fragment_path = s;
1082                         else if (streq(name, "DefaultControlGroup"))
1083                                 i->default_control_group = s;
1084                         else if (streq(name, "StatusText"))
1085                                 i->status_text = s;
1086                         else if (streq(name, "SysFSPath"))
1087                                 i->sysfs_path = s;
1088                         else if (streq(name, "Where"))
1089                                 i->where = s;
1090                         else if (streq(name, "What"))
1091                                 i->what = s;
1092                 }
1093
1094                 break;
1095         }
1096
1097         case DBUS_TYPE_BOOLEAN: {
1098                 dbus_bool_t b;
1099
1100                 dbus_message_iter_get_basic(iter, &b);
1101
1102                 if (streq(name, "Accept"))
1103                         i->accept = b;
1104
1105                 break;
1106         }
1107
1108         case DBUS_TYPE_UINT32: {
1109                 uint32_t u;
1110
1111                 dbus_message_iter_get_basic(iter, &u);
1112
1113                 if (streq(name, "MainPID")) {
1114                         if (u > 0) {
1115                                 i->main_pid = (pid_t) u;
1116                                 i->running = true;
1117                         }
1118                 } else if (streq(name, "ControlPID"))
1119                         i->control_pid = (pid_t) u;
1120                 else if (streq(name, "ExecMainPID")) {
1121                         if (u > 0)
1122                                 i->main_pid = (pid_t) u;
1123                 } else if (streq(name, "NAccepted"))
1124                         i->n_accepted = u;
1125                 else if (streq(name, "NConnections"))
1126                         i->n_connections = u;
1127
1128                 break;
1129         }
1130
1131         case DBUS_TYPE_INT32: {
1132                 int32_t j;
1133
1134                 dbus_message_iter_get_basic(iter, &j);
1135
1136                 if (streq(name, "ExecMainCode"))
1137                         i->exit_code = (int) j;
1138                 else if (streq(name, "ExecMainStatus"))
1139                         i->exit_status = (int) j;
1140
1141                 break;
1142         }
1143
1144         case DBUS_TYPE_UINT64: {
1145                 uint64_t u;
1146
1147                 dbus_message_iter_get_basic(iter, &u);
1148
1149                 if (streq(name, "ExecMainStartTimestamp"))
1150                         i->start_timestamp = (usec_t) u;
1151                 else if (streq(name, "ExecMainExitTimestamp"))
1152                         i->exit_timestamp = (usec_t) u;
1153
1154                 break;
1155         }
1156         }
1157
1158         return 0;
1159 }
1160
1161 static int print_property(const char *name, DBusMessageIter *iter) {
1162         assert(name);
1163         assert(iter);
1164
1165         /* This is a low-level property printer, see
1166          * print_status_info() for the nicer output */
1167
1168         if (arg_property && !streq(name, arg_property))
1169                 return 0;
1170
1171         switch (dbus_message_iter_get_arg_type(iter)) {
1172
1173         case DBUS_TYPE_STRING: {
1174                 const char *s;
1175                 dbus_message_iter_get_basic(iter, &s);
1176
1177                 if (arg_all || s[0])
1178                         printf("%s=%s\n", name, s);
1179
1180                 return 0;
1181         }
1182
1183         case DBUS_TYPE_BOOLEAN: {
1184                 dbus_bool_t b;
1185                 dbus_message_iter_get_basic(iter, &b);
1186                 printf("%s=%s\n", name, yes_no(b));
1187
1188                 return 0;
1189         }
1190
1191         case DBUS_TYPE_UINT64: {
1192                 uint64_t u;
1193                 dbus_message_iter_get_basic(iter, &u);
1194
1195                 /* Yes, heuristics! But we can change this check
1196                  * should it turn out to not be sufficient */
1197
1198                 if (strstr(name, "Timestamp")) {
1199                         char timestamp[FORMAT_TIMESTAMP_MAX], *t;
1200
1201                         if ((t = format_timestamp(timestamp, sizeof(timestamp), u)) || arg_all)
1202                                 printf("%s=%s\n", name, strempty(t));
1203                 } else if (strstr(name, "USec")) {
1204                         char timespan[FORMAT_TIMESPAN_MAX];
1205
1206                         printf("%s=%s\n", name, format_timespan(timespan, sizeof(timespan), u));
1207                 } else
1208                         printf("%s=%llu\n", name, (unsigned long long) u);
1209
1210                 return 0;
1211         }
1212
1213         case DBUS_TYPE_UINT32: {
1214                 uint32_t u;
1215                 dbus_message_iter_get_basic(iter, &u);
1216
1217                 if (strstr(name, "UMask") || strstr(name, "Mode"))
1218                         printf("%s=%04o\n", name, u);
1219                 else
1220                         printf("%s=%u\n", name, (unsigned) u);
1221
1222                 return 0;
1223         }
1224
1225         case DBUS_TYPE_INT32: {
1226                 int32_t i;
1227                 dbus_message_iter_get_basic(iter, &i);
1228
1229                 printf("%s=%i\n", name, (int) i);
1230                 return 0;
1231         }
1232
1233         case DBUS_TYPE_STRUCT: {
1234                 DBusMessageIter sub;
1235                 dbus_message_iter_recurse(iter, &sub);
1236
1237                 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "Job")) {
1238                         uint32_t u;
1239
1240                         dbus_message_iter_get_basic(&sub, &u);
1241
1242                         if (u)
1243                                 printf("%s=%u\n", name, (unsigned) u);
1244                         else if (arg_all)
1245                                 printf("%s=\n", name);
1246
1247                         return 0;
1248                 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {
1249                         const char *s;
1250
1251                         dbus_message_iter_get_basic(&sub, &s);
1252
1253                         if (arg_all || s[0])
1254                                 printf("%s=%s\n", name, s);
1255
1256                         return 0;
1257                 }
1258
1259                 break;
1260         }
1261
1262         case DBUS_TYPE_ARRAY:
1263
1264                 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) {
1265                         DBusMessageIter sub;
1266                         bool space = false;
1267
1268                         dbus_message_iter_recurse(iter, &sub);
1269
1270                         if (arg_all ||
1271                             dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1272                                 printf("%s=", name);
1273
1274                                 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1275                                         const char *s;
1276
1277                                         assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING);
1278                                         dbus_message_iter_get_basic(&sub, &s);
1279                                         printf("%s%s", space ? " " : "", s);
1280
1281                                         space = true;
1282                                         dbus_message_iter_next(&sub);
1283                                 }
1284
1285                                 puts("");
1286                         }
1287
1288                         return 0;
1289                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_BYTE) {
1290                         DBusMessageIter sub;
1291
1292                         dbus_message_iter_recurse(iter, &sub);
1293
1294                         if (arg_all ||
1295                             dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1296                                 printf("%s=", name);
1297
1298                                 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1299                                         uint8_t u;
1300
1301                                         assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_BYTE);
1302                                         dbus_message_iter_get_basic(&sub, &u);
1303                                         printf("%02x", u);
1304
1305                                         dbus_message_iter_next(&sub);
1306                                 }
1307
1308                                 puts("");
1309                         }
1310
1311                         return 0;
1312                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) {
1313                         DBusMessageIter sub, sub2;
1314
1315                         dbus_message_iter_recurse(iter, &sub);
1316
1317                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
1318                                 const char *type, *path;
1319
1320                                 dbus_message_iter_recurse(&sub, &sub2);
1321
1322                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
1323                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)
1324                                         printf("%s=%s\n", type, path);
1325
1326                                 dbus_message_iter_next(&sub);
1327                         }
1328
1329                         return 0;
1330                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {
1331                         DBusMessageIter sub, sub2;
1332
1333                         dbus_message_iter_recurse(iter, &sub);
1334
1335                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
1336                                 const char *base;
1337                                 uint64_t value, next_elapse;
1338
1339                                 dbus_message_iter_recurse(&sub, &sub2);
1340
1341                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 &&
1342                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 &&
1343                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) {
1344                                         char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
1345
1346                                         printf("%s={ value=%s ; next_elapse=%s }\n",
1347                                                base,
1348                                                format_timespan(timespan1, sizeof(timespan1), value),
1349                                                format_timespan(timespan2, sizeof(timespan2), next_elapse));
1350                                 }
1351
1352                                 dbus_message_iter_next(&sub);
1353                         }
1354
1355                         return 0;
1356                 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) {
1357
1358                         DBusMessageIter sub, sub2, sub3;
1359
1360                         dbus_message_iter_recurse(iter, &sub);
1361
1362                         while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
1363                                 const char *path;
1364                                 uint64_t start_time, exit_time;
1365                                 uint32_t pid;
1366                                 int32_t code, status;
1367
1368                                 dbus_message_iter_recurse(&sub, &sub2);
1369
1370                                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0)
1371                                         continue;
1372
1373                                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY ||
1374                                     dbus_message_iter_get_element_type(&sub2) != DBUS_TYPE_STRING)
1375                                         continue;
1376
1377                                 printf("%s={ path=%s ; argv[]=", name, path);
1378
1379                                 dbus_message_iter_recurse(&sub2, &sub3);
1380
1381                                 while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {
1382                                         const char *s;
1383
1384                                         assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);
1385                                         dbus_message_iter_get_basic(&sub3, &s);
1386                                         printf("%s ", s);
1387                                         dbus_message_iter_next(&sub3);
1388                                 }
1389
1390                                 if (dbus_message_iter_next(&sub2) &&
1391                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_time, true) >= 0 &&
1392                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_time, true) >= 0 &&
1393                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, true) >= 0 &&
1394                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &code, true) >= 0 &&
1395                                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &status, false) >= 0) {
1396
1397                                         char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
1398
1399                                         printf("; start=%s ; stop=%s ; pid=%u ; code=%s ; status=%i/%s",
1400                                                strna(format_timestamp(timestamp1, sizeof(timestamp1), start_time)),
1401                                                strna(format_timestamp(timestamp2, sizeof(timestamp2), exit_time)),
1402                                                (unsigned) pid,
1403                                                sigchld_code_to_string(code),
1404                                                status,
1405                                                strempty(code == CLD_EXITED ? NULL : strsignal(status)));
1406                                 }
1407
1408                                 printf(" }\n");
1409
1410                                 dbus_message_iter_next(&sub);
1411                         }
1412
1413                         return 0;
1414                 }
1415
1416                 break;
1417         }
1418
1419         if (arg_all)
1420                 printf("%s=[unprintable]\n", name);
1421
1422         return 0;
1423 }
1424
1425 static int show_one(DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
1426         DBusMessage *m = NULL, *reply = NULL;
1427         const char *interface = "";
1428         int r;
1429         DBusError error;
1430         DBusMessageIter iter, sub, sub2, sub3;
1431         UnitStatusInfo info;
1432
1433         assert(bus);
1434         assert(path);
1435         assert(new_line);
1436
1437         zero(info);
1438         dbus_error_init(&error);
1439
1440         if (!(m = dbus_message_new_method_call(
1441                               "org.freedesktop.systemd1",
1442                               path,
1443                               "org.freedesktop.DBus.Properties",
1444                               "GetAll"))) {
1445                 log_error("Could not allocate message.");
1446                 r = -ENOMEM;
1447                 goto finish;
1448         }
1449
1450         if (!dbus_message_append_args(m,
1451                                       DBUS_TYPE_STRING, &interface,
1452                                       DBUS_TYPE_INVALID)) {
1453                 log_error("Could not append arguments to message.");
1454                 r = -ENOMEM;
1455                 goto finish;
1456         }
1457
1458         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1459                 log_error("Failed to issue method call: %s", error.message);
1460                 r = -EIO;
1461                 goto finish;
1462         }
1463
1464         if (!dbus_message_iter_init(reply, &iter) ||
1465             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
1466             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY)  {
1467                 log_error("Failed to parse reply.");
1468                 r = -EIO;
1469                 goto finish;
1470         }
1471
1472         dbus_message_iter_recurse(&iter, &sub);
1473
1474         if (*new_line)
1475                 printf("\n");
1476
1477         *new_line = true;
1478
1479         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1480                 const char *name;
1481
1482                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
1483                         log_error("Failed to parse reply.");
1484                         r = -EIO;
1485                         goto finish;
1486                 }
1487
1488                 dbus_message_iter_recurse(&sub, &sub2);
1489
1490                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
1491                         log_error("Failed to parse reply.");
1492                         r = -EIO;
1493                         goto finish;
1494                 }
1495
1496                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT)  {
1497                         log_error("Failed to parse reply.");
1498                         r = -EIO;
1499                         goto finish;
1500                 }
1501
1502                 dbus_message_iter_recurse(&sub2, &sub3);
1503
1504                 if (show_properties)
1505                         r = print_property(name, &sub3);
1506                 else
1507                         r = status_property(name, &sub3, &info);
1508
1509                 if (r < 0) {
1510                         log_error("Failed to parse reply.");
1511                         r = -EIO;
1512                         goto finish;
1513                 }
1514
1515                 dbus_message_iter_next(&sub);
1516         }
1517
1518         if (!show_properties)
1519                 print_status_info(&info);
1520
1521         r = 0;
1522
1523 finish:
1524         if (m)
1525                 dbus_message_unref(m);
1526
1527         if (reply)
1528                 dbus_message_unref(reply);
1529
1530         dbus_error_free(&error);
1531
1532         return r;
1533 }
1534
1535 static int show(DBusConnection *bus, char **args, unsigned n) {
1536         DBusMessage *m = NULL, *reply = NULL;
1537         int r;
1538         DBusError error;
1539         unsigned i;
1540         bool show_properties, new_line = false;
1541
1542         assert(bus);
1543         assert(args);
1544
1545         dbus_error_init(&error);
1546
1547         show_properties = !streq(args[0], "status");
1548
1549         if (show_properties && n <= 1) {
1550                 /* If not argument is specified inspect the manager
1551                  * itself */
1552
1553                 r = show_one(bus, "/org/freedesktop/systemd1", show_properties, &new_line);
1554                 goto finish;
1555         }
1556
1557         for (i = 1; i < n; i++) {
1558                 const char *path = NULL;
1559                 uint32_t id;
1560
1561                 if (!show_properties || safe_atou32(args[i], &id) < 0) {
1562
1563                         if (!(m = dbus_message_new_method_call(
1564                                               "org.freedesktop.systemd1",
1565                                               "/org/freedesktop/systemd1",
1566                                               "org.freedesktop.systemd1.Manager",
1567                                               "LoadUnit"))) {
1568                                 log_error("Could not allocate message.");
1569                                 r = -ENOMEM;
1570                                 goto finish;
1571                         }
1572
1573                         if (!dbus_message_append_args(m,
1574                                                       DBUS_TYPE_STRING, &args[i],
1575                                                       DBUS_TYPE_INVALID)) {
1576                                 log_error("Could not append arguments to message.");
1577                                 r = -ENOMEM;
1578                                 goto finish;
1579                         }
1580
1581                         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1582
1583                                 if (!dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) {
1584                                         log_error("Failed to issue method call: %s", error.message);
1585                                         r = -EIO;
1586                                         goto finish;
1587                                 }
1588
1589                                 dbus_error_free(&error);
1590
1591                                 dbus_message_unref(m);
1592                                 if (!(m = dbus_message_new_method_call(
1593                                                       "org.freedesktop.systemd1",
1594                                                       "/org/freedesktop/systemd1",
1595                                                       "org.freedesktop.systemd1.Manager",
1596                                                       "GetUnit"))) {
1597                                         log_error("Could not allocate message.");
1598                                         r = -ENOMEM;
1599                                         goto finish;
1600                                 }
1601
1602                                 if (!dbus_message_append_args(m,
1603                                                               DBUS_TYPE_STRING, &args[i],
1604                                                               DBUS_TYPE_INVALID)) {
1605                                         log_error("Could not append arguments to message.");
1606                                         r = -ENOMEM;
1607                                         goto finish;
1608                                 }
1609
1610                                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1611                                         log_error("Failed to issue method call: %s", error.message);
1612                                         r = -EIO;
1613                                         goto finish;
1614                                 }
1615                         }
1616
1617                 } else {
1618
1619                         if (!(m = dbus_message_new_method_call(
1620                                               "org.freedesktop.systemd1",
1621                                               "/org/freedesktop/systemd1",
1622                                               "org.freedesktop.systemd1.Manager",
1623                                               "GetJob"))) {
1624                                 log_error("Could not allocate message.");
1625                                 r = -ENOMEM;
1626                                 goto finish;
1627                         }
1628
1629                         if (!dbus_message_append_args(m,
1630                                                       DBUS_TYPE_UINT32, &id,
1631                                                       DBUS_TYPE_INVALID)) {
1632                                 log_error("Could not append arguments to message.");
1633                                 r = -ENOMEM;
1634                                 goto finish;
1635                         }
1636
1637                         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1638                                 log_error("Failed to issue method call: %s", error.message);
1639                                 r = -EIO;
1640                                 goto finish;
1641                         }
1642                 }
1643
1644                 if (!dbus_message_get_args(reply, &error,
1645                                            DBUS_TYPE_OBJECT_PATH, &path,
1646                                            DBUS_TYPE_INVALID)) {
1647                         log_error("Failed to parse reply: %s", error.message);
1648                         r = -EIO;
1649                         goto finish;
1650                 }
1651
1652                 if ((r = show_one(bus, path, show_properties, &new_line)) < 0)
1653                         goto finish;
1654
1655                 dbus_message_unref(m);
1656                 dbus_message_unref(reply);
1657                 m = reply = NULL;
1658         }
1659
1660         r = 0;
1661
1662 finish:
1663         if (m)
1664                 dbus_message_unref(m);
1665
1666         if (reply)
1667                 dbus_message_unref(reply);
1668
1669         dbus_error_free(&error);
1670
1671         return r;
1672 }
1673
1674 static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) {
1675         DBusError error;
1676         DBusMessage *m = NULL, *reply = NULL;
1677
1678         assert(connection);
1679         assert(message);
1680
1681         dbus_error_init(&error);
1682
1683         log_debug("Got D-Bus request: %s.%s() on %s",
1684                   dbus_message_get_interface(message),
1685                   dbus_message_get_member(message),
1686                   dbus_message_get_path(message));
1687
1688         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
1689                 log_error("Warning! D-Bus connection terminated.");
1690                 dbus_connection_close(connection);
1691
1692         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitNew") ||
1693                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {
1694                 const char *id, *path;
1695
1696                 if (!dbus_message_get_args(message, &error,
1697                                            DBUS_TYPE_STRING, &id,
1698                                            DBUS_TYPE_OBJECT_PATH, &path,
1699                                            DBUS_TYPE_INVALID))
1700                         log_error("Failed to parse message: %s", error.message);
1701                 else if (streq(dbus_message_get_member(message), "UnitNew"))
1702                         printf("Unit %s added.\n", id);
1703                 else
1704                         printf("Unit %s removed.\n", id);
1705
1706         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobNew") ||
1707                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
1708                 uint32_t id;
1709                 const char *path;
1710
1711                 if (!dbus_message_get_args(message, &error,
1712                                            DBUS_TYPE_UINT32, &id,
1713                                            DBUS_TYPE_OBJECT_PATH, &path,
1714                                            DBUS_TYPE_INVALID))
1715                         log_error("Failed to parse message: %s", error.message);
1716                 else if (streq(dbus_message_get_member(message), "JobNew"))
1717                         printf("Job %u added.\n", id);
1718                 else
1719                         printf("Job %u removed.\n", id);
1720
1721
1722         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Unit", "Changed") ||
1723                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Job", "Changed")) {
1724
1725                 const char *path, *interface, *property = "Id";
1726                 DBusMessageIter iter, sub;
1727
1728                 path = dbus_message_get_path(message);
1729                 interface = dbus_message_get_interface(message);
1730
1731                 if (!(m = dbus_message_new_method_call(
1732                               "org.freedesktop.systemd1",
1733                               path,
1734                               "org.freedesktop.DBus.Properties",
1735                               "Get"))) {
1736                         log_error("Could not allocate message.");
1737                         goto oom;
1738                 }
1739
1740                 if (!dbus_message_append_args(m,
1741                                               DBUS_TYPE_STRING, &interface,
1742                                               DBUS_TYPE_STRING, &property,
1743                                               DBUS_TYPE_INVALID)) {
1744                         log_error("Could not append arguments to message.");
1745                         goto finish;
1746                 }
1747
1748                 if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) {
1749                         log_error("Failed to issue method call: %s", error.message);
1750                         goto finish;
1751                 }
1752
1753                 if (!dbus_message_iter_init(reply, &iter) ||
1754                     dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
1755                         log_error("Failed to parse reply.");
1756                         goto finish;
1757                 }
1758
1759                 dbus_message_iter_recurse(&iter, &sub);
1760
1761                 if (streq(interface, "org.freedesktop.systemd1.Unit")) {
1762                         const char *id;
1763
1764                         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
1765                                 log_error("Failed to parse reply.");
1766                                 goto finish;
1767                         }
1768
1769                         dbus_message_iter_get_basic(&sub, &id);
1770                         printf("Unit %s changed.\n", id);
1771                 } else {
1772                         uint32_t id;
1773
1774                         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)  {
1775                                 log_error("Failed to parse reply.");
1776                                 goto finish;
1777                         }
1778
1779                         dbus_message_iter_get_basic(&sub, &id);
1780                         printf("Job %u changed.\n", id);
1781                 }
1782         }
1783
1784 finish:
1785         if (m)
1786                 dbus_message_unref(m);
1787
1788         if (reply)
1789                 dbus_message_unref(reply);
1790
1791         dbus_error_free(&error);
1792         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1793
1794 oom:
1795         if (m)
1796                 dbus_message_unref(m);
1797
1798         if (reply)
1799                 dbus_message_unref(reply);
1800
1801         dbus_error_free(&error);
1802         return DBUS_HANDLER_RESULT_NEED_MEMORY;
1803 }
1804
1805 static int monitor(DBusConnection *bus, char **args, unsigned n) {
1806         DBusMessage *m = NULL, *reply = NULL;
1807         DBusError error;
1808         int r;
1809
1810         dbus_error_init(&error);
1811
1812         if (!private_bus) {
1813                 dbus_bus_add_match(bus,
1814                                    "type='signal',"
1815                                    "sender='org.freedesktop.systemd1',"
1816                                    "interface='org.freedesktop.systemd1.Manager',"
1817                                    "path='/org/freedesktop/systemd1'",
1818                                    &error);
1819
1820                 if (dbus_error_is_set(&error)) {
1821                         log_error("Failed to add match: %s", error.message);
1822                         r = -EIO;
1823                         goto finish;
1824                 }
1825
1826                 dbus_bus_add_match(bus,
1827                                    "type='signal',"
1828                                    "sender='org.freedesktop.systemd1',"
1829                                    "interface='org.freedesktop.systemd1.Unit',"
1830                                    "member='Changed'",
1831                                    &error);
1832
1833                 if (dbus_error_is_set(&error)) {
1834                         log_error("Failed to add match: %s", error.message);
1835                         r = -EIO;
1836                         goto finish;
1837                 }
1838
1839                 dbus_bus_add_match(bus,
1840                                    "type='signal',"
1841                                    "sender='org.freedesktop.systemd1',"
1842                                    "interface='org.freedesktop.systemd1.Job',"
1843                                    "member='Changed'",
1844                                    &error);
1845
1846                 if (dbus_error_is_set(&error)) {
1847                         log_error("Failed to add match: %s", error.message);
1848                         r = -EIO;
1849                         goto finish;
1850                 }
1851         }
1852
1853         if (!dbus_connection_add_filter(bus, monitor_filter, NULL, NULL)) {
1854                 log_error("Failed to add filter.");
1855                 r = -ENOMEM;
1856                 goto finish;
1857         }
1858
1859         if (!(m = dbus_message_new_method_call(
1860                               "org.freedesktop.systemd1",
1861                               "/org/freedesktop/systemd1",
1862                               "org.freedesktop.systemd1.Manager",
1863                               "Subscribe"))) {
1864                 log_error("Could not allocate message.");
1865                 r = -ENOMEM;
1866                 goto finish;
1867         }
1868
1869         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1870                 log_error("Failed to issue method call: %s", error.message);
1871                 r = -EIO;
1872                 goto finish;
1873         }
1874
1875         while (dbus_connection_read_write_dispatch(bus, -1))
1876                 ;
1877
1878         r = 0;
1879
1880 finish:
1881
1882         /* This is slightly dirty, since we don't undo the filter or the matches. */
1883
1884         if (m)
1885                 dbus_message_unref(m);
1886
1887         if (reply)
1888                 dbus_message_unref(reply);
1889
1890         dbus_error_free(&error);
1891
1892         return r;
1893 }
1894
1895 static int dump(DBusConnection *bus, char **args, unsigned n) {
1896         DBusMessage *m = NULL, *reply = NULL;
1897         DBusError error;
1898         int r;
1899         const char *text;
1900
1901         dbus_error_init(&error);
1902
1903         if (!(m = dbus_message_new_method_call(
1904                               "org.freedesktop.systemd1",
1905                               "/org/freedesktop/systemd1",
1906                               "org.freedesktop.systemd1.Manager",
1907                               "Dump"))) {
1908                 log_error("Could not allocate message.");
1909                 return -ENOMEM;
1910         }
1911
1912         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1913                 log_error("Failed to issue method call: %s", error.message);
1914                 r = -EIO;
1915                 goto finish;
1916         }
1917
1918         if (!dbus_message_get_args(reply, &error,
1919                                    DBUS_TYPE_STRING, &text,
1920                                    DBUS_TYPE_INVALID)) {
1921                 log_error("Failed to parse reply: %s", error.message);
1922                 r = -EIO;
1923                 goto finish;
1924         }
1925
1926         fputs(text, stdout);
1927
1928         r = 0;
1929
1930 finish:
1931         if (m)
1932                 dbus_message_unref(m);
1933
1934         if (reply)
1935                 dbus_message_unref(reply);
1936
1937         dbus_error_free(&error);
1938
1939         return r;
1940 }
1941
1942 static int snapshot(DBusConnection *bus, char **args, unsigned n) {
1943         DBusMessage *m = NULL, *reply = NULL;
1944         DBusError error;
1945         int r;
1946         const char *name = "", *path, *id;
1947         dbus_bool_t cleanup = FALSE;
1948         DBusMessageIter iter, sub;
1949         const char
1950                 *interface = "org.freedesktop.systemd1.Unit",
1951                 *property = "Id";
1952
1953         dbus_error_init(&error);
1954
1955         if (!(m = dbus_message_new_method_call(
1956                               "org.freedesktop.systemd1",
1957                               "/org/freedesktop/systemd1",
1958                               "org.freedesktop.systemd1.Manager",
1959                               "CreateSnapshot"))) {
1960                 log_error("Could not allocate message.");
1961                 return -ENOMEM;
1962         }
1963
1964         if (n > 1)
1965                 name = args[1];
1966
1967         if (!dbus_message_append_args(m,
1968                                       DBUS_TYPE_STRING, &name,
1969                                       DBUS_TYPE_BOOLEAN, &cleanup,
1970                                       DBUS_TYPE_INVALID)) {
1971                 log_error("Could not append arguments to message.");
1972                 r = -ENOMEM;
1973                 goto finish;
1974         }
1975
1976         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1977                 log_error("Failed to issue method call: %s", error.message);
1978                 r = -EIO;
1979                 goto finish;
1980         }
1981
1982         if (!dbus_message_get_args(reply, &error,
1983                                    DBUS_TYPE_OBJECT_PATH, &path,
1984                                    DBUS_TYPE_INVALID)) {
1985                 log_error("Failed to parse reply: %s", error.message);
1986                 r = -EIO;
1987                 goto finish;
1988         }
1989
1990         dbus_message_unref(m);
1991         if (!(m = dbus_message_new_method_call(
1992                               "org.freedesktop.systemd1",
1993                               path,
1994                               "org.freedesktop.DBus.Properties",
1995                               "Get"))) {
1996                 log_error("Could not allocate message.");
1997                 return -ENOMEM;
1998         }
1999
2000         if (!dbus_message_append_args(m,
2001                                       DBUS_TYPE_STRING, &interface,
2002                                       DBUS_TYPE_STRING, &property,
2003                                       DBUS_TYPE_INVALID)) {
2004                 log_error("Could not append arguments to message.");
2005                 r = -ENOMEM;
2006                 goto finish;
2007         }
2008
2009         dbus_message_unref(reply);
2010         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2011                 log_error("Failed to issue method call: %s", error.message);
2012                 r = -EIO;
2013                 goto finish;
2014         }
2015
2016         if (!dbus_message_iter_init(reply, &iter) ||
2017             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
2018                 log_error("Failed to parse reply.");
2019                 r = -EIO;
2020                 goto finish;
2021         }
2022
2023         dbus_message_iter_recurse(&iter, &sub);
2024
2025         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
2026                 log_error("Failed to parse reply.");
2027                 r = -EIO;
2028                 goto finish;
2029         }
2030
2031         dbus_message_iter_get_basic(&sub, &id);
2032
2033         if (!arg_quiet)
2034                 puts(id);
2035         r = 0;
2036
2037 finish:
2038         if (m)
2039                 dbus_message_unref(m);
2040
2041         if (reply)
2042                 dbus_message_unref(reply);
2043
2044         dbus_error_free(&error);
2045
2046         return r;
2047 }
2048
2049 static int delete_snapshot(DBusConnection *bus, char **args, unsigned n) {
2050         DBusMessage *m = NULL, *reply = NULL;
2051         int r;
2052         DBusError error;
2053         unsigned i;
2054
2055         assert(bus);
2056         assert(args);
2057
2058         dbus_error_init(&error);
2059
2060         for (i = 1; i < n; i++) {
2061                 const char *path = NULL;
2062
2063                 if (!(m = dbus_message_new_method_call(
2064                                       "org.freedesktop.systemd1",
2065                                       "/org/freedesktop/systemd1",
2066                                       "org.freedesktop.systemd1.Manager",
2067                                       "GetUnit"))) {
2068                         log_error("Could not allocate message.");
2069                         r = -ENOMEM;
2070                         goto finish;
2071                 }
2072
2073                 if (!dbus_message_append_args(m,
2074                                               DBUS_TYPE_STRING, &args[i],
2075                                               DBUS_TYPE_INVALID)) {
2076                         log_error("Could not append arguments to message.");
2077                         r = -ENOMEM;
2078                         goto finish;
2079                 }
2080
2081                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2082                         log_error("Failed to issue method call: %s", error.message);
2083                         r = -EIO;
2084                         goto finish;
2085                 }
2086
2087                 if (!dbus_message_get_args(reply, &error,
2088                                            DBUS_TYPE_OBJECT_PATH, &path,
2089                                            DBUS_TYPE_INVALID)) {
2090                         log_error("Failed to parse reply: %s", error.message);
2091                         r = -EIO;
2092                         goto finish;
2093                 }
2094
2095                 dbus_message_unref(m);
2096                 if (!(m = dbus_message_new_method_call(
2097                                       "org.freedesktop.systemd1",
2098                                       path,
2099                                       "org.freedesktop.systemd1.Snapshot",
2100                                       "Remove"))) {
2101                         log_error("Could not allocate message.");
2102                         r = -ENOMEM;
2103                         goto finish;
2104                 }
2105
2106                 dbus_message_unref(reply);
2107                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2108                         log_error("Failed to issue method call: %s", error.message);
2109                         r = -EIO;
2110                         goto finish;
2111                 }
2112
2113                 dbus_message_unref(m);
2114                 dbus_message_unref(reply);
2115                 m = reply = NULL;
2116         }
2117
2118         r = 0;
2119
2120 finish:
2121         if (m)
2122                 dbus_message_unref(m);
2123
2124         if (reply)
2125                 dbus_message_unref(reply);
2126
2127         dbus_error_free(&error);
2128
2129         return r;
2130 }
2131
2132 static int clear_jobs(DBusConnection *bus, char **args, unsigned n) {
2133         DBusMessage *m = NULL, *reply = NULL;
2134         DBusError error;
2135         int r;
2136         const char *method;
2137
2138         dbus_error_init(&error);
2139
2140         if (arg_action == ACTION_RELOAD)
2141                 method = "Reload";
2142         else if (arg_action == ACTION_REEXEC)
2143                 method = "Reexecute";
2144         else {
2145                 assert(arg_action == ACTION_SYSTEMCTL);
2146
2147                 method =
2148                         streq(args[0], "clear-jobs")    ? "ClearJobs" :
2149                         streq(args[0], "daemon-reload") ? "Reload" :
2150                         streq(args[0], "daemon-reexec") ? "Reexecute" :
2151                                                           "Exit";
2152         }
2153
2154         if (!(m = dbus_message_new_method_call(
2155                               "org.freedesktop.systemd1",
2156                               "/org/freedesktop/systemd1",
2157                               "org.freedesktop.systemd1.Manager",
2158                               method))) {
2159                 log_error("Could not allocate message.");
2160                 return -ENOMEM;
2161         }
2162
2163         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2164
2165                 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
2166                         /* There's always a fallback possible for
2167                          * legacy actions. */
2168                         r = 0;
2169                         goto finish;
2170                 }
2171
2172                 log_error("Failed to issue method call: %s", error.message);
2173                 r = -EIO;
2174                 goto finish;
2175         }
2176
2177         r = 1;
2178
2179 finish:
2180         if (m)
2181                 dbus_message_unref(m);
2182
2183         if (reply)
2184                 dbus_message_unref(reply);
2185
2186         dbus_error_free(&error);
2187
2188         return r;
2189 }
2190
2191 static int show_enviroment(DBusConnection *bus, char **args, unsigned n) {
2192         DBusMessage *m = NULL, *reply = NULL;
2193         DBusError error;
2194         DBusMessageIter iter, sub, sub2;
2195         int r;
2196         const char
2197                 *interface = "org.freedesktop.systemd1.Manager",
2198                 *property = "Environment";
2199
2200         dbus_error_init(&error);
2201
2202         if (!(m = dbus_message_new_method_call(
2203                               "org.freedesktop.systemd1",
2204                               "/org/freedesktop/systemd1",
2205                               "org.freedesktop.DBus.Properties",
2206                               "Get"))) {
2207                 log_error("Could not allocate message.");
2208                 return -ENOMEM;
2209         }
2210
2211         if (!dbus_message_append_args(m,
2212                                       DBUS_TYPE_STRING, &interface,
2213                                       DBUS_TYPE_STRING, &property,
2214                                       DBUS_TYPE_INVALID)) {
2215                 log_error("Could not append arguments to message.");
2216                 r = -ENOMEM;
2217                 goto finish;
2218         }
2219
2220         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2221                 log_error("Failed to issue method call: %s", error.message);
2222                 r = -EIO;
2223                 goto finish;
2224         }
2225
2226         if (!dbus_message_iter_init(reply, &iter) ||
2227             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
2228                 log_error("Failed to parse reply.");
2229                 r = -EIO;
2230                 goto finish;
2231         }
2232
2233         dbus_message_iter_recurse(&iter, &sub);
2234
2235         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY ||
2236             dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING)  {
2237                 log_error("Failed to parse reply.");
2238                 r = -EIO;
2239                 goto finish;
2240         }
2241
2242         dbus_message_iter_recurse(&sub, &sub2);
2243
2244         while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) {
2245                 const char *text;
2246
2247                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
2248                         log_error("Failed to parse reply.");
2249                         r = -EIO;
2250                         goto finish;
2251                 }
2252
2253                 dbus_message_iter_get_basic(&sub2, &text);
2254                 printf("%s\n", text);
2255
2256                 dbus_message_iter_next(&sub2);
2257         }
2258
2259         r = 0;
2260
2261 finish:
2262         if (m)
2263                 dbus_message_unref(m);
2264
2265         if (reply)
2266                 dbus_message_unref(reply);
2267
2268         dbus_error_free(&error);
2269
2270         return r;
2271 }
2272
2273 static int set_environment(DBusConnection *bus, char **args, unsigned n) {
2274         DBusMessage *m = NULL, *reply = NULL;
2275         DBusError error;
2276         int r;
2277         const char *method;
2278         DBusMessageIter iter, sub;
2279         unsigned i;
2280
2281         dbus_error_init(&error);
2282
2283         method = streq(args[0], "set-environment")
2284                 ? "SetEnvironment"
2285                 : "UnsetEnvironment";
2286
2287         if (!(m = dbus_message_new_method_call(
2288                               "org.freedesktop.systemd1",
2289                               "/org/freedesktop/systemd1",
2290                               "org.freedesktop.systemd1.Manager",
2291                               method))) {
2292
2293                 log_error("Could not allocate message.");
2294                 return -ENOMEM;
2295         }
2296
2297         dbus_message_iter_init_append(m, &iter);
2298
2299         if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
2300                 log_error("Could not append arguments to message.");
2301                 r = -ENOMEM;
2302                 goto finish;
2303         }
2304
2305         for (i = 1; i < n; i++)
2306                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &args[i])) {
2307                         log_error("Could not append arguments to message.");
2308                         r = -ENOMEM;
2309                         goto finish;
2310                 }
2311
2312         if (!dbus_message_iter_close_container(&iter, &sub)) {
2313                 log_error("Could not append arguments to message.");
2314                 r = -ENOMEM;
2315                 goto finish;
2316         }
2317
2318         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2319                 log_error("Failed to issue method call: %s", error.message);
2320                 r = -EIO;
2321                 goto finish;
2322         }
2323
2324         r = 0;
2325
2326 finish:
2327         if (m)
2328                 dbus_message_unref(m);
2329
2330         if (reply)
2331                 dbus_message_unref(reply);
2332
2333         dbus_error_free(&error);
2334
2335         return r;
2336 }
2337
2338 static int systemctl_help(void) {
2339
2340         printf("%s [OPTIONS...] {COMMAND} ...\n\n"
2341                "Send control commands to the systemd manager.\n\n"
2342                "  -h --help          Show this help\n"
2343                "  -t --type=TYPE     List only units of a particular type\n"
2344                "  -p --property=NAME Show only properties by this name\n"
2345                "  -a --all           Show all units/properties, including dead/empty ones\n"
2346                "     --replace       When installing a new job, replace existing conflicting ones\n"
2347                "     --system        Connect to system bus\n"
2348                "     --session       Connect to session bus\n"
2349                "  -q --quiet         Suppress output\n"
2350                "     --no-block      Do not wait until operation finished\n"
2351                "     --no-wall       Don't send wall message before halt/power-off/reboot\n\n"
2352                "Commands:\n"
2353                "  list-units                      List units\n"
2354                "  start [NAME...]                 Start one or more units\n"
2355                "  stop [NAME...]                  Stop one or more units\n"
2356                "  restart [NAME...]               Restart one or more units\n"
2357                "  reload [NAME...]                Reload one or more units\n"
2358                "  isolate [NAME]                  Start one unit and stop all others\n"
2359                "  check [NAME...]                 Check whether any of the passed units are active\n"
2360                "  status [NAME...]                Show status of one or more units\n"
2361                "  show [NAME...|JOB...]           Show properties of one or more units/jobs/manager\n"
2362                "  load [NAME...]                  Load one or more units\n"
2363                "  list-jobs                       List jobs\n"
2364                "  cancel [JOB...]                 Cancel one or more jobs\n"
2365                "  clear-jobs                      Cancel all jobs\n"
2366                "  monitor                         Monitor unit/job changes\n"
2367                "  dump                            Dump server status\n"
2368                "  snapshot [NAME]                 Create a snapshot\n"
2369                "  delete [NAME...]                Remove one or more snapshots\n"
2370                "  daemon-reload                   Reload systemd manager configuration\n"
2371                "  daemon-reexec                   Reexecute systemd manager\n"
2372                "  daemon-exit                     Ask the systemd manager to quit\n"
2373                "  show-environment                Dump environment\n"
2374                "  set-environment [NAME=VALUE...] Set one or more environment variables\n"
2375                "  unset-environment [NAME...]     Unset one or more environment variables\n"
2376                "  halt                            Shut down and halt the system\n"
2377                "  poweroff                        Shut down and power-off the system\n"
2378                "  reboot                          Shut down and reboot the system\n"
2379                "  default                         Enter default mode\n"
2380                "  rescue                          Enter rescue mode\n"
2381                "  emergency                       Enter emergency mode\n",
2382                program_invocation_short_name);
2383
2384         return 0;
2385 }
2386
2387 static int halt_help(void) {
2388
2389         printf("%s [OPTIONS...]\n\n"
2390                "%s the system.\n\n"
2391                "     --help      Show this help\n"
2392                "     --halt      Halt the machine\n"
2393                "  -p --poweroff  Switch off the machine\n"
2394                "     --reboot    Reboot the machine\n"
2395                "  -f --force     Force immediate halt/power-off/reboot\n"
2396                "  -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
2397                "  -d --no-wtmp   Don't write wtmp record\n"
2398                "  -n --no-sync   Don't sync before halt/power-off/reboot\n"
2399                "     --no-wall   Don't send wall message before halt/power-off/reboot\n",
2400                program_invocation_short_name,
2401                arg_action == ACTION_REBOOT   ? "Reboot" :
2402                arg_action == ACTION_POWEROFF ? "Power off" :
2403                                                "Halt");
2404
2405         return 0;
2406 }
2407
2408 static int shutdown_help(void) {
2409
2410         printf("%s [OPTIONS...] [now] [WALL...]\n\n"
2411                "Shut down the system.\n\n"
2412                "     --help      Show this help\n"
2413                "  -H --halt      Halt the machine\n"
2414                "  -P --poweroff  Power-off the machine\n"
2415                "  -r --reboot    Reboot the machine\n"
2416                "  -h             Equivalent to --poweroff, overriden by --halt\n"
2417                "  -k             Don't halt/power-off/reboot, just send warnings\n"
2418                "     --no-wall   Don't send wall message before halt/power-off/reboot\n",
2419                program_invocation_short_name);
2420
2421         return 0;
2422 }
2423
2424 static int telinit_help(void) {
2425
2426         printf("%s [OPTIONS...] {COMMAND}\n\n"
2427                "Send control commands to the init daemon.\n\n"
2428                "     --help      Show this help\n"
2429                "     --no-wall   Don't send wall message before halt/power-off/reboot\n\n"
2430                "Commands:\n"
2431                "  0              Power-off the machine\n"
2432                "  6              Reboot the machine\n"
2433                "  2, 3, 4, 5     Start runlevelX.target unit\n"
2434                "  1, s, S        Enter rescue mode\n"
2435                "  q, Q           Reload init daemon configuration\n"
2436                "  u, U           Reexecute init daemon\n",
2437                program_invocation_short_name);
2438
2439         return 0;
2440 }
2441
2442 static int runlevel_help(void) {
2443
2444         printf("%s [OPTIONS...]\n\n"
2445                "Prints the previous and current runlevel of the init system.\n\n"
2446                "     --help      Show this help\n",
2447                program_invocation_short_name);
2448
2449         return 0;
2450 }
2451
2452 static int systemctl_parse_argv(int argc, char *argv[]) {
2453
2454         enum {
2455                 ARG_REPLACE = 0x100,
2456                 ARG_SESSION,
2457                 ARG_SYSTEM,
2458                 ARG_NO_BLOCK,
2459                 ARG_NO_WALL
2460         };
2461
2462         static const struct option options[] = {
2463                 { "help",      no_argument,       NULL, 'h'          },
2464                 { "type",      required_argument, NULL, 't'          },
2465                 { "property",  required_argument, NULL, 'p'          },
2466                 { "all",       no_argument,       NULL, 'a'          },
2467                 { "replace",   no_argument,       NULL, ARG_REPLACE  },
2468                 { "session",   no_argument,       NULL, ARG_SESSION  },
2469                 { "system",    no_argument,       NULL, ARG_SYSTEM   },
2470                 { "no-block",  no_argument,       NULL, ARG_NO_BLOCK },
2471                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL  },
2472                 { "quiet",     no_argument,       NULL, 'q'          },
2473                 { NULL,        0,                 NULL, 0            }
2474         };
2475
2476         int c;
2477
2478         assert(argc >= 0);
2479         assert(argv);
2480
2481         while ((c = getopt_long(argc, argv, "ht:p:aq", options, NULL)) >= 0) {
2482
2483                 switch (c) {
2484
2485                 case 'h':
2486                         systemctl_help();
2487                         return 0;
2488
2489                 case 't':
2490                         arg_type = optarg;
2491                         break;
2492
2493                 case 'p':
2494                         arg_property = optarg;
2495
2496                         /* If the user asked for a particular
2497                          * property, show it to him, even if it is
2498                          * empty. */
2499                         arg_all = true;
2500                         break;
2501
2502                 case 'a':
2503                         arg_all = true;
2504                         break;
2505
2506                 case ARG_REPLACE:
2507                         arg_replace = true;
2508                         break;
2509
2510                 case ARG_SESSION:
2511                         arg_session = true;
2512                         break;
2513
2514                 case ARG_SYSTEM:
2515                         arg_session = false;
2516                         break;
2517
2518                 case ARG_NO_BLOCK:
2519                         arg_no_block = true;
2520                         break;
2521
2522                 case ARG_NO_WALL:
2523                         arg_no_wall = true;
2524                         break;
2525
2526                 case 'q':
2527                         arg_quiet = true;
2528                         break;
2529
2530                 case '?':
2531                         return -EINVAL;
2532
2533                 default:
2534                         log_error("Unknown option code %c", c);
2535                         return -EINVAL;
2536                 }
2537         }
2538
2539         return 1;
2540 }
2541
2542 static int halt_parse_argv(int argc, char *argv[]) {
2543
2544         enum {
2545                 ARG_HELP = 0x100,
2546                 ARG_HALT,
2547                 ARG_REBOOT,
2548                 ARG_NO_WALL
2549         };
2550
2551         static const struct option options[] = {
2552                 { "help",      no_argument,       NULL, ARG_HELP    },
2553                 { "halt",      no_argument,       NULL, ARG_HALT    },
2554                 { "poweroff",  no_argument,       NULL, 'p'         },
2555                 { "reboot",    no_argument,       NULL, ARG_REBOOT  },
2556                 { "force",     no_argument,       NULL, 'f'         },
2557                 { "wtmp-only", no_argument,       NULL, 'w'         },
2558                 { "no-wtmp",   no_argument,       NULL, 'd'         },
2559                 { "no-sync",   no_argument,       NULL, 'n'         },
2560                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
2561                 { NULL,        0,                 NULL, 0           }
2562         };
2563
2564         int c, runlevel;
2565
2566         assert(argc >= 0);
2567         assert(argv);
2568
2569         if (utmp_get_runlevel(&runlevel, NULL) >= 0)
2570                 if (runlevel == '0' || runlevel == '6')
2571                         arg_immediate = true;
2572
2573         while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) {
2574                 switch (c) {
2575
2576                 case ARG_HELP:
2577                         halt_help();
2578                         return 0;
2579
2580                 case ARG_HALT:
2581                         arg_action = ACTION_HALT;
2582                         break;
2583
2584                 case 'p':
2585                         arg_action = ACTION_POWEROFF;
2586                         break;
2587
2588                 case ARG_REBOOT:
2589                         arg_action = ACTION_REBOOT;
2590                         break;
2591
2592                 case 'f':
2593                         arg_immediate = true;
2594                         break;
2595
2596                 case 'w':
2597                         arg_dry = true;
2598                         break;
2599
2600                 case 'd':
2601                         arg_no_wtmp = true;
2602                         break;
2603
2604                 case 'n':
2605                         arg_no_sync = true;
2606                         break;
2607
2608                 case ARG_NO_WALL:
2609                         arg_no_wall = true;
2610                         break;
2611
2612                 case 'i':
2613                 case 'h':
2614                         /* Compatibility nops */
2615                         break;
2616
2617                 case '?':
2618                         return -EINVAL;
2619
2620                 default:
2621                         log_error("Unknown option code %c", c);
2622                         return -EINVAL;
2623                 }
2624         }
2625
2626         if (optind < argc) {
2627                 log_error("Too many arguments.");
2628                 return -EINVAL;
2629         }
2630
2631         return 1;
2632 }
2633
2634 static int shutdown_parse_argv(int argc, char *argv[]) {
2635
2636         enum {
2637                 ARG_HELP = 0x100,
2638                 ARG_NO_WALL
2639         };
2640
2641         static const struct option options[] = {
2642                 { "help",      no_argument,       NULL, ARG_HELP    },
2643                 { "halt",      no_argument,       NULL, 'H'         },
2644                 { "poweroff",  no_argument,       NULL, 'P'         },
2645                 { "reboot",    no_argument,       NULL, 'r'         },
2646                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
2647                 { NULL,        0,                 NULL, 0           }
2648         };
2649
2650         int c;
2651
2652         assert(argc >= 0);
2653         assert(argv);
2654
2655         while ((c = getopt_long(argc, argv, "HPrhkt:a", options, NULL)) >= 0) {
2656                 switch (c) {
2657
2658                 case ARG_HELP:
2659                         shutdown_help();
2660                         return 0;
2661
2662                 case 'H':
2663                         arg_action = ACTION_HALT;
2664                         break;
2665
2666                 case 'P':
2667                         arg_action = ACTION_POWEROFF;
2668                         break;
2669
2670                 case 'r':
2671                         arg_action = ACTION_REBOOT;
2672                         break;
2673
2674                 case 'h':
2675                         if (arg_action != ACTION_HALT)
2676                                 arg_action = ACTION_POWEROFF;
2677                         break;
2678
2679                 case 'k':
2680                         arg_dry = true;
2681                         break;
2682
2683                 case ARG_NO_WALL:
2684                         arg_no_wall = true;
2685                         break;
2686
2687                 case 't':
2688                 case 'a':
2689                         /* Compatibility nops */
2690                         break;
2691
2692                 case '?':
2693                         return -EINVAL;
2694
2695                 default:
2696                         log_error("Unknown option code %c", c);
2697                         return -EINVAL;
2698                 }
2699         }
2700
2701         if (argc > optind && !streq(argv[optind], "now"))
2702                 log_warning("First argument '%s' isn't 'now'. Ignoring.", argv[optind]);
2703
2704         /* We ignore the time argument */
2705         if (argc > optind + 1)
2706                 arg_wall = argv + optind + 1;
2707
2708         optind = argc;
2709
2710         return 1;
2711 }
2712
2713 static int telinit_parse_argv(int argc, char *argv[]) {
2714
2715         enum {
2716                 ARG_HELP = 0x100,
2717                 ARG_NO_WALL
2718         };
2719
2720         static const struct option options[] = {
2721                 { "help",      no_argument,       NULL, ARG_HELP    },
2722                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
2723                 { NULL,        0,                 NULL, 0           }
2724         };
2725
2726         static const struct {
2727                 char from;
2728                 enum action to;
2729         } table[] = {
2730                 { '0', ACTION_POWEROFF },
2731                 { '6', ACTION_REBOOT },
2732                 { '1', ACTION_RESCUE },
2733                 { '2', ACTION_RUNLEVEL2 },
2734                 { '3', ACTION_RUNLEVEL3 },
2735                 { '4', ACTION_RUNLEVEL4 },
2736                 { '5', ACTION_RUNLEVEL5 },
2737                 { 's', ACTION_RESCUE },
2738                 { 'S', ACTION_RESCUE },
2739                 { 'q', ACTION_RELOAD },
2740                 { 'Q', ACTION_RELOAD },
2741                 { 'u', ACTION_REEXEC },
2742                 { 'U', ACTION_REEXEC }
2743         };
2744
2745         unsigned i;
2746         int c;
2747
2748         assert(argc >= 0);
2749         assert(argv);
2750
2751         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
2752                 switch (c) {
2753
2754                 case ARG_HELP:
2755                         telinit_help();
2756                         return 0;
2757
2758                 case ARG_NO_WALL:
2759                         arg_no_wall = true;
2760                         break;
2761
2762                 case '?':
2763                         return -EINVAL;
2764
2765                 default:
2766                         log_error("Unknown option code %c", c);
2767                         return -EINVAL;
2768                 }
2769         }
2770
2771         if (optind >= argc) {
2772                 telinit_help();
2773                 return -EINVAL;
2774         }
2775
2776         if (optind + 1 < argc) {
2777                 log_error("Too many arguments.");
2778                 return -EINVAL;
2779         }
2780
2781         if (strlen(argv[optind]) != 1) {
2782                 log_error("Expected single character argument.");
2783                 return -EINVAL;
2784         }
2785
2786         for (i = 0; i < ELEMENTSOF(table); i++)
2787                 if (table[i].from == argv[optind][0])
2788                         break;
2789
2790         if (i >= ELEMENTSOF(table)) {
2791                 log_error("Unknown command %s.", argv[optind]);
2792                 return -EINVAL;
2793         }
2794
2795         arg_action = table[i].to;
2796
2797         optind ++;
2798
2799         return 1;
2800 }
2801
2802 static int runlevel_parse_argv(int argc, char *argv[]) {
2803
2804         enum {
2805                 ARG_HELP = 0x100,
2806         };
2807
2808         static const struct option options[] = {
2809                 { "help",      no_argument,       NULL, ARG_HELP    },
2810                 { NULL,        0,                 NULL, 0           }
2811         };
2812
2813         int c;
2814
2815         assert(argc >= 0);
2816         assert(argv);
2817
2818         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
2819                 switch (c) {
2820
2821                 case ARG_HELP:
2822                         runlevel_help();
2823                         return 0;
2824
2825                 case '?':
2826                         return -EINVAL;
2827
2828                 default:
2829                         log_error("Unknown option code %c", c);
2830                         return -EINVAL;
2831                 }
2832         }
2833
2834         if (optind < argc) {
2835                 log_error("Too many arguments.");
2836                 return -EINVAL;
2837         }
2838
2839         return 1;
2840 }
2841
2842 static int parse_argv(int argc, char *argv[]) {
2843         assert(argc >= 0);
2844         assert(argv);
2845
2846         if (program_invocation_short_name) {
2847
2848                 if (strstr(program_invocation_short_name, "halt")) {
2849                         arg_action = ACTION_HALT;
2850                         return halt_parse_argv(argc, argv);
2851                 } else if (strstr(program_invocation_short_name, "poweroff")) {
2852                         arg_action = ACTION_POWEROFF;
2853                         return halt_parse_argv(argc, argv);
2854                 } else if (strstr(program_invocation_short_name, "reboot")) {
2855                         arg_action = ACTION_REBOOT;
2856                         return halt_parse_argv(argc, argv);
2857                 } else if (strstr(program_invocation_short_name, "shutdown")) {
2858                         arg_action = ACTION_POWEROFF;
2859                         return shutdown_parse_argv(argc, argv);
2860                 } else if (strstr(program_invocation_short_name, "init")) {
2861                         arg_action = ACTION_INVALID;
2862                         return telinit_parse_argv(argc, argv);
2863                 } else if (strstr(program_invocation_short_name, "runlevel")) {
2864                         arg_action = ACTION_RUNLEVEL;
2865                         return runlevel_parse_argv(argc, argv);
2866                 }
2867         }
2868
2869         arg_action = ACTION_SYSTEMCTL;
2870         return systemctl_parse_argv(argc, argv);
2871 }
2872
2873 static int action_to_runlevel(void) {
2874
2875         static const char table[_ACTION_MAX] = {
2876                 [ACTION_HALT] =      '0',
2877                 [ACTION_POWEROFF] =  '0',
2878                 [ACTION_REBOOT] =    '6',
2879                 [ACTION_RUNLEVEL2] = '2',
2880                 [ACTION_RUNLEVEL3] = '3',
2881                 [ACTION_RUNLEVEL4] = '4',
2882                 [ACTION_RUNLEVEL5] = '5',
2883                 [ACTION_RESCUE] =    '1'
2884         };
2885
2886         assert(arg_action < _ACTION_MAX);
2887
2888         return table[arg_action];
2889 }
2890
2891 static int talk_upstart(void) {
2892         DBusMessage *m = NULL, *reply = NULL;
2893         DBusError error;
2894         int previous, rl, r;
2895         char
2896                 env1_buf[] = "RUNLEVEL=X",
2897                 env2_buf[] = "PREVLEVEL=X";
2898         char *env1 = env1_buf, *env2 = env2_buf;
2899         const char *emit = "runlevel";
2900         dbus_bool_t b_false = FALSE;
2901         DBusMessageIter iter, sub;
2902         DBusConnection *bus;
2903
2904         dbus_error_init(&error);
2905
2906         if (!(rl = action_to_runlevel()))
2907                 return 0;
2908
2909         if (utmp_get_runlevel(&previous, NULL) < 0)
2910                 previous = 'N';
2911
2912         if (!(bus = dbus_connection_open("unix:abstract=/com/ubuntu/upstart", &error))) {
2913                 if (dbus_error_has_name(&error, DBUS_ERROR_NO_SERVER)) {
2914                         r = 0;
2915                         goto finish;
2916                 }
2917
2918                 log_error("Failed to connect to Upstart bus: %s", error.message);
2919                 r = -EIO;
2920                 goto finish;
2921         }
2922
2923         if ((r = bus_check_peercred(bus)) < 0) {
2924                 log_error("Failed to verify owner of bus.");
2925                 goto finish;
2926         }
2927
2928         if (!(m = dbus_message_new_method_call(
2929                               "com.ubuntu.Upstart",
2930                               "/com/ubuntu/Upstart",
2931                               "com.ubuntu.Upstart0_6",
2932                               "EmitEvent"))) {
2933
2934                 log_error("Could not allocate message.");
2935                 r = -ENOMEM;
2936                 goto finish;
2937         }
2938
2939         dbus_message_iter_init_append(m, &iter);
2940
2941         env1_buf[sizeof(env1_buf)-2] = rl;
2942         env2_buf[sizeof(env2_buf)-2] = previous;
2943
2944         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &emit) ||
2945             !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub) ||
2946             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env1) ||
2947             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env2) ||
2948             !dbus_message_iter_close_container(&iter, &sub) ||
2949             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b_false)) {
2950                 log_error("Could not append arguments to message.");
2951                 r = -ENOMEM;
2952                 goto finish;
2953         }
2954
2955         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2956
2957                 if (error_is_no_service(&error)) {
2958                         r = 0;
2959                         goto finish;
2960                 }
2961
2962                 log_error("Failed to issue method call: %s", error.message);
2963                 r = -EIO;
2964                 goto finish;
2965         }
2966
2967         r = 1;
2968
2969 finish:
2970         if (m)
2971                 dbus_message_unref(m);
2972
2973         if (reply)
2974                 dbus_message_unref(reply);
2975
2976         if (bus)
2977                 dbus_connection_unref(bus);
2978
2979         dbus_error_free(&error);
2980
2981         return r;
2982 }
2983
2984 static int talk_initctl(void) {
2985         struct init_request request;
2986         int r, fd;
2987         char rl;
2988
2989         if (!(rl = action_to_runlevel()))
2990                 return 0;
2991
2992         zero(request);
2993         request.magic = INIT_MAGIC;
2994         request.sleeptime = 0;
2995         request.cmd = INIT_CMD_RUNLVL;
2996         request.runlevel = rl;
2997
2998         if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) {
2999
3000                 if (errno == ENOENT)
3001                         return 0;
3002
3003                 log_error("Failed to open "INIT_FIFO": %m");
3004                 return -errno;
3005         }
3006
3007         errno = 0;
3008         r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
3009         close_nointr_nofail(fd);
3010
3011         if (r < 0) {
3012                 log_error("Failed to write to "INIT_FIFO": %m");
3013                 return errno ? -errno : -EIO;
3014         }
3015
3016         return 1;
3017 }
3018
3019 static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) {
3020
3021         static const struct {
3022                 const char* verb;
3023                 const enum {
3024                         MORE,
3025                         LESS,
3026                         EQUAL
3027                 } argc_cmp;
3028                 const int argc;
3029                 int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
3030         } verbs[] = {
3031                 { "list-units",        LESS,  1, list_units      },
3032                 { "list-jobs",         EQUAL, 1, list_jobs       },
3033                 { "clear-jobs",        EQUAL, 1, clear_jobs      },
3034                 { "load",              MORE,  2, load_unit       },
3035                 { "cancel",            MORE,  2, cancel_job      },
3036                 { "start",             MORE,  2, start_unit      },
3037                 { "stop",              MORE,  2, start_unit      },
3038                 { "reload",            MORE,  2, start_unit      },
3039                 { "restart",           MORE,  2, start_unit      },
3040                 { "isolate",           EQUAL, 2, start_unit      },
3041                 { "check",             MORE,  2, check_unit      },
3042                 { "show",              MORE,  1, show            },
3043                 { "status",            MORE,  2, show            },
3044                 { "monitor",           EQUAL, 1, monitor         },
3045                 { "dump",              EQUAL, 1, dump            },
3046                 { "snapshot",          LESS,  2, snapshot        },
3047                 { "delete",            MORE,  2, delete_snapshot },
3048                 { "daemon-reload",     EQUAL, 1, clear_jobs      },
3049                 { "daemon-reexec",     EQUAL, 1, clear_jobs      },
3050                 { "daemon-exit",       EQUAL, 1, clear_jobs      },
3051                 { "show-environment",  EQUAL, 1, show_enviroment },
3052                 { "set-environment",   MORE,  2, set_environment },
3053                 { "unset-environment", MORE,  2, set_environment },
3054                 { "halt",              EQUAL, 1, start_special   },
3055                 { "poweroff",          EQUAL, 1, start_special   },
3056                 { "reboot",            EQUAL, 1, start_special   },
3057                 { "default",           EQUAL, 1, start_special   },
3058                 { "rescue",            EQUAL, 1, start_special   },
3059                 { "emergency",         EQUAL, 1, start_special   }
3060         };
3061
3062         int left;
3063         unsigned i;
3064
3065         assert(bus);
3066         assert(argc >= 0);
3067         assert(argv);
3068
3069         left = argc - optind;
3070
3071         if (left <= 0)
3072                 /* Special rule: no arguments means "list-units" */
3073                 i = 0;
3074         else {
3075                 if (streq(argv[optind], "help")) {
3076                         systemctl_help();
3077                         return 0;
3078                 }
3079
3080                 for (i = 0; i < ELEMENTSOF(verbs); i++)
3081                         if (streq(argv[optind], verbs[i].verb))
3082                                 break;
3083
3084                 if (i >= ELEMENTSOF(verbs)) {
3085                         log_error("Unknown operation %s", argv[optind]);
3086                         return -EINVAL;
3087                 }
3088         }
3089
3090         switch (verbs[i].argc_cmp) {
3091
3092         case EQUAL:
3093                 if (left != verbs[i].argc) {
3094                         log_error("Invalid number of arguments.");
3095                         return -EINVAL;
3096                 }
3097
3098                 break;
3099
3100         case MORE:
3101                 if (left < verbs[i].argc) {
3102                         log_error("Too few arguments.");
3103                         return -EINVAL;
3104                 }
3105
3106                 break;
3107
3108         case LESS:
3109                 if (left > verbs[i].argc) {
3110                         log_error("Too many arguments.");
3111                         return -EINVAL;
3112                 }
3113
3114                 break;
3115
3116         default:
3117                 assert_not_reached("Unknown comparison operator.");
3118         }
3119
3120         return verbs[i].dispatch(bus, argv + optind, left);
3121 }
3122
3123 static int reload_with_fallback(DBusConnection *bus) {
3124         int r;
3125
3126         if (bus) {
3127                 /* First, tr