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