HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/busctl/busctl.c

82,954 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 88eba5a51268e6d7348530d668ad9f9a9284324f

Lines 2001–2308 of 2,308

                return r;
 
        r = sd_bus_match_signal(bus, NULL, sender, path, interface, member, on_bus_signal, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to match signal %s on interface %s: %m", member, interface);
 
        r = sd_event_new(&e);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate event loop: %m\n");
 
        r = sd_bus_attach_event(bus, e, SD_EVENT_PRIORITY_NORMAL);
        if (r < 0)
                return log_error_errno(r, "Failed to attach bus event: %m\n");
 
        if (arg_timeout) {
                r = sd_event_add_time_relative(e, &timer, CLOCK_MONOTONIC, arg_timeout, 0, NULL, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to schedule timeout: %m\n");
        }
 
        /* The match is installed and we're ready to observe the signal */
        sd_notify(/* unset_environment= */ false, "READY=1");
 
        return sd_event_loop(e);
}
 
VERB(verb_set_property, "set-property", "SERVICE OBJECT INTERFACE PROPERTY SIGNATURE ARGUMENT…\0", 6, VERB_ANY, 0,
     "Set property value");
static int verb_set_property(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_fdset_free_ FDSet *passed_fdset = NULL;
        char **p;
        int r;
 
        if (!service_name_is_valid(argv[1]))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", argv[1]);
        if (!object_path_is_valid(argv[2]))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", argv[2]);
        if (!interface_name_is_valid(argv[3]))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", argv[3]);
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2],
                                           "org.freedesktop.DBus.Properties", "Set");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append(m, "ss", argv[3], argv[4]);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(m, 'v', argv[5]);
        if (r < 0)
                return bus_log_create_error(r);
 
        p = argv + 6;
        r = message_append_cmdline(m, argv[5], &passed_fdset, &p);
        if (r < 0)
                return r;
 
        r = sd_bus_message_close_container(m);
        if (r < 0)
                return bus_log_create_error(r);
 
        if (*p)
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Too many parameters for signature.");
 
        r = sd_bus_call(bus, m, arg_timeout, &error, NULL);
        if (r < 0) {
                notify_bus_error(&error);
                return log_error_errno(r, "Failed to set property %s on interface %s: %s",
                                       argv[4], argv[3],
                                       bus_error_message(&error, r));
        }
 
        return 0;
}
 
VERB_COMMON_HELP_AUTO();
 
