HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/sd-varlink.c
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, ¶meters);
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(¶meters, 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(¶meters, 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);