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