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