]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/systemctl/systemctl.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
util: split-out path-util.[ch]
[thirdparty/systemd.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
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22 #include <sys/reboot.h>
23 #include <stdio.h>
24 #include <getopt.h>
25 #include <stdbool.h>
26 #include <string.h>
27 #include <errno.h>
28 #include <sys/ioctl.h>
29 #include <termios.h>
30 #include <unistd.h>
31 #include <fcntl.h>
32 #include <sys/socket.h>
33 #include <sys/stat.h>
34 #include <stddef.h>
35 #include <sys/prctl.h>
36 #include <dbus/dbus.h>
37
38 #include <systemd/sd-daemon.h>
39 #include <systemd/sd-shutdown.h>
40
41 #include "log.h"
42 #include "util.h"
43 #include "macro.h"
44 #include "set.h"
45 #include "utmp-wtmp.h"
46 #include "special.h"
47 #include "initreq.h"
48 #include "path-util.h"
49 #include "strv.h"
50 #include "dbus-common.h"
51 #include "cgroup-show.h"
52 #include "cgroup-util.h"
53 #include "list.h"
54 #include "path-lookup.h"
55 #include "conf-parser.h"
56 #include "exit-status.h"
57 #include "bus-errors.h"
58 #include "build.h"
59 #include "unit-name.h"
60 #include "pager.h"
61 #include "spawn-ask-password-agent.h"
62 #include "spawn-polkit-agent.h"
63 #include "install.h"
64 #include "logs-show.h"
65 #include "path-util.h"
66
67 static const char *arg_type = NULL;
68 static char **arg_property = NULL;
69 static bool arg_all = false;
70 static const char *arg_job_mode = "replace";
71 static UnitFileScope arg_scope = UNIT_FILE_SYSTEM;
72 static bool arg_no_block = false;
73 static bool arg_no_legend = false;
74 static bool arg_no_pager = false;
75 static bool arg_no_wtmp = false;
76 static bool arg_no_sync = false;
77 static bool arg_no_wall = false;
78 static bool arg_no_reload = false;
79 static bool arg_dry = false;
80 static bool arg_quiet = false;
81 static bool arg_full = false;
82 static int arg_force = 0;
83 static bool arg_ask_password = true;
84 static bool arg_failed = false;
85 static bool arg_runtime = false;
86 static char **arg_wall = NULL;
87 static const char *arg_kill_who = NULL;
88 static const char *arg_kill_mode = NULL;
89 static int arg_signal = SIGTERM;
90 static const char *arg_root = NULL;
91 static usec_t arg_when = 0;
92 static enum action {
93 ACTION_INVALID,
94 ACTION_SYSTEMCTL,
95 ACTION_HALT,
96 ACTION_POWEROFF,
97 ACTION_REBOOT,
98 ACTION_KEXEC,
99 ACTION_EXIT,
100 ACTION_RUNLEVEL2,
101 ACTION_RUNLEVEL3,
102 ACTION_RUNLEVEL4,
103 ACTION_RUNLEVEL5,
104 ACTION_RESCUE,
105 ACTION_EMERGENCY,
106 ACTION_DEFAULT,
107 ACTION_RELOAD,
108 ACTION_REEXEC,
109 ACTION_RUNLEVEL,
110 ACTION_CANCEL_SHUTDOWN,
111 _ACTION_MAX
112 } arg_action = ACTION_SYSTEMCTL;
113 static enum dot {
114 DOT_ALL,
115 DOT_ORDER,
116 DOT_REQUIRE
117 } arg_dot = DOT_ALL;
118 static enum transport {
119 TRANSPORT_NORMAL,
120 TRANSPORT_SSH,
121 TRANSPORT_POLKIT
122 } arg_transport = TRANSPORT_NORMAL;
123 static const char *arg_host = NULL;
124 static bool arg_follow = false;
125 static unsigned arg_lines = 10;
126 static OutputMode arg_output = OUTPUT_SHORT;
127
128 static bool private_bus = false;
129
130 static int daemon_reload(DBusConnection *bus, char **args);
131 static void halt_now(enum action a);
132
133 static bool on_tty(void) {
134 static int t = -1;
135
136 /* Note that this is invoked relatively early, before we start
137 * the pager. That means the value we return reflects whether
138 * we originally were started on a tty, not if we currently
139 * are. But this is intended, since we want colour and so on
140 * when run in our own pager. */
141
142 if (_unlikely_(t < 0))
143 t = isatty(STDOUT_FILENO) > 0;
144
145 return t;
146 }
147
148 static void pager_open_if_enabled(void) {
149
150 /* Cache result before we open the pager */
151 on_tty();
152
153 if (arg_no_pager)
154 return;
155
156 pager_open();
157 }
158
159 static void ask_password_agent_open_if_enabled(void) {
160
161 /* Open the password agent as a child process if necessary */
162
163 if (!arg_ask_password)
164 return;
165
166 if (arg_scope != UNIT_FILE_SYSTEM)
167 return;
168
169 ask_password_agent_open();
170 }
171
172 static void polkit_agent_open_if_enabled(void) {
173
174 /* Open the polkit agent as a child process if necessary */
175
176 if (!arg_ask_password)
177 return;
178
179 if (arg_scope != UNIT_FILE_SYSTEM)
180 return;
181
182 polkit_agent_open();
183 }
184
185 static const char *ansi_highlight_red(bool b) {
186
187 if (!on_tty())
188 return "";
189
190 return b ? ANSI_HIGHLIGHT_RED_ON : ANSI_HIGHLIGHT_OFF;
191 }
192
193 static const char *ansi_highlight_green(bool b) {
194
195 if (!on_tty())
196 return "";
197
198 return b ? ANSI_HIGHLIGHT_GREEN_ON : ANSI_HIGHLIGHT_OFF;
199 }
200
201 static bool error_is_no_service(const DBusError *error) {
202 assert(error);
203
204 if (!dbus_error_is_set(error))
205 return false;
206
207 if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))
208 return true;
209
210 if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))
211 return true;
212
213 return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");
214 }
215
216 static int translate_bus_error_to_exit_status(int r, const DBusError *error) {
217 assert(error);
218
219 if (!dbus_error_is_set(error))
220 return r;
221
222 if (dbus_error_has_name(error, DBUS_ERROR_ACCESS_DENIED) ||
223 dbus_error_has_name(error, BUS_ERROR_ONLY_BY_DEPENDENCY) ||
224 dbus_error_has_name(error, BUS_ERROR_NO_ISOLATION) ||
225 dbus_error_has_name(error, BUS_ERROR_TRANSACTION_IS_DESTRUCTIVE))
226 return EXIT_NOPERMISSION;
227
228 if (dbus_error_has_name(error, BUS_ERROR_NO_SUCH_UNIT))
229 return EXIT_NOTINSTALLED;
230
231 if (dbus_error_has_name(error, BUS_ERROR_JOB_TYPE_NOT_APPLICABLE) ||
232 dbus_error_has_name(error, BUS_ERROR_NOT_SUPPORTED))
233 return EXIT_NOTIMPLEMENTED;
234
235 if (dbus_error_has_name(error, BUS_ERROR_LOAD_FAILED))
236 return EXIT_NOTCONFIGURED;
237
238 if (r != 0)
239 return r;
240
241 return EXIT_FAILURE;
242 }
243
244 static void warn_wall(enum action a) {
245 static const char *table[_ACTION_MAX] = {
246 [ACTION_HALT] = "The system is going down for system halt NOW!",
247 [ACTION_REBOOT] = "The system is going down for reboot NOW!",
248 [ACTION_POWEROFF] = "The system is going down for power-off NOW!",
249 [ACTION_KEXEC] = "The system is going down for kexec reboot NOW!",
250 [ACTION_RESCUE] = "The system is going down to rescue mode NOW!",
251 [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!"
252 };
253
254 if (arg_no_wall)
255 return;
256
257 if (arg_wall) {
258 char *p;
259
260 p = strv_join(arg_wall, " ");
261 if (!p) {
262 log_error("Failed to join strings.");
263 return;
264 }
265
266 if (*p) {
267 utmp_wall(p, NULL);
268 free(p);
269 return;
270 }
271
272 free(p);
273 }
274
275 if (!table[a])
276 return;
277
278 utmp_wall(table[a], NULL);
279 }
280
281 static bool avoid_bus(void) {
282
283 if (running_in_chroot() > 0)
284 return true;
285
286 if (sd_booted() <= 0)
287 return true;
288
289 if (!isempty(arg_root))
290 return true;
291
292 if (arg_scope == UNIT_FILE_GLOBAL)
293 return true;
294
295 return false;
296 }
297
298 struct unit_info {
299 const char *id;
300 const char *description;
301 const char *load_state;
302 const char *active_state;
303 const char *sub_state;
304 const char *following;
305 const char *unit_path;
306 uint32_t job_id;
307 const char *job_type;
308 const char *job_path;
309 };
310
311 static int compare_unit_info(const void *a, const void *b) {
312 const char *d1, *d2;
313 const struct unit_info *u = a, *v = b;
314
315 d1 = strrchr(u->id, '.');
316 d2 = strrchr(v->id, '.');
317
318 if (d1 && d2) {
319 int r;
320
321 if ((r = strcasecmp(d1, d2)) != 0)
322 return r;
323 }
324
325 return strcasecmp(u->id, v->id);
326 }
327
328 static bool output_show_unit(const struct unit_info *u) {
329 const char *dot;
330
331 if (arg_failed)
332 return streq(u->active_state, "failed");
333
334 return (!arg_type || ((dot = strrchr(u->id, '.')) &&
335 streq(dot+1, arg_type))) &&
336 (arg_all || !(streq(u->active_state, "inactive") || u->following[0]) || u->job_id > 0);
337 }
338
339 static void output_units_list(const struct unit_info *unit_infos, unsigned c) {
340 unsigned id_len, max_id_len, active_len, sub_len, job_len, desc_len, n_shown = 0;
341 const struct unit_info *u;
342
343 max_id_len = sizeof("UNIT")-1;
344 active_len = sizeof("ACTIVE")-1;
345 sub_len = sizeof("SUB")-1;
346 job_len = sizeof("JOB")-1;
347 desc_len = 0;
348
349 for (u = unit_infos; u < unit_infos + c; u++) {
350 if (!output_show_unit(u))
351 continue;
352
353 max_id_len = MAX(max_id_len, strlen(u->id));
354 active_len = MAX(active_len, strlen(u->active_state));
355 sub_len = MAX(sub_len, strlen(u->sub_state));
356 if (u->job_id != 0)
357 job_len = MAX(job_len, strlen(u->job_type));
358 }
359
360 if (!arg_full) {
361 unsigned basic_len;
362 id_len = MIN(max_id_len, 25);
363 basic_len = 5 + id_len + 6 + active_len + sub_len + job_len;
364 if (basic_len < (unsigned) columns()) {
365 unsigned extra_len, incr;
366 extra_len = columns() - basic_len;
367 /* Either UNIT already got 25, or is fully satisfied.
368 * Grant up to 25 to DESC now. */
369 incr = MIN(extra_len, 25);
370 desc_len += incr;
371 extra_len -= incr;
372 /* split the remaining space between UNIT and DESC,
373 * but do not give UNIT more than it needs. */
374 if (extra_len > 0) {
375 incr = MIN(extra_len / 2, max_id_len - id_len);
376 id_len += incr;
377 desc_len += extra_len - incr;
378 }
379 }
380 } else
381 id_len = max_id_len;
382
383 if (!arg_no_legend) {
384 printf("%-*s %-6s %-*s %-*s %-*s ", id_len, "UNIT", "LOAD",
385 active_len, "ACTIVE", sub_len, "SUB", job_len, "JOB");
386 if (!arg_full && arg_no_pager)
387 printf("%.*s\n", desc_len, "DESCRIPTION");
388 else
389 printf("%s\n", "DESCRIPTION");
390 }
391
392 for (u = unit_infos; u < unit_infos + c; u++) {
393 char *e;
394 const char *on_loaded, *off_loaded;
395 const char *on_active, *off_active;
396
397 if (!output_show_unit(u))
398 continue;
399
400 n_shown++;
401
402 if (streq(u->load_state, "error")) {
403 on_loaded = ansi_highlight_red(true);
404 off_loaded = ansi_highlight_red(false);
405 } else
406 on_loaded = off_loaded = "";
407
408 if (streq(u->active_state, "failed")) {
409 on_active = ansi_highlight_red(true);
410 off_active = ansi_highlight_red(false);
411 } else
412 on_active = off_active = "";
413
414 e = arg_full ? NULL : ellipsize(u->id, id_len, 33);
415
416 printf("%-*s %s%-6s%s %s%-*s %-*s%s %-*s ",
417 id_len, e ? e : u->id,
418 on_loaded, u->load_state, off_loaded,
419 on_active, active_len, u->active_state,
420 sub_len, u->sub_state, off_active,
421 job_len, u->job_id ? u->job_type : "");
422 if (!arg_full && arg_no_pager)
423 printf("%.*s\n", desc_len, u->description);
424 else
425 printf("%s\n", u->description);
426
427 free(e);
428 }
429
430 if (!arg_no_legend) {
431 printf("\nLOAD = Reflects whether the unit definition was properly loaded.\n"
432 "ACTIVE = The high-level unit activation state, i.e. generalization of SUB.\n"
433 "SUB = The low-level unit activation state, values depend on unit type.\n"
434 "JOB = Pending job for the unit.\n");
435
436 if (arg_all)
437 printf("\n%u units listed.\n", n_shown);
438 else
439 printf("\n%u units listed. Pass --all to see inactive units, too.\n", n_shown);
440 }
441 }
442
443 static int list_units(DBusConnection *bus, char **args) {
444 DBusMessage *m = NULL, *reply = NULL;
445 DBusError error;
446 int r;
447 DBusMessageIter iter, sub, sub2;
448 unsigned c = 0, n_units = 0;
449 struct unit_info *unit_infos = NULL;
450
451 dbus_error_init(&error);
452
453 assert(bus);
454
455 pager_open_if_enabled();
456
457 if (!(m = dbus_message_new_method_call(
458 "org.freedesktop.systemd1",
459 "/org/freedesktop/systemd1",
460 "org.freedesktop.systemd1.Manager",
461 "ListUnits"))) {
462 log_error("Could not allocate message.");
463 return -ENOMEM;
464 }
465
466 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
467 log_error("Failed to issue method call: %s", bus_error_message(&error));
468 r = -EIO;
469 goto finish;
470 }
471
472 if (!dbus_message_iter_init(reply, &iter) ||
473 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
474 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
475 log_error("Failed to parse reply.");
476 r = -EIO;
477 goto finish;
478 }
479
480 dbus_message_iter_recurse(&iter, &sub);
481
482 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
483 struct unit_info *u;
484
485 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
486 log_error("Failed to parse reply.");
487 r = -EIO;
488 goto finish;
489 }
490
491 if (c >= n_units) {
492 struct unit_info *w;
493
494 n_units = MAX(2*c, 16);
495 w = realloc(unit_infos, sizeof(struct unit_info) * n_units);
496
497 if (!w) {
498 log_error("Failed to allocate unit array.");
499 r = -ENOMEM;
500 goto finish;
501 }
502
503 unit_infos = w;
504 }
505
506 u = unit_infos+c;
507
508 dbus_message_iter_recurse(&sub, &sub2);
509
510 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->id, true) < 0 ||
511 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->description, true) < 0 ||
512 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->load_state, true) < 0 ||
513 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->active_state, true) < 0 ||
514 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->sub_state, true) < 0 ||
515 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->following, true) < 0 ||
516 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->unit_path, true) < 0 ||
517 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &u->job_id, true) < 0 ||
518 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->job_type, true) < 0 ||
519 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &u->job_path, false) < 0) {
520 log_error("Failed to parse reply.");
521 r = -EIO;
522 goto finish;
523 }
524
525 dbus_message_iter_next(&sub);
526 c++;
527 }
528
529 if (c > 0) {
530 qsort(unit_infos, c, sizeof(struct unit_info), compare_unit_info);
531 output_units_list(unit_infos, c);
532 }
533
534 r = 0;
535
536 finish:
537 if (m)
538 dbus_message_unref(m);
539
540 if (reply)
541 dbus_message_unref(reply);
542
543 free(unit_infos);
544
545 dbus_error_free(&error);
546
547 return r;
548 }
549
550 static int compare_unit_file_list(const void *a, const void *b) {
551 const char *d1, *d2;
552 const UnitFileList *u = a, *v = b;
553
554 d1 = strrchr(u->path, '.');
555 d2 = strrchr(v->path, '.');
556
557 if (d1 && d2) {
558 int r;
559
560 r = strcasecmp(d1, d2);
561 if (r != 0)
562 return r;
563 }
564
565 return strcasecmp(path_get_file_name(u->path), path_get_file_name(v->path));
566 }
567
568 static bool output_show_unit_file(const UnitFileList *u) {
569 const char *dot;
570
571 return !arg_type || ((dot = strrchr(u->path, '.')) && streq(dot+1, arg_type));
572 }
573
574 static void output_unit_file_list(const UnitFileList *units, unsigned c) {
575 unsigned max_id_len, id_cols, state_cols, n_shown = 0;
576 const UnitFileList *u;
577
578 max_id_len = sizeof("UNIT FILE")-1;
579 state_cols = sizeof("STATE")-1;
580 for (u = units; u < units + c; u++) {
581 if (!output_show_unit_file(u))
582 continue;
583
584 max_id_len = MAX(max_id_len, strlen(path_get_file_name(u->path)));
585 state_cols = MAX(state_cols, strlen(unit_file_state_to_string(u->state)));
586 }
587
588 if (!arg_full) {
589 unsigned basic_cols;
590 id_cols = MIN(max_id_len, 25);
591 basic_cols = 1 + id_cols + state_cols;
592 if (basic_cols < (unsigned) columns())
593 id_cols += MIN(columns() - basic_cols, max_id_len - id_cols);
594 } else
595 id_cols = max_id_len;
596
597 if (!arg_no_legend)
598 printf("%-*s %-*s\n", id_cols, "UNIT FILE", state_cols, "STATE");
599
600 for (u = units; u < units + c; u++) {
601 char *e;
602 const char *on, *off;
603 const char *id;
604
605 if (!output_show_unit_file(u))
606 continue;
607
608 n_shown++;
609
610 if (u->state == UNIT_FILE_MASKED ||
611 u->state == UNIT_FILE_MASKED_RUNTIME ||
612 u->state == UNIT_FILE_DISABLED) {
613 on = ansi_highlight_red(true);
614 off = ansi_highlight_red(false);
615 } else if (u->state == UNIT_FILE_ENABLED) {
616 on = ansi_highlight_green(true);
617 off = ansi_highlight_green(false);
618 } else
619 on = off = "";
620
621 id = path_get_file_name(u->path);
622
623 e = arg_full ? NULL : ellipsize(id, id_cols, 33);
624
625 printf("%-*s %s%-*s%s\n",
626 id_cols, e ? e : id,
627 on, state_cols, unit_file_state_to_string(u->state), off);
628
629 free(e);
630 }
631
632 if (!arg_no_legend)
633 printf("\n%u unit files listed.\n", n_shown);
634 }
635
636 static int list_unit_files(DBusConnection *bus, char **args) {
637 DBusMessage *m = NULL, *reply = NULL;
638 DBusError error;
639 int r;
640 DBusMessageIter iter, sub, sub2;
641 unsigned c = 0, n_units = 0;
642 UnitFileList *units = NULL;
643
644 dbus_error_init(&error);
645
646 pager_open_if_enabled();
647
648 if (avoid_bus()) {
649 Hashmap *h;
650 UnitFileList *u;
651 Iterator i;
652
653 h = hashmap_new(string_hash_func, string_compare_func);
654 if (!h) {
655 log_error("Out of memory");
656 return -ENOMEM;
657 }
658
659 r = unit_file_get_list(arg_scope, arg_root, h);
660 if (r < 0) {
661 unit_file_list_free(h);
662 log_error("Failed to get unit file list: %s", strerror(-r));
663 return r;
664 }
665
666 n_units = hashmap_size(h);
667 units = new(UnitFileList, n_units);
668 if (!units) {
669 unit_file_list_free(h);
670 log_error("Out of memory");
671 return -ENOMEM;
672 }
673
674 HASHMAP_FOREACH(u, h, i) {
675 memcpy(units + c++, u, sizeof(UnitFileList));
676 free(u);
677 }
678
679 hashmap_free(h);
680 } else {
681 assert(bus);
682
683 m = dbus_message_new_method_call(
684 "org.freedesktop.systemd1",
685 "/org/freedesktop/systemd1",
686 "org.freedesktop.systemd1.Manager",
687 "ListUnitFiles");
688 if (!m) {
689 log_error("Could not allocate message.");
690 return -ENOMEM;
691 }
692
693 reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
694 if (!reply) {
695 log_error("Failed to issue method call: %s", bus_error_message(&error));
696 r = -EIO;
697 goto finish;
698 }
699
700 if (!dbus_message_iter_init(reply, &iter) ||
701 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
702 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
703 log_error("Failed to parse reply.");
704 r = -EIO;
705 goto finish;
706 }
707
708 dbus_message_iter_recurse(&iter, &sub);
709
710 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
711 UnitFileList *u;
712 const char *state;
713
714 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
715 log_error("Failed to parse reply.");
716 r = -EIO;
717 goto finish;
718 }
719
720 if (c >= n_units) {
721 UnitFileList *w;
722
723 n_units = MAX(2*c, 16);
724 w = realloc(units, sizeof(struct UnitFileList) * n_units);
725
726 if (!w) {
727 log_error("Failed to allocate unit array.");
728 r = -ENOMEM;
729 goto finish;
730 }
731
732 units = w;
733 }
734
735 u = units+c;
736
737 dbus_message_iter_recurse(&sub, &sub2);
738
739 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &u->path, true) < 0 ||
740 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, false) < 0) {
741 log_error("Failed to parse reply.");
742 r = -EIO;
743 goto finish;
744 }
745
746 u->state = unit_file_state_from_string(state);
747
748 dbus_message_iter_next(&sub);
749 c++;
750 }
751 }
752
753 if (c > 0) {
754 qsort(units, c, sizeof(UnitFileList), compare_unit_file_list);
755 output_unit_file_list(units, c);
756 }
757
758 r = 0;
759
760 finish:
761 if (m)
762 dbus_message_unref(m);
763
764 if (reply)
765 dbus_message_unref(reply);
766
767 free(units);
768
769 dbus_error_free(&error);
770
771 return r;
772 }
773
774 static int dot_one_property(const char *name, const char *prop, DBusMessageIter *iter) {
775 static const char * const colors[] = {
776 "Requires", "[color=\"black\"]",
777 "RequiresOverridable", "[color=\"black\"]",
778 "Requisite", "[color=\"darkblue\"]",
779 "RequisiteOverridable", "[color=\"darkblue\"]",
780 "Wants", "[color=\"darkgrey\"]",
781 "Conflicts", "[color=\"red\"]",
782 "ConflictedBy", "[color=\"red\"]",
783 "After", "[color=\"green\"]"
784 };
785
786 const char *c = NULL;
787 unsigned i;
788
789 assert(name);
790 assert(prop);
791 assert(iter);
792
793 for (i = 0; i < ELEMENTSOF(colors); i += 2)
794 if (streq(colors[i], prop)) {
795 c = colors[i+1];
796 break;
797 }
798
799 if (!c)
800 return 0;
801
802 if (arg_dot != DOT_ALL)
803 if ((arg_dot == DOT_ORDER) != streq(prop, "After"))
804 return 0;
805
806 switch (dbus_message_iter_get_arg_type(iter)) {
807
808 case DBUS_TYPE_ARRAY:
809
810 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRING) {
811 DBusMessageIter sub;
812
813 dbus_message_iter_recurse(iter, &sub);
814
815 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
816 const char *s;
817
818 assert(dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING);
819 dbus_message_iter_get_basic(&sub, &s);
820 printf("\t\"%s\"->\"%s\" %s;\n", name, s, c);
821
822 dbus_message_iter_next(&sub);
823 }
824
825 return 0;
826 }
827 }
828
829 return 0;
830 }
831
832 static int dot_one(DBusConnection *bus, const char *name, const char *path) {
833 DBusMessage *m = NULL, *reply = NULL;
834 const char *interface = "org.freedesktop.systemd1.Unit";
835 int r;
836 DBusError error;
837 DBusMessageIter iter, sub, sub2, sub3;
838
839 assert(bus);
840 assert(path);
841
842 dbus_error_init(&error);
843
844 if (!(m = dbus_message_new_method_call(
845 "org.freedesktop.systemd1",
846 path,
847 "org.freedesktop.DBus.Properties",
848 "GetAll"))) {
849 log_error("Could not allocate message.");
850 r = -ENOMEM;
851 goto finish;
852 }
853
854 if (!dbus_message_append_args(m,
855 DBUS_TYPE_STRING, &interface,
856 DBUS_TYPE_INVALID)) {
857 log_error("Could not append arguments to message.");
858 r = -ENOMEM;
859 goto finish;
860 }
861
862 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
863 log_error("Failed to issue method call: %s", bus_error_message(&error));
864 r = -EIO;
865 goto finish;
866 }
867
868 if (!dbus_message_iter_init(reply, &iter) ||
869 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
870 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {
871 log_error("Failed to parse reply.");
872 r = -EIO;
873 goto finish;
874 }
875
876 dbus_message_iter_recurse(&iter, &sub);
877
878 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
879 const char *prop;
880
881 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
882 log_error("Failed to parse reply.");
883 r = -EIO;
884 goto finish;
885 }
886
887 dbus_message_iter_recurse(&sub, &sub2);
888
889 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &prop, true) < 0) {
890 log_error("Failed to parse reply.");
891 r = -EIO;
892 goto finish;
893 }
894
895 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
896 log_error("Failed to parse reply.");
897 r = -EIO;
898 goto finish;
899 }
900
901 dbus_message_iter_recurse(&sub2, &sub3);
902
903 if (dot_one_property(name, prop, &sub3)) {
904 log_error("Failed to parse reply.");
905 r = -EIO;
906 goto finish;
907 }
908
909 dbus_message_iter_next(&sub);
910 }
911
912 r = 0;
913
914 finish:
915 if (m)
916 dbus_message_unref(m);
917
918 if (reply)
919 dbus_message_unref(reply);
920
921 dbus_error_free(&error);
922
923 return r;
924 }
925
926 static int dot(DBusConnection *bus, char **args) {
927 DBusMessage *m = NULL, *reply = NULL;
928 DBusError error;
929 int r;
930 DBusMessageIter iter, sub, sub2;
931
932 dbus_error_init(&error);
933
934 assert(bus);
935
936 if (!(m = dbus_message_new_method_call(
937 "org.freedesktop.systemd1",
938 "/org/freedesktop/systemd1",
939 "org.freedesktop.systemd1.Manager",
940 "ListUnits"))) {
941 log_error("Could not allocate message.");
942 return -ENOMEM;
943 }
944
945 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
946 log_error("Failed to issue method call: %s", bus_error_message(&error));
947 r = -EIO;
948 goto finish;
949 }
950
951 if (!dbus_message_iter_init(reply, &iter) ||
952 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
953 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
954 log_error("Failed to parse reply.");
955 r = -EIO;
956 goto finish;
957 }
958
959 printf("digraph systemd {\n");
960
961 dbus_message_iter_recurse(&iter, &sub);
962 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
963 const char *id, *description, *load_state, *active_state, *sub_state, *following, *unit_path;
964
965 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
966 log_error("Failed to parse reply.");
967 r = -EIO;
968 goto finish;
969 }
970
971 dbus_message_iter_recurse(&sub, &sub2);
972
973 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
974 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 ||
975 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 ||
976 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 ||
977 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 ||
978 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &following, true) < 0 ||
979 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, true) < 0) {
980 log_error("Failed to parse reply.");
981 r = -EIO;
982 goto finish;
983 }
984
985 if ((r = dot_one(bus, id, unit_path)) < 0)
986 goto finish;
987
988 /* printf("\t\"%s\";\n", id); */
989 dbus_message_iter_next(&sub);
990 }
991
992 printf("}\n");
993
994 log_info(" Color legend: black = Requires\n"
995 " dark blue = Requisite\n"
996 " dark grey = Wants\n"
997 " red = Conflicts\n"
998 " green = After\n");
999
1000 if (on_tty())
1001 log_notice("-- You probably want to process this output with graphviz' dot tool.\n"
1002 "-- Try a shell pipeline like 'systemctl dot | dot -Tsvg > systemd.svg'!\n");
1003
1004 r = 0;
1005
1006 finish:
1007 if (m)
1008 dbus_message_unref(m);
1009
1010 if (reply)
1011 dbus_message_unref(reply);
1012
1013 dbus_error_free(&error);
1014
1015 return r;
1016 }
1017
1018 static int list_jobs(DBusConnection *bus, char **args) {
1019 DBusMessage *m = NULL, *reply = NULL;
1020 DBusError error;
1021 int r;
1022 DBusMessageIter iter, sub, sub2;
1023 unsigned k = 0;
1024
1025 dbus_error_init(&error);
1026
1027 assert(bus);
1028
1029 pager_open_if_enabled();
1030
1031 if (!(m = dbus_message_new_method_call(
1032 "org.freedesktop.systemd1",
1033 "/org/freedesktop/systemd1",
1034 "org.freedesktop.systemd1.Manager",
1035 "ListJobs"))) {
1036 log_error("Could not allocate message.");
1037 return -ENOMEM;
1038 }
1039
1040 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1041 log_error("Failed to issue method call: %s", bus_error_message(&error));
1042 r = -EIO;
1043 goto finish;
1044 }
1045
1046 if (!dbus_message_iter_init(reply, &iter) ||
1047 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
1048 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
1049 log_error("Failed to parse reply.");
1050 r = -EIO;
1051 goto finish;
1052 }
1053
1054 dbus_message_iter_recurse(&iter, &sub);
1055
1056 if (on_tty())
1057 printf("%4s %-25s %-15s %-7s\n", "JOB", "UNIT", "TYPE", "STATE");
1058
1059 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
1060 const char *name, *type, *state, *job_path, *unit_path;
1061 uint32_t id;
1062 char *e;
1063
1064 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
1065 log_error("Failed to parse reply.");
1066 r = -EIO;
1067 goto finish;
1068 }
1069
1070 dbus_message_iter_recurse(&sub, &sub2);
1071
1072 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 ||
1073 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
1074 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
1075 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 ||
1076 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 ||
1077 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) {
1078 log_error("Failed to parse reply.");
1079 r = -EIO;
1080 goto finish;
1081 }
1082
1083 e = arg_full ? NULL : ellipsize(name, 25, 33);
1084 printf("%4u %-25s %-15s %-7s\n", id, e ? e : name, type, state);
1085 free(e);
1086
1087 k++;
1088
1089 dbus_message_iter_next(&sub);
1090 }
1091
1092 if (on_tty())
1093 printf("\n%u jobs listed.\n", k);
1094
1095 r = 0;
1096
1097 finish:
1098 if (m)
1099 dbus_message_unref(m);
1100
1101 if (reply)
1102 dbus_message_unref(reply);
1103
1104 dbus_error_free(&error);
1105
1106 return r;
1107 }
1108
1109 static int load_unit(DBusConnection *bus, char **args) {
1110 DBusMessage *m = NULL;
1111 DBusError error;
1112 int r;
1113 char **name;
1114
1115 dbus_error_init(&error);
1116
1117 assert(bus);
1118 assert(args);
1119
1120 STRV_FOREACH(name, args+1) {
1121 DBusMessage *reply;
1122
1123 if (!(m = dbus_message_new_method_call(
1124 "org.freedesktop.systemd1",
1125 "/org/freedesktop/systemd1",
1126 "org.freedesktop.systemd1.Manager",
1127 "LoadUnit"))) {
1128 log_error("Could not allocate message.");
1129 r = -ENOMEM;
1130 goto finish;
1131 }
1132
1133 if (!dbus_message_append_args(m,
1134 DBUS_TYPE_STRING, name,
1135 DBUS_TYPE_INVALID)) {
1136 log_error("Could not append arguments to message.");
1137 r = -ENOMEM;
1138 goto finish;
1139 }
1140
1141 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1142 log_error("Failed to issue method call: %s", bus_error_message(&error));
1143 r = -EIO;
1144 goto finish;
1145 }
1146
1147 dbus_message_unref(m);
1148 dbus_message_unref(reply);
1149
1150 m = reply = NULL;
1151 }
1152
1153 r = 0;
1154
1155 finish:
1156 if (m)
1157 dbus_message_unref(m);
1158
1159 dbus_error_free(&error);
1160
1161 return r;
1162 }
1163
1164 static int cancel_job(DBusConnection *bus, char **args) {
1165 DBusMessage *m = NULL, *reply = NULL;
1166 DBusError error;
1167 int r;
1168 char **name;
1169
1170 dbus_error_init(&error);
1171
1172 assert(bus);
1173 assert(args);
1174
1175 if (strv_length(args) <= 1)
1176 return daemon_reload(bus, args);
1177
1178 STRV_FOREACH(name, args+1) {
1179 unsigned id;
1180 const char *path;
1181
1182 if (!(m = dbus_message_new_method_call(
1183 "org.freedesktop.systemd1",
1184 "/org/freedesktop/systemd1",
1185 "org.freedesktop.systemd1.Manager",
1186 "GetJob"))) {
1187 log_error("Could not allocate message.");
1188 r = -ENOMEM;
1189 goto finish;
1190 }
1191
1192 if ((r = safe_atou(*name, &id)) < 0) {
1193 log_error("Failed to parse job id: %s", strerror(-r));
1194 goto finish;
1195 }
1196
1197 assert_cc(sizeof(uint32_t) == sizeof(id));
1198 if (!dbus_message_append_args(m,
1199 DBUS_TYPE_UINT32, &id,
1200 DBUS_TYPE_INVALID)) {
1201 log_error("Could not append arguments to message.");
1202 r = -ENOMEM;
1203 goto finish;
1204 }
1205
1206 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1207 log_error("Failed to issue method call: %s", bus_error_message(&error));
1208 r = -EIO;
1209 goto finish;
1210 }
1211
1212 if (!dbus_message_get_args(reply, &error,
1213 DBUS_TYPE_OBJECT_PATH, &path,
1214 DBUS_TYPE_INVALID)) {
1215 log_error("Failed to parse reply: %s", bus_error_message(&error));
1216 r = -EIO;
1217 goto finish;
1218 }
1219
1220 dbus_message_unref(m);
1221 if (!(m = dbus_message_new_method_call(
1222 "org.freedesktop.systemd1",
1223 path,
1224 "org.freedesktop.systemd1.Job",
1225 "Cancel"))) {
1226 log_error("Could not allocate message.");
1227 r = -ENOMEM;
1228 goto finish;
1229 }
1230
1231 dbus_message_unref(reply);
1232 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1233 log_error("Failed to issue method call: %s", bus_error_message(&error));
1234 r = -EIO;
1235 goto finish;
1236 }
1237
1238 dbus_message_unref(m);
1239 dbus_message_unref(reply);
1240 m = reply = NULL;
1241 }
1242
1243 r = 0;
1244
1245 finish:
1246 if (m)
1247 dbus_message_unref(m);
1248
1249 if (reply)
1250 dbus_message_unref(reply);
1251
1252 dbus_error_free(&error);
1253
1254 return r;
1255 }
1256
1257 static bool need_daemon_reload(DBusConnection *bus, const char *unit) {
1258 DBusMessage *m = NULL, *reply = NULL;
1259 dbus_bool_t b = FALSE;
1260 DBusMessageIter iter, sub;
1261 const char
1262 *interface = "org.freedesktop.systemd1.Unit",
1263 *property = "NeedDaemonReload",
1264 *path;
1265
1266 /* We ignore all errors here, since this is used to show a warning only */
1267
1268 if (!(m = dbus_message_new_method_call(
1269 "org.freedesktop.systemd1",
1270 "/org/freedesktop/systemd1",
1271 "org.freedesktop.systemd1.Manager",
1272 "GetUnit")))
1273 goto finish;
1274
1275 if (!dbus_message_append_args(m,
1276 DBUS_TYPE_STRING, &unit,
1277 DBUS_TYPE_INVALID))
1278 goto finish;
1279
1280 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))
1281 goto finish;
1282
1283 if (!dbus_message_get_args(reply, NULL,
1284 DBUS_TYPE_OBJECT_PATH, &path,
1285 DBUS_TYPE_INVALID))
1286 goto finish;
1287
1288 dbus_message_unref(m);
1289 if (!(m = dbus_message_new_method_call(
1290 "org.freedesktop.systemd1",
1291 path,
1292 "org.freedesktop.DBus.Properties",
1293 "Get")))
1294 goto finish;
1295
1296 if (!dbus_message_append_args(m,
1297 DBUS_TYPE_STRING, &interface,
1298 DBUS_TYPE_STRING, &property,
1299 DBUS_TYPE_INVALID)) {
1300 goto finish;
1301 }
1302
1303 dbus_message_unref(reply);
1304 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, NULL)))
1305 goto finish;
1306
1307 if (!dbus_message_iter_init(reply, &iter) ||
1308 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
1309 goto finish;
1310
1311 dbus_message_iter_recurse(&iter, &sub);
1312
1313 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_BOOLEAN)
1314 goto finish;
1315
1316 dbus_message_iter_get_basic(&sub, &b);
1317
1318 finish:
1319 if (m)
1320 dbus_message_unref(m);
1321
1322 if (reply)
1323 dbus_message_unref(reply);
1324
1325 return b;
1326 }
1327
1328 typedef struct WaitData {
1329 Set *set;
1330 char *result;
1331 } WaitData;
1332
1333 static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) {
1334 DBusError error;
1335 WaitData *d = data;
1336
1337 assert(connection);
1338 assert(message);
1339 assert(d);
1340
1341 dbus_error_init(&error);
1342
1343 log_debug("Got D-Bus request: %s.%s() on %s",
1344 dbus_message_get_interface(message),
1345 dbus_message_get_member(message),
1346 dbus_message_get_path(message));
1347
1348 if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
1349 log_error("Warning! D-Bus connection terminated.");
1350 dbus_connection_close(connection);
1351
1352 } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
1353 uint32_t id;
1354 const char *path, *result, *unit;
1355 dbus_bool_t success = true;
1356
1357 if (dbus_message_get_args(message, &error,
1358 DBUS_TYPE_UINT32, &id,
1359 DBUS_TYPE_OBJECT_PATH, &path,
1360 DBUS_TYPE_STRING, &unit,
1361 DBUS_TYPE_STRING, &result,
1362 DBUS_TYPE_INVALID)) {
1363 char *p;
1364
1365 p = set_remove(d->set, (char*) path);
1366 free(p);
1367
1368 if (*result)
1369 d->result = strdup(result);
1370
1371 goto finish;
1372 }
1373 #ifndef LEGACY
1374 dbus_error_free(&error);
1375 if (dbus_message_get_args(message, &error,
1376 DBUS_TYPE_UINT32, &id,
1377 DBUS_TYPE_OBJECT_PATH, &path,
1378 DBUS_TYPE_STRING, &result,
1379 DBUS_TYPE_INVALID)) {
1380 char *p;
1381
1382 /* Compatibility with older systemd versions <
1383 * 183 during upgrades. This should be dropped
1384 * one day. */
1385 p = set_remove(d->set, (char*) path);
1386 free(p);
1387
1388 if (*result)
1389 d->result = strdup(result);
1390
1391 goto finish;
1392 }
1393
1394 dbus_error_free(&error);
1395 if (dbus_message_get_args(message, &error,
1396 DBUS_TYPE_UINT32, &id,
1397 DBUS_TYPE_OBJECT_PATH, &path,
1398 DBUS_TYPE_BOOLEAN, &success,
1399 DBUS_TYPE_INVALID)) {
1400 char *p;
1401
1402 /* Compatibility with older systemd versions <
1403 * 19 during upgrades. This should be dropped
1404 * one day */
1405
1406 p = set_remove(d->set, (char*) path);
1407 free(p);
1408
1409 if (!success)
1410 d->result = strdup("failed");
1411
1412 goto finish;
1413 }
1414 #endif
1415
1416 log_error("Failed to parse message: %s", bus_error_message(&error));
1417 }
1418
1419 finish:
1420 dbus_error_free(&error);
1421 return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
1422 }
1423
1424 static int enable_wait_for_jobs(DBusConnection *bus) {
1425 DBusError error;
1426
1427 assert(bus);
1428
1429 if (private_bus)
1430 return 0;
1431
1432 dbus_error_init(&error);
1433 dbus_bus_add_match(bus,
1434 "type='signal',"
1435 "sender='org.freedesktop.systemd1',"
1436 "interface='org.freedesktop.systemd1.Manager',"
1437 "member='JobRemoved',"
1438 "path='/org/freedesktop/systemd1'",
1439 &error);
1440
1441 if (dbus_error_is_set(&error)) {
1442 log_error("Failed to add match: %s", bus_error_message(&error));
1443 dbus_error_free(&error);
1444 return -EIO;
1445 }
1446
1447 /* This is slightly dirty, since we don't undo the match registrations. */
1448 return 0;
1449 }
1450
1451 static int wait_for_jobs(DBusConnection *bus, Set *s) {
1452 int r;
1453 WaitData d;
1454
1455 assert(bus);
1456 assert(s);
1457
1458 zero(d);
1459 d.set = s;
1460
1461 if (!dbus_connection_add_filter(bus, wait_filter, &d, NULL)) {
1462 log_error("Failed to add filter.");
1463 r = -ENOMEM;
1464 goto finish;
1465 }
1466
1467 while (!set_isempty(s) &&
1468 dbus_connection_read_write_dispatch(bus, -1))
1469 ;
1470
1471 if (!arg_quiet && d.result) {
1472 if (streq(d.result, "timeout"))
1473 log_error("Job timed out.");
1474 else if (streq(d.result, "canceled"))
1475 log_error("Job canceled.");
1476 else if (streq(d.result, "dependency"))
1477 log_error("A dependency job failed. See system journal for details.");
1478 else if (!streq(d.result, "done") && !streq(d.result, "skipped"))
1479 log_error("Job failed. See system journal and 'systemctl status' for details.");
1480 }
1481
1482 if (streq_ptr(d.result, "timeout"))
1483 r = -ETIME;
1484 else if (streq_ptr(d.result, "canceled"))
1485 r = -ECANCELED;
1486 else if (!streq_ptr(d.result, "done") && !streq_ptr(d.result, "skipped"))
1487 r = -EIO;
1488 else
1489 r = 0;
1490
1491 free(d.result);
1492
1493 finish:
1494 /* This is slightly dirty, since we don't undo the filter registration. */
1495
1496 return r;
1497 }
1498
1499 static int start_unit_one(
1500 DBusConnection *bus,
1501 const char *method,
1502 const char *name,
1503 const char *mode,
1504 DBusError *error,
1505 Set *s) {
1506
1507 DBusMessage *m = NULL, *reply = NULL;
1508 const char *path;
1509 int r;
1510
1511 assert(bus);
1512 assert(method);
1513 assert(name);
1514 assert(mode);
1515 assert(error);
1516 assert(arg_no_block || s);
1517
1518 if (!(m = dbus_message_new_method_call(
1519 "org.freedesktop.systemd1",
1520 "/org/freedesktop/systemd1",
1521 "org.freedesktop.systemd1.Manager",
1522 method))) {
1523 log_error("Could not allocate message.");
1524 r = -ENOMEM;
1525 goto finish;
1526 }
1527
1528 if (!dbus_message_append_args(m,
1529 DBUS_TYPE_STRING, &name,
1530 DBUS_TYPE_STRING, &mode,
1531 DBUS_TYPE_INVALID)) {
1532 log_error("Could not append arguments to message.");
1533 r = -ENOMEM;
1534 goto finish;
1535 }
1536
1537 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, error))) {
1538
1539 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(error)) {
1540 /* There's always a fallback possible for
1541 * legacy actions. */
1542 r = -EADDRNOTAVAIL;
1543 goto finish;
1544 }
1545
1546 log_error("Failed to issue method call: %s", bus_error_message(error));
1547 r = -EIO;
1548 goto finish;
1549 }
1550
1551 if (!dbus_message_get_args(reply, error,
1552 DBUS_TYPE_OBJECT_PATH, &path,
1553 DBUS_TYPE_INVALID)) {
1554 log_error("Failed to parse reply: %s", bus_error_message(error));
1555 r = -EIO;
1556 goto finish;
1557 }
1558
1559 if (need_daemon_reload(bus, name))
1560 log_warning("Warning: Unit file of created job changed on disk, 'systemctl %s daemon-reload' recommended.",
1561 arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");
1562
1563 if (!arg_no_block) {
1564 char *p;
1565
1566 if (!(p = strdup(path))) {
1567 log_error("Failed to duplicate path.");
1568 r = -ENOMEM;
1569 goto finish;
1570 }
1571
1572 if ((r = set_put(s, p)) < 0) {
1573 free(p);
1574 log_error("Failed to add path to set.");
1575 goto finish;
1576 }
1577 }
1578
1579 r = 0;
1580
1581 finish:
1582 if (m)
1583 dbus_message_unref(m);
1584
1585 if (reply)
1586 dbus_message_unref(reply);
1587
1588 return r;
1589 }
1590
1591 static enum action verb_to_action(const char *verb) {
1592 if (streq(verb, "halt"))
1593 return ACTION_HALT;
1594 else if (streq(verb, "poweroff"))
1595 return ACTION_POWEROFF;
1596 else if (streq(verb, "reboot"))
1597 return ACTION_REBOOT;
1598 else if (streq(verb, "kexec"))
1599 return ACTION_KEXEC;
1600 else if (streq(verb, "rescue"))
1601 return ACTION_RESCUE;
1602 else if (streq(verb, "emergency"))
1603 return ACTION_EMERGENCY;
1604 else if (streq(verb, "default"))
1605 return ACTION_DEFAULT;
1606 else if (streq(verb, "exit"))
1607 return ACTION_EXIT;
1608 else
1609 return ACTION_INVALID;
1610 }
1611
1612 static int start_unit(DBusConnection *bus, char **args) {
1613
1614 static const char * const table[_ACTION_MAX] = {
1615 [ACTION_HALT] = SPECIAL_HALT_TARGET,
1616 [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET,
1617 [ACTION_REBOOT] = SPECIAL_REBOOT_TARGET,
1618 [ACTION_KEXEC] = SPECIAL_KEXEC_TARGET,
1619 [ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET,
1620 [ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET,
1621 [ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET,
1622 [ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET,
1623 [ACTION_RESCUE] = SPECIAL_RESCUE_TARGET,
1624 [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_TARGET,
1625 [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET,
1626 [ACTION_EXIT] = SPECIAL_EXIT_TARGET
1627 };
1628
1629 int r, ret = 0;
1630 const char *method, *mode, *one_name;
1631 Set *s = NULL;
1632 DBusError error;
1633 char **name;
1634
1635 dbus_error_init(&error);
1636
1637 assert(bus);
1638
1639 ask_password_agent_open_if_enabled();
1640
1641 if (arg_action == ACTION_SYSTEMCTL) {
1642 method =
1643 streq(args[0], "stop") ||
1644 streq(args[0], "condstop") ? "StopUnit" :
1645 streq(args[0], "reload") ? "ReloadUnit" :
1646 streq(args[0], "restart") ? "RestartUnit" :
1647
1648 streq(args[0], "try-restart") ||
1649 streq(args[0], "condrestart") ? "TryRestartUnit" :
1650
1651 streq(args[0], "reload-or-restart") ? "ReloadOrRestartUnit" :
1652
1653 streq(args[0], "reload-or-try-restart") ||
1654 streq(args[0], "condreload") ||
1655
1656 streq(args[0], "force-reload") ? "ReloadOrTryRestartUnit" :
1657 "StartUnit";
1658
1659 mode =
1660 (streq(args[0], "isolate") ||
1661 streq(args[0], "rescue") ||
1662 streq(args[0], "emergency")) ? "isolate" : arg_job_mode;
1663
1664 one_name = table[verb_to_action(args[0])];
1665
1666 } else {
1667 assert(arg_action < ELEMENTSOF(table));
1668 assert(table[arg_action]);
1669
1670 method = "StartUnit";
1671
1672 mode = (arg_action == ACTION_EMERGENCY ||
1673 arg_action == ACTION_RESCUE ||
1674 arg_action == ACTION_RUNLEVEL2 ||
1675 arg_action == ACTION_RUNLEVEL3 ||
1676 arg_action == ACTION_RUNLEVEL4 ||
1677 arg_action == ACTION_RUNLEVEL5) ? "isolate" : "replace";
1678
1679 one_name = table[arg_action];
1680 }
1681
1682 if (!arg_no_block) {
1683 if ((ret = enable_wait_for_jobs(bus)) < 0) {
1684 log_error("Could not watch jobs: %s", strerror(-ret));
1685 goto finish;
1686 }
1687
1688 if (!(s = set_new(string_hash_func, string_compare_func))) {
1689 log_error("Failed to allocate set.");
1690 ret = -ENOMEM;
1691 goto finish;
1692 }
1693 }
1694
1695 if (one_name) {
1696 if ((ret = start_unit_one(bus, method, one_name, mode, &error, s)) <= 0)
1697 goto finish;
1698 } else {
1699 STRV_FOREACH(name, args+1)
1700 if ((r = start_unit_one(bus, method, *name, mode, &error, s)) != 0) {
1701 ret = translate_bus_error_to_exit_status(r, &error);
1702 dbus_error_free(&error);
1703 }
1704 }
1705
1706 if (!arg_no_block)
1707 if ((r = wait_for_jobs(bus, s)) < 0) {
1708 ret = r;
1709 goto finish;
1710 }
1711
1712 finish:
1713 if (s)
1714 set_free_free(s);
1715
1716 dbus_error_free(&error);
1717
1718 return ret;
1719 }
1720
1721 /* Ask systemd-logind, which might grant access to unprivileged users
1722 * through PolicyKit */
1723 static int reboot_with_logind(DBusConnection *bus, enum action a) {
1724 #ifdef HAVE_LOGIND
1725 const char *method;
1726 DBusMessage *m = NULL, *reply = NULL;
1727 DBusError error;
1728 dbus_bool_t interactive = true;
1729 int r;
1730
1731 dbus_error_init(&error);
1732
1733 polkit_agent_open_if_enabled();
1734
1735 switch (a) {
1736
1737 case ACTION_REBOOT:
1738 method = "Reboot";
1739 break;
1740
1741 case ACTION_POWEROFF:
1742 method = "PowerOff";
1743 break;
1744
1745 default:
1746 return -EINVAL;
1747 }
1748
1749 m = dbus_message_new_method_call(
1750 "org.freedesktop.login1",
1751 "/org/freedesktop/login1",
1752 "org.freedesktop.login1.Manager",
1753 method);
1754 if (!m) {
1755 log_error("Could not allocate message.");
1756 r = -ENOMEM;
1757 goto finish;
1758 }
1759
1760 if (!dbus_message_append_args(m,
1761 DBUS_TYPE_BOOLEAN, &interactive,
1762 DBUS_TYPE_INVALID)) {
1763 log_error("Could not append arguments to message.");
1764 r = -ENOMEM;
1765 goto finish;
1766 }
1767
1768 reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
1769 if (!reply) {
1770 if (error_is_no_service(&error)) {
1771 log_debug("Failed to issue method call: %s", bus_error_message(&error));
1772 r = -ENOENT;
1773 goto finish;
1774 }
1775
1776 if (dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) {
1777 log_debug("Failed to issue method call: %s", bus_error_message(&error));
1778 r = -EACCES;
1779 goto finish;
1780 }
1781
1782 log_info("Failed to issue method call: %s", bus_error_message(&error));
1783 r = -EIO;
1784 goto finish;
1785 }
1786
1787 r = 0;
1788
1789 finish:
1790 if (m)
1791 dbus_message_unref(m);
1792
1793 if (reply)
1794 dbus_message_unref(reply);
1795
1796 dbus_error_free(&error);
1797
1798 return r;
1799 #else
1800 return -ENOSYS;
1801 #endif
1802 }
1803
1804 static int start_special(DBusConnection *bus, char **args) {
1805 enum action a;
1806 int r;
1807
1808 assert(args);
1809
1810 a = verb_to_action(args[0]);
1811
1812 if (arg_force >= 2 && geteuid() != 0) {
1813 log_error("Must be root.");
1814 return -EPERM;
1815 }
1816
1817 if (arg_force >= 2 &&
1818 (a == ACTION_HALT ||
1819 a == ACTION_POWEROFF ||
1820 a == ACTION_REBOOT))
1821 halt_now(a);
1822
1823 if (arg_force >= 1 &&
1824 (a == ACTION_HALT ||
1825 a == ACTION_POWEROFF ||
1826 a == ACTION_REBOOT ||
1827 a == ACTION_KEXEC ||
1828 a == ACTION_EXIT))
1829 return daemon_reload(bus, args);
1830
1831 /* first try logind, to allow authentication with polkit */
1832 if (geteuid() != 0 &&
1833 (a == ACTION_POWEROFF ||
1834 a == ACTION_REBOOT)) {
1835 r = reboot_with_logind(bus, a);
1836 if (r >= 0)
1837 return r;
1838 }
1839
1840 r = start_unit(bus, args);
1841 if (r >= 0)
1842 warn_wall(a);
1843
1844 return r;
1845 }
1846
1847 static int check_unit(DBusConnection *bus, char **args) {
1848 DBusMessage *m = NULL, *reply = NULL;
1849 const char
1850 *interface = "org.freedesktop.systemd1.Unit",
1851 *property = "ActiveState";
1852 int r = 3; /* According to LSB: "program is not running" */
1853 DBusError error;
1854 char **name;
1855
1856 assert(bus);
1857 assert(args);
1858
1859 dbus_error_init(&error);
1860
1861 STRV_FOREACH(name, args+1) {
1862 const char *path = NULL;
1863 const char *state;
1864 DBusMessageIter iter, sub;
1865
1866 if (!(m = dbus_message_new_method_call(
1867 "org.freedesktop.systemd1",
1868 "/org/freedesktop/systemd1",
1869 "org.freedesktop.systemd1.Manager",
1870 "GetUnit"))) {
1871 log_error("Could not allocate message.");
1872 r = -ENOMEM;
1873 goto finish;
1874 }
1875
1876 if (!dbus_message_append_args(m,
1877 DBUS_TYPE_STRING, name,
1878 DBUS_TYPE_INVALID)) {
1879 log_error("Could not append arguments to message.");
1880 r = -ENOMEM;
1881 goto finish;
1882 }
1883
1884 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1885
1886 /* Hmm, cannot figure out anything about this unit... */
1887 if (!arg_quiet)
1888 puts("unknown");
1889
1890 dbus_error_free(&error);
1891 dbus_message_unref(m);
1892 m = NULL;
1893 continue;
1894 }
1895
1896 if (!dbus_message_get_args(reply, &error,
1897 DBUS_TYPE_OBJECT_PATH, &path,
1898 DBUS_TYPE_INVALID)) {
1899 log_error("Failed to parse reply: %s", bus_error_message(&error));
1900 r = -EIO;
1901 goto finish;
1902 }
1903
1904 dbus_message_unref(m);
1905 if (!(m = dbus_message_new_method_call(
1906 "org.freedesktop.systemd1",
1907 path,
1908 "org.freedesktop.DBus.Properties",
1909 "Get"))) {
1910 log_error("Could not allocate message.");
1911 r = -ENOMEM;
1912 goto finish;
1913 }
1914
1915 if (!dbus_message_append_args(m,
1916 DBUS_TYPE_STRING, &interface,
1917 DBUS_TYPE_STRING, &property,
1918 DBUS_TYPE_INVALID)) {
1919 log_error("Could not append arguments to message.");
1920 r = -ENOMEM;
1921 goto finish;
1922 }
1923
1924 dbus_message_unref(reply);
1925 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1926 log_error("Failed to issue method call: %s", bus_error_message(&error));
1927 r = -EIO;
1928 goto finish;
1929 }
1930
1931 if (!dbus_message_iter_init(reply, &iter) ||
1932 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
1933 log_error("Failed to parse reply.");
1934 r = -EIO;
1935 goto finish;
1936 }
1937
1938 dbus_message_iter_recurse(&iter, &sub);
1939
1940 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
1941 log_error("Failed to parse reply.");
1942 r = -EIO;
1943 goto finish;
1944 }
1945
1946 dbus_message_iter_get_basic(&sub, &state);
1947
1948 if (!arg_quiet)
1949 puts(state);
1950
1951 if (streq(state, "active") || streq(state, "reloading"))
1952 r = 0;
1953
1954 dbus_message_unref(m);
1955 dbus_message_unref(reply);
1956 m = reply = NULL;
1957 }
1958
1959 finish:
1960 if (m)
1961 dbus_message_unref(m);
1962
1963 if (reply)
1964 dbus_message_unref(reply);
1965
1966 dbus_error_free(&error);
1967
1968 return r;
1969 }
1970
1971 static int kill_unit(DBusConnection *bus, char **args) {
1972 DBusMessage *m = NULL;
1973 int r = 0;
1974 DBusError error;
1975 char **name;
1976
1977 assert(bus);
1978 assert(args);
1979
1980 dbus_error_init(&error);
1981
1982 if (!arg_kill_who)
1983 arg_kill_who = "all";
1984
1985 if (!arg_kill_mode)
1986 arg_kill_mode = streq(arg_kill_who, "all") ? "control-group" : "process";
1987
1988 STRV_FOREACH(name, args+1) {
1989 DBusMessage *reply;
1990
1991 if (!(m = dbus_message_new_method_call(
1992 "org.freedesktop.systemd1",
1993 "/org/freedesktop/systemd1",
1994 "org.freedesktop.systemd1.Manager",
1995 "KillUnit"))) {
1996 log_error("Could not allocate message.");
1997 r = -ENOMEM;
1998 goto finish;
1999 }
2000
2001 if (!dbus_message_append_args(m,
2002 DBUS_TYPE_STRING, name,
2003 DBUS_TYPE_STRING, &arg_kill_who,
2004 DBUS_TYPE_STRING, &arg_kill_mode,
2005 DBUS_TYPE_INT32, &arg_signal,
2006 DBUS_TYPE_INVALID)) {
2007 log_error("Could not append arguments to message.");
2008 r = -ENOMEM;
2009 goto finish;
2010 }
2011
2012 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2013 log_error("Failed to issue method call: %s", bus_error_message(&error));
2014 dbus_error_free(&error);
2015 r = -EIO;
2016 }
2017
2018 dbus_message_unref(m);
2019
2020 if (reply)
2021 dbus_message_unref(reply);
2022 m = reply = NULL;
2023 }
2024
2025 finish:
2026 if (m)
2027 dbus_message_unref(m);
2028
2029 dbus_error_free(&error);
2030
2031 return r;
2032 }
2033
2034 typedef struct ExecStatusInfo {
2035 char *name;
2036
2037 char *path;
2038 char **argv;
2039
2040 bool ignore;
2041
2042 usec_t start_timestamp;
2043 usec_t exit_timestamp;
2044 pid_t pid;
2045 int code;
2046 int status;
2047
2048 LIST_FIELDS(struct ExecStatusInfo, exec);
2049 } ExecStatusInfo;
2050
2051 static void exec_status_info_free(ExecStatusInfo *i) {
2052 assert(i);
2053
2054 free(i->name);
2055 free(i->path);
2056 strv_free(i->argv);
2057 free(i);
2058 }
2059
2060 static int exec_status_info_deserialize(DBusMessageIter *sub, ExecStatusInfo *i) {
2061 uint64_t start_timestamp, exit_timestamp, start_timestamp_monotonic, exit_timestamp_monotonic;
2062 DBusMessageIter sub2, sub3;
2063 const char*path;
2064 unsigned n;
2065 uint32_t pid;
2066 int32_t code, status;
2067 dbus_bool_t ignore;
2068
2069 assert(i);
2070 assert(i);
2071
2072 if (dbus_message_iter_get_arg_type(sub) != DBUS_TYPE_STRUCT)
2073 return -EIO;
2074
2075 dbus_message_iter_recurse(sub, &sub2);
2076
2077 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0)
2078 return -EIO;
2079
2080 if (!(i->path = strdup(path)))
2081 return -ENOMEM;
2082
2083 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_ARRAY ||
2084 dbus_message_iter_get_element_type(&sub2) != DBUS_TYPE_STRING)
2085 return -EIO;
2086
2087 n = 0;
2088 dbus_message_iter_recurse(&sub2, &sub3);
2089 while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {
2090 assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);
2091 dbus_message_iter_next(&sub3);
2092 n++;
2093 }
2094
2095
2096 if (!(i->argv = new0(char*, n+1)))
2097 return -ENOMEM;
2098
2099 n = 0;
2100 dbus_message_iter_recurse(&sub2, &sub3);
2101 while (dbus_message_iter_get_arg_type(&sub3) != DBUS_TYPE_INVALID) {
2102 const char *s;
2103
2104 assert(dbus_message_iter_get_arg_type(&sub3) == DBUS_TYPE_STRING);
2105 dbus_message_iter_get_basic(&sub3, &s);
2106 dbus_message_iter_next(&sub3);
2107
2108 if (!(i->argv[n++] = strdup(s)))
2109 return -ENOMEM;
2110 }
2111
2112 if (!dbus_message_iter_next(&sub2) ||
2113 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, true) < 0 ||
2114 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp, true) < 0 ||
2115 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &start_timestamp_monotonic, true) < 0 ||
2116 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp, true) < 0 ||
2117 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &exit_timestamp_monotonic, true) < 0 ||
2118 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &pid, true) < 0 ||
2119 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &code, true) < 0 ||
2120 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_INT32, &status, false) < 0)
2121 return -EIO;
2122
2123 i->ignore = ignore;
2124 i->start_timestamp = (usec_t) start_timestamp;
2125 i->exit_timestamp = (usec_t) exit_timestamp;
2126 i->pid = (pid_t) pid;
2127 i->code = code;
2128 i->status = status;
2129
2130 return 0;
2131 }
2132
2133 typedef struct UnitStatusInfo {
2134 const char *id;
2135 const char *load_state;
2136 const char *active_state;
2137 const char *sub_state;
2138 const char *unit_file_state;
2139
2140 const char *description;
2141 const char *following;
2142
2143 const char *path;
2144 const char *default_control_group;
2145
2146 const char *load_error;
2147 const char *result;
2148
2149 usec_t inactive_exit_timestamp;
2150 usec_t inactive_exit_timestamp_monotonic;
2151 usec_t active_enter_timestamp;
2152 usec_t active_exit_timestamp;
2153 usec_t inactive_enter_timestamp;
2154
2155 bool need_daemon_reload;
2156
2157 /* Service */
2158 pid_t main_pid;
2159 pid_t control_pid;
2160 const char *status_text;
2161 bool running:1;
2162 #ifdef HAVE_SYSV_COMPAT
2163 bool is_sysv:1;
2164 #endif
2165
2166 usec_t start_timestamp;
2167 usec_t exit_timestamp;
2168
2169 int exit_code, exit_status;
2170
2171 usec_t condition_timestamp;
2172 bool condition_result;
2173
2174 /* Socket */
2175 unsigned n_accepted;
2176 unsigned n_connections;
2177 bool accept;
2178
2179 /* Device */
2180 const char *sysfs_path;
2181
2182 /* Mount, Automount */
2183 const char *where;
2184
2185 /* Swap */
2186 const char *what;
2187
2188 LIST_HEAD(ExecStatusInfo, exec);
2189 } UnitStatusInfo;
2190
2191 static void print_status_info(UnitStatusInfo *i) {
2192 ExecStatusInfo *p;
2193 const char *on, *off, *ss;
2194 usec_t timestamp;
2195 char since1[FORMAT_TIMESTAMP_PRETTY_MAX], *s1;
2196 char since2[FORMAT_TIMESTAMP_MAX], *s2;
2197
2198 assert(i);
2199
2200 /* This shows pretty information about a unit. See
2201 * print_property() for a low-level property printer */
2202
2203 printf("%s", strna(i->id));
2204
2205 if (i->description && !streq_ptr(i->id, i->description))
2206 printf(" - %s", i->description);
2207
2208 printf("\n");
2209
2210 if (i->following)
2211 printf("\t Follow: unit currently follows state of %s\n", i->following);
2212
2213 if (streq_ptr(i->load_state, "error")) {
2214 on = ansi_highlight_red(true);
2215 off = ansi_highlight_red(false);
2216 } else
2217 on = off = "";
2218
2219 if (i->load_error)
2220 printf("\t Loaded: %s%s%s (Reason: %s)\n", on, strna(i->load_state), off, i->load_error);
2221 else if (i->path && i->unit_file_state)
2222 printf("\t Loaded: %s%s%s (%s; %s)\n", on, strna(i->load_state), off, i->path, i->unit_file_state);
2223 else if (i->path)
2224 printf("\t Loaded: %s%s%s (%s)\n", on, strna(i->load_state), off, i->path);
2225 else
2226 printf("\t Loaded: %s%s%s\n", on, strna(i->load_state), off);
2227
2228 ss = streq_ptr(i->active_state, i->sub_state) ? NULL : i->sub_state;
2229
2230 if (streq_ptr(i->active_state, "failed")) {
2231 on = ansi_highlight_red(true);
2232 off = ansi_highlight_red(false);
2233 } else if (streq_ptr(i->active_state, "active") || streq_ptr(i->active_state, "reloading")) {
2234 on = ansi_highlight_green(true);
2235 off = ansi_highlight_green(false);
2236 } else
2237 on = off = "";
2238
2239 if (ss)
2240 printf("\t Active: %s%s (%s)%s",
2241 on,
2242 strna(i->active_state),
2243 ss,
2244 off);
2245 else
2246 printf("\t Active: %s%s%s",
2247 on,
2248 strna(i->active_state),
2249 off);
2250
2251 if (!isempty(i->result) && !streq(i->result, "success"))
2252 printf(" (Result: %s)", i->result);
2253
2254 timestamp = (streq_ptr(i->active_state, "active") ||
2255 streq_ptr(i->active_state, "reloading")) ? i->active_enter_timestamp :
2256 (streq_ptr(i->active_state, "inactive") ||
2257 streq_ptr(i->active_state, "failed")) ? i->inactive_enter_timestamp :
2258 streq_ptr(i->active_state, "activating") ? i->inactive_exit_timestamp :
2259 i->active_exit_timestamp;
2260
2261 s1 = format_timestamp_pretty(since1, sizeof(since1), timestamp);
2262 s2 = format_timestamp(since2, sizeof(since2), timestamp);
2263
2264 if (s1)
2265 printf(" since %s; %s\n", s2, s1);
2266 else if (s2)
2267 printf(" since %s\n", s2);
2268 else
2269 printf("\n");
2270
2271 if (!i->condition_result && i->condition_timestamp > 0) {
2272 s1 = format_timestamp_pretty(since1, sizeof(since1), i->condition_timestamp);
2273 s2 = format_timestamp(since2, sizeof(since2), i->condition_timestamp);
2274
2275 if (s1)
2276 printf("\t start condition failed at %s; %s\n", s2, s1);
2277 else if (s2)
2278 printf("\t start condition failed at %s\n", s2);
2279 }
2280
2281 if (i->sysfs_path)
2282 printf("\t Device: %s\n", i->sysfs_path);
2283 if (i->where)
2284 printf("\t Where: %s\n", i->where);
2285 if (i->what)
2286 printf("\t What: %s\n", i->what);
2287
2288 if (i->accept)
2289 printf("\tAccepted: %u; Connected: %u\n", i->n_accepted, i->n_connections);
2290
2291 LIST_FOREACH(exec, p, i->exec) {
2292 char *t;
2293 bool good;
2294
2295 /* Only show exited processes here */
2296 if (p->code == 0)
2297 continue;
2298
2299 t = strv_join(p->argv, " ");
2300 printf("\t Process: %u %s=%s ", p->pid, p->name, strna(t));
2301 free(t);
2302
2303 #ifdef HAVE_SYSV_COMPAT
2304 if (i->is_sysv)
2305 good = is_clean_exit_lsb(p->code, p->status);
2306 else
2307 #endif
2308 good = is_clean_exit(p->code, p->status);
2309
2310 if (!good) {
2311 on = ansi_highlight_red(true);
2312 off = ansi_highlight_red(false);
2313 } else
2314 on = off = "";
2315
2316 printf("%s(code=%s, ", on, sigchld_code_to_string(p->code));
2317
2318 if (p->code == CLD_EXITED) {
2319 const char *c;
2320
2321 printf("status=%i", p->status);
2322
2323 #ifdef HAVE_SYSV_COMPAT
2324 if ((c = exit_status_to_string(p->status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD)))
2325 #else
2326 if ((c = exit_status_to_string(p->status, EXIT_STATUS_SYSTEMD)))
2327 #endif
2328 printf("/%s", c);
2329
2330 } else
2331 printf("signal=%s", signal_to_string(p->status));
2332
2333 printf(")%s\n", off);
2334
2335 if (i->main_pid == p->pid &&
2336 i->start_timestamp == p->start_timestamp &&
2337 i->exit_timestamp == p->start_timestamp)
2338 /* Let's not show this twice */
2339 i->main_pid = 0;
2340
2341 if (p->pid == i->control_pid)
2342 i->control_pid = 0;
2343 }
2344
2345 if (i->main_pid > 0 || i->control_pid > 0) {
2346 printf("\t");
2347
2348 if (i->main_pid > 0) {
2349 printf("Main PID: %u", (unsigned) i->main_pid);
2350
2351 if (i->running) {
2352 char *t = NULL;
2353 get_process_comm(i->main_pid, &t);
2354 if (t) {
2355 printf(" (%s)", t);
2356 free(t);
2357 }
2358 } else if (i->exit_code > 0) {
2359 printf(" (code=%s, ", sigchld_code_to_string(i->exit_code));
2360
2361 if (i->exit_code == CLD_EXITED) {
2362 const char *c;
2363
2364 printf("status=%i", i->exit_status);
2365
2366 #ifdef HAVE_SYSV_COMPAT
2367 if ((c = exit_status_to_string(i->exit_status, i->is_sysv ? EXIT_STATUS_LSB : EXIT_STATUS_SYSTEMD)))
2368 #else
2369 if ((c = exit_status_to_string(i->exit_status, EXIT_STATUS_SYSTEMD)))
2370 #endif
2371 printf("/%s", c);
2372
2373 } else
2374 printf("signal=%s", signal_to_string(i->exit_status));
2375 printf(")");
2376 }
2377 }
2378
2379 if (i->main_pid > 0 && i->control_pid > 0)
2380 printf(";");
2381
2382 if (i->control_pid > 0) {
2383 char *t = NULL;
2384
2385 printf(" Control: %u", (unsigned) i->control_pid);
2386
2387 get_process_comm(i->control_pid, &t);
2388 if (t) {
2389 printf(" (%s)", t);
2390 free(t);
2391 }
2392 }
2393
2394 printf("\n");
2395 }
2396
2397 if (i->status_text)
2398 printf("\t Status: \"%s\"\n", i->status_text);
2399
2400 if (i->default_control_group) {
2401 unsigned c;
2402
2403 printf("\t CGroup: %s\n", i->default_control_group);
2404
2405 if (arg_transport != TRANSPORT_SSH) {
2406 unsigned k = 0;
2407 pid_t extra[2];
2408
2409 c = columns();
2410 if (c > 18)
2411 c -= 18;
2412 else
2413 c = 0;
2414
2415 if (i->main_pid > 0)
2416 extra[k++] = i->main_pid;
2417
2418 if (i->control_pid > 0)
2419 extra[k++] = i->control_pid;
2420
2421 show_cgroup_and_extra_by_spec(i->default_control_group, "\t\t ", c, false, arg_all, extra, k);
2422 }
2423 }
2424
2425 if (i->id && arg_transport != TRANSPORT_SSH) {
2426 printf("\n");
2427 show_journal_by_unit(i->id, arg_output, 0, i->inactive_exit_timestamp_monotonic, arg_lines, arg_all, arg_follow);
2428 }
2429
2430 if (i->need_daemon_reload)
2431 printf("\n%sWarning:%s Unit file changed on disk, 'systemctl %s daemon-reload' recommended.\n",
2432 ansi_highlight_red(true),
2433 ansi_highlight_red(false),
2434 arg_scope == UNIT_FILE_SYSTEM ? "--system" : "--user");
2435 }
2436
2437 static int status_property(const char *name, DBusMessageIter *iter, UnitStatusInfo *i) {
2438
2439 assert(name);
2440 assert(iter);
2441 assert(i);
2442
2443 switch (dbus_message_iter_get_arg_type(iter)) {
2444
2445 case DBUS_TYPE_STRING: {
2446 const char *s;
2447
2448 dbus_message_iter_get_basic(iter, &s);
2449
2450 if (!isempty(s)) {
2451 if (streq(name, "Id"))
2452 i->id = s;
2453 else if (streq(name, "LoadState"))
2454 i->load_state = s;
2455 else if (streq(name, "ActiveState"))
2456 i->active_state = s;
2457 else if (streq(name, "SubState"))
2458 i->sub_state = s;
2459 else if (streq(name, "Description"))
2460 i->description = s;
2461 else if (streq(name, "FragmentPath"))
2462 i->path = s;
2463 #ifdef HAVE_SYSV_COMPAT
2464 else if (streq(name, "SysVPath")) {
2465 i->is_sysv = true;
2466 i->path = s;
2467 }
2468 #endif
2469 else if (streq(name, "DefaultControlGroup"))
2470 i->default_control_group = s;
2471 else if (streq(name, "StatusText"))
2472 i->status_text = s;
2473 else if (streq(name, "SysFSPath"))
2474 i->sysfs_path = s;
2475 else if (streq(name, "Where"))
2476 i->where = s;
2477 else if (streq(name, "What"))
2478 i->what = s;
2479 else if (streq(name, "Following"))
2480 i->following = s;
2481 else if (streq(name, "UnitFileState"))
2482 i->unit_file_state = s;
2483 else if (streq(name, "Result"))
2484 i->result = s;
2485 }
2486
2487 break;
2488 }
2489
2490 case DBUS_TYPE_BOOLEAN: {
2491 dbus_bool_t b;
2492
2493 dbus_message_iter_get_basic(iter, &b);
2494
2495 if (streq(name, "Accept"))
2496 i->accept = b;
2497 else if (streq(name, "NeedDaemonReload"))
2498 i->need_daemon_reload = b;
2499 else if (streq(name, "ConditionResult"))
2500 i->condition_result = b;
2501
2502 break;
2503 }
2504
2505 case DBUS_TYPE_UINT32: {
2506 uint32_t u;
2507
2508 dbus_message_iter_get_basic(iter, &u);
2509
2510 if (streq(name, "MainPID")) {
2511 if (u > 0) {
2512 i->main_pid = (pid_t) u;
2513 i->running = true;
2514 }
2515 } else if (streq(name, "ControlPID"))
2516 i->control_pid = (pid_t) u;
2517 else if (streq(name, "ExecMainPID")) {
2518 if (u > 0)
2519 i->main_pid = (pid_t) u;
2520 } else if (streq(name, "NAccepted"))
2521 i->n_accepted = u;
2522 else if (streq(name, "NConnections"))
2523 i->n_connections = u;
2524
2525 break;
2526 }
2527
2528 case DBUS_TYPE_INT32: {
2529 int32_t j;
2530
2531 dbus_message_iter_get_basic(iter, &j);
2532
2533 if (streq(name, "ExecMainCode"))
2534 i->exit_code = (int) j;
2535 else if (streq(name, "ExecMainStatus"))
2536 i->exit_status = (int) j;
2537
2538 break;
2539 }
2540
2541 case DBUS_TYPE_UINT64: {
2542 uint64_t u;
2543
2544 dbus_message_iter_get_basic(iter, &u);
2545
2546 if (streq(name, "ExecMainStartTimestamp"))
2547 i->start_timestamp = (usec_t) u;
2548 else if (streq(name, "ExecMainExitTimestamp"))
2549 i->exit_timestamp = (usec_t) u;
2550 else if (streq(name, "ActiveEnterTimestamp"))
2551 i->active_enter_timestamp = (usec_t) u;
2552 else if (streq(name, "InactiveEnterTimestamp"))
2553 i->inactive_enter_timestamp = (usec_t) u;
2554 else if (streq(name, "InactiveExitTimestamp"))
2555 i->inactive_exit_timestamp = (usec_t) u;
2556 else if (streq(name, "InactiveExitTimestampMonotonic"))
2557 i->inactive_exit_timestamp_monotonic = (usec_t) u;
2558 else if (streq(name, "ActiveExitTimestamp"))
2559 i->active_exit_timestamp = (usec_t) u;
2560 else if (streq(name, "ConditionTimestamp"))
2561 i->condition_timestamp = (usec_t) u;
2562
2563 break;
2564 }
2565
2566 case DBUS_TYPE_ARRAY: {
2567
2568 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT &&
2569 startswith(name, "Exec")) {
2570 DBusMessageIter sub;
2571
2572 dbus_message_iter_recurse(iter, &sub);
2573 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2574 ExecStatusInfo *info;
2575 int r;
2576
2577 if (!(info = new0(ExecStatusInfo, 1)))
2578 return -ENOMEM;
2579
2580 if (!(info->name = strdup(name))) {
2581 free(info);
2582 return -ENOMEM;
2583 }
2584
2585 if ((r = exec_status_info_deserialize(&sub, info)) < 0) {
2586 free(info);
2587 return r;
2588 }
2589
2590 LIST_PREPEND(ExecStatusInfo, exec, i->exec, info);
2591
2592 dbus_message_iter_next(&sub);
2593 }
2594 }
2595
2596 break;
2597 }
2598
2599 case DBUS_TYPE_STRUCT: {
2600
2601 if (streq(name, "LoadError")) {
2602 DBusMessageIter sub;
2603 const char *n, *message;
2604 int r;
2605
2606 dbus_message_iter_recurse(iter, &sub);
2607
2608 r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &n, true);
2609 if (r < 0)
2610 return r;
2611
2612 r = bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &message, false);
2613 if (r < 0)
2614 return r;
2615
2616 if (!isempty(message))
2617 i->load_error = message;
2618 }
2619
2620 break;
2621 }
2622 }
2623
2624 return 0;
2625 }
2626
2627 static int print_property(const char *name, DBusMessageIter *iter) {
2628 assert(name);
2629 assert(iter);
2630
2631 /* This is a low-level property printer, see
2632 * print_status_info() for the nicer output */
2633
2634 if (arg_property && !strv_find(arg_property, name))
2635 return 0;
2636
2637 switch (dbus_message_iter_get_arg_type(iter)) {
2638
2639 case DBUS_TYPE_STRUCT: {
2640 DBusMessageIter sub;
2641 dbus_message_iter_recurse(iter, &sub);
2642
2643 if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_UINT32 && streq(name, "Job")) {
2644 uint32_t u;
2645
2646 dbus_message_iter_get_basic(&sub, &u);
2647
2648 if (u)
2649 printf("%s=%u\n", name, (unsigned) u);
2650 else if (arg_all)
2651 printf("%s=\n", name);
2652
2653 return 0;
2654 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "Unit")) {
2655 const char *s;
2656
2657 dbus_message_iter_get_basic(&sub, &s);
2658
2659 if (arg_all || s[0])
2660 printf("%s=%s\n", name, s);
2661
2662 return 0;
2663 } else if (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRING && streq(name, "LoadError")) {
2664 const char *a = NULL, *b = NULL;
2665
2666 if (bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &a, true) >= 0)
2667 bus_iter_get_basic_and_next(&sub, DBUS_TYPE_STRING, &b, false);
2668
2669 if (arg_all || !isempty(a) || !isempty(b))
2670 printf("%s=%s \"%s\"\n", name, strempty(a), strempty(b));
2671
2672 return 0;
2673 }
2674
2675 break;
2676 }
2677
2678 case DBUS_TYPE_ARRAY:
2679
2680 if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "EnvironmentFiles")) {
2681 DBusMessageIter sub, sub2;
2682
2683 dbus_message_iter_recurse(iter, &sub);
2684 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2685 const char *path;
2686 dbus_bool_t ignore;
2687
2688 dbus_message_iter_recurse(&sub, &sub2);
2689
2690 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) >= 0 &&
2691 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_BOOLEAN, &ignore, false) >= 0)
2692 printf("EnvironmentFile=%s (ignore_errors=%s)\n", path, yes_no(ignore));
2693
2694 dbus_message_iter_next(&sub);
2695 }
2696
2697 return 0;
2698
2699 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Paths")) {
2700 DBusMessageIter sub, sub2;
2701
2702 dbus_message_iter_recurse(iter, &sub);
2703 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2704 const char *type, *path;
2705
2706 dbus_message_iter_recurse(&sub, &sub2);
2707
2708 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) >= 0 &&
2709 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, false) >= 0)
2710 printf("%s=%s\n", type, path);
2711
2712 dbus_message_iter_next(&sub);
2713 }
2714
2715 return 0;
2716
2717 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "Timers")) {
2718 DBusMessageIter sub, sub2;
2719
2720 dbus_message_iter_recurse(iter, &sub);
2721 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2722 const char *base;
2723 uint64_t value, next_elapse;
2724
2725 dbus_message_iter_recurse(&sub, &sub2);
2726
2727 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &base, true) >= 0 &&
2728 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &value, true) >= 0 &&
2729 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT64, &next_elapse, false) >= 0) {
2730 char timespan1[FORMAT_TIMESPAN_MAX], timespan2[FORMAT_TIMESPAN_MAX];
2731
2732 printf("%s={ value=%s ; next_elapse=%s }\n",
2733 base,
2734 format_timespan(timespan1, sizeof(timespan1), value),
2735 format_timespan(timespan2, sizeof(timespan2), next_elapse));
2736 }
2737
2738 dbus_message_iter_next(&sub);
2739 }
2740
2741 return 0;
2742
2743 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && streq(name, "ControlGroupAttributes")) {
2744 DBusMessageIter sub, sub2;
2745
2746 dbus_message_iter_recurse(iter, &sub);
2747 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2748 const char *controller, *attr, *value;
2749
2750 dbus_message_iter_recurse(&sub, &sub2);
2751
2752 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &controller, true) >= 0 &&
2753 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &attr, true) >= 0 &&
2754 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &value, false) >= 0) {
2755
2756 printf("ControlGroupAttribute={ controller=%s ; attribute=%s ; value=\"%s\" }\n",
2757 controller,
2758 attr,
2759 value);
2760 }
2761
2762 dbus_message_iter_next(&sub);
2763 }
2764
2765 return 0;
2766
2767 } else if (dbus_message_iter_get_element_type(iter) == DBUS_TYPE_STRUCT && startswith(name, "Exec")) {
2768 DBusMessageIter sub;
2769
2770 dbus_message_iter_recurse(iter, &sub);
2771 while (dbus_message_iter_get_arg_type(&sub) == DBUS_TYPE_STRUCT) {
2772 ExecStatusInfo info;
2773
2774 zero(info);
2775 if (exec_status_info_deserialize(&sub, &info) >= 0) {
2776 char timestamp1[FORMAT_TIMESTAMP_MAX], timestamp2[FORMAT_TIMESTAMP_MAX];
2777 char *t;
2778
2779 t = strv_join(info.argv, " ");
2780
2781 printf("%s={ path=%s ; argv[]=%s ; ignore_errors=%s ; start_time=[%s] ; stop_time=[%s] ; pid=%u ; code=%s ; status=%i%s%s }\n",
2782 name,
2783 strna(info.path),
2784 strna(t),
2785 yes_no(info.ignore),
2786 strna(format_timestamp(timestamp1, sizeof(timestamp1), info.start_timestamp)),
2787 strna(format_timestamp(timestamp2, sizeof(timestamp2), info.exit_timestamp)),
2788 (unsigned) info. pid,
2789 sigchld_code_to_string(info.code),
2790 info.status,
2791 info.code == CLD_EXITED ? "" : "/",
2792 strempty(info.code == CLD_EXITED ? NULL : signal_to_string(info.status)));
2793
2794 free(t);
2795 }
2796
2797 free(info.path);
2798 strv_free(info.argv);
2799
2800 dbus_message_iter_next(&sub);
2801 }
2802
2803 return 0;
2804 }
2805
2806 break;
2807 }
2808
2809 if (generic_print_property(name, iter, arg_all) > 0)
2810 return 0;
2811
2812 if (arg_all)
2813 printf("%s=[unprintable]\n", name);
2814
2815 return 0;
2816 }
2817
2818 static int show_one(const char *verb, DBusConnection *bus, const char *path, bool show_properties, bool *new_line) {
2819 DBusMessage *m = NULL, *reply = NULL;
2820 const char *interface = "";
2821 int r;
2822 DBusError error;
2823 DBusMessageIter iter, sub, sub2, sub3;
2824 UnitStatusInfo info;
2825 ExecStatusInfo *p;
2826
2827 assert(bus);
2828 assert(path);
2829 assert(new_line);
2830
2831 zero(info);
2832 dbus_error_init(&error);
2833
2834 if (!(m = dbus_message_new_method_call(
2835 "org.freedesktop.systemd1",
2836 path,
2837 "org.freedesktop.DBus.Properties",
2838 "GetAll"))) {
2839 log_error("Could not allocate message.");
2840 r = -ENOMEM;
2841 goto finish;
2842 }
2843
2844 if (!dbus_message_append_args(m,
2845 DBUS_TYPE_STRING, &interface,
2846 DBUS_TYPE_INVALID)) {
2847 log_error("Could not append arguments to message.");
2848 r = -ENOMEM;
2849 goto finish;
2850 }
2851
2852 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2853 log_error("Failed to issue method call: %s", bus_error_message(&error));
2854 r = -EIO;
2855 goto finish;
2856 }
2857
2858 if (!dbus_message_iter_init(reply, &iter) ||
2859 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
2860 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_DICT_ENTRY) {
2861 log_error("Failed to parse reply.");
2862 r = -EIO;
2863 goto finish;
2864 }
2865
2866 dbus_message_iter_recurse(&iter, &sub);
2867
2868 if (*new_line)
2869 printf("\n");
2870
2871 *new_line = true;
2872
2873 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
2874 const char *name;
2875
2876 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_DICT_ENTRY) {
2877 log_error("Failed to parse reply.");
2878 r = -EIO;
2879 goto finish;
2880 }
2881
2882 dbus_message_iter_recurse(&sub, &sub2);
2883
2884 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0) {
2885 log_error("Failed to parse reply.");
2886 r = -EIO;
2887 goto finish;
2888 }
2889
2890 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_VARIANT) {
2891 log_error("Failed to parse reply.");
2892 r = -EIO;
2893 goto finish;
2894 }
2895
2896 dbus_message_iter_recurse(&sub2, &sub3);
2897
2898 if (show_properties)
2899 r = print_property(name, &sub3);
2900 else
2901 r = status_property(name, &sub3, &info);
2902
2903 if (r < 0) {
2904 log_error("Failed to parse reply.");
2905 r = -EIO;
2906 goto finish;
2907 }
2908
2909 dbus_message_iter_next(&sub);
2910 }
2911
2912 r = 0;
2913
2914 if (!show_properties)
2915 print_status_info(&info);
2916
2917 if (!streq_ptr(info.active_state, "active") &&
2918 !streq_ptr(info.active_state, "reloading") &&
2919 streq(verb, "status"))
2920 /* According to LSB: "program not running" */
2921 r = 3;
2922
2923 while ((p = info.exec)) {
2924 LIST_REMOVE(ExecStatusInfo, exec, info.exec, p);
2925 exec_status_info_free(p);
2926 }
2927
2928 finish:
2929 if (m)
2930 dbus_message_unref(m);
2931
2932 if (reply)
2933 dbus_message_unref(reply);
2934
2935 dbus_error_free(&error);
2936
2937 return r;
2938 }
2939
2940 static int show(DBusConnection *bus, char **args) {
2941 DBusMessage *m = NULL, *reply = NULL;
2942 int r, ret = 0;
2943 DBusError error;
2944 bool show_properties, new_line = false;
2945 char **name;
2946
2947 assert(bus);
2948 assert(args);
2949
2950 dbus_error_init(&error);
2951
2952 show_properties = !streq(args[0], "status");
2953
2954 if (show_properties)
2955 pager_open_if_enabled();
2956
2957 if (show_properties && strv_length(args) <= 1) {
2958 /* If not argument is specified inspect the manager
2959 * itself */
2960
2961 ret = show_one(args[0], bus, "/org/freedesktop/systemd1", show_properties, &new_line);
2962 goto finish;
2963 }
2964
2965 STRV_FOREACH(name, args+1) {
2966 const char *path = NULL;
2967 uint32_t id;
2968
2969 if (safe_atou32(*name, &id) < 0) {
2970
2971 /* Interpret as unit name */
2972
2973 if (!(m = dbus_message_new_method_call(
2974 "org.freedesktop.systemd1",
2975 "/org/freedesktop/systemd1",
2976 "org.freedesktop.systemd1.Manager",
2977 "LoadUnit"))) {
2978 log_error("Could not allocate message.");
2979 ret = -ENOMEM;
2980 goto finish;
2981 }
2982
2983 if (!dbus_message_append_args(m,
2984 DBUS_TYPE_STRING, name,
2985 DBUS_TYPE_INVALID)) {
2986 log_error("Could not append arguments to message.");
2987 ret = -ENOMEM;
2988 goto finish;
2989 }
2990
2991 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
2992
2993 if (!dbus_error_has_name(&error, DBUS_ERROR_ACCESS_DENIED)) {
2994 log_error("Failed to issue method call: %s", bus_error_message(&error));
2995 ret = -EIO;
2996 goto finish;
2997 }
2998
2999 dbus_error_free(&error);
3000
3001 dbus_message_unref(m);
3002 if (!(m = dbus_message_new_method_call(
3003 "org.freedesktop.systemd1",
3004 "/org/freedesktop/systemd1",
3005 "org.freedesktop.systemd1.Manager",
3006 "GetUnit"))) {
3007 log_error("Could not allocate message.");
3008 ret = -ENOMEM;
3009 goto finish;
3010 }
3011
3012 if (!dbus_message_append_args(m,
3013 DBUS_TYPE_STRING, name,
3014 DBUS_TYPE_INVALID)) {
3015 log_error("Could not append arguments to message.");
3016 ret = -ENOMEM;
3017 goto finish;
3018 }
3019
3020 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3021 log_error("Failed to issue method call: %s", bus_error_message(&error));
3022
3023 if (dbus_error_has_name(&error, BUS_ERROR_NO_SUCH_UNIT))
3024 ret = 4; /* According to LSB: "program or service status is unknown" */
3025 else
3026 ret = -EIO;
3027 goto finish;
3028 }
3029 }
3030
3031 } else if (show_properties) {
3032
3033 /* Interpret as job id */
3034
3035 if (!(m = dbus_message_new_method_call(
3036 "org.freedesktop.systemd1",
3037 "/org/freedesktop/systemd1",
3038 "org.freedesktop.systemd1.Manager",
3039 "GetJob"))) {
3040 log_error("Could not allocate message.");
3041 ret = -ENOMEM;
3042 goto finish;
3043 }
3044
3045 if (!dbus_message_append_args(m,
3046 DBUS_TYPE_UINT32, &id,
3047 DBUS_TYPE_INVALID)) {
3048 log_error("Could not append arguments to message.");
3049 ret = -ENOMEM;
3050 goto finish;
3051 }
3052
3053 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3054 log_error("Failed to issue method call: %s", bus_error_message(&error));
3055 ret = -EIO;
3056 goto finish;
3057 }
3058 } else {
3059
3060 /* Interpret as PID */
3061
3062 if (!(m = dbus_message_new_method_call(
3063 "org.freedesktop.systemd1",
3064 "/org/freedesktop/systemd1",
3065 "org.freedesktop.systemd1.Manager",
3066 "GetUnitByPID"))) {
3067 log_error("Could not allocate message.");
3068 ret = -ENOMEM;
3069 goto finish;
3070 }
3071
3072 if (!dbus_message_append_args(m,
3073 DBUS_TYPE_UINT32, &id,
3074 DBUS_TYPE_INVALID)) {
3075 log_error("Could not append arguments to message.");
3076 ret = -ENOMEM;
3077 goto finish;
3078 }
3079
3080 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3081 log_error("Failed to issue method call: %s", bus_error_message(&error));
3082 ret = -EIO;
3083 goto finish;
3084 }
3085 }
3086
3087 if (!dbus_message_get_args(reply, &error,
3088 DBUS_TYPE_OBJECT_PATH, &path,
3089 DBUS_TYPE_INVALID)) {
3090 log_error("Failed to parse reply: %s", bus_error_message(&error));
3091 ret = -EIO;
3092 goto finish;
3093 }
3094
3095 if ((r = show_one(args[0], bus, path, show_properties, &new_line)) != 0)
3096 ret = r;
3097
3098 dbus_message_unref(m);
3099 dbus_message_unref(reply);
3100 m = reply = NULL;
3101 }
3102
3103 finish:
3104 if (m)
3105 dbus_message_unref(m);
3106
3107 if (reply)
3108 dbus_message_unref(reply);
3109
3110 dbus_error_free(&error);
3111
3112 return ret;
3113 }
3114
3115 static int dump(DBusConnection *bus, char **args) {
3116 DBusMessage *m = NULL, *reply = NULL;
3117 DBusError error;
3118 int r;
3119 const char *text;
3120
3121 dbus_error_init(&error);
3122
3123 pager_open_if_enabled();
3124
3125 if (!(m = dbus_message_new_method_call(
3126 "org.freedesktop.systemd1",
3127 "/org/freedesktop/systemd1",
3128 "org.freedesktop.systemd1.Manager",
3129 "Dump"))) {
3130 log_error("Could not allocate message.");
3131 return -ENOMEM;
3132 }
3133
3134 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3135 log_error("Failed to issue method call: %s", bus_error_message(&error));
3136 r = -EIO;
3137 goto finish;
3138 }
3139
3140 if (!dbus_message_get_args(reply, &error,
3141 DBUS_TYPE_STRING, &text,
3142 DBUS_TYPE_INVALID)) {
3143 log_error("Failed to parse reply: %s", bus_error_message(&error));
3144 r = -EIO;
3145 goto finish;
3146 }
3147
3148 fputs(text, stdout);
3149
3150 r = 0;
3151
3152 finish:
3153 if (m)
3154 dbus_message_unref(m);
3155
3156 if (reply)
3157 dbus_message_unref(reply);
3158
3159 dbus_error_free(&error);
3160
3161 return r;
3162 }
3163
3164 static int snapshot(DBusConnection *bus, char **args) {
3165 DBusMessage *m = NULL, *reply = NULL;
3166 DBusError error;
3167 int r;
3168 const char *name = "", *path, *id;
3169 dbus_bool_t cleanup = FALSE;
3170 DBusMessageIter iter, sub;
3171 const char
3172 *interface = "org.freedesktop.systemd1.Unit",
3173 *property = "Id";
3174
3175 dbus_error_init(&error);
3176
3177 if (!(m = dbus_message_new_method_call(
3178 "org.freedesktop.systemd1",
3179 "/org/freedesktop/systemd1",
3180 "org.freedesktop.systemd1.Manager",
3181 "CreateSnapshot"))) {
3182 log_error("Could not allocate message.");
3183 return -ENOMEM;
3184 }
3185
3186 if (strv_length(args) > 1)
3187 name = args[1];
3188
3189 if (!dbus_message_append_args(m,
3190 DBUS_TYPE_STRING, &name,
3191 DBUS_TYPE_BOOLEAN, &cleanup,
3192 DBUS_TYPE_INVALID)) {
3193 log_error("Could not append arguments to message.");
3194 r = -ENOMEM;
3195 goto finish;
3196 }
3197
3198 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3199 log_error("Failed to issue method call: %s", bus_error_message(&error));
3200 r = -EIO;
3201 goto finish;
3202 }
3203
3204 if (!dbus_message_get_args(reply, &error,
3205 DBUS_TYPE_OBJECT_PATH, &path,
3206 DBUS_TYPE_INVALID)) {
3207 log_error("Failed to parse reply: %s", bus_error_message(&error));
3208 r = -EIO;
3209 goto finish;
3210 }
3211
3212 dbus_message_unref(m);
3213 if (!(m = dbus_message_new_method_call(
3214 "org.freedesktop.systemd1",
3215 path,
3216 "org.freedesktop.DBus.Properties",
3217 "Get"))) {
3218 log_error("Could not allocate message.");
3219 return -ENOMEM;
3220 }
3221
3222 if (!dbus_message_append_args(m,
3223 DBUS_TYPE_STRING, &interface,
3224 DBUS_TYPE_STRING, &property,
3225 DBUS_TYPE_INVALID)) {
3226 log_error("Could not append arguments to message.");
3227 r = -ENOMEM;
3228 goto finish;
3229 }
3230
3231 dbus_message_unref(reply);
3232 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3233 log_error("Failed to issue method call: %s", bus_error_message(&error));
3234 r = -EIO;
3235 goto finish;
3236 }
3237
3238 if (!dbus_message_iter_init(reply, &iter) ||
3239 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
3240 log_error("Failed to parse reply.");
3241 r = -EIO;
3242 goto finish;
3243 }
3244
3245 dbus_message_iter_recurse(&iter, &sub);
3246
3247 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING) {
3248 log_error("Failed to parse reply.");
3249 r = -EIO;
3250 goto finish;
3251 }
3252
3253 dbus_message_iter_get_basic(&sub, &id);
3254
3255 if (!arg_quiet)
3256 puts(id);
3257 r = 0;
3258
3259 finish:
3260 if (m)
3261 dbus_message_unref(m);
3262
3263 if (reply)
3264 dbus_message_unref(reply);
3265
3266 dbus_error_free(&error);
3267
3268 return r;
3269 }
3270
3271 static int delete_snapshot(DBusConnection *bus, char **args) {
3272 DBusMessage *m = NULL, *reply = NULL;
3273 int r;
3274 DBusError error;
3275 char **name;
3276
3277 assert(bus);
3278 assert(args);
3279
3280 dbus_error_init(&error);
3281
3282 STRV_FOREACH(name, args+1) {
3283 const char *path = NULL;
3284
3285 if (!(m = dbus_message_new_method_call(
3286 "org.freedesktop.systemd1",
3287 "/org/freedesktop/systemd1",
3288 "org.freedesktop.systemd1.Manager",
3289 "GetUnit"))) {
3290 log_error("Could not allocate message.");
3291 r = -ENOMEM;
3292 goto finish;
3293 }
3294
3295 if (!dbus_message_append_args(m,
3296 DBUS_TYPE_STRING, name,
3297 DBUS_TYPE_INVALID)) {
3298 log_error("Could not append arguments to message.");
3299 r = -ENOMEM;
3300 goto finish;
3301 }
3302
3303 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3304 log_error("Failed to issue method call: %s", bus_error_message(&error));
3305 r = -EIO;
3306 goto finish;
3307 }
3308
3309 if (!dbus_message_get_args(reply, &error,
3310 DBUS_TYPE_OBJECT_PATH, &path,
3311 DBUS_TYPE_INVALID)) {
3312 log_error("Failed to parse reply: %s", bus_error_message(&error));
3313 r = -EIO;
3314 goto finish;
3315 }
3316
3317 dbus_message_unref(m);
3318 if (!(m = dbus_message_new_method_call(
3319 "org.freedesktop.systemd1",
3320 path,
3321 "org.freedesktop.systemd1.Snapshot",
3322 "Remove"))) {
3323 log_error("Could not allocate message.");
3324 r = -ENOMEM;
3325 goto finish;
3326 }
3327
3328 dbus_message_unref(reply);
3329 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3330 log_error("Failed to issue method call: %s", bus_error_message(&error));
3331 r = -EIO;
3332 goto finish;
3333 }
3334
3335 dbus_message_unref(m);
3336 dbus_message_unref(reply);
3337 m = reply = NULL;
3338 }
3339
3340 r = 0;
3341
3342 finish:
3343 if (m)
3344 dbus_message_unref(m);
3345
3346 if (reply)
3347 dbus_message_unref(reply);
3348
3349 dbus_error_free(&error);
3350
3351 return r;
3352 }
3353
3354 static int daemon_reload(DBusConnection *bus, char **args) {
3355 DBusMessage *m = NULL, *reply = NULL;
3356 DBusError error;
3357 int r;
3358 const char *method;
3359
3360 dbus_error_init(&error);
3361
3362 if (arg_action == ACTION_RELOAD)
3363 method = "Reload";
3364 else if (arg_action == ACTION_REEXEC)
3365 method = "Reexecute";
3366 else {
3367 assert(arg_action == ACTION_SYSTEMCTL);
3368
3369 method =
3370 streq(args[0], "clear-jobs") ||
3371 streq(args[0], "cancel") ? "ClearJobs" :
3372 streq(args[0], "daemon-reexec") ? "Reexecute" :
3373 streq(args[0], "reset-failed") ? "ResetFailed" :
3374 streq(args[0], "halt") ? "Halt" :
3375 streq(args[0], "poweroff") ? "PowerOff" :
3376 streq(args[0], "reboot") ? "Reboot" :
3377 streq(args[0], "kexec") ? "KExec" :
3378 streq(args[0], "exit") ? "Exit" :
3379 /* "daemon-reload" */ "Reload";
3380 }
3381
3382 if (!(m = dbus_message_new_method_call(
3383 "org.freedesktop.systemd1",
3384 "/org/freedesktop/systemd1",
3385 "org.freedesktop.systemd1.Manager",
3386 method))) {
3387 log_error("Could not allocate message.");
3388 return -ENOMEM;
3389 }
3390
3391 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3392
3393 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
3394 /* There's always a fallback possible for
3395 * legacy actions. */
3396 r = -EADDRNOTAVAIL;
3397 goto finish;
3398 }
3399
3400 if (streq(method, "Reexecute") && dbus_error_has_name(&error, DBUS_ERROR_NO_REPLY)) {
3401 /* On reexecution, we expect a disconnect, not
3402 * a reply */
3403 r = 0;
3404 goto finish;
3405 }
3406
3407 log_error("Failed to issue method call: %s", bus_error_message(&error));
3408 r = -EIO;
3409 goto finish;
3410 }
3411
3412 r = 0;
3413
3414 finish:
3415 if (m)
3416 dbus_message_unref(m);
3417
3418 if (reply)
3419 dbus_message_unref(reply);
3420
3421 dbus_error_free(&error);
3422
3423 return r;
3424 }
3425
3426 static int reset_failed(DBusConnection *bus, char **args) {
3427 DBusMessage *m = NULL;
3428 int r;
3429 DBusError error;
3430 char **name;
3431
3432 assert(bus);
3433 dbus_error_init(&error);
3434
3435 if (strv_length(args) <= 1)
3436 return daemon_reload(bus, args);
3437
3438 STRV_FOREACH(name, args+1) {
3439 DBusMessage *reply;
3440
3441 if (!(m = dbus_message_new_method_call(
3442 "org.freedesktop.systemd1",
3443 "/org/freedesktop/systemd1",
3444 "org.freedesktop.systemd1.Manager",
3445 "ResetFailedUnit"))) {
3446 log_error("Could not allocate message.");
3447 r = -ENOMEM;
3448 goto finish;
3449 }
3450
3451 if (!dbus_message_append_args(m,
3452 DBUS_TYPE_STRING, name,
3453 DBUS_TYPE_INVALID)) {
3454 log_error("Could not append arguments to message.");
3455 r = -ENOMEM;
3456 goto finish;
3457 }
3458
3459 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3460 log_error("Failed to issue method call: %s", bus_error_message(&error));
3461 r = -EIO;
3462 goto finish;
3463 }
3464
3465 dbus_message_unref(m);
3466 dbus_message_unref(reply);
3467 m = reply = NULL;
3468 }
3469
3470 r = 0;
3471
3472 finish:
3473 if (m)
3474 dbus_message_unref(m);
3475
3476 dbus_error_free(&error);
3477
3478 return r;
3479 }
3480
3481 static int show_enviroment(DBusConnection *bus, char **args) {
3482 DBusMessage *m = NULL, *reply = NULL;
3483 DBusError error;
3484 DBusMessageIter iter, sub, sub2;
3485 int r;
3486 const char
3487 *interface = "org.freedesktop.systemd1.Manager",
3488 *property = "Environment";
3489
3490 dbus_error_init(&error);
3491
3492 pager_open_if_enabled();
3493
3494 if (!(m = dbus_message_new_method_call(
3495 "org.freedesktop.systemd1",
3496 "/org/freedesktop/systemd1",
3497 "org.freedesktop.DBus.Properties",
3498 "Get"))) {
3499 log_error("Could not allocate message.");
3500 return -ENOMEM;
3501 }
3502
3503 if (!dbus_message_append_args(m,
3504 DBUS_TYPE_STRING, &interface,
3505 DBUS_TYPE_STRING, &property,
3506 DBUS_TYPE_INVALID)) {
3507 log_error("Could not append arguments to message.");
3508 r = -ENOMEM;
3509 goto finish;
3510 }
3511
3512 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3513 log_error("Failed to issue method call: %s", bus_error_message(&error));
3514 r = -EIO;
3515 goto finish;
3516 }
3517
3518 if (!dbus_message_iter_init(reply, &iter) ||
3519 dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT) {
3520 log_error("Failed to parse reply.");
3521 r = -EIO;
3522 goto finish;
3523 }
3524
3525 dbus_message_iter_recurse(&iter, &sub);
3526
3527 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY ||
3528 dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING) {
3529 log_error("Failed to parse reply.");
3530 r = -EIO;
3531 goto finish;
3532 }
3533
3534 dbus_message_iter_recurse(&sub, &sub2);
3535
3536 while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) {
3537 const char *text;
3538
3539 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
3540 log_error("Failed to parse reply.");
3541 r = -EIO;
3542 goto finish;
3543 }
3544
3545 dbus_message_iter_get_basic(&sub2, &text);
3546 printf("%s\n", text);
3547
3548 dbus_message_iter_next(&sub2);
3549 }
3550
3551 r = 0;
3552
3553 finish:
3554 if (m)
3555 dbus_message_unref(m);
3556
3557 if (reply)
3558 dbus_message_unref(reply);
3559
3560 dbus_error_free(&error);
3561
3562 return r;
3563 }
3564
3565 static int set_environment(DBusConnection *bus, char **args) {
3566 DBusMessage *m = NULL, *reply = NULL;
3567 DBusError error;
3568 int r;
3569 const char *method;
3570 DBusMessageIter iter, sub;
3571 char **name;
3572
3573 dbus_error_init(&error);
3574
3575 method = streq(args[0], "set-environment")
3576 ? "SetEnvironment"
3577 : "UnsetEnvironment";
3578
3579 if (!(m = dbus_message_new_method_call(
3580 "org.freedesktop.systemd1",
3581 "/org/freedesktop/systemd1",
3582 "org.freedesktop.systemd1.Manager",
3583 method))) {
3584
3585 log_error("Could not allocate message.");
3586 return -ENOMEM;
3587 }
3588
3589 dbus_message_iter_init_append(m, &iter);
3590
3591 if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
3592 log_error("Could not append arguments to message.");
3593 r = -ENOMEM;
3594 goto finish;
3595 }
3596
3597 STRV_FOREACH(name, args+1)
3598 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, name)) {
3599 log_error("Could not append arguments to message.");
3600 r = -ENOMEM;
3601 goto finish;
3602 }
3603
3604 if (!dbus_message_iter_close_container(&iter, &sub)) {
3605 log_error("Could not append arguments to message.");
3606 r = -ENOMEM;
3607 goto finish;
3608 }
3609
3610 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
3611 log_error("Failed to issue method call: %s", bus_error_message(&error));
3612 r = -EIO;
3613 goto finish;
3614 }
3615
3616 r = 0;
3617
3618 finish:
3619 if (m)
3620 dbus_message_unref(m);
3621
3622 if (reply)
3623 dbus_message_unref(reply);
3624
3625 dbus_error_free(&error);
3626
3627 return r;
3628 }
3629
3630 static int enable_sysv_units(char **args) {
3631 int r = 0;
3632
3633 #if defined (HAVE_SYSV_COMPAT) && (defined(TARGET_FEDORA) || defined(TARGET_MANDRIVA) || defined(TARGET_SUSE) || defined(TARGET_MEEGO) || defined(TARGET_ALTLINUX) || defined(TARGET_MAGEIA))
3634 const char *verb = args[0];
3635 unsigned f = 1, t = 1;
3636 LookupPaths paths;
3637
3638 if (arg_scope != UNIT_FILE_SYSTEM)
3639 return 0;
3640
3641 if (!streq(verb, "enable") &&
3642 !streq(verb, "disable") &&
3643 !streq(verb, "is-enabled"))
3644 return 0;
3645
3646 /* Processes all SysV units, and reshuffles the array so that
3647 * afterwards only the native units remain */
3648
3649 zero(paths);
3650 r = lookup_paths_init(&paths, MANAGER_SYSTEM, false);
3651 if (r < 0)
3652 return r;
3653
3654 r = 0;
3655
3656 for (f = 1; args[f]; f++) {
3657 const char *name;
3658 char *p;
3659 bool found_native = false, found_sysv;
3660 unsigned c = 1;
3661 const char *argv[6] = { "/sbin/chkconfig", NULL, NULL, NULL, NULL };
3662 char **k, *l, *q = NULL;
3663 int j;
3664 pid_t pid;
3665 siginfo_t status;
3666
3667 name = args[f];
3668
3669 if (!endswith(name, ".service"))
3670 continue;
3671
3672 if (path_is_absolute(name))
3673 continue;
3674
3675 STRV_FOREACH(k, paths.unit_path) {
3676 p = NULL;
3677
3678 if (!isempty(arg_root))
3679 asprintf(&p, "%s/%s/%s", arg_root, *k, name);
3680 else
3681 asprintf(&p, "%s/%s", *k, name);
3682
3683 if (!p) {
3684 log_error("No memory");
3685 r = -ENOMEM;
3686 goto finish;
3687 }
3688
3689 found_native = access(p, F_OK) >= 0;
3690 free(p);
3691
3692 if (found_native)
3693 break;
3694 }
3695
3696 if (found_native)
3697 continue;
3698
3699 p = NULL;
3700 if (!isempty(arg_root))
3701 asprintf(&p, "%s/" SYSTEM_SYSVINIT_PATH "/%s", arg_root, name);
3702 else
3703 asprintf(&p, SYSTEM_SYSVINIT_PATH "/%s", name);
3704 if (!p) {
3705 log_error("No memory");
3706 r = -ENOMEM;
3707 goto finish;
3708 }
3709
3710 p[strlen(p) - sizeof(".service") + 1] = 0;
3711 found_sysv = access(p, F_OK) >= 0;
3712
3713 if (!found_sysv) {
3714 free(p);
3715 continue;
3716 }
3717
3718 /* Mark this entry, so that we don't try enabling it as native unit */
3719 args[f] = (char*) "";
3720
3721 log_info("%s is not a native service, redirecting to /sbin/chkconfig.", name);
3722
3723 if (!isempty(arg_root))
3724 argv[c++] = q = strappend("--root=", arg_root);
3725
3726 argv[c++] = path_get_file_name(p);
3727 argv[c++] =
3728 streq(verb, "enable") ? "on" :
3729 streq(verb, "disable") ? "off" : "--level=5";
3730 argv[c] = NULL;
3731
3732 l = strv_join((char**)argv, " ");
3733 if (!l) {
3734 log_error("No memory.");
3735 free(q);
3736 free(p);
3737 r = -ENOMEM;
3738 goto finish;
3739 }
3740
3741 log_info("Executing %s", l);
3742 free(l);
3743
3744 pid = fork();
3745 if (pid < 0) {
3746 log_error("Failed to fork: %m");
3747 free(p);
3748 free(q);
3749 r = -errno;
3750 goto finish;
3751 } else if (pid == 0) {
3752 /* Child */
3753
3754 execv(argv[0], (char**) argv);
3755 _exit(EXIT_FAILURE);
3756 }
3757
3758 free(p);
3759 free(q);
3760
3761 j = wait_for_terminate(pid, &status);
3762 if (j < 0) {
3763 log_error("Failed to wait for child: %s", strerror(-r));
3764 r = j;
3765 goto finish;
3766 }
3767
3768 if (status.si_code == CLD_EXITED) {
3769 if (streq(verb, "is-enabled")) {
3770 if (status.si_status == 0) {
3771 if (!arg_quiet)
3772 puts("enabled");
3773 r = 1;
3774 } else {
3775 if (!arg_quiet)
3776 puts("disabled");
3777 }
3778
3779 } else if (status.si_status != 0) {
3780 r = -EINVAL;
3781 goto finish;
3782 }
3783 } else {
3784 r = -EPROTO;
3785 goto finish;
3786 }
3787 }
3788
3789 finish:
3790 lookup_paths_free(&paths);
3791
3792 /* Drop all SysV units */
3793 for (f = 1, t = 1; args[f]; f++) {
3794
3795 if (isempty(args[f]))
3796 continue;
3797
3798 args[t++] = args[f];
3799 }
3800
3801 args[t] = NULL;
3802
3803 #endif
3804 return r;
3805 }
3806
3807 static int enable_unit(DBusConnection *bus, char **args) {
3808 const char *verb = args[0];
3809 UnitFileChange *changes = NULL;
3810 unsigned n_changes = 0, i;
3811 int carries_install_info = -1;
3812 DBusMessage *m = NULL, *reply = NULL;
3813 int r;
3814 DBusError error;
3815
3816 r = enable_sysv_units(args);
3817 if (r < 0)
3818 return r;
3819
3820 if (!args[1])
3821 return 0;
3822
3823 dbus_error_init(&error);
3824
3825 if (!bus || avoid_bus()) {
3826 if (streq(verb, "enable")) {
3827 r = unit_file_enable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3828 carries_install_info = r;
3829 } else if (streq(verb, "disable"))
3830 r = unit_file_disable(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes);
3831 else if (streq(verb, "reenable")) {
3832 r = unit_file_reenable(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3833 carries_install_info = r;
3834 } else if (streq(verb, "link"))
3835 r = unit_file_link(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3836 else if (streq(verb, "preset")) {
3837 r = unit_file_preset(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3838 carries_install_info = r;
3839 } else if (streq(verb, "mask"))
3840 r = unit_file_mask(arg_scope, arg_runtime, arg_root, args+1, arg_force, &changes, &n_changes);
3841 else if (streq(verb, "unmask"))
3842 r = unit_file_unmask(arg_scope, arg_runtime, arg_root, args+1, &changes, &n_changes);
3843 else
3844 assert_not_reached("Unknown verb");
3845
3846 if (r < 0) {
3847 log_error("Operation failed: %s", strerror(-r));
3848 goto finish;
3849 }
3850
3851 if (!arg_quiet) {
3852 for (i = 0; i < n_changes; i++) {
3853 if (changes[i].type == UNIT_FILE_SYMLINK)
3854 log_info("ln -s '%s' '%s'", changes[i].source, changes[i].path);
3855 else
3856 log_info("rm '%s'", changes[i].path);
3857 }
3858 }
3859
3860 } else {
3861 const char *method;
3862 bool send_force = true, expect_carries_install_info = false;
3863 dbus_bool_t a, b;
3864 DBusMessageIter iter, sub, sub2;
3865
3866 if (streq(verb, "enable")) {
3867 method = "EnableUnitFiles";
3868 expect_carries_install_info = true;
3869 } else if (streq(verb, "disable")) {
3870 method = "DisableUnitFiles";
3871 send_force = false;
3872 } else if (streq(verb, "reenable")) {
3873 method = "ReenableUnitFiles";
3874 expect_carries_install_info = true;
3875 } else if (streq(verb, "link"))
3876 method = "LinkUnitFiles";
3877 else if (streq(verb, "preset")) {
3878 method = "PresetUnitFiles";
3879 expect_carries_install_info = true;
3880 } else if (streq(verb, "mask"))
3881 method = "MaskUnitFiles";
3882 else if (streq(verb, "unmask")) {
3883 method = "UnmaskUnitFiles";
3884 send_force = false;
3885 } else
3886 assert_not_reached("Unknown verb");
3887
3888 m = dbus_message_new_method_call(
3889 "org.freedesktop.systemd1",
3890 "/org/freedesktop/systemd1",
3891 "org.freedesktop.systemd1.Manager",
3892 method);
3893 if (!m) {
3894 log_error("Out of memory");
3895 r = -ENOMEM;
3896 goto finish;
3897 }
3898
3899 dbus_message_iter_init_append(m, &iter);
3900
3901 r = bus_append_strv_iter(&iter, args+1);
3902 if (r < 0) {
3903 log_error("Failed to append unit files.");
3904 goto finish;
3905 }
3906
3907 a = arg_runtime;
3908 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &a)) {
3909 log_error("Failed to append runtime boolean.");
3910 r = -ENOMEM;
3911 goto finish;
3912 }
3913
3914 if (send_force) {
3915 b = arg_force;
3916
3917 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b)) {
3918 log_error("Failed to append force boolean.");
3919 r = -ENOMEM;
3920 goto finish;
3921 }
3922 }
3923
3924 reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
3925 if (!reply) {
3926 log_error("Failed to issue method call: %s", bus_error_message(&error));
3927 r = -EIO;
3928 goto finish;
3929 }
3930
3931 if (!dbus_message_iter_init(reply, &iter)) {
3932 log_error("Failed to initialize iterator.");
3933 goto finish;
3934 }
3935
3936 if (expect_carries_install_info) {
3937 r = bus_iter_get_basic_and_next(&iter, DBUS_TYPE_BOOLEAN, &b, true);
3938 if (r < 0) {
3939 log_error("Failed to parse reply.");
3940 goto finish;
3941 }
3942
3943 carries_install_info = b;
3944 }
3945
3946 if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
3947 dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT) {
3948 log_error("Failed to parse reply.");
3949 r = -EIO;
3950 goto finish;
3951 }
3952
3953 dbus_message_iter_recurse(&iter, &sub);
3954 while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
3955 const char *type, *path, *source;
3956
3957 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
3958 log_error("Failed to parse reply.");
3959 r = -EIO;
3960 goto finish;
3961 }
3962
3963 dbus_message_iter_recurse(&sub, &sub2);
3964
3965 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
3966 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &path, true) < 0 ||
3967 bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &source, false) < 0) {
3968 log_error("Failed to parse reply.");
3969 r = -EIO;
3970 goto finish;
3971 }
3972
3973 if (!arg_quiet) {
3974 if (streq(type, "symlink"))
3975 log_info("ln -s '%s' '%s'", source, path);
3976 else
3977 log_info("rm '%s'", path);
3978 }
3979
3980 dbus_message_iter_next(&sub);
3981 }
3982
3983 /* Try to reload if enabeld */
3984 if (!arg_no_reload)
3985 r = daemon_reload(bus, args);
3986 }
3987
3988 if (carries_install_info == 0)
3989 log_warning("Warning: unit files do not carry install information. No operation executed.");
3990
3991 finish:
3992 if (m)
3993 dbus_message_unref(m);
3994
3995 if (reply)
3996 dbus_message_unref(reply);
3997
3998 unit_file_changes_free(changes, n_changes);
3999
4000 dbus_error_free(&error);
4001 return r;
4002 }
4003
4004 static int unit_is_enabled(DBusConnection *bus, char **args) {
4005 DBusError error;
4006 int r;
4007 DBusMessage *m = NULL, *reply = NULL;
4008 bool enabled;
4009 char **name;
4010
4011 dbus_error_init(&error);
4012
4013 r = enable_sysv_units(args);
4014 if (r < 0)
4015 return r;
4016
4017 enabled = r > 0;
4018
4019 if (!bus || avoid_bus()) {
4020
4021 STRV_FOREACH(name, args+1) {
4022 UnitFileState state;
4023
4024 state = unit_file_get_state(arg_scope, arg_root, *name);
4025 if (state < 0) {
4026 r = state;
4027 goto finish;
4028 }
4029
4030 if (state == UNIT_FILE_ENABLED ||
4031 state == UNIT_FILE_ENABLED_RUNTIME ||
4032 state == UNIT_FILE_STATIC)
4033 enabled = true;
4034
4035 if (!arg_quiet)
4036 puts(unit_file_state_to_string(state));
4037 }
4038
4039 } else {
4040 STRV_FOREACH(name, args+1) {
4041 const char *s;
4042
4043 m = dbus_message_new_method_call(
4044 "org.freedesktop.systemd1",
4045 "/org/freedesktop/systemd1",
4046 "org.freedesktop.systemd1.Manager",
4047 "GetUnitFileState");
4048 if (!m) {
4049 log_error("Out of memory");
4050 r = -ENOMEM;
4051 goto finish;
4052 }
4053
4054 if (!dbus_message_append_args(m,
4055 DBUS_TYPE_STRING, name,
4056 DBUS_TYPE_INVALID)) {
4057 log_error("Could not append arguments to message.");
4058 r = -ENOMEM;
4059 goto finish;
4060 }
4061
4062 reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error);
4063 if (!reply) {
4064 log_error("Failed to issue method call: %s", bus_error_message(&error));
4065 r = -EIO;
4066 goto finish;
4067 }
4068
4069 if (!dbus_message_get_args(reply, &error,
4070 DBUS_TYPE_STRING, &s,
4071 DBUS_TYPE_INVALID)) {
4072 log_error("Failed to parse reply: %s", bus_error_message(&error));
4073 r = -EIO;
4074 goto finish;
4075 }
4076
4077 dbus_message_unref(m);
4078 dbus_message_unref(reply);
4079 m = reply = NULL;
4080
4081 if (streq(s, "enabled") ||
4082 streq(s, "enabled-runtime") ||
4083 streq(s, "static"))
4084 enabled = true;
4085
4086 if (!arg_quiet)
4087 puts(s);
4088 }
4089 }
4090
4091 r = enabled ? 0 : 1;
4092
4093 finish:
4094 if (m)
4095 dbus_message_unref(m);
4096
4097 if (reply)
4098 dbus_message_unref(reply);
4099
4100 dbus_error_free(&error);
4101 return r;
4102 }
4103
4104 static int systemctl_help(void) {
4105
4106 pager_open_if_enabled();
4107
4108 printf("%s [OPTIONS...] {COMMAND} ...\n\n"
4109 "Query or send control commands to the systemd manager.\n\n"
4110 " -h --help Show this help\n"
4111 " --version Show package version\n"
4112 " -t --type=TYPE List only units of a particular type\n"
4113 " -p --property=NAME Show only properties by this name\n"
4114 " -a --all Show all units/properties, including dead/empty ones\n"
4115 " --failed Show only failed units\n"
4116 " --full Don't ellipsize unit names on output\n"
4117 " --fail When queueing a new job, fail if conflicting jobs are\n"
4118 " pending\n"
4119 " --ignore-dependencies\n"
4120 " When queueing a new job, ignore all its dependencies\n"
4121 " --kill-who=WHO Who to send signal to\n"
4122 " -s --signal=SIGNAL Which signal to send\n"
4123 " -H --host=[USER@]HOST\n"
4124 " Show information for remote host\n"
4125 " -P --privileged Acquire privileges before execution\n"
4126 " -q --quiet Suppress output\n"
4127 " --no-block Do not wait until operation finished\n"
4128 " --no-wall Don't send wall message before halt/power-off/reboot\n"
4129 " --no-reload When enabling/disabling unit files, don't reload daemon\n"
4130 " configuration\n"
4131 " --no-legend Do not print a legend (column headers and hints)\n"
4132 " --no-pager Do not pipe output into a pager\n"
4133 " --no-ask-password\n"
4134 " Do not ask for system passwords\n"
4135 " --order When generating graph for dot, show only order\n"
4136 " --require When generating graph for dot, show only requirement\n"
4137 " --system Connect to system manager\n"
4138 " --user Connect to user service manager\n"
4139 " --global Enable/disable unit files globally\n"
4140 " -f --force When enabling unit files, override existing symlinks\n"
4141 " When shutting down, execute action immediately\n"
4142 " --root=PATH Enable unit files in the specified root directory\n"
4143 " --runtime Enable unit files only temporarily until next reboot\n"
4144 " -n --lines=INTEGER Journal entries to show\n"
4145 " --follow Follow journal\n"
4146 " -o --output=STRING Change journal output mode (short, short-monotonic,\n"
4147 " verbose, export, json, cat)\n\n"
4148 "Unit Commands:\n"
4149 " list-units List loaded units\n"
4150 " start [NAME...] Start (activate) one or more units\n"
4151 " stop [NAME...] Stop (deactivate) one or more units\n"
4152 " reload [NAME...] Reload one or more units\n"
4153 " restart [NAME...] Start or restart one or more units\n"
4154 " try-restart [NAME...] Restart one or more units if active\n"
4155 " reload-or-restart [NAME...] Reload one or more units is possible,\n"
4156 " otherwise start or restart\n"
4157 " reload-or-try-restart [NAME...] Reload one or more units is possible,\n"
4158 " otherwise restart if active\n"
4159 " isolate [NAME] Start one unit and stop all others\n"
4160 " kill [NAME...] Send signal to processes of a unit\n"
4161 " is-active [NAME...] Check whether units are active\n"
4162 " status [NAME...|PID...] Show runtime status of one or more units\n"
4163 " show [NAME...|JOB...] Show properties of one or more\n"
4164 " units/jobs or the manager\n"
4165 " reset-failed [NAME...] Reset failed state for all, one, or more\n"
4166 " units\n"
4167 " load [NAME...] Load one or more units\n\n"
4168 "Unit File Commands:\n"
4169 " list-unit-files List installed unit files\n"
4170 " enable [NAME...] Enable one or more unit files\n"
4171 " disable [NAME...] Disable one or more unit files\n"
4172 " reenable [NAME...] Reenable one or more unit files\n"
4173 " preset [NAME...] Enable/disable one or more unit files\n"
4174 " based on preset configuration\n"
4175 " mask [NAME...] Mask one or more units\n"
4176 " unmask [NAME...] Unmask one or more units\n"
4177 " link [PATH...] Link one or more units files into\n"
4178 " the search path\n"
4179 " is-enabled [NAME...] Check whether unit files are enabled\n\n"
4180 "Job Commands:\n"
4181 " list-jobs List jobs\n"
4182 " cancel [JOB...] Cancel all, one, or more jobs\n\n"
4183 "Status Commands:\n"
4184 " dump Dump server status\n"
4185 " dot Dump dependency graph for dot(1)\n\n"
4186 "Snapshot Commands:\n"
4187 " snapshot [NAME] Create a snapshot\n"
4188 " delete [NAME...] Remove one or more snapshots\n\n"
4189 "Environment Commands:\n"
4190 " show-environment Dump environment\n"
4191 " set-environment [NAME=VALUE...] Set one or more environment variables\n"
4192 " unset-environment [NAME...] Unset one or more environment variables\n\n"
4193 "Manager Lifecycle Commands:\n"
4194 " daemon-reload Reload systemd manager configuration\n"
4195 " daemon-reexec Reexecute systemd manager\n\n"
4196 "System Commands:\n"
4197 " default Enter system default mode\n"
4198 " rescue Enter system rescue mode\n"
4199 " emergency Enter system emergency mode\n"
4200 " halt Shut down and halt the system\n"
4201 " poweroff Shut down and power-off the system\n"
4202 " reboot Shut down and reboot the system\n"
4203 " kexec Shut down and reboot the system with kexec\n"
4204 " exit Ask for user instance termination\n",
4205 program_invocation_short_name);
4206
4207 return 0;
4208 }
4209
4210 static int halt_help(void) {
4211
4212 printf("%s [OPTIONS...]\n\n"
4213 "%s the system.\n\n"
4214 " --help Show this help\n"
4215 " --halt Halt the machine\n"
4216 " -p --poweroff Switch off the machine\n"
4217 " --reboot Reboot the machine\n"
4218 " -f --force Force immediate halt/power-off/reboot\n"
4219 " -w --wtmp-only Don't halt/power-off/reboot, just write wtmp record\n"
4220 " -d --no-wtmp Don't write wtmp record\n"
4221 " -n --no-sync Don't sync before halt/power-off/reboot\n"
4222 " --no-wall Don't send wall message before halt/power-off/reboot\n",
4223 program_invocation_short_name,
4224 arg_action == ACTION_REBOOT ? "Reboot" :
4225 arg_action == ACTION_POWEROFF ? "Power off" :
4226 "Halt");
4227
4228 return 0;
4229 }
4230
4231 static int shutdown_help(void) {
4232
4233 printf("%s [OPTIONS...] [TIME] [WALL...]\n\n"
4234 "Shut down the system.\n\n"
4235 " --help Show this help\n"
4236 " -H --halt Halt the machine\n"
4237 " -P --poweroff Power-off the machine\n"
4238 " -r --reboot Reboot the machine\n"
4239 " -h Equivalent to --poweroff, overriden by --halt\n"
4240 " -k Don't halt/power-off/reboot, just send warnings\n"
4241 " --no-wall Don't send wall message before halt/power-off/reboot\n"
4242 " -c Cancel a pending shutdown\n",
4243 program_invocation_short_name);
4244
4245 return 0;
4246 }
4247
4248 static int telinit_help(void) {
4249
4250 printf("%s [OPTIONS...] {COMMAND}\n\n"
4251 "Send control commands to the init daemon.\n\n"
4252 " --help Show this help\n"
4253 " --no-wall Don't send wall message before halt/power-off/reboot\n\n"
4254 "Commands:\n"
4255 " 0 Power-off the machine\n"
4256 " 6 Reboot the machine\n"
4257 " 2, 3, 4, 5 Start runlevelX.target unit\n"
4258 " 1, s, S Enter rescue mode\n"
4259 " q, Q Reload init daemon configuration\n"
4260 " u, U Reexecute init daemon\n",
4261 program_invocation_short_name);
4262
4263 return 0;
4264 }
4265
4266 static int runlevel_help(void) {
4267
4268 printf("%s [OPTIONS...]\n\n"
4269 "Prints the previous and current runlevel of the init system.\n\n"
4270 " --help Show this help\n",
4271 program_invocation_short_name);
4272
4273 return 0;
4274 }
4275
4276 static int systemctl_parse_argv(int argc, char *argv[]) {
4277
4278 enum {
4279 ARG_FAIL = 0x100,
4280 ARG_IGNORE_DEPENDENCIES,
4281 ARG_VERSION,
4282 ARG_USER,
4283 ARG_SYSTEM,
4284 ARG_GLOBAL,
4285 ARG_NO_BLOCK,
4286 ARG_NO_LEGEND,
4287 ARG_NO_PAGER,
4288 ARG_NO_WALL,
4289 ARG_ORDER,
4290 ARG_REQUIRE,
4291 ARG_ROOT,
4292 ARG_FULL,
4293 ARG_NO_RELOAD,
4294 ARG_KILL_MODE,
4295 ARG_KILL_WHO,
4296 ARG_NO_ASK_PASSWORD,
4297 ARG_FAILED,
4298 ARG_RUNTIME,
4299 ARG_FOLLOW,
4300 ARG_FORCE
4301 };
4302
4303 static const struct option options[] = {
4304 { "help", no_argument, NULL, 'h' },
4305 { "version", no_argument, NULL, ARG_VERSION },
4306 { "type", required_argument, NULL, 't' },
4307 { "property", required_argument, NULL, 'p' },
4308 { "all", no_argument, NULL, 'a' },
4309 { "failed", no_argument, NULL, ARG_FAILED },
4310 { "full", no_argument, NULL, ARG_FULL },
4311 { "fail", no_argument, NULL, ARG_FAIL },
4312 { "ignore-dependencies", no_argument, NULL, ARG_IGNORE_DEPENDENCIES },
4313 { "user", no_argument, NULL, ARG_USER },
4314 { "system", no_argument, NULL, ARG_SYSTEM },
4315 { "global", no_argument, NULL, ARG_GLOBAL },
4316 { "no-block", no_argument, NULL, ARG_NO_BLOCK },
4317 { "no-legend", no_argument, NULL, ARG_NO_LEGEND },
4318 { "no-pager", no_argument, NULL, ARG_NO_PAGER },
4319 { "no-wall", no_argument, NULL, ARG_NO_WALL },
4320 { "quiet", no_argument, NULL, 'q' },
4321 { "order", no_argument, NULL, ARG_ORDER },
4322 { "require", no_argument, NULL, ARG_REQUIRE },
4323 { "root", required_argument, NULL, ARG_ROOT },
4324 { "force", no_argument, NULL, ARG_FORCE },
4325 { "no-reload", no_argument, NULL, ARG_NO_RELOAD },
4326 { "kill-mode", required_argument, NULL, ARG_KILL_MODE }, /* undocumented on purpose */
4327 { "kill-who", required_argument, NULL, ARG_KILL_WHO },
4328 { "signal", required_argument, NULL, 's' },
4329 { "no-ask-password", no_argument, NULL, ARG_NO_ASK_PASSWORD },
4330 { "host", required_argument, NULL, 'H' },
4331 { "privileged",no_argument, NULL, 'P' },
4332 { "runtime", no_argument, NULL, ARG_RUNTIME },
4333 { "lines", required_argument, NULL, 'n' },
4334 { "follow", no_argument, NULL, ARG_FOLLOW },
4335 { "output", required_argument, NULL, 'o' },
4336 { NULL, 0, NULL, 0 }
4337 };
4338
4339 int c;
4340
4341 assert(argc >= 0);
4342 assert(argv);
4343
4344 while ((c = getopt_long(argc, argv, "ht:p:aqfs:H:Pn:o:", options, NULL)) >= 0) {
4345
4346 switch (c) {
4347
4348 case 'h':
4349 systemctl_help();
4350 return 0;
4351
4352 case ARG_VERSION:
4353 puts(PACKAGE_STRING);
4354 puts(DISTRIBUTION);
4355 puts(SYSTEMD_FEATURES);
4356 return 0;
4357
4358 case 't':
4359 arg_type = optarg;
4360 break;
4361
4362 case 'p': {
4363 char **l;
4364
4365 if (!(l = strv_append(arg_property, optarg)))
4366 return -ENOMEM;
4367
4368 strv_free(arg_property);
4369 arg_property = l;
4370
4371 /* If the user asked for a particular
4372 * property, show it to him, even if it is
4373 * empty. */
4374 arg_all = true;
4375 break;
4376 }
4377
4378 case 'a':
4379 arg_all = true;
4380 break;
4381
4382 case ARG_FAIL:
4383 arg_job_mode = "fail";
4384 break;
4385
4386 case ARG_IGNORE_DEPENDENCIES:
4387 arg_job_mode = "ignore-dependencies";
4388 break;
4389
4390 case ARG_USER:
4391 arg_scope = UNIT_FILE_USER;
4392 break;
4393
4394 case ARG_SYSTEM:
4395 arg_scope = UNIT_FILE_SYSTEM;
4396 break;
4397
4398 case ARG_GLOBAL:
4399 arg_scope = UNIT_FILE_GLOBAL;
4400 break;
4401
4402 case ARG_NO_BLOCK:
4403 arg_no_block = true;
4404 break;
4405
4406 case ARG_NO_LEGEND:
4407 arg_no_legend = true;
4408 break;
4409
4410 case ARG_NO_PAGER:
4411 arg_no_pager = true;
4412 break;
4413
4414 case ARG_NO_WALL:
4415 arg_no_wall = true;
4416 break;
4417
4418 case ARG_ORDER:
4419 arg_dot = DOT_ORDER;
4420 break;
4421
4422 case ARG_REQUIRE:
4423 arg_dot = DOT_REQUIRE;
4424 break;
4425
4426 case ARG_ROOT:
4427 arg_root = optarg;
4428 break;
4429
4430 case ARG_FULL:
4431 arg_full = true;
4432 break;
4433
4434 case ARG_FAILED:
4435 arg_failed = true;
4436 break;
4437
4438 case 'q':
4439 arg_quiet = true;
4440 break;
4441
4442 case ARG_FORCE:
4443 arg_force ++;
4444 break;
4445
4446 case ARG_FOLLOW:
4447 arg_follow = true;
4448 break;
4449
4450 case 'f':
4451 /* -f is short for both --follow and --force! */
4452 arg_force ++;
4453 arg_follow = true;
4454 break;
4455
4456 case ARG_NO_RELOAD:
4457 arg_no_reload = true;
4458 break;
4459
4460 case ARG_KILL_WHO:
4461 arg_kill_who = optarg;
4462 break;
4463
4464 case ARG_KILL_MODE:
4465 arg_kill_mode = optarg;
4466 break;
4467
4468 case 's':
4469 if ((arg_signal = signal_from_string_try_harder(optarg)) < 0) {
4470 log_error("Failed to parse signal string %s.", optarg);
4471 return -EINVAL;
4472 }
4473 break;
4474
4475 case ARG_NO_ASK_PASSWORD:
4476 arg_ask_password = false;
4477 break;
4478
4479 case 'P':
4480 arg_transport = TRANSPORT_POLKIT;
4481 break;
4482
4483 case 'H':
4484 arg_transport = TRANSPORT_SSH;
4485 arg_host = optarg;
4486 break;
4487
4488 case ARG_RUNTIME:
4489 arg_runtime = true;
4490 break;
4491
4492 case 'n':
4493 if (safe_atou(optarg, &arg_lines) < 0) {
4494 log_error("Failed to parse lines '%s'", optarg);
4495 return -EINVAL;
4496 }
4497 break;
4498
4499 case 'o':
4500 arg_output = output_mode_from_string(optarg);
4501 if (arg_output < 0) {
4502 log_error("Unknown output '%s'.", optarg);
4503 return -EINVAL;
4504 }
4505 break;
4506
4507 case '?':
4508 return -EINVAL;
4509
4510 default:
4511 log_error("Unknown option code %c", c);
4512 return -EINVAL;
4513 }
4514 }
4515
4516 if (arg_transport != TRANSPORT_NORMAL && arg_scope != UNIT_FILE_SYSTEM) {
4517 log_error("Cannot access user instance remotely.");
4518 return -EINVAL;
4519 }
4520
4521 return 1;
4522 }
4523
4524 static int halt_parse_argv(int argc, char *argv[]) {
4525
4526 enum {
4527 ARG_HELP = 0x100,
4528 ARG_HALT,
4529 ARG_REBOOT,
4530 ARG_NO_WALL
4531 };
4532
4533 static const struct option options[] = {
4534 { "help", no_argument, NULL, ARG_HELP },
4535 { "halt", no_argument, NULL, ARG_HALT },
4536 { "poweroff", no_argument, NULL, 'p' },
4537 { "reboot", no_argument, NULL, ARG_REBOOT },
4538 { "force", no_argument, NULL, 'f' },
4539 { "wtmp-only", no_argument, NULL, 'w' },
4540 { "no-wtmp", no_argument, NULL, 'd' },
4541 { "no-sync", no_argument, NULL, 'n' },
4542 { "no-wall", no_argument, NULL, ARG_NO_WALL },
4543 { NULL, 0, NULL, 0 }
4544 };
4545
4546 int c, runlevel;
4547
4548 assert(argc >= 0);
4549 assert(argv);
4550
4551 if (utmp_get_runlevel(&runlevel, NULL) >= 0)
4552 if (runlevel == '0' || runlevel == '6')
4553 arg_force = 2;
4554
4555 while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) {
4556 switch (c) {
4557
4558 case ARG_HELP:
4559 halt_help();
4560 return 0;
4561
4562 case ARG_HALT:
4563 arg_action = ACTION_HALT;
4564 break;
4565
4566 case 'p':
4567 if (arg_action != ACTION_REBOOT)
4568 arg_action = ACTION_POWEROFF;
4569 break;
4570
4571 case ARG_REBOOT:
4572 arg_action = ACTION_REBOOT;
4573 break;
4574
4575 case 'f':
4576 arg_force = 2;
4577 break;
4578
4579 case 'w':
4580 arg_dry = true;
4581 break;
4582
4583 case 'd':
4584 arg_no_wtmp = true;
4585 break;
4586
4587 case 'n':
4588 arg_no_sync = true;
4589 break;
4590
4591 case ARG_NO_WALL:
4592 arg_no_wall = true;
4593 break;
4594
4595 case 'i':
4596 case 'h':
4597 /* Compatibility nops */
4598 break;
4599
4600 case '?':
4601 return -EINVAL;
4602
4603 default:
4604 log_error("Unknown option code %c", c);
4605 return -EINVAL;
4606 }
4607 }
4608
4609 if (optind < argc) {
4610 log_error("Too many arguments.");
4611 return -EINVAL;
4612 }
4613
4614 return 1;
4615 }
4616
4617 static int parse_time_spec(const char *t, usec_t *_u) {
4618 assert(t);
4619 assert(_u);
4620
4621 if (streq(t, "now"))
4622 *_u = 0;
4623 else if (!strchr(t, ':')) {
4624 uint64_t u;
4625
4626 if (safe_atou64(t, &u) < 0)
4627 return -EINVAL;
4628
4629 *_u = now(CLOCK_REALTIME) + USEC_PER_MINUTE * u;
4630 } else {
4631 char *e = NULL;
4632 long hour, minute;
4633 struct tm tm;
4634 time_t s;
4635 usec_t n;
4636
4637 errno = 0;
4638 hour = strtol(t, &e, 10);
4639 if (errno != 0 || *e != ':' || hour < 0 || hour > 23)
4640 return -EINVAL;
4641
4642 minute = strtol(e+1, &e, 10);
4643 if (errno != 0 || *e != 0 || minute < 0 || minute > 59)
4644 return -EINVAL;
4645
4646 n = now(CLOCK_REALTIME);
4647 s = (time_t) (n / USEC_PER_SEC);
4648
4649 zero(tm);
4650 assert_se(localtime_r(&s, &tm));
4651
4652 tm.tm_hour = (int) hour;
4653 tm.tm_min = (int) minute;
4654 tm.tm_sec = 0;
4655
4656 assert_se(s = mktime(&tm));
4657
4658 *_u = (usec_t) s * USEC_PER_SEC;
4659
4660 while (*_u <= n)
4661 *_u += USEC_PER_DAY;
4662 }
4663
4664 return 0;
4665 }
4666
4667 static int shutdown_parse_argv(int argc, char *argv[]) {
4668
4669 enum {
4670 ARG_HELP = 0x100,
4671 ARG_NO_WALL
4672 };
4673
4674 static const struct option options[] = {
4675 { "help", no_argument, NULL, ARG_HELP },
4676 { "halt", no_argument, NULL, 'H' },
4677 { "poweroff", no_argument, NULL, 'P' },
4678 { "reboot", no_argument, NULL, 'r' },
4679 { "kexec", no_argument, NULL, 'K' }, /* not documented extension */
4680 { "no-wall", no_argument, NULL, ARG_NO_WALL },
4681 { NULL, 0, NULL, 0 }
4682 };
4683
4684 int c, r;
4685
4686 assert(argc >= 0);
4687 assert(argv);
4688
4689 while ((c = getopt_long(argc, argv, "HPrhkt:afFc", options, NULL)) >= 0) {
4690 switch (c) {
4691
4692 case ARG_HELP:
4693 shutdown_help();
4694 return 0;
4695
4696 case 'H':
4697 arg_action = ACTION_HALT;
4698 break;
4699
4700 case 'P':
4701 arg_action = ACTION_POWEROFF;
4702 break;
4703
4704 case 'r':
4705 if (kexec_loaded())
4706 arg_action = ACTION_KEXEC;
4707 else
4708 arg_action = ACTION_REBOOT;
4709 break;
4710
4711 case 'K':
4712 arg_action = ACTION_KEXEC;
4713 break;
4714
4715 case 'h':
4716 if (arg_action != ACTION_HALT)
4717 arg_action = ACTION_POWEROFF;
4718 break;
4719
4720 case 'k':
4721 arg_dry = true;
4722 break;
4723
4724 case ARG_NO_WALL:
4725 arg_no_wall = true;
4726 break;
4727
4728 case 't':
4729 case 'a':
4730 /* Compatibility nops */
4731 break;
4732
4733 case 'c':
4734 arg_action = ACTION_CANCEL_SHUTDOWN;
4735 break;
4736
4737 case '?':
4738 return -EINVAL;
4739
4740 default:
4741 log_error("Unknown option code %c", c);
4742 return -EINVAL;
4743 }
4744 }
4745
4746 if (argc > optind) {
4747 r = parse_time_spec(argv[optind], &arg_when);
4748 if (r < 0) {
4749 log_error("Failed to parse time specification: %s", argv[optind]);
4750 return r;
4751 }
4752 } else
4753 arg_when = now(CLOCK_REALTIME) + USEC_PER_MINUTE;
4754
4755 /* We skip the time argument */
4756 if (argc > optind + 1)
4757 arg_wall = argv + optind + 1;
4758
4759 optind = argc;
4760
4761 return 1;
4762 }
4763
4764 static int telinit_parse_argv(int argc, char *argv[]) {
4765
4766 enum {
4767 ARG_HELP = 0x100,
4768 ARG_NO_WALL
4769 };
4770
4771 static const struct option options[] = {
4772 { "help", no_argument, NULL, ARG_HELP },
4773 { "no-wall", no_argument, NULL, ARG_NO_WALL },
4774 { NULL, 0, NULL, 0 }
4775 };
4776
4777 static const struct {
4778 char from;
4779 enum action to;
4780 } table[] = {
4781 { '0', ACTION_POWEROFF },
4782 { '6', ACTION_REBOOT },
4783 { '1', ACTION_RESCUE },
4784 { '2', ACTION_RUNLEVEL2 },
4785 { '3', ACTION_RUNLEVEL3 },
4786 { '4', ACTION_RUNLEVEL4 },
4787 { '5', ACTION_RUNLEVEL5 },
4788 { 's', ACTION_RESCUE },
4789 { 'S', ACTION_RESCUE },
4790 { 'q', ACTION_RELOAD },
4791 { 'Q', ACTION_RELOAD },
4792 { 'u', ACTION_REEXEC },
4793 { 'U', ACTION_REEXEC }
4794 };
4795
4796 unsigned i;
4797 int c;
4798
4799 assert(argc >= 0);
4800 assert(argv);
4801
4802 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
4803 switch (c) {
4804
4805 case ARG_HELP:
4806 telinit_help();
4807 return 0;
4808
4809 case ARG_NO_WALL:
4810 arg_no_wall = true;
4811 break;
4812
4813 case '?':
4814 return -EINVAL;
4815
4816 default:
4817 log_error("Unknown option code %c", c);
4818 return -EINVAL;
4819 }
4820 }
4821
4822 if (optind >= argc) {
4823 telinit_help();
4824 return -EINVAL;
4825 }
4826
4827 if (optind + 1 < argc) {
4828 log_error("Too many arguments.");
4829 return -EINVAL;
4830 }
4831
4832 if (strlen(argv[optind]) != 1) {
4833 log_error("Expected single character argument.");
4834 return -EINVAL;
4835 }
4836
4837 for (i = 0; i < ELEMENTSOF(table); i++)
4838 if (table[i].from == argv[optind][0])
4839 break;
4840
4841 if (i >= ELEMENTSOF(table)) {
4842 log_error("Unknown command %s.", argv[optind]);
4843 return -EINVAL;
4844 }
4845
4846 arg_action = table[i].to;
4847
4848 optind ++;
4849
4850 return 1;
4851 }
4852
4853 static int runlevel_parse_argv(int argc, char *argv[]) {
4854
4855 enum {
4856 ARG_HELP = 0x100,
4857 };
4858
4859 static const struct option options[] = {
4860 { "help", no_argument, NULL, ARG_HELP },
4861 { NULL, 0, NULL, 0 }
4862 };
4863
4864 int c;
4865
4866 assert(argc >= 0);
4867 assert(argv);
4868
4869 while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
4870 switch (c) {
4871
4872 case ARG_HELP:
4873 runlevel_help();
4874 return 0;
4875
4876 case '?':
4877 return -EINVAL;
4878
4879 default:
4880 log_error("Unknown option code %c", c);
4881 return -EINVAL;
4882 }
4883 }
4884
4885 if (optind < argc) {
4886 log_error("Too many arguments.");
4887 return -EINVAL;
4888 }
4889
4890 return 1;
4891 }
4892
4893 static int parse_argv(int argc, char *argv[]) {
4894 assert(argc >= 0);
4895 assert(argv);
4896
4897 if (program_invocation_short_name) {
4898
4899 if (strstr(program_invocation_short_name, "halt")) {
4900 arg_action = ACTION_HALT;
4901 return halt_parse_argv(argc, argv);
4902 } else if (strstr(program_invocation_short_name, "poweroff")) {
4903 arg_action = ACTION_POWEROFF;
4904 return halt_parse_argv(argc, argv);
4905 } else if (strstr(program_invocation_short_name, "reboot")) {
4906 if (kexec_loaded())
4907 arg_action = ACTION_KEXEC;
4908 else
4909 arg_action = ACTION_REBOOT;
4910 return halt_parse_argv(argc, argv);
4911 } else if (strstr(program_invocation_short_name, "shutdown")) {
4912 arg_action = ACTION_POWEROFF;
4913 return shutdown_parse_argv(argc, argv);
4914 } else if (strstr(program_invocation_short_name, "init")) {
4915
4916 if (sd_booted() > 0) {
4917 arg_action = ACTION_INVALID;
4918 return telinit_parse_argv(argc, argv);
4919 } else {
4920 /* Hmm, so some other init system is
4921 * running, we need to forward this
4922 * request to it. For now we simply
4923 * guess that it is Upstart. */
4924
4925 execv("/lib/upstart/telinit", argv);
4926
4927 log_error("Couldn't find an alternative telinit implementation to spawn.");
4928 return -EIO;
4929 }
4930
4931 } else if (strstr(program_invocation_short_name, "runlevel")) {
4932 arg_action = ACTION_RUNLEVEL;
4933 return runlevel_parse_argv(argc, argv);
4934 }
4935 }
4936
4937 arg_action = ACTION_SYSTEMCTL;
4938 return systemctl_parse_argv(argc, argv);
4939 }
4940
4941 static int action_to_runlevel(void) {
4942
4943 static const char table[_ACTION_MAX] = {
4944 [ACTION_HALT] = '0',
4945 [ACTION_POWEROFF] = '0',
4946 [ACTION_REBOOT] = '6',
4947 [ACTION_RUNLEVEL2] = '2',
4948 [ACTION_RUNLEVEL3] = '3',
4949 [ACTION_RUNLEVEL4] = '4',
4950 [ACTION_RUNLEVEL5] = '5',
4951 [ACTION_RESCUE] = '1'
4952 };
4953
4954 assert(arg_action < _ACTION_MAX);
4955
4956 return table[arg_action];
4957 }
4958
4959 static int talk_upstart(void) {
4960 DBusMessage *m = NULL, *reply = NULL;
4961 DBusError error;
4962 int previous, rl, r;
4963 char
4964 env1_buf[] = "RUNLEVEL=X",
4965 env2_buf[] = "PREVLEVEL=X";
4966 char *env1 = env1_buf, *env2 = env2_buf;
4967 const char *emit = "runlevel";
4968 dbus_bool_t b_false = FALSE;
4969 DBusMessageIter iter, sub;
4970 DBusConnection *bus;
4971
4972 dbus_error_init(&error);
4973
4974 if (!(rl = action_to_runlevel()))
4975 return 0;
4976
4977 if (utmp_get_runlevel(&previous, NULL) < 0)
4978 previous = 'N';
4979
4980 if (!(bus = dbus_connection_open_private("unix:abstract=/com/ubuntu/upstart", &error))) {
4981 if (dbus_error_has_name(&error, DBUS_ERROR_NO_SERVER)) {
4982 r = 0;
4983 goto finish;
4984 }
4985
4986 log_error("Failed to connect to Upstart bus: %s", bus_error_message(&error));
4987 r = -EIO;
4988 goto finish;
4989 }
4990
4991 if ((r = bus_check_peercred(bus)) < 0) {
4992 log_error("Failed to verify owner of bus.");
4993 goto finish;
4994 }
4995
4996 if (!(m = dbus_message_new_method_call(
4997 "com.ubuntu.Upstart",
4998 "/com/ubuntu/Upstart",
4999 "com.ubuntu.Upstart0_6",
5000 "EmitEvent"))) {
5001
5002 log_error("Could not allocate message.");
5003 r = -ENOMEM;
5004 goto finish;
5005 }
5006
5007 dbus_message_iter_init_append(m, &iter);
5008
5009 env1_buf[sizeof(env1_buf)-2] = rl;
5010 env2_buf[sizeof(env2_buf)-2] = previous;
5011
5012 if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &emit) ||
5013 !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub) ||
5014 !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env1) ||
5015 !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env2) ||
5016 !dbus_message_iter_close_container(&iter, &sub) ||
5017 !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b_false)) {
5018 log_error("Could not append arguments to message.");
5019 r = -ENOMEM;
5020 goto finish;
5021 }
5022
5023 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
5024
5025 if (error_is_no_service(&error)) {
5026 r = -EADDRNOTAVAIL;
5027 goto finish;
5028 }
5029
5030 log_error("Failed to issue method call: %s", bus_error_message(&error));
5031 r = -EIO;
5032 goto finish;
5033 }
5034
5035 r = 1;
5036
5037 finish:
5038 if (m)
5039 dbus_message_unref(m);
5040
5041 if (reply)
5042 dbus_message_unref(reply);
5043
5044 if (bus) {
5045 dbus_connection_flush(bus);
5046 dbus_connection_close(bus);
5047 dbus_connection_unref(bus);
5048 }
5049
5050 dbus_error_free(&error);
5051
5052 return r;
5053 }
5054
5055 static int talk_initctl(void) {
5056 struct init_request request;
5057 int r, fd;
5058 char rl;
5059
5060 if (!(rl = action_to_runlevel()))
5061 return 0;
5062
5063 zero(request);
5064 request.magic = INIT_MAGIC;
5065 request.sleeptime = 0;
5066 request.cmd = INIT_CMD_RUNLVL;
5067 request.runlevel = rl;
5068
5069 if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) {
5070
5071 if (errno == ENOENT)
5072 return 0;
5073
5074 log_error("Failed to open "INIT_FIFO": %m");
5075 return -errno;
5076 }
5077
5078 errno = 0;
5079 r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
5080 close_nointr_nofail(fd);
5081
5082 if (r < 0) {
5083 log_error("Failed to write to "INIT_FIFO": %m");
5084 return errno ? -errno : -EIO;
5085 }
5086
5087 return 1;
5088 }
5089
5090 static int systemctl_main(DBusConnection *bus, int argc, char *argv[], DBusError *error) {
5091
5092 static const struct {
5093 const char* verb;
5094 const enum {
5095 MORE,
5096 LESS,
5097 EQUAL
5098 } argc_cmp;
5099 const int argc;
5100 int (* const dispatch)(DBusConnection *bus, char **args);
5101 } verbs[] = {
5102 { "list-units", LESS, 1, list_units },
5103 { "list-unit-files", EQUAL, 1, list_unit_files },
5104 { "list-jobs", EQUAL, 1, list_jobs },
5105 { "clear-jobs", EQUAL, 1, daemon_reload },
5106 { "load", MORE, 2, load_unit },
5107 { "cancel", MORE, 2, cancel_job },
5108 { "start", MORE, 2, start_unit },
5109 { "stop", MORE, 2, start_unit },
5110 { "condstop", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
5111 { "reload", MORE, 2, start_unit },
5112 { "restart", MORE, 2, start_unit },
5113 { "try-restart", MORE, 2, start_unit },
5114 { "reload-or-restart", MORE, 2, start_unit },
5115 { "reload-or-try-restart", MORE, 2, start_unit },
5116 { "force-reload", MORE, 2, start_unit }, /* For compatibility with SysV */
5117 { "condreload", MORE, 2, start_unit }, /* For compatibility with ALTLinux */
5118 { "condrestart", MORE, 2, start_unit }, /* For compatibility with RH */
5119 { "isolate", EQUAL, 2, start_unit },
5120 { "kill", MORE, 2, kill_unit },
5121 { "is-active", MORE, 2, check_unit },
5122 { "check", MORE, 2, check_unit },
5123 { "show", MORE, 1, show },
5124 { "status", MORE, 2, show },
5125 { "dump", EQUAL, 1, dump },
5126 { "dot", EQUAL, 1, dot },
5127 { "snapshot", LESS, 2, snapshot },
5128 { "delete", MORE, 2, delete_snapshot },
5129 { "daemon-reload", EQUAL, 1, daemon_reload },
5130 { "daemon-reexec", EQUAL, 1, daemon_reload },
5131 { "show-environment", EQUAL, 1, show_enviroment },
5132 { "set-environment", MORE, 2, set_environment },
5133 { "unset-environment", MORE, 2, set_environment },
5134 { "halt", EQUAL, 1, start_special },
5135 { "poweroff", EQUAL, 1, start_special },
5136 { "reboot", EQUAL, 1, start_special },
5137 { "kexec", EQUAL, 1, start_special },
5138 { "default", EQUAL, 1, start_special },
5139 { "rescue", EQUAL, 1, start_special },
5140 { "emergency", EQUAL, 1, start_special },
5141 { "exit", EQUAL, 1, start_special },
5142 { "reset-failed", MORE, 1, reset_failed },
5143 { "enable", MORE, 2, enable_unit },
5144 { "disable", MORE, 2, enable_unit },
5145 { "is-enabled", MORE, 2, unit_is_enabled },
5146 { "reenable", MORE, 2, enable_unit },
5147 { "preset", MORE, 2, enable_unit },
5148 { "mask", MORE, 2, enable_unit },
5149 { "unmask", MORE, 2, enable_unit },
5150 { "link", MORE, 2, enable_unit }
5151 };
5152
5153 int left;
5154 unsigned i;
5155
5156 assert(argc >= 0);
5157 assert(argv);
5158 assert(error);
5159
5160 left = argc - optind;
5161
5162 if (left <= 0)
5163 /* Special rule: no arguments means "list-units" */
5164 i = 0;
5165 else {
5166 if (streq(argv[optind], "help")) {
5167 systemctl_help();
5168 return 0;
5169 }
5170
5171 for (i = 0; i < ELEMENTSOF(verbs); i++)
5172 if (streq(argv[optind], verbs[i].verb))
5173 break;
5174
5175 if (i >= ELEMENTSOF(verbs)) {
5176 log_error("Unknown operation %s", argv[optind]);
5177 return -EINVAL;
5178 }
5179 }
5180
5181 switch (verbs[i].argc_cmp) {
5182
5183 case EQUAL:
5184 if (left != verbs[i].argc) {
5185 log_error("Invalid number of arguments.");
5186 return -EINVAL;
5187 }
5188
5189 break;
5190
5191 case MORE:
5192 if (left < verbs[i].argc) {
5193 log_error("Too few arguments.");
5194 return -EINVAL;
5195 }
5196
5197 break;
5198
5199 case LESS:
5200 if (left > verbs[i].argc) {
5201 log_error("Too many arguments.");
5202 return -EINVAL;
5203 }
5204
5205 break;
5206
5207 default:
5208 assert_not_reached("Unknown comparison operator.");
5209 }
5210
5211 /* Require a bus connection for all operations but
5212 * enable/disable */
5213 if (!streq(verbs[i].verb, "enable") &&
5214 !streq(verbs[i].verb, "disable") &&
5215 !streq(verbs[i].verb, "is-enabled") &&
5216 !streq(verbs[i].verb, "list-unit-files") &&
5217 !streq(verbs[i].verb, "reenable") &&
5218 !streq(verbs[i].verb, "preset") &&
5219 !streq(verbs[i].verb, "mask") &&
5220 !streq(verbs[i].verb, "unmask") &&
5221 !streq(verbs[i].verb, "link")) {
5222
5223 if (running_in_chroot() > 0) {
5224 log_info("Running in chroot, ignoring request.");
5225 return 0;
5226 }
5227
5228 if (((!streq(verbs[i].verb, "reboot") &&
5229 !streq(verbs[i].verb, "halt") &&
5230 !streq(verbs[i].verb, "poweroff")) || arg_force <= 0) && !bus) {
5231 log_error("Failed to get D-Bus connection: %s",
5232 dbus_error_is_set(error) ? error->message : "No connection to service manager.");
5233 return -EIO;
5234 }
5235
5236 } else {
5237
5238 if (!bus && !avoid_bus()) {
5239 log_error("Failed to get D-Bus connection: %s",
5240 dbus_error_is_set(error) ? error->message : "No connection to service manager.");
5241 return -EIO;
5242 }
5243 }
5244
5245 return verbs[i].dispatch(bus, argv + optind);
5246 }
5247
5248 static int send_shutdownd(usec_t t, char mode, bool dry_run, bool warn, const char *message) {
5249 int fd;
5250 struct msghdr msghdr;
5251 struct iovec iovec[2];
5252 union sockaddr_union sockaddr;
5253 struct sd_shutdown_command c;
5254
5255 fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0);
5256 if (fd < 0)
5257 return -errno;
5258
5259 zero(c);
5260 c.usec = t;
5261 c.mode = mode;
5262 c.dry_run = dry_run;
5263 c.warn_wall = warn;
5264
5265 zero(sockaddr);
5266 sockaddr.sa.sa_family = AF_UNIX;
5267 strncpy(sockaddr.un.sun_path, "/run/systemd/shutdownd", sizeof(sockaddr.un.sun_path));
5268
5269 zero(msghdr);
5270 msghdr.msg_name = &sockaddr;
5271 msghdr.msg_namelen = offsetof(struct sockaddr_un, sun_path) + sizeof("/run/systemd/shutdownd") - 1;
5272
5273 zero(iovec);
5274 iovec[0].iov_base = (char*) &c;
5275 iovec[0].iov_len = offsetof(struct sd_shutdown_command, wall_message);
5276
5277 if (isempty(message))
5278 msghdr.msg_iovlen = 1;
5279 else {
5280 iovec[1].iov_base = (char*) message;
5281 iovec[1].iov_len = strlen(message);
5282 msghdr.msg_iovlen = 2;
5283 }
5284 msghdr.msg_iov = iovec;
5285
5286 if (sendmsg(fd, &msghdr, MSG_NOSIGNAL) < 0) {
5287 close_nointr_nofail(fd);
5288 return -errno;
5289 }
5290
5291 close_nointr_nofail(fd);
5292 return 0;
5293 }
5294
5295 static int reload_with_fallback(DBusConnection *bus) {
5296
5297 if (bus) {
5298 /* First, try systemd via D-Bus. */
5299 if (daemon_reload(bus, NULL) >= 0)
5300 return 0;
5301 }
5302
5303 /* Nothing else worked, so let's try signals */
5304 assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC);
5305
5306 if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0) {
5307 log_error("kill() failed: %m");
5308 return -errno;
5309 }
5310
5311 return 0;
5312 }
5313
5314 static int start_with_fallback(DBusConnection *bus) {
5315
5316 if (bus) {
5317 /* First, try systemd via D-Bus. */
5318 if (start_unit(bus, NULL) >= 0)
5319 goto done;
5320 }
5321
5322 /* Hmm, talking to systemd via D-Bus didn't work. Then
5323 * let's try to talk to Upstart via D-Bus. */
5324 if (talk_upstart() > 0)
5325 goto done;
5326
5327 /* Nothing else worked, so let's try
5328 * /dev/initctl */
5329 if (talk_initctl() > 0)
5330 goto done;
5331
5332 log_error("Failed to talk to init daemon.");
5333 return -EIO;
5334
5335 done:
5336 warn_wall(arg_action);
5337 return 0;
5338 }
5339
5340 static void halt_now(enum action a) {
5341
5342 /* Make sure C-A-D is handled by the kernel from this
5343 * point on... */
5344 reboot(RB_ENABLE_CAD);
5345
5346 switch (a) {
5347
5348 case ACTION_HALT:
5349 log_info("Halting.");
5350 reboot(RB_HALT_SYSTEM);
5351 break;
5352
5353 case ACTION_POWEROFF:
5354 log_info("Powering off.");
5355 reboot(RB_POWER_OFF);
5356 break;
5357
5358 case ACTION_REBOOT:
5359 log_info("Rebooting.");
5360 reboot(RB_AUTOBOOT);
5361 break;
5362
5363 default:
5364 assert_not_reached("Unknown halt action.");
5365 }
5366
5367 assert_not_reached("Uh? This shouldn't happen.");
5368 }
5369
5370 static int halt_main(DBusConnection *bus) {
5371 int r;
5372
5373 if (geteuid() != 0) {
5374 /* Try logind if we are a normal user and no special
5375 * mode applies. Maybe PolicyKit allows us to shutdown
5376 * the machine. */
5377
5378 if (arg_when <= 0 &&
5379 !arg_dry &&
5380 !arg_force &&
5381 (arg_action == ACTION_POWEROFF ||
5382 arg_action == ACTION_REBOOT)) {
5383 r = reboot_with_logind(bus, arg_action);
5384 if (r >= 0)
5385 return r;
5386 }
5387
5388 log_error("Must be root.");
5389 return -EPERM;
5390 }
5391
5392 if (arg_when > 0) {
5393 char *m;
5394
5395 m = strv_join(arg_wall, " ");
5396 r = send_shutdownd(arg_when,
5397 arg_action == ACTION_HALT ? 'H' :
5398 arg_action == ACTION_POWEROFF ? 'P' :
5399 arg_action == ACTION_KEXEC ? 'K' :
5400 'r',
5401 arg_dry,
5402 !arg_no_wall,
5403 m);
5404 free(m);
5405
5406 if (r < 0)
5407 log_warning("Failed to talk to shutdownd, proceeding with immediate shutdown: %s", strerror(-r));
5408 else {
5409 char date[FORMAT_TIMESTAMP_MAX];
5410
5411 log_info("Shutdown scheduled for %s, use 'shutdown -c' to cancel.",
5412 format_timestamp(date, sizeof(date), arg_when));
5413 return 0;
5414 }
5415 }
5416
5417 if (!arg_dry && !arg_force)
5418 return start_with_fallback(bus);
5419
5420 if (!arg_no_wtmp) {
5421 if (sd_booted() > 0)
5422 log_debug("Not writing utmp record, assuming that systemd-update-utmp is used.");
5423 else {
5424 r = utmp_put_shutdown();
5425 if (r < 0)
5426 log_warning("Failed to write utmp record: %s", strerror(-r));
5427 }
5428 }
5429
5430 if (!arg_no_sync)
5431 sync();
5432
5433 if (arg_dry)
5434 return 0;
5435
5436 halt_now(arg_action);
5437 /* We should never reach this. */
5438 return -ENOSYS;
5439 }
5440
5441 static int runlevel_main(void) {
5442 int r, runlevel, previous;
5443
5444 r = utmp_get_runlevel(&runlevel, &previous);
5445 if (r < 0) {
5446 puts("unknown");
5447 return r;
5448 }
5449
5450 printf("%c %c\n",
5451 previous <= 0 ? 'N' : previous,
5452 runlevel <= 0 ? 'N' : runlevel);
5453
5454 return 0;
5455 }
5456
5457 int main(int argc, char*argv[]) {
5458 int r, retval = EXIT_FAILURE;
5459 DBusConnection *bus = NULL;
5460 DBusError error;
5461
5462 dbus_error_init(&error);
5463
5464 log_parse_environment();
5465 log_open();
5466
5467 r = parse_argv(argc, argv);
5468 if (r < 0)
5469 goto finish;
5470 else if (r == 0) {
5471 retval = EXIT_SUCCESS;
5472 goto finish;
5473 }
5474
5475 /* /sbin/runlevel doesn't need to communicate via D-Bus, so
5476 * let's shortcut this */
5477 if (arg_action == ACTION_RUNLEVEL) {
5478 r = runlevel_main();
5479 retval = r < 0 ? EXIT_FAILURE : r;
5480 goto finish;
5481 }
5482
5483 if (running_in_chroot() > 0 && arg_action != ACTION_SYSTEMCTL) {
5484 log_info("Running in chroot, ignoring request.");
5485 retval = 0;
5486 goto finish;
5487 }
5488
5489 if (!avoid_bus()) {
5490 if (arg_transport == TRANSPORT_NORMAL)
5491 bus_connect(arg_scope == UNIT_FILE_SYSTEM ? DBUS_BUS_SYSTEM : DBUS_BUS_SESSION, &bus, &private_bus, &error);
5492 else if (arg_transport == TRANSPORT_POLKIT) {
5493 bus_connect_system_polkit(&bus, &error);
5494 private_bus = false;
5495 } else if (arg_transport == TRANSPORT_SSH) {
5496 bus_connect_system_ssh(NULL, arg_host, &bus, &error);
5497 private_bus = false;
5498 } else
5499 assert_not_reached("Uh, invalid transport...");
5500 }
5501
5502 switch (arg_action) {
5503
5504 case ACTION_SYSTEMCTL:
5505 r = systemctl_main(bus, argc, argv, &error);
5506 break;
5507
5508 case ACTION_HALT:
5509 case ACTION_POWEROFF:
5510 case ACTION_REBOOT:
5511 case ACTION_KEXEC:
5512 r = halt_main(bus);
5513 break;
5514
5515 case ACTION_RUNLEVEL2:
5516 case ACTION_RUNLEVEL3:
5517 case ACTION_RUNLEVEL4:
5518 case ACTION_RUNLEVEL5:
5519 case ACTION_RESCUE:
5520 case ACTION_EMERGENCY:
5521 case ACTION_DEFAULT:
5522 r = start_with_fallback(bus);
5523 break;
5524
5525 case ACTION_RELOAD:
5526 case ACTION_REEXEC:
5527 r = reload_with_fallback(bus);
5528 break;
5529
5530 case ACTION_CANCEL_SHUTDOWN:
5531 r = send_shutdownd(0, 0, false, false, NULL);
5532 break;
5533
5534 case ACTION_INVALID:
5535 case ACTION_RUNLEVEL:
5536 default:
5537 assert_not_reached("Unknown action");
5538 }
5539
5540 retval = r < 0 ? EXIT_FAILURE : r;
5541
5542 finish:
5543 if (bus) {
5544 dbus_connection_flush(bus);
5545 dbus_connection_close(bus);
5546 dbus_connection_unref(bus);
5547 }
5548
5549 dbus_error_free(&error);
5550
5551 dbus_shutdown();
5552
5553 strv_free(arg_property);
5554
5555 pager_close();
5556 ask_password_agent_close();
5557 polkit_agent_close();
5558
5559 return retval;
5560 }
Unnamed repository; edit this file 'description' to name the repository.