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