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 2001–3000 of 4,353

        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_observe(v, method, parameters);
}
 
/* On success v->state will equal VARLINK_CALLED, the caller is responsible to adjust the state further if
 * needed */
static int varlink_call_internal(sd_varlink *v, sd_json_variant *request) {
        int r;
 
        assert(v);
        assert(request);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
        if (v->state != VARLINK_IDLE_CLIENT)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        assert(v->n_pending == 0); /* n_pending can't be > 0 if we are in VARLINK_IDLE_CLIENT state */
 
        /* If there was still a reply pinned from a previous call, now it's the time to get rid of it, so
         * that we can assign a new reply shortly. */
        varlink_clear_current(v);
 
        r = varlink_enqueue(v, request);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
        varlink_set_state(v, VARLINK_CALLING);
        v->n_pending++;
        json_stream_mark_activity(&v->stream);
 
        while (v->state == VARLINK_CALLING) {
                r = sd_varlink_process(v);
                if (r < 0)
                        return r;
                if (r > 0)
                        continue;
 
                r = sd_varlink_wait(v, USEC_INFINITY);
                if (r < 0)
                        return r;
        }
 
        switch (v->state) {
 
        case VARLINK_CALLED:
                assert(v->current);
                return 0;
 
        case VARLINK_PENDING_DISCONNECT:
        case VARLINK_DISCONNECTED:
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ECONNRESET), "Connection was closed.");
 
        case VARLINK_PENDING_TIMEOUT:
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ETIME), "Connection timed out.");
 
        default:
                assert_not_reached();
        }
}
 
_public_ int sd_varlink_call_full(
                sd_varlink *v,
                const char *method,
                sd_json_variant *parameters,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                sd_varlink_reply_flags_t *ret_flags) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        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_call_internal(v, m);
        if (r < 0)
                return r;
 
        varlink_set_state(v, VARLINK_IDLE_CLIENT);
        assert(v->n_pending == 1);
        v->n_pending--;
 
        sd_json_variant *e = sd_json_variant_by_key(v->current, "error"),
                *p = sd_json_variant_by_key(v->current, "parameters");
 
        /* If caller doesn't ask for the error string, then let's return an error code in case of failure */
        if (!ret_error_id && e)
                return sd_varlink_error_to_errno(sd_json_variant_string(e), p);
 
        if (ret_parameters)
                *ret_parameters = p;
        if (ret_error_id)
                *ret_error_id = e ? sd_json_variant_string(e) : NULL;
        if (ret_flags)
                *ret_flags = v->current_reply_flags;
 
        return 1;
}
 
_public_ int sd_varlink_call(
                sd_varlink *v,
                const char *method,
                sd_json_variant *parameters,
                sd_json_variant **ret_parameters,
                const char **ret_error_id) {
 
        return sd_varlink_call_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
 
_public_ int sd_varlink_call_and_upgrade(
                sd_varlink *v,
                const char *method,
                sd_json_variant *parameters,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                int *ret_input_fd,
                int *ret_output_fd) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
        assert_return(ret_input_fd || ret_output_fd, -EINVAL);
 
        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("upgrade", true));
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        json_stream_set_flags(&v->stream, JSON_STREAM_BOUNDED_READS, true);
        r = varlink_call_internal(v, m);
        if (r < 0) {
                json_stream_set_flags(&v->stream, JSON_STREAM_BOUNDED_READS, false);
                return r;
        }
 
        /* ensure we did not consume any data from the upgraded protocol */
        assert(!json_stream_has_buffered_input(&v->stream));
 
        sd_json_variant *e = sd_json_variant_by_key(v->current, "error"),
                *p = sd_json_variant_by_key(v->current, "parameters");
 
        /* don't steal the fd on server error */
        if (e) {
                if (ret_error_id) {
                        *ret_error_id = sd_json_variant_string(e);
                        if (ret_parameters)
                                *ret_parameters = p;
                        r = 0;
                } else
                        r = sd_varlink_error_to_errno(sd_json_variant_string(e), p);
 
                varlink_set_state(v, VARLINK_IDLE_CLIENT);
                goto finish;
        }
 
        /* Even if setting up the fds fails we must disconnect: the server already accepted the
         * upgrade, so the other side is speaking raw protocol while we expect JSON. */
        r = varlink_handle_upgrade_fds(v, ret_input_fd, ret_output_fd);
        if (r < 0) {
                varlink_set_state(v, VARLINK_DISCONNECTED);
                goto finish;
        }
 
        varlink_set_state(v, VARLINK_DISCONNECTED);
        assert(v->n_pending == 1);
        v->n_pending--;
 
        if (ret_parameters)
                *ret_parameters = p;
        if (ret_error_id)
                *ret_error_id = NULL;
 
        return 1;
 
