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 1001–2000 of 2,308

                                return -ENOMEM;
 
        if (m->writable)
                if (!strextend_with_separator(&str, " ", "writable"))
                        return -ENOMEM;
 
        *ret = TAKE_PTR(str);
        return 0;
}
 
VERB(verb_introspect, "introspect", "SERVICE OBJECT [INTERFACE]\0", 3, 4, 0,
     "Introspect an object");
static int verb_introspect(int argc, char *argv[], uintptr_t _data, void *userdata) {
        static const XMLIntrospectOps ops = {
                .on_interface = on_interface,
                .on_method = on_method,
                .on_signal = on_signal,
                .on_property = on_property,
        };
 
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply_xml = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_set_free_ Set *members = NULL;
        Member *m;
        const char *xml;
        int r;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        members = set_new(&member_hash_ops);
        if (!members)
                return log_oom();
 
        r = sd_bus_call_method(bus, argv[1], argv[2],
                               "org.freedesktop.DBus.Introspectable", "Introspect",
                               &error, &reply_xml, NULL);
        if (r < 0) {
                notify_bus_error(&error);
                return log_error_errno(r, "Failed to introspect object %s of service %s: %s",
                                       argv[2], argv[1], bus_error_message(&error, r));
        }
 
        r = sd_bus_message_read(reply_xml, "s", &xml);
        if (r < 0)
                return bus_log_parse_error(r);
 
        if (arg_xml_interface) {
                /* Just dump the received XML and finish */
                pager_open(arg_pager_flags);
                puts(xml);
                return 0;
        }
 
        /* First, get list of all properties */
        r = parse_xml_introspect(argv[2], xml, &ops, members);
        if (r < 0)
                return r;
 
        /* Second, find the current values for them */
        SET_FOREACH(m, members) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 
                if (!streq(m->type, "property"))
                        continue;
 
                if (m->value)
                        continue;
 
                if (argv[3] && !streq(argv[3], m->interface))
                        continue;
 
                r = sd_bus_call_method(bus, argv[1], argv[2],
                                       "org.freedesktop.DBus.Properties", "GetAll",
                                       &error, &reply, "s", m->interface);
                if (r < 0) {
                        notify_bus_error(&error);
                        return log_error_errno(r, "Failed to get all properties on interface %s: %s",
                                               m->interface, bus_error_message(&error, r));
                }
 
                r = sd_bus_message_enter_container(reply, 'a', "{sv}");
                if (r < 0)
                        return bus_log_parse_error(r);
 
                for (;;) {
                        _cleanup_(memstream_done) MemStream ms = {};
                        _cleanup_free_ char *buf = NULL;
                        const char *name, *contents;
                        Member *z;
                        char type;
                        FILE *mf;
 
                        r = sd_bus_message_enter_container(reply, 'e', "sv");
                        if (r < 0)
                                return bus_log_parse_error(r);
                        if (r == 0)
                                break;
 
                        r = sd_bus_message_read(reply, "s", &name);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_peek_type(reply, &type, &contents);
                        if (r < 0)
                                return bus_log_parse_error(r);
                        if (type != 'v')
                                return bus_log_parse_error(EINVAL);
 
                        r = sd_bus_message_enter_container(reply, 'v', contents);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        mf = memstream_init(&ms);
                        if (!mf)
                                return log_oom();
 
                        r = format_cmdline(reply, mf, false);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = memstream_finalize(&ms, &buf, NULL);
                        if (r < 0)
                                return log_error_errno(r, "Failed to flush and close memstream: %m");
 
                        z = set_get(members, &((Member) {
                                                .type = "property",
                                                .interface = m->interface,
                                                .signature = (char*) contents,
                                                .name = (char*) name }));
                        if (z)
                                free_and_replace(z->value, buf);
 
                        r = sd_bus_message_exit_container(reply);
                        if (r < 0)
                                return bus_log_parse_error(r);
 
                        r = sd_bus_message_exit_container(reply);
                        if (r < 0)
                                return bus_log_parse_error(r);
                }
 
                r = sd_bus_message_exit_container(reply);
                if (r < 0)
                        return bus_log_parse_error(r);
        }
 
        size_t n;
        _cleanup_free_ Member **sorted = NULL;
        r = set_dump_sorted(members, (void***) &sorted, &n);
        if (r < 0)
                return log_oom();
 
        _cleanup_(table_unrefp) Table *table = table_new("name", "type", "signature", "result/value", "flags");
        if (!table)
                return log_oom();
 
        if (arg_full)
                table_set_width(table, 0);
        (void) table_set_maximum_width(table, table_get_cell(table, 0, 3), arg_full ? 100 : 40);
        table_set_header(table, arg_legend);
        table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
 
        FOREACH_ARRAY(p, sorted, n) {
                bool is_interface;
 
                m = *p;
 
                if (argv[3] && !streq(argv[3], m->interface))
                        continue;
 
                is_interface = streq(m->type, "interface");
 
                if (argv[3] && is_interface)
                        continue;
 
                if (is_interface)
                        r = table_add_many(
                                        table,
                                        TABLE_STRING, m->interface,
                                        TABLE_SET_COLOR, ansi_highlight());
                else
                        r = table_add_cell_stringf(
                                        table, /* ret_cell= */ NULL, ".%s", m->name);
                if (r < 0)
                        return table_log_add_error(r);
 
                _cleanup_free_ char *flags = NULL;
                r = members_flags_to_string(m, &flags);
                if (r < 0)
                        return log_oom();
 
                r = table_add_many(
                                table,
                                TABLE_STRING, m->type,
                                TABLE_STRING, m->signature,
                                TABLE_STRING, m->value ?: m->result,
                                TABLE_STRING, flags);
                if (r < 0)
                        return table_log_add_error(r);
        }
 
        return table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
}
 
