HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/libsystemd/sd-varlink/sd-varlink.c

160,383 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 574fb57b5d87a469ddecdbe866d4aaf7f9d9b05f

Lines 1001–2000 of 4,353

        };
        _cleanup_free_ char *text = NULL;
        const sd_varlink_interface *interface;
        const char *name = NULL;
        int r;
 
        assert(link);
 
        r = sd_json_dispatch(parameters, dispatch_table, 0, &name);
        if (r < 0)
                return r;
 
        interface = hashmap_get(ASSERT_PTR(link->server)->interfaces, name);
        if (!interface)
                return sd_varlink_errorbo(
                                link,
                                SD_VARLINK_ERROR_INTERFACE_NOT_FOUND,
                                SD_JSON_BUILD_PAIR_STRING("interface", name));
 
        r = sd_varlink_idl_format(interface, &text);
        if (r < 0)
                return r;
 
        return sd_varlink_replybo(
                        link,
                        SD_JSON_BUILD_PAIR_STRING("description", text));
}
 
static int varlink_dispatch_sentinel(sd_varlink *v) {
        int r;
 
        assert(v);
        assert(v->sentinel);
 
        if (v->previous) {
                r = json_stream_enqueue_full(&v->stream, v->previous, v->previous_fds, v->n_previous_fds);
                if (r >= 0) {
                        v->previous = sd_json_variant_unref(v->previous);
                        v->previous_fds = mfree(v->previous_fds);
                        v->n_previous_fds = 0;
                        /* Mirror sd_varlink_reply()'s post-enqueue state machine: PENDING_* means we're
                         * outside the dispatch stack frame (e.g. called from varlink_fiber_entry after
                         * the fiber returned), so we go straight to IDLE_SERVER ourselves. PROCESSING_*
                         * means we're inside varlink_dispatch_method(), which will transition us. */
                        if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE)) {
                                varlink_clear_current(v);
                                varlink_set_state(v, VARLINK_IDLE_SERVER);
                        } else
                                varlink_set_state(v, VARLINK_PROCESSED_METHOD);
                }
 
                return r;
        }
 
        char *sentinel = TAKE_PTR(v->sentinel);
 
        /* Propagate the sentinel to the client if one was configured and no replies were enqueued by
         * the callback. */
        if (sentinel == POINTER_MAX)
                /* Synthetic empty terminator. Skip IDL validation since the empty parameters wouldn't
                 * satisfy any mandatory output fields the method declares. */
                r = varlink_reply_terminator(v);
        else {
                r = sd_varlink_error(v, sentinel, NULL);
                /* sd_varlink_error() deliberately returns a negative
                 * errno mapped from the error id on success (so method
                 * callbacks can `return sd_varlink_error(...);` to
                 * enqueue a reply and propagate a matching errno in one
                 * go). For sentinel dispatch we don't care about that
                 * mapping — the reply is either enqueued or not, which
                 * we detect via the state transition instead. */
                if (IN_SET(v->state, VARLINK_PROCESSED_METHOD, VARLINK_IDLE_SERVER))
                        r = 0;
        }
 
        if (sentinel != POINTER_MAX)
                free(sentinel);
 
        return r;
}
 
typedef struct VarlinkFiberData {
        sd_varlink *link;
        sd_json_variant *parameters;
        sd_varlink_method_flags_t flags;
        void *userdata;
        sd_varlink_method_t callback;
} VarlinkFiberData;
 
static VarlinkFiberData* varlink_fiber_data_free(VarlinkFiberData *d) {
        if (!d)
                return NULL;
 
        sd_json_variant_unref(d->parameters);
        sd_varlink_unref(d->link);
        return mfree(d);
}
 
DEFINE_TRIVIAL_CLEANUP_FUNC(VarlinkFiberData*, varlink_fiber_data_free);
 
static void varlink_fiber_data_destroy(void *userdata) {
        varlink_fiber_data_free(userdata);
}
 
