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 1–1000 of 2,308

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <unistd.h>
 
#include "sd-bus.h"
#include "sd-daemon.h"
#include "sd-event.h"
#include "sd-json.h"
 
#include "alloc-util.h"
#include "ansi-color.h"
#include "bitfield.h"
#include "build.h"
#include "bus-dump.h"
#include "bus-error.h"
#include "bus-internal.h"
#include "bus-signature.h"
#include "bus-type.h"
#include "bus-util.h"
#include "busctl-introspect.h"
#include "capsule-util.h"
#include "errno-util.h"
#include "escape.h"
#include "fd-util.h"
#include "fdset.h"
#include "fileio.h"
#include "format-table.h"
#include "glyph-util.h"
#include "log.h"
#include "logarithm.h"
#include "main-func.h"
#include "memstream-util.h"
#include "os-util.h"
#include "pager.h"
#include "parse-argument.h"
#include "parse-util.h"
#include "path-util.h"
#include "runtime-scope.h"
#include "set.h"
#include "string-util.h"
#include "strv.h"
#include "terminal-util.h"
#include "time-util.h"
#include "user-util.h"
#include "verbs.h"
#include "version.h"
 
static sd_json_format_flags_t arg_json_format_flags = SD_JSON_FORMAT_OFF;
static PagerFlags arg_pager_flags = 0;
static bool arg_legend = true;
static int arg_full = -1;
static const char *arg_address = NULL;
static bool arg_unique = false;
static bool arg_acquired = false;
static bool arg_activatable = false;
static bool arg_show_machine = false;
static char **arg_matches = NULL;
static BusTransport arg_transport = BUS_TRANSPORT_LOCAL;
static const char *arg_host = NULL;
static RuntimeScope arg_runtime_scope = RUNTIME_SCOPE_SYSTEM;
static size_t arg_snaplen = 4096;
static bool arg_list = false;
static bool arg_quiet = false;
static bool arg_verbose = false;
static bool arg_xml_interface = false;
static bool arg_expect_reply = true;
static bool arg_auto_start = true;
static bool arg_allow_interactive_authorization = true;
static bool arg_augment_creds = true;
static bool arg_watch_bind = false;
static usec_t arg_timeout = 0;
static const char *arg_destination = NULL;
static uint64_t arg_limit_messages = UINT64_MAX;
static uint64_t arg_limit_signals = 1;
 
STATIC_DESTRUCTOR_REGISTER(arg_matches, strv_freep);
 
COMMAND(
        "busctl\0",
        "Introspect the D-Bus IPC bus.",
        .man_pages = "busctl(1)\0",
        .pager_flags = &arg_pager_flags,
        .flags = COMMAND_HELP_SEPARATE,  /* the verb table is very wide */
);
 
#define NAME_IS_ACQUIRED INT_TO_PTR(1)
#define NAME_IS_ACTIVATABLE INT_TO_PTR(2)
 
