]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/systemctl/systemctl.c
projects / thirdparty / systemd.git / blob
? search:


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