static int varlink_fiber_entry(void *userdata) {
        VarlinkFiberData *d = ASSERT_PTR(userdata);
        sd_varlink *v = d->link;
        int r;
 
        r = d->callback(v, d->parameters, d->flags, d->userdata);
 
        /* The fiber runs after varlink_dispatch_method() has already transitioned the state from
         * VARLINK_PROCESSING_METHOD{,_MORE} to VARLINK_PENDING_METHOD{,_MORE}, so that's what we match
         * here to decide whether the call still needs a reply. Any other state (e.g. IDLE_SERVER after
         * the callback replied, or DISCONNECTED after sd_varlink_close()) means no fixup is needed. */
        if (!IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                return r;
 
        if (r < 0) {
                varlink_log_errno(v, r, "Fiber returned error: %m");
 
                /* Propagate error to the client if the method call remains unanswered. */
                r = sd_varlink_error_errno(v, r);
        } else if (v->sentinel) {
                r = varlink_dispatch_sentinel(v);
                if (r < 0)
                        varlink_log_errno(v, r, "Failed to process sentinel: %m");
        } else if (v->n_ref <= 2) {
                /* Bare minimum refs (server + fiber data) means the connection wasn't stashed
                 * to reply later, so the fiber was supposed to reply itself but didn't. */
                r = varlink_log_errno(v, SYNTHETIC_ERRNO(EPROTO),
                                      "Fiber returned without enqueuing a reply or stashing connection, failing.");
                goto fail;
        } else
                r = 0;
 
        /* If we didn't manage to enqueue a response, then fail the connection completely. */
        if (r < 0 && IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                goto fail;
 
        return r;
 
fail:
        varlink_set_state(v, VARLINK_PROCESSING_FAILURE);
        varlink_dispatch_local_error(v, SD_VARLINK_ERROR_PROTOCOL);
        sd_varlink_close(v);
 
        return r;
}
 
static int varlink_dispatch_fiber(sd_varlink *v, const char *method, sd_varlink_method_t callback, sd_json_variant *parameters, sd_varlink_method_flags_t flags) {
        int r;
 
        assert(v);
        assert(v->server);
        assert(method);
        assert(callback);
 
        if (!v->server->event)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EDEADLK),
                                         "Cannot dispatch fiber method without event loop.");
 
        _cleanup_(varlink_fiber_data_freep) VarlinkFiberData *d = new(VarlinkFiberData, 1);
        if (!d)
                return log_oom_debug();
 
        *d = (VarlinkFiberData) {
                .link = sd_varlink_ref(v),
                .parameters = sd_json_variant_ref(parameters),
                .flags = flags,
                .userdata = v->userdata,
                .callback = callback,
        };
 
        _cleanup_(sd_future_unrefp) sd_future *f = NULL;
        r = sd_fiber_new(v->server->event, method, varlink_fiber_entry, d, varlink_fiber_data_destroy, &f);
        if (r < 0)
                return r;
 
        TAKE_PTR(d); /* The fiber owns the data now. */
 
        /* Run the fiber at a higher priority than the connection's quit event source, so that on event
         * loop exit the fiber's exit source (which cancels it and drives its cleanup) fires before
         * varlink's quit_callback closes the connection. This lets a fiber handler reply with an error
         * or flush its sentinel on a still-open connection during graceful shutdown. */
        int64_t priority;
        r = sd_event_source_get_priority(v->quit_event_source, &priority);
        if (r < 0)
                return r;
 
        r = sd_future_set_priority(f, priority > INT64_MIN ? priority - 1 : priority);
        if (r < 0)
                return r;
 
        /* Hand the future's lifetime over to the event loop: it'll auto-unref on resolve. */
        r = sd_fiber_set_floating(f, true);
        if (r < 0)
                return r;
 
        return 0;
}
 
