HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/machine/machinectl.c

98,584 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 716f23c6ded933841fb02c45bd18ca97aed8379f

Lines 2001–2625 of 2,625

                q = normalize_nspawn_filename(*name, &file);
                if (q < 0)
                        return r < 0 ? r : q;
 
                q = get_settings_path(file, &path);
                if (q == -ENOENT) {
                        log_error_errno(q, "No settings file found for machine '%s'.", *name);
                        r = r < 0 ? r : q;
                        continue;
                }
                if (q < 0) {
                        log_error_errno(q, "Failed to get the path of the settings file: %m");
                        return r < 0 ? r : q;
                }
 
                q = cat_files(path, /* dropins= */ NULL, /* flags= */ CAT_FORMAT_HAS_SECTIONS);
                if (q < 0)
                        return r < 0 ? r : q;
        }
 
        return r;
}
 
VERB(verb_clone_image, "clone", "NAME NAME\0", 3, 3, 0,
     "Clone an image");
static int verb_clone_image(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CloneImage");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append(m, "ssb", argv[1], argv[2], arg_read_only);
        if (r < 0)
                return bus_log_create_error(r);
 
        /* This is a slow operation, hence turn off any method call timeouts */
        r = sd_bus_call(bus, m, USEC_INFINITY, &error, NULL);
        if (r < 0)
                return log_error_errno(r, "Could not clone image: %s", bus_error_message(&error, r));
 
        return 0;
}
 
VERB(verb_rename_image, "rename", "NAME NAME\0", 3, 3, 0,
     "Rename an image");
static int verb_rename_image(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_call_method(
                        bus,
                        bus_machine_mgr,
                        "RenameImage",
                        &error,
                        NULL,
                        "ss", argv[1], argv[2]);
        if (r < 0)
                return log_error_errno(r, "Could not rename image: %s", bus_error_message(&error, r));
 
        return 0;
}
 
VERB(verb_read_only_image, "read-only", "NAME [BOOL]\0", 2, 3, 0,
     "Mark or unmark image read-only");
static int verb_read_only_image(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = ASSERT_PTR(userdata);
        int b = true, r;
 
        if (argc > 2) {
                b = parse_boolean(argv[2]);
                if (b < 0)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Failed to parse boolean argument: %s",
                                               argv[2]);
        }
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_call_method(bus, bus_machine_mgr, "MarkImageReadOnly", &error, NULL, "sb", argv[1], b);
        if (r < 0)
                return log_error_errno(r, "Could not mark image read-only: %s", bus_error_message(&error, r));
 
        return 0;
}
 
VERB(verb_remove_image, "remove", "NAME…\0", 2, VERB_ANY, 0,
     "Remove an image");