finish:
        json_stream_set_flags(&v->stream, JSON_STREAM_BOUNDED_READS, false);
        assert(v->n_pending == 1);
        v->n_pending--;
        return r;
}
 
_public_ int sd_varlink_call_and_upgradeb(
                sd_varlink *v,
                const char *method,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                int *ret_input_fd,
                int *ret_output_fd,
                ...) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        va_start(ap, ret_output_fd);
        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_call_and_upgrade(v, method, parameters, ret_parameters, ret_error_id, ret_input_fd, ret_output_fd);
}
 
_public_ int sd_varlink_callb_ap(
                sd_varlink *v,
                const char *method,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                sd_varlink_reply_flags_t *ret_flags,
                va_list ap) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(method, -EINVAL);
 
        r = sd_json_buildv(&parameters, ap);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        return sd_varlink_call_full(v, method, parameters, ret_parameters, ret_error_id, ret_flags);
}
 
_public_ int sd_varlink_callb(
                sd_varlink *v,
                const char *method,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                ...) {
 
        va_list ap;
        int r;
 
        va_start(ap, ret_error_id);
        r = sd_varlink_callb_ap(v, method, ret_parameters, ret_error_id, NULL, ap);
        va_end(ap);
        return r;
}
 
_public_ int sd_varlink_callb_full(
                sd_varlink *v,
                const char *method,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                sd_varlink_reply_flags_t *ret_flags,
                ...) {
 
        va_list ap;
        int r;
 
        va_start(ap, ret_flags);
        r = sd_varlink_callb_ap(v, method, ret_parameters, ret_error_id, ret_flags, ap);
        va_end(ap);
        return r;
}
 
_public_ int sd_varlink_collect_full(
                sd_varlink *v,
                const char *method,
                sd_json_variant *parameters,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                sd_varlink_reply_flags_t *ret_flags) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL, *collected = 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.");
        if (v->state != VARLINK_IDLE_CLIENT)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        assert(v->n_pending == 0); /* n_pending can't be > 0 if we are in VARLINK_IDLE_CLIENT state */
 
        /* If there was still a reply pinned from a previous call, now it's the time to get rid of it, so
         * that we can assign a new reply shortly. */
        varlink_clear_current(v);
 
        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_COLLECTING);
        v->n_pending++;
        json_stream_mark_activity(&v->stream);
 
        for (;;) {
                while (v->state == VARLINK_COLLECTING) {
                        r = sd_varlink_process(v);
                        if (r < 0)
                                return r;
                        if (r > 0)
                                continue;
 
                        r = sd_varlink_wait(v, USEC_INFINITY);
                        if (r < 0)
                                return r;
                }
 
                switch (v->state) {
 
                case VARLINK_COLLECTING_REPLY: {
                        assert(v->current);
 
                        sd_json_variant *e = sd_json_variant_by_key(v->current, "error"),
                                *p = sd_json_variant_by_key(v->current, "parameters");
 
                        /* Unless there is more to collect we reset state to idle */
                        if (!FLAGS_SET(v->current_reply_flags, SD_VARLINK_REPLY_CONTINUES)) {
                                varlink_set_state(v, VARLINK_IDLE_CLIENT);
                                assert(v->n_pending == 1);
                                v->n_pending--;
                        }
 
                        if (e) {
                                if (!ret_error_id)
                                        return sd_varlink_error_to_errno(sd_json_variant_string(e), p);
 
                                if (ret_parameters)
                                        *ret_parameters = p;
                                if (ret_error_id)
                                        *ret_error_id = sd_json_variant_string(e);
                                if (ret_flags)
                                        *ret_flags = v->current_reply_flags;
 
                                return 1;
                        }
 
                        if (sd_json_variant_elements(collected) >= VARLINK_COLLECT_MAX)
                                return varlink_log_errno(v, SYNTHETIC_ERRNO(E2BIG), "Number of reply messages grew too large (%zu) while collecting.", sd_json_variant_elements(collected));
 
                        r = sd_json_variant_append_array(&collected, p);
                        if (r < 0)
                                return varlink_log_errno(v, r, "Failed to append JSON object to array: %m");
 
                        if (FLAGS_SET(v->current_reply_flags, SD_VARLINK_REPLY_CONTINUES)) {
                                /* There's more to collect, continue */
                                varlink_clear_current(v);
                                varlink_set_state(v, VARLINK_COLLECTING);
                                continue;
                        }
 
                        if (ret_parameters)
                                /* Install the collection array in the connection object, so that we can hand
                                 * out a pointer to it without passing over ownership, to make it work more
                                 * alike regular method call replies */
                                *ret_parameters = v->current_collected = TAKE_PTR(collected);
                        if (ret_error_id)
                                *ret_error_id = NULL;
                        if (ret_flags)
                                *ret_flags = v->current_reply_flags;
 
                        return 1;
                }
 
                case VARLINK_PENDING_DISCONNECT:
                case VARLINK_DISCONNECTED:
                        return varlink_log_errno(v, SYNTHETIC_ERRNO(ECONNRESET), "Connection was closed.");
 
                case VARLINK_PENDING_TIMEOUT:
                        return varlink_log_errno(v, SYNTHETIC_ERRNO(ETIME), "Connection timed out.");
 
                default:
                        assert_not_reached();
                }
        }
}
 