static int varlink_dispatch_method(sd_varlink *v) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        sd_varlink_method_flags_t flags = 0;
        const char *method = NULL;
        sd_json_variant *e;
        sd_varlink_method_t callback;
        const char *k;
        int r;
 
        assert(v);
 
        if (v->state != VARLINK_IDLE_SERVER)
                return 0;
        if (!v->current)
                return 0;
 
        if (!sd_json_variant_is_object(v->current))
                goto invalid;
 
        JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
 
                if (streq(k, "method")) {
                        if (method)
                                goto invalid;
                        if (!sd_json_variant_is_string(e))
                                goto invalid;
 
                        method = sd_json_variant_string(e);
 
                } else if (streq(k, "parameters")) {
                        if (parameters)
                                goto invalid;
                        if (!sd_json_variant_is_object(e) && !sd_json_variant_is_null(e))
                                goto invalid;
 
                        parameters = sd_json_variant_ref(e);
 
                } else if (streq(k, "oneway")) {
 
                        if ((flags & (SD_VARLINK_METHOD_ONEWAY|SD_VARLINK_METHOD_MORE|SD_VARLINK_METHOD_UPGRADE)) != 0)
                                goto invalid;
 
                        if (!sd_json_variant_is_boolean(e))
                                goto invalid;
 
                        if (sd_json_variant_boolean(e))
                                flags |= SD_VARLINK_METHOD_ONEWAY;
 
                } else if (streq(k, "more")) {
 
                        if ((flags & (SD_VARLINK_METHOD_ONEWAY|SD_VARLINK_METHOD_MORE|SD_VARLINK_METHOD_UPGRADE)) != 0)
                                goto invalid;
 
                        if (!sd_json_variant_is_boolean(e))
                                goto invalid;
 
                        if (sd_json_variant_boolean(e))
                                flags |= SD_VARLINK_METHOD_MORE;
 
                } else if (streq(k, "upgrade")) {
 
                        if ((flags & (SD_VARLINK_METHOD_ONEWAY|SD_VARLINK_METHOD_MORE|SD_VARLINK_METHOD_UPGRADE)) != 0)
                                goto invalid;
 
                        if (!sd_json_variant_is_boolean(e))
                                goto invalid;
 
                        if (sd_json_variant_boolean(e))
                                flags |= SD_VARLINK_METHOD_UPGRADE;
 
                } else
                        goto invalid;
        }
 
        if (!method)
                goto invalid;
 
        r = varlink_normalize_incoming_parameters(NULL, &parameters);
        if (r < 0)
                goto fail;
 
        varlink_set_state(v, (flags & SD_VARLINK_METHOD_MORE)    ? VARLINK_PROCESSING_METHOD_MORE :
                             (flags & SD_VARLINK_METHOD_ONEWAY)  ? VARLINK_PROCESSING_METHOD_ONEWAY :
                             (flags & SD_VARLINK_METHOD_UPGRADE) ? VARLINK_PROCESSING_METHOD_UPGRADE :
                                                                   VARLINK_PROCESSING_METHOD);
 
        assert(v->server);
 
        /* Reset the per-call upgrade marker on every dispatch — a previous method's
         * UPGRADE flag must not bleed into this one. The transport-level bounded reads
         * stay active for SD_VARLINK_SERVER_UPGRADABLE servers regardless. */
        json_stream_set_flags(
                        &v->stream,
                        JSON_STREAM_BOUNDED_READS,
                        FLAGS_SET(flags, SD_VARLINK_METHOD_UPGRADE) || FLAGS_SET(v->server->flags, SD_VARLINK_SERVER_UPGRADABLE));
 
        /* First consult user supplied method implementations */
        bool is_fiber = false;
        callback = hashmap_get(v->server->methods, method);
        if (!callback) {
                callback = hashmap_get(v->server->fiber_methods, method);
                if (callback)
                        is_fiber = true;
        }
        if (!callback) {
                if (streq(method, "org.varlink.service.GetInfo"))
                        callback = generic_method_get_info;
                else if (streq(method, "org.varlink.service.GetInterfaceDescription"))
                        callback = generic_method_get_interface_description;
        }
 
        if (callback) {
                bool invalid = false;
 
                v->current_method = hashmap_get(v->server->symbols, method);
                if (!v->current_method)
                        varlink_log(v, "No interface description defined for method '%s', not validating.", method);
                else {
                        const char *bad_field;
 
                        r = varlink_idl_validate_method_call(v->current_method, parameters, flags, &bad_field);
                        if (r == -EBADE) {
                                bool missing_upgrade = FLAGS_SET(v->current_method->symbol_flags, SD_VARLINK_REQUIRES_UPGRADE) &&
                                                       !FLAGS_SET(flags, SD_VARLINK_METHOD_UPGRADE);
 
                                varlink_log_errno(v, r, "Method %s() called without '%s' flag, but flag needs to be set.",
                                                  method, missing_upgrade ? "upgrade" : "more");
 
                                if (v->state == VARLINK_PROCESSING_METHOD) {
                                        r = sd_varlink_error(v, missing_upgrade ? SD_VARLINK_ERROR_EXPECTED_UPGRADE
                                                                                : SD_VARLINK_ERROR_EXPECTED_MORE, NULL);
                                        /* If we didn't manage to enqueue an error response, then fail the
                                         * connection completely. Otherwise ignore the error from
                                         * sd_varlink_error() here, as it is synthesized from the function's
                                         * parameters. */
                                        if (r < 0 && VARLINK_STATE_WANTS_REPLY(v->state))
                                                goto fail;
                                }
                        } else if (r < 0) {
                                /* Please adjust test/units/end.sh when updating the log message. */
                                varlink_log_errno(v, r, "Parameters for method %s() didn't pass validation on field '%s': %m",
                                                  method, strna(bad_field));
 
                                if (VARLINK_STATE_WANTS_REPLY(v->state)) {
                                        r = sd_varlink_error_invalid_parameter_name(v, bad_field);
                                        /* If we didn't manage to enqueue an error response, then fail the connection completely. */
                                        if (r < 0 && VARLINK_STATE_WANTS_REPLY(v->state))
                                                goto fail;
                                }
                        }
 
                        invalid = r < 0;
                }
 
                if (!invalid) {
                        if (is_fiber)
                                /* Spawn a fiber to run the callback. The VarlinkFiberData takes a ref on the
                                 * connection (bumping n_ref above 2), so the post-callback logic below treats
                                 * this as a deferred reply and moves state to PENDING_METHOD. */
                                r = varlink_dispatch_fiber(v, method, callback, parameters, flags);
                        else
                                r = callback(v, parameters, flags, v->userdata);
                        if (VARLINK_STATE_WANTS_REPLY(v->state)) {
                                if (r < 0) {
                                        varlink_log_errno(v, r, "Callback for '%s' returned error: %m", method);
 
                                        /* We got an error back from the callback. Propagate it to the client
                                         * if the method call remains unanswered. */
                                        r = sd_varlink_error_errno(v, r);
                                } else if (v->sentinel) {
                                        r = varlink_dispatch_sentinel(v);
                                        if (r < 0)
                                                varlink_log_errno(v, r, "Failed to process sentinel for method '%s': %m", method);
                                } else {
                                        assert(!v->previous);
 
                                        /* We're at the bare minimum referenced by sd_varlink_server and
                                         * sd_varlink_process() */
                                        if (v->n_ref <= 2) {
                                                r = varlink_log_errno(v, SYNTHETIC_ERRNO(EPROTO),
                                                                      "Callback for method '%s' returned without enqueuing a reply or stashing connection, failing.",
                                                                      method);
                                                goto fail;
                                        }
 
                                        r = 0;
                                }
 
                                /* If we didn't manage to enqueue a response, then fail the connection completely. */
                                if (r < 0 && VARLINK_STATE_WANTS_REPLY(v->state))
                                        goto fail;
 
                        } else
                                assert(!v->previous);
                }
        } else if (VARLINK_STATE_WANTS_REPLY(v->state)) {
                r = sd_varlink_errorbo(v, SD_VARLINK_ERROR_METHOD_NOT_FOUND, SD_JSON_BUILD_PAIR_STRING("method", method));
                /* If we didn't manage to enqueue an error response, then fail the connection completely. */
                if (r < 0 && VARLINK_STATE_WANTS_REPLY(v->state))
                        goto fail;
        }
 
        switch (v->state) {
 
        case VARLINK_PROCESSED_METHOD: /* Method call is fully processed */
        case VARLINK_PROCESSING_METHOD_ONEWAY: /* ditto */
                varlink_clear_current(v);
                varlink_set_state(v, VARLINK_IDLE_SERVER);
                break;
 
        case VARLINK_PROCESSING_METHOD: /* Method call wasn't replied to, will be replied to later */
                varlink_set_state(v, VARLINK_PENDING_METHOD);
                break;
 
        case VARLINK_PROCESSING_METHOD_MORE: /* No reply for a "more" message was sent, more to come */
                varlink_set_state(v, VARLINK_PENDING_METHOD_MORE);
                break;
 
        case VARLINK_PROCESSING_METHOD_UPGRADE: /* Method call wasn't replied to, will be replied to later */
                varlink_set_state(v, VARLINK_PENDING_METHOD_UPGRADE);
                break;
 
        case VARLINK_PROCESSED_METHOD_UPGRADE: /* Upgrade requested, let's now wait till everything is flushed */
                varlink_clear_current(v);
                varlink_set_state(v, VARLINK_UPGRADING);
                break;
 
        case VARLINK_DISCONNECTED: /* Handler called sd_varlink_close() on us, which is fine */
                break;
 
        default:
                assert_not_reached();
        }
 
        return 1;
 
