src/systemctl/systemctl.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <getopt.h>
   4 #include <locale.h>
   5 #include <unistd.h>
   6
   7 #include "sd-daemon.h"
   8
   9 #include "build.h"
  10 #include "bus-util.h"
  11 #include "dissect-image.h"
  12 #include "install.h"
  13 #include "main-func.h"
  14 #include "mount-util.h"
  15 #include "output-mode.h"
  16 #include "pager.h"
  17 #include "parse-argument.h"
  18 #include "path-util.h"
  19 #include "pretty-print.h"
  20 #include "process-util.h"
  21 #include "reboot-util.h"
  22 #include "rlimit-util.h"
  23 #include "sigbus.h"
  24 #include "signal-util.h"
  25 #include "stat-util.h"
  26 #include "string-table.h"
  27 #include "systemctl-add-dependency.h"
  28 #include "systemctl-cancel-job.h"
  29 #include "systemctl-clean-or-freeze.h"
  30 #include "systemctl-compat-halt.h"
  31 #include "systemctl-compat-runlevel.h"
  32 #include "systemctl-compat-shutdown.h"
  33 #include "systemctl-compat-telinit.h"
  34 #include "systemctl-daemon-reload.h"
  35 #include "systemctl-edit.h"
  36 #include "systemctl-enable.h"
  37 #include "systemctl-is-active.h"
  38 #include "systemctl-is-enabled.h"
  39 #include "systemctl-is-system-running.h"
  40 #include "systemctl-kill.h"
  41 #include "systemctl-list-dependencies.h"
  42 #include "systemctl-list-jobs.h"
  43 #include "systemctl-list-machines.h"
  44 #include "systemctl-list-unit-files.h"
  45 #include "systemctl-list-units.h"
  46 #include "systemctl-log-setting.h"
  47 #include "systemctl-logind.h"
  48 #include "systemctl-mount.h"
  49 #include "systemctl-preset-all.h"
  50 #include "systemctl-reset-failed.h"
  51 #include "systemctl-service-watchdogs.h"
  52 #include "systemctl-set-default.h"
  53 #include "systemctl-set-environment.h"
  54 #include "systemctl-set-property.h"
  55 #include "systemctl-show.h"
  56 #include "systemctl-start-special.h"
  57 #include "systemctl-start-unit.h"
  58 #include "systemctl-switch-root.h"
  59 #include "systemctl-sysv-compat.h"
  60 #include "systemctl-trivial-method.h"
  61 #include "systemctl-util.h"
  62 #include "systemctl-whoami.h"
  63 #include "systemctl.h"
  64 #include "terminal-util.h"
  65 #include "time-util.h"
  66 #include "verbs.h"
  67 #include "virt.h"
  68
  69 char **arg_types = NULL;
  70 char **arg_states = NULL;
  71 char **arg_properties = NULL;
  72 bool arg_all = false;
  73 enum dependency arg_dependency = DEPENDENCY_FORWARD;
  74 const char *_arg_job_mode = NULL;
  75 RuntimeScope arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
  76 bool arg_wait = false;
  77 bool arg_no_block = false;
  78 int arg_legend = -1; /* -1: true, unless --quiet is passed, 1: true */
  79 PagerFlags arg_pager_flags = 0;
  80 bool arg_no_wtmp = false;
  81 bool arg_no_sync = false;
  82 bool arg_no_wall = false;
  83 bool arg_no_reload = false;
  84 BusPrintPropertyFlags arg_print_flags = 0;
  85 bool arg_show_types = false;
  86 int arg_check_inhibitors = -1;
  87 bool arg_dry_run = false;
  88 bool arg_quiet = false;
  89 bool arg_no_warn = false;
  90 bool arg_full = false;
  91 bool arg_recursive = false;
  92 bool arg_with_dependencies = false;
  93 bool arg_show_transaction = false;
  94 int arg_force = 0;
  95 bool arg_ask_password = false;
  96 bool arg_runtime = false;
  97 UnitFilePresetMode arg_preset_mode = UNIT_FILE_PRESET_FULL;
  98 char **arg_wall = NULL;
  99 const char *arg_kill_whom = NULL;
 100 int arg_signal = SIGTERM;
 101 int arg_kill_value;
 102 bool arg_kill_value_set = false;
 103 char *arg_root = NULL;
 104 char *arg_image = NULL;
 105 usec_t arg_when = 0;
 106 bool arg_stdin = false;
 107 const char *arg_reboot_argument = NULL;
 108 enum action arg_action = ACTION_SYSTEMCTL;
 109 BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
 110 const char *arg_host = NULL;
 111 unsigned arg_lines = 10;
 112 OutputMode arg_output = OUTPUT_SHORT;
 113 bool arg_plain = false;
 114 bool arg_firmware_setup = false;
 115 usec_t arg_boot_loader_menu = USEC_INFINITY;
 116 const char *arg_boot_loader_entry = NULL;
 117 bool arg_now = false;
 118 bool arg_jobs_before = false;
 119 bool arg_jobs_after = false;
 120 char **arg_clean_what = NULL;
 121 TimestampStyle arg_timestamp_style = TIMESTAMP_PRETTY;
 122 bool arg_read_only = false;
 123 bool arg_mkdir = false;
 124 bool arg_marked = false;
 125 const char *arg_drop_in = NULL;
 126 ImagePolicy *arg_image_policy = NULL;
 127
 128 STATIC_DESTRUCTOR_REGISTER(arg_types, strv_freep);
 129 STATIC_DESTRUCTOR_REGISTER(arg_states, strv_freep);
 130 STATIC_DESTRUCTOR_REGISTER(arg_properties, strv_freep);
 131 STATIC_DESTRUCTOR_REGISTER(_arg_job_mode, unsetp);
 132 STATIC_DESTRUCTOR_REGISTER(arg_wall, strv_freep);
 133 STATIC_DESTRUCTOR_REGISTER(arg_kill_whom, unsetp);
 134 STATIC_DESTRUCTOR_REGISTER(arg_root, freep);
 135 STATIC_DESTRUCTOR_REGISTER(arg_image, freep);
 136 STATIC_DESTRUCTOR_REGISTER(arg_reboot_argument, unsetp);
 137 STATIC_DESTRUCTOR_REGISTER(arg_host, unsetp);
 138 STATIC_DESTRUCTOR_REGISTER(arg_boot_loader_entry, unsetp);
 139 STATIC_DESTRUCTOR_REGISTER(arg_clean_what, strv_freep);
 140 STATIC_DESTRUCTOR_REGISTER(arg_drop_in, unsetp);
 141 STATIC_DESTRUCTOR_REGISTER(arg_image_policy, image_policy_freep);
 142
 143 static int systemctl_help(void) {
 144         _cleanup_free_ char *link = NULL;
 145         int r;
 146
 147         pager_open(arg_pager_flags);
 148
 149         r = terminal_urlify_man("systemctl", "1", &link);
 150         if (r < 0)
 151                 return log_oom();
 152
 153         printf("%1$s [OPTIONS...] COMMAND ...\n\n"
 154                "%5$sQuery or send control commands to the system manager.%6$s\n"
 155                "\n%3$sUnit Commands:%4$s\n"
 156                "  list-units [PATTERN...]             List units currently in memory\n"
 157                "  list-automounts [PATTERN...]        List automount units currently in memory,\n"
 158                "                                      ordered by path\n"
 159                "  list-paths [PATTERN...]             List path units currently in memory,\n"
 160                "                                      ordered by path\n"
 161                "  list-sockets [PATTERN...]           List socket units currently in memory,\n"
 162                "                                      ordered by address\n"
 163                "  list-timers [PATTERN...]            List timer units currently in memory,\n"
 164                "                                      ordered by next elapse\n"
 165                "  is-active PATTERN...                Check whether units are active\n"
 166                "  is-failed [PATTERN...]              Check whether units are failed or\n"
 167                "                                      system is in degraded state\n"
 168                "  status [PATTERN...|PID...]          Show runtime status of one or more units\n"
 169                "  show [PATTERN...|JOB...]            Show properties of one or more\n"
 170                "                                      units/jobs or the manager\n"
 171                "  cat PATTERN...                      Show files and drop-ins of specified units\n"
 172                "  help PATTERN...|PID...              Show manual for one or more units\n"
 173                "  list-dependencies [UNIT...]         Recursively show units which are required\n"
 174                "                                      or wanted by the units or by which those\n"
 175                "                                      units are required or wanted\n"
 176                "  start UNIT...                       Start (activate) one or more units\n"
 177                "  stop UNIT...                        Stop (deactivate) one or more units\n"
 178                "  reload UNIT...                      Reload one or more units\n"
 179                "  restart UNIT...                     Start or restart one or more units\n"
 180                "  try-restart UNIT...                 Restart one or more units if active\n"
 181                "  reload-or-restart UNIT...           Reload one or more units if possible,\n"
 182                "                                      otherwise start or restart\n"
 183                "  try-reload-or-restart UNIT...       If active, reload one or more units,\n"
 184                "                                      if supported, otherwise restart\n"
 185                "  isolate UNIT                        Start one unit and stop all others\n"
 186                "  kill UNIT...                        Send signal to processes of a unit\n"
 187                "  clean UNIT...                       Clean runtime, cache, state, logs or\n"
 188                "                                      configuration of unit\n"
 189                "  freeze PATTERN...                   Freeze execution of unit processes\n"
 190                "  thaw PATTERN...                     Resume execution of a frozen unit\n"
 191                "  set-property UNIT PROPERTY=VALUE... Sets one or more properties of a unit\n"
 192                "  bind UNIT PATH [PATH]               Bind-mount a path from the host into a\n"
 193                "                                      unit's namespace\n"
 194                "  mount-image UNIT PATH [PATH [OPTS]] Mount an image from the host into a\n"
 195                "                                      unit's namespace\n"
 196                "  service-log-level SERVICE [LEVEL]   Get/set logging threshold for service\n"
 197                "  service-log-target SERVICE [TARGET] Get/set logging target for service\n"
 198                "  reset-failed [PATTERN...]           Reset failed state for all, one, or more\n"
 199                "                                      units\n"
 200                "  whoami [PID...]                     Return unit caller or specified PIDs are\n"
 201                "                                      part of\n"
 202                "\n%3$sUnit File Commands:%4$s\n"
 203                "  list-unit-files [PATTERN...]        List installed unit files\n"
 204                "  enable [UNIT...|PATH...]            Enable one or more unit files\n"
 205                "  disable UNIT...                     Disable one or more unit files\n"
 206                "  reenable UNIT...                    Reenable one or more unit files\n"
 207                "  preset UNIT...                      Enable/disable one or more unit files\n"
 208                "                                      based on preset configuration\n"
 209                "  preset-all                          Enable/disable all unit files based on\n"
 210                "                                      preset configuration\n"
 211                "  is-enabled UNIT...                  Check whether unit files are enabled\n"
 212                "  mask UNIT...                        Mask one or more units\n"
 213                "  unmask UNIT...                      Unmask one or more units\n"
 214                "  link PATH...                        Link one or more units files into\n"
 215                "                                      the search path\n"
 216                "  revert UNIT...                      Revert one or more unit files to vendor\n"
 217                "                                      version\n"
 218                "  add-wants TARGET UNIT...            Add 'Wants' dependency for the target\n"
 219                "                                      on specified one or more units\n"
 220                "  add-requires TARGET UNIT...         Add 'Requires' dependency for the target\n"
 221                "                                      on specified one or more units\n"
 222                "  edit UNIT...                        Edit one or more unit files\n"
 223                "  get-default                         Get the name of the default target\n"
 224                "  set-default TARGET                  Set the default target\n"
 225                "\n%3$sMachine Commands:%4$s\n"
 226                "  list-machines [PATTERN...]          List local containers and host\n"
 227                "\n%3$sJob Commands:%4$s\n"
 228                "  list-jobs [PATTERN...]              List jobs\n"
 229                "  cancel [JOB...]                     Cancel all, one, or more jobs\n"
 230                "\n%3$sEnvironment Commands:%4$s\n"
 231                "  show-environment                    Dump environment\n"
 232                "  set-environment VARIABLE=VALUE...   Set one or more environment variables\n"
 233                "  unset-environment VARIABLE...       Unset one or more environment variables\n"
 234                "  import-environment VARIABLE...      Import all or some environment variables\n"
 235                "\n%3$sManager State Commands:%4$s\n"
 236                "  daemon-reload                       Reload systemd manager configuration\n"
 237                "  daemon-reexec                       Reexecute systemd manager\n"
 238                "  log-level [LEVEL]                   Get/set logging threshold for manager\n"
 239                "  log-target [TARGET]                 Get/set logging target for manager\n"
 240                "  service-watchdogs [BOOL]            Get/set service watchdog state\n"
 241                "\n%3$sSystem Commands:%4$s\n"
 242                "  is-system-running                   Check whether system is fully running\n"
 243                "  default                             Enter system default mode\n"
 244                "  rescue                              Enter system rescue mode\n"
 245                "  emergency                           Enter system emergency mode\n"
 246                "  halt                                Shut down and halt the system\n"
 247                "  poweroff                            Shut down and power-off the system\n"
 248                "  reboot                              Shut down and reboot the system\n"
 249                "  kexec                               Shut down and reboot the system with kexec\n"
 250                "  soft-reboot                         Shut down and reboot userspace\n"
 251                "  exit [EXIT_CODE]                    Request user instance or container exit\n"
 252                "  switch-root [ROOT [INIT]]           Change to a different root file system\n"
 253                "  sleep                               Put the system to sleep (through one of\n"
 254                "                                      the operations below)\n"
 255                "  suspend                             Suspend the system\n"
 256                "  hibernate                           Hibernate the system\n"
 257                "  hybrid-sleep                        Hibernate and suspend the system\n"
 258                "  suspend-then-hibernate              Suspend the system, wake after a period of\n"
 259                "                                      time, and hibernate"
 260                "\n%3$sOptions:%4$s\n"
 261                "  -h --help              Show this help\n"
 262                "     --version           Show package version\n"
 263                "     --system            Connect to system manager\n"
 264                "     --user              Connect to user service manager\n"
 265                "  -H --host=[USER@]HOST  Operate on remote host\n"
 266                "  -M --machine=CONTAINER Operate on a local container\n"
 267                "  -t --type=TYPE         List units of a particular type\n"
 268                "     --state=STATE       List units with particular LOAD or SUB or ACTIVE state\n"
 269                "     --failed            Shortcut for --state=failed\n"
 270                "  -p --property=NAME     Show only properties by this name\n"
 271                "  -P NAME                Equivalent to --value --property=NAME\n"
 272                "  -a --all               Show all properties/all units currently in memory,\n"
 273                "                         including dead/empty ones. To list all units installed\n"
 274                "                         on the system, use 'list-unit-files' instead.\n"
 275                "  -l --full              Don't ellipsize unit names on output\n"
 276                "  -r --recursive         Show unit list of host and local containers\n"
 277                "     --reverse           Show reverse dependencies with 'list-dependencies'\n"
 278                "     --with-dependencies Show unit dependencies with 'status', 'cat',\n"
 279                "                         'list-units', and 'list-unit-files'.\n"
 280                "     --job-mode=MODE     Specify how to deal with already queued jobs, when\n"
 281                "                         queueing a new job\n"
 282                "  -T --show-transaction  When enqueuing a unit job, show full transaction\n"
 283                "     --show-types        When showing sockets, explicitly show their type\n"
 284                "     --value             When showing properties, only print the value\n"
 285                "     --check-inhibitors=MODE\n"
 286                "                         Whether to check inhibitors before shutting down,\n"
 287                "                         sleeping, or hibernating\n"
 288                "  -i                     Shortcut for --check-inhibitors=no\n"
 289                "     --kill-whom=WHOM    Whom to send signal to\n"
 290                "     --kill-value=INT    Signal value to enqueue\n"
 291                "  -s --signal=SIGNAL     Which signal to send\n"
 292                "     --what=RESOURCES    Which types of resources to remove\n"
 293                "     --now               Start or stop unit after enabling or disabling it\n"
 294                "     --dry-run           Only print what would be done\n"
 295                "                         Currently supported by verbs: halt, poweroff, reboot,\n"
 296                "                             kexec, soft-reboot, suspend, hibernate, \n"
 297                "                             suspend-then-hibernate, hybrid-sleep, default,\n"
 298                "                             rescue, emergency, and exit.\n"
 299                "  -q --quiet             Suppress output\n"
 300                "     --no-warn           Suppress several warnings shown by default\n"
 301                "     --wait              For (re)start, wait until service stopped again\n"
 302                "                         For is-system-running, wait until startup is completed\n"
 303                "     --no-block          Do not wait until operation finished\n"
 304                "     --no-wall           Don't send wall message before halt/power-off/reboot\n"
 305                "     --no-reload         Don't reload daemon after en-/dis-abling unit files\n"
 306                "     --legend=BOOL       Enable/disable the legend (column headers and hints)\n"
 307                "     --no-pager          Do not pipe output into a pager\n"
 308                "     --no-ask-password   Do not ask for system passwords\n"
 309                "     --global            Edit/enable/disable/mask default user unit files\n"
 310                "                         globally\n"
 311                "     --runtime           Edit/enable/disable/mask unit files temporarily until\n"
 312                "                         next reboot\n"
 313                "  -f --force             When enabling unit files, override existing symlinks\n"
 314                "                         When shutting down, execute action immediately\n"
 315                "     --preset-mode=      Apply only enable, only disable, or all presets\n"
 316                "     --root=PATH         Edit/enable/disable/mask unit files in the specified\n"
 317                "                         root directory\n"
 318                "     --image=PATH        Edit/enable/disable/mask unit files in the specified\n"
 319                "                         disk image\n"
 320                "     --image-policy=POLICY\n"
 321                "                         Specify disk image dissection policy\n"
 322                "  -n --lines=INTEGER     Number of journal entries to show\n"
 323                "  -o --output=STRING     Change journal output mode (short, short-precise,\n"
 324                "                             short-iso, short-iso-precise, short-full,\n"
 325                "                             short-monotonic, short-unix, short-delta,\n"
 326                "                             verbose, export, json, json-pretty, json-sse, cat)\n"
 327                "     --firmware-setup    Tell the firmware to show the setup menu on next boot\n"
 328                "     --boot-loader-menu=TIME\n"
 329                "                         Boot into boot loader menu on next boot\n"
 330                "     --boot-loader-entry=NAME\n"
 331                "                         Boot into a specific boot loader entry on next boot\n"
 332                "     --plain             Print unit dependencies as a list instead of a tree\n"
 333                "     --timestamp=FORMAT  Change format of printed timestamps (pretty, unix,\n"
 334                "                             us, utc, us+utc)\n"
 335                "     --read-only         Create read-only bind mount\n"
 336                "     --mkdir             Create directory before mounting, if missing\n"
 337                "     --marked            Restart/reload previously marked units\n"
 338                "     --drop-in=NAME      Edit unit files using the specified drop-in file name\n"
 339                "     --when=TIME         Schedule halt/power-off/reboot/kexec action after\n"
 340                "                         a certain timestamp\n"
 341                "     --stdin             Read contents of edited file from stdin\n"
 342                "\nSee the %2$s for details.\n",
 343                program_invocation_short_name,
 344                link,
 345                ansi_underline(),
 346                ansi_normal(),
 347                ansi_highlight(),
 348                ansi_normal());
 349
 350         return 0;
 351 }
 352
 353 static void help_types(void) {
 354         if (arg_legend != 0)
 355                 puts("Available unit types:");
 356
 357         DUMP_STRING_TABLE(unit_type, UnitType, _UNIT_TYPE_MAX);
 358 }
 359
 360 static void help_states(void) {
 361         if (arg_legend != 0)
 362                 puts("Available unit load states:");
 363         DUMP_STRING_TABLE(unit_load_state, UnitLoadState, _UNIT_LOAD_STATE_MAX);
 364
 365         if (arg_legend != 0)
 366                 puts("\nAvailable unit active states:");
 367         DUMP_STRING_TABLE(unit_active_state, UnitActiveState, _UNIT_ACTIVE_STATE_MAX);
 368
 369         if (arg_legend != 0)
 370                 puts("\nAvailable unit file states:");
 371         DUMP_STRING_TABLE(unit_file_state, UnitFileState, _UNIT_FILE_STATE_MAX);
 372
 373         if (arg_legend != 0)
 374                 puts("\nAvailable automount unit substates:");
 375         DUMP_STRING_TABLE(automount_state, AutomountState, _AUTOMOUNT_STATE_MAX);
 376
 377         if (arg_legend != 0)
 378                 puts("\nAvailable device unit substates:");
 379         DUMP_STRING_TABLE(device_state, DeviceState, _DEVICE_STATE_MAX);
 380
 381         if (arg_legend != 0)
 382                 puts("\nAvailable mount unit substates:");
 383         DUMP_STRING_TABLE(mount_state, MountState, _MOUNT_STATE_MAX);
 384
 385         if (arg_legend != 0)
 386                 puts("\nAvailable path unit substates:");
 387         DUMP_STRING_TABLE(path_state, PathState, _PATH_STATE_MAX);
 388
 389         if (arg_legend != 0)
 390                 puts("\nAvailable scope unit substates:");
 391         DUMP_STRING_TABLE(scope_state, ScopeState, _SCOPE_STATE_MAX);
 392
 393         if (arg_legend != 0)
 394                 puts("\nAvailable service unit substates:");
 395         DUMP_STRING_TABLE(service_state, ServiceState, _SERVICE_STATE_MAX);
 396
 397         if (arg_legend != 0)
 398                 puts("\nAvailable slice unit substates:");
 399         DUMP_STRING_TABLE(slice_state, SliceState, _SLICE_STATE_MAX);
 400
 401         if (arg_legend != 0)
 402                 puts("\nAvailable socket unit substates:");
 403         DUMP_STRING_TABLE(socket_state, SocketState, _SOCKET_STATE_MAX);
 404
 405         if (arg_legend != 0)
 406                 puts("\nAvailable swap unit substates:");
 407         DUMP_STRING_TABLE(swap_state, SwapState, _SWAP_STATE_MAX);
 408
 409         if (arg_legend != 0)
 410                 puts("\nAvailable target unit substates:");
 411         DUMP_STRING_TABLE(target_state, TargetState, _TARGET_STATE_MAX);
 412
 413         if (arg_legend != 0)
 414                 puts("\nAvailable timer unit substates:");
 415         DUMP_STRING_TABLE(timer_state, TimerState, _TIMER_STATE_MAX);
 416 }
 417
 418 static int systemctl_parse_argv(int argc, char *argv[]) {
 419         enum {
 420                 ARG_FAIL = 0x100,            /* compatibility only */
 421                 ARG_REVERSE,
 422                 ARG_AFTER,
 423                 ARG_BEFORE,
 424                 ARG_CHECK_INHIBITORS,
 425                 ARG_DRY_RUN,
 426                 ARG_SHOW_TYPES,
 427                 ARG_IRREVERSIBLE,            /* compatibility only */
 428                 ARG_IGNORE_DEPENDENCIES,     /* compatibility only */
 429                 ARG_VALUE,
 430                 ARG_VERSION,
 431                 ARG_USER,
 432                 ARG_SYSTEM,
 433                 ARG_GLOBAL,
 434                 ARG_NO_BLOCK,
 435                 ARG_LEGEND,
 436                 ARG_NO_LEGEND,                /* compatibility only */
 437                 ARG_NO_PAGER,
 438                 ARG_NO_WALL,
 439                 ARG_ROOT,
 440                 ARG_IMAGE,
 441                 ARG_IMAGE_POLICY,
 442                 ARG_NO_RELOAD,
 443                 ARG_KILL_WHOM,
 444                 ARG_KILL_VALUE,
 445                 ARG_NO_ASK_PASSWORD,
 446                 ARG_FAILED,
 447                 ARG_RUNTIME,
 448                 ARG_PLAIN,
 449                 ARG_STATE,
 450                 ARG_JOB_MODE,
 451                 ARG_PRESET_MODE,
 452                 ARG_FIRMWARE_SETUP,
 453                 ARG_BOOT_LOADER_MENU,
 454                 ARG_BOOT_LOADER_ENTRY,
 455                 ARG_NOW,
 456                 ARG_MESSAGE,
 457                 ARG_WITH_DEPENDENCIES,
 458                 ARG_WAIT,
 459                 ARG_WHAT,
 460                 ARG_REBOOT_ARG,
 461                 ARG_TIMESTAMP_STYLE,
 462                 ARG_READ_ONLY,
 463                 ARG_MKDIR,
 464                 ARG_MARKED,
 465                 ARG_NO_WARN,
 466                 ARG_DROP_IN,
 467                 ARG_WHEN,
 468                 ARG_STDIN,
 469         };
 470
 471         static const struct option options[] = {
 472                 { "help",                no_argument,       NULL, 'h'                     },
 473                 { "version",             no_argument,       NULL, ARG_VERSION             },
 474                 { "type",                required_argument, NULL, 't'                     },
 475                 { "property",            required_argument, NULL, 'p'                     },
 476                 { "all",                 no_argument,       NULL, 'a'                     },
 477                 { "reverse",             no_argument,       NULL, ARG_REVERSE             },
 478                 { "after",               no_argument,       NULL, ARG_AFTER               },
 479                 { "before",              no_argument,       NULL, ARG_BEFORE              },
 480                 { "show-types",          no_argument,       NULL, ARG_SHOW_TYPES          },
 481                 { "failed",              no_argument,       NULL, ARG_FAILED              },
 482                 { "full",                no_argument,       NULL, 'l'                     },
 483                 { "job-mode",            required_argument, NULL, ARG_JOB_MODE            },
 484                 { "fail",                no_argument,       NULL, ARG_FAIL                }, /* compatibility only */
 485                 { "irreversible",        no_argument,       NULL, ARG_IRREVERSIBLE        }, /* compatibility only */
 486                 { "ignore-dependencies", no_argument,       NULL, ARG_IGNORE_DEPENDENCIES }, /* compatibility only */
 487                 { "ignore-inhibitors",   no_argument,       NULL, 'i'                     }, /* compatibility only */
 488                 { "check-inhibitors",    required_argument, NULL, ARG_CHECK_INHIBITORS    },
 489                 { "value",               no_argument,       NULL, ARG_VALUE               },
 490                 { "user",                no_argument,       NULL, ARG_USER                },
 491                 { "system",              no_argument,       NULL, ARG_SYSTEM              },
 492                 { "global",              no_argument,       NULL, ARG_GLOBAL              },
 493                 { "wait",                no_argument,       NULL, ARG_WAIT                },
 494                 { "no-block",            no_argument,       NULL, ARG_NO_BLOCK            },
 495                 { "legend",              required_argument, NULL, ARG_LEGEND              },
 496                 { "no-legend",           no_argument,       NULL, ARG_NO_LEGEND           }, /* compatibility only */
 497                 { "no-pager",            no_argument,       NULL, ARG_NO_PAGER            },
 498                 { "no-wall",             no_argument,       NULL, ARG_NO_WALL             },
 499                 { "dry-run",             no_argument,       NULL, ARG_DRY_RUN             },
 500                 { "quiet",               no_argument,       NULL, 'q'                     },
 501                 { "no-warn",             no_argument,       NULL, ARG_NO_WARN             },
 502                 { "root",                required_argument, NULL, ARG_ROOT                },
 503                 { "image",               required_argument, NULL, ARG_IMAGE               },
 504                 { "image-policy",        required_argument, NULL, ARG_IMAGE_POLICY        },
 505                 { "force",               no_argument,       NULL, 'f'                     },
 506                 { "no-reload",           no_argument,       NULL, ARG_NO_RELOAD           },
 507                 { "kill-whom",           required_argument, NULL, ARG_KILL_WHOM           },
 508                 { "kill-value",          required_argument, NULL, ARG_KILL_VALUE          },
 509                 { "signal",              required_argument, NULL, 's'                     },
 510                 { "no-ask-password",     no_argument,       NULL, ARG_NO_ASK_PASSWORD     },
 511                 { "host",                required_argument, NULL, 'H'                     },
 512                 { "machine",             required_argument, NULL, 'M'                     },
 513                 { "runtime",             no_argument,       NULL, ARG_RUNTIME             },
 514                 { "lines",               required_argument, NULL, 'n'                     },
 515                 { "output",              required_argument, NULL, 'o'                     },
 516                 { "plain",               no_argument,       NULL, ARG_PLAIN               },
 517                 { "state",               required_argument, NULL, ARG_STATE               },
 518                 { "recursive",           no_argument,       NULL, 'r'                     },
 519                 { "with-dependencies",   no_argument,       NULL, ARG_WITH_DEPENDENCIES   },
 520                 { "preset-mode",         required_argument, NULL, ARG_PRESET_MODE         },
 521                 { "firmware-setup",      no_argument,       NULL, ARG_FIRMWARE_SETUP      },
 522                 { "boot-loader-menu",    required_argument, NULL, ARG_BOOT_LOADER_MENU    },
 523                 { "boot-loader-entry",   required_argument, NULL, ARG_BOOT_LOADER_ENTRY   },
 524                 { "now",                 no_argument,       NULL, ARG_NOW                 },
 525                 { "message",             required_argument, NULL, ARG_MESSAGE             },
 526                 { "show-transaction",    no_argument,       NULL, 'T'                     },
 527                 { "what",                required_argument, NULL, ARG_WHAT                },
 528                 { "reboot-argument",     required_argument, NULL, ARG_REBOOT_ARG          },
 529                 { "timestamp",           required_argument, NULL, ARG_TIMESTAMP_STYLE     },
 530                 { "read-only",           no_argument,       NULL, ARG_READ_ONLY           },
 531                 { "mkdir",               no_argument,       NULL, ARG_MKDIR               },
 532                 { "marked",              no_argument,       NULL, ARG_MARKED              },
 533                 { "drop-in",             required_argument, NULL, ARG_DROP_IN             },
 534                 { "when",                required_argument, NULL, ARG_WHEN                },
 535                 { "stdin",               no_argument,       NULL, ARG_STDIN               },
 536                 {}
 537         };
 538
 539         int c, r;
 540
 541         assert(argc >= 0);
 542         assert(argv);
 543
 544         /* We default to allowing interactive authorization only in systemctl (not in the legacy commands) */
 545         arg_ask_password = true;
 546
 547         while ((c = getopt_long(argc, argv, "ht:p:P:alqfs:H:M:n:o:iTr.::", options, NULL)) >= 0)
 548
 549                 switch (c) {
 550
 551                 case 'h':
 552                         return systemctl_help();
 553
 554                 case ARG_VERSION:
 555                         return version();
 556
 557                 case 't':
 558                         if (isempty(optarg))
 559                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 560                                                        "--type= requires arguments.");
 561
 562                         for (const char *p = optarg;;) {
 563                                 _cleanup_free_ char *type = NULL;
 564
 565                                 r = extract_first_word(&p, &type, ",", 0);
 566                                 if (r < 0)
 567                                         return log_error_errno(r, "Failed to parse type: %s", optarg);
 568                                 if (r == 0)
 569                                         break;
 570
 571                                 if (streq(type, "help")) {
 572                                         help_types();
 573                                         return 0;
 574                                 }
 575
 576                                 if (unit_type_from_string(type) >= 0) {
 577                                         if (strv_consume(&arg_types, TAKE_PTR(type)) < 0)
 578                                                 return log_oom();
 579                                         continue;
 580                                 }
 581
 582                                 /* It's much nicer to use --state= for load states, but let's support this in
 583                                  * --types= too for compatibility with old versions */
 584                                 if (unit_load_state_from_string(type) >= 0) {
 585                                         if (strv_consume(&arg_states, TAKE_PTR(type)) < 0)
 586                                                 return log_oom();
 587                                         continue;
 588                                 }
 589
 590                                 log_error("Unknown unit type or load state '%s'.", type);
 591                                 return log_info_errno(SYNTHETIC_ERRNO(EINVAL),
 592                                                       "Use -t help to see a list of allowed values.");
 593                         }
 594
 595                         break;
 596
 597                 case 'P':
 598                         SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
 599                         _fallthrough_;
 600
 601                 case 'p':
 602                         /* Make sure that if the empty property list was specified, we won't show any
 603                            properties. */
 604                         if (isempty(optarg) && !arg_properties) {
 605                                 arg_properties = new0(char*, 1);
 606                                 if (!arg_properties)
 607                                         return log_oom();
 608                         } else
 609                                 for (const char *p = optarg;;) {
 610                                         _cleanup_free_ char *prop = NULL;
 611
 612                                         r = extract_first_word(&p, &prop, ",", 0);
 613                                         if (r < 0)
 614                                                 return log_error_errno(r, "Failed to parse property: %s", optarg);
 615                                         if (r == 0)
 616                                                 break;
 617
 618                                         if (strv_consume(&arg_properties, TAKE_PTR(prop)) < 0)
 619                                                 return log_oom();
 620                                 }
 621
 622                         /* If the user asked for a particular property, show it, even if it is empty. */
 623                         SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
 624
 625                         break;
 626
 627                 case 'a':
 628                         SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
 629                         arg_all = true;
 630                         break;
 631
 632                 case ARG_REVERSE:
 633                         arg_dependency = DEPENDENCY_REVERSE;
 634                         break;
 635
 636                 case ARG_AFTER:
 637                         arg_dependency = DEPENDENCY_AFTER;
 638                         arg_jobs_after = true;
 639                         break;
 640
 641                 case ARG_BEFORE:
 642                         arg_dependency = DEPENDENCY_BEFORE;
 643                         arg_jobs_before = true;
 644                         break;
 645
 646                 case ARG_SHOW_TYPES:
 647                         arg_show_types = true;
 648                         break;
 649
 650                 case ARG_VALUE:
 651                         SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
 652                         break;
 653
 654                 case ARG_JOB_MODE:
 655                         _arg_job_mode = optarg;
 656                         break;
 657
 658                 case ARG_FAIL:
 659                         _arg_job_mode = "fail";
 660                         break;
 661
 662                 case ARG_IRREVERSIBLE:
 663                         _arg_job_mode = "replace-irreversibly";
 664                         break;
 665
 666                 case ARG_IGNORE_DEPENDENCIES:
 667                         _arg_job_mode = "ignore-dependencies";
 668                         break;
 669
 670                 case ARG_USER:
 671                         arg_runtime_scope = RUNTIME_SCOPE_USER;
 672                         break;
 673
 674                 case ARG_SYSTEM:
 675                         arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
 676                         break;
 677
 678                 case ARG_GLOBAL:
 679                         arg_runtime_scope = RUNTIME_SCOPE_GLOBAL;
 680                         break;
 681
 682                 case ARG_WAIT:
 683                         arg_wait = true;
 684                         break;
 685
 686                 case ARG_NO_BLOCK:
 687                         arg_no_block = true;
 688                         break;
 689
 690                 case ARG_NO_LEGEND:
 691                         arg_legend = false;
 692                         break;
 693
 694                 case ARG_LEGEND:
 695                         r = parse_boolean_argument("--legend", optarg, NULL);
 696                         if (r < 0)
 697                                 return r;
 698                         arg_legend = r;
 699                         break;
 700
 701                 case ARG_NO_PAGER:
 702                         arg_pager_flags |= PAGER_DISABLE;
 703                         break;
 704
 705                 case ARG_NO_WALL:
 706                         arg_no_wall = true;
 707                         break;
 708
 709                 case ARG_ROOT:
 710                         r = parse_path_argument(optarg, false, &arg_root);
 711                         if (r < 0)
 712                                 return r;
 713                         break;
 714
 715                 case ARG_IMAGE:
 716                         r = parse_path_argument(optarg, false, &arg_image);
 717                         if (r < 0)
 718                                 return r;
 719                         break;
 720
 721                 case ARG_IMAGE_POLICY:
 722                         r = parse_image_policy_argument(optarg, &arg_image_policy);
 723                         if (r < 0)
 724                                 return r;
 725                         break;
 726
 727                 case 'l':
 728                         arg_full = true;
 729                         break;
 730
 731                 case ARG_FAILED:
 732                         if (strv_extend(&arg_states, "failed") < 0)
 733                                 return log_oom();
 734
 735                         break;
 736
 737                 case ARG_DRY_RUN:
 738                         arg_dry_run = true;
 739                         break;
 740
 741                 case 'q':
 742                         arg_quiet = true;
 743
 744                         if (arg_legend < 0)
 745                                 arg_legend = false;
 746
 747                         break;
 748
 749                 case 'f':
 750                         arg_force++;
 751                         break;
 752
 753                 case ARG_NO_RELOAD:
 754                         arg_no_reload = true;
 755                         break;
 756
 757                 case ARG_KILL_WHOM:
 758                         arg_kill_whom = optarg;
 759                         break;
 760
 761                 case ARG_KILL_VALUE: {
 762                         unsigned u;
 763
 764                         if (isempty(optarg)) {
 765                                 arg_kill_value_set = false;
 766                                 return 0;
 767                         }
 768
 769                         /* First, try to parse unsigned, so that we can support the prefixes 0x, 0o, 0b */
 770                         r = safe_atou_full(optarg, 0, &u);
 771                         if (r < 0)
 772                                 /* If this didn't work, try as signed integer, without those prefixes */
 773                                 r = safe_atoi(optarg, &arg_kill_value);
 774                         else if (u > INT_MAX)
 775                                 r = -ERANGE;
 776                         else
 777                                 arg_kill_value = (int) u;
 778                         if (r < 0)
 779                                 return log_error_errno(r, "Unable to parse signal queue value: %s", optarg);
 780
 781                         arg_kill_value_set = true;
 782                         break;
 783                 }
 784
 785                 case 's':
 786                         r = parse_signal_argument(optarg, &arg_signal);
 787                         if (r <= 0)
 788                                 return r;
 789                         break;
 790
 791                 case ARG_NO_ASK_PASSWORD:
 792                         arg_ask_password = false;
 793                         break;
 794
 795                 case 'H':
 796                         arg_transport = BUS_TRANSPORT_REMOTE;
 797                         arg_host = optarg;
 798                         break;
 799
 800                 case 'M':
 801                         arg_transport = BUS_TRANSPORT_MACHINE;
 802                         arg_host = optarg;
 803                         break;
 804
 805                 case ARG_RUNTIME:
 806                         arg_runtime = true;
 807                         break;
 808
 809                 case 'n':
 810                         if (safe_atou(optarg, &arg_lines) < 0)
 811                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 812                                                        "Failed to parse lines '%s'",
 813                                                        optarg);
 814                         break;
 815
 816                 case 'o':
 817                         if (streq(optarg, "help")) {
 818                                 DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);
 819                                 return 0;
 820                         }
 821
 822                         arg_output = output_mode_from_string(optarg);
 823                         if (arg_output < 0)
 824                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 825                                                        "Unknown output '%s'.",
 826                                                        optarg);
 827
 828                         if (OUTPUT_MODE_IS_JSON(arg_output)) {
 829                                 arg_legend = false;
 830                                 arg_plain = true;
 831                         }
 832                         break;
 833
 834                 case 'i':
 835                         arg_check_inhibitors = 0;
 836                         break;
 837
 838                 case ARG_CHECK_INHIBITORS:
 839                         r = parse_tristate_full(optarg, "auto", &arg_check_inhibitors);
 840                         if (r < 0)
 841                                 return log_error_errno(r, "Failed to parse --check-inhibitors= argument: %s", optarg);
 842                         break;
 843
 844                 case ARG_PLAIN:
 845                         arg_plain = true;
 846                         break;
 847
 848                 case ARG_FIRMWARE_SETUP:
 849                         arg_firmware_setup = true;
 850                         break;
 851
 852                 case ARG_BOOT_LOADER_MENU:
 853
 854                         r = parse_sec(optarg, &arg_boot_loader_menu);
 855                         if (r < 0)
 856                                 return log_error_errno(r, "Failed to parse --boot-loader-menu= argument '%s': %m", optarg);
 857
 858                         break;
 859
 860                 case ARG_BOOT_LOADER_ENTRY:
 861
 862                         if (streq(optarg, "help")) { /* Yes, this means, "help" is not a valid boot loader entry name we can deal with */
 863                                 r = help_boot_loader_entry();
 864                                 if (r < 0)
 865                                         return r;
 866
 867                                 return 0;
 868                         }
 869
 870                         arg_boot_loader_entry = empty_to_null(optarg);
 871                         break;
 872
 873                 case ARG_STATE:
 874                         if (isempty(optarg))
 875                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 876                                                        "--state= requires arguments.");
 877
 878                         for (const char *p = optarg;;) {
 879                                 _cleanup_free_ char *s = NULL;
 880
 881                                 r = extract_first_word(&p, &s, ",", 0);
 882                                 if (r < 0)
 883                                         return log_error_errno(r, "Failed to parse state: %s", optarg);
 884                                 if (r == 0)
 885                                         break;
 886
 887                                 if (streq(s, "help")) {
 888                                         help_states();
 889                                         return 0;
 890                                 }
 891
 892                                 if (strv_consume(&arg_states, TAKE_PTR(s)) < 0)
 893                                         return log_oom();
 894                         }
 895                         break;
 896
 897                 case 'r':
 898                         if (geteuid() != 0)
 899                                 return log_error_errno(SYNTHETIC_ERRNO(EPERM),
 900                                                        "--recursive requires root privileges.");
 901
 902                         arg_recursive = true;
 903                         break;
 904
 905                 case ARG_PRESET_MODE:
 906                         if (streq(optarg, "help")) {
 907                                 DUMP_STRING_TABLE(unit_file_preset_mode, UnitFilePresetMode, _UNIT_FILE_PRESET_MODE_MAX);
 908                                 return 0;
 909                         }
 910
 911                         arg_preset_mode = unit_file_preset_mode_from_string(optarg);
 912                         if (arg_preset_mode < 0)
 913                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 914                                                        "Failed to parse preset mode: %s.", optarg);
 915
 916                         break;
 917
 918                 case ARG_NOW:
 919                         arg_now = true;
 920                         break;
 921
 922                 case ARG_MESSAGE:
 923                         if (strv_extend(&arg_wall, optarg) < 0)
 924                                 return log_oom();
 925                         break;
 926
 927                 case 'T':
 928                         arg_show_transaction = true;
 929                         break;
 930
 931                 case ARG_WITH_DEPENDENCIES:
 932                         arg_with_dependencies = true;
 933                         break;
 934
 935                 case ARG_WHAT:
 936                         if (isempty(optarg))
 937                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--what= requires arguments.");
 938
 939                         for (const char *p = optarg;;) {
 940                                 _cleanup_free_ char *k = NULL;
 941
 942                                 r = extract_first_word(&p, &k, ",", 0);
 943                                 if (r < 0)
 944                                         return log_error_errno(r, "Failed to parse directory type: %s", optarg);
 945                                 if (r == 0)
 946                                         break;
 947
 948                                 if (streq(k, "help")) {
 949                                         puts("runtime\n"
 950                                              "state\n"
 951                                              "cache\n"
 952                                              "logs\n"
 953                                              "configuration\n"
 954                                              "fdstore");
 955                                         return 0;
 956                                 }
 957
 958                                 r = strv_consume(&arg_clean_what, TAKE_PTR(k));
 959                                 if (r < 0)
 960                                         return log_oom();
 961                         }
 962
 963                         break;
 964
 965                 case ARG_REBOOT_ARG:
 966                         arg_reboot_argument = optarg;
 967                         break;
 968
 969                 case ARG_TIMESTAMP_STYLE:
 970                         if (streq(optarg, "help")) {
 971                                 DUMP_STRING_TABLE(timestamp_style, TimestampStyle, _TIMESTAMP_STYLE_MAX);
 972                                 return 0;
 973                         }
 974
 975                         arg_timestamp_style = timestamp_style_from_string(optarg);
 976                         if (arg_timestamp_style < 0)
 977                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
 978                                                        "Invalid value: %s.", optarg);
 979
 980                         break;
 981
 982                 case ARG_READ_ONLY:
 983                         arg_read_only = true;
 984                         break;
 985
 986                 case ARG_MKDIR:
 987                         arg_mkdir = true;
 988                         break;
 989
 990                 case ARG_MARKED:
 991                         arg_marked = true;
 992                         break;
 993
 994                 case ARG_NO_WARN:
 995                         arg_no_warn = true;
 996                         break;
 997
 998                 case ARG_DROP_IN:
 999                         arg_drop_in = optarg;
