HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/sd-varlink.c
Git blob: 574fb57b5d87a469ddecdbe866d4aaf7f9d9b05f
Lines 2001–3000 of 4,353
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_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(¶meters, 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(¶meters, 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(¶meters, 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(¶meters, 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(¶meters, 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(¶meters, 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(¶meters_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(¶meters_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(¶meters, 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);