_public_ int sd_varlink_collect(
                sd_varlink *v,
                const char *method,
                sd_json_variant *parameters,
                sd_json_variant **ret_parameters,
                const char **ret_error_id) {
 
        return sd_varlink_collect_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
 
_public_ int sd_varlink_collectb(
                sd_varlink *v,
                const char *method,
                sd_json_variant **ret_parameters,
                const char **ret_error_id,
                ...) {
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, ret_error_id);
        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_collect_full(v, method, parameters, ret_parameters, ret_error_id, NULL);
}
 
static int varlink_reply_internal(sd_varlink *v, sd_json_variant *parameters, bool skip_validation) {
        int r;
 
        assert(v);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        if (!IN_SET(v->state,
                    VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PROCESSING_METHOD_UPGRADE,
                    VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        bool more = IN_SET(v->state, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PENDING_METHOD_MORE);
 
        /* Validate parameters BEFORE sanitization. Validation should be skipped for the synthetic
         * empty terminator. */
        if (!skip_validation && v->current_method) {
                const char *bad_field = NULL;
 
                r = varlink_idl_validate_method_reply(v->current_method, parameters, more && v->sentinel ? SD_VARLINK_REPLY_CONTINUES : 0, &bad_field);
                if (r == -EBADE)
                        varlink_log_errno(v, r, "Method reply for %s() has 'continues' flag set, but IDL structure doesn't allow that, ignoring: %m",
                                          v->current_method->name);
                else if (r < 0)
                        /* Please adjust test/units/end.sh when updating the log message. */
                        varlink_log_errno(v, r, "Return parameters for method reply %s() didn't pass validation on field '%s', ignoring: %m",
                                          v->current_method->name, strna(bad_field));
        }
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        r = sd_json_buildo(&m, JSON_BUILD_PAIR_VARIANT_NON_EMPTY("parameters", parameters));
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to build json message: %m");
 
        if (more && v->sentinel) {
                if (v->previous) {
                        r = sd_json_variant_set_field_boolean(&v->previous, "continues", true);
                        if (r < 0)
                                return r;
 
                        r = json_stream_enqueue_full(&v->stream, v->previous, v->previous_fds, v->n_previous_fds);
                        if (r < 0)
                                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
                        v->previous = sd_json_variant_unref(v->previous);
                        v->previous_fds = mfree(v->previous_fds);
                        v->n_previous_fds = 0;
                }
 
                v->previous = sd_json_variant_ref(m);
                v->previous_fds = TAKE_PTR(v->pushed_fds);
                v->n_previous_fds = v->n_pushed_fds;
                v->n_pushed_fds = 0;
 
                return 1;
        }
 
        r = varlink_enqueue(v, m);
        if (r < 0)
                return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
        if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE)) {
                /* We just replied to a method call that was let hanging for a while (i.e. we were outside of
                 * the varlink_dispatch_method() stack frame), which means with this reply we are ready to
                 * process further messages. */
                varlink_clear_current(v);
                varlink_set_state(v, VARLINK_IDLE_SERVER);
        } else
                /* We replied to a method call from within the varlink_dispatch_method() stack frame), which
                 * means we should it handle the rest of the state engine. */
                varlink_set_state(v, VARLINK_PROCESSED_METHOD);
 
        return 1;
}
 