invalid:
        r = -EINVAL;
 
fail:
        varlink_set_state(v, VARLINK_PROCESSING_FAILURE);
        varlink_dispatch_local_error(v, SD_VARLINK_ERROR_PROTOCOL);
        sd_varlink_close(v);
 
        return r;
}
 
static int varlink_handle_upgrade_fds(sd_varlink *v, int *ret_input_fd, int *ret_output_fd) {
        int r;
 
        assert(v);
        assert(ret_input_fd || ret_output_fd);
 
        /* Ensure no post-upgrade data was consumed into our input buffer (we ensure this via MSG_PEEK or
         * byte-to-byte) and refuse the upgrade rather than silently losing the data. */
        if (json_stream_has_buffered_input(&v->stream))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EPROTO),
                                         "Unexpected buffered data during protocol upgrade, refusing.");
 
        _cleanup_close_ int input_fd = TAKE_FD(v->stream.input_fd),
                            output_fd = TAKE_FD(v->stream.output_fd);
 
        /* Pass the connection fds to the caller, it owns them now. Reset to blocking mode
         * since callers of the upgraded protocol will generally expect normal blocking
         * semantics. For bidirectional sockets (input_fd == output_fd), dup the fd so that
         * callers always get two independent fds they can close separately. */
        if (input_fd == output_fd) {
                output_fd = fcntl(input_fd, F_DUPFD_CLOEXEC, 3);
                if (output_fd < 0)
                        return varlink_log_errno(v, errno, "Failed to dup upgraded connection fd: %m");
        } else {
                r = fd_nonblock(output_fd, false);
                if (r < 0)
                        return varlink_log_errno(v, r, "Failed to set output fd to blocking mode: %m");
        }
 
        r = fd_nonblock(input_fd, false);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to set input fd to blocking mode: %m");
 
        /* Hand out requested fds, shut down unwanted directions. */
        if (ret_input_fd)
                *ret_input_fd = TAKE_FD(input_fd);
        else
                (void) shutdown(input_fd, SHUT_RD);
 
        if (ret_output_fd)
                *ret_output_fd = TAKE_FD(output_fd);
        else
                (void) shutdown(output_fd, SHUT_WR);
 
        return 0;
}
 
