HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-bus/sd-bus.c

140,786 bytesGit mode 100644Download original fileLGPL-2.1-or-later

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 */
}