static int varlink_reply_terminator(sd_varlink *v) {
        return varlink_reply_internal(v, /* parameters= */ NULL, /* skip_validation= */ true);
}
 
_public_ int sd_varlink_reply(sd_varlink *v, sd_json_variant *parameters) {
        assert_return(v, -EINVAL);
 
        return varlink_reply_internal(v, parameters, /* skip_validation= */ false);
}
 
_public_ int sd_varlink_replyb(sd_varlink *v, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, v);
        r = sd_json_buildv(&parameters, ap);
        va_end(ap);
 
        if (r < 0)
                return r;
 
        return sd_varlink_reply(v, parameters);
}
 
_public_ int sd_varlink_respond_and_upgrade(
                sd_varlink *v,
                sd_json_variant *parameters) {
        int r;
 
        assert_return(v, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        /* Return -EBUSY if we are not processing methods at all */
        if (!IN_SET(v->state,
                    VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PROCESSING_METHOD_ONEWAY, VARLINK_PROCESSING_METHOD_UPGRADE,
                    VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        /* Return -EPROTO if we are processing methods, but an upgrade was not requested. */
        if (!IN_SET(v->state,
                    VARLINK_PROCESSING_METHOD_UPGRADE,
                    VARLINK_PENDING_METHOD_UPGRADE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EPROTO), "Method call did not request a protocol upgrade.");
 
        /* Ensure we did not buffer any data beyond the upgrade request. Check this before sending the reply
         * so that we can return a normal error (the framework will send an error reply to the client). In
         * normal operation this cannot happen because the client waits for our reply before sending raw
         * data, and we disabled unbounded reads in dispatch to limit subsequent reads to single bytes. But a
         * misbehaving client could pipeline data early. */
        if (json_stream_has_buffered_input(&v->stream))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBADMSG),
                                         "Unexpected buffered data from client during protocol upgrade.");
 
        /* Validate parameters BEFORE sanitization (same validation as sd_varlink_reply(), but upgrade
         * replies never carry the 'continues' flag so we always pass flags=0) */
        if (v->current_method) {
                const char *bad_field = NULL;
 
                r = varlink_idl_validate_method_reply(v->current_method, parameters, /* flags= */ 0, &bad_field);
                if (r < 0)
                        /* Please adjust test/units/end.sh when updating the log message. */
                        varlink_log_errno(v, r, "Return parameters for method reply %s() didn't pass validation on field '%s', ignoring: %m",
                                          v->current_method->name, strna(bad_field));
        }
 
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        r = sd_json_buildo(&m, 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");
 
        switch (v->state) {
 
        case VARLINK_PENDING_METHOD_UPGRADE:
                varlink_clear_current(v);
                varlink_set_state(v, VARLINK_UPGRADING);
                break;
 
        case VARLINK_PROCESSING_METHOD_UPGRADE:
                varlink_set_state(v, VARLINK_PROCESSED_METHOD_UPGRADE);
                break;
 
        default:
                assert_not_reached();
        }
 
        return 1;
}
 
_public_ int sd_varlink_respond_and_upgradeb(sd_varlink *v, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, v);
        r = sd_json_buildv(&parameters, ap);
        va_end(ap);
 
        if (r < 0)
                return r;
 
        return sd_varlink_respond_and_upgrade(v, parameters);
}
 
_public_ int sd_varlink_reply_and_upgrade(
                sd_varlink *v,
                sd_json_variant *parameters,
                int *ret_input_fd,
                int *ret_output_fd) {
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(ret_input_fd || ret_output_fd, -EINVAL);
 
        r = sd_varlink_respond_and_upgrade(v, parameters);
        if (r < 0)
                return r;
 
        /* Flush the reply to the socket before stealing the fds. The reply must be fully written
         * before the caller starts speaking the upgraded protocol. */
        r = json_stream_flush(&v->stream);
        if (r < 0) {
                varlink_log_errno(v, r, "Failed to flush reply before protocol upgrade: %m");
                goto disconnect;
        }
 
        /* Detach from the event loop before stealing the fds */
        sd_varlink_detach_event(v);
 
        /* Now hand the original FDs over to the caller, from this point on we have nothing to do with the
         * connection anymore, it's up to the caller and we close the connection below */
        r = varlink_handle_upgrade_fds(v, ret_input_fd, ret_output_fd);
 
disconnect:
        /* This also sets the connection state to VARLINK_DISCONNECTED */
        sd_varlink_close(v);
 
        return r < 0 ? r : 1;
}
 
_public_ int sd_varlink_reset_fds(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        /* Closes all currently pending fds to send. This may be used whenever the caller is in the process
         * of putting together a message with fds, and then eventually something fails and they need to
         * rollback the fds. Note that this is implicitly called whenever an error reply is sent, see
         * below. */
 
        close_many(v->pushed_fds, v->n_pushed_fds);
        v->n_pushed_fds = 0;
        return 0;
}
 
_public_ int sd_varlink_error(sd_varlink *v, const char *error_id, sd_json_variant *parameters) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(error_id, -EINVAL);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
        if (!IN_SET(v->state,
                    VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PROCESSING_METHOD_UPGRADE,
                    VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        if (v->previous) {
                r = sd_json_variant_set_field_boolean(&v->previous, "continues", true);
                if (r < 0)
                        return r;
 
                /* If we have a previous reply still ready make sure we queue it before the error. We only
                 * ever set "previous" if we're in a streaming method so we pass more=true unconditionally
                 * here as we know we're still going to queue an error afterwards. */
                r = json_stream_enqueue_full(&v->stream, v->previous, v->previous_fds, v->n_previous_fds);
                if (r < 0)
                        return varlink_log_errno(v, r, "Failed to enqueue json message: %m");
 
                v->previous = sd_json_variant_unref(v->previous);
                v->previous_fds = mfree(v->previous_fds);
                v->n_previous_fds = 0;
        }
 
        /* Reset the list of pushed file descriptors before sending an error reply. We do this here to
         * simplify code that puts together a complex reply message with fds, and half-way something
         * fails. In that case the pushed fds need to be flushed out again. Under the assumption that it
         * never makes sense to send fds along with errors we simply flush them out here beforehand, so that
         * the callers don't need to do this explicitly. */
        sd_varlink_reset_fds(v);
 
        /* Validate parameters BEFORE sanitization */
        sd_varlink_symbol *symbol = hashmap_get(v->server->symbols, error_id);
        if (!symbol)
                varlink_log(v, "No interface description defined for error '%s', not validating.", error_id);
        else {
                const char *bad_field = NULL;
 
                r = varlink_idl_validate_error(symbol, parameters, &bad_field);
                if (r < 0)
                        /* Please adjust test/units/end.sh when updating the log message. */
                        varlink_log_errno(v, r, "Parameters for error %s didn't pass validation on field '%s', ignoring: %m",
                                          error_id, strna(bad_field));
        }
 
        r = sd_json_buildo(
                        &m,
                        SD_JSON_BUILD_PAIR_STRING("error", error_id),
                        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");
 
        if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE)) {
                varlink_clear_current(v);
                varlink_set_state(v, VARLINK_IDLE_SERVER);
        } else
                varlink_set_state(v, VARLINK_PROCESSED_METHOD);
 
        /* Everything worked. Let's now return the error we got passed as input as negative errno, so that
         * programs can just do "return sd_varlink_error();" and get both: a friendly error reply to clients,
         * and an error return from the current stack frame. */
        return sd_varlink_error_to_errno(error_id, parameters);
}
 
_public_ int sd_varlink_errorb(sd_varlink *v, const char *error_id, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(error_id, -EINVAL);
 
        va_start(ap, error_id);
        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_error(v, error_id, parameters);
}
 
_public_ int sd_varlink_error_invalid_parameter(sd_varlink *v, sd_json_variant *parameters) {
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(parameters, -EINVAL);
 
        /* We expect to be called in one of two ways: the 'parameters' argument is a string variant in which
         * case it is the parameter key name that is invalid. Or the 'parameters' argument is an object
         * variant in which case we'll pull out the first key. The latter mode is useful in functions that
         * don't expect any arguments. */
 
        /* varlink_error(...) expects a json object as the third parameter. Passing a string variant causes
         * parameter sanitization to fail, and it returns -EINVAL. */
 
        if (sd_json_variant_is_string(parameters)) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters_obj = NULL;
 
                r = sd_json_buildo(&parameters_obj, SD_JSON_BUILD_PAIR_VARIANT("parameter", parameters));
                if (r < 0)
                        return r;
 
                return sd_varlink_error(v, SD_VARLINK_ERROR_INVALID_PARAMETER, parameters_obj);
        }
 
        if (sd_json_variant_is_object(parameters) &&
            sd_json_variant_elements(parameters) > 0) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters_obj = NULL;
 
                r = sd_json_buildo(&parameters_obj, SD_JSON_BUILD_PAIR_VARIANT("parameter", sd_json_variant_by_index(parameters, 0)));
                if (r < 0)
                        return r;
 
                return sd_varlink_error(v, SD_VARLINK_ERROR_INVALID_PARAMETER, parameters_obj);
        }
 
        return -EINVAL;
}
 