static int acquire_bus(bool set_monitor, sd_bus **ret) {
        _cleanup_(sd_bus_close_unrefp) sd_bus *bus = NULL;
        _cleanup_close_ int pin_fd = -EBADF;
        int r;
 
        assert(ret);
 
        r = sd_bus_new(&bus);
        if (r < 0)
                return log_error_errno(r, "Failed to allocate bus: %m");
 
        (void) sd_bus_set_description(bus, "busctl");
 
        if (set_monitor) {
                r = sd_bus_set_monitor(bus, true);
                if (r < 0)
                        return log_error_errno(r, "Failed to set monitor mode: %m");
 
                r = sd_bus_negotiate_creds(bus, true, _SD_BUS_CREDS_ALL);
                if (r < 0)
                        return log_error_errno(r, "Failed to enable credentials: %m");
 
                r = sd_bus_negotiate_timestamp(bus, true);
                if (r < 0)
                        return log_error_errno(r, "Failed to enable timestamps: %m");
 
                r = sd_bus_negotiate_fds(bus, true);
                if (r < 0)
                        return log_error_errno(r, "Failed to enable fds: %m");
        }
 
        r = sd_bus_set_bus_client(bus, true);
        if (r < 0)
                return log_error_errno(r, "Failed to set bus client: %m");
 
        r = sd_bus_set_watch_bind(bus, arg_watch_bind);
        if (r < 0)
                return log_error_errno(r, "Failed to set watch-bind setting to '%s': %m",
                                       yes_no(arg_watch_bind));
 
        if (arg_address)
                r = sd_bus_set_address(bus, arg_address);
        else
                switch (arg_transport) {
 
                case BUS_TRANSPORT_LOCAL:
 
                        switch (arg_runtime_scope) {
 
                        case RUNTIME_SCOPE_USER:
                                r = bus_set_address_user(bus);
                                break;
 
                        case RUNTIME_SCOPE_SYSTEM:
                                r = bus_set_address_system(bus);
                                break;
 
                        default:
                                assert_not_reached();
                        }
 
                        break;
 
                case BUS_TRANSPORT_REMOTE:
                        r = bus_set_address_system_remote(bus, arg_host);
                        break;
 
                case BUS_TRANSPORT_MACHINE:
                        r = bus_set_address_machine(bus, arg_runtime_scope, arg_host);
                        break;
 
                case BUS_TRANSPORT_CAPSULE:
                        r = bus_set_address_capsule_bus(bus, arg_host, &pin_fd);
                        break;
 
                default:
                        assert_not_reached();
                }
        if (r < 0)
                return bus_log_address_error(r, arg_transport);
 
        r = sd_bus_start(bus);
        if (r < 0)
                return bus_log_connect_error(r, arg_transport, arg_runtime_scope);
 
        *ret = TAKE_PTR(bus);
 
        return 0;
}
 
static void notify_bus_error(const sd_bus_error *error) {
 
        if (!sd_bus_error_is_set(error))
                return;
 
        (void) sd_notifyf(/* unset_environment= */ false, "BUSERROR=%s", error->name);
}
 