static int varlink_dispatch_upgrade(sd_varlink *v) {
        int r;
 
        assert(v);
 
        if (v->state != VARLINK_UPGRADING)
                return 0;
 
        r = json_stream_has_buffered_output(&v->stream);
        if (r < 0)
                return r;
        if (r > 0)
                return 0;
 
        /* Detach from the event loop before stealing the fds */
        sd_varlink_detach_event(v);
 
        _cleanup_close_ int input_fd = -EBADF, output_fd = -EBADF;
        r = varlink_handle_upgrade_fds(v, &input_fd, &output_fd);
        sd_varlink_close(v);
        if (r < 0)
                return r;
 
        /* Fail if by this time the caller still hasn't set an upgrade callback. */
        if (!v->upgrade_callback)
                return -ENOPKG;
 
        /* No matter what, we donate the fds to callback */
        r = v->upgrade_callback(v, TAKE_FD(input_fd), TAKE_FD(output_fd), v->userdata);
        if (r < 0)
                return r;
 
        return 1;
}
 
_public_ int sd_varlink_process(sd_varlink *v) {
        int r;
 
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        sd_varlink_ref(v);
 
        r = varlink_write(v);
        if (r < 0)
                varlink_log_errno(v, r, "Write failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_dispatch_upgrade(v);
        if (r < 0)
                varlink_log_errno(v, r, "Upgrade dispatch failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_dispatch_reply(v);
        if (r < 0)
                varlink_log_errno(v, r, "Reply dispatch failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_dispatch_method(v);
        if (r < 0)
                varlink_log_errno(v, r, "Method dispatch failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_parse_message(v);
        if (r < 0)
                varlink_log_errno(v, r, "Message parsing failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_read(v);
        if (r < 0)
                varlink_log_errno(v, r, "Read failed: %m");
        if (r != 0)
                goto finish;
 
        r = varlink_test_disconnect(v);
        assert(r >= 0);
        if (r != 0)
                goto finish;
 
        r = varlink_dispatch_disconnect(v);
        assert(r >= 0);
        if (r != 0)
                goto finish;
 
        r = varlink_test_timeout(v);
        assert(r >= 0);
        if (r != 0)
                goto finish;
 
        r = varlink_dispatch_timeout(v);
        assert(r >= 0);
        if (r != 0)
                goto finish;
 
finish:
        if (r >= 0 && v->defer_event_source) {
                int q;
 
                /* If we did some processing, make sure we are called again soon */
                q = sd_event_source_set_enabled(v->defer_event_source, r > 0 ? SD_EVENT_ON : SD_EVENT_OFF);
                if (q < 0)
                        r = varlink_log_errno(v, q, "Failed to enable deferred event source: %m");
        }
 
        if (r < 0) {
                if (VARLINK_STATE_IS_ALIVE(v->state))
                        /* Initiate disconnection */
                        varlink_set_state(v, VARLINK_PENDING_DISCONNECT);
                else
                        /* We failed while disconnecting, in that case close right away */
                        sd_varlink_close(v);
        }
 
        sd_varlink_unref(v);
        return r;
}
 
_public_ int sd_varlink_dispatch_again(sd_varlink *v) {
        int r;
 
        assert_return(v, -EINVAL);
 
        /* If a method call handler could not process the method call just yet (for example because it needed
         * some Polkit authentication first), then it can leave the call unanswered, do its thing, and then
         * ask to be dispatched a second time, via this call. It will then be called again, for the same
         * message */
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
        if (!IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection has no pending method.");
 
        varlink_set_state(v, VARLINK_IDLE_SERVER);
 
        r = sd_event_source_set_enabled(v->defer_event_source, SD_EVENT_ON);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enable deferred event source: %m");
 
        return 0;
}
 
_public_ int sd_varlink_get_current_method(sd_varlink *v, const char **ret) {
        assert_return(v, -EINVAL);
 
        if (!v->current)
                return -ENODATA;
 
        sd_json_variant *p = sd_json_variant_by_key(v->current, "method");
        if (!p)
                return -ENODATA;
 
        const char *s = sd_json_variant_string(p);
        if (!s)
                return -ENODATA;
 
        if (ret)
                *ret = s;
        return 0;
}
 
_public_ int sd_varlink_get_current_parameters(sd_varlink *v, sd_json_variant **ret) {
        sd_json_variant *p;
 
        assert_return(v, -EINVAL);
 
        if (!v->current)
                return -ENODATA;
 
        if (!ret)
                return 0;
 
        p = sd_json_variant_by_key(v->current, "parameters");
        if (!p || sd_json_variant_is_null(p))
                return sd_json_variant_new_object(ret, NULL, 0);
 
        *ret = sd_json_variant_ref(p);
        return 0;
}
 
_public_ int sd_varlink_wait(sd_varlink *v, uint64_t timeout) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        return json_stream_wait(&v->stream, timeout);
}
 
_public_ int sd_varlink_is_idle(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        /* Returns true if there's nothing pending on the connection anymore, i.e. we processed all incoming
         * or outgoing messages fully, or finished disconnection */
 
        return IN_SET(v->state, VARLINK_DISCONNECTED, VARLINK_IDLE_CLIENT, VARLINK_IDLE_SERVER);
}
 
_public_ int sd_varlink_is_connected(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        /* Returns true if the connection is still connected */
 
        return v->state != VARLINK_DISCONNECTED;
}
 
_public_ int sd_varlink_get_fd(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        int input_fd = v->stream.input_fd;
        int output_fd = v->stream.output_fd;
 
        if (input_fd != output_fd)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADF), "Separate file descriptors for input/output set.");
        if (input_fd < 0)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADF), "No valid fd.");
 
        return input_fd;
}
 
_public_ int sd_varlink_get_input_fd(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        int input_fd = v->stream.input_fd;
        if (input_fd < 0)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADF), "No valid input fd.");
 
        return input_fd;
}
 