_public_ int sd_varlink_error_invalid_parameter_name(sd_varlink *v, const char *name) {
        return sd_varlink_errorbo(
                        v,
                        SD_VARLINK_ERROR_INVALID_PARAMETER,
                        SD_JSON_BUILD_PAIR_STRING("parameter", name));
}
 
_public_ int sd_varlink_error_errno(sd_varlink *v, int error) {
 
        /* This generates a system error return that includes the Linux error number, and error name. The
         * error number is kinda Linux specific (and to some degree the error name too), hence let's indicate
         * the origin of the system error. This way interpretation of the error should not leave questions
         * open, even to foreign systems. */
 
        error = abs(error);
        const char *name = errno_name_no_fallback(error);
 
        return sd_varlink_errorbo(
                        v,
                        SD_VARLINK_ERROR_SYSTEM,
                        SD_JSON_BUILD_PAIR_STRING("origin", "linux"),
                        SD_JSON_BUILD_PAIR_INTEGER("errno", error),
                        JSON_BUILD_PAIR_STRING_NON_EMPTY("errnoName", name));
}
 
_public_ int sd_varlink_notify(sd_varlink *v, sd_json_variant *parameters) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *m = NULL;
        int r;
 
        assert_return(v, -EINVAL);
 
        if (v->sentinel)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EINVAL), "Cannot use sd_varlink_notify() on method with sentinel set");
 
        assert(!v->previous);
 
        if (v->state == VARLINK_DISCONNECTED)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(ENOTCONN), "Not connected.");
 
        /* If we want to reply with a notify connection but the caller didn't set "more", then return an
         * error indicating that we expected to be called with "more" set */
        if (IN_SET(v->state, VARLINK_PROCESSING_METHOD, VARLINK_PENDING_METHOD))
                return sd_varlink_error(v, SD_VARLINK_ERROR_EXPECTED_MORE, NULL);
 
        if (!IN_SET(v->state, VARLINK_PROCESSING_METHOD_MORE, VARLINK_PENDING_METHOD_MORE))
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "Connection busy.");
 
        /* Validate parameters BEFORE sanitization */
        if (v->current_method) {
                const char *bad_field = NULL;
 
                r = varlink_idl_validate_method_reply(v->current_method, parameters, SD_VARLINK_REPLY_CONTINUES, &bad_field);
                if (r == -EBADE)
                        varlink_log_errno(v, r, "Method reply for %s() has 'continues' flag set, but IDL structure doesn't allow that, ignoring: %m",
                                          v->current_method->name);
                else if (r < 0)
                        /* Please adjust test/units/end.sh when updating the log message. */
                        varlink_log_errno(v, r, "Return parameters for method reply %s() didn't pass validation on field '%s', ignoring: %m",
                                          v->current_method->name, strna(bad_field));
        }
 
        r = sd_json_buildo(
                        &m,
                        JSON_BUILD_PAIR_VARIANT_NON_EMPTY("parameters", parameters),
                        SD_JSON_BUILD_PAIR_BOOLEAN("continues", 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, as more is coming */
        return 1;
}
 
_public_ int sd_varlink_notifyb(sd_varlink *v, ...) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL;
        va_list ap;
        int r;
 
        assert_return(v, -EINVAL);
 
        va_start(ap, v);
        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_notify(v, parameters);
}
 