static int message_dump(sd_bus_message *m, FILE *f) {
        int r;
 
        assert(m);
 
        r = sd_bus_message_dump(m, f, SD_BUS_MESSAGE_DUMP_WITH_HEADER);
        if (r < 0)
                return log_error_errno(r, "Failed to dump DBus message: %m");
 
        return 0;
}
 
static int message_pcap(sd_bus_message *m, FILE *f) {
        int r;
 
        assert(m);
 
        r = bus_message_pcap_frame(m, arg_snaplen, f);
        if (r < 0)
                return log_error_errno(r, "Failed to dump DBus message in PCAP format: %m");
 
        return 0;
}
 
static int message_json(sd_bus_message *m, FILE *f) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
        int r;
 
        assert(m);
 
        r = sd_bus_message_dump_json(m, SD_BUS_MESSAGE_DUMP_WITH_HEADER, &v);
        if (r < 0)
                return log_error_errno(r, "Failed to build JSON object from DBus message: %m");
 
        r = sd_json_variant_dump(v, arg_json_format_flags, f, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to show JSON object: %m");
 
        return 0;
}
 
static int monitor(int argc, char **argv, int (*dump)(sd_bus_message *m, FILE *f)) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *message = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        uint32_t flags = 0;
        const char *unique_name;
        bool is_monitor = false;
        int r;
 
        r = acquire_bus(true, &bus);
        if (r < 0)
                return r;
 
        usec_t end = arg_timeout > 0 ?
                usec_add(now(CLOCK_MONOTONIC), arg_timeout) : USEC_INFINITY;
 
        /* upgrade connection; it's not used for anything else after this call */
        r = sd_bus_message_new_method_call(bus,
                                           &message,
                                           "org.freedesktop.DBus",
                                           "/org/freedesktop/DBus",
                                           "org.freedesktop.DBus.Monitoring",
                                           "BecomeMonitor");
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_open_container(message, 'a', "s");
        if (r < 0)
                return bus_log_create_error(r);
 
        STRV_FOREACH(i, argv+1) {
                _cleanup_free_ char *m = NULL;
 
                if (!sd_bus_service_name_is_valid(*i))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name '%s'", *i);
 
                m = strjoin("sender='", *i, "'");
                if (!m)
                        return log_oom();
 
                r = sd_bus_message_append_basic(message, 's', m);
                if (r < 0)
                        return bus_log_create_error(r);
 
                free(m);
                m = strjoin("destination='", *i, "'");
                if (!m)
                        return log_oom();
 
                r = sd_bus_message_append_basic(message, 's', m);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        STRV_FOREACH(i, arg_matches) {
                r = sd_bus_message_append_basic(message, 's', *i);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_close_container(message);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_append_basic(message, 'u', &flags);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_call(bus, message, arg_timeout, &error, NULL);
        if (r < 0) {
                notify_bus_error(&error);
                return log_error_errno(r, "Call to org.freedesktop.DBus.Monitoring.BecomeMonitor failed: %s",
                                       bus_error_message(&error, r));
        }
 
        r = sd_bus_get_unique_name(bus, &unique_name);
        if (r < 0)
                return log_error_errno(r, "Failed to get unique name: %m");
 
        if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
                log_info("Monitoring bus message stream.");
 
        (void) sd_notify(/* unset_environment=false */ false, "READY=1");
 
        for (;;) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL;
 
                r = sd_bus_process(bus, &m);
                if (r < 0)
                        return log_error_errno(r, "Failed to process bus: %m");
 
                if (m) {
                        if (!is_monitor) {
                                const char *name;
 
                                /* wait until we lose our unique name */
                                if (sd_bus_message_is_signal(m, "org.freedesktop.DBus", "NameLost") <= 0)
                                        continue;
 
                                r = sd_bus_message_read(m, "s", &name);
                                if (r < 0)
                                        return bus_log_parse_error(r);
 
                                if (streq(name, unique_name))
                                        is_monitor = true;
 
                                continue;
                        }
 
                        dump(m, stdout);
                        fflush(stdout);
 
                        if (arg_limit_messages != UINT64_MAX) {
                                arg_limit_messages--;
 
                                if (arg_limit_messages == 0) {
                                        if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
                                                log_info("Received requested maximum number of messages, exiting.");
                                        return 0;
                                }
                        }
 
                        if (sd_bus_message_is_signal(m, "org.freedesktop.DBus.Local", "Disconnected") > 0) {
                                if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
                                        log_info("Connection terminated, exiting.");
                                return 0;
                        }
 
                        continue;
                }
 
                if (r > 0)
                        continue;
 
                r = sd_bus_wait(bus, arg_timeout > 0 ? usec_sub_unsigned(end, now(CLOCK_MONOTONIC)) : UINT64_MAX);
                if (r == 0 && arg_timeout > 0 && now(CLOCK_MONOTONIC) >= end) {
                        if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
                                log_info("Timed out waiting for messages, exiting.");
                        return 0;
                }
                if (r < 0)
                        return log_error_errno(r, "Failed to wait for bus: %m");
        }
}
 