VERB_DEFAULT_NOARG(verb_list, "list", "List bus names");
static int verb_list(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_strv_free_ char **acquired = NULL, **activatable = NULL;
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        _cleanup_hashmap_free_ Hashmap *names = NULL;
        _cleanup_(table_unrefp) Table *table = NULL;
        char *k;
        void *v;
        int r;
 
        enum {
                COLUMN_ACTIVATABLE,
                COLUMN_NAME,
                COLUMN_PID,
                COLUMN_PROCESS,
                COLUMN_USER,
                COLUMN_CONNECTION,
                COLUMN_UNIT,
                COLUMN_SESSION,
                COLUMN_DESCRIPTION,
                COLUMN_MACHINE,
        };
 
        if (!arg_unique && !arg_acquired && !arg_activatable)
                arg_unique = arg_acquired = arg_activatable = true;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        r = sd_bus_list_names(bus,
                              (arg_acquired || arg_unique) ? &acquired : NULL,
                              arg_activatable ? &activatable : NULL);
        if (r < 0)
                return log_error_errno(r, "Failed to list names: %m");
 
        names = hashmap_new(&string_hash_ops);
        if (!names)
                return log_oom();
 
        STRV_FOREACH(i, acquired) {
                r = hashmap_put(names, *i, NAME_IS_ACQUIRED);
                if (r < 0)
                        return log_error_errno(r, "Failed to add to hashmap: %m");
        }
 
        STRV_FOREACH(i, activatable) {
                r = hashmap_put(names, *i, NAME_IS_ACTIVATABLE);
                if (r < 0 && r != -EEXIST)
                        return log_error_errno(r, "Failed to add to hashmap: %m");
        }
 
        table = table_new("activatable",
                          "name",
                          "pid",
                          "process",
                          "user",
                          "connection",
                          "unit",
                          "session",
                          "description",
                          "machine");
        if (!table)
                return log_oom();
 
        if (arg_full > 0)
                table_set_width(table, 0);
 
        r = table_set_align_percent(table, table_get_cell(table, 0, COLUMN_PID), 100);
        if (r < 0)
                return log_error_errno(r, "Failed to set alignment: %m");
 
        table_set_ersatz_string(table, TABLE_ERSATZ_DASH);
 
        r = table_set_sort(table, (size_t) COLUMN_NAME);
        if (r < 0)
                return log_error_errno(r, "Failed to set sort column: %m");
 
        if (arg_show_machine)
                r = table_set_display(table, (size_t) COLUMN_NAME,
                                             (size_t) COLUMN_PID,
                                             (size_t) COLUMN_PROCESS,
                                             (size_t) COLUMN_USER,
                                             (size_t) COLUMN_CONNECTION,
                                             (size_t) COLUMN_UNIT,
                                             (size_t) COLUMN_SESSION,
                                             (size_t) COLUMN_DESCRIPTION,
                                             (size_t) COLUMN_MACHINE);
        else
                r = table_set_display(table, (size_t) COLUMN_NAME,
                                             (size_t) COLUMN_PID,
                                             (size_t) COLUMN_PROCESS,
                                             (size_t) COLUMN_USER,
                                             (size_t) COLUMN_CONNECTION,
                                             (size_t) COLUMN_UNIT,
                                             (size_t) COLUMN_SESSION,
                                             (size_t) COLUMN_DESCRIPTION);
 
        if (r < 0)
                return log_error_errno(r, "Failed to set columns to display: %m");
 
        HASHMAP_FOREACH_KEY(v, k, names) {
                _cleanup_(sd_bus_creds_unrefp) sd_bus_creds *creds = NULL;
 
                if (v == NAME_IS_ACTIVATABLE) {
                        r = table_add_many(
                                        table,
                                        TABLE_INT, PTR_TO_INT(v),
                                        TABLE_STRING, k,
                                        TABLE_EMPTY,
                                        TABLE_EMPTY,
                                        TABLE_EMPTY,
                                        TABLE_STRING, "(activatable)", TABLE_SET_COLOR, ansi_grey(),
                                        TABLE_EMPTY,
                                        TABLE_EMPTY,
                                        TABLE_EMPTY,
                                        TABLE_EMPTY);
                        if (r < 0)
                                return table_log_add_error(r);
 
                        continue;
                }
 
                assert(v == NAME_IS_ACQUIRED);
 
                if (!arg_unique && k[0] == ':')
                        continue;
 
                if (!arg_acquired && k[0] != ':')
                        continue;
 
                r = table_add_many(table,
                                   TABLE_INT, PTR_TO_INT(v),
                                   TABLE_STRING, k);
                if (r < 0)
                        return table_log_add_error(r);
 
                r = sd_bus_get_name_creds(
                                bus, k,
                                (arg_augment_creds ? SD_BUS_CREDS_AUGMENT : 0) |
                                SD_BUS_CREDS_EUID|SD_BUS_CREDS_PID|SD_BUS_CREDS_COMM|
                                SD_BUS_CREDS_UNIQUE_NAME|SD_BUS_CREDS_UNIT|SD_BUS_CREDS_SESSION|
                                SD_BUS_CREDS_DESCRIPTION, &creds);
                if (r < 0) {
                        log_debug_errno(r, "Failed to acquire credentials of service %s, ignoring: %m", k);
 
                        r = table_fill_empty(table, COLUMN_MACHINE);
                } else {
                        const char *unique = NULL, *session = NULL, *unit = NULL, *cn = NULL;
                        pid_t pid;
                        uid_t uid;
 
                        r = sd_bus_creds_get_pid(creds, &pid);
                        if (r >= 0) {
                                const char *comm = NULL;
 
                                (void) sd_bus_creds_get_comm(creds, &comm);
 
                                r = table_add_many(table,
                                                   TABLE_PID, pid,
                                                   TABLE_STRING, strna(comm));
                        } else
                                r = table_add_many(table, TABLE_EMPTY, TABLE_EMPTY);
                        if (r < 0)
                                return table_log_add_error(r);
 
                        r = sd_bus_creds_get_euid(creds, &uid);
                        if (r >= 0) {
                                _cleanup_free_ char *u = NULL;
 
                                u = uid_to_name(uid);
                                if (!u)
                                        return log_oom();
 
                                r = table_add_cell(table, NULL, TABLE_STRING, u);
                        } else
                                r = table_add_cell(table, NULL, TABLE_EMPTY, NULL);
                        if (r < 0)
                                return table_log_add_error(r);
 
                        (void) sd_bus_creds_get_unique_name(creds, &unique);
                        (void) sd_bus_creds_get_unit(creds, &unit);
                        (void) sd_bus_creds_get_session(creds, &session);
                        (void) sd_bus_creds_get_description(creds, &cn);
 
                        r = table_add_many(
                                        table,
                                        TABLE_STRING, unique,
                                        TABLE_STRING, unit,
                                        TABLE_STRING, session,
                                        TABLE_STRING, cn);
                }
                if (r < 0)
                        return table_log_add_error(r);
 
                if (arg_show_machine) {
                        sd_id128_t mid;
 
                        r = sd_bus_get_name_machine_id(bus, k, &mid);
                        if (r < 0)
                                log_debug_errno(r, "Failed to acquire credentials of service %s, ignoring: %m", k);
                        else {
                                r = table_add_cell(table, NULL, TABLE_ID128, &mid);
                                if (r < 0)
                                        return table_log_add_error(r);
 
                                continue; /* line fully filled, no need to fill the remainder below */
                        }
                }
 
                r = table_fill_empty(table, 0);
                if (r < 0)
                        return log_error_errno(r, "Failed to fill line: %m");
        }
 
        return table_print_with_pager(table, arg_json_format_flags, arg_pager_flags, arg_legend);
}
 