_public_ int sd_varlink_dispatch(sd_varlink *v, sd_json_variant *parameters, const sd_json_dispatch_field dispatch_table[], void *userdata) {
        const char *bad_field = NULL;
        int r;
 
        assert_return(v, -EINVAL);
 
        /* A wrapper around json_dispatch_full() that returns a nice InvalidParameter error if we hit a problem with some field. */
 
        /* sd_json_dispatch_full() now handles NULL parameters gracefully */
        r = sd_json_dispatch_full(parameters, dispatch_table, /* bad= */ NULL, /* flags= */ 0, userdata, &bad_field);
        if (r < 0) {
                if (bad_field)
                        return sd_varlink_error_invalid_parameter_name(v, bad_field);
                return r;
        }
 
        return 0;
}
 
_public_ int sd_varlink_bind_reply(sd_varlink *v, sd_varlink_reply_t reply) {
        assert_return(v, -EINVAL);
 
        if (reply && v->reply_callback && reply != v->reply_callback)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
        v->reply_callback = reply;
 
        return 0;
}
 
_public_ int sd_varlink_bind_upgrade(sd_varlink *v, sd_varlink_upgrade_t upgrade) {
        assert_return(v, -EINVAL);
 
        if (upgrade && v->upgrade_callback && upgrade != v->upgrade_callback)
                return varlink_log_errno(v, SYNTHETIC_ERRNO(EBUSY), "A different callback was already set.");
 
        v->upgrade_callback = upgrade;
 
        return 0;
}
 