1000                         break;
1001
1002                 case ARG_WHEN:
1003                         if (streq(optarg, "show")) {
1004                                 r = logind_show_shutdown();
1005                                 if (r < 0 && r != -ENODATA)
1006                                         return r;
1007
1008                                 return 0;
1009                         }
1010
1011                         if (STR_IN_SET(optarg, "", "cancel")) {
1012                                 arg_when = USEC_INFINITY;
1013                                 break;
1014                         }
1015
1016                         r = parse_timestamp(optarg, &arg_when);
1017                         if (r < 0)
1018                                 return log_error_errno(r, "Failed to parse --when= argument '%s': %m", optarg);
1019
1020                         if (!timestamp_is_set(arg_when))
1021                                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1022                                                        "Invalid timestamp '%s' specified for --when=.", optarg);
1023
1024                         break;
1025
1026                 case ARG_STDIN:
1027                         arg_stdin = true;
1028                         break;
1029
1030                 case '.':
1031                         /* Output an error mimicking getopt, and print a hint afterwards */
1032                         log_error("%s: invalid option -- '.'", program_invocation_name);
1033                         log_notice("Hint: to specify units starting with a dash, use \"--\":\n"
1034                                    "      %s [OPTIONS...] COMMAND -- -.%s ...",
1035                                    program_invocation_name, optarg ?: "mount");
1036                         _fallthrough_;
1037
1038                 case '?':
1039                         return -EINVAL;
1040
1041                 default:
1042                         assert_not_reached();
1043                 }
1044
1045         /* If we are in --user mode, there's no point in talking to PolicyKit or the infra to query system
1046          * passwords */
1047         if (arg_runtime_scope != RUNTIME_SCOPE_SYSTEM)
1048                 arg_ask_password = false;
1049
1050         if (arg_transport == BUS_TRANSPORT_REMOTE && arg_runtime_scope != RUNTIME_SCOPE_SYSTEM)
1051                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1052                                        "Cannot access user instance remotely.");
1053
1054         if (arg_wait && arg_no_block)
1055                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1056                                        "--wait may not be combined with --no-block.");
1057
1058         bool do_reload_or_restart = streq_ptr(argv[optind], "reload-or-restart");
1059         if (arg_marked) {
1060                 if (!do_reload_or_restart)
1061                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1062                                                "--marked may only be used with 'reload-or-restart'.");
1063                 if (optind + 1 < argc)
1064                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1065                                                "No additional arguments allowed with 'reload-or-restart --marked'.");
1066                 if (arg_wait)
1067                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1068                                                "--marked --wait is not supported.");
1069                 if (arg_show_transaction)
1070                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1071                                                "--marked --show-transaction is not supported.");
1072
1073         } else if (do_reload_or_restart) {
1074                 if (optind + 1 >= argc)
1075                         return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1076                                                "List of units to restart/reload is required.");
1077         }
1078
1079         if (arg_image && arg_root)
1080                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1081                                        "Please specify either --root= or --image=, the combination of both is not supported.");
1082
1083         return 1;
1084 }
1085
1086 int systemctl_dispatch_parse_argv(int argc, char *argv[]) {
1087         assert(argc >= 0);
1088         assert(argv);
1089
1090         if (invoked_as(argv, "halt")) {
1091                 arg_action = ACTION_HALT;
1092                 return halt_parse_argv(argc, argv);
1093
1094         } else if (invoked_as(argv, "poweroff")) {
1095                 arg_action = ACTION_POWEROFF;
1096                 return halt_parse_argv(argc, argv);
1097
1098         } else if (invoked_as(argv, "reboot")) {
1099                 arg_action = ACTION_REBOOT;
1100                 return halt_parse_argv(argc, argv);
1101
1102         } else if (invoked_as(argv, "shutdown")) {
1103                 arg_action = ACTION_POWEROFF;
1104                 return shutdown_parse_argv(argc, argv);
1105
1106         } else if (invoked_as(argv, "init")) {
1107
1108                 /* Matches invocations as "init" as well as "telinit", which are synonymous when run
1109                  * as PID != 1 on SysV.
1110                  *
1111                  * On SysV "telinit" was the official command to communicate with PID 1, but "init" would
1112                  * redirect itself to "telinit" if called with PID != 1. We follow the same logic here still,
1113                  * though we add one level of indirection, as we implement "telinit" in "systemctl". Hence,
1114                  * for us if you invoke "init" you get "systemd", but it will execve() "systemctl"
1115                  * immediately with argv[] unmodified if PID is != 1. If you invoke "telinit" you directly
1116                  * get "systemctl". In both cases we shall do the same thing, which is why we do
1117                  * invoked_as(argv, "init") here, as a quick way to match both.
1118                  *
1119                  * Also see redirect_telinit() in src/core/main.c. */
1120
1121                 arg_action = _ACTION_INVALID; /* telinit_parse_argv() will figure out the actual action we'll execute */
1122                 return telinit_parse_argv(argc, argv);
1123
1124         } else if (invoked_as(argv, "runlevel")) {
1125                 arg_action = ACTION_RUNLEVEL;
1126                 return runlevel_parse_argv(argc, argv);
1127         }
1128
1129         arg_action = ACTION_SYSTEMCTL;
1130         return systemctl_parse_argv(argc, argv);
1131 }
1132
1133 #ifndef FUZZ_SYSTEMCTL_PARSE_ARGV
1134 static int systemctl_main(int argc, char *argv[]) {
1135         static const Verb verbs[] = {
1136                 { "list-units",            VERB_ANY, VERB_ANY, VERB_DEFAULT|VERB_ONLINE_ONLY, verb_list_units },
1137                 { "list-unit-files",       VERB_ANY, VERB_ANY, 0,                verb_list_unit_files         },
1138                 { "list-automounts",       VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_automounts         },
1139                 { "list-paths",            VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_paths              },
1140                 { "list-sockets",          VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_sockets            },
1141                 { "list-timers",           VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_timers             },
1142                 { "list-jobs",             VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_jobs               },
1143                 { "list-machines",         VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_machines           },
1144                 { "clear-jobs",            VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_trivial_method          },
1145                 { "cancel",                VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_cancel                  },
1146                 { "start",                 2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1147                 { "stop",                  2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1148                 { "condstop",              2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   }, /* For compatibility with ALTLinux */
1149                 { "reload",                2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1150                 { "restart",               2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1151                 { "try-restart",           2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1152                 { "reload-or-restart",     VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1153                 { "reload-or-try-restart", 2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   }, /* For compatibility with old systemctl <= 228 */
1154                 { "try-reload-or-restart", 2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   },
1155                 { "force-reload",          2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   }, /* For compatibility with SysV */
1156                 { "condreload",            2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   }, /* For compatibility with ALTLinux */
1157                 { "condrestart",           2,        VERB_ANY, VERB_ONLINE_ONLY, verb_start                   }, /* For compatibility with RH */
1158                 { "isolate",               2,        2,        VERB_ONLINE_ONLY, verb_start                   },
1159                 { "kill",                  2,        VERB_ANY, VERB_ONLINE_ONLY, verb_kill                    },
1160                 { "clean",                 2,        VERB_ANY, VERB_ONLINE_ONLY, verb_clean_or_freeze         },
1161                 { "freeze",                2,        VERB_ANY, VERB_ONLINE_ONLY, verb_clean_or_freeze         },
1162                 { "thaw",                  2,        VERB_ANY, VERB_ONLINE_ONLY, verb_clean_or_freeze         },
1163                 { "is-active",             2,        VERB_ANY, VERB_ONLINE_ONLY, verb_is_active               },
1164                 { "check",                 2,        VERB_ANY, VERB_ONLINE_ONLY, verb_is_active               }, /* deprecated alias of is-active */
1165                 { "is-failed",             VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_is_failed               },
1166                 { "show",                  VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_show                    },
1167                 { "cat",                   2,        VERB_ANY, VERB_ONLINE_ONLY, verb_cat                     },
1168                 { "status",                VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_show                    },
1169                 { "help",                  VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_show                    },
1170                 { "daemon-reload",         1,        1,        VERB_ONLINE_ONLY, verb_daemon_reload           },
1171                 { "daemon-reexec",         1,        1,        VERB_ONLINE_ONLY, verb_daemon_reload           },
1172                 { "log-level",             VERB_ANY, 2,        VERB_ONLINE_ONLY, verb_log_setting             },
1173                 { "log-target",            VERB_ANY, 2,        VERB_ONLINE_ONLY, verb_log_setting             },
1174                 { "service-log-level",     2,        3,        VERB_ONLINE_ONLY, verb_service_log_setting     },
1175                 { "service-log-target",    2,        3,        VERB_ONLINE_ONLY, verb_service_log_setting     },
1176                 { "service-watchdogs",     VERB_ANY, 2,        VERB_ONLINE_ONLY, verb_service_watchdogs       },
1177                 { "show-environment",      VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_show_environment        },
1178                 { "set-environment",       2,        VERB_ANY, VERB_ONLINE_ONLY, verb_set_environment         },
1179                 { "unset-environment",     2,        VERB_ANY, VERB_ONLINE_ONLY, verb_set_environment         },
1180                 { "import-environment",    VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_import_environment      },
1181                 { "halt",                  VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1182                 { "poweroff",              VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1183                 { "reboot",                VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1184                 { "kexec",                 VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1185                 { "soft-reboot",           VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1186                 { "sleep",                 VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1187                 { "suspend",               VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1188                 { "hibernate",             VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1189                 { "hybrid-sleep",          VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1190                 { "suspend-then-hibernate",VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1191                 { "default",               VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_special           },
1192                 { "rescue",                VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1193                 { "emergency",             VERB_ANY, 1,        VERB_ONLINE_ONLY, verb_start_system_special    },
1194                 { "exit",                  VERB_ANY, 2,        VERB_ONLINE_ONLY, verb_start_special           },
1195                 { "reset-failed",          VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_reset_failed            },
1196                 { "enable",                2,        VERB_ANY, 0,                verb_enable                  },
1197                 { "disable",               2,        VERB_ANY, 0,                verb_enable                  },
1198                 { "is-enabled",            2,        VERB_ANY, 0,                verb_is_enabled              },
1199                 { "reenable",              2,        VERB_ANY, 0,                verb_enable                  },
1200                 { "preset",                2,        VERB_ANY, 0,                verb_enable                  },
1201                 { "preset-all",            VERB_ANY, 1,        0,                verb_preset_all              },
1202                 { "mask",                  2,        VERB_ANY, 0,                verb_enable                  },
1203                 { "unmask",                2,        VERB_ANY, 0,                verb_enable                  },
1204                 { "link",                  2,        VERB_ANY, 0,                verb_enable                  },
1205                 { "revert",                2,        VERB_ANY, 0,                verb_enable                  },
1206                 { "switch-root",           VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_switch_root             },
1207                 { "list-dependencies",     VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_list_dependencies       },
1208                 { "set-default",           2,        2,        0,                verb_set_default             },
1209                 { "get-default",           VERB_ANY, 1,        0,                verb_get_default             },
1210                 { "set-property",          3,        VERB_ANY, VERB_ONLINE_ONLY, verb_set_property            },
1211                 { "is-system-running",     VERB_ANY, 1,        0,                verb_is_system_running       },
1212                 { "add-wants",             3,        VERB_ANY, 0,                verb_add_dependency          },
1213                 { "add-requires",          3,        VERB_ANY, 0,                verb_add_dependency          },
1214                 { "edit",                  2,        VERB_ANY, VERB_ONLINE_ONLY, verb_edit                    },
1215                 { "bind",                  3,        4,        VERB_ONLINE_ONLY, verb_bind                    },
1216                 { "mount-image",           4,        5,        VERB_ONLINE_ONLY, verb_mount_image             },
1217                 { "whoami",                VERB_ANY, VERB_ANY, VERB_ONLINE_ONLY, verb_whoami                  },
1218                 {}
1219         };
1220
1221         const Verb *verb = verbs_find_verb(argv[optind], verbs);
1222         if (verb && (verb->flags & VERB_ONLINE_ONLY) && arg_root)
1223                 return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
1224                                        "Verb '%s' cannot be used with --root= or --image=.",
1225                                        argv[optind] ?: verb->verb);
1226
1227         return dispatch_verb(argc, argv, verbs, NULL);
1228 }
1229
1230 static int run(int argc, char *argv[]) {
1231         _cleanup_(loop_device_unrefp) LoopDevice *loop_device = NULL;
1232         _cleanup_(umount_and_freep) char *mounted_dir = NULL;
1233         int r;
1234
1235         setlocale(LC_ALL, "");
1236         log_setup();
1237
1238         /* The journal merging logic potentially needs a lot of fds. */
1239         (void) rlimit_nofile_bump(HIGH_RLIMIT_NOFILE);
1240
1241         sigbus_install();
1242
1243         r = systemctl_dispatch_parse_argv(argc, argv);
1244         if (r <= 0)
1245                 goto finish;
1246
1247         if (proc_mounted() == 0)
1248                 log_full(arg_no_warn ? LOG_DEBUG : LOG_WARNING,
1249                          "%s%s/proc/ is not mounted. This is not a supported mode of operation. Please fix\n"
1250                          "your invocation environment to mount /proc/ and /sys/ properly. Proceeding anyway.\n"
1251                          "Your mileage may vary.",
1252                          emoji_enabled() ? special_glyph(SPECIAL_GLYPH_WARNING_SIGN) : "",
1253                          emoji_enabled() ? " " : "");
1254
1255         if (arg_action != ACTION_SYSTEMCTL && running_in_chroot() > 0) {
1256                 if (!arg_quiet)
1257                         log_info("Running in chroot, ignoring request.");
1258                 r = 0;
1259                 goto finish;
1260         }
1261
1262         /* systemctl_main() will print an error message for the bus connection, but only if it needs to */
1263
1264         if (arg_image) {
1265                 assert(!arg_root);
1266
1267                 r = mount_image_privately_interactively(
1268                                 arg_image,
1269                                 arg_image_policy,
1270                                 DISSECT_IMAGE_GENERIC_ROOT |
1271                                 DISSECT_IMAGE_REQUIRE_ROOT |
1272                                 DISSECT_IMAGE_RELAX_VAR_CHECK |
1273                                 DISSECT_IMAGE_VALIDATE_OS,
1274                                 &mounted_dir,
1275                                 /* ret_dir_fd= */ NULL,
1276                                 &loop_device);
1277                 if (r < 0)
1278                         return r;
1279
1280                 arg_root = strdup(mounted_dir);
1281                 if (!arg_root)
1282                         return log_oom();
1283         }
1284
1285         switch (arg_action) {
1286
1287         case ACTION_SYSTEMCTL:
1288                 r = systemctl_main(argc, argv);
1289                 break;
1290
1291         /* Legacy command aliases set arg_action. They provide some fallbacks, e.g. to tell sysvinit to
1292          * reboot after you have installed systemd binaries. */
1293
1294         case ACTION_HALT:
1295         case ACTION_POWEROFF:
1296         case ACTION_REBOOT:
1297         case ACTION_KEXEC:
1298                 r = halt_main();
1299                 break;
1300
1301         case ACTION_RUNLEVEL2:
1302         case ACTION_RUNLEVEL3:
1303         case ACTION_RUNLEVEL4:
1304         case ACTION_RUNLEVEL5:
1305         case ACTION_RESCUE:
1306                 r = start_with_fallback();
1307                 break;
1308
1309         case ACTION_RELOAD:
1310         case ACTION_REEXEC:
1311                 r = reload_with_fallback();
1312                 break;
1313
1314         case ACTION_CANCEL_SHUTDOWN:
1315                 r = logind_cancel_shutdown();
1316                 break;
1317
1318         case ACTION_SHOW_SHUTDOWN:
1319                 r = logind_show_shutdown();
1320                 break;
1321
1322         case ACTION_RUNLEVEL:
1323                 r = runlevel_main();
1324                 break;
1325
1326         case ACTION_EXIT:
1327         case ACTION_SLEEP:
1328         case ACTION_SUSPEND:
1329         case ACTION_HIBERNATE:
1330         case ACTION_HYBRID_SLEEP:
1331         case ACTION_SUSPEND_THEN_HIBERNATE:
1332         case ACTION_EMERGENCY:
1333         case ACTION_DEFAULT:
1334                 /* systemctl verbs with no equivalent in the legacy commands. These cannot appear in
1335                  * arg_action. Fall through. */
1336
1337         case _ACTION_INVALID:
1338         default:
1339                 assert_not_reached();
1340         }
1341
1342 finish:
1343         release_busses();
1344
1345         /* Note that we return r here, not 0, so that we can implement the LSB-like return codes */
1346         return r;
1347 }
1348
1349 DEFINE_MAIN_FUNCTION_WITH_POSITIVE_FAILURE(run);
1350 #endif