HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/busctl/busctl.c
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]))