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