HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-bus/sd-bus.c
Git blob: 1a6eed2baad85e39cff35c47f1771ee148f511c6
Lines 4001–4512 of 4,512
}
_public_ int sd_bus_default_system(sd_bus **ret) {
return bus_default(sd_bus_open_system, &default_system_bus, ret);
}
_public_ int sd_bus_default_user(sd_bus **ret) {
return bus_default(sd_bus_open_user, &default_user_bus, ret);
}
_public_ int sd_bus_default(sd_bus **ret) {
int (*bus_open)(sd_bus **) = NULL;
sd_bus **busp;
busp = bus_choose_default(&bus_open);
return bus_default(bus_open, busp, ret);
}
_public_ int sd_bus_get_tid(sd_bus *b, pid_t *ret) {
assert_return(b, -EINVAL);
assert_return(ret, -EINVAL);
assert_return(!bus_origin_changed(b), -ECHILD);
if (b->tid != 0) {
*ret = b->tid;
return 0;
}
if (b->event)
return sd_event_get_tid(b->event, ret);
return -ENXIO;
}
_public_ int sd_bus_path_encode(const char *prefix, const char *external_id, char **ret) {
_cleanup_free_ char *e = NULL;
char *s;
assert_return(object_path_is_valid(prefix), -EINVAL);
assert_return(external_id, -EINVAL);
assert_return(ret, -EINVAL);
e = bus_label_escape(external_id);
if (!e)
return -ENOMEM;
s = path_join(prefix, e);
if (!s)
return -ENOMEM;
*ret = s;
return 0;
}
_public_ int sd_bus_path_decode(const char *path, const char *prefix, char **ret) {
const char *e;
char *s;
assert_return(object_path_is_valid(path), -EINVAL);
assert_return(object_path_is_valid(prefix), -EINVAL);
assert_return(ret, -EINVAL);
e = object_path_startswith(path, prefix);
if (!e) {
*ret = NULL;
return 0;
}
/* Note that 'e' might be an empty string here. That's expected. E.g. a case where the subtree
* corresponds to a subtree on a disk, and we want to return something that represents the root
* of the filesystem. */
s = bus_label_unescape(e);
if (!s)
return -ENOMEM;
*ret = s;
return 1;
}
_public_ int sd_bus_path_encode_many(char **ret, const char *path_template, ...) {
_cleanup_strv_free_ char **labels = NULL;
char *path, *path_pos, **label_pos;
const char *sep, *template_pos;
size_t path_length;
va_list list;
int r;
assert_return(ret, -EINVAL);
assert_return(path_template, -EINVAL);
path_length = strlen(path_template);
va_start(list, path_template);
for (sep = strchr(path_template, '%'); sep; sep = strchr(sep + 1, '%')) {
const char *arg;
char *label;
arg = va_arg(list, const char *);
if (!arg) {
va_end(list);
return -EINVAL;
}
label = bus_label_escape(arg);
if (!label) {
va_end(list);
return -ENOMEM;
}
r = strv_consume(&labels, label);
if (r < 0) {
va_end(list);
return r;
}
/* add label length, but account for the format character */
path_length += strlen(label) - 1;
}
va_end(list);
path = malloc(path_length + 1);
if (!path)
return -ENOMEM;
path_pos = path;
label_pos = labels;
for (template_pos = path_template; *template_pos; ) {
sep = strchrnul(template_pos, '%');
path_pos = mempcpy(path_pos, template_pos, sep - template_pos);
if (!*sep)
break;
path_pos = stpcpy(path_pos, *label_pos++);
template_pos = sep + 1;
}
*path_pos = 0;
*ret = path;
return 0;
}
_public_ int sd_bus_path_decode_many(const char *path, const char *path_template, ...) {
_cleanup_strv_free_ char **labels = NULL;
const char *template_pos, *path_pos;
char **label_pos;
va_list list;
int r;
/*
* This decodes an object-path based on a template argument. The
* template consists of a verbatim path, optionally including special
* directives:
*
* - Each occurrence of '%' in the template matches an arbitrary
* substring of a label in the given path. At most one such
* directive is allowed per label. For each such directive, the
* caller must provide an output parameter (char **) via va_arg. If
* NULL is passed, the given label is verified, but not returned.
* For each matched label, the *decoded* label is stored in the
* passed output argument, and the caller is responsible to free
* it. Note that the output arguments are only modified if the
* actually path matched the template. Otherwise, they're left
* untouched.
*
* This function returns <0 on error, 0 if the path does not match the
* template, 1 if it matched.
*/
assert_return(path, -EINVAL);
assert_return(path_template, -EINVAL);
path_pos = path;
for (template_pos = path_template; *template_pos; ) {
const char *sep;
size_t length, path_length;
char *label;
/* verify everything until the next '%' matches verbatim */
sep = strchrnul(template_pos, '%');
length = sep - template_pos;
if (!strneq(path_pos, template_pos, length))
return 0;
path_pos += length;
template_pos += length;
if (!*template_pos)
break;
/* We found the next '%' character. Everything up until here
* matched. We now skip ahead to the end of this label and make
* sure it matches the tail of the label in the path. Then we
* decode the string in-between and save it for later use. */
++template_pos; /* skip over '%' */
sep = strchrnul(template_pos, '/');
length = sep - template_pos; /* length of suffix to match verbatim */
/* verify the suffixes match */
sep = strchrnul(path_pos, '/');
path_length = sep - path_pos;
if (length > path_length || !strneq(sep - length, template_pos, length))
return 0;
template_pos += length; /* skip over matched label */
length = sep - path_pos - length; /* length of sub-label to decode */
/* store unescaped label for later use */
label = bus_label_unescape_n(path_pos, length);
if (!label)
return -ENOMEM;
r = strv_consume(&labels, label);
if (r < 0)
return r;
path_pos = sep; /* skip decoded label and suffix */
}
/* end of template must match end of path */
if (*path_pos)
return 0;
/* copy the labels over to the caller */
va_start(list, path_template);
for (label_pos = labels; label_pos && *label_pos; ++label_pos) {
char **arg;
arg = va_arg(list, char **);
if (arg)
*arg = *label_pos;
else
free(*label_pos);
}
va_end(list);
labels = mfree(labels);
return 1;
}
_public_ int sd_bus_try_close(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return -EOPNOTSUPP;
}
_public_ int sd_bus_get_description(sd_bus *bus, const char **ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!bus_origin_changed(bus), -ECHILD);
const char *d = bus->description;
if (!d)
d = runtime_scope_to_string(bus->runtime_scope);
if (!d)
return -ENXIO;
*ret = d;
return 0;
}
_public_ int sd_bus_get_scope(sd_bus *bus, const char **ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!bus_origin_changed(bus), -ECHILD);
if (bus->runtime_scope < 0)
return -ENODATA;
*ret = runtime_scope_to_string(bus->runtime_scope);
return 0;
}
_public_ int sd_bus_get_address(sd_bus *bus, const char **ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!bus_origin_changed(bus), -ECHILD);
if (!bus->address)
return -ENODATA;
*ret = bus->address;
return 0;
}
_public_ int sd_bus_get_creds_mask(sd_bus *bus, uint64_t *ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
assert_return(!bus_origin_changed(bus), -ECHILD);
*ret = bus->creds_mask;
return 0;
}
_public_ int sd_bus_is_bus_client(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return bus->bus_client;
}
_public_ int sd_bus_is_server(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return bus->is_server;
}
_public_ int sd_bus_is_anonymous(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return bus->anonymous_auth;
}
_public_ int sd_bus_is_trusted(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return bus->trusted;
}
_public_ int sd_bus_is_monitor(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
return bus->is_monitor;
}
static void flush_close(sd_bus *bus) {
if (!bus)
return;
/* Flushes and closes the specified bus. We take a ref before,
* to ensure the flushing does not cause the bus to be
* unreferenced. */
sd_bus_flush_close_unref(sd_bus_ref(bus));
}
_public_ void sd_bus_default_flush_close(void) {
flush_close(default_starter_bus);
flush_close(default_user_bus);
flush_close(default_system_bus);
}
_public_ int sd_bus_set_exit_on_disconnect(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
/* Turns on exit-on-disconnect, and triggers it immediately if the bus connection was already
* disconnected. Note that this is triggered exclusively on disconnections triggered by the server side, never
* from the client side. */
bus->exit_on_disconnect = b;
/* If the exit condition was triggered already, exit immediately. */
return bus_exit_now(bus, /* event= */ NULL);
}
_public_ int sd_bus_get_exit_on_disconnect(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
return bus->exit_on_disconnect;
}
_public_ int sd_bus_set_sender(sd_bus *bus, const char *sender) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus->bus_client, -EPERM);
assert_return(!sender || service_name_is_valid(sender), -EINVAL);
return free_and_strdup(&bus->patch_sender, sender);
}
_public_ int sd_bus_get_sender(sd_bus *bus, const char **ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
if (!bus->patch_sender)
return -ENODATA;
*ret = bus->patch_sender;
return 0;
}
_public_ int sd_bus_get_n_queued_read(sd_bus *bus, uint64_t *ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
assert_return(ret, -EINVAL);
*ret = bus->rqueue_size;
return 0;
}
_public_ int sd_bus_get_n_queued_write(sd_bus *bus, uint64_t *ret) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(!bus_origin_changed(bus), -ECHILD);
assert_return(ret, -EINVAL);
*ret = bus->wqueue_size;
return 0;
}
_public_ int sd_bus_set_method_call_timeout(sd_bus *bus, uint64_t usec) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
bus->method_call_timeout = usec;
return 0;
}
_public_ int sd_bus_get_method_call_timeout(sd_bus *bus, uint64_t *ret) {
const char *e;
usec_t usec;
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(ret, -EINVAL);
if (bus->method_call_timeout != 0) {
*ret = bus->method_call_timeout;
return 0;
}
e = secure_getenv("SYSTEMD_BUS_TIMEOUT");
if (e && parse_sec(e, &usec) >= 0 && usec != 0) {
/* Save the parsed value to avoid multiple parsing. To change the timeout value,
* use sd_bus_set_method_call_timeout() instead of setenv(). */
*ret = bus->method_call_timeout = usec;
return 0;
}
*ret = bus->method_call_timeout = BUS_DEFAULT_TIMEOUT;
return 0;
}
_public_ int sd_bus_set_close_on_exit(sd_bus *bus, int b) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
bus->close_on_exit = b;
return 0;
}
_public_ int sd_bus_get_close_on_exit(sd_bus *bus) {
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
return bus->close_on_exit;
}
_public_ int sd_bus_enqueue_for_read(sd_bus *bus, sd_bus_message *m) {
int r;
assert_return(bus, -EINVAL);
assert_return(bus = bus_resolve(bus), -ENOPKG);
assert_return(m, -EINVAL);
assert_return(m->sealed, -EINVAL);
assert_return(!bus_origin_changed(bus), -ECHILD);
if (!BUS_IS_OPEN(bus->state))
return -ENOTCONN;
/* Re-enqueue a message for reading. This is primarily useful for PolicyKit-style authentication,
* where we accept a message, then determine we need to interactively authenticate the user, and then
* we want to process the message again. */
r = bus_rqueue_make_room(bus);
if (r < 0)
return r;
bus->rqueue[bus->rqueue_size++] = bus_message_ref_queued(m, bus);
return 0;
}
_public_ int sd_bus_pending_method_calls(sd_bus *bus) {
/* Returns the number of currently pending asynchronous method calls. This is graceful, i.e. an
* unallocated (i.e. NULL) bus connection has no method calls pending. */
if (!bus)
return 0;
assert_return(bus = bus_resolve(bus), -ENOPKG);
if (!BUS_IS_OPEN(bus->state))
return 0;
size_t n = ordered_hashmap_size(bus->reply_callbacks);
return n > INT_MAX ? INT_MAX : (int) n; /* paranoid overflow check */
}