static void print_subtree(const char *prefix, const char *path, char **l) {
        assert(l);
 
        /* We assume the list is sorted. Let's first skip over the
         * entry we are looking at. */
        for (;;) {
                if (!*l)
                        return;
 
                if (!streq(*l, path))
                        break;
 
                l++;
        }
 
        const char
                *vertical = strjoina(prefix, glyph(GLYPH_TREE_VERTICAL)),
                *space = strjoina(prefix, glyph(GLYPH_TREE_SPACE));
 
        for (;;) {
                bool has_more = false;
                char **n;
 
                if (!*l || !path_startswith(*l, path))
                        break;
 
                n = l + 1;
                for (;;) {
                        if (!*n || !path_startswith(*n, path))
                                break;
 
                        if (!path_startswith(*n, *l)) {
                                has_more = true;
                                break;
                        }
 
                        n++;
                }
 
                printf("%s%s %s\n",
                       prefix,
                       glyph(has_more ? GLYPH_TREE_BRANCH : GLYPH_TREE_RIGHT),
                       *l);
 
                print_subtree(has_more ? vertical : space, *l, l);
                l = n;
        }
}
 
static void print_tree(char **l) {
        if (arg_list)
                strv_print(l);
        else if (strv_isempty(l))
                printf("No objects discovered.\n");
        else if (streq(l[0], "/") && !l[1])
                printf("Only root object discovered.\n");
        else
                print_subtree("", "/", l);
}
 
static int on_path(const char *path, void *userdata) {
        Set *paths = ASSERT_PTR(userdata);
        int r;
 
        r = set_put_strdup(&paths, path);
        if (r < 0)
                return log_oom();
 
        return 0;
}
 
static int find_nodes(sd_bus *bus, const char *service, const char *path, Set *paths) {
        static const XMLIntrospectOps ops = {
                .on_path = on_path,
        };
 
        _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
        _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
        const char *xml;
        int r;
 
        r = sd_bus_call_method(bus, service, path,
                               "org.freedesktop.DBus.Introspectable", "Introspect",
                               &error, &reply, NULL);
        if (r < 0) {
                notify_bus_error(&error);
                printf("%sFailed to introspect object %s of service %s: %s%s\n",
                       ansi_highlight_red(),
                       path, service, bus_error_message(&error, r),
                       ansi_normal());
                return r;
        }
 
        r = sd_bus_message_read(reply, "s", &xml);
        if (r < 0)
                return bus_log_parse_error(r);
 
        return parse_xml_introspect(path, xml, &ops, paths);
}
 