VERB(verb_monitor, "monitor", "[SERVICE…]\0", VERB_ANY, VERB_ANY, 0,
     "Show bus traffic");
static int verb_monitor(int argc, char *argv[], uintptr_t _data, void *userdata) {
        return monitor(argc, argv, sd_json_format_enabled(arg_json_format_flags) ? message_json : message_dump);
}
 
VERB(verb_capture, "capture", "[SERVICE…]\0", VERB_ANY, VERB_ANY, 0,
     "Capture bus traffic as pcap");
static int verb_capture(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_free_ char *osname = NULL;
        static const char info[] =
                "busctl (systemd) " PROJECT_VERSION_FULL " (Git " GIT_VERSION ")";
        int r;
 
        if (isatty_safe(STDOUT_FILENO))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                       "Refusing to write message data to console, please redirect output to a file.");
 
        r = parse_os_release(NULL, "PRETTY_NAME", &osname);
        if (r < 0)
                log_full_errno(r == -ENOENT ? LOG_DEBUG : LOG_INFO, r,
                               "Failed to read os-release file, ignoring: %m");
        bus_pcap_header(arg_snaplen, osname, info, stdout);
 
        r = monitor(argc, argv, message_pcap);
        if (r < 0)
                return r;
 
        r = fflush_and_check(stdout);
        if (r < 0)
                return log_error_errno(r, "Couldn't write capture file: %m");
 
        return r;
}
 
VERB(verb_status, "status", "[SERVICE]\0", VERB_ANY, 2, 0,
     "Show bus service, process, or bus owner credentials");