_public_ int sd_varlink_get_output_fd(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        int output_fd = v->stream.output_fd;
        if (output_fd < 0)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADF), "No valid output fd.");
 
        return output_fd;
}
 
_public_ int sd_varlink_get_events(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        return json_stream_get_events(&v->stream);
}
 
_public_ int sd_varlink_get_timeout(sd_varlink *v, uint64_t *ret) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        usec_t deadline = json_stream_get_timeout(&v->stream);
 
        if (ret)
                *ret = deadline;
 
        return deadline != USEC_INFINITY;
}
 
_public_ int sd_varlink_flush(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        return json_stream_flush(&v->stream);
}
 
static void varlink_detach_server(sd_varlink *v, bool connected) {
        sd_varlink_server *saved_server;
 
        assert(v);
 
        if (!v->server)
                return;
 
        /* Only touch by_uid for connections we already counted in count_connection() —
         * those are exactly the ones for which the ucred was acquired or injected during
         * sd_varlink_server_add_connection_pair(). Don't trigger an acquire from here. */
        struct ucred ucred;
        if (v->server->by_uid &&
            json_stream_get_peer_ucred(&v->stream, &ucred) >= 0 &&
            uid_is_valid(ucred.uid)) {
                unsigned c;
 
                c = PTR_TO_UINT(hashmap_get(v->server->by_uid, UID_TO_PTR(ucred.uid)));
                assert(c > 0);
 
                if (c == 1)
                        (void) hashmap_remove(v->server->by_uid, UID_TO_PTR(ucred.uid));
                else
                        (void) hashmap_replace(v->server->by_uid, UID_TO_PTR(ucred.uid), UINT_TO_PTR(c - 1));
        }
 
        assert(v->server->n_connections > 0);
        v->server->n_connections--;
 
        /* If this is a connection associated to a server, then let's disconnect the server and the
         * connection from each other. This drops the dangling reference that connect_callback() set up. But
         * before we release the references, let's call the disconnection callback if it is defined. */
 
        saved_server = TAKE_PTR(v->server);
 
        if (saved_server->disconnect_callback && connected)
                saved_server->disconnect_callback(saved_server, v, saved_server->userdata);
 
        varlink_server_test_exit_on_idle(saved_server);
        sd_varlink_server_unref(saved_server);
        sd_varlink_unref(v);
}
 