static int verb_remove_image(int argc, char *argv[], uintptr_t _data, void *userdata) {
        sd_bus *bus = ASSERT_PTR(userdata);
        int r;
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        for (int i = 1; i < argc; i++) {
                _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 
                r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "RemoveImage");
                if (r < 0)
                        return bus_log_create_error(r);
 
                r = sd_bus_message_append(m, "s", argv[i]);
                if (r < 0)
                        return bus_log_create_error(r);
 
                /* This is a slow operation, hence turn off any method call timeouts */
                r = sd_bus_call(bus, m, USEC_INFINITY, &error, NULL);
                if (r < 0)
                        return log_error_errno(r, "Could not remove image: %s", bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB(verb_set_limit, "set-limit", "[NAME] BYTES\0", 2, 3, 0,
     "Set image or pool size limit (disk quota)");
static int verb_set_limit(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        sd_bus *bus = userdata;
        uint64_t limit;
        int r;
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        if (STR_IN_SET(argv[argc-1], "-", "none", "infinity"))
                limit = UINT64_MAX;
        else {
                r = parse_size(argv[argc-1], 1024, &limit);
                if (r < 0)
                        return log_error_errno(r, "Failed to parse size: %s", argv[argc-1]);
        }
 
        if (argc > 2)
                /* With two arguments changes the quota limit of the
                 * specified image */
                r = bus_call_method(bus, bus_machine_mgr, "SetImageLimit", &error, NULL, "st", argv[1], limit);
        else
                /* With one argument changes the pool quota limit */
                r = bus_call_method(bus, bus_machine_mgr, "SetPoolLimit", &error, NULL, "t", limit);
 
        if (r < 0)
                return log_error_errno(r, "Could not set limit: %s", bus_error_message(&error, r));
 
        return 0;
}
 
VERB(verb_clean_images, "clean", /* argspec= */ NULL, VERB_ANY, 1, 0,
     "Remove hidden (or all) images");
static int verb_clean_images(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        uint64_t usage, total = 0;
        sd_bus *bus = userdata;
        const char *name;
        unsigned c = 0;
        int r;
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        r = bus_message_new_method_call(bus, &m, bus_machine_mgr, "CleanPool");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append(m, "s", arg_all ? "all" : "hidden");
        if (r < 0)
                return bus_log_create_error(r);
 
        /* This is a slow operation, hence permit a longer time for completion. */
        r = sd_bus_call(bus, m, USEC_INFINITY, &error, &reply);
        if (r < 0)
                return log_error_errno(r, "Could not clean pool: %s", bus_error_message(&error, r));
 
        r = sd_bus_message_enter_container(reply, 'a', "(st)");
        if (r < 0)
                return bus_log_parse_error(r);
 
        while ((r = sd_bus_message_read(reply, "(st)", &name, &usage)) > 0) {
                if (usage == UINT64_MAX) {
                        log_info("Removed image '%s'", name);
                        total = UINT64_MAX;
                } else {
                        log_info("Removed image '%s'. Freed exclusive disk space: %s",
                                 name, FORMAT_BYTES(usage));
                        if (total != UINT64_MAX)
                                total += usage;
                }
                c++;
        }
 
        r = sd_bus_message_exit_container(reply);
        if (r < 0)
                return bus_log_parse_error(r);
 
        if (total == UINT64_MAX)
                log_info("Removed %u images in total.", c);
        else
                log_info("Removed %u images in total. Total freed exclusive disk space: %s.",
                         c, FORMAT_BYTES(total));
 
        return 0;
}
 
VERB(verb_bind_volume, "bind-volume", "MACHINE PROVIDER:VOLUME[:…]\0", 3, 3, 0,
     "Attach a volume to a running machine");
static int verb_bind_volume(int argc, char *argv[], uintptr_t _data, void *userdata) {
        int r;
 
        if (arg_transport != BUS_TRANSPORT_LOCAL)
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "bind-volume is only supported on the local transport.");
 
        _cleanup_(bind_volume_freep) BindVolume *bv = NULL;
        r = bind_volume_parse(argv[2], &bv);
        if (r < 0)
                return log_error_errno(r, "Failed to parse bind-volume argument '%s': %m", argv[2]);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        /* Locate and connect to the target machine before acquiring storage, so a missing
         * machine doesn't trigger 'create=new' side effects on the StorageProvider. */
        _cleanup_free_ char *address = NULL;
        r = machine_get_control_address(argv[1], &address);
        if (r == -EOPNOTSUPP)
                return log_error_errno(r, "Machine '%s' does not expose a varlink control socket.", argv[1]);
        if (r < 0)
                return r;
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
        r = sd_varlink_connect_address(&vl, address);
        if (r < 0)
                return log_error_errno(r, "Failed to connect to machine control socket %s: %m", address);
 
        r = sd_varlink_set_allow_fd_passing_output(vl, true);
        if (r < 0)
                return log_error_errno(r, "Failed to enable fd passing on varlink connection: %m");
 
        _cleanup_(storage_acquire_reply_done) StorageAcquireReply reply = STORAGE_ACQUIRE_REPLY_INIT;
        _cleanup_free_ char *acquire_error_id = NULL;
        r = storage_acquire_volume(arg_runtime_scope, bv, arg_ask_password, &acquire_error_id, &reply);
        if (r < 0) {
                if (acquire_error_id)
                        return log_error_errno(r, "Failed to acquire storage volume '%s:%s' from provider: %s",
                                               bv->provider, bv->volume, acquire_error_id);
                return log_error_errno(r, "Failed to acquire storage volume '%s:%s' from provider: %m",
                                       bv->provider, bv->volume);
        }
 
        int fd_index = sd_varlink_push_fd(vl, reply.fd);
        if (fd_index < 0)
                return log_error_errno(fd_index, "Failed to push storage fd onto varlink connection: %m");
        TAKE_FD(reply.fd);
 
        _cleanup_free_ char *name = strjoin(bv->provider, ":", bv->volume);
        if (!name)
                return log_oom();
 
        sd_json_variant *vl_reply = NULL;
        const char *error_id = NULL;
        r = sd_varlink_callbo(
                        vl,
                        "io.systemd.MachineInstance.AddStorage",
                        &vl_reply, &error_id,
                        SD_JSON_BUILD_PAIR_INTEGER("fileDescriptorIndex", fd_index),
                        SD_JSON_BUILD_PAIR_STRING("name", name),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("config", bv->config));
        if (r < 0)
                return log_error_errno(r, "Failed to call io.systemd.MachineInstance.AddStorage: %m");
        if (error_id)
                return log_error_errno(sd_varlink_error_to_errno(error_id, vl_reply),
                                       "AddStorage failed for '%s': %s", name, error_id);
 
        return 0;
}
 
VERB(verb_unbind_volume, "unbind-volume", "MACHINE PROVIDER:VOLUME\0", 3, 3, 0,
     "Detach a volume from a running machine");
static int verb_unbind_volume(int argc, char *argv[], uintptr_t _data, void *userdata) {
        int r;
 
        if (arg_transport != BUS_TRANSPORT_LOCAL)
                return log_error_errno(SYNTHETIC_ERRNO(EOPNOTSUPP),
                                       "unbind-volume is only supported on the local transport.");
 
        r = machine_storage_name_split(argv[2], /* ret_provider= */ NULL, /* ret_volume= */ NULL);
        if (r == -ENOMEM)
                return log_oom();
        if (r < 0)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Invalid unbind-volume name '%s', expected '<provider>:<volume>'.", argv[2]);
 
        (void) polkit_agent_open_if_enabled(arg_transport, arg_ask_password);
 
        _cleanup_free_ char *address = NULL;
        r = machine_get_control_address(argv[1], &address);
        if (r == -EOPNOTSUPP)
                return log_error_errno(r, "Machine '%s' does not expose a varlink control socket.", argv[1]);
        if (r < 0)
                return r;
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *vl = NULL;
        r = sd_varlink_connect_address(&vl, address);
        if (r < 0)
                return log_error_errno(r, "Failed to connect to machine control socket %s: %m", address);
 
        sd_json_variant *reply = NULL;
        const char *error_id = NULL;
        r = sd_varlink_callbo(
                        vl,
                        "io.systemd.MachineInstance.RemoveStorage",
                        &reply, &error_id,
                        SD_JSON_BUILD_PAIR_STRING("name", argv[2]));
        if (r < 0)
                return log_error_errno(r, "Failed to call io.systemd.MachineInstance.RemoveStorage: %m");
        if (error_id)
                return log_error_errno(sd_varlink_error_to_errno(error_id, reply),
                                       "RemoveStorage failed for '%s': %s", argv[2], error_id);
 
        return 0;
}
 
static int chainload_importctl(char **args) {
        int r;
 
        if (!arg_quiet)
                log_notice("The 'machinectl %1$s' command has been replaced by 'importctl -m %1$s'. "
                           "Redirecting invocation.", args[0]);
 
        _cleanup_strv_free_ char **c =
                strv_new("importctl", "--class=machine");
        if (!c)
                return log_oom();
 
        if (FLAGS_SET(arg_pager_flags, PAGER_DISABLE))
                if (strv_extend(&c, "--no-pager") < 0)
                        return log_oom();
        if (!arg_legend)
                if (strv_extend(&c, "--no-legend") < 0)
                        return log_oom();
        if (arg_read_only)
                if (strv_extend(&c, "--read-only") < 0)
                        return log_oom();
        if (arg_force)
                if (strv_extend(&c, "--force") < 0)
                        return log_oom();
        if (arg_quiet)
                if (strv_extend(&c, "--quiet") < 0)
                        return log_oom();
        if (!arg_ask_password)
                if (strv_extend(&c, "--no-ask-password") < 0)
                        return log_oom();
        if (strv_extend_many(&c, "--verify", import_verify_to_string(arg_verify)) < 0)
                return log_oom();
        if (arg_format)
                if (strv_extend_many(&c, "--format", arg_format) < 0)
                        return log_oom();
 
        if (strv_extend_strv(&c, args, /* filter_duplicates= */ false) < 0)
                return log_oom();
 
        if (DEBUG_LOGGING) {
                _cleanup_free_ char *joined = strv_join(c, " ");
                log_debug("Chainloading: %s", joined);
        }
 
        r = invoke_callout_binary(BINDIR "/importctl", c);
        return log_error_errno(r, "Failed to invoke 'importctl': %m");
}
 
VERB_COMMON_HELP_AUTO_HIDDEN();
 
static int parse_argv(int argc, char *argv[], char ***ret_args) {
        assert(argc >= 0);
        assert(argv);
        assert(ret_args);
 
        /* For "shell" we don't want option reordering; options specified after the command should be passed
         * to the program to execute, and not processed by us. For other verbs, we consume all options as
         * usual. To make this work, start with OPTION_PARSER_RETURN_POSITIONAL_ARGS and switch to either
         * OPTION_PARSER_STOP_AT_FIRST_NONOPTION or OPTION_PARSER_NORMAL after we've seen the verb and one
         * more argument after that. */
        OptionParser opts = { argc, argv, OPTION_PARSER_RETURN_POSITIONAL_ARGS };
        _cleanup_strv_free_ char **args = NULL;
        int r;
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_POSITIONAL:
                        assert(opts.mode == OPTION_PARSER_RETURN_POSITIONAL_ARGS);
 
                        if (!args && !streq(opts.arg, "shell"))
                                opts.mode = OPTION_PARSER_NORMAL;
                        else if (args)
                                opts.mode = OPTION_PARSER_STOP_AT_FIRST_NONOPTION;
 
                        r = strv_extend(&args, opts.arg);
                        if (r < 0)
                                return log_oom();
                        break;
 
                OPTION_COMMON_HELP:
                        return command_print_help();
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_COMMON_HOST:
                        arg_transport = BUS_TRANSPORT_REMOTE;
                        arg_host = opts.arg;
                        break;
 
                OPTION_COMMON_MACHINE:
                        arg_transport = BUS_TRANSPORT_MACHINE;
                        arg_host = opts.arg;
                        break;
 
                OPTION_LONG("system", NULL, "Connect to system machine manager"):
                        arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
                        break;
 
                OPTION_LONG("user", NULL, "Connect to user machine manager"):
                        arg_runtime_scope = RUNTIME_SCOPE_USER;
                        break;
 
                OPTION_LONG("value", NULL, "When showing properties, only print the value"):
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
                        break;
 
                OPTION('p', "property", "NAME", "Show only properties by this name"): {}
                OPTION_SHORT('P', "NAME", "Equivalent to --value --property=NAME"):
                        r = strv_extend(&arg_property, opts.arg);
                        if (r < 0)
                                return log_oom();
 
                        /* If the user asked for a particular property, show it to them, even if empty. */
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
 
                        if (opts.opt->short_code == 'P')
                                SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_ONLY_VALUE, true);
 
                        break;
 
                OPTION('a', "all", NULL, "Show all properties, including empty ones"):
                        SET_FLAG(arg_print_flags, BUS_PRINT_PROPERTY_SHOW_EMPTY, true);
                        arg_all = true;
                        break;
 
                OPTION('l', "full", NULL, "Do not ellipsize output"):
                        arg_full = true;
                        break;
 
                OPTION_LONG("kill-whom", "WHOM", "Whom to send signal to"):
                        arg_kill_whom = opts.arg;
                        break;
 
                OPTION('s', "signal", "SIGNAL", "Which signal to send"):
                        r = parse_signal_argument(opts.arg, &arg_signal);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION_LONG("uid", "USER", "Specify user ID to invoke shell as"):
                        arg_uid = opts.arg;
                        break;
 
                OPTION('E', "setenv", "VAR[=VALUE]", "Add an environment variable for shell"):
                        r = strv_env_replace_strdup_passthrough(&arg_setenv, opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Cannot assign environment variable %s: %m", opts.arg);
                        break;
 
                OPTION_LONG("read-only", NULL, "Create read-only bind mount or clone"):
                        arg_read_only = true;
                        break;
 
                OPTION_LONG("mkdir", NULL, "Create directory before bind mounting, if missing"):
                        arg_mkdir = true;
                        break;
 
                OPTION('n', "lines", "INTEGER", "Number of journal entries to show"):
                        if (safe_atou(opts.arg, &arg_lines) < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Failed to parse lines '%s'", opts.arg);
                        break;
 
                OPTION_LONG("max-addresses", "INTEGER",
                            "Number of internet addresses to show at most"):
                        if (streq(opts.arg, "all"))
                                arg_max_addresses = UINT_MAX;
                        else if (safe_atou(opts.arg, &arg_max_addresses) < 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Invalid number of addresses: %s", opts.arg);
                        break;
 
                OPTION('o', "output", "STRING",
                       "Change journal output mode (short, short-precise, short-iso, "
                       "short-iso-precise, short-full, short-monotonic, short-unix, short-delta, "
                       "json, json-pretty, json-sse, json-seq, cat, verbose, export, with-unit)"):
                        if (streq(opts.arg, "help"))
                                return DUMP_STRING_TABLE(output_mode, OutputMode, _OUTPUT_MODE_MAX);
 
                        r = output_mode_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Unknown output '%s'.", opts.arg);
                        arg_output = r;
 
                        if (OUTPUT_MODE_IS_JSON(arg_output))
                                arg_legend = false;
                        break;
 
                OPTION_LONG("force", NULL, "Replace target file when copying, if necessary"):
                        arg_force = true;
                        break;
 
                OPTION_LONG("now", NULL,
                            "Start or power off container after enabling or disabling it"):
                        arg_now = true;
                        break;
 
                OPTION_LONG("runner", "RUNNER",
                            "Select between nspawn and vmspawn as the runner"):
                        r = machine_runner_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --runner= setting: %s", opts.arg);
 
                        arg_runner = r;
                        break;
 
                OPTION_SHORT('V', NULL, "Short for --runner=vmspawn"):
                        arg_runner = RUNNER_VMSPAWN;
                        break;
 
                /* Hidden options below */
 
                OPTION_LONG("verify", "MODE", /* help= */ NULL):
                        if (streq(opts.arg, "help"))
                                return DUMP_STRING_TABLE(import_verify, ImportVerify, _IMPORT_VERIFY_MAX);
 
                        r = import_verify_from_string(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --verify= setting: %s", opts.arg);
                        arg_verify = r;
                        break;
 
                OPTION_LONG("format", "FORMAT", /* help= */ NULL):
                        if (!STR_IN_SET(opts.arg, "uncompressed", "xz", "gzip", "bzip2", "zstd"))
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                                       "Unknown format: %s", opts.arg);
 
                        arg_format = opts.arg;
                        break;
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_COMMON_NO_LEGEND:
                        arg_legend = false;
                        break;
 
                OPTION_COMMON_NO_ASK_PASSWORD:
                        arg_ask_password = false;
                        break;
 
                OPTION('q', "quiet", NULL, "Suppress output"):
                        arg_quiet = true;
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(SD_JSON_FORMAT_OFF);
                }
 
        /* We gathered some positional args in 'args' ourselves. Append the remaining ones. */
        if (strv_extend_strv(&args, option_parser_get_args(&opts), /* filter_duplicates= */ false) < 0)
                return log_oom();
 
        *ret_args = TAKE_PTR(args);
        return 1;
}
 
static int run(int argc, char *argv[]) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_strv_free_ char **args = NULL;
        int r;
 
        COMPRESS_JOURNAL_NOTE;
        LIBSELINUX_NOTE(recommended);
 
        setlocale(LC_ALL, "");
        log_setup();
 
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        journal_browse_prepare();
 
        if (args && STR_IN_SET(args[0],
                               "import-tar", "import-raw", "import-fs",
                               "export-tar", "export-raw",
                               "pull-tar", "pull-raw",
                               "list-transfers", "cancel-transfer"))
                return chainload_importctl(args);
 
        r = bus_connect_transport(arg_transport, arg_host, arg_runtime_scope, &bus);
        if (r < 0)
                return bus_log_connect_error(r, arg_transport, arg_runtime_scope);
 
        (void) sd_bus_set_allow_interactive_authorization(bus, arg_ask_password);
 
        return dispatch_verb(args, bus);
}
 
DEFINE_MAIN_FUNCTION(run);