static int tree_one(sd_bus *bus, const char *service) {
        _cleanup_set_free_ Set *paths = NULL, *done = NULL, *failed = NULL;
        _cleanup_free_ char **l = NULL;
        int r;
 
        r = set_put_strdup(&paths, "/");
        if (r < 0)
                return log_oom();
 
        for (;;) {
                _cleanup_free_ char *p = NULL;
                int q;
 
                p = set_steal_first(paths);
                if (!p)
                        break;
 
                if (set_contains(done, p) ||
                    set_contains(failed, p))
                        continue;
 
                q = find_nodes(bus, service, p, paths);
                if (q < 0 && r >= 0)
                        r = q;
 
                q = set_ensure_consume(q < 0 ? &failed : &done, &string_hash_ops_free, TAKE_PTR(p));
                assert(q != 0);
                if (q < 0)
                        return log_oom();
        }
 
        pager_open(arg_pager_flags);
 
        l = set_get_strv(done);
        if (!l)
                return log_oom();
 
        strv_sort(l);
        print_tree(l);
 
        fflush(stdout);
 
        return r;
}
 
VERB(verb_tree, "tree", "[SERVICE…]\0", VERB_ANY, VERB_ANY, 0,
     "Show object tree of service");
static int verb_tree(int argc, char *argv[], uintptr_t _data, void *userdata) {
        _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
        int r;
 
        /* Do superficial verification of arguments before even opening the bus */
        STRV_FOREACH(i, strv_skip(argv, 1))
                if (!sd_bus_service_name_is_valid(*i))
                        return log_error_errno(SYNTHETIC_ERRNO(EINVAL),
                                               "Invalid bus service name: %s", *i);
 
        if (!arg_unique && !arg_acquired)
                arg_acquired = true;
 
        r = acquire_bus(false, &bus);
        if (r < 0)
                return r;
 
        char **args = strv_skip(argv, 1);
        if (args)
                STRV_FOREACH(arg, args) {
                        if (arg != args)
                                puts("");
 
                        if (args[1]) {
                                pager_open(arg_pager_flags);
                                printf("Service %s%s%s:\n", ansi_highlight(), *arg, ansi_normal());
                        }
 
                        RET_GATHER(r, tree_one(bus, *arg));
                }
        else {
                _cleanup_strv_free_ char **names = NULL;
 
                r = sd_bus_list_names(bus, &names, NULL);
                if (r < 0)
                        return log_error_errno(r, "Failed to get name list: %m");
 
                pager_open(arg_pager_flags);
 
                STRV_FOREACH(name, names) {
                        if (!arg_unique && (*name)[0] == ':')
                                continue;
 
                        if (!arg_acquired && (*name)[0] == ':')
                                continue;
 
                        if (name != names)
                                puts("");
 
                        printf("Service %s%s%s:\n", ansi_highlight(), *name, ansi_normal());
 
                        RET_GATHER(r, tree_one(bus, *name));
                }
        }
 
        return r;
}
 
