src/systemctl.c

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