static int parse_argv(int argc, char *argv[], char ***remaining_args) {
        assert(argc >= 0);
        assert(argv);
        assert(remaining_args);
 
        OptionParser opts = { argc, argv };
        int r;
 
        FOREACH_OPTION_OR_RETURN(c, &opts)
                switch (c) {
 
                OPTION_COMMON_HELP:
                        return command_print_help();
 
                OPTION_COMMON_VERSION:
                        return version();
 
                OPTION_COMMON_NO_PAGER:
                        arg_pager_flags |= PAGER_DISABLE;
                        break;
 
                OPTION_COMMON_NO_LEGEND:
                        arg_legend = false;
                        break;
 
                OPTION('l', "full", NULL, "Do not ellipsize output"):
                        arg_full = true;
                        break;
 
                OPTION_LONG("system", NULL, "Connect to system bus"):
                        arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
                        break;
 
                OPTION_LONG("user", NULL, "Connect to user bus"):
                        arg_runtime_scope = RUNTIME_SCOPE_USER;
                        break;
 
                OPTION_COMMON_HOST:
                        arg_transport = BUS_TRANSPORT_REMOTE;
                        arg_host = opts.arg;
                        break;
 
                OPTION_COMMON_MACHINE:
                        r = parse_machine_argument(opts.arg, &arg_host, &arg_transport);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION('C', "capsule", "NAME", "Operate on capsule"):
                        r = capsule_name_is_valid(opts.arg);
                        if (r < 0)
                                return log_error_errno(r, "Unable to validate capsule name '%s': %m", opts.arg);
                        if (r == 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid capsule name: %s", opts.arg);
 
                        arg_host = opts.arg;
                        arg_transport = BUS_TRANSPORT_CAPSULE;
                        break;
 
                OPTION_LONG("address", "ADDRESS", "Connect to bus specified by address"):
                        arg_address = opts.arg;
                        break;
 
                OPTION_LONG("show-machine", NULL, "Show machine ID column in list"):
                        arg_show_machine = true;
                        break;
 
                OPTION_LONG("unique", NULL, "Only show unique names"):
                        arg_unique = true;
                        break;
 
                OPTION_LONG("acquired", NULL, "Only show acquired names"):
                        arg_acquired = true;
                        break;
 
                OPTION_LONG("activatable", NULL, "Only show activatable names"):
                        arg_activatable = true;
                        break;
 
                OPTION_LONG("match", "MATCH", "Only show matching messages"):
                        if (strv_extend(&arg_matches, opts.arg) < 0)
                                return log_oom();
                        break;
 
                OPTION_LONG("size", "SIZE", "Maximum length of captured packet"): {
                        uint64_t sz;
 
                        r = parse_size(opts.arg, 1024, &sz);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse size '%s': %m", opts.arg);
 
                        if ((uint64_t) (size_t) sz !=  sz)
                                return log_error_errno(SYNTHETIC_ERRNO(E2BIG),
                                                       "Size out of range.");
 
                        arg_snaplen = (size_t) sz;
                        break;
                }
 
                OPTION_LONG("list", NULL, "Don't show tree, but simple object path list"):
                        arg_list = true;
                        break;
 
                OPTION('q', "quiet", NULL, "Don't show method call reply"):
                        arg_quiet = true;
                        break;
 
                OPTION_LONG("verbose", NULL, "Show result values in long format"):
                        arg_verbose = true;
                        break;
 
                OPTION_COMMON_JSON:
                        r = parse_json_argument(opts.arg, &arg_json_format_flags);
                        if (r <= 0)
                                return r;
                        break;
 
                OPTION_COMMON_LOWERCASE_J:
                        arg_json_format_flags = SD_JSON_FORMAT_PRETTY_AUTO|SD_JSON_FORMAT_COLOR_AUTO;
                        break;
 
                OPTION_LONG("xml-interface", NULL, "Dump the XML description in introspect command"):
                        arg_xml_interface = true;
                        break;
 
                OPTION_LONG("expect-reply", "BOOL", "Expect a method call reply"):
                        r = parse_boolean_argument("--expect-reply=", opts.arg, &arg_expect_reply);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("auto-start", "BOOL", "Auto-start destination service"):
                        r = parse_boolean_argument("--auto-start=", opts.arg, &arg_auto_start);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("allow-interactive-authorization", "",
                            "Allow interactive authorization for operation"):
                        r = parse_boolean_argument("--allow-interactive-authorization=", opts.arg,
                                                   &arg_allow_interactive_authorization);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("timeout", "SECS", "Maximum time to wait for method call completion"):
                        if (isempty(opts.arg)) {
                                arg_timeout = 0; /* Reset to default */
                                break;
                        }
 
                        r = parse_sec(opts.arg, &arg_timeout);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --timeout= parameter '%s': %m", opts.arg);
                        break;
 
                OPTION_LONG("augment-creds", "BOOL",
                            "Extend credential data with data read from /proc/$PID"):
                        r = parse_boolean_argument("--augment-creds=", opts.arg, &arg_augment_creds);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("watch-bind", "BOOL",
                            "Wait for bus AF_UNIX socket to be bound in the file system"):
                        r = parse_boolean_argument("--watch-bind=", opts.arg, &arg_watch_bind);
                        if (r < 0)
                                return r;
                        break;
 
                OPTION_LONG("destination", "SERVICE", "Destination service of a signal"):
                        arg_destination = opts.arg;
                        break;
 
                OPTION('N', "limit-messages", "NUMBER",
                       "Stop monitoring after receiving the specified number of messages"):
                        if (isempty(opts.arg)) {
                                /* Reset to default */
                                arg_limit_messages = UINT64_MAX;
                                arg_limit_signals = 1;
                                break;
                        }
 
                        if (streq(opts.arg, "infinity")) {
                                arg_limit_signals = arg_limit_messages = UINT64_MAX;
                                break;
                        }
 
                        r = safe_atou64(opts.arg, &arg_limit_messages);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse --limit-messages= parameter: %s", opts.arg);
                        if (arg_limit_messages == 0)
                                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "--limit-messages= parameter cannot be 0");
 
                        arg_limit_signals = arg_limit_messages;
                        break;
 
                OPTION_COMMON_INTROSPECT_CLI:
                        return introspect_cli(arg_json_format_flags);
                }
 
        if (arg_full < 0)
                arg_full = terminal_is_dumb();
 
        *remaining_args = option_parser_get_args(&opts);
        return 1;
}
 
static int run(int argc, char *argv[]) {
        int r;
 
        log_setup();
 
        char **args = NULL;
        r = parse_argv(argc, argv, &args);
        if (r <= 0)
                return r;
 
        return dispatch_verb(args, NULL);
}
 
DEFINE_MAIN_FUNCTION(run);