_public_ int sd_varlink_close(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return 0;
 
        bool connected = v->state >= 0;
 
        varlink_set_state(v, VARLINK_DISCONNECTED);
 
        /* Let's take a reference first, since varlink_detach_server() might drop the final (dangling) ref
         * which would destroy us before we can call varlink_clear() */
        sd_varlink_ref(v);
        varlink_detach_server(v, connected);
        varlink_clear(v);
        sd_varlink_unref(v);
 
        return 1;
}
 
_public_ sd_varlink* sd_varlink_close_unref(sd_varlink *v) {
        if (!v)
                return NULL;
 
        (void) sd_varlink_close(v);
        return sd_varlink_unref(v);
}
 
_public_ sd_varlink* sd_varlink_flush_close_unref(sd_varlink *v) {
        if (!v)
                return NULL;
 
        (void) sd_varlink_flush(v);
        return sd_varlink_close_unref(v);
}
 
_public_ int sd_varlink_send(sd_varlink *v, const char *method, sd_json_variant *parameters) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        /* We allow enqueuing multiple method calls at once! */
        if (!IN_SET(v->state, VARLINK_IDLE_CLIENT, VARLINK_AWAITING_REPLY))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        r = sd_json_buildo(
                        &m,
                        SD_JSON_BUILD_PAIR_STRING("method", method),
                        JSON_BUILD_PAIR_VARIANT_NON_EMPTY("parameters", parameters),
                        SD_JSON_BUILD_PAIR_BOOLEAN("oneway", true));
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        r = varlink_enqueue(v, m);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
        /* No state change here, this is one-way only after all */
        json_stream_mark_activity(&v->stream);
        return 0;
}
 