static int format_cmdline(sd_bus_message *m, FILE *f, bool needs_space) {
        int r;
 
        for (;;) {
                const char *contents = NULL;
                char type;
                union {
                        uint8_t u8;
                        uint16_t u16;
                        int16_t s16;
                        uint32_t u32;
                        int32_t s32;
                        uint64_t u64;
                        int64_t s64;
                        double d64;
                        const char *string;
                        int i;
                } basic;
 
                r = sd_bus_message_peek_type(m, &type, &contents);
                if (r < 0)
                        return r;
                if (r == 0)
                        return needs_space;
 
                if (bus_type_is_container(type) > 0) {
 
                        r = sd_bus_message_enter_container(m, type, contents);
                        if (r < 0)
                                return r;
 
                        if (type == SD_BUS_TYPE_ARRAY) {
                                unsigned n = 0;
 
                                /* count array entries */
                                for (;;) {
 
                                        r = sd_bus_message_skip(m, contents);
                                        if (r < 0)
                                                return r;
                                        if (r == 0)
                                                break;
 
                                        n++;
                                }
 
                                r = sd_bus_message_rewind(m, false);
                                if (r < 0)
                                        return r;
 
                                if (needs_space)
                                        fputc(' ', f);
 
                                fprintf(f, "%u", n);
                                needs_space = true;
 
                        } else if (type == SD_BUS_TYPE_VARIANT) {
 
                                if (needs_space)
                                        fputc(' ', f);
 
                                fprintf(f, "%s", contents);
                                needs_space = true;
                        }
 
                        r = format_cmdline(m, f, needs_space);
                        if (r < 0)
                                return r;
 
                        needs_space = r > 0;
 
                        r = sd_bus_message_exit_container(m);
                        if (r < 0)
                                return r;
 
                        continue;
                }
 
                r = sd_bus_message_read_basic(m, type, &basic);
                if (r < 0)
                        return r;
 
                if (needs_space)
                        fputc(' ', f);
 
                switch (type) {
                case SD_BUS_TYPE_BYTE:
                        fprintf(f, "%u", basic.u8);
                        break;
 
                case SD_BUS_TYPE_BOOLEAN:
                        fputs(true_false(basic.i), f);
                        break;
 
                case SD_BUS_TYPE_INT16:
                        fprintf(f, "%i", basic.s16);
                        break;
 
                case SD_BUS_TYPE_UINT16:
                        fprintf(f, "%u", basic.u16);
                        break;
 
                case SD_BUS_TYPE_INT32:
                        fprintf(f, "%i", basic.s32);
                        break;
 
                case SD_BUS_TYPE_UINT32:
                        fprintf(f, "%u", basic.u32);
                        break;
 
                case SD_BUS_TYPE_INT64:
                        fprintf(f, "%" PRIi64, basic.s64);
                        break;
 
                case SD_BUS_TYPE_UINT64:
                        fprintf(f, "%" PRIu64, basic.u64);
                        break;
 
                case SD_BUS_TYPE_DOUBLE:
                        fprintf(f, "%g", basic.d64);
                        break;
 
                case SD_BUS_TYPE_STRING:
                case SD_BUS_TYPE_OBJECT_PATH:
                case SD_BUS_TYPE_SIGNATURE: {
                        _cleanup_free_ char *b = NULL;
 
                        b = cescape(basic.string);
                        if (!b)
                                return -ENOMEM;
 
                        fprintf(f, "\"%s\"", b);
                        break;
                }
 
                case SD_BUS_TYPE_UNIX_FD:
                        fprintf(f, "%i", basic.i);
                        break;
 
                default:
                        assert_not_reached();
                }
 
                needs_space = true;
        }
}
 
typedef struct Member {
        const char *type;
        char *interface;
        char *name;
        char *signature;
        char *result;
        char *value;
        bool writable;
        uint64_t flags;
} Member;
 
static void member_hash_func(const Member *m, struct siphash *state) {
        uint64_t arity = 1;
 
        assert(m);
        assert(m->type);
 
        string_hash_func(m->type, state);
 
        arity += !!m->name + !!m->interface;
 
        uint64_hash_func(&arity, state);
 
        if (m->name)
                string_hash_func(m->name, state);
 
        if (m->signature)
                string_hash_func(m->signature, state);
 
        if (m->interface)
                string_hash_func(m->interface, state);
}
 
static int member_compare_func(const Member *x, const Member *y) {
        int d;
 
        assert(x);
        assert(y);
        assert(x->type);
        assert(y->type);
 
        d = strcmp_ptr(x->interface, y->interface);
        if (d != 0)
                return d;
 
        d = strcmp(x->type, y->type);
        if (d != 0)
                return d;
 
        d = strcmp_ptr(x->name, y->name);
        if (d != 0)
                return d;
 
        return strcmp_ptr(x->signature, y->signature);
}
 
static Member* member_free(Member *m) {
        if (!m)
                return NULL;
 
        free(m->interface);
        free(m->name);
        free(m->signature);
        free(m->result);
        free(m->value);
        return mfree(m);
}
DEFINE_TRIVIAL_CLEANUP_FUNC(Member*, member_free);
 
