chiark / gitweb /
systemctl: fail in the case that no unit files were found
[elogind.git] / src / systemctl / systemctl.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4   This file is part of systemd.
5
6   Copyright 2010 Lennart Poettering
7   Copyright 2013 Marc-Antoine Perennou
8
9   systemd is free software; you can redistribute it and/or modify it
10   under the terms of the GNU Lesser General Public License as published by
11   the Free Software Foundation; either version 2.1 of the License, or
12   (at your option) any later version.
13
14   systemd is distributed in the hope that it will be useful, but
15   WITHOUT ANY WARRANTY; without even the implied warranty of
16   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17   Lesser General Public License for more details.
18
19   You should have received a copy of the GNU Lesser General Public License
20   along with systemd; If not, see <http://www.gnu.org/licenses/>.
21 ***/
22
23 #include <sys/reboot.h>
24 #include <linux/reboot.h>
25 #include <sys/syscall.h>
26 #include <stdio.h>
27 #include <getopt.h>
28 #include <locale.h>
29 #include <stdbool.h>
30 #include <string.h>
31 #include <errno.h>
32 #include <sys/ioctl.h>
33 #include <termios.h>
34 #include <unistd.h>
35 #include <fcntl.h>
36 #include <sys/socket.h>
37 #include <sys/stat.h>
38 #include <stddef.h>
39 #include <sys/prctl.h>
40 #include <fnmatch.h>
41
42 #include "sd-daemon.h"
43 #include "sd-shutdown.h"
44 #include "sd-login.h"
45 #include "sd-bus.h"
46 #include "log.h"
47 #include "util.h"
48 #include "macro.h"
49 #include "set.h"
50 #include "utmp-wtmp.h"
51 #include "special.h"
52 #include "initreq.h"
53 #include "path-util.h"
54 #include "strv.h"
55 #include "cgroup-show.h"
56 #include "cgroup-util.h"
57 #include "list.h"
58 #include "path-lookup.h"
59 #include "conf-parser.h"
60 #include "exit-status.h"
61 #include "build.h"
62 #include "unit-name.h"
63 #include "pager.h"
64 #include "spawn-ask-password-agent.h"
65 #include "spawn-polkit-agent.h"
66 #include "install.h"
67 #include "logs-show.h"
68 #include "socket-util.h"
69 #include "fileio.h"
70 #include "env-util.h"
71 #include "bus-util.h"
72 #include "bus-message.h"
73 #include "bus-error.h"
74 #include "bus-errors.h"
75
76 static char **arg_types = NULL;
77 static char **arg_states = NULL;
78 static char **arg_properties = NULL;
79 static bool arg_all = false;
80 static enum dependency {
81         DEPENDENCY_FORWARD,
82         DEPENDENCY_REVERSE,
83         DEPENDENCY_AFTER,
84         DEPENDENCY_BEFORE,
85         _DEPENDENCY_MAX
86 } arg_dependency = DEPENDENCY_FORWARD;
87 static const char *arg_job_mode = "replace";
88 static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
89 static bool arg_no_block = false;
90 static bool arg_no_legend = false;
91 static bool arg_no_pager = false;
92 static bool arg_no_wtmp = false;
93 static bool arg_no_wall = false;
94 static bool arg_no_reload = false;
95 static bool arg_show_types = false;
96 static bool arg_ignore_inhibitors = false;
97 static bool arg_dry = false;
98 static bool arg_quiet = false;
99 static bool arg_full = false;
100 static bool arg_recursive = false;
101 static int arg_force = 0;
102 static bool arg_ask_password = true;
103 static bool arg_runtime = false;
104 static UnitFilePresetMode arg_preset_mode = UNIT_FILE_PRESET_FULL;
105 static char **arg_wall = NULL;
106 static const char *arg_kill_who = NULL;
107 static int arg_signal = SIGTERM;
108 static const char *arg_root = NULL;
109 static usec_t arg_when = 0;
110 static enum action {
111         _ACTION_INVALID,
112         ACTION_SYSTEMCTL,
113         ACTION_HALT,
114         ACTION_POWEROFF,
115         ACTION_REBOOT,
116         ACTION_KEXEC,
117         ACTION_EXIT,
118         ACTION_SUSPEND,
119         ACTION_HIBERNATE,
120         ACTION_HYBRID_SLEEP,
121         ACTION_RUNLEVEL2,
122         ACTION_RUNLEVEL3,
123         ACTION_RUNLEVEL4,
124         ACTION_RUNLEVEL5,
125         ACTION_RESCUE,
126         ACTION_EMERGENCY,
127         ACTION_DEFAULT,
128         ACTION_RELOAD,
129         ACTION_REEXEC,
130         ACTION_RUNLEVEL,
131         ACTION_CANCEL_SHUTDOWN,
132         _ACTION_MAX
133 } arg_action = ACTION_SYSTEMCTL;
134 static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
135 static char *arg_host = NULL;
136 static unsigned arg_lines = 10;
137 static OutputMode arg_output = OUTPUT_SHORT;
138 static bool arg_plain = false;
139
140 static const struct {
141         const char *verb;
142         const char *method;
143 } unit_actions[] = {
144         { "start",                 "StartUnit" },
145         { "stop",                  "StopUnit" },
146         { "condstop",              "StopUnit" },
147         { "reload",                "ReloadUnit" },
148         { "restart",               "RestartUnit" },
149         { "try-restart",           "TryRestartUnit" },
150         { "condrestart",           "TryRestartUnit" },
151         { "reload-or-restart",     "ReloadOrRestartUnit" },
152         { "reload-or-try-restart", "ReloadOrTryRestartUnit" },
153         { "condreload",            "ReloadOrTryRestartUnit" },
154         { "force-reload",          "ReloadOrTryRestartUnit" }
155 };
156
157 static bool original_stdout_is_tty;
158
159 static int daemon_reload(sd_bus *bus, char **args);
160 static int halt_now(enum action a);
161 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet);
162
163 static char** strv_skip_first(char **strv) {
164         if (strv_length(strv) > 0)
165                 return strv + 1;
166         return NULL;
167 }
168
169 static void pager_open_if_enabled(void) {
170
171         if (arg_no_pager)
172                 return;
173
174         pager_open(false);
175 }
176
177 static void ask_password_agent_open_if_enabled(void) {
178
179         /* Open the password agent as a child process if necessary */
180
181         if (!arg_ask_password)
182                 return;
183
184         if (arg_scope != UNIT_FILE_SYSTEM)
185                 return;
186
187         if (arg_transport != BUS_TRANSPORT_LOCAL)
188                 return;
189
190         ask_password_agent_open();
191 }
192
193 #ifdef HAVE_LOGIND
194 static void polkit_agent_open_if_enabled(void) {
195
196         /* Open the polkit agent as a child process if necessary */
197
198         if (!arg_ask_password)
199                 return;
200
201         if (arg_scope != UNIT_FILE_SYSTEM)
202                 return;
203
204         if (arg_transport != BUS_TRANSPORT_LOCAL)
205                 return;
206
207         polkit_agent_open();
208 }
209 #endif
210
211 static int translate_bus_error_to_exit_status(int r, const sd_bus_error *error) {
212         assert(error);
213
214         if (!sd_bus_error_is_set(error))
215                 return r;
216
217         if (sd_bus_error_has_name(error, SD_BUS_ERROR_ACCESS_DENIED) ||
218             sd_bus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
219             sd_bus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
220             sd_bus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
221                 return EXIT_NOPERMISSION;
222
223         if (sd_bus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
224                 return EXIT_NOTINSTALLED;
225
226         if (sd_bus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
227             sd_bus_error_has_name(error, SD_BUS_ERROR_NOT_SUPPORTED))
228                 return EXIT_NOTIMPLEMENTED;
229
230         if (sd_bus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
231                 return EXIT_NOTCONFIGURED;
232
233         if (r != 0)
234                 return r;
235
236         return EXIT_FAILURE;
237 }
238
239 static void warn_wall(enum action a) {
240         static const char *table[_ACTION_MAX] = {
241                 [ACTION_HALT]            = "The system is going down for system halt NOW!",
242                 [ACTION_REBOOT]          = "The system is going down for reboot NOW!",
243                 [ACTION_POWEROFF]        = "The system is going down for power-off NOW!",
244                 [ACTION_KEXEC]           = "The system is going down for kexec reboot NOW!",
245                 [ACTION_RESCUE]          = "The system is going down to rescue mode NOW!",
246                 [ACTION_EMERGENCY]       = "The system is going down to emergency mode NOW!",
247                 [ACTION_CANCEL_SHUTDOWN] = "The system shutdown has been cancelled NOW!"
248         };
249
250         if (arg_no_wall)
251                 return;
252
253         if (arg_wall) {
254                 _cleanup_free_ char *p;
255
256                 p = strv_join(arg_wall, " ");
257                 if (!p) {
258                         log_oom();
259                         return;
260                 }
261
262                 if (*p) {
263                         utmp_wall(p, NULL, NULL);
264                         return;
265                 }
266         }
267
268         if (!table[a])
269                 return;
270
271         utmp_wall(table[a], NULL, NULL);
272 }
273
274 static bool avoid_bus(void) {
275
276         if (running_in_chroot() > 0)
277                 return true;
278
279         if (sd_booted() <= 0)
280                 return true;
281
282         if (!isempty(arg_root))
283                 return true;
284
285         if (arg_scope == UNIT_FILE_GLOBAL)
286                 return true;
287
288         return false;
289 }
290
291 static int compare_unit_info(const void *a, const void *b) {
292         const UnitInfo *u = a, *v = b;
293         const char *d1, *d2;
294         int r;
295
296         /* First, order by machine */
297         if (!u->machine && v->machine)
298                 return -1;
299         if (u->machine && !v->machine)
300                 return 1;
301         if (u->machine && v->machine) {
302                 r = strcasecmp(u->machine, v->machine);
303                 if (r != 0)
304                         return r;
305         }
306
307         /* Second, order by unit type */
308         d1 = strrchr(u->id, '.');
309         d2 = strrchr(v->id, '.');
310         if (d1 && d2) {
311                 r = strcasecmp(d1, d2);
312                 if (r != 0)
313                         return r;
314         }
315
316         /* Third, order by name */
317         return strcasecmp(u->id, v->id);
318 }
319
320 static bool output_show_unit(const UnitInfo *u, char **patterns) {
321         const char *dot;
322
323         if (!strv_isempty(patterns)) {
324                 char **pattern;
325
326                 STRV_FOREACH(pattern, patterns)
327                         if (fnmatch(*pattern, u->id, FNM_NOESCAPE) == 0)
328                                 return true;
329                 return false;
330         }
331
332         return (!arg_types || ((dot = strrchr(u->id, '.')) &&
333                                strv_find(arg_types, dot+1))) &&
334                 (arg_all || !(streq(u->active_state, "inactive")
335                               || u->following[0]) || u->job_id > 0);
336 }
337
338 static int output_units_list(const UnitInfo *unit_infos, unsigned c) {
339         unsigned circle_len = 0, id_len, max_id_len, load_len, active_len, sub_len, job_len, desc_len;
340         const UnitInfo *u;
341         unsigned n_shown = 0;
342         int job_count = 0;
343
344         max_id_len = strlen("UNIT");
345         load_len = strlen("LOAD");
346         active_len = strlen("ACTIVE");
347         sub_len = strlen("SUB");
348         job_len = strlen("JOB");
349         desc_len = 0;
350
351         for (u = unit_infos; u < unit_infos + c; u++) {
352                 max_id_len = MAX(max_id_len, strlen(u->id) + (u->machine ? strlen(u->machine)+1 : 0));
353                 load_len = MAX(load_len, strlen(u->load_state));
354                 active_len = MAX(active_len, strlen(u->active_state));
355                 sub_len = MAX(sub_len, strlen(u->sub_state));
356
357                 if (u->job_id != 0) {
358                         job_len = MAX(job_len, strlen(u->job_type));
359                         job_count++;
360                 }
361
362                 if (!arg_no_legend &&
363                     (streq(u->active_state, "failed") ||
364                      STR_IN_SET(u->load_state, "error", "not-found", "masked")))
365                         circle_len = 2;
366         }
367
368         if (!arg_full && original_stdout_is_tty) {
369                 unsigned basic_len;
370
371                 id_len = MIN(max_id_len, 25u);
372                 basic_len = circle_len + 5 + id_len + 5 + active_len + sub_len;
373
374                 if (job_count)
375                         basic_len += job_len + 1;
376
377                 if (basic_len < (unsigned) columns()) {
378                         unsigned extra_len, incr;
379                         extra_len = columns() - basic_len;
380
381                         /* Either UNIT already got 25, or is fully satisfied.
382                          * Grant up to 25 to DESC now. */
383                         incr = MIN(extra_len, 25u);
384                         desc_len += incr;
385                         extra_len -= incr;
386
387                         /* split the remaining space between UNIT and DESC,
388                          * but do not give UNIT more than it needs. */
389                         if (extra_len > 0) {
390                                 incr = MIN(extra_len / 2, max_id_len - id_len);
391                                 id_len += incr;
392                                 desc_len += extra_len - incr;
393                         }
394                 }
395         } else
396                 id_len = max_id_len;
397
398         for (u = unit_infos; u < unit_infos + c; u++) {
399                 _cleanup_free_ char *e = NULL, *j = NULL;
400                 const char *on_loaded = "", *off_loaded = "";
401                 const char *on_active = "", *off_active = "";
402                 const char *on_circle = "", *off_circle = "";
403                 const char *id;
404                 bool circle = false;
405
406                 if (!n_shown && !arg_no_legend) {
407
408                         if (circle_len > 0)
409                                 fputs("  ", stdout);
410
411                         printf("%-*s %-*s %-*s %-*s ",
412                                id_len, "UNIT",
413                                load_len, "LOAD",
414                                active_len, "ACTIVE",
415                                sub_len, "SUB");
416
417                         if (job_count)
418                                 printf("%-*s ", job_len, "JOB");
419
420                         if (!arg_full && arg_no_pager)
421                                 printf("%.*s\n", desc_len, "DESCRIPTION");
422                         else
423                                 printf("%s\n", "DESCRIPTION");
424                 }
425
426                 n_shown++;
427
428                 if (STR_IN_SET(u->load_state, "error", "not-found", "masked")) {
429                         on_loaded = ansi_highlight_red();
430                         on_circle = ansi_highlight_yellow();
431                         off_loaded = off_circle = ansi_highlight_off();
432                         circle = true;
433                 }
434
435                 if (streq(u->active_state, "failed")) {
436                         on_circle = on_active = ansi_highlight_red();
437                         off_circle = off_active = ansi_highlight_off();
438                         circle = true;
439                 }
440
441                 if (u->machine) {
442                         j = strjoin(u->machine, ":", u->id, NULL);
443                         if (!j)
444                                 return log_oom();
445
446                         id = j;
447                 } else
448                         id = u->id;
449
450                 if (arg_full) {
451                         e = ellipsize(id, id_len, 33);
452                         if (!e)
453                                 return log_oom();
454
455                         id = e;
456                 }
457
458                 if (circle_len > 0)
459                         printf("%s%s%s ", on_circle, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_circle);
460
461                 printf("%s%-*s%s %s%-*s%s %s%-*s %-*s%s %-*s",
462                        on_active, id_len, id, off_active,
463                        on_loaded, load_len, u->load_state, off_loaded,
464                        on_active, active_len, u->active_state,
465                        sub_len, u->sub_state, off_active,
466                        job_count ? job_len + 1 : 0, u->job_id ? u->job_type : "");
467
468                 if (desc_len > 0)
469                         printf("%.*s\n", desc_len, u->description);
470                 else
471                         printf("%s\n", u->description);
472         }
473
474         if (!arg_no_legend) {
475                 const char *on, *off;
476
477                 if (n_shown) {
478                         puts("\n"
479                              "LOAD   = Reflects whether the unit definition was properly loaded.\n"
480                              "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
481                              "SUB    = The low-level unit activation state, values depend on unit type.");
482                         puts(job_count ? "JOB    = Pending job for the unit.\n" : "");
483                         on = ansi_highlight();
484                         off = ansi_highlight_off();
485                 } else {
486                         on = ansi_highlight_red();
487                         off = ansi_highlight_off();
488                 }
489
490                 if (arg_all)
491                         printf("%s%u loaded units listed.%s\n"
492                                "To show all installed unit files use 'systemctl list-unit-files'.\n",
493                                on, n_shown, off);
494                 else
495                         printf("%s%u loaded units listed.%s Pass --all to see loaded but inactive units, too.\n"
496                                "To show all installed unit files use 'systemctl list-unit-files'.\n",
497                                on, n_shown, off);
498         }
499
500         return 0;
501 }
502
503 static int get_unit_list(
504                 sd_bus *bus,
505                 const char *machine,
506                 char **patterns,
507                 UnitInfo **unit_infos,
508                 int c,
509                 sd_bus_message **_reply) {
510
511         _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
512         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
513         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
514         size_t size = c;
515         int r;
516         UnitInfo u;
517
518         assert(bus);
519         assert(unit_infos);
520         assert(_reply);
521
522         r = sd_bus_message_new_method_call(
523                         bus,
524                         &m,
525                         "org.freedesktop.systemd1",
526                         "/org/freedesktop/systemd1",
527                         "org.freedesktop.systemd1.Manager",
528                         "ListUnitsFiltered");
529
530         if (r < 0)
531                 return bus_log_create_error(r);
532
533         r = sd_bus_message_append_strv(m, arg_states);
534         if (r < 0)
535                 return bus_log_create_error(r);
536
537         r = sd_bus_call(bus, m, 0, &error, &reply);
538         if (r < 0) {
539                 log_error("Failed to list units: %s", bus_error_message(&error, r));
540                 return r;
541         }
542
543         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssssouso)");
544         if (r < 0)
545                 return bus_log_parse_error(r);
546
547         while ((r = bus_parse_unit_info(reply, &u)) > 0) {
548                 u.machine = machine;
549
550                 if (!output_show_unit(&u, patterns))
551                         continue;
552
553                 if (!GREEDY_REALLOC(*unit_infos, size, c+1))
554                         return log_oom();
555
556                 (*unit_infos)[c++] = u;
557         }
558         if (r < 0)
559                 return bus_log_parse_error(r);
560
561         r = sd_bus_message_exit_container(reply);
562         if (r < 0)
563                 return bus_log_parse_error(r);
564
565         *_reply = reply;
566         reply = NULL;
567
568         return c;
569 }
570
571 static void message_set_freep(Set **set) {
572         sd_bus_message *m;
573
574         while ((m = set_steal_first(*set)))
575                 sd_bus_message_unref(m);
576
577         set_free(*set);
578 }
579
580 static int get_unit_list_recursive(
581                 sd_bus *bus,
582                 char **patterns,
583                 UnitInfo **_unit_infos,
584                 Set **_replies,
585                 char ***_machines) {
586
587         _cleanup_free_ UnitInfo *unit_infos = NULL;
588         _cleanup_(message_set_freep) Set *replies;
589         sd_bus_message *reply;
590         int c, r;
591
592         assert(bus);
593         assert(_replies);
594         assert(_unit_infos);
595         assert(_machines);
596
597         replies = set_new(NULL, NULL);
598         if (!replies)
599                 return log_oom();
600
601         c = get_unit_list(bus, NULL, patterns, &unit_infos, 0, &reply);
602         if (c < 0)
603                 return c;
604
605         r = set_put(replies, reply);
606         if (r < 0) {
607                 sd_bus_message_unref(reply);
608                 return r;
609         }
610
611         if (arg_recursive) {
612                 _cleanup_strv_free_ char **machines = NULL;
613                 char **i;
614
615                 r = sd_get_machine_names(&machines);
616                 if (r < 0)
617                         return r;
618
619                 STRV_FOREACH(i, machines) {
620                         _cleanup_bus_close_unref_ sd_bus *container = NULL;
621                         int k;
622
623                         r = sd_bus_open_system_container(&container, *i);
624                         if (r < 0) {
625                                 log_error("Failed to connect to container %s: %s", *i, strerror(-r));
626                                 continue;
627                         }
628
629                         k = get_unit_list(container, *i, patterns, &unit_infos, c, &reply);
630                         if (k < 0)
631                                 return k;
632
633                         c = k;
634
635                         r = set_put(replies, reply);
636                         if (r < 0) {
637                                 sd_bus_message_unref(reply);
638                                 return r;
639                         }
640                 }
641
642                 *_machines = machines;
643                 machines = NULL;
644         } else
645                 *_machines = NULL;
646
647         *_unit_infos = unit_infos;
648         unit_infos = NULL;
649
650         *_replies = replies;
651         replies = NULL;
652
653         return c;
654 }
655
656 static int list_units(sd_bus *bus, char **args) {
657         _cleanup_free_ UnitInfo *unit_infos = NULL;
658         _cleanup_(message_set_freep) Set *replies = NULL;
659         _cleanup_strv_free_ char **machines = NULL;
660         int r;
661
662         pager_open_if_enabled();
663
664         r = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
665         if (r < 0)
666                 return r;
667
668         qsort_safe(unit_infos, r, sizeof(UnitInfo), compare_unit_info);
669         return output_units_list(unit_infos, r);
670 }
671
672 static int get_triggered_units(
673                 sd_bus *bus,
674                 const char* path,
675                 char*** ret) {
676
677         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
678         int r;
679
680         r = sd_bus_get_property_strv(
681                         bus,
682                         "org.freedesktop.systemd1",
683                         path,
684                         "org.freedesktop.systemd1.Unit",
685                         "Triggers",
686                         &error,
687                         ret);
688
689         if (r < 0)
690                 log_error("Failed to determine triggers: %s", bus_error_message(&error, r));
691
692         return 0;
693 }
694
695 static int get_listening(
696                 sd_bus *bus,
697                 const char* unit_path,
698                 char*** listening) {
699
700         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
701         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
702         const char *type, *path;
703         int r, n = 0;
704
705         r = sd_bus_get_property(
706                         bus,
707                         "org.freedesktop.systemd1",
708                         unit_path,
709                         "org.freedesktop.systemd1.Socket",
710                         "Listen",
711                         &error,
712                         &reply,
713                         "a(ss)");
714         if (r < 0) {
715                 log_error("Failed to get list of listening sockets: %s", bus_error_message(&error, r));
716                 return r;
717         }
718
719         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
720         if (r < 0)
721                 return bus_log_parse_error(r);
722
723         while ((r = sd_bus_message_read(reply, "(ss)", &type, &path)) > 0) {
724
725                 r = strv_extend(listening, type);
726                 if (r < 0)
727                         return log_oom();
728
729                 r = strv_extend(listening, path);
730                 if (r < 0)
731                         return log_oom();
732
733                 n++;
734         }
735         if (r < 0)
736                 return bus_log_parse_error(r);
737
738         r = sd_bus_message_exit_container(reply);
739         if (r < 0)
740                 return bus_log_parse_error(r);
741
742         return n;
743 }
744
745 struct socket_info {
746         const char *machine;
747         const char* id;
748
749         char* type;
750         char* path;
751
752         /* Note: triggered is a list here, although it almost certainly
753          * will always be one unit. Nevertheless, dbus API allows for multiple
754          * values, so let's follow that.*/
755         char** triggered;
756
757         /* The strv above is shared. free is set only in the first one. */
758         bool own_triggered;
759 };
760
761 static int socket_info_compare(const struct socket_info *a, const struct socket_info *b) {
762         int o;
763
764         assert(a);
765         assert(b);
766
767         if (!a->machine && b->machine)
768                 return -1;
769         if (a->machine && !b->machine)
770                 return 1;
771         if (a->machine && b->machine) {
772                 o = strcasecmp(a->machine, b->machine);
773                 if (o != 0)
774                         return o;
775         }
776
777         o = strcmp(a->path, b->path);
778         if (o == 0)
779                 o = strcmp(a->type, b->type);
780
781         return o;
782 }
783
784 static int output_sockets_list(struct socket_info *socket_infos, unsigned cs) {
785         struct socket_info *s;
786         unsigned pathlen = strlen("LISTEN"),
787                 typelen = strlen("TYPE") * arg_show_types,
788                 socklen = strlen("UNIT"),
789                 servlen = strlen("ACTIVATES");
790         const char *on, *off;
791
792         for (s = socket_infos; s < socket_infos + cs; s++) {
793                 unsigned tmp = 0;
794                 char **a;
795
796                 socklen = MAX(socklen, strlen(s->id));
797                 if (arg_show_types)
798                         typelen = MAX(typelen, strlen(s->type));
799                 pathlen = MAX(pathlen, strlen(s->path) + (s->machine ? strlen(s->machine)+1 : 0));
800
801                 STRV_FOREACH(a, s->triggered)
802                         tmp += strlen(*a) + 2*(a != s->triggered);
803                 servlen = MAX(servlen, tmp);
804         }
805
806         if (cs) {
807                 if (!arg_no_legend)
808                         printf("%-*s %-*.*s%-*s %s\n",
809                                pathlen, "LISTEN",
810                                typelen + arg_show_types, typelen + arg_show_types, "TYPE ",
811                                socklen, "UNIT",
812                                "ACTIVATES");
813
814                 for (s = socket_infos; s < socket_infos + cs; s++) {
815                         _cleanup_free_ char *j = NULL;
816                         const char *path;
817                         char **a;
818
819                         if (s->machine) {
820                                 j = strjoin(s->machine, ":", s->path, NULL);
821                                 if (!j)
822                                         return log_oom();
823                                 path = j;
824                         } else
825                                 path = s->path;
826
827                         if (arg_show_types)
828                                 printf("%-*s %-*s %-*s",
829                                        pathlen, path, typelen, s->type, socklen, s->id);
830                         else
831                                 printf("%-*s %-*s",
832                                        pathlen, path, socklen, s->id);
833                         STRV_FOREACH(a, s->triggered)
834                                 printf("%s %s",
835                                        a == s->triggered ? "" : ",", *a);
836                         printf("\n");
837                 }
838
839                 on = ansi_highlight();
840                 off = ansi_highlight_off();
841                 if (!arg_no_legend)
842                         printf("\n");
843         } else {
844                 on = ansi_highlight_red();
845                 off = ansi_highlight_off();
846         }
847
848         if (!arg_no_legend) {
849                 printf("%s%u sockets listed.%s\n", on, cs, off);
850                 if (!arg_all)
851                         printf("Pass --all to see loaded but inactive sockets, too.\n");
852         }
853
854         return 0;
855 }
856
857 static int list_sockets(sd_bus *bus, char **args) {
858         _cleanup_(message_set_freep) Set *replies = NULL;
859         _cleanup_strv_free_ char **machines = NULL;
860         _cleanup_free_ UnitInfo *unit_infos = NULL;
861         _cleanup_free_ struct socket_info *socket_infos = NULL;
862         const UnitInfo *u;
863         struct socket_info *s;
864         unsigned cs = 0;
865         size_t size = 0;
866         int r = 0, n;
867
868         pager_open_if_enabled();
869
870         n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
871         if (n < 0)
872                 return n;
873
874         for (u = unit_infos; u < unit_infos + n; u++) {
875                 _cleanup_strv_free_ char **listening = NULL, **triggered = NULL;
876                 int i, c;
877
878                 if (!endswith(u->id, ".socket"))
879                         continue;
880
881                 r = get_triggered_units(bus, u->unit_path, &triggered);
882                 if (r < 0)
883                         goto cleanup;
884
885                 c = get_listening(bus, u->unit_path, &listening);
886                 if (c < 0) {
887                         r = c;
888                         goto cleanup;
889                 }
890
891                 if (!GREEDY_REALLOC(socket_infos, size, cs + c)) {
892                         r = log_oom();
893                         goto cleanup;
894                 }
895
896                 for (i = 0; i < c; i++)
897                         socket_infos[cs + i] = (struct socket_info) {
898                                 .machine = u->machine,
899                                 .id = u->id,
900                                 .type = listening[i*2],
901                                 .path = listening[i*2 + 1],
902                                 .triggered = triggered,
903                                 .own_triggered = i==0,
904                         };
905
906                 /* from this point on we will cleanup those socket_infos */
907                 cs += c;
908                 free(listening);
909                 listening = triggered = NULL; /* avoid cleanup */
910         }
911
912         qsort_safe(socket_infos, cs, sizeof(struct socket_info),
913                    (__compar_fn_t) socket_info_compare);
914
915         output_sockets_list(socket_infos, cs);
916
917  cleanup:
918         assert(cs == 0 || socket_infos);
919         for (s = socket_infos; s < socket_infos + cs; s++) {
920                 free(s->type);
921                 free(s->path);
922                 if (s->own_triggered)
923                         strv_free(s->triggered);
924         }
925
926         return r;
927 }
928
929 static int get_next_elapse(
930                 sd_bus *bus,
931                 const char *path,
932                 dual_timestamp *next) {
933
934         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
935         dual_timestamp t;
936         int r;
937
938         assert(bus);
939         assert(path);
940         assert(next);
941
942         r = sd_bus_get_property_trivial(
943                         bus,
944                         "org.freedesktop.systemd1",
945                         path,
946                         "org.freedesktop.systemd1.Timer",
947                         "NextElapseUSecMonotonic",
948                         &error,
949                         't',
950                         &t.monotonic);
951         if (r < 0) {
952                 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
953                 return r;
954         }
955
956         r = sd_bus_get_property_trivial(
957                         bus,
958                         "org.freedesktop.systemd1",
959                         path,
960                         "org.freedesktop.systemd1.Timer",
961                         "NextElapseUSecRealtime",
962                         &error,
963                         't',
964                         &t.realtime);
965         if (r < 0) {
966                 log_error("Failed to get next elapsation time: %s", bus_error_message(&error, r));
967                 return r;
968         }
969
970         *next = t;
971         return 0;
972 }
973
974 static int get_last_trigger(
975                 sd_bus *bus,
976                 const char *path,
977                 usec_t *last) {
978
979         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
980         int r;
981
982         assert(bus);
983         assert(path);
984         assert(last);
985
986         r = sd_bus_get_property_trivial(
987                         bus,
988                         "org.freedesktop.systemd1",
989                         path,
990                         "org.freedesktop.systemd1.Timer",
991                         "LastTriggerUSec",
992                         &error,
993                         't',
994                         last);
995         if (r < 0) {
996                 log_error("Failed to get last trigger time: %s", bus_error_message(&error, r));
997                 return r;
998         }
999
1000         return 0;
1001 }
1002
1003 struct timer_info {
1004         const char* machine;
1005         const char* id;
1006         usec_t next_elapse;
1007         usec_t last_trigger;
1008         char** triggered;
1009 };
1010
1011 static int timer_info_compare(const struct timer_info *a, const struct timer_info *b) {
1012         int o;
1013
1014         assert(a);
1015         assert(b);
1016
1017         if (!a->machine && b->machine)
1018                 return -1;
1019         if (a->machine && !b->machine)
1020                 return 1;
1021         if (a->machine && b->machine) {
1022                 o = strcasecmp(a->machine, b->machine);
1023                 if (o != 0)
1024                         return o;
1025         }
1026
1027         if (a->next_elapse < b->next_elapse)
1028                 return -1;
1029         if (a->next_elapse > b->next_elapse)
1030                 return 1;
1031
1032         return strcmp(a->id, b->id);
1033 }
1034
1035 static int output_timers_list(struct timer_info *timer_infos, unsigned n) {
1036         struct timer_info *t;
1037         unsigned
1038                 nextlen = strlen("NEXT"),
1039                 leftlen = strlen("LEFT"),
1040                 lastlen = strlen("LAST"),
1041                 passedlen = strlen("PASSED"),
1042                 unitlen = strlen("UNIT"),
1043                 activatelen = strlen("ACTIVATES");
1044
1045         const char *on, *off;
1046
1047         assert(timer_infos || n == 0);
1048
1049         for (t = timer_infos; t < timer_infos + n; t++) {
1050                 unsigned ul = 0;
1051                 char **a;
1052
1053                 if (t->next_elapse > 0) {
1054                         char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
1055
1056                         format_timestamp(tstamp, sizeof(tstamp), t->next_elapse);
1057                         nextlen = MAX(nextlen, strlen(tstamp) + 1);
1058
1059                         format_timestamp_relative(trel, sizeof(trel), t->next_elapse);
1060                         leftlen = MAX(leftlen, strlen(trel));
1061                 }
1062
1063                 if (t->last_trigger > 0) {
1064                         char tstamp[FORMAT_TIMESTAMP_MAX] = "", trel[FORMAT_TIMESTAMP_RELATIVE_MAX] = "";
1065
1066                         format_timestamp(tstamp, sizeof(tstamp), t->last_trigger);
1067                         lastlen = MAX(lastlen, strlen(tstamp) + 1);
1068
1069                         format_timestamp_relative(trel, sizeof(trel), t->last_trigger);
1070                         passedlen = MAX(passedlen, strlen(trel));
1071                 }
1072
1073                 unitlen = MAX(unitlen, strlen(t->id) + (t->machine ? strlen(t->machine)+1 : 0));
1074
1075                 STRV_FOREACH(a, t->triggered)
1076                         ul += strlen(*a) + 2*(a != t->triggered);
1077
1078                 activatelen = MAX(activatelen, ul);
1079         }
1080
1081         if (n > 0) {
1082                 if (!arg_no_legend)
1083                         printf("%-*s %-*s %-*s %-*s %-*s %s\n",
1084                                nextlen,   "NEXT",
1085                                leftlen,   "LEFT",
1086                                lastlen,   "LAST",
1087                                passedlen, "PASSED",
1088                                unitlen,   "UNIT",
1089                                           "ACTIVATES");
1090
1091                 for (t = timer_infos; t < timer_infos + n; t++) {
1092                         _cleanup_free_ char *j = NULL;
1093                         const char *unit;
1094                         char tstamp1[FORMAT_TIMESTAMP_MAX] = "n/a", trel1[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
1095                         char tstamp2[FORMAT_TIMESTAMP_MAX] = "n/a", trel2[FORMAT_TIMESTAMP_RELATIVE_MAX] = "n/a";
1096                         char **a;
1097
1098                         format_timestamp(tstamp1, sizeof(tstamp1), t->next_elapse);
1099                         format_timestamp_relative(trel1, sizeof(trel1), t->next_elapse);
1100
1101                         format_timestamp(tstamp2, sizeof(tstamp2), t->last_trigger);
1102                         format_timestamp_relative(trel2, sizeof(trel2), t->last_trigger);
1103
1104                         if (t->machine) {
1105                                 j = strjoin(t->machine, ":", t->id, NULL);
1106                                 if (!j)
1107                                         return log_oom();
1108                                 unit = j;
1109                         } else
1110                                 unit = t->id;
1111
1112                         printf("%-*s %-*s %-*s %-*s %-*s",
1113                                nextlen, tstamp1, leftlen, trel1, lastlen, tstamp2, passedlen, trel2, unitlen, unit);
1114
1115                         STRV_FOREACH(a, t->triggered)
1116                                 printf("%s %s",
1117                                        a == t->triggered ? "" : ",", *a);
1118                         printf("\n");
1119                 }
1120
1121                 on = ansi_highlight();
1122                 off = ansi_highlight_off();
1123                 if (!arg_no_legend)
1124                         printf("\n");
1125         } else {
1126                 on = ansi_highlight_red();
1127                 off = ansi_highlight_off();
1128         }
1129
1130         if (!arg_no_legend) {
1131                 printf("%s%u timers listed.%s\n", on, n, off);
1132                 if (!arg_all)
1133                         printf("Pass --all to see loaded but inactive timers, too.\n");
1134         }
1135
1136         return 0;
1137 }
1138
1139 static usec_t calc_next_elapse(dual_timestamp *nw, dual_timestamp *next) {
1140         usec_t next_elapse;
1141
1142         assert(nw);
1143         assert(next);
1144
1145         if (next->monotonic != USEC_INFINITY && next->monotonic > 0) {
1146                 usec_t converted;
1147
1148                 if (next->monotonic > nw->monotonic)
1149                         converted = nw->realtime + (next->monotonic - nw->monotonic);
1150                 else
1151                         converted = nw->realtime - (nw->monotonic - next->monotonic);
1152
1153                 if (next->realtime != USEC_INFINITY && next->realtime > 0)
1154                         next_elapse = MIN(converted, next->realtime);
1155                 else
1156                         next_elapse = converted;
1157
1158         } else
1159                 next_elapse = next->realtime;
1160
1161         return next_elapse;
1162 }
1163
1164 static int list_timers(sd_bus *bus, char **args) {
1165         _cleanup_(message_set_freep) Set *replies = NULL;
1166         _cleanup_strv_free_ char **machines = NULL;
1167         _cleanup_free_ struct timer_info *timer_infos = NULL;
1168         _cleanup_free_ UnitInfo *unit_infos = NULL;
1169         struct timer_info *t;
1170         const UnitInfo *u;
1171         size_t size = 0;
1172         int n, c = 0;
1173         dual_timestamp nw;
1174         int r = 0;
1175
1176         pager_open_if_enabled();
1177
1178         n = get_unit_list_recursive(bus, strv_skip_first(args), &unit_infos, &replies, &machines);
1179         if (n < 0)
1180                 return n;
1181
1182         dual_timestamp_get(&nw);
1183
1184         for (u = unit_infos; u < unit_infos + n; u++) {
1185                 _cleanup_strv_free_ char **triggered = NULL;
1186                 dual_timestamp next = {};
1187                 usec_t m, last = 0;
1188
1189                 if (!endswith(u->id, ".timer"))
1190                         continue;
1191
1192                 r = get_triggered_units(bus, u->unit_path, &triggered);
1193                 if (r < 0)
1194                         goto cleanup;
1195
1196                 r = get_next_elapse(bus, u->unit_path, &next);
1197                 if (r < 0)
1198                         goto cleanup;
1199
1200                 get_last_trigger(bus, u->unit_path, &last);
1201
1202                 if (!GREEDY_REALLOC(timer_infos, size, c+1)) {
1203                         r = log_oom();
1204                         goto cleanup;
1205                 }
1206
1207                 m = calc_next_elapse(&nw, &next);
1208
1209                 timer_infos[c++] = (struct timer_info) {
1210                         .machine = u->machine,
1211                         .id = u->id,
1212                         .next_elapse = m,
1213                         .last_trigger = last,
1214                         .triggered = triggered,
1215                 };
1216
1217                 triggered = NULL; /* avoid cleanup */
1218         }
1219
1220         qsort_safe(timer_infos, c, sizeof(struct timer_info),
1221                    (__compar_fn_t) timer_info_compare);
1222
1223         output_timers_list(timer_infos, c);
1224
1225  cleanup:
1226         for (t = timer_infos; t < timer_infos + c; t++)
1227                 strv_free(t->triggered);
1228
1229         return r;
1230 }
1231
1232 static int compare_unit_file_list(const void *a, const void *b) {
1233         const char *d1, *d2;
1234         const UnitFileList *u = a, *v = b;
1235
1236         d1 = strrchr(u->path, '.');
1237         d2 = strrchr(v->path, '.');
1238
1239         if (d1 && d2) {
1240                 int r;
1241
1242                 r = strcasecmp(d1, d2);
1243                 if (r != 0)
1244                         return r;
1245         }
1246
1247         return strcasecmp(basename(u->path), basename(v->path));
1248 }
1249
1250 static bool output_show_unit_file(const UnitFileList *u, char **patterns) {
1251         const char *dot;
1252
1253         if (!strv_isempty(patterns)) {
1254                 char **pattern;
1255
1256                 STRV_FOREACH(pattern, patterns)
1257                         if (fnmatch(*pattern, basename(u->path), FNM_NOESCAPE) == 0)
1258                                 return true;
1259                 return false;
1260         }
1261
1262         return !arg_types || ((dot = strrchr(u->path, '.')) && strv_find(arg_types, dot+1));
1263 }
1264
1265 static void output_unit_file_list(const UnitFileList *units, unsigned c) {
1266         unsigned max_id_len, id_cols, state_cols;
1267         const UnitFileList *u;
1268
1269         max_id_len = strlen("UNIT FILE");
1270         state_cols = strlen("STATE");
1271
1272         for (u = units; u < units + c; u++) {
1273                 max_id_len = MAX(max_id_len, strlen(basename(u->path)));
1274                 state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));
1275         }
1276
1277         if (!arg_full) {
1278                 unsigned basic_cols;
1279
1280                 id_cols = MIN(max_id_len, 25u);
1281                 basic_cols = 1 + id_cols + state_cols;
1282                 if (basic_cols < (unsigned) columns())
1283                         id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);
1284         } else
1285                 id_cols = max_id_len;
1286
1287         if (!arg_no_legend)
1288                 printf("%-*s %-*s\n",
1289                        id_cols, "UNIT FILE",
1290                        state_cols, "STATE");
1291
1292         for (u = units; u < units + c; u++) {
1293                 _cleanup_free_ char *e = NULL;
1294                 const char *on, *off;
1295                 const char *id;
1296
1297                 if (u->state == UNIT_FILE_MASKED ||
1298                     u->state == UNIT_FILE_MASKED_RUNTIME ||
1299                     u->state == UNIT_FILE_DISABLED ||
1300                     u->state == UNIT_FILE_INVALID) {
1301                         on  = ansi_highlight_red();
1302                         off = ansi_highlight_off();
1303                 } else if (u->state == UNIT_FILE_ENABLED) {
1304                         on  = ansi_highlight_green();
1305                         off = ansi_highlight_off();
1306                 } else
1307                         on = off = "";
1308
1309                 id = basename(u->path);
1310
1311                 e = arg_full ? NULL : ellipsize(id, id_cols, 33);
1312
1313                 printf("%-*s %s%-*s%s\n",
1314                        id_cols, e ? e : id,
1315                        on, state_cols, unit_file_state_to_string(u->state), off);
1316         }
1317
1318         if (!arg_no_legend)
1319                 printf("\n%u unit files listed.\n", c);
1320 }
1321
1322 static int list_unit_files(sd_bus *bus, char **args) {
1323         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1324         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1325         _cleanup_free_ UnitFileList *units = NULL;
1326         UnitFileList *unit;
1327         size_t size = 0;
1328         unsigned c = 0;
1329         const char *state;
1330         char *path;
1331         int r;
1332
1333         pager_open_if_enabled();
1334
1335         if (avoid_bus()) {
1336                 Hashmap *h;
1337                 UnitFileList *u;
1338                 Iterator i;
1339                 unsigned n_units;
1340
1341                 h = hashmap_new(string_hash_func, string_compare_func);
1342                 if (!h)
1343                         return log_oom();
1344
1345                 r = unit_file_get_list(arg_scope, arg_root, h);
1346                 if (r < 0) {
1347                         unit_file_list_free(h);
1348                         log_error("Failed to get unit file list: %s", strerror(-r));
1349                         return r;
1350                 }
1351
1352                 n_units = hashmap_size(h);
1353
1354                 if (n_units == 0)
1355                         return 0;
1356
1357                 units = new(UnitFileList, n_units);
1358                 if (!units) {
1359                         unit_file_list_free(h);
1360                         return log_oom();
1361                 }
1362
1363                 HASHMAP_FOREACH(u, h, i) {
1364                         if (!output_show_unit_file(u, strv_skip_first(args)))
1365                                 continue;
1366
1367                         units[c++] = *u;
1368                         free(u);
1369                 }
1370
1371                 assert(c <= n_units);
1372                 hashmap_free(h);
1373         } else {
1374                 r = sd_bus_call_method(
1375                                 bus,
1376                                 "org.freedesktop.systemd1",
1377                                 "/org/freedesktop/systemd1",
1378                                 "org.freedesktop.systemd1.Manager",
1379                                 "ListUnitFiles",
1380                                 &error,
1381                                 &reply,
1382                                 NULL);
1383                 if (r < 0) {
1384                         log_error("Failed to list unit files: %s", bus_error_message(&error, r));
1385                         return r;
1386                 }
1387
1388                 r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ss)");
1389                 if (r < 0)
1390                         return bus_log_parse_error(r);
1391
1392                 while ((r = sd_bus_message_read(reply, "(ss)", &path, &state)) > 0) {
1393
1394                         if (!GREEDY_REALLOC(units, size, c + 1))
1395                                 return log_oom();
1396
1397                         units[c] = (struct UnitFileList) {
1398                                 path,
1399                                 unit_file_state_from_string(state)
1400                         };
1401
1402                         if (output_show_unit_file(&units[c], strv_skip_first(args)))
1403                                 c ++;
1404
1405                 }
1406                 if (r < 0)
1407                         return bus_log_parse_error(r);
1408
1409                 r = sd_bus_message_exit_container(reply);
1410                 if (r < 0)
1411                         return bus_log_parse_error(r);
1412         }
1413
1414         if (c > 0) {
1415                 qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);
1416                 output_unit_file_list(units, c);
1417         }
1418
1419         if (avoid_bus())
1420                 for (unit = units; unit < units + c; unit++)
1421                         free(unit->path);
1422
1423         return 0;
1424 }
1425
1426 static int list_dependencies_print(const char *name, int level, unsigned int branches, bool last) {
1427         _cleanup_free_ char *n = NULL;
1428         size_t max_len = MAX(columns(),20u);
1429         size_t len = 0;
1430         int i;
1431
1432         if (!arg_plain) {
1433
1434                 for (i = level - 1; i >= 0; i--) {
1435                         len += 2;
1436                         if (len > max_len - 3 && !arg_full) {
1437                                 printf("%s...\n",max_len % 2 ? "" : " ");
1438                                 return 0;
1439                         }
1440                         printf("%s", draw_special_char(branches & (1 << i) ? DRAW_TREE_VERTICAL : DRAW_TREE_SPACE));
1441                 }
1442                 len += 2;
1443
1444                 if (len > max_len - 3 && !arg_full) {
1445                         printf("%s...\n",max_len % 2 ? "" : " ");
1446                         return 0;
1447                 }
1448
1449                 printf("%s", draw_special_char(last ? DRAW_TREE_RIGHT : DRAW_TREE_BRANCH));
1450         }
1451
1452         if (arg_full){
1453                 printf("%s\n", name);
1454                 return 0;
1455         }
1456
1457         n = ellipsize(name, max_len-len, 100);
1458         if (!n)
1459                 return log_oom();
1460
1461         printf("%s\n", n);
1462         return 0;
1463 }
1464
1465 static int list_dependencies_get_dependencies(sd_bus *bus, const char *name, char ***deps) {
1466
1467         static const char *dependencies[_DEPENDENCY_MAX] = {
1468                 [DEPENDENCY_FORWARD] = "Requires\0"
1469                                        "RequiresOverridable\0"
1470                                        "Requisite\0"
1471                                        "RequisiteOverridable\0"
1472                                        "Wants\0",
1473                 [DEPENDENCY_REVERSE] = "RequiredBy\0"
1474                                        "RequiredByOverridable\0"
1475                                        "WantedBy\0"
1476                                        "PartOf\0",
1477                 [DEPENDENCY_AFTER]   = "After\0",
1478                 [DEPENDENCY_BEFORE]  = "Before\0",
1479         };
1480
1481         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1482         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1483         _cleanup_strv_free_ char **ret = NULL;
1484         _cleanup_free_ char *path = NULL;
1485         int r;
1486
1487         assert(bus);
1488         assert(name);
1489         assert(deps);
1490         assert_cc(ELEMENTSOF(dependencies) == _DEPENDENCY_MAX);
1491
1492         path = unit_dbus_path_from_name(name);
1493         if (!path)
1494                 return log_oom();
1495
1496         r = sd_bus_call_method(
1497                         bus,
1498                         "org.freedesktop.systemd1",
1499                         path,
1500                         "org.freedesktop.DBus.Properties",
1501                         "GetAll",
1502                         &error,
1503                         &reply,
1504                         "s", "org.freedesktop.systemd1.Unit");
1505         if (r < 0) {
1506                 log_error("Failed to get properties of %s: %s", name, bus_error_message(&error, r));
1507                 return r;
1508         }
1509
1510         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "{sv}");
1511         if (r < 0)
1512                 return bus_log_parse_error(r);
1513
1514         while ((r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_DICT_ENTRY, "sv")) > 0) {
1515                 const char *prop;
1516
1517                 r = sd_bus_message_read(reply, "s", &prop);
1518                 if (r < 0)
1519                         return bus_log_parse_error(r);
1520
1521                 if (!nulstr_contains(dependencies[arg_dependency], prop)) {
1522                         r = sd_bus_message_skip(reply, "v");
1523                         if (r < 0)
1524                                 return bus_log_parse_error(r);
1525                 } else {
1526
1527                         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_VARIANT, "as");
1528                         if (r < 0)
1529                                 return bus_log_parse_error(r);
1530
1531                         r = bus_message_read_strv_extend(reply, &ret);
1532                         if (r < 0)
1533                                 return bus_log_parse_error(r);
1534
1535                         r = sd_bus_message_exit_container(reply);
1536                         if (r < 0)
1537                                 return bus_log_parse_error(r);
1538                 }
1539
1540                 r = sd_bus_message_exit_container(reply);
1541                 if (r < 0)
1542                         return bus_log_parse_error(r);
1543
1544         }
1545         if (r < 0)
1546                 return bus_log_parse_error(r);
1547
1548         r = sd_bus_message_exit_container(reply);
1549         if (r < 0)
1550                 return bus_log_parse_error(r);
1551
1552         *deps = ret;
1553         ret = NULL;
1554
1555         return 0;
1556 }
1557
1558 static int list_dependencies_compare(const void *_a, const void *_b) {
1559         const char **a = (const char**) _a, **b = (const char**) _b;
1560
1561         if (unit_name_to_type(*a) == UNIT_TARGET && unit_name_to_type(*b) != UNIT_TARGET)
1562                 return 1;
1563         if (unit_name_to_type(*a) != UNIT_TARGET && unit_name_to_type(*b) == UNIT_TARGET)
1564                 return -1;
1565
1566         return strcasecmp(*a, *b);
1567 }
1568
1569 static int list_dependencies_one(
1570                 sd_bus *bus,
1571                 const char *name,
1572                 int level,
1573                 char ***units,
1574                 unsigned int branches) {
1575
1576         _cleanup_strv_free_ char **deps = NULL;
1577         char **c;
1578         int r = 0;
1579
1580         assert(bus);
1581         assert(name);
1582         assert(units);
1583
1584         r = strv_extend(units, name);
1585         if (r < 0)
1586                 return log_oom();
1587
1588         r = list_dependencies_get_dependencies(bus, name, &deps);
1589         if (r < 0)
1590                 return r;
1591
1592         qsort_safe(deps, strv_length(deps), sizeof (char*), list_dependencies_compare);
1593
1594         STRV_FOREACH(c, deps) {
1595                 int state;
1596
1597                 if (strv_contains(*units, *c)) {
1598                         if (!arg_plain) {
1599                                 r = list_dependencies_print("...", level + 1, (branches << 1) | (c[1] == NULL ? 0 : 1), 1);
1600                                 if (r < 0)
1601                                         return r;
1602                         }
1603                         continue;
1604                 }
1605
1606                 state = check_one_unit(bus, *c, "activating\0active\0reloading\0", true);
1607                 if (state > 0)
1608                         printf("%s%s%s ", ansi_highlight_green(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1609                 else
1610                         printf("%s%s%s ", ansi_highlight_red(), draw_special_char(DRAW_BLACK_CIRCLE), ansi_highlight_off());
1611
1612                 r = list_dependencies_print(*c, level, branches, c[1] == NULL);
1613                 if (r < 0)
1614                         return r;
1615
1616                 if (arg_all || unit_name_to_type(*c) == UNIT_TARGET) {
1617                        r = list_dependencies_one(bus, *c, level + 1, units, (branches << 1) | (c[1] == NULL ? 0 : 1));
1618                        if (r < 0)
1619                                return r;
1620                 }
1621         }
1622
1623         if (!arg_plain)
1624                 strv_remove(*units, name);
1625
1626         return 0;
1627 }
1628
1629 static int list_dependencies(sd_bus *bus, char **args) {
1630         _cleanup_strv_free_ char **units = NULL;
1631         _cleanup_free_ char *unit = NULL;
1632         const char *u;
1633
1634         assert(bus);
1635
1636         if (args[1]) {
1637                 unit = unit_name_mangle(args[1], MANGLE_NOGLOB);
1638                 if (!unit)
1639                         return log_oom();
1640                 u = unit;
1641         } else
1642                 u = SPECIAL_DEFAULT_TARGET;
1643
1644         pager_open_if_enabled();
1645
1646         puts(u);
1647
1648         return list_dependencies_one(bus, u, 0, &units, 0);
1649 }
1650
1651 struct machine_info {
1652         bool is_host;
1653         char *name;
1654         char *state;
1655         char *control_group;
1656         uint32_t n_failed_units;
1657         uint32_t n_jobs;
1658         usec_t timestamp;
1659 };
1660
1661 static const struct bus_properties_map machine_info_property_map[] = {
1662         { "SystemState",        "s", NULL, offsetof(struct machine_info, state)          },
1663         { "NJobs",              "u", NULL, offsetof(struct machine_info, n_jobs)         },
1664         { "NFailedUnits",       "u", NULL, offsetof(struct machine_info, n_failed_units) },
1665         { "ControlGroup",       "s", NULL, offsetof(struct machine_info, control_group)  },
1666         { "UserspaceTimestamp", "t", NULL, offsetof(struct machine_info, timestamp)      },
1667         {}
1668 };
1669
1670 static void free_machines_list(struct machine_info *machine_infos, int n) {
1671         int i;
1672
1673         if (!machine_infos)
1674                 return;
1675
1676         for (i = 0; i < n; i++) {
1677                 free(machine_infos[i].name);
1678                 free(machine_infos[i].state);
1679                 free(machine_infos[i].control_group);
1680         }
1681
1682         free(machine_infos);
1683 }
1684
1685 static int compare_machine_info(const void *a, const void *b) {
1686         const struct machine_info *u = a, *v = b;
1687
1688         if (u->is_host != v->is_host)
1689                 return u->is_host > v->is_host ? -1 : 1;
1690
1691         return strcasecmp(u->name, v->name);
1692 }
1693
1694 static int get_machine_properties(sd_bus *bus, struct machine_info *mi) {
1695         _cleanup_bus_close_unref_ sd_bus *container = NULL;
1696         int r;
1697
1698         assert(mi);
1699
1700         if (!bus) {
1701                 r = sd_bus_open_system_container(&container, mi->name);
1702                 if (r < 0)
1703                         return r;
1704
1705                 bus = container;
1706         }
1707
1708         r = bus_map_all_properties(bus, "org.freedesktop.systemd1", "/org/freedesktop/systemd1", machine_info_property_map, mi);
1709         if (r < 0)
1710                 return r;
1711
1712         return 0;
1713 }
1714
1715 static bool output_show_machine(const char *name, char **patterns) {
1716         char **i;
1717
1718         assert(name);
1719
1720         if (strv_isempty(patterns))
1721                 return true;
1722
1723         STRV_FOREACH(i, patterns)
1724                 if (fnmatch(*i, name, FNM_NOESCAPE) == 0)
1725                         return true;
1726
1727         return false;
1728 }
1729
1730 static int get_machine_list(
1731                 sd_bus *bus,
1732                 struct machine_info **_machine_infos,
1733                 char **patterns) {
1734
1735         struct machine_info *machine_infos = NULL;
1736         _cleanup_strv_free_ char **m = NULL;
1737         _cleanup_free_ char *hn = NULL;
1738         size_t sz = 0;
1739         char **i;
1740         int c = 0;
1741
1742         hn = gethostname_malloc();
1743         if (!hn)
1744                 return log_oom();
1745
1746         if (output_show_machine(hn, patterns)) {
1747                 if (!GREEDY_REALLOC0(machine_infos, sz, c+1))
1748                         return log_oom();
1749
1750                 machine_infos[c].is_host = true;
1751                 machine_infos[c].name = hn;
1752                 hn = NULL;
1753
1754                 get_machine_properties(bus, &machine_infos[c]);
1755                 c++;
1756         }
1757
1758         sd_get_machine_names(&m);
1759         STRV_FOREACH(i, m) {
1760                 _cleanup_free_ char *class = NULL;
1761
1762                 if (!output_show_machine(*i, patterns))
1763                         continue;
1764
1765                 sd_machine_get_class(*i, &class);
1766                 if (!streq_ptr(class, "container"))
1767                         continue;
1768
1769                 if (!GREEDY_REALLOC0(machine_infos, sz, c+1)) {
1770                         free_machines_list(machine_infos, c);
1771                         return log_oom();
1772                 }
1773
1774                 machine_infos[c].is_host = false;
1775                 machine_infos[c].name = strdup(*i);
1776                 if (!machine_infos[c].name) {
1777                         free_machines_list(machine_infos, c);
1778                         return log_oom();
1779                 }
1780
1781                 get_machine_properties(NULL, &machine_infos[c]);
1782                 c++;
1783         }
1784
1785         *_machine_infos = machine_infos;
1786         return c;
1787 }
1788
1789 static void output_machines_list(struct machine_info *machine_infos, unsigned n) {
1790         struct machine_info *m;
1791         unsigned
1792                 circle_len = 0,
1793                 namelen = sizeof("NAME") - 1,
1794                 statelen = sizeof("STATE") - 1,
1795                 failedlen = sizeof("FAILED") - 1,
1796                 jobslen = sizeof("JOBS") - 1;
1797
1798         assert(machine_infos || n == 0);
1799
1800         for (m = machine_infos; m < machine_infos + n; m++) {
1801                 namelen = MAX(namelen, strlen(m->name) + (m->is_host ? sizeof(" (host)") - 1 : 0));
1802                 statelen = MAX(statelen, m->state ? strlen(m->state) : 0);
1803                 failedlen = MAX(failedlen, DECIMAL_STR_WIDTH(m->n_failed_units));
1804                 jobslen = MAX(jobslen, DECIMAL_STR_WIDTH(m->n_jobs));
1805
1806                 if (!arg_no_legend && !streq_ptr(m->state, "running"))
1807                         circle_len = 2;
1808         }
1809
1810         if (!arg_no_legend) {
1811                 if (circle_len > 0)
1812                         fputs("  ", stdout);
1813
1814                 printf("%-*s %-*s %-*s %-*s\n",
1815                          namelen, "NAME",
1816                         statelen, "STATE",
1817                        failedlen, "FAILED",
1818                          jobslen, "JOBS");
1819         }
1820
1821         for (m = machine_infos; m < machine_infos + n; m++) {
1822                 const char *on_state = "", *off_state = "";
1823                 const char *on_failed = "", *off_failed = "";
1824                 bool circle = false;
1825
1826                 if (streq_ptr(m->state, "degraded")) {
1827                         on_state = ansi_highlight_red();
1828                         off_state = ansi_highlight_off();
1829                         circle = true;
1830                 } else if (!streq_ptr(m->state, "running")) {
1831                         on_state = ansi_highlight_yellow();
1832                         off_state = ansi_highlight_off();
1833                         circle = true;
1834                 }
1835
1836                 if (m->n_failed_units > 0) {
1837                         on_failed = ansi_highlight_red();
1838                         off_failed = ansi_highlight_off();
1839                 } else
1840                         on_failed = off_failed = "";
1841
1842                 if (circle_len > 0)
1843                         printf("%s%s%s ", on_state, circle ? draw_special_char(DRAW_BLACK_CIRCLE) : " ", off_state);
1844
1845                 if (m->is_host)
1846                         printf("%-*s (host) %s%-*s%s %s%*u%s %*u\n",
1847                                (int) (namelen - (sizeof(" (host)")-1)), strna(m->name),
1848                                on_state, statelen, strna(m->state), off_state,
1849                                on_failed, failedlen, m->n_failed_units, off_failed,
1850                                jobslen, m->n_jobs);
1851                 else
1852                         printf("%-*s %s%-*s%s %s%*u%s %*u\n",
1853                                namelen, strna(m->name),
1854                                on_state, statelen, strna(m->state), off_state,
1855                                on_failed, failedlen, m->n_failed_units, off_failed,
1856                                jobslen, m->n_jobs);
1857         }
1858
1859         if (!arg_no_legend)
1860                 printf("\n%u machines listed.\n", n);
1861 }
1862
1863 static int list_machines(sd_bus *bus, char **args) {
1864         struct machine_info *machine_infos = NULL;
1865         int r;
1866
1867         assert(bus);
1868
1869         if (geteuid() != 0) {
1870                 log_error("Must be root.");
1871                 return -EPERM;
1872         }
1873
1874         pager_open_if_enabled();
1875
1876         r = get_machine_list(bus, &machine_infos, strv_skip_first(args));
1877         if (r < 0)
1878                 return r;
1879
1880         qsort_safe(machine_infos, r, sizeof(struct machine_info), compare_machine_info);
1881         output_machines_list(machine_infos, r);
1882         free_machines_list(machine_infos, r);
1883
1884         return 0;
1885 }
1886
1887 static int get_default(sd_bus *bus, char **args) {
1888         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1889         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1890         _cleanup_free_ char *_path = NULL;
1891         const char *path;
1892         int r;
1893
1894         if (!bus || avoid_bus()) {
1895                 r = unit_file_get_default(arg_scope, arg_root, &_path);
1896                 if (r < 0) {
1897                         log_error("Failed to get default target: %s", strerror(-r));
1898                         return r;
1899                 }
1900                 path = _path;
1901
1902         } else {
1903                 r = sd_bus_call_method(
1904                                 bus,
1905                                 "org.freedesktop.systemd1",
1906                                 "/org/freedesktop/systemd1",
1907                                 "org.freedesktop.systemd1.Manager",
1908                                 "GetDefaultTarget",
1909                                 &error,
1910                                 &reply,
1911                                 NULL);
1912                 if (r < 0) {
1913                         log_error("Failed to get default target: %s", bus_error_message(&error, -r));
1914                         return r;
1915                 }
1916
1917                 r = sd_bus_message_read(reply, "s", &path);
1918                 if (r < 0)
1919                         return bus_log_parse_error(r);
1920         }
1921
1922         if (path)
1923                 printf("%s\n", path);
1924
1925         return 0;
1926 }
1927
1928 static void dump_unit_file_changes(const UnitFileChange *changes, unsigned n_changes) {
1929         unsigned i;
1930
1931         assert(changes || n_changes == 0);
1932
1933         for (i = 0; i < n_changes; i++) {
1934                 if (changes[i].type == UNIT_FILE_SYMLINK)
1935                         log_info("Created symlink from %s to %s.", changes[i].path, changes[i].source);
1936                 else
1937                         log_info("Removed symlink %s.", changes[i].path);
1938         }
1939 }
1940
1941 static int deserialize_and_dump_unit_file_changes(sd_bus_message *m) {
1942         const char *type, *path, *source;
1943         int r;
1944
1945         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_ARRAY, "(sss)");
1946         if (r < 0)
1947                 return bus_log_parse_error(r);
1948
1949         while ((r = sd_bus_message_read(m, "(sss)", &type, &path, &source)) > 0) {
1950                 if (!arg_quiet) {
1951                         if (streq(type, "symlink"))
1952                                 log_info("Created symlink from %s to %s.", path, source);
1953                         else
1954                                 log_info("Removed symlink %s.", path);
1955                 }
1956         }
1957         if (r < 0)
1958                 return bus_log_parse_error(r);
1959
1960         r = sd_bus_message_exit_container(m);
1961         if (r < 0)
1962                 return bus_log_parse_error(r);
1963
1964         return 0;
1965 }
1966
1967 static int set_default(sd_bus *bus, char **args) {
1968         _cleanup_free_ char *unit = NULL;
1969         UnitFileChange *changes = NULL;
1970         unsigned n_changes = 0;
1971         int r;
1972
1973         unit = unit_name_mangle_with_suffix(args[1], MANGLE_NOGLOB, ".target");
1974         if (!unit)
1975                 return log_oom();
1976
1977         if (!bus || avoid_bus()) {
1978                 r = unit_file_set_default(arg_scope, arg_root, unit, true, &changes, &n_changes);
1979                 if (r < 0) {
1980                         log_error("Failed to set default target: %s", strerror(-r));
1981                         return r;
1982                 }
1983
1984                 if (!arg_quiet)
1985                         dump_unit_file_changes(changes, n_changes);
1986
1987                 r = 0;
1988         } else {
1989                 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
1990                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
1991
1992                 r = sd_bus_call_method(
1993                                 bus,
1994                                 "org.freedesktop.systemd1",
1995                                 "/org/freedesktop/systemd1",
1996                                 "org.freedesktop.systemd1.Manager",
1997                                 "SetDefaultTarget",
1998                                 &error,
1999                                 &reply,
2000                                 "sb", unit, true);
2001                 if (r < 0) {
2002                         log_error("Failed to set default target: %s", bus_error_message(&error, -r));
2003                         return r;
2004                 }
2005
2006                 r = deserialize_and_dump_unit_file_changes(reply);
2007                 if (r < 0)
2008                         return r;
2009
2010                 /* Try to reload if enabled */
2011                 if (!arg_no_reload)
2012                         r = daemon_reload(bus, args);
2013                 else
2014                         r = 0;
2015         }
2016
2017         unit_file_changes_free(changes, n_changes);
2018
2019         return r;
2020 }
2021
2022 struct job_info {
2023         uint32_t id;
2024         const char *name, *type, *state;
2025 };
2026
2027 static void output_jobs_list(const struct job_info* jobs, unsigned n, bool skipped) {
2028         unsigned id_len, unit_len, type_len, state_len;
2029         const struct job_info *j;
2030         const char *on, *off;
2031         bool shorten = false;
2032
2033         assert(n == 0 || jobs);
2034
2035         if (n == 0) {
2036                 on = ansi_highlight_green();
2037                 off = ansi_highlight_off();
2038
2039                 printf("%sNo jobs %s.%s\n", on, skipped ? "listed" : "running", off);
2040                 return;
2041         }
2042
2043         pager_open_if_enabled();
2044
2045         id_len = strlen("JOB");
2046         unit_len = strlen("UNIT");
2047         type_len = strlen("TYPE");
2048         state_len = strlen("STATE");
2049
2050         for (j = jobs; j < jobs + n; j++) {
2051                 uint32_t id = j->id;
2052                 assert(j->name && j->type && j->state);
2053
2054                 id_len = MAX(id_len, DECIMAL_STR_WIDTH(id));
2055                 unit_len = MAX(unit_len, strlen(j->name));
2056                 type_len = MAX(type_len, strlen(j->type));
2057                 state_len = MAX(state_len, strlen(j->state));
2058         }
2059
2060         if (!arg_full && id_len + 1 + unit_len + type_len + 1 + state_len > columns()) {
2061                 unit_len = MAX(33u, columns() - id_len - type_len - state_len - 3);
2062                 shorten = true;
2063         }
2064
2065         if (!arg_no_legend)
2066                 printf("%*s %-*s %-*s %-*s\n",
2067                        id_len, "JOB",
2068                        unit_len, "UNIT",
2069                        type_len, "TYPE",
2070                        state_len, "STATE");
2071
2072         for (j = jobs; j < jobs + n; j++) {
2073                 _cleanup_free_ char *e = NULL;
2074
2075                 if (streq(j->state, "running")) {
2076                         on = ansi_highlight();
2077                         off = ansi_highlight_off();
2078                 } else
2079                         on = off = "";
2080
2081                 e = shorten ? ellipsize(j->name, unit_len, 33) : NULL;
2082                 printf("%*u %s%-*s%s %-*s %s%-*s%s\n",
2083                        id_len, j->id,
2084                        on, unit_len, e ? e : j->name, off,
2085                        type_len, j->type,
2086                        on, state_len, j->state, off);
2087         }
2088
2089         if (!arg_no_legend) {
2090                 on = ansi_highlight();
2091                 off = ansi_highlight_off();
2092
2093                 printf("\n%s%u jobs listed%s.\n", on, n, off);
2094         }
2095 }
2096
2097 static bool output_show_job(struct job_info *job, char **patterns) {
2098         char **pattern;
2099
2100         assert(job);
2101
2102         if (strv_isempty(patterns))
2103                 return true;
2104
2105         STRV_FOREACH(pattern, patterns)
2106                 if (fnmatch(*pattern, job->name, FNM_NOESCAPE) == 0)
2107                         return true;
2108         return false;
2109 }
2110
2111 static int list_jobs(sd_bus *bus, char **args) {
2112         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2113         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2114         const char *name, *type, *state, *job_path, *unit_path;
2115         _cleanup_free_ struct job_info *jobs = NULL;
2116         size_t size = 0;
2117         unsigned c = 0;
2118         uint32_t id;
2119         int r;
2120         bool skipped = false;
2121
2122         r = sd_bus_call_method(
2123                         bus,
2124                         "org.freedesktop.systemd1",
2125                         "/org/freedesktop/systemd1",
2126                         "org.freedesktop.systemd1.Manager",
2127                         "ListJobs",
2128                         &error,
2129                         &reply,
2130                         NULL);
2131         if (r < 0) {
2132                 log_error("Failed to list jobs: %s", bus_error_message(&error, r));
2133                 return r;
2134         }
2135
2136         r = sd_bus_message_enter_container(reply, 'a', "(usssoo)");
2137         if (r < 0)
2138                 return bus_log_parse_error(r);
2139
2140         while ((r = sd_bus_message_read(reply, "(usssoo)", &id, &name, &type, &state, &job_path, &unit_path)) > 0) {
2141                 struct job_info job = { id, name, type, state };
2142
2143                 if (!output_show_job(&job, strv_skip_first(args))) {
2144                         skipped = true;
2145                         continue;
2146                 }
2147
2148                 if (!GREEDY_REALLOC(jobs, size, c + 1))
2149                         return log_oom();
2150
2151                 jobs[c++] = job;
2152         }
2153         if (r < 0)
2154                 return bus_log_parse_error(r);
2155
2156         r = sd_bus_message_exit_container(reply);
2157         if (r < 0)
2158                 return bus_log_parse_error(r);
2159
2160         output_jobs_list(jobs, c, skipped);
2161         return r;
2162 }
2163
2164 static int cancel_job(sd_bus *bus, char **args) {
2165         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2166         char **name;
2167
2168         assert(args);
2169
2170         if (strv_length(args) <= 1)
2171                 return daemon_reload(bus, args);
2172
2173         STRV_FOREACH(name, args+1) {
2174                 uint32_t id;
2175                 int r;
2176
2177                 r = safe_atou32(*name, &id);
2178                 if (r < 0) {
2179                         log_error("Failed to parse job id \"%s\": %s", *name, strerror(-r));
2180                         return r;
2181                 }
2182
2183                 r = sd_bus_call_method(
2184                                 bus,
2185                                 "org.freedesktop.systemd1",
2186                                 "/org/freedesktop/systemd1",
2187                                 "org.freedesktop.systemd1.Manager",
2188                                 "CancelJob",
2189                                 &error,
2190                                 NULL,
2191                                 "u", id);
2192                 if (r < 0) {
2193                         log_error("Failed to cancel job %u: %s", (unsigned) id, bus_error_message(&error, r));
2194                         return r;
2195                 }
2196         }
2197
2198         return 0;
2199 }
2200
2201 static int need_daemon_reload(sd_bus *bus, const char *unit) {
2202         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2203         const char *path;
2204         int b, r;
2205
2206         /* We ignore all errors here, since this is used to show a
2207          * warning only */
2208
2209         /* We don't use unit_dbus_path_from_name() directly since we
2210          * don't want to load the unit if it isn't loaded. */
2211
2212         r = sd_bus_call_method(
2213                         bus,
2214                         "org.freedesktop.systemd1",
2215                         "/org/freedesktop/systemd1",
2216                         "org.freedesktop.systemd1.Manager",
2217                         "GetUnit",
2218                         NULL,
2219                         &reply,
2220                         "s", unit);
2221         if (r < 0)
2222                 return r;
2223
2224         r = sd_bus_message_read(reply, "o", &path);
2225         if (r < 0)
2226                 return r;
2227
2228         r = sd_bus_get_property_trivial(
2229                         bus,
2230                         "org.freedesktop.systemd1",
2231                         path,
2232                         "org.freedesktop.systemd1.Unit",
2233                         "NeedDaemonReload",
2234                         NULL,
2235                         'b', &b);
2236         if (r < 0)
2237                 return r;
2238
2239         return b;
2240 }
2241
2242 typedef struct WaitData {
2243         Set *set;
2244
2245         char *name;
2246         char *result;
2247 } WaitData;
2248
2249 static int wait_filter(sd_bus *bus, sd_bus_message *m, void *data, sd_bus_error *error) {
2250         WaitData *d = data;
2251
2252         assert(bus);
2253         assert(m);
2254         assert(d);
2255
2256         log_debug("Got D-Bus request: %s.%s() on %s",
2257                   sd_bus_message_get_interface(m),
2258                   sd_bus_message_get_member(m),
2259                   sd_bus_message_get_path(m));
2260
2261         if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected")) {
2262                 log_error("Warning! D-Bus connection terminated.");
2263                 sd_bus_close(bus);
2264         } else if (sd_bus_message_is_signal(m, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
2265                 uint32_t id;
2266                 const char *path, *result, *unit;
2267                 char *ret;
2268                 int r;
2269
2270                 r = sd_bus_message_read(m, "uoss", &id, &path, &unit, &result);
2271                 if (r >= 0) {
2272                         ret = set_remove(d->set, (char*) path);
2273                         if (!ret)
2274                                 return 0;
2275
2276                         free(ret);
2277
2278                         if (!isempty(result))
2279                                 d->result = strdup(result);
2280
2281                         if (!isempty(unit))
2282                                 d->name = strdup(unit);
2283
2284                         return 0;
2285                 }
2286 #ifndef NOLEGACY
2287                 r = sd_bus_message_read(m, "uos", &id, &path, &result);
2288                 if (r >= 0) {
2289                         ret = set_remove(d->set, (char*) path);
2290                         if (!ret)
2291                                 return 0;
2292
2293                         free(ret);
2294
2295                         if (*result)
2296                                 d->result = strdup(result);
2297
2298                         return 0;
2299                 }
2300 #endif
2301
2302                 bus_log_parse_error(r);
2303         }
2304
2305         return 0;
2306 }
2307
2308 static int enable_wait_for_jobs(sd_bus *bus) {
2309         int r;
2310
2311         assert(bus);
2312
2313         r = sd_bus_add_match(
2314                         bus,
2315                         NULL,
2316                         "type='signal',"
2317                         "sender='org.freedesktop.systemd1',"
2318                         "interface='org.freedesktop.systemd1.Manager',"
2319                         "member='JobRemoved',"
2320                         "path='/org/freedesktop/systemd1'",
2321                         NULL, NULL);
2322         if (r < 0) {
2323                 log_error("Failed to add match");
2324                 return -EIO;
2325         }
2326
2327         /* This is slightly dirty, since we don't undo the match registrations. */
2328         return 0;
2329 }
2330
2331 static int bus_process_wait(sd_bus *bus) {
2332         int r;
2333
2334         for (;;) {
2335                 r = sd_bus_process(bus, NULL);
2336                 if (r < 0)
2337                         return r;
2338                 if (r > 0)
2339                         return 0;
2340                 r = sd_bus_wait(bus, (uint64_t) -1);
2341                 if (r < 0)
2342                         return r;
2343         }
2344 }
2345
2346 static int check_wait_response(WaitData *d) {
2347         int r = 0;
2348
2349         assert(d->result);
2350
2351         if (!arg_quiet) {
2352                 if (streq(d->result, "timeout"))
2353                         log_error("Job for %s timed out.", strna(d->name));
2354                 else if (streq(d->result, "canceled"))
2355                         log_error("Job for %s canceled.", strna(d->name));
2356                 else if (streq(d->result, "dependency"))
2357                         log_error("A dependency job for %s failed. See 'journalctl -xn' for details.", strna(d->name));
2358                 else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2359                         log_error("Job for %s failed. See 'systemctl status %s' and 'journalctl -xn' for details.", strna(d->name), strna(d->name));
2360         }
2361
2362         if (streq(d->result, "timeout"))
2363                 r = -ETIME;
2364         else if (streq(d->result, "canceled"))
2365                 r = -ECANCELED;
2366         else if (streq(d->result, "dependency"))
2367                 r = -EIO;
2368         else if (!streq(d->result, "done") && !streq(d->result, "skipped"))
2369                 r = -EIO;
2370
2371         return r;
2372 }
2373
2374 static int wait_for_jobs(sd_bus *bus, Set *s) {
2375         _cleanup_bus_slot_unref_ sd_bus_slot *slot = NULL;
2376         WaitData d = { .set = s };
2377         int r = 0, q;
2378
2379         assert(bus);
2380         assert(s);
2381
2382         q = sd_bus_add_filter(bus, &slot, wait_filter, &d);
2383         if (q < 0)
2384                 return log_oom();
2385
2386         while (!set_isempty(s)) {
2387                 q = bus_process_wait(bus);
2388                 if (q < 0) {
2389                         log_error("Failed to wait for response: %s", strerror(-r));
2390                         return q;
2391                 }
2392
2393                 if (d.result) {
2394                         q = check_wait_response(&d);
2395                         /* Return the first error as it is most likely to be
2396                          * meaningful. */
2397                         if (q < 0 && r == 0)
2398                                 r = q;
2399                         log_debug("Got result %s/%s for job %s",
2400                                   strna(d.result), strerror(-q), strna(d.name));
2401                 }
2402
2403                 free(d.name);
2404                 d.name = NULL;
2405
2406                 free(d.result);
2407                 d.result = NULL;
2408         }
2409
2410         return r;
2411 }
2412
2413 static int check_one_unit(sd_bus *bus, const char *name, const char *good_states, bool quiet) {
2414         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2415         _cleanup_free_ char *n = NULL, *state = NULL;
2416         const char *path;
2417         int r;
2418
2419         assert(name);
2420
2421         n = unit_name_mangle(name, MANGLE_NOGLOB);
2422         if (!n)
2423                 return log_oom();
2424
2425         /* We don't use unit_dbus_path_from_name() directly since we
2426          * don't want to load the unit if it isn't loaded. */
2427
2428         r = sd_bus_call_method(
2429                         bus,
2430                         "org.freedesktop.systemd1",
2431                         "/org/freedesktop/systemd1",
2432                         "org.freedesktop.systemd1.Manager",
2433                         "GetUnit",
2434                         NULL,
2435                         &reply,
2436                         "s", n);
2437         if (r < 0) {
2438                 if (!quiet)
2439                         puts("unknown");
2440                 return 0;
2441         }
2442
2443         r = sd_bus_message_read(reply, "o", &path);
2444         if (r < 0)
2445                 return bus_log_parse_error(r);
2446
2447         r = sd_bus_get_property_string(
2448                         bus,
2449                         "org.freedesktop.systemd1",
2450                         path,
2451                         "org.freedesktop.systemd1.Unit",
2452                         "ActiveState",
2453                         NULL,
2454                         &state);
2455         if (r < 0) {
2456                 if (!quiet)
2457                         puts("unknown");
2458                 return 0;
2459         }
2460
2461         if (!quiet)
2462                 puts(state);
2463
2464         return nulstr_contains(good_states, state);
2465 }
2466
2467 static int check_triggering_units(
2468                 sd_bus *bus,
2469                 const char *name) {
2470
2471         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2472         _cleanup_free_ char *path = NULL, *n = NULL, *state = NULL;
2473         _cleanup_strv_free_ char **triggered_by = NULL;
2474         bool print_warning_label = true;
2475         char **i;
2476         int r;
2477
2478         n = unit_name_mangle(name, MANGLE_NOGLOB);
2479         if (!n)
2480                 return log_oom();
2481
2482         path = unit_dbus_path_from_name(n);
2483         if (!path)
2484                 return log_oom();
2485
2486         r = sd_bus_get_property_string(
2487                         bus,
2488                         "org.freedesktop.systemd1",
2489                         path,
2490                         "org.freedesktop.systemd1.Unit",
2491                         "LoadState",
2492                         &error,
2493                         &state);
2494         if (r < 0) {
2495                 log_error("Failed to get load state of %s: %s", n, bus_error_message(&error, r));
2496                 return r;
2497         }
2498
2499         if (streq(state, "masked"))
2500                 return 0;
2501
2502         r = sd_bus_get_property_strv(
2503                         bus,
2504                         "org.freedesktop.systemd1",
2505                         path,
2506                         "org.freedesktop.systemd1.Unit",
2507                         "TriggeredBy",
2508                         &error,
2509                         &triggered_by);
2510         if (r < 0) {
2511                 log_error("Failed to get triggered by array of %s: %s", n, bus_error_message(&error, r));
2512                 return r;
2513         }
2514
2515         STRV_FOREACH(i, triggered_by) {
2516                 r = check_one_unit(bus, *i, "active\0reloading\0", true);
2517                 if (r < 0) {
2518                         log_error("Failed to check unit: %s", strerror(-r));
2519                         return r;
2520                 }
2521
2522                 if (r == 0)
2523                         continue;
2524
2525                 if (print_warning_label) {
2526                         log_warning("Warning: Stopping %s, but it can still be activated by:", n);
2527                         print_warning_label = false;
2528                 }
2529
2530                 log_warning("  %s", *i);
2531         }
2532
2533         return 0;
2534 }
2535
2536 static const char *verb_to_method(const char *verb) {
2537        uint i;
2538
2539        for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2540                 if (streq_ptr(unit_actions[i].verb, verb))
2541                         return unit_actions[i].method;
2542
2543        return "StartUnit";
2544 }
2545
2546 static const char *method_to_verb(const char *method) {
2547        uint i;
2548
2549        for (i = 0; i < ELEMENTSOF(unit_actions); i++)
2550                 if (streq_ptr(unit_actions[i].method, method))
2551                         return unit_actions[i].verb;
2552
2553        return "n/a";
2554 }
2555
2556 static int start_unit_one(
2557                 sd_bus *bus,
2558                 const char *method,
2559                 const char *name,
2560                 const char *mode,
2561                 sd_bus_error *error,
2562                 Set *s) {
2563
2564         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2565         const char *path;
2566         int r;
2567
2568         assert(method);
2569         assert(name);
2570         assert(mode);
2571         assert(error);
2572
2573         log_debug("Calling manager for %s on %s, %s", method, name, mode);
2574         r = sd_bus_call_method(
2575                         bus,
2576                         "org.freedesktop.systemd1",
2577                         "/org/freedesktop/systemd1",
2578                         "org.freedesktop.systemd1.Manager",
2579                         method,
2580                         error,
2581                         &reply,
2582                         "ss", name, mode);
2583         if (r < 0) {
2584                 const char *verb;
2585
2586                 if (r == -ENOENT && arg_action != ACTION_SYSTEMCTL)
2587                         /* There's always a fallback possible for
2588                          * legacy actions. */
2589                         return -EADDRNOTAVAIL;
2590
2591                 verb = method_to_verb(method);
2592
2593                 log_error("Failed to %s %s: %s", verb, name, bus_error_message(error, r));
2594                 return r;
2595         }
2596
2597         r = sd_bus_message_read(reply, "o", &path);
2598         if (r < 0)
2599                 return bus_log_parse_error(r);
2600
2601         if (need_daemon_reload(bus, name) > 0)
2602                 log_warning("Warning: Unit file of %s changed on disk, 'systemctl%s daemon-reload' recommended.",
2603                             name, arg_scope == UNIT_FILE_SYSTEM ? "" : " --user");
2604
2605         if (s) {
2606                 char *p;
2607
2608                 p = strdup(path);
2609                 if (!p)
2610                         return log_oom();
2611
2612                 log_debug("Adding %s to the set", p);
2613                 r = set_consume(s, p);
2614                 if (r < 0)
2615                         return log_oom();
2616         }
2617
2618         return 0;
2619 }
2620
2621 static int expand_names(sd_bus *bus, char **names, const char* suffix, char ***ret) {
2622
2623         _cleanup_strv_free_ char **mangled = NULL, **globs = NULL;
2624         char **name;
2625         int r = 0, i;
2626
2627         STRV_FOREACH(name, names) {
2628                 char *t;
2629
2630                 if (suffix)
2631                         t = unit_name_mangle_with_suffix(*name, MANGLE_GLOB, suffix);
2632                 else
2633                         t = unit_name_mangle(*name, MANGLE_GLOB);
2634                 if (!t)
2635                         return log_oom();
2636
2637                 if (string_is_glob(t))
2638                         r = strv_consume(&globs, t);
2639                 else
2640                         r = strv_consume(&mangled, t);
2641                 if (r < 0)
2642                         return log_oom();
2643         }
2644
2645         /* Query the manager only if any of the names are a glob, since
2646          * this is fairly expensive */
2647         if (!strv_isempty(globs)) {
2648                 _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2649                 _cleanup_free_ UnitInfo *unit_infos = NULL;
2650
2651                 r = get_unit_list(bus, NULL, globs, &unit_infos, 0, &reply);
2652                 if (r < 0)
2653                         return r;
2654
2655                 for (i = 0; i < r; i++)
2656                         if (strv_extend(&mangled, unit_infos[i].id) < 0)
2657                                 return log_oom();
2658         }
2659
2660         *ret = mangled;
2661         mangled = NULL; /* do not free */
2662
2663         return 0;
2664 }
2665
2666 static const struct {
2667         const char *target;
2668         const char *verb;
2669         const char *mode;
2670 } action_table[_ACTION_MAX] = {
2671         [ACTION_HALT]         = { SPECIAL_HALT_TARGET,         "halt",         "replace-irreversibly" },
2672         [ACTION_POWEROFF]     = { SPECIAL_POWEROFF_TARGET,     "poweroff",     "replace-irreversibly" },
2673         [ACTION_REBOOT]       = { SPECIAL_REBOOT_TARGET,       "reboot",       "replace-irreversibly" },
2674         [ACTION_KEXEC]        = { SPECIAL_KEXEC_TARGET,        "kexec",        "replace-irreversibly" },
2675         [ACTION_RUNLEVEL2]    = { SPECIAL_RUNLEVEL2_TARGET,    NULL,           "isolate" },
2676         [ACTION_RUNLEVEL3]    = { SPECIAL_RUNLEVEL3_TARGET,    NULL,           "isolate" },
2677         [ACTION_RUNLEVEL4]    = { SPECIAL_RUNLEVEL4_TARGET,    NULL,           "isolate" },
2678         [ACTION_RUNLEVEL5]    = { SPECIAL_RUNLEVEL5_TARGET,    NULL,           "isolate" },
2679         [ACTION_RESCUE]       = { SPECIAL_RESCUE_TARGET,       "rescue",       "isolate" },
2680         [ACTION_EMERGENCY]    = { SPECIAL_EMERGENCY_TARGET,    "emergency",    "isolate" },
2681         [ACTION_DEFAULT]      = { SPECIAL_DEFAULT_TARGET,      "default",      "isolate" },
2682         [ACTION_EXIT]         = { SPECIAL_EXIT_TARGET,         "exit",         "replace-irreversibly" },
2683         [ACTION_SUSPEND]      = { SPECIAL_SUSPEND_TARGET,      "suspend",      "replace-irreversibly" },
2684         [ACTION_HIBERNATE]    = { SPECIAL_HIBERNATE_TARGET,    "hibernate",    "replace-irreversibly" },
2685         [ACTION_HYBRID_SLEEP] = { SPECIAL_HYBRID_SLEEP_TARGET, "hybrid-sleep", "replace-irreversibly" },
2686 };
2687
2688 static enum action verb_to_action(const char *verb) {
2689         enum action i;
2690
2691         for (i = _ACTION_INVALID; i < _ACTION_MAX; i++)
2692                 if (streq_ptr(action_table[i].verb, verb))
2693                         return i;
2694
2695         return _ACTION_INVALID;
2696 }
2697
2698 static int start_unit(sd_bus *bus, char **args) {
2699         _cleanup_set_free_free_ Set *s = NULL;
2700         _cleanup_strv_free_ char **names = NULL;
2701         const char *method, *mode, *one_name;
2702         char **name;
2703         int r = 0;
2704
2705         assert(bus);
2706
2707         ask_password_agent_open_if_enabled();
2708
2709         if (arg_action == ACTION_SYSTEMCTL) {
2710                 enum action action;
2711                 method = verb_to_method(args[0]);
2712                 action = verb_to_action(args[0]);
2713
2714                 mode = streq(args[0], "isolate") ? "isolate" :
2715                        action_table[action].mode ?: arg_job_mode;
2716
2717                 one_name = action_table[action].target;
2718         } else {
2719                 assert(arg_action < ELEMENTSOF(action_table));
2720                 assert(action_table[arg_action].target);
2721
2722                 method = "StartUnit";
2723
2724                 mode = action_table[arg_action].mode;
2725                 one_name = action_table[arg_action].target;
2726         }
2727
2728         if (one_name)
2729                 names = strv_new(one_name, NULL);
2730         else {
2731                 r = expand_names(bus, args + 1, NULL, &names);
2732                 if (r < 0)
2733                         log_error("Failed to expand names: %s", strerror(-r));
2734         }
2735
2736         if (!arg_no_block) {
2737                 r = enable_wait_for_jobs(bus);
2738                 if (r < 0) {
2739                         log_error("Could not watch jobs: %s", strerror(-r));
2740                         return r;
2741                 }
2742
2743                 s = set_new(string_hash_func, string_compare_func);
2744                 if (!s)
2745                         return log_oom();
2746         }
2747
2748         STRV_FOREACH(name, names) {
2749                 _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2750                 int q;
2751
2752                 q = start_unit_one(bus, method, *name, mode, &error, s);
2753                 if (r >= 0 && q < 0)
2754                         r = translate_bus_error_to_exit_status(q, &error);
2755         }
2756
2757         if (!arg_no_block) {
2758                 int q;
2759
2760                 q = wait_for_jobs(bus, s);
2761                 if (q < 0)
2762                         return q;
2763
2764                 /* When stopping units, warn if they can still be triggered by
2765                  * another active unit (socket, path, timer) */
2766                 if (!arg_quiet && streq(method, "StopUnit"))
2767                         STRV_FOREACH(name, names)
2768                                 check_triggering_units(bus, *name);
2769         }
2770
2771         return r;
2772 }
2773
2774 /* Ask systemd-logind, which might grant access to unprivileged users
2775  * through PolicyKit */
2776 static int reboot_with_logind(sd_bus *bus, enum action a) {
2777 #ifdef HAVE_LOGIND
2778         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
2779         const char *method;
2780         int r;
2781
2782         if (!bus)
2783                 return -EIO;
2784
2785         polkit_agent_open_if_enabled();
2786
2787         switch (a) {
2788
2789         case ACTION_REBOOT:
2790                 method = "Reboot";
2791                 break;
2792
2793         case ACTION_POWEROFF:
2794                 method = "PowerOff";
2795                 break;
2796
2797         case ACTION_SUSPEND:
2798                 method = "Suspend";
2799                 break;
2800
2801         case ACTION_HIBERNATE:
2802                 method = "Hibernate";
2803                 break;
2804
2805         case ACTION_HYBRID_SLEEP:
2806                 method = "HybridSleep";
2807                 break;
2808
2809         default:
2810                 return -EINVAL;
2811         }
2812
2813         r = sd_bus_call_method(
2814                         bus,
2815                         "org.freedesktop.login1",
2816                         "/org/freedesktop/login1",
2817                         "org.freedesktop.login1.Manager",
2818                         method,
2819                         &error,
2820                         NULL,
2821                         "b", true);
2822         if (r < 0)
2823                 log_error("Failed to execute operation: %s", bus_error_message(&error, r));
2824
2825         return r;
2826 #else
2827         return -ENOSYS;
2828 #endif
2829 }
2830
2831 static int check_inhibitors(sd_bus *bus, enum action a) {
2832 #ifdef HAVE_LOGIND
2833         _cleanup_bus_message_unref_ sd_bus_message *reply = NULL;
2834         _cleanup_strv_free_ char **sessions = NULL;
2835         const char *what, *who, *why, *mode;
2836         uint32_t uid, pid;
2837         unsigned c = 0;
2838         char **s;
2839         int r;
2840
2841         if (!bus)
2842                 return 0;
2843
2844         if (arg_ignore_inhibitors || arg_force > 0)
2845                 return 0;
2846
2847         if (arg_when > 0)
2848                 return 0;
2849
2850         if (geteuid() == 0)
2851                 return 0;
2852
2853         if (!on_tty())
2854                 return 0;
2855
2856         r = sd_bus_call_method(
2857                         bus,
2858                         "org.freedesktop.login1",
2859                         "/org/freedesktop/login1",
2860                         "org.freedesktop.login1.Manager",
2861                         "ListInhibitors",
2862                         NULL,
2863                         &reply,
2864                         NULL);
2865         if (r < 0)
2866                 /* If logind is not around, then there are no inhibitors... */
2867                 return 0;
2868
2869         r = sd_bus_message_enter_container(reply, SD_BUS_TYPE_ARRAY, "(ssssuu)");
2870         if (r < 0)
2871                 return bus_log_parse_error(r);
2872
2873         while ((r = sd_bus_message_read(reply, "(ssssuu)", &what, &who, &why, &mode, &uid, &pid)) > 0) {
2874                 _cleanup_free_ char *comm = NULL, *user = NULL;
2875                 _cleanup_strv_free_ char **sv = NULL;
2876
2877                 if (!streq(mode, "block"))
2878                         continue;
2879
2880                 sv = strv_split(what, ":");
2881                 if (!sv)
2882                         return log_oom();
2883
2884                 if (!strv_contains(sv,
2885                                   a == ACTION_HALT ||
2886                                   a == ACTION_POWEROFF ||
2887                                   a == ACTION_REBOOT ||
2888                                   a == ACTION_KEXEC ? "shutdown" : "sleep"))
2889                         continue;
2890
2891                 get_process_comm(pid, &comm);
2892                 user = uid_to_name(uid);
2893
2894                 log_warning("Operation inhibited by \"%s\" (PID "PID_FMT" \"%s\", user %s), reason is \"%s\".",
2895                             who, pid, strna(comm), strna(user), why);
2896
2897                 c++;
2898         }
2899         if (r < 0)
2900                 return bus_log_parse_error(r);
2901
2902         r = sd_bus_message_exit_container(reply);
2903         if (r < 0)
2904                 return bus_log_parse_error(r);
2905
2906         /* Check for current sessions */
2907         sd_get_sessions(&sessions);
2908         STRV_FOREACH(s, sessions) {
2909                 _cleanup_free_ char *type = NULL, *tty = NULL, *seat = NULL, *user = NULL, *service = NULL, *class = NULL;
2910
2911                 if (sd_session_get_uid(*s, &uid) < 0 || uid == getuid())
2912                         continue;
2913
2914                 if (sd_session_get_class(*s, &class) < 0 || !streq(class, "user"))
2915                         continue;
2916
2917                 if (sd_session_get_type(*s, &type) < 0 || (!streq(type, "x11") && !streq(type, "tty")))
2918                         continue;
2919
2920                 sd_session_get_tty(*s, &tty);
2921                 sd_session_get_seat(*s, &seat);
2922                 sd_session_get_service(*s, &service);
2923                 user = uid_to_name(uid);
2924
2925                 log_warning("User %s is logged in on %s.", strna(user), isempty(tty) ? (isempty(seat) ? strna(service) : seat) : tty);
2926                 c++;
2927         }
2928
2929         if (c <= 0)
2930                 return 0;
2931
2932         log_error("Please retry operation after closing inhibitors and logging out other users.\nAlternatively, ignore inhibitors and users with 'systemctl %s -i'.",
2933                   action_table[a].verb);
2934
2935         return -EPERM;
2936 #else
2937         return 0;
2938 #endif
2939 }
2940
2941 static int start_special(sd_bus *bus, char **args) {
2942         enum action a;
2943         int r;
2944
2945         assert(args);
2946
2947         a = verb_to_action(args[0]);
2948
2949         r = check_inhibitors(bus, a);
2950         if (r < 0)
2951                 return r;
2952
2953         if (arg_force >= 2 && geteuid() != 0) {
2954                 log_error("Must be root.");
2955                 return -EPERM;
2956         }
2957
2958         if (arg_force >= 2 &&
2959             (a == ACTION_HALT ||
2960              a == ACTION_POWEROFF ||
2961              a == ACTION_REBOOT))
2962                 return halt_now(a);
2963
2964         if (arg_force >= 1 &&
2965             (a == ACTION_HALT ||
2966              a == ACTION_POWEROFF ||
2967              a == ACTION_REBOOT ||
2968              a == ACTION_KEXEC ||
2969              a == ACTION_EXIT))
2970                 return daemon_reload(bus, args);
2971
2972         /* first try logind, to allow authentication with polkit */
2973         if (geteuid() != 0 &&
2974             (a == ACTION_POWEROFF ||
2975              a == ACTION_REBOOT ||
2976              a == ACTION_SUSPEND ||
2977              a == ACTION_HIBERNATE ||
2978              a == ACTION_HYBRID_SLEEP)) {
2979                 r = reboot_with_logind(bus, a);
2980                 if (r >= 0)
2981                         return r;
2982         }
2983
2984         r = start_unit(bus, args);
2985         if (r == EXIT_SUCCESS)
2986                 warn_wall(a);
2987
2988         return r;
2989 }
2990
2991 static int check_unit_generic(sd_bus *bus, int code, const char *good_states, char **args) {
2992         _cleanup_strv_free_ char **names = NULL;
2993         char **name;
2994         int r;
2995
2996         assert(bus);
2997         assert(args);
2998
2999         r = expand_names(bus, args, NULL, &names);
3000         if (r < 0) {
3001                 log_error("Failed to expand names: %s", strerror(-r));
3002                 return r;
3003         }
3004
3005         STRV_FOREACH(name, names) {
3006                 int state;
3007
3008                 state = check_one_unit(bus, *name, good_states, arg_quiet);
3009                 if (state < 0)
3010                         return state;
3011                 if (state == 0)
3012                         r = code;
3013         }
3014
3015         return r;
3016 }
3017
3018 static int check_unit_active(sd_bus *bus, char **args) {
3019         /* According to LSB: 3, "program is not running" */
3020         return check_unit_generic(bus, 3, "active\0reloading\0", args + 1);
3021 }
3022
3023 static int check_unit_failed(sd_bus *bus, char **args) {
3024         return check_unit_generic(bus, 1, "failed\0", args + 1);
3025 }
3026
3027 static int kill_unit(sd_bus *bus, char **args) {
3028         _cleanup_bus_error_free_ sd_bus_error error = SD_BUS_ERROR_NULL;
3029         _cleanup_strv_free_ char **names = NULL;
3030         char **name;
3031         int r, q;
3032
3033         assert(bus);
3034         assert(args);
3035
3036         if (!arg_kill_who)
3037                 arg_kill_who = "all";
3038
3039         r = expand_names(bus, args + 1, NULL, &names);
3040         if (r < 0)
3041                 log_error("Failed to expand names: %s", strerror(-r));
3042
3043         STRV_FOREACH(name, names) {
3044                 q = sd_bus_call_method(
3045                                 bus,
3046                                 "org.freedesktop.systemd1",
3047                                 "/org/freedesktop/systemd1",
3048                                 "org.freedesktop.systemd1.Manager",
3049                                 "KillUnit",
3050                                 &error,
3051                                 NULL,
3052                                 "ssi", *names, arg_kill_who, arg_signal);
3053                 if (q < 0) {
3054                         log_error("Failed to kill unit %s: %s",
3055                                   *names, bus_error_message(&error, r));
3056                         if (r == 0)
3057                                 r = q;
3058                 }
3059         }
3060
3061         return r;
3062 }
3063
3064 typedef struct ExecStatusInfo {
3065         char *name;
3066
3067         char *path;
3068         char **argv;
3069
3070         bool ignore;
3071
3072         usec_t start_timestamp;
3073         usec_t exit_timestamp;
3074         pid_t pid;
3075         int code;
3076         int status;
3077
3078         LIST_FIELDS(struct ExecStatusInfo, exec);
3079 } ExecStatusInfo;
3080
3081 static void exec_status_info_free(ExecStatusInfo *i) {
3082         assert(i);
3083
3084         free(i->name);
3085         free(i->path);
3086         strv_free(i->argv);
3087         free(i);
3088 }
3089
3090 static int exec_status_info_deserialize(sd_bus_message *m, ExecStatusInfo *i) {
3091         uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
3092         const char *path;
3093         uint32_t pid;
3094         int32_t code, status;
3095         int ignore, r;
3096
3097         assert(m);
3098         assert(i);
3099
3100         r = sd_bus_message_enter_container(m, SD_BUS_TYPE_STRUCT, "sasbttttuii");
3101         if (r < 0)
3102                 return bus_log_parse_error(r);
3103         else if (r == 0)
3104                 return 0;
3105
3106         r = sd_bus_message_read(m, "s", &path);
3107         if (r < 0)
3108                 return bus_log_parse_error(r);
3109
3110         i->path = strdup(path);
3111         if (!i->path)
3112                 return log_oom();
3113
3114         r = sd_bus_message_read_strv(m, &i->argv);
3115         if (r < 0)
3116                 return bus_log_parse_error(r);
3117
3118         r = sd_bus_message_read(m,
3119                                 "bttttuii",
3120                                 &ignore,
3121                                 &start_timestamp, &start_timestamp_monotonic,
3122                                 &exit_timestamp, &exit_timestamp_monotonic,
3123                                 &pid,
3124                                 &code, &status);
3125         if (r < 0)
3126                 return bus_log_parse_error(r);
3127
3128         i->ignore = ignore;
3129         i->start_timestamp = (usec_t) start_timestamp;
3130         i->exit_timestamp = (usec_t) exit_timestamp;
3131         i->pid = (pid_t) pid;
3132         i->code = code;
3133         i->status = status;
3134
3135         r = sd_bus_message_exit_container(m);
3136         if (r < 0)
3137                 return bus_log_parse_error(r);
3138
3139         return 1;
3140 }
3141
3142 typedef struct UnitStatusInfo {
3143         const char *id;
3144         const char *load_state;
3145         const char *active_state;
3146         const char *sub_state;
3147         const char *unit_file_state;
3148
3149         const char *description;
3150         const char *following;
3151
3152         char **documentation;
3153
3154         const char *fragment_path;
3155         const char *source_path;
3156         const char *control_group;
3157
3158         char **dropin_paths;
3159
3160         const char *load_error;
3161         const char *result;
3162
3163         usec_t inactive_exit_timestamp;
3164         usec_t inactive_exit_timestamp_monotonic;
3165         usec_t active_enter_timestamp;
3166         usec_t active_exit_timestamp;
3167         usec_t inactive_enter_timestamp;