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