static int on_interface(const char *interface, uint64_t flags, void *userdata) {
        _cleanup_(member_freep) Member *m = NULL;
        Set *members = ASSERT_PTR(userdata);
        int r;
 
        assert(interface);
 
        m = new(Member, 1);
        if (!m)
                return log_oom();
 
        *m = (Member) {
                .type = "interface",
                .flags = flags,
        };
 
        r = strdup_to(&m->interface, interface);
        if (r < 0)
                return log_oom();
 
        r = set_consume(members, TAKE_PTR(m));
        if (r < 0)
                return log_oom();
        if (r == 0)
                return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
                                       "Invalid introspection data: duplicate interface '%s'.", interface);
 
        return 0;
}
 
static int on_method(const char *interface, const char *name, const char *signature, const char *result, uint64_t flags, void *userdata) {
        _cleanup_(member_freep) Member *m = NULL;
        Set *members = userdata;
        int r;
 
        assert(interface);
        assert(name);
 
        m = new(Member, 1);
        if (!m)
                return log_oom();
 
        *m = (Member) {
                .type = "method",
                .flags = flags,
        };
 
        r = strdup_to(&m->interface, interface);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->name, name);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->signature, signature);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->result, result);
        if (r < 0)
                return log_oom();
 
        r = set_consume(members, TAKE_PTR(m));
        if (r < 0)
                return log_oom();
        if (r == 0)
                return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
                                       "Invalid introspection data: duplicate method '%s' on interface '%s'.", name, interface);
 
        return 0;
}
 
static int on_signal(const char *interface, const char *name, const char *signature, uint64_t flags, void *userdata) {
        _cleanup_(member_freep) Member *m = NULL;
        Set *members = userdata;
        int r;
 
        assert(interface);
        assert(name);
 
        m = new(Member, 1);
        if (!m)
                return log_oom();
 
        *m = (Member) {
                .type = "signal",
                .flags = flags,
        };
 
        r = strdup_to(&m->interface, interface);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->name, name);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->signature, signature);
        if (r < 0)
                return log_oom();
 
        r = set_consume(members, TAKE_PTR(m));
        if (r < 0)
                return log_oom();
        if (r == 0)
                return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
                                       "Invalid introspection data: duplicate signal '%s' on interface '%s'.", name, interface);
 
        return 0;
}
 
static int on_property(const char *interface, const char *name, const char *signature, bool writable, uint64_t flags, void *userdata) {
        _cleanup_(member_freep) Member *m = NULL;
        Set *members = userdata;
        int r;
 
        assert(interface);
        assert(name);
 
        m = new(Member, 1);
        if (!m)
                return log_oom();
 
        *m = (Member) {
                .type = "property",
                .flags = flags,
                .writable = writable,
        };
 
        r = strdup_to(&m->interface, interface);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->name, name);
        if (r < 0)
                return log_oom();
 
        r = strdup_to(&m->signature, signature);
        if (r < 0)
                return log_oom();
 
        r = set_consume(members, TAKE_PTR(m));
        if (r < 0)
                return log_oom();
        if (r == 0)
                return log_error_errno(SYNTHETIC_ERRNO(EEXIST),
                                       "Invalid introspection data: duplicate property '%s' on interface '%s'.", name, interface);
 
        return 0;
}
 
DEFINE_PRIVATE_HASH_OPS_WITH_KEY_DESTRUCTOR(
                member_hash_ops,
                Member,
                member_hash_func,
                member_compare_func,
                member_free);
 
static int members_flags_to_string(const Member *m, char **ret) {
        static const char *map[] = {
                [LOG2U(SD_BUS_VTABLE_DEPRECATED)]                  = "deprecated",
                [LOG2U(SD_BUS_VTABLE_METHOD_NO_REPLY)]             = "no-reply",
                [LOG2U(SD_BUS_VTABLE_PROPERTY_CONST)]              = "const",
                [LOG2U(SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE)]       = "emits-change",
                [LOG2U(SD_BUS_VTABLE_PROPERTY_EMITS_INVALIDATION)] = "emits-invalidation",
        };
 
        assert(m);
        assert(ret);
 
        _cleanup_free_ char *str = NULL;
        for (size_t i = 0; i < ELEMENTSOF(map); i++)
                if (BIT_SET(m->flags, i) && map[i])
                        if (!strextend_with_separator(&str, " ", map[i]))