static int verb_status(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
        pid_t pid;
        int r;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        pager_open(arg_pager_flags);
 
        if (!isempty(argv[1])) {
                r = parse_pid(argv[1], &pid);
                if (r < 0)
                        r = sd_bus_get_name_creds(
                                        bus,
                                        argv[1],
                                        (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
                                        &creds);
                else
                        r = sd_bus_creds_new_from_pid(
                                        &creds,
                                        pid,
                                        _SD_BUS_CREDS_ALL);
        } else {
                const char *scope, *address;
                sd_id128_t bus_id;
 
                r = sd_bus_get_address(bus, &address);
                if (r >= 0)
                        printf("BusAddress=%s%s%s\n", ansi_highlight(), address, ansi_normal());
 
                r = sd_bus_get_scope(bus, &scope);
                if (r >= 0)
                        printf("BusScope=%s%s%s\n", ansi_highlight(), scope, ansi_normal());
 
                r = sd_bus_get_bus_id(bus, &bus_id);
                if (r >= 0)
                        printf("BusID=%s" SD_ID128_FORMAT_STR "%s\n",
                               ansi_highlight(), SD_ID128_FORMAT_VAL(bus_id), ansi_normal());
 
                r = sd_bus_get_owner_creds(
                                bus,
                                (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) | _SD_BUS_CREDS_ALL,
                                &creds);
        }
 
        if (r < 0)
                return log_error_errno(r, "Failed to get credentials: %m");
 
        bus_creds_dump(creds, NULL, false);
        return 0;
}
 
static int message_append_cmdline(sd_bus_message *m, const char *signature, FDSet **passed_fdset, char ***x) {
        char **p;
        int r;
 
        assert(m);
        assert(signature);
        assert(passed_fdset);
        assert(x);
 
        p = *x;
 
        for (;;) {
                const char *v;
                char t;
 
                t = *signature;
                v = *p;
 
                if (t == 0)
                        break;
                if (!v)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Too few parameters for signature.");
 
                signature++;
                p++;
 
                switch (t) {
 
                case SD_BUS_TYPE_BOOLEAN:
 
                        r = parse_boolean(v);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as boolean: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &r);
                        break;
 
                case SD_BUS_TYPE_BYTE: {
                        uint8_t z;
 
                        r = safe_atou8(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as byte (unsigned 8-bit integer): %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_INT16: {
                        int16_t z;
 
                        r = safe_atoi16(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as signed 16-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_UINT16: {
                        uint16_t z;
 
                        r = safe_atou16(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as unsigned 16-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_INT32: {
                        int32_t z;
 
                        r = safe_atoi32(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as signed 32-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_UINT32: {
                        uint32_t z;
 
                        r = safe_atou32(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as unsigned 32-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_INT64: {
                        int64_t z;
 
                        r = safe_atoi64(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as signed 64-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_UINT64: {
                        uint64_t z;
 
                        r = safe_atou64(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as unsigned 64-bit integer: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_DOUBLE: {
                        double z;
 
                        r = safe_atod(v, &z);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' as double precision floating point: %m", v);
 
                        r = sd_bus_message_append_basic(m, t, &z);
                        break;
                }
 
                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE:
 
                        r = sd_bus_message_append_basic(m, t, v);
                        break;
 
                case SD_BUS_TYPE_ARRAY: {
                        uint32_t n;
                        size_t k;
 
                        r = safe_atou32(v, &n);
                        if (r < 0)
                                return log_error_errno(r, "Failed to parse '%s' number of array entries: %m", v);
 
                        r = signature_element_length(signature, &k);
                        if (r < 0)
                                return log_error_errno(r, "Invalid array signature: %m");
 
                        {
                                char s[k + 1];
                                memcpy(s, signature, k);
                                s[k] = 0;
 
                                r = sd_bus_message_open_container(m, SD_BUS_TYPE_ARRAY, s);
                                if (r < 0)
                                        return bus_log_create_error(r);
 
                                for (unsigned i = 0; i < n; i++) {
                                        r = message_append_cmdline(m, s, passed_fdset, &p);
                                        if (r < 0)
                                                return r;
                                }
                        }
 
                        signature += k;
 
                        r = sd_bus_message_close_container(m);
                        break;
                }
 
                case SD_BUS_TYPE_VARIANT:
                        r = sd_bus_message_open_container(m, SD_BUS_TYPE_VARIANT, v);
                        if (r < 0)
                                return bus_log_create_error(r);
 
                        r = message_append_cmdline(m, v, passed_fdset, &p);
                        if (r < 0)
                                return r;
 
                        r = sd_bus_message_close_container(m);
                        break;
 
                case SD_BUS_TYPE_STRUCT_BEGIN:
                case SD_BUS_TYPE_DICT_ENTRY_BEGIN: {
                        size_t k;
 
                        signature--;
                        p--;
 
                        r = signature_element_length(signature, &k);
                        if (r < 0 || k < 2) {
                                if (r >= 0 && k < 2)
                                        r = -ERANGE;
                                return log_error_errno(r, "Invalid struct/dict entry signature: %m");
                        }
 
                        {
                                char s[k-1];
                                memcpy(s, signature + 1, k - 2);
                                s[k - 2] = 0;
 
                                const char ctype = t == SD_BUS_TYPE_STRUCT_BEGIN ?
                                        SD_BUS_TYPE_STRUCT : SD_BUS_TYPE_DICT_ENTRY;
                                r = sd_bus_message_open_container(m, ctype, s);
                                if (r < 0)
                                        return bus_log_create_error(r);
 
                                r = message_append_cmdline(m, s, passed_fdset, &p);
                                if (r < 0)
                                        return r;
                        }
 
                        signature += k;
 
                        r = sd_bus_message_close_container(m);
                        break;
                }
 
                case SD_BUS_TYPE_UNIX_FD: {
                        int fd;
 
                        fd = parse_fd(v);
                        if (fd < 0)
                                return log_error_errno(fd, "Failed to parse '%s' as a file descriptor: %m", v);
 
                        if (!*passed_fdset) {
                                r = fdset_new_fill(/* filter_cloexec= */ 0, passed_fdset);
                                if (r < 0)
                                        return log_error_errno(r, "Failed to create fd set: %m");
                        }
 
                        if (!fdset_contains(*passed_fdset, fd))
                                return log_error_errno(SYNTHETIC_ERRNO(EBADF), "Failed to find file descriptor '%s' among passed file descriptors.", v);
 
                        r = sd_bus_message_append_basic(m, t, &fd);
                        break;
                }
 
                default:
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Unknown signature type %c.", t);
                }
 
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        *x = p;
        return 0;
}
 
static int bus_message_dump(sd_bus_message *m, uint64_t flags) {
        const char *contents;
        int r;
 
        assert(m);
 
        r = sd_bus_message_rewind(m, !FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY));
        if (r < 0)
                return log_error_errno(r, "Failed to rewind: %m");
 
        if (FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
                r = sd_bus_message_peek_type(m, /* ret_type= */ NULL, &contents);
                if (r < 0)
                        return bus_log_parse_error(r);
 
                r = sd_bus_message_enter_container(m, 'v', contents);
                if (r < 0)
                        return bus_log_parse_error(r);
        } else {
                r = sd_bus_message_is_empty(m);
                if (r < 0)
                        return bus_log_parse_error(r);
                if (r > 0 || arg_quiet)
                        return 0;
        }
 
        if (sd_json_format_enabled(arg_json_format_flags)) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
 
                if (arg_json_format_flags & (SD_JSON_FORMAT_PRETTY|SD_JSON_FORMAT_PRETTY_AUTO))
                        pager_open(arg_pager_flags);
 
                r = sd_bus_message_dump_json(m, flags, &v);
                if (r < 0)
                        return log_error_errno(r, "Failed to dump DBus message to JSON object: %m");
 
                r = sd_json_variant_dump(v, arg_json_format_flags, NULL, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to dump JSON object: %m");
 
        } else if (arg_verbose) {
                pager_open(arg_pager_flags);
 
                r = sd_bus_message_dump(m, NULL, flags);
                if (r < 0)
                        return log_error_errno(r, "Failed to dump DBus message: %m");
        } else {
 
                fputs(FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY) ? contents : sd_bus_message_get_signature(m, true), stdout);
                fputc(' ', stdout);
 
                r = format_cmdline(m, stdout, /* needs_space= */ false);
                if (r < 0)
                        return bus_log_parse_error(r);
 
                fputc('\n', stdout);
        }
 
        if (FLAGS_SET(flags, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY)) {
                r = sd_bus_message_exit_container(m);
                if (r < 0)
                        return bus_log_parse_error(r);
        }
 
        return 0;
}
 
VERB(verb_call, "call", "SERVICE OBJECT INTERFACE METHOD [SIGNATURE [ARGUMENT…]]\0", 5, VERB_ANY, 0,
     "Call a method");
static int verb_call(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *m = NULL, *reply = NULL;
        _cleanup_fdset_free_ FDSet *passed_fdset = NULL;
        int r;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return 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]);
        if (!member_name_is_valid(argv[4]))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid member name: %s", argv[4]);
 
        r = sd_bus_message_new_method_call(bus, &m, argv[1], argv[2], argv[3], argv[4]);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_set_expect_reply(m, arg_expect_reply);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_set_auto_start(m, arg_auto_start);
        if (r < 0)
                return bus_log_create_error(r);
 
        r = sd_bus_message_set_allow_interactive_authorization(m, arg_allow_interactive_authorization);
        if (r < 0)
                return bus_log_create_error(r);
 
        if (!isempty(argv[5])) {
                char **p;
 
                p = argv+6;
 
                r = message_append_cmdline(m, argv[5], &passed_fdset, &p);
                if (r < 0)
                        return r;
 
                if (*p)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Too many parameters for signature.");
        }
 
        if (!arg_expect_reply) {
                r = sd_bus_send(bus, m, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to send message: %m");
 
                return 0;
        }
 
        r = sd_bus_call(bus, m, arg_timeout, &error, &reply);
        if (r < 0) {
                notify_bus_error(&error);
                return log_error_errno(r, "Call failed: %s", bus_error_message(&error, r));
        }
 
        return bus_message_dump(reply, /* flags= */ 0);
}
 
VERB(verb_emit, "emit", "OBJECT INTERFACE SIGNAL [SIGNATURE [ARGUMENT…]]\0", 4, VERB_ANY, 0,
     "Emit a signal");
static int verb_emit(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_fdset_free_ FDSet *passed_fdset = NULL;
        int r;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        r = sd_bus_message_new_signal(bus, &m, argv[1], argv[2], argv[3]);
        if (r < 0)
                return bus_log_create_error(r);
 
        if (arg_destination) {
                r = sd_bus_message_set_destination(m, arg_destination);
                if (r < 0)
                        return bus_log_create_error(r);
        }
 
        r = sd_bus_message_set_auto_start(m, arg_auto_start);
        if (r < 0)
                return bus_log_create_error(r);
 
        if (!isempty(argv[4])) {
                char **p;
 
                p = argv+5;
 
                r = message_append_cmdline(m, argv[4], &passed_fdset, &p);
                if (r < 0)
                        return r;
 
                if (*p)
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Too many parameters for signature.");
        }
 
        r = sd_bus_send(bus, m, NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to send signal: %m");
 
        return 0;
}
 
VERB(verb_get_property, "get-property", "SERVICE OBJECT INTERFACE PROPERTY…\0", 5, VERB_ANY, 0,
     "Get property value");
static int verb_get_property(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        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;
 
        STRV_FOREACH(i, argv + 4) {
                _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 
                r = sd_bus_call_method(bus, argv[1], argv[2],
                                       "org.freedesktop.DBus.Properties", "Get",
                                       &error, &reply, "ss", argv[3], *i);
                if (r < 0) {
                        notify_bus_error(&error);
                        return log_error_errno(r, "Failed to get property %s on interface %s: %s",
                                               *i, argv[3],
                                               bus_error_message(&error, r));
                }
 
                r = bus_message_dump(reply, SD_BUS_MESSAGE_DUMP_SUBTREE_ONLY);
                if (r < 0)
                        return r;
        }
 
        return 0;
}
 
static int on_bus_signal(sd_bus_message *msg, void *userdata, sd_bus_error *ret_error) {
        int r;
 
        r = bus_message_dump(msg, /* flags= */ 0);
        if (r < 0)
                return sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(ASSERT_PTR(msg))), r);
 
        if (arg_limit_signals != UINT64_MAX) {
                arg_limit_signals--;
 
                if (arg_limit_signals == 0) {
                        if (!arg_quiet && !sd_json_format_enabled(arg_json_format_flags))
                                log_info("Received requested maximum number of signals, exiting.");
 
                        return sd_event_exit(sd_bus_get_event(sd_bus_message_get_bus(ASSERT_PTR(msg))), 0);
                }
        }
 
        return 0;
}
 
VERB(verb_wait, "wait", "[SERVICE] OBJECT INTERFACE SIGNAL\0", 4, 5, 0,
     "Wait for a signal");
static int verb_wait(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_(sd_event_unrefp) sd_event *e = NULL;
        _cleanup_(sd_event_source_unrefp) sd_event_source *timer = NULL;
        int argn = 1, r;
 
        const char *sender = argc == 5 ? argv[argn++] : NULL;
        const char *path = argv[argn++];
        const char *interface = argv[argn++];
        const char *member = argv[argn++];
 
        if (sender && !service_name_is_valid(sender))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid service name: %s", sender);
        if (!object_path_is_valid(path))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid object path: %s", path);
        if (!interface_name_is_valid(interface))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid interface name: %s", interface);
        if (!member_name_is_valid(member))
                return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Invalid member name: %s", member);
 
        r = acquire_bus(/* set_monitor= */ false, &bus);
        if (r < 0)