_public_ void* sd_varlink_set_userdata(sd_varlink *v, void *userdata) {
        void *old;
 
        assert_return(v, NULL);
 
        old = v->userdata;
        v->userdata = userdata;
 
        return old;
}
 
_public_ void* sd_varlink_get_userdata(sd_varlink *v) {
        assert_return(v, NULL);
 
        return v->userdata;
}
 
_public_ int sd_varlink_set_sentinel(sd_varlink *v, const char *error_id) {
        assert_return(v, -EINVAL);
 
        /* If the caller doesn't want a reply, then don't set a sentinel. */
        if (v->state == VARLINK_PROCESSING_METHOD_ONEWAY)
                return 0;
 
        /* This has to be called during a callback, and not after it has exited. The PENDING states
         * apply to fiber callbacks, which run after varlink_dispatch_method() has already transitioned
         * the state from PROCESSING to PENDING. */
        assert_return(IN_SET(v->state,
                             VARLINK_PROCESSING_METHOD, VARLINK_PROCESSING_METHOD_MORE,
                             VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE),
                      -EUCLEAN);
 
        char *s = NULL;
        if (strdup_to(&s, error_id) < 0)
                return log_oom_debug();
 
        if (v->sentinel != POINTER_MAX)
                free(v->sentinel);
 
        v->sentinel = s ?: POINTER_MAX;
        return 0;
}
 
_public_ int sd_varlink_get_peer_uid(sd_varlink *v, uid_t *ret) {
        assert_return(v, -EINVAL);
        assert_return(ret, -EINVAL);
 
        return json_stream_acquire_peer_uid(&v->stream, ret);
}
 
_public_ int sd_varlink_get_peer_gid(sd_varlink *v, gid_t *ret) {
        assert_return(v, -EINVAL);
        assert_return(ret, -EINVAL);
 
        return json_stream_acquire_peer_gid(&v->stream, ret);
}
 
_public_ int sd_varlink_get_peer_pid(sd_varlink *v, pid_t *ret) {
        assert_return(v, -EINVAL);
        assert_return(ret, -EINVAL);