_public_ int sd_varlink_sendb(sd_varlink *v, const char *method, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, method);
        r = sd_json_buildv(&parameters, ap);
        va_end(ap);
 
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        return sd_varlink_send(v, method, parameters);
}
 
_public_ int sd_varlink_invoke(sd_varlink *v, const char *method, sd_json_variant *parameters) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        /* We allow enqueuing multiple method calls at once! */
        if (!IN_SET(v->state, VARLINK_IDLE_CLIENT, VARLINK_AWAITING_REPLY))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        r = sd_json_buildo(
                        &m,
                        SD_JSON_BUILD_PAIR_STRING("method", method),
                        JSON_BUILD_PAIR_VARIANT_NON_EMPTY("parameters", parameters));
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        r = varlink_enqueue(v, m);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
        varlink_set_state(v, VARLINK_AWAITING_REPLY);
        v->n_pending++;
        json_stream_mark_activity(&v->stream);
 
        return 0;
}
 
_public_ int sd_varlink_invokeb(sd_varlink *v, const char *method, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, method);
        r = sd_json_buildv(&parameters, ap);
        va_end(ap);
 
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        return sd_varlink_invoke(v, method, parameters);
}
 
_public_ int sd_varlink_observe(sd_varlink *v, const char *method, sd_json_variant *parameters) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        /* Note that we don't allow enqueuing multiple method calls when we are in more/continues mode! We
         * thus insist on an idle client here. */
        if (v->state != VARLINK_IDLE_CLIENT)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        r = sd_json_buildo(
                        &m,
                        SD_JSON_BUILD_PAIR_STRING("method", method),
                        JSON_BUILD_PAIR_VARIANT_NON_EMPTY("parameters", parameters),
                        SD_JSON_BUILD_PAIR_BOOLEAN("more", true));
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        r = varlink_enqueue(v, m);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
        varlink_set_state(v, VARLINK_AWAITING_REPLY_MORE);
        v->n_pending++;
        json_stream_mark_activity(&v->stream);
 
        return 0;
}
 
_public_ int sd_varlink_observeb(sd_varlink *v, const char *method, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);