src/systemctl.c

   1 /*-*- Mode: C; c-basic-offset: 8 -*-*/
   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
  33 #include <dbus/dbus.h>
  34
  35 #include "log.h"
  36 #include "util.h"
  37 #include "macro.h"
  38 #include "set.h"
  39 #include "utmp-wtmp.h"
  40 #include "special.h"
  41 #include "initreq.h"
  42 #include "strv.h"
  43
  44 static const char *arg_type = NULL;
  45 static bool arg_all = false;
  46 static bool arg_replace = false;
  47 static bool arg_session = false;
  48 static bool arg_block = false;
  49 static bool arg_immediate = false;
  50 static bool arg_no_wtmp = false;
  51 static bool arg_no_sync = false;
  52 static bool arg_no_wall = false;
  53 static bool arg_dry = false;
  54 static char **arg_wall = NULL;
  55 enum action {
  56         ACTION_INVALID,
  57         ACTION_SYSTEMCTL,
  58         ACTION_HALT,
  59         ACTION_POWEROFF,
  60         ACTION_REBOOT,
  61         ACTION_RUNLEVEL2,
  62         ACTION_RUNLEVEL3,
  63         ACTION_RUNLEVEL4,
  64         ACTION_RUNLEVEL5,
  65         ACTION_RESCUE,
  66         ACTION_EMERGENCY,
  67         ACTION_DEFAULT,
  68         ACTION_RELOAD,
  69         ACTION_REEXEC,
  70         ACTION_RUNLEVEL,
  71         _ACTION_MAX
  72 } arg_action = ACTION_SYSTEMCTL;
  73
  74 static bool error_is_no_service(DBusError *error) {
  75
  76         assert(error);
  77
  78         if (!dbus_error_is_set(error))
  79                 return false;
  80
  81         if (dbus_error_has_name(error, DBUS_ERROR_NAME_HAS_NO_OWNER))
  82                 return true;
  83
  84         if (dbus_error_has_name(error, DBUS_ERROR_SERVICE_UNKNOWN))
  85                 return true;
  86
  87         return startswith(error->name, "org.freedesktop.DBus.Error.Spawn.");
  88 }
  89
  90 static int bus_iter_get_basic_and_next(DBusMessageIter *iter, int type, void *data, bool next) {
  91
  92         assert(iter);
  93         assert(data);
  94
  95         if (dbus_message_iter_get_arg_type(iter) != type)
  96                 return -EIO;
  97
  98         dbus_message_iter_get_basic(iter, data);
  99
 100         if (!dbus_message_iter_next(iter) != !next)
 101                 return -EIO;
 102
 103         return 0;
 104 }
 105
 106 static int columns(void) {
 107         static int parsed_columns = 0;
 108         const char *e;
 109
 110         if (parsed_columns > 0)
 111                 return parsed_columns;
 112
 113         if ((e = getenv("COLUMNS")))
 114                 parsed_columns = atoi(e);
 115
 116         if (parsed_columns <= 0) {
 117                 struct winsize ws;
 118                 zero(ws);
 119
 120                 if (ioctl(STDIN_FILENO, TIOCGWINSZ, &ws) >= 0)
 121                         parsed_columns = ws.ws_col;
 122         }
 123
 124         if (parsed_columns <= 0)
 125                 parsed_columns = 80;
 126
 127         return parsed_columns;
 128
 129 }
 130
 131 static void warn_wall(enum action action) {
 132         static const char *table[_ACTION_MAX] = {
 133                 [ACTION_HALT]      = "The system is going down for system halt NOW!",
 134                 [ACTION_REBOOT]    = "The system is going down for reboot NOW!",
 135                 [ACTION_POWEROFF]  = "The system is going down for power-off NOW!",
 136                 [ACTION_RESCUE]    = "The system is going down to rescue mode NOW!",
 137                 [ACTION_EMERGENCY] = "The system is going down to emergency mode NOW!"
 138         };
 139
 140         if (arg_no_wall)
 141                 return;
 142
 143         if (arg_wall) {
 144                 char *p;
 145
 146                 if (!(p = strv_join(arg_wall, " "))) {
 147                         log_error("Failed to join strings.");
 148                         return;
 149                 }
 150
 151                 if (*p) {
 152                         utmp_wall(p);
 153                         free(p);
 154                         return;
 155                 }
 156
 157                 free(p);
 158         }
 159
 160         if (!table[action])
 161                 return;
 162
 163         utmp_wall(table[action]);
 164 }
 165
 166 static int list_units(DBusConnection *bus, char **args, unsigned n) {
 167         DBusMessage *m = NULL, *reply = NULL;
 168         DBusError error;
 169         int r;
 170         DBusMessageIter iter, sub, sub2;
 171         unsigned k = 0;
 172
 173         dbus_error_init(&error);
 174
 175         assert(bus);
 176
 177         if (!(m = dbus_message_new_method_call(
 178                               "org.freedesktop.systemd1",
 179                               "/org/freedesktop/systemd1",
 180                               "org.freedesktop.systemd1.Manager",
 181                               "ListUnits"))) {
 182                 log_error("Could not allocate message.");
 183                 return -ENOMEM;
 184         }
 185
 186         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 187                 log_error("Failed to issue method call: %s", error.message);
 188                 r = -EIO;
 189                 goto finish;
 190         }
 191
 192         if (!dbus_message_iter_init(reply, &iter) ||
 193             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
 194             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
 195                 log_error("Failed to parse reply.");
 196                 r = -EIO;
 197                 goto finish;
 198         }
 199
 200         dbus_message_iter_recurse(&iter, &sub);
 201
 202         printf("%-45s %-6s %-12s %-12s %-15s %s\n", "UNIT", "LOAD", "ACTIVE", "SUB", "JOB", "DESCRIPTION");
 203
 204         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
 205                 const char *id, *description, *load_state, *active_state, *sub_state, *unit_state, *job_type, *job_path, *dot;
 206                 uint32_t job_id;
 207
 208                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
 209                         log_error("Failed to parse reply.");
 210                         r = -EIO;
 211                         goto finish;
 212                 }
 213
 214                 dbus_message_iter_recurse(&sub, &sub2);
 215
 216                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &id, true) < 0 ||
 217                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &description, true) < 0 ||
 218                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &load_state, true) < 0 ||
 219                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &active_state, true) < 0 ||
 220                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &sub_state, true) < 0 ||
 221                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_state, true) < 0 ||
 222                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &job_id, true) < 0 ||
 223                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &job_type, true) < 0 ||
 224                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, false) < 0) {
 225                         log_error("Failed to parse reply.");
 226                         r = -EIO;
 227                         goto finish;
 228                 }
 229
 230                 if ((!arg_type || ((dot = strrchr(id, '.')) &&
 231                                    streq(dot+1, arg_type))) &&
 232                     (arg_all || !streq(active_state, "inactive"))) {
 233
 234                         int a = 0, b = 0;
 235
 236                         printf("%-45s %-6s %-12s %-12s%n", id, load_state, active_state, sub_state, &a);
 237
 238                         if (job_id != 0)
 239                                 printf(" %-15s%n", job_type, &b);
 240                         else
 241                                 b = 1 + 15;
 242
 243                         if (a + b + 2 < columns()) {
 244                                 if (job_id == 0)
 245                                         printf("                ");
 246
 247                                 printf("%.*s", columns() - a - b - 2, description);
 248                         }
 249
 250                         fputs("\n", stdout);
 251                         k++;
 252                 }
 253
 254                 dbus_message_iter_next(&sub);
 255         }
 256
 257         if (arg_all)
 258                 printf("\n%u units listed.\n", k);
 259         else
 260                 printf("\n%u live units listed. Pass --all to see dead units, too.\n", k);
 261
 262         r = 0;
 263
 264 finish:
 265         if (m)
 266                 dbus_message_unref(m);
 267
 268         if (reply)
 269                 dbus_message_unref(reply);
 270
 271         dbus_error_free(&error);
 272
 273         return r;
 274 }
 275
 276 static int list_jobs(DBusConnection *bus, char **args, unsigned n) {
 277         DBusMessage *m = NULL, *reply = NULL;
 278         DBusError error;
 279         int r;
 280         DBusMessageIter iter, sub, sub2;
 281         unsigned k = 0;
 282
 283         dbus_error_init(&error);
 284
 285         assert(bus);
 286
 287         if (!(m = dbus_message_new_method_call(
 288                               "org.freedesktop.systemd1",
 289                               "/org/freedesktop/systemd1",
 290                               "org.freedesktop.systemd1.Manager",
 291                               "ListJobs"))) {
 292                 log_error("Could not allocate message.");
 293                 return -ENOMEM;
 294         }
 295
 296         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 297                 log_error("Failed to issue method call: %s", error.message);
 298                 r = -EIO;
 299                 goto finish;
 300         }
 301
 302         if (!dbus_message_iter_init(reply, &iter) ||
 303             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY ||
 304             dbus_message_iter_get_element_type(&iter) != DBUS_TYPE_STRUCT)  {
 305                 log_error("Failed to parse reply.");
 306                 r = -EIO;
 307                 goto finish;
 308         }
 309
 310         dbus_message_iter_recurse(&iter, &sub);
 311
 312         printf("%4s %-45s %-17s %-7s\n", "JOB", "UNIT", "TYPE", "STATE");
 313
 314         while (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_INVALID) {
 315                 const char *name, *type, *state, *job_path, *unit_path;
 316                 uint32_t id;
 317
 318                 if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRUCT) {
 319                         log_error("Failed to parse reply.");
 320                         r = -EIO;
 321                         goto finish;
 322                 }
 323
 324                 dbus_message_iter_recurse(&sub, &sub2);
 325
 326                 if (bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_UINT32, &id, true) < 0 ||
 327                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &name, true) < 0 ||
 328                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &type, true) < 0 ||
 329                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_STRING, &state, true) < 0 ||
 330                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &job_path, true) < 0 ||
 331                     bus_iter_get_basic_and_next(&sub2, DBUS_TYPE_OBJECT_PATH, &unit_path, false) < 0) {
 332                         log_error("Failed to parse reply.");
 333                         r = -EIO;
 334                         goto finish;
 335                 }
 336
 337                 printf("%4u %-45s %-17s %-7s\n", id, name, type, state);
 338                 k++;
 339
 340                 dbus_message_iter_next(&sub);
 341         }
 342
 343         printf("\n%u jobs listed.\n", k);
 344         r = 0;
 345
 346 finish:
 347         if (m)
 348                 dbus_message_unref(m);
 349
 350         if (reply)
 351                 dbus_message_unref(reply);
 352
 353         dbus_error_free(&error);
 354
 355         return r;
 356 }
 357
 358 static int load_unit(DBusConnection *bus, char **args, unsigned n) {
 359         DBusMessage *m = NULL, *reply = NULL;
 360         DBusError error;
 361         int r;
 362         unsigned i;
 363
 364         dbus_error_init(&error);
 365
 366         assert(bus);
 367         assert(args);
 368
 369         for (i = 1; i < n; i++) {
 370
 371                 if (!(m = dbus_message_new_method_call(
 372                                       "org.freedesktop.systemd1",
 373                                       "/org/freedesktop/systemd1",
 374                                       "org.freedesktop.systemd1.Manager",
 375                                       "LoadUnit"))) {
 376                         log_error("Could not allocate message.");
 377                         r = -ENOMEM;
 378                         goto finish;
 379                 }
 380
 381                 if (!dbus_message_append_args(m,
 382                                               DBUS_TYPE_STRING, &args[i],
 383                                               DBUS_TYPE_INVALID)) {
 384                         log_error("Could not append arguments to message.");
 385                         r = -ENOMEM;
 386                         goto finish;
 387                 }
 388
 389                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 390                         log_error("Failed to issue method call: %s", error.message);
 391                         r = -EIO;
 392                         goto finish;
 393                 }
 394
 395                 dbus_message_unref(m);
 396                 dbus_message_unref(reply);
 397
 398                 m = reply = NULL;
 399         }
 400
 401         r = 0;
 402
 403 finish:
 404         if (m)
 405                 dbus_message_unref(m);
 406
 407         if (reply)
 408                 dbus_message_unref(reply);
 409
 410         dbus_error_free(&error);
 411
 412         return r;
 413 }
 414
 415 static int cancel_job(DBusConnection *bus, char **args, unsigned n) {
 416         DBusMessage *m = NULL, *reply = NULL;
 417         DBusError error;
 418         int r;
 419         unsigned i;
 420
 421         dbus_error_init(&error);
 422
 423         assert(bus);
 424         assert(args);
 425
 426         for (i = 1; i < n; i++) {
 427                 unsigned id;
 428                 const char *path;
 429
 430                 if (!(m = dbus_message_new_method_call(
 431                                       "org.freedesktop.systemd1",
 432                                       "/org/freedesktop/systemd1",
 433                                       "org.freedesktop.systemd1.Manager",
 434                                       "GetJob"))) {
 435                         log_error("Could not allocate message.");
 436                         r = -ENOMEM;
 437                         goto finish;
 438                 }
 439
 440                 if ((r = safe_atou(args[i], &id)) < 0) {
 441                         log_error("Failed to parse job id: %s", strerror(-r));
 442                         goto finish;
 443                 }
 444
 445                 assert_cc(sizeof(uint32_t) == sizeof(id));
 446                 if (!dbus_message_append_args(m,
 447                                               DBUS_TYPE_UINT32, &id,
 448                                               DBUS_TYPE_INVALID)) {
 449                         log_error("Could not append arguments to message.");
 450                         r = -ENOMEM;
 451                         goto finish;
 452                 }
 453
 454                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 455                         log_error("Failed to issue method call: %s", error.message);
 456                         r = -EIO;
 457                         goto finish;
 458                 }
 459
 460                 if (!dbus_message_get_args(reply, &error,
 461                                            DBUS_TYPE_OBJECT_PATH, &path,
 462                                            DBUS_TYPE_INVALID)) {
 463                         log_error("Failed to parse reply: %s", error.message);
 464                         r = -EIO;
 465                         goto finish;
 466                 }
 467
 468                 dbus_message_unref(m);
 469                 if (!(m = dbus_message_new_method_call(
 470                                       "org.freedesktop.systemd1",
 471                                       path,
 472                                       "org.freedesktop.systemd1.Job",
 473                                       "Cancel"))) {
 474                         log_error("Could not allocate message.");
 475                         r = -ENOMEM;
 476                         goto finish;
 477                 }
 478
 479                 dbus_message_unref(reply);
 480                 if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 481                         log_error("Failed to issue method call: %s", error.message);
 482                         r = -EIO;
 483                         goto finish;
 484                 }
 485
 486                 dbus_message_unref(m);
 487                 dbus_message_unref(reply);
 488                 m = reply = NULL;
 489         }
 490
 491         r = 0;
 492
 493 finish:
 494         if (m)
 495                 dbus_message_unref(m);
 496
 497         if (reply)
 498                 dbus_message_unref(reply);
 499
 500         dbus_error_free(&error);
 501
 502         return r;
 503 }
 504
 505 static DBusHandlerResult wait_filter(DBusConnection *connection, DBusMessage *message, void *data) {
 506         DBusError error;
 507         Set *s = data;
 508
 509         assert(connection);
 510         assert(message);
 511         assert(s);
 512
 513         dbus_error_init(&error);
 514
 515         /* log_debug("Got D-Bus request: %s.%s() on %s", */
 516         /*           dbus_message_get_interface(message), */
 517         /*           dbus_message_get_member(message), */
 518         /*           dbus_message_get_path(message)); */
 519
 520         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
 521                 log_error("Warning! D-Bus connection terminated.");
 522                 dbus_connection_close(connection);
 523
 524         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
 525                 uint32_t id;
 526                 const char *path;
 527
 528                 if (!dbus_message_get_args(message, &error,
 529                                            DBUS_TYPE_UINT32, &id,
 530                                            DBUS_TYPE_OBJECT_PATH, &path,
 531                                            DBUS_TYPE_INVALID))
 532                         log_error("Failed to parse message: %s", error.message);
 533                 else {
 534                         char *p;
 535
 536                         if ((p = set_remove(s, (char*) path)))
 537                                 free(p);
 538                 }
 539         }
 540
 541         dbus_error_free(&error);
 542         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 543 }
 544
 545 static int enable_wait_for_jobs(DBusConnection *bus) {
 546         DBusError error;
 547         DBusMessage *m = NULL, *reply = NULL;
 548         int r;
 549
 550         assert(bus);
 551
 552         dbus_error_init(&error);
 553
 554         dbus_bus_add_match(bus,
 555                            "type='signal',"
 556                            "sender='org.freedesktop.systemd1',"
 557                            "interface='org.freedesktop.systemd1.Manager',"
 558                            "member='JobRemoved',"
 559                            "path='/org/freedesktop/systemd1'",
 560                            &error);
 561
 562         if (dbus_error_is_set(&error)) {
 563                 log_error("Failed to add match: %s", error.message);
 564                 r = -EIO;
 565                 goto finish;
 566         }
 567
 568         if (!(m = dbus_message_new_method_call(
 569                               "org.freedesktop.systemd1",
 570                               "/org/freedesktop/systemd1",
 571                               "org.freedesktop.systemd1.Manager",
 572                               "Subscribe"))) {
 573                 log_error("Could not allocate message.");
 574                 r = -ENOMEM;
 575                 goto finish;
 576         }
 577
 578         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 579                 log_error("Failed to issue method call: %s", error.message);
 580                 r = -EIO;
 581                 goto finish;
 582         }
 583
 584         r = 0;
 585
 586 finish:
 587         /* This is slightly dirty, since we don't undo the match registrations. */
 588
 589         if (m)
 590                 dbus_message_unref(m);
 591
 592         if (reply)
 593                 dbus_message_unref(reply);
 594
 595         dbus_error_free(&error);
 596
 597         return r;
 598 }
 599
 600 static int wait_for_jobs(DBusConnection *bus, Set *s) {
 601         int r;
 602
 603         assert(bus);
 604         assert(s);
 605
 606         if (!dbus_connection_add_filter(bus, wait_filter, s, NULL)) {
 607                 log_error("Failed to add filter.");
 608                 r = -ENOMEM;
 609                 goto finish;
 610         }
 611
 612         while (!set_isempty(s) &&
 613                dbus_connection_read_write_dispatch(bus, -1))
 614                 ;
 615
 616         r = 0;
 617
 618 finish:
 619         /* This is slightly dirty, since we don't undo the filter registration. */
 620
 621         return r;
 622 }
 623
 624 static int start_unit_one(
 625                 DBusConnection *bus,
 626                 const char *method,
 627                 const char *name,
 628                 const char *mode,
 629                 Set *s) {
 630
 631         DBusMessage *m = NULL, *reply = NULL;
 632         DBusError error;
 633         int r;
 634
 635         assert(bus);
 636         assert(method);
 637         assert(name);
 638         assert(mode);
 639         assert(!arg_block || s);
 640
 641         dbus_error_init(&error);
 642
 643         if (!(m = dbus_message_new_method_call(
 644                               "org.freedesktop.systemd1",
 645                               "/org/freedesktop/systemd1",
 646                               "org.freedesktop.systemd1.Manager",
 647                               method))) {
 648                 log_error("Could not allocate message.");
 649                 r = -ENOMEM;
 650                 goto finish;
 651         }
 652
 653         if (!dbus_message_append_args(m,
 654                                       DBUS_TYPE_STRING, &name,
 655                                       DBUS_TYPE_STRING, &mode,
 656                                       DBUS_TYPE_INVALID)) {
 657                 log_error("Could not append arguments to message.");
 658                 r = -ENOMEM;
 659                 goto finish;
 660         }
 661
 662         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
 663
 664                 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
 665                         /* There's always a fallback possible for
 666                          * legacy actions. */
 667                         r = 0;
 668                         goto finish;
 669                 }
 670
 671                 log_error("Failed to issue method call: %s", error.message);
 672                 r = -EIO;
 673                 goto finish;
 674         }
 675
 676         if (arg_block) {
 677                 const char *path;
 678                 char *p;
 679
 680                 if (!dbus_message_get_args(reply, &error,
 681                                            DBUS_TYPE_OBJECT_PATH, &path,
 682                                            DBUS_TYPE_INVALID)) {
 683                         log_error("Failed to parse reply: %s", error.message);
 684                         r = -EIO;
 685                         goto finish;
 686                 }
 687
 688                 if (!(p = strdup(path))) {
 689                         log_error("Failed to duplicate path.");
 690                         r = -ENOMEM;
 691                         goto finish;
 692                 }
 693
 694                 if ((r = set_put(s, p)) < 0) {
 695                         free(p);
 696                         log_error("Failed to add path to set.");
 697                         goto finish;
 698                 }
 699         }
 700
 701         r = 1;
 702
 703 finish:
 704         if (m)
 705                 dbus_message_unref(m);
 706
 707         if (reply)
 708                 dbus_message_unref(reply);
 709
 710         dbus_error_free(&error);
 711
 712         return r;
 713 }
 714
 715 static enum action verb_to_action(const char *verb) {
 716         if (streq(verb, "halt"))
 717                 return ACTION_HALT;
 718         else if (streq(verb, "poweroff"))
 719                 return ACTION_POWEROFF;
 720         else if (streq(verb, "reboot"))
 721                 return ACTION_REBOOT;
 722         else if (streq(verb, "rescue"))
 723                 return ACTION_RESCUE;
 724         else if (streq(verb, "emergency"))
 725                 return ACTION_EMERGENCY;
 726         else if (streq(verb, "default"))
 727                 return ACTION_DEFAULT;
 728         else
 729                 return ACTION_INVALID;
 730 }
 731
 732 static int start_unit(DBusConnection *bus, char **args, unsigned n) {
 733
 734         static const char * const table[_ACTION_MAX] = {
 735                 [ACTION_HALT] = SPECIAL_HALT_TARGET,
 736                 [ACTION_POWEROFF] = SPECIAL_POWEROFF_TARGET,
 737                 [ACTION_REBOOT] = SPECIAL_REBOOT_TARGET,
 738                 [ACTION_RUNLEVEL2] = SPECIAL_RUNLEVEL2_TARGET,
 739                 [ACTION_RUNLEVEL3] = SPECIAL_RUNLEVEL3_TARGET,
 740                 [ACTION_RUNLEVEL4] = SPECIAL_RUNLEVEL4_TARGET,
 741                 [ACTION_RUNLEVEL5] = SPECIAL_RUNLEVEL5_TARGET,
 742                 [ACTION_RESCUE] = SPECIAL_RESCUE_TARGET,
 743                 [ACTION_EMERGENCY] = SPECIAL_EMERGENCY_SERVICE,
 744                 [ACTION_DEFAULT] = SPECIAL_DEFAULT_TARGET
 745         };
 746
 747         int r;
 748         unsigned i;
 749         const char *method, *mode, *one_name;
 750         Set *s = NULL;
 751
 752         assert(bus);
 753
 754         if (arg_action == ACTION_SYSTEMCTL) {
 755                 method =
 756                         streq(args[0], "stop")    ? "StopUnit" :
 757                         streq(args[0], "reload")  ? "ReloadUnit" :
 758                         streq(args[0], "restart") ? "RestartUnit" :
 759                                                     "StartUnit";
 760
 761                 mode =
 762                         (streq(args[0], "isolate") ||
 763                          streq(args[0], "rescue")  ||
 764                          streq(args[0], "emergency")) ? "isolate" :
 765                                           arg_replace ? "replace" :
 766                                                         "fail";
 767
 768                 one_name = table[verb_to_action(args[0])];
 769
 770         } else {
 771                 assert(arg_action < ELEMENTSOF(table));
 772                 assert(table[arg_action]);
 773
 774                 method = "StartUnit";
 775
 776                 mode = (arg_action == ACTION_EMERGENCY ||
 777                         arg_action == ACTION_RESCUE) ? "isolate" : "replace";
 778
 779                 one_name = table[arg_action];
 780         }
 781
 782         if (arg_block) {
 783                 if ((r = enable_wait_for_jobs(bus)) < 0) {
 784                         log_error("Could not watch jobs: %s", strerror(-r));
 785                         goto finish;
 786                 }
 787
 788                 if (!(s = set_new(string_hash_func, string_compare_func))) {
 789                         log_error("Failed to allocate set.");
 790                         r = -ENOMEM;
 791                         goto finish;
 792                 }
 793         }
 794
 795         r = 0;
 796
 797         if (one_name) {
 798                 if ((r = start_unit_one(bus, method, one_name, mode, s)) <= 0)
 799                         goto finish;
 800         } else {
 801                 for (i = 1; i < n; i++)
 802                         if ((r = start_unit_one(bus, method, args[i], mode, s)) < 0)
 803                                 goto finish;
 804         }
 805
 806         if (arg_block)
 807                 r = wait_for_jobs(bus, s);
 808
 809 finish:
 810         if (s)
 811                 set_free_free(s);
 812
 813         return r;
 814 }
 815
 816 static int start_special(DBusConnection *bus, char **args, unsigned n) {
 817         assert(bus);
 818         assert(args);
 819
 820         warn_wall(verb_to_action(args[0]));
 821
 822         return start_unit(bus, args, n);
 823 }
 824
 825 static DBusHandlerResult monitor_filter(DBusConnection *connection, DBusMessage *message, void *data) {
 826         DBusError error;
 827         DBusMessage *m = NULL, *reply = NULL;
 828
 829         assert(connection);
 830         assert(message);
 831
 832         dbus_error_init(&error);
 833
 834         /* log_debug("Got D-Bus request: %s.%s() on %s", */
 835         /*           dbus_message_get_interface(message), */
 836         /*           dbus_message_get_member(message), */
 837         /*           dbus_message_get_path(message)); */
 838
 839         if (dbus_message_is_signal(message, DBUS_INTERFACE_LOCAL, "Disconnected")) {
 840                 log_error("Warning! D-Bus connection terminated.");
 841                 dbus_connection_close(connection);
 842
 843         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitNew") ||
 844                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "UnitRemoved")) {
 845                 const char *id, *path;
 846
 847                 if (!dbus_message_get_args(message, &error,
 848                                            DBUS_TYPE_STRING, &id,
 849                                            DBUS_TYPE_OBJECT_PATH, &path,
 850                                            DBUS_TYPE_INVALID))
 851                         log_error("Failed to parse message: %s", error.message);
 852                 else if (streq(dbus_message_get_member(message), "UnitNew"))
 853                         printf("Unit %s added.\n", id);
 854                 else
 855                         printf("Unit %s removed.\n", id);
 856
 857         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobNew") ||
 858                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Manager", "JobRemoved")) {
 859                 uint32_t id;
 860                 const char *path;
 861
 862                 if (!dbus_message_get_args(message, &error,
 863                                            DBUS_TYPE_UINT32, &id,
 864                                            DBUS_TYPE_OBJECT_PATH, &path,
 865                                            DBUS_TYPE_INVALID))
 866                         log_error("Failed to parse message: %s", error.message);
 867                 else if (streq(dbus_message_get_member(message), "JobNew"))
 868                         printf("Job %u added.\n", id);
 869                 else
 870                         printf("Job %u removed.\n", id);
 871
 872
 873         } else if (dbus_message_is_signal(message, "org.freedesktop.systemd1.Unit", "Changed") ||
 874                    dbus_message_is_signal(message, "org.freedesktop.systemd1.Job", "Changed")) {
 875
 876                 const char *path, *interface, *property = "Id";
 877                 DBusMessageIter iter, sub;
 878
 879                 path = dbus_message_get_path(message);
 880                 interface = dbus_message_get_interface(message);
 881
 882                 if (!(m = dbus_message_new_method_call(
 883                               "org.freedesktop.systemd1",
 884                               path,
 885                               "org.freedesktop.DBus.Properties",
 886                               "Get"))) {
 887                         log_error("Could not allocate message.");
 888                         goto oom;
 889                 }
 890
 891                 if (!dbus_message_append_args(m,
 892                                               DBUS_TYPE_STRING, &interface,
 893                                               DBUS_TYPE_STRING, &property,
 894                                               DBUS_TYPE_INVALID)) {
 895                         log_error("Could not append arguments to message.");
 896                         goto finish;
 897                 }
 898
 899                 if (!(reply = dbus_connection_send_with_reply_and_block(connection, m, -1, &error))) {
 900                         log_error("Failed to issue method call: %s", error.message);
 901                         goto finish;
 902                 }
 903
 904                 if (!dbus_message_iter_init(reply, &iter) ||
 905                     dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
 906                         log_error("Failed to parse reply.");
 907                         goto finish;
 908                 }
 909
 910                 dbus_message_iter_recurse(&iter, &sub);
 911
 912                 if (streq(interface, "org.freedesktop.systemd1.Unit")) {
 913                         const char *id;
 914
 915                         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
 916                                 log_error("Failed to parse reply.");
 917                                 goto finish;
 918                         }
 919
 920                         dbus_message_iter_get_basic(&sub, &id);
 921                         printf("Unit %s changed.\n", id);
 922                 } else {
 923                         uint32_t id;
 924
 925                         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_UINT32)  {
 926                                 log_error("Failed to parse reply.");
 927                                 goto finish;
 928                         }
 929
 930                         dbus_message_iter_get_basic(&sub, &id);
 931                         printf("Job %u changed.\n", id);
 932                 }
 933         }
 934
 935 finish:
 936         if (m)
 937                 dbus_message_unref(m);
 938
 939         if (reply)
 940                 dbus_message_unref(reply);
 941
 942         dbus_error_free(&error);
 943         return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
 944
 945 oom:
 946         if (m)
 947                 dbus_message_unref(m);
 948
 949         if (reply)
 950                 dbus_message_unref(reply);
 951
 952         dbus_error_free(&error);
 953         return DBUS_HANDLER_RESULT_NEED_MEMORY;
 954 }
 955
 956 static int monitor(DBusConnection *bus, char **args, unsigned n) {
 957         DBusMessage *m = NULL, *reply = NULL;
 958         DBusError error;
 959         int r;
 960
 961         dbus_error_init(&error);
 962
 963         dbus_bus_add_match(bus,
 964                            "type='signal',"
 965                            "sender='org.freedesktop.systemd1',"
 966                            "interface='org.freedesktop.systemd1.Manager',"
 967                            "path='/org/freedesktop/systemd1'",
 968                            &error);
 969
 970         if (dbus_error_is_set(&error)) {
 971                 log_error("Failed to add match: %s", error.message);
 972                 r = -EIO;
 973                 goto finish;
 974         }
 975
 976         dbus_bus_add_match(bus,
 977                            "type='signal',"
 978                            "sender='org.freedesktop.systemd1',"
 979                            "interface='org.freedesktop.systemd1.Unit',"
 980                            "member='Changed'",
 981                            &error);
 982
 983         if (dbus_error_is_set(&error)) {
 984                 log_error("Failed to add match: %s", error.message);
 985                 r = -EIO;
 986                 goto finish;
 987         }
 988
 989         dbus_bus_add_match(bus,
 990                            "type='signal',"
 991                            "sender='org.freedesktop.systemd1',"
 992                            "interface='org.freedesktop.systemd1.Job',"
 993                            "member='Changed'",
 994                            &error);
 995
 996         if (dbus_error_is_set(&error)) {
 997                 log_error("Failed to add match: %s", error.message);
 998                 r = -EIO;
 999                 goto finish;
1000         }
1001
1002         if (!dbus_connection_add_filter(bus, monitor_filter, NULL, NULL)) {
1003                 log_error("Failed to add filter.");
1004                 r = -ENOMEM;
1005                 goto finish;
1006         }
1007
1008         if (!(m = dbus_message_new_method_call(
1009                               "org.freedesktop.systemd1",
1010                               "/org/freedesktop/systemd1",
1011                               "org.freedesktop.systemd1.Manager",
1012                               "Subscribe"))) {
1013                 log_error("Could not allocate message.");
1014                 r = -ENOMEM;
1015                 goto finish;
1016         }
1017
1018         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1019                 log_error("Failed to issue method call: %s", error.message);
1020                 r = -EIO;
1021                 goto finish;
1022         }
1023
1024         while (dbus_connection_read_write_dispatch(bus, -1))
1025                 ;
1026
1027         r = 0;
1028
1029 finish:
1030
1031         /* This is slightly dirty, since we don't undo the filter or the matches. */
1032
1033         if (m)
1034                 dbus_message_unref(m);
1035
1036         if (reply)
1037                 dbus_message_unref(reply);
1038
1039         dbus_error_free(&error);
1040
1041         return r;
1042 }
1043
1044 static int dump(DBusConnection *bus, char **args, unsigned n) {
1045         DBusMessage *m = NULL, *reply = NULL;
1046         DBusError error;
1047         int r;
1048         const char *text;
1049
1050         dbus_error_init(&error);
1051
1052         if (!(m = dbus_message_new_method_call(
1053                               "org.freedesktop.systemd1",
1054                               "/org/freedesktop/systemd1",
1055                               "org.freedesktop.systemd1.Manager",
1056                               "Dump"))) {
1057                 log_error("Could not allocate message.");
1058                 return -ENOMEM;
1059         }
1060
1061         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1062                 log_error("Failed to issue method call: %s", error.message);
1063                 r = -EIO;
1064                 goto finish;
1065         }
1066
1067         if (!dbus_message_get_args(reply, &error,
1068                                    DBUS_TYPE_STRING, &text,
1069                                    DBUS_TYPE_INVALID)) {
1070                 log_error("Failed to parse reply: %s", error.message);
1071                 r = -EIO;
1072                 goto finish;
1073         }
1074
1075         fputs(text, stdout);
1076
1077         r = 0;
1078
1079 finish:
1080         if (m)
1081                 dbus_message_unref(m);
1082
1083         if (reply)
1084                 dbus_message_unref(reply);
1085
1086         dbus_error_free(&error);
1087
1088         return r;
1089 }
1090
1091 static int snapshot(DBusConnection *bus, char **args, unsigned n) {
1092         DBusMessage *m = NULL, *reply = NULL;
1093         DBusError error;
1094         int r;
1095         const char *name = "", *path, *id;
1096         dbus_bool_t cleanup = FALSE;
1097         DBusMessageIter iter, sub;
1098         const char
1099                 *interface = "org.freedesktop.systemd1.Unit",
1100                 *property = "Id";
1101
1102         dbus_error_init(&error);
1103
1104         if (!(m = dbus_message_new_method_call(
1105                               "org.freedesktop.systemd1",
1106                               "/org/freedesktop/systemd1",
1107                               "org.freedesktop.systemd1.Manager",
1108                               "CreateSnapshot"))) {
1109                 log_error("Could not allocate message.");
1110                 return -ENOMEM;
1111         }
1112
1113         if (n > 1)
1114                 name = args[1];
1115
1116         if (!dbus_message_append_args(m,
1117                                       DBUS_TYPE_STRING, &name,
1118                                       DBUS_TYPE_BOOLEAN, &cleanup,
1119                                       DBUS_TYPE_INVALID)) {
1120                 log_error("Could not append arguments to message.");
1121                 r = -ENOMEM;
1122                 goto finish;
1123         }
1124
1125         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1126                 log_error("Failed to issue method call: %s", error.message);
1127                 r = -EIO;
1128                 goto finish;
1129         }
1130
1131         if (!dbus_message_get_args(reply, &error,
1132                                    DBUS_TYPE_OBJECT_PATH, &path,
1133                                    DBUS_TYPE_INVALID)) {
1134                 log_error("Failed to parse reply: %s", error.message);
1135                 r = -EIO;
1136                 goto finish;
1137         }
1138
1139         dbus_message_unref(m);
1140         if (!(m = dbus_message_new_method_call(
1141                               "org.freedesktop.systemd1",
1142                               path,
1143                               "org.freedesktop.DBus.Properties",
1144                               "Get"))) {
1145                 log_error("Could not allocate message.");
1146                 return -ENOMEM;
1147         }
1148
1149         if (!dbus_message_append_args(m,
1150                                       DBUS_TYPE_STRING, &interface,
1151                                       DBUS_TYPE_STRING, &property,
1152                                       DBUS_TYPE_INVALID)) {
1153                 log_error("Could not append arguments to message.");
1154                 r = -ENOMEM;
1155                 goto finish;
1156         }
1157
1158         dbus_message_unref(reply);
1159         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1160                 log_error("Failed to issue method call: %s", error.message);
1161                 r = -EIO;
1162                 goto finish;
1163         }
1164
1165         if (!dbus_message_iter_init(reply, &iter) ||
1166             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
1167                 log_error("Failed to parse reply.");
1168                 r = -EIO;
1169                 goto finish;
1170         }
1171
1172         dbus_message_iter_recurse(&iter, &sub);
1173
1174         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_STRING)  {
1175                 log_error("Failed to parse reply.");
1176                 r = -EIO;
1177                 goto finish;
1178         }
1179
1180         dbus_message_iter_get_basic(&sub, &id);
1181         puts(id);
1182         r = 0;
1183
1184 finish:
1185         if (m)
1186                 dbus_message_unref(m);
1187
1188         if (reply)
1189                 dbus_message_unref(reply);
1190
1191         dbus_error_free(&error);
1192
1193         return r;
1194 }
1195
1196 static int clear_jobs(DBusConnection *bus, char **args, unsigned n) {
1197         DBusMessage *m = NULL, *reply = NULL;
1198         DBusError error;
1199         int r;
1200         const char *method;
1201
1202         dbus_error_init(&error);
1203
1204         if (arg_action == ACTION_RELOAD)
1205                 method = "Reload";
1206         else if (arg_action == ACTION_REEXEC)
1207                 method = "Reexecute";
1208         else {
1209                 assert(arg_action == ACTION_SYSTEMCTL);
1210
1211                 method =
1212                         streq(args[0], "clear-jobs")    ? "ClearJobs" :
1213                         streq(args[0], "daemon-reload") ? "Reload" :
1214                         streq(args[0], "daemon-reexec") ? "Reexecute" :
1215                                                           "Exit";
1216         }
1217
1218         if (!(m = dbus_message_new_method_call(
1219                               "org.freedesktop.systemd1",
1220                               "/org/freedesktop/systemd1",
1221                               "org.freedesktop.systemd1.Manager",
1222                               method))) {
1223                 log_error("Could not allocate message.");
1224                 return -ENOMEM;
1225         }
1226
1227         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1228
1229                 if (arg_action != ACTION_SYSTEMCTL && error_is_no_service(&error)) {
1230                         /* There's always a fallback possible for
1231                          * legacy actions. */
1232                         r = 0;
1233                         goto finish;
1234                 }
1235
1236                 log_error("Failed to issue method call: %s", error.message);
1237                 r = -EIO;
1238                 goto finish;
1239         }
1240
1241         r = 1;
1242
1243 finish:
1244         if (m)
1245                 dbus_message_unref(m);
1246
1247         if (reply)
1248                 dbus_message_unref(reply);
1249
1250         dbus_error_free(&error);
1251
1252         return r;
1253 }
1254
1255 static int show_enviroment(DBusConnection *bus, char **args, unsigned n) {
1256         DBusMessage *m = NULL, *reply = NULL;
1257         DBusError error;
1258         DBusMessageIter iter, sub, sub2;
1259         int r;
1260         const char
1261                 *interface = "org.freedesktop.systemd1.Manager",
1262                 *property = "Environment";
1263
1264         dbus_error_init(&error);
1265
1266         if (!(m = dbus_message_new_method_call(
1267                               "org.freedesktop.systemd1",
1268                               "/org/freedesktop/systemd1",
1269                               "org.freedesktop.DBus.Properties",
1270                               "Get"))) {
1271                 log_error("Could not allocate message.");
1272                 return -ENOMEM;
1273         }
1274
1275         if (!dbus_message_append_args(m,
1276                                       DBUS_TYPE_STRING, &interface,
1277                                       DBUS_TYPE_STRING, &property,
1278                                       DBUS_TYPE_INVALID)) {
1279                 log_error("Could not append arguments to message.");
1280                 r = -ENOMEM;
1281                 goto finish;
1282         }
1283
1284         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1285                 log_error("Failed to issue method call: %s", error.message);
1286                 r = -EIO;
1287                 goto finish;
1288         }
1289
1290         if (!dbus_message_iter_init(reply, &iter) ||
1291             dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)  {
1292                 log_error("Failed to parse reply.");
1293                 r = -EIO;
1294                 goto finish;
1295         }
1296
1297         dbus_message_iter_recurse(&iter, &sub);
1298
1299         if (dbus_message_iter_get_arg_type(&sub) != DBUS_TYPE_ARRAY ||
1300             dbus_message_iter_get_element_type(&sub) != DBUS_TYPE_STRING)  {
1301                 log_error("Failed to parse reply.");
1302                 r = -EIO;
1303                 goto finish;
1304         }
1305
1306         dbus_message_iter_recurse(&sub, &sub2);
1307
1308         while (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_INVALID) {
1309                 const char *text;
1310
1311                 if (dbus_message_iter_get_arg_type(&sub2) != DBUS_TYPE_STRING) {
1312                         log_error("Failed to parse reply.");
1313                         r = -EIO;
1314                         goto finish;
1315                 }
1316
1317                 dbus_message_iter_get_basic(&sub2, &text);
1318                 printf("%s\n", text);
1319
1320                 dbus_message_iter_next(&sub2);
1321         }
1322
1323         r = 0;
1324
1325 finish:
1326         if (m)
1327                 dbus_message_unref(m);
1328
1329         if (reply)
1330                 dbus_message_unref(reply);
1331
1332         dbus_error_free(&error);
1333
1334         return r;
1335 }
1336
1337 static int set_environment(DBusConnection *bus, char **args, unsigned n) {
1338         DBusMessage *m = NULL, *reply = NULL;
1339         DBusError error;
1340         int r;
1341         const char *method;
1342         DBusMessageIter iter, sub;
1343         unsigned i;
1344
1345         dbus_error_init(&error);
1346
1347         method = streq(args[0], "set-environment")
1348                 ? "SetEnvironment"
1349                 : "UnsetEnvironment";
1350
1351         if (!(m = dbus_message_new_method_call(
1352                               "org.freedesktop.systemd1",
1353                               "/org/freedesktop/systemd1",
1354                               "org.freedesktop.systemd1.Manager",
1355                               method))) {
1356
1357                 log_error("Could not allocate message.");
1358                 return -ENOMEM;
1359         }
1360
1361         dbus_message_iter_init_append(m, &iter);
1362
1363         if (!dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub)) {
1364                 log_error("Could not append arguments to message.");
1365                 r = -ENOMEM;
1366                 goto finish;
1367         }
1368
1369         for (i = 1; i < n; i++)
1370                 if (!dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &args[i])) {
1371                         log_error("Could not append arguments to message.");
1372                         r = -ENOMEM;
1373                         goto finish;
1374                 }
1375
1376         if (!dbus_message_iter_close_container(&iter, &sub)) {
1377                 log_error("Could not append arguments to message.");
1378                 r = -ENOMEM;
1379                 goto finish;
1380         }
1381
1382         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1383                 log_error("Failed to issue method call: %s", error.message);
1384                 r = -EIO;
1385                 goto finish;
1386         }
1387
1388         r = 0;
1389
1390 finish:
1391         if (m)
1392                 dbus_message_unref(m);
1393
1394         if (reply)
1395                 dbus_message_unref(reply);
1396
1397         dbus_error_free(&error);
1398
1399         return r;
1400 }
1401
1402 static int systemctl_help(void) {
1403
1404         printf("%s [options]\n\n"
1405                "Send control commands to the init daemon.\n\n"
1406                "  -h --help      Show this help\n"
1407                "  -t --type=TYPE List only units of a particular type\n"
1408                "  -a --all       Show all units, including dead ones\n"
1409                "     --replace   When installing a new job, replace existing conflicting ones\n"
1410                "     --system    Connect to system bus\n"
1411                "     --session   Connect to session bus\n"
1412                "     --block     Wait until operation finished\n"
1413                "     --no-wall   Don't send wall message before reboot/halt/power-off\n\n"
1414                "Commands:\n"
1415                "  list-units                      List units\n"
1416                "  list-jobs                       List jobs\n"
1417                "  clear-jobs                      Cancel all jobs\n"
1418                "  load [NAME...]                  Load one or more units\n"
1419                "  cancel [JOB...]                 Cancel one or more jobs\n"
1420                "  start [NAME...]                 Start one or more units\n"
1421                "  stop [NAME...]                  Stop one or more units\n"
1422                "  restart [NAME...]               Restart one or more units\n"
1423                "  reload [NAME...]                Reload one or more units\n"
1424                "  isolate [NAME]                  Start one unit and stop all others\n"
1425                "  monitor                         Monitor unit/job changes\n"
1426                "  dump                            Dump server status\n"
1427                "  snapshot [NAME]                 Create a snapshot\n"
1428                "  daemon-reload                   Reload init daemon configuration\n"
1429                "  daemon-reexecute                Reexecute init daemon\n"
1430                "  daemon-exit                     Ask the init daemon to quit\n"
1431                "  show-environment                Dump environment\n"
1432                "  set-environment [NAME=VALUE...] Set one or more environment variables\n"
1433                "  unset-environment [NAME...]     Unset one or more environment variables\n"
1434                "  halt                            Shut down and halt the system\n"
1435                "  reboot                          Shut down and reboot the system\n"
1436                "  poweroff                        Shut down and power off the system\n"
1437                "  default                         Enter default mode\n"
1438                "  rescue                          Enter rescue mode\n"
1439                "  emergency                       Enter emergency mode\n",
1440                program_invocation_short_name);
1441
1442         return 0;
1443 }
1444
1445 static int halt_help(void) {
1446
1447         printf("%s [options]\n\n"
1448                "%s the system.\n\n"
1449                "     --help      Show this help\n"
1450                "     --halt      Halt the machine\n"
1451                "  -p --poweroff  Switch off the machine\n"
1452                "     --reboot    Reboot the machine\n"
1453                "  -f --force     Force immediate reboot/halt/power-off\n"
1454                "  -w --wtmp-only Don't reboot/halt/power-off, just write wtmp record\n"
1455                "  -d --no-wtmp   Don't write wtmp record\n"
1456                "  -n --no-sync   Don't sync before reboot/halt/power-off\n"
1457                "     --no-wall   Don't send wall message before reboot/halt/power-off\n",
1458                program_invocation_short_name,
1459                arg_action == ACTION_REBOOT   ? "Reboot" :
1460                arg_action == ACTION_POWEROFF ? "Power off" :
1461                                                "Halt");
1462
1463         return 0;
1464 }
1465
1466 static int shutdown_help(void) {
1467
1468         printf("%s [options] [now] [WALL...]\n\n"
1469                "Shut down the system.\n\n"
1470                "     --help      Show this help\n"
1471                "  -H --halt      Halt the machine\n"
1472                "  -P --poweroff  Power-off the machine\n"
1473                "  -r --reboot    Reboot the machine\n"
1474                "  -h             Equivalent to --poweroff, overriden by --halt\n"
1475                "  -k             Don't reboot/halt/power-off, just send warnings\n"
1476                "     --no-wall   Don't send wall message before reboot/halt/power-off\n",
1477                program_invocation_short_name);
1478
1479         return 0;
1480 }
1481
1482 static int telinit_help(void) {
1483
1484         printf("%s [options]\n\n"
1485                "Send control commands to the init daemon.\n\n"
1486                "     --help      Show this help\n"
1487                "     --no-wall   Don't send wall message before reboot/halt/power-off\n\n"
1488                "Commands:\n"
1489                "  0              Power-off the machine\n"
1490                "  6              Reboot the machine\n"
1491                "  2, 3, 4, 5     Start runlevelX.target unit\n"
1492                "  1, s, S        Enter rescue mode\n"
1493                "  q, Q           Reload init daemon configuration\n"
1494                "  u, U           Reexecute init daemon\n",
1495                program_invocation_short_name);
1496
1497         return 0;
1498 }
1499
1500 static int runlevel_help(void) {
1501
1502         printf("%s [options]\n\n"
1503                "Prints the previous and current runlevel of the init system.\n\n"
1504                "     --help      Show this help\n",
1505                program_invocation_short_name);
1506
1507         return 0;
1508 }
1509
1510 static int systemctl_parse_argv(int argc, char *argv[]) {
1511
1512         enum {
1513                 ARG_REPLACE = 0x100,
1514                 ARG_SESSION,
1515                 ARG_SYSTEM,
1516                 ARG_BLOCK,
1517                 ARG_NO_WALL
1518         };
1519
1520         static const struct option options[] = {
1521                 { "help",      no_argument,       NULL, 'h'         },
1522                 { "type",      required_argument, NULL, 't'         },
1523                 { "all",       no_argument,       NULL, 'a'         },
1524                 { "replace",   no_argument,       NULL, ARG_REPLACE },
1525                 { "session",   no_argument,       NULL, ARG_SESSION },
1526                 { "system",    no_argument,       NULL, ARG_SYSTEM  },
1527                 { "block",     no_argument,       NULL, ARG_BLOCK   },
1528                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
1529                 { NULL,        0,                 NULL, 0           }
1530         };
1531
1532         int c;
1533
1534         assert(argc >= 0);
1535         assert(argv);
1536
1537         while ((c = getopt_long(argc, argv, "hta", options, NULL)) >= 0) {
1538
1539                 switch (c) {
1540
1541                 case 'h':
1542                         systemctl_help();
1543                         return 0;
1544
1545                 case 't':
1546                         arg_type = optarg;
1547                         break;
1548
1549                 case 'a':
1550                         arg_all = true;
1551                         break;
1552
1553                 case ARG_REPLACE:
1554                         arg_replace = true;
1555                         break;
1556
1557                 case ARG_SESSION:
1558                         arg_session = true;
1559                         break;
1560
1561                 case ARG_SYSTEM:
1562                         arg_session = false;
1563                         break;
1564
1565                 case ARG_BLOCK:
1566                         arg_block = true;
1567                         break;
1568
1569                 case ARG_NO_WALL:
1570                         arg_no_wall = true;
1571                         break;
1572
1573                 case '?':
1574                         return -EINVAL;
1575
1576                 default:
1577                         log_error("Unknown option code %c", c);
1578                         return -EINVAL;
1579                 }
1580         }
1581
1582         return 1;
1583 }
1584
1585 static int halt_parse_argv(int argc, char *argv[]) {
1586
1587         enum {
1588                 ARG_HELP = 0x100,
1589                 ARG_HALT,
1590                 ARG_REBOOT,
1591                 ARG_NO_WALL
1592         };
1593
1594         static const struct option options[] = {
1595                 { "help",      no_argument,       NULL, ARG_HELP    },
1596                 { "halt",      no_argument,       NULL, ARG_HALT    },
1597                 { "poweroff",  no_argument,       NULL, 'p'         },
1598                 { "reboot",    no_argument,       NULL, ARG_REBOOT  },
1599                 { "force",     no_argument,       NULL, 'f'         },
1600                 { "wtmp-only", no_argument,       NULL, 'w'         },
1601                 { "no-wtmp",   no_argument,       NULL, 'd'         },
1602                 { "no-sync",   no_argument,       NULL, 'n'         },
1603                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
1604                 { NULL,        0,                 NULL, 0           }
1605         };
1606
1607         int c, runlevel;
1608
1609         assert(argc >= 0);
1610         assert(argv);
1611
1612         if (utmp_get_runlevel(&runlevel, NULL) >= 0)
1613                 if (runlevel == '0' || runlevel == '6')
1614                         arg_immediate = true;
1615
1616         while ((c = getopt_long(argc, argv, "pfwdnih", options, NULL)) >= 0) {
1617                 switch (c) {
1618
1619                 case ARG_HELP:
1620                         halt_help();
1621                         return 0;
1622
1623                 case ARG_HALT:
1624                         arg_action = ACTION_HALT;
1625                         break;
1626
1627                 case 'p':
1628                         arg_action = ACTION_POWEROFF;
1629                         break;
1630
1631                 case ARG_REBOOT:
1632                         arg_action = ACTION_REBOOT;
1633                         break;
1634
1635                 case 'f':
1636                         arg_immediate = true;
1637                         break;
1638
1639                 case 'w':
1640                         arg_dry = true;
1641                         break;
1642
1643                 case 'd':
1644                         arg_no_wtmp = true;
1645                         break;
1646
1647                 case 'n':
1648                         arg_no_sync = true;
1649                         break;
1650
1651                 case ARG_NO_WALL:
1652                         arg_no_wall = true;
1653                         break;
1654
1655                 case 'i':
1656                 case 'h':
1657                         /* Compatibility nops */
1658                         break;
1659
1660                 case '?':
1661                         return -EINVAL;
1662
1663                 default:
1664                         log_error("Unknown option code %c", c);
1665                         return -EINVAL;
1666                 }
1667         }
1668
1669         if (optind < argc) {
1670                 log_error("Too many arguments.");
1671                 return -EINVAL;
1672         }
1673
1674         return 1;
1675 }
1676
1677 static int shutdown_parse_argv(int argc, char *argv[]) {
1678
1679         enum {
1680                 ARG_HELP = 0x100,
1681                 ARG_NO_WALL
1682         };
1683
1684         static const struct option options[] = {
1685                 { "help",      no_argument,       NULL, ARG_HELP    },
1686                 { "halt",      no_argument,       NULL, 'H'         },
1687                 { "poweroff",  no_argument,       NULL, 'P'         },
1688                 { "reboot",    no_argument,       NULL, 'r'         },
1689                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
1690                 { NULL,        0,                 NULL, 0           }
1691         };
1692
1693         int c;
1694
1695         assert(argc >= 0);
1696         assert(argv);
1697
1698         while ((c = getopt_long(argc, argv, "HPrhkt:a", options, NULL)) >= 0) {
1699                 switch (c) {
1700
1701                 case ARG_HELP:
1702                         shutdown_help();
1703                         return 0;
1704
1705                 case 'H':
1706                         arg_action = ACTION_HALT;
1707                         break;
1708
1709                 case 'P':
1710                         arg_action = ACTION_POWEROFF;
1711                         break;
1712
1713                 case 'r':
1714                         arg_action = ACTION_REBOOT;
1715                         break;
1716
1717                 case 'h':
1718                         if (arg_action != ACTION_HALT)
1719                                 arg_action = ACTION_POWEROFF;
1720                         break;
1721
1722                 case 'k':
1723                         arg_dry = true;
1724                         break;
1725
1726                 case ARG_NO_WALL:
1727                         arg_no_wall = true;
1728                         break;
1729
1730                 case 't':
1731                 case 'a':
1732                         /* Compatibility nops */
1733                         break;
1734
1735                 case '?':
1736                         return -EINVAL;
1737
1738                 default:
1739                         log_error("Unknown option code %c", c);
1740                         return -EINVAL;
1741                 }
1742         }
1743
1744         if (argc > optind && !streq(argv[optind], "now"))
1745                 log_warning("First argument '%s' isn't 'now'. Ignoring.", argv[optind]);
1746
1747         /* We ignore the time argument */
1748         if (argc > optind + 1)
1749                 arg_wall = argv + optind + 1;
1750
1751         optind = argc;
1752
1753         return 1;
1754
1755 }
1756
1757 static int telinit_parse_argv(int argc, char *argv[]) {
1758
1759         enum {
1760                 ARG_HELP = 0x100,
1761                 ARG_NO_WALL
1762         };
1763
1764         static const struct option options[] = {
1765                 { "help",      no_argument,       NULL, ARG_HELP    },
1766                 { "no-wall",   no_argument,       NULL, ARG_NO_WALL },
1767                 { NULL,        0,                 NULL, 0           }
1768         };
1769
1770         static const struct {
1771                 char from;
1772                 enum action to;
1773         } table[] = {
1774                 { '0', ACTION_POWEROFF },
1775                 { '6', ACTION_REBOOT },
1776                 { '1', ACTION_RESCUE },
1777                 { '2', ACTION_RUNLEVEL2 },
1778                 { '3', ACTION_RUNLEVEL3 },
1779                 { '4', ACTION_RUNLEVEL4 },
1780                 { '5', ACTION_RUNLEVEL5 },
1781                 { 's', ACTION_RESCUE },
1782                 { 'S', ACTION_RESCUE },
1783                 { 'q', ACTION_RELOAD },
1784                 { 'Q', ACTION_RELOAD },
1785                 { 'u', ACTION_REEXEC },
1786                 { 'U', ACTION_REEXEC }
1787         };
1788
1789         unsigned i;
1790         int c;
1791
1792         assert(argc >= 0);
1793         assert(argv);
1794
1795         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
1796                 switch (c) {
1797
1798                 case ARG_HELP:
1799                         telinit_help();
1800                         return 0;
1801
1802                 case ARG_NO_WALL:
1803                         arg_no_wall = true;
1804                         break;
1805
1806                 case '?':
1807                         return -EINVAL;
1808
1809                 default:
1810                         log_error("Unknown option code %c", c);
1811                         return -EINVAL;
1812                 }
1813         }
1814
1815         if (optind >= argc) {
1816                 log_error("Argument missing.");
1817                 return -EINVAL;
1818         }
1819
1820         if (optind + 1 < argc) {
1821                 log_error("Too many arguments.");
1822                 return -EINVAL;
1823         }
1824
1825         if (strlen(argv[optind]) != 1) {
1826                 log_error("Expected single character argument.");
1827                 return -EINVAL;
1828         }
1829
1830         for (i = 0; i < ELEMENTSOF(table); i++)
1831                 if (table[i].from == argv[optind][0])
1832                         break;
1833
1834         if (i >= ELEMENTSOF(table)) {
1835                 log_error("Unknown command %s.", argv[optind]);
1836                 return -EINVAL;
1837         }
1838
1839         arg_action = table[i].to;
1840
1841         optind ++;
1842
1843         return 1;
1844 }
1845
1846 static int runlevel_parse_argv(int argc, char *argv[]) {
1847
1848         enum {
1849                 ARG_HELP = 0x100,
1850         };
1851
1852         static const struct option options[] = {
1853                 { "help",      no_argument,       NULL, ARG_HELP    },
1854                 { NULL,        0,                 NULL, 0           }
1855         };
1856
1857         int c;
1858
1859         assert(argc >= 0);
1860         assert(argv);
1861
1862         while ((c = getopt_long(argc, argv, "", options, NULL)) >= 0) {
1863                 switch (c) {
1864
1865                 case ARG_HELP:
1866                         runlevel_help();
1867                         return 0;
1868
1869                 case '?':
1870                         return -EINVAL;
1871
1872                 default:
1873                         log_error("Unknown option code %c", c);
1874                         return -EINVAL;
1875                 }
1876         }
1877
1878         if (optind < argc) {
1879                 log_error("Too many arguments.");
1880                 return -EINVAL;
1881         }
1882
1883         return 1;
1884 }
1885
1886 static int parse_argv(int argc, char *argv[]) {
1887         assert(argc >= 0);
1888         assert(argv);
1889
1890         if (program_invocation_short_name) {
1891
1892                 if (strstr(program_invocation_short_name, "halt")) {
1893                         arg_action = ACTION_HALT;
1894                         return halt_parse_argv(argc, argv);
1895                 } else if (strstr(program_invocation_short_name, "poweroff")) {
1896                         arg_action = ACTION_POWEROFF;
1897                         return halt_parse_argv(argc, argv);
1898                 } else if (strstr(program_invocation_short_name, "reboot")) {
1899                         arg_action = ACTION_REBOOT;
1900                         return halt_parse_argv(argc, argv);
1901                 } else if (strstr(program_invocation_short_name, "shutdown")) {
1902                         arg_action = ACTION_POWEROFF;
1903                         return shutdown_parse_argv(argc, argv);
1904                 } else if (strstr(program_invocation_short_name, "init")) {
1905                         arg_action = ACTION_INVALID;
1906                         return telinit_parse_argv(argc, argv);
1907                 } else if (strstr(program_invocation_short_name, "runlevel")) {
1908                         arg_action = ACTION_RUNLEVEL;
1909                         return runlevel_parse_argv(argc, argv);
1910                 }
1911         }
1912
1913         arg_action = ACTION_SYSTEMCTL;
1914         return systemctl_parse_argv(argc, argv);
1915 }
1916
1917 static int action_to_runlevel(void) {
1918
1919         static const char table[_ACTION_MAX] = {
1920                 [ACTION_HALT] =      '0',
1921                 [ACTION_POWEROFF] =  '0',
1922                 [ACTION_REBOOT] =    '6',
1923                 [ACTION_RUNLEVEL2] = '2',
1924                 [ACTION_RUNLEVEL3] = '3',
1925                 [ACTION_RUNLEVEL4] = '4',
1926                 [ACTION_RUNLEVEL5] = '5',
1927                 [ACTION_RESCUE] =    '1'
1928         };
1929
1930         assert(arg_action < _ACTION_MAX);
1931
1932         return table[arg_action];
1933 }
1934
1935 static int talk_upstart(DBusConnection *bus) {
1936         DBusMessage *m = NULL, *reply = NULL;
1937         DBusError error;
1938         int previous, rl, r;
1939         char
1940                 env1_buf[] = "RUNLEVEL=X",
1941                 env2_buf[] = "PREVLEVEL=X";
1942         char *env1 = env1_buf, *env2 = env2_buf;
1943         const char *emit = "runlevel";
1944         dbus_bool_t b_false = FALSE;
1945         DBusMessageIter iter, sub;
1946
1947         dbus_error_init(&error);
1948
1949         if (!(rl = action_to_runlevel()))
1950                 return 0;
1951
1952         if (utmp_get_runlevel(&previous, NULL) < 0)
1953                 previous = 'N';
1954
1955         if (!(m = dbus_message_new_method_call(
1956                               "com.ubuntu.Upstart",
1957                               "/com/ubuntu/Upstart",
1958                               "com.ubuntu.Upstart0_6",
1959                               "EmitEvent"))) {
1960
1961                 log_error("Could not allocate message.");
1962                 return -ENOMEM;
1963         }
1964
1965         dbus_message_iter_init_append(m, &iter);
1966
1967         env1_buf[sizeof(env1_buf)-2] = rl;
1968         env2_buf[sizeof(env2_buf)-2] = previous;
1969
1970         if (!dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &emit) ||
1971             !dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY, "s", &sub) ||
1972             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env1) ||
1973             !dbus_message_iter_append_basic(&sub, DBUS_TYPE_STRING, &env2) ||
1974             !dbus_message_iter_close_container(&iter, &sub) ||
1975             !dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &b_false)) {
1976                 log_error("Could not append arguments to message.");
1977                 r = -ENOMEM;
1978                 goto finish;
1979         }
1980
1981         if (!(reply = dbus_connection_send_with_reply_and_block(bus, m, -1, &error))) {
1982
1983                 if (error_is_no_service(&error)) {
1984                         r = 0;
1985                         goto finish;
1986                 }
1987
1988                 log_error("Failed to issue method call: %s", error.message);
1989                 r = -EIO;
1990                 goto finish;
1991         }
1992
1993         r = 1;
1994
1995 finish:
1996         if (m)
1997                 dbus_message_unref(m);
1998
1999         if (reply)
2000                 dbus_message_unref(reply);
2001
2002         dbus_error_free(&error);
2003
2004         return r;
2005 }
2006
2007 static int talk_initctl(void) {
2008         struct init_request request;
2009         int r, fd;
2010         char rl;
2011
2012         if (!(rl = action_to_runlevel()))
2013                 return 0;
2014
2015         zero(request);
2016         request.magic = INIT_MAGIC;
2017         request.sleeptime = 0;
2018         request.cmd = INIT_CMD_RUNLVL;
2019         request.runlevel = rl;
2020
2021         if ((fd = open(INIT_FIFO, O_WRONLY|O_NDELAY|O_CLOEXEC|O_NOCTTY)) < 0) {
2022
2023                 if (errno == ENOENT)
2024                         return 0;
2025
2026                 log_error("Failed to open "INIT_FIFO": %m");
2027                 return -errno;
2028         }
2029
2030         errno = 0;
2031         r = loop_write(fd, &request, sizeof(request), false) != sizeof(request);
2032         close_nointr_nofail(fd);
2033
2034         if (r < 0) {
2035                 log_error("Failed to write to "INIT_FIFO": %m");
2036                 return errno ? -errno : -EIO;
2037         }
2038
2039         return 1;
2040 }
2041
2042 static int systemctl_main(DBusConnection *bus, int argc, char *argv[]) {
2043
2044         static const struct {
2045                 const char* verb;
2046                 const enum {
2047                         MORE,
2048                         LESS,
2049                         EQUAL
2050                 } argc_cmp;
2051                 const int argc;
2052                 int (* const dispatch)(DBusConnection *bus, char **args, unsigned n);
2053         } verbs[] = {
2054                 { "list-units",        LESS,  1, list_units      },
2055                 { "list-jobs",         EQUAL, 1, list_jobs       },
2056                 { "clear-jobs",        EQUAL, 1, clear_jobs      },
2057                 { "load",              MORE,  2, load_unit       },
2058                 { "cancel",            MORE,  2, cancel_job      },
2059                 { "start",             MORE,  2, start_unit      },
2060                 { "stop",              MORE,  2, start_unit      },
2061                 { "reload",            MORE,  2, start_unit      },
2062                 { "restart",           MORE,  2, start_unit      },
2063                 { "isolate",           EQUAL, 2, start_unit      },
2064                 { "monitor",           EQUAL, 1, monitor         },
2065                 { "dump",              EQUAL, 1, dump            },
2066                 { "snapshot",          LESS,  2, snapshot        },
2067                 { "daemon-reload",     EQUAL, 1, clear_jobs      },
2068                 { "daemon-reexec",     EQUAL, 1, clear_jobs      },
2069                 { "daemon-exit",       EQUAL, 1, clear_jobs      },
2070                 { "show-environment",  EQUAL, 1, show_enviroment },
2071                 { "set-environment",   MORE,  2, set_environment },
2072                 { "unset-environment", MORE,  2, set_environment },
2073                 { "halt",              EQUAL, 1, start_special   },
2074                 { "poweroff",          EQUAL, 1, start_special   },
2075                 { "reboot",            EQUAL, 1, start_special   },
2076                 { "default",           EQUAL, 1, start_special   },
2077                 { "rescue",            EQUAL, 1, start_special   },
2078                 { "emergency",         EQUAL, 1, start_special   },
2079         };
2080
2081         int left;
2082         unsigned i;
2083
2084         assert(bus);
2085         assert(argc >= 0);
2086         assert(argv);
2087
2088         left = argc - optind;
2089
2090         if (left <= 0)
2091                 /* Special rule: no arguments means "list-units" */
2092                 i = 0;
2093         else {
2094                 for (i = 0; i < ELEMENTSOF(verbs); i++)
2095                         if (streq(argv[optind], verbs[i].verb))
2096                                 break;
2097
2098                 if (i >= ELEMENTSOF(verbs)) {
2099                         log_error("Unknown operation %s", argv[optind]);
2100                         return -EINVAL;
2101                 }
2102         }
2103
2104         switch (verbs[i].argc_cmp) {
2105
2106         case EQUAL:
2107                 if (left != verbs[i].argc) {
2108                         log_error("Invalid number of arguments.");
2109                         return -EINVAL;
2110                 }
2111
2112                 break;
2113
2114         case MORE:
2115                 if (left < verbs[i].argc) {
2116                         log_error("Too few arguments.");
2117                         return -EINVAL;
2118                 }
2119
2120                 break;
2121
2122         case LESS:
2123                 if (left > verbs[i].argc) {
2124                         log_error("Too many arguments.");
2125                         return -EINVAL;
2126                 }
2127
2128                 break;
2129
2130         default:
2131                 assert_not_reached("Unknown comparison operator.");
2132         }
2133
2134         return verbs[i].dispatch(bus, argv + optind, left);
2135 }
2136
2137 static int reload_with_fallback(DBusConnection *bus) {
2138         int r;
2139
2140         if (bus) {
2141                 /* First, try systemd via D-Bus. */
2142                 if ((r = clear_jobs(bus, NULL, 0)) > 0)
2143                         return 0;
2144         }
2145
2146         /* Nothing else worked, so let's try signals */
2147         assert(arg_action == ACTION_RELOAD || arg_action == ACTION_REEXEC);
2148
2149         if (kill(1, arg_action == ACTION_RELOAD ? SIGHUP : SIGTERM) < 0) {
2150                 log_error("kill() failed: %m");
2151                 return -errno;
2152         }
2153
2154         return 0;
2155 }
2156
2157 static int start_with_fallback(DBusConnection *bus) {
2158         int r;
2159
2160         warn_wall(arg_action);
2161
2162         if (bus) {
2163                 /* First, try systemd via D-Bus. */
2164                 if ((r = start_unit(bus, NULL, 0)) > 0)
2165                         return 0;
2166
2167                 /* Hmm, talking to systemd via D-Bus didn't work. Then
2168                  * let's try to talk to Upstart via D-Bus. */
2169                 if ((r = talk_upstart(bus)) > 0)
2170                         return 0;
2171         }
2172
2173         /* Nothing else worked, so let's try
2174          * /dev/initctl */
2175         if ((r = talk_initctl()) != 0)
2176                 return 0;
2177
2178         log_error("Failed to talk to init daemon.");
2179         return -EIO;
2180 }
2181
2182 static int halt_main(DBusConnection *bus) {
2183         int r;
2184
2185         if (!arg_immediate)
2186                 return start_with_fallback(bus);
2187
2188         if (!arg_no_wtmp)
2189                 if ((r = utmp_put_shutdown(0)) < 0)
2190                         log_warning("Failed to write utmp record: %s", strerror(-r));
2191
2192         if (!arg_no_sync)
2193                 sync();
2194
2195         if (arg_dry)
2196                 return 0;
2197
2198         /* Make sure C-A-D is handled by the kernel from this
2199          * point on... */
2200         reboot(RB_ENABLE_CAD);
2201
2202         switch (arg_action) {
2203
2204         case ACTION_HALT:
2205                 log_info("Halting");
2206                 reboot(RB_HALT_SYSTEM);
2207                 break;
2208
2209         case ACTION_POWEROFF:
2210                 log_info("Powering off");
2211                 reboot(RB_POWER_OFF);
2212                 break;
2213
2214         case ACTION_REBOOT:
2215                 log_info("Rebooting");
2216                 reboot(RB_AUTOBOOT);
2217                 break;
2218
2219         default:
2220                 assert_not_reached("Unknown halt action.");
2221         }
2222
2223         /* We should never reach this. */
2224         return -ENOSYS;
2225 }
2226
2227 static int runlevel_main(void) {
2228         int r, runlevel, previous;
2229
2230         if ((r = utmp_get_runlevel(&runlevel, &previous)) < 0) {
2231                 printf("unknown");
2232                 return r;
2233         }
2234
2235         printf("%c %c\n",
2236                previous <= 0 ? 'N' : previous,
2237                runlevel <= 0 ? 'N' : runlevel);
2238
2239         return 0;
2240 }
2241
2242 int main(int argc, char*argv[]) {
2243         int r, retval = 1;
2244         DBusConnection *bus = NULL;
2245         DBusError error;
2246
2247         dbus_error_init(&error);
2248
2249         log_parse_environment();
2250
2251         if ((r = parse_argv(argc, argv)) < 0)
2252                 goto finish;
2253         else if (r == 0) {
2254                 retval = 0;
2255                 goto finish;
2256         }
2257
2258         /* /sbin/runlevel doesn't need to communicate via D-Bus, so
2259          * let's shortcut this */
2260         if (arg_action == ACTION_RUNLEVEL) {
2261                 retval = runlevel_main() < 0;
2262                 goto finish;
2263         }
2264
2265         if ((bus = dbus_bus_get(arg_session ? DBUS_BUS_SESSION : DBUS_BUS_SYSTEM, &error)))
2266                 dbus_connection_set_exit_on_disconnect(bus, FALSE);
2267
2268         switch (arg_action) {
2269
2270         case ACTION_SYSTEMCTL: {
2271
2272                 if (!bus) {
2273                         log_error("Failed to get D-Bus connection: %s", error.message);
2274                         goto finish;
2275                 }
2276
2277                 retval = systemctl_main(bus, argc, argv) < 0;
2278                 break;
2279         }
2280
2281         case ACTION_HALT:
2282         case ACTION_POWEROFF:
2283         case ACTION_REBOOT:
2284                 retval = halt_main(bus) < 0;
2285                 break;
2286
2287         case ACTION_RUNLEVEL2:
2288         case ACTION_RUNLEVEL3:
2289         case ACTION_RUNLEVEL4:
2290         case ACTION_RUNLEVEL5:
2291         case ACTION_RESCUE:
2292         case ACTION_EMERGENCY:
2293         case ACTION_DEFAULT:
2294                 retval = start_with_fallback(bus) < 0;
2295                 break;
2296
2297         case ACTION_RELOAD:
2298         case ACTION_REEXEC:
2299                 retval = reload_with_fallback(bus) < 0;
2300                 break;
2301
2302         case ACTION_INVALID:
2303         case ACTION_RUNLEVEL:
2304         default:
2305                 assert_not_reached("Unknown action");
2306         }
2307
2308 finish:
2309
2310         if (bus)
2311                 dbus_connection_unref(bus);
2312
2313         dbus_error_free(&error);
2314
2315         dbus_shutdown();
2316
2317         return retval;
2318 }