HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/sd-varlink.c
Git blob: 574fb57b5d87a469ddecdbe866d4aaf7f9d9b05f
Lines 1–1000 of 4,353
/* SPDX-License-Identifier: LGPL-2.1-or-later */
#include <poll.h>
#include <stdlib.h>
#include <unistd.h>
#include "sd-daemon.h"
#include "sd-event.h"
#include "sd-future.h"
#include "sd-varlink.h"
#include "alloc-util.h"
#include "env-util.h"
#include "errno-list.h"
#include "errno-util.h"
#include "escape.h"
#include "extract-word.h"
#include "fd-util.h"
#include "format-util.h"
#include "glyph-util.h"
#include "hashmap.h"
#include "json-util.h"
#include "list.h"
#include "log.h"
#include "mkdir.h"
#include "path-util.h"
#include "pidfd-util.h"
#include "pidref.h"
#include "process-util.h"
#include "socket-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
#include "umask-util.h"
#include "user-util.h"
#include "varlink-idl-util.h"
#include "varlink-internal.h"
#include "varlink-io.systemd.h"
#include "varlink-org.varlink.service.h"
#include "varlink-util.h"
#include "xattr-util.h"
#define VARLINK_DEFAULT_CONNECTIONS_MAX 4096U
#define VARLINK_DEFAULT_CONNECTIONS_PER_UID_MAX 128U
#define VARLINK_DEFAULT_TIMEOUT_USEC (45U*USEC_PER_SEC)
#define VARLINK_COLLECT_MAX 1024U
static const char* const varlink_state_table[_VARLINK_STATE_MAX] = {
[VARLINK_IDLE_CLIENT] = "idle-client",
[VARLINK_AWAITING_REPLY] = "awaiting-reply",
[VARLINK_AWAITING_REPLY_MORE] = "awaiting-reply-more",
[VARLINK_CALLING] = "calling",
[VARLINK_CALLED] = "called",
[VARLINK_COLLECTING] = "collecting",
[VARLINK_COLLECTING_REPLY] = "collecting-reply",
[VARLINK_PROCESSING_REPLY] = "processing-reply",
[VARLINK_IDLE_SERVER] = "idle-server",
[VARLINK_PROCESSING_METHOD] = "processing-method",
[VARLINK_PROCESSING_METHOD_MORE] = "processing-method-more",
[VARLINK_PROCESSING_METHOD_ONEWAY] = "processing-method-oneway",
[VARLINK_PROCESSING_METHOD_UPGRADE] = "processing-method-upgrade",
[VARLINK_PROCESSED_METHOD] = "processed-method",
[VARLINK_PROCESSED_METHOD_UPGRADE] = "processed-method-upgrade",
[VARLINK_PENDING_METHOD] = "pending-method",
[VARLINK_PENDING_METHOD_MORE] = "pending-method-more",
[VARLINK_PENDING_METHOD_UPGRADE] = "pending-method-upgrade",
[VARLINK_UPGRADING] = "upgrading",
[VARLINK_PENDING_DISCONNECT] = "pending-disconnect",
[VARLINK_PENDING_TIMEOUT] = "pending-timeout",
[VARLINK_PROCESSING_DISCONNECT] = "processing-disconnect",
[VARLINK_PROCESSING_TIMEOUT] = "processing-timeout",
[VARLINK_PROCESSING_FAILURE] = "processing-failure",
[VARLINK_DISCONNECTED] = "disconnected",
};
DEFINE_PRIVATE_STRING_TABLE_LOOKUP_TO_STRING(varlink_state, VarlinkState);
static void varlink_server_test_exit_on_idle(sd_varlink_server *s);
static int varlink_reply_terminator(sd_varlink *v);
static void varlink_set_state(sd_varlink *v, VarlinkState state) {
assert(v);
assert(state >= 0 && state < _VARLINK_STATE_MAX);
if (v->state < 0)
varlink_log(v, "Setting state %s",
varlink_state_to_string(state));
else
varlink_log(v, "Changing state %s %s %s",
varlink_state_to_string(v->state),
glyph(GLYPH_ARROW_RIGHT),
varlink_state_to_string(state));
v->state = state;
}
/* Map the varlink state machine onto the generic transport-level "phase". The transport
* uses this to decide whether to ask for POLLIN, whether the connection is salvageable
* after a read/write disconnect, and whether the idle timeout deadline is in force. */
static JsonStreamPhase varlink_phase(void *userdata) {
sd_varlink *v = ASSERT_PTR(userdata);
/* Client side reading a reply with the per-call deadline in force. */
if (IN_SET(v->state,
VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE,
VARLINK_CALLING, VARLINK_COLLECTING) &&
!v->current)
return JSON_STREAM_PHASE_AWAITING_REPLY;
/* Server side reading the next request — no deadline applies. */
if (v->state == VARLINK_IDLE_SERVER && !v->current)
return JSON_STREAM_PHASE_READING;
if (v->state == VARLINK_IDLE_CLIENT)
return JSON_STREAM_PHASE_IDLE_CLIENT;
if (IN_SET(v->state, VARLINK_PENDING_METHOD, VARLINK_PENDING_METHOD_MORE, VARLINK_PENDING_METHOD_UPGRADE))
return JSON_STREAM_PHASE_PENDING_OUTPUT;
return JSON_STREAM_PHASE_OTHER;
}
static int varlink_dispatch(void *userdata) {
sd_varlink *v = ASSERT_PTR(userdata);
return sd_varlink_process(v);
}
static int varlink_new(sd_varlink **ret) {
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
int r;
assert(ret);
v = new(sd_varlink, 1);
if (!v)
return -ENOMEM;
*v = (sd_varlink) {
.n_ref = 1,
.state = _VARLINK_STATE_INVALID,
.exec_pidref = PIDREF_NULL,
};
r = json_stream_init(
&v->stream,
&(JsonStreamParams) {
.phase = varlink_phase,
.dispatch = varlink_dispatch,
.userdata = v,
});
if (r < 0)
return r;
json_stream_set_timeout(&v->stream, VARLINK_DEFAULT_TIMEOUT_USEC);
*ret = TAKE_PTR(v);
return 0;
}
static int mark_varlink_socket(int fd, const char *path, const char *role) {
int r;
assert(wildcard_fd_is_valid(fd));
assert(role);
/* We define four roles:
*
* 1. "client" → this socket was created via socket()+connect() [sockfs]
* 2. "server" → this socket was created via accept() [sockfs]
* 3. "listen" → this socket was created via socket()+listen() [sockfs]
* 4. "entrypoint" → this is the entrypoint socket inode [not sockfs]
*/
r = socket_xattr_supported(); /* Let's check for the feature directly, to make use of the cache */
if (r < 0)
return r;
if (r == 0)
return -EOPNOTSUPP;
r = xsetxattr(fd, path, AT_EMPTY_PATH, "user.varlink", role);
if (r < 0)
return log_debug_errno(r, "Failed to set 'user.varlink' to '%s': %m", role);
return 0;
}
_public_ int sd_varlink_connect_address(sd_varlink **ret, const char *address) {
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(address, -EINVAL);
r = varlink_new(&v);
if (r < 0)
return log_debug_errno(r, "Failed to create varlink object: %m");
r = json_stream_connect_address(&v->stream, address);
if (r < 0)
return r;
(void) mark_varlink_socket(v->stream.input_fd, /* path= */ NULL, "client");
varlink_set_state(v, VARLINK_IDLE_CLIENT);
*ret = TAKE_PTR(v);
return 0;
}
static int varlink_socketpair(int *ret_client_fd, int *ret_server_fd) {
assert(ret_client_fd);
assert(ret_server_fd);
_cleanup_close_pair_ int pair[2] = EBADF_PAIR;
if (socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0, pair) < 0)
return log_debug_errno(errno, "Failed to allocate AF_UNIX socket pair: %m");
(void) mark_varlink_socket(pair[0], /* path= */ NULL, "client");
(void) mark_varlink_socket(pair[1], /* path= */ NULL, "server");
*ret_client_fd = TAKE_FD(pair[0]);
*ret_server_fd = TAKE_FD(pair[1]);
return 0;
}
_public_ int sd_varlink_connect_exec(sd_varlink **ret, const char *_command, char **_argv) {
_cleanup_(pidref_done_sigkill_wait) PidRef pidref = PIDREF_NULL;
_cleanup_free_ char *command = NULL;
_cleanup_strv_free_ char **argv = NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(_command, -EINVAL);
/* Copy the strings, in case they point into our own argv[], which we'll invalidate shortly because
* we rename the child process */
command = strdup(_command);
if (!command)
return -ENOMEM;
if (strv_isempty(_argv))
argv = strv_new(command);
else
argv = strv_copy(_argv);
if (!argv)
return -ENOMEM;
log_debug("Forking off Varlink child process '%s'.", command);
_cleanup_close_ int client_fd = -EBADF, server_fd = -EBADF;
r = varlink_socketpair(&client_fd, &server_fd);
if (r < 0)
return r;
r = fd_nonblock(server_fd, false);
if (r < 0)
return log_debug_errno(r, "Failed to disable O_NONBLOCK for varlink socket: %m");
r = pidref_safe_fork_full(
"(sd-vlexec)",
/* stdio_fds= */ NULL,
/* except_fds= */ (int[]) { server_fd },
/* n_except_fds= */ 1,
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_PACK_FDS|FORK_CLOEXEC_OFF|FORK_REOPEN_LOG|FORK_DEATHSIG_SIGTERM|FORK_RLIMIT_NOFILE_SAFE,
&pidref);
if (r < 0)
return log_debug_errno(r, "Failed to spawn process: %m");
if (r == 0) {
char spid[DECIMAL_STR_MAX(pid_t)+1];
const char *setenv_list[] = {
"LISTEN_PID", spid,
"LISTEN_FDS", "1",
"LISTEN_FDNAMES", "varlink",
NULL, NULL,
};
/* Child */
xsprintf(spid, PID_FMT, pidref.pid);
uint64_t pidfdid;
if (pidfd_get_inode_id_self_cached(&pidfdid) >= 0) {
r = setenvf("LISTEN_PIDFDID", /* overwrite= */ true, "%" PRIu64, pidfdid);
if (r < 0) {
log_debug_errno(r, "Failed to set environment variable 'LISTEN_PIDFDID': %m");
_exit(EXIT_FAILURE);
}
}
STRV_FOREACH_PAIR(a, b, setenv_list) {
if (setenv(*a, *b, /* overwrite= */ true) < 0) {
log_debug_errno(errno, "Failed to set environment variable '%s': %m", *a);
_exit(EXIT_FAILURE);
}
}
execvp(command, argv);
log_debug_errno(errno, "Failed to invoke process '%s': %m", command);
_exit(EXIT_FAILURE);
}
server_fd = safe_close(server_fd);
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
r = varlink_new(&v);
if (r < 0)
return log_debug_errno(r, "Failed to create varlink object: %m");
r = json_stream_attach_fds(&v->stream, client_fd, client_fd);
if (r < 0)
return r;
TAKE_FD(client_fd);
v->exec_pidref = TAKE_PIDREF(pidref);
varlink_set_state(v, VARLINK_IDLE_CLIENT);
*ret = TAKE_PTR(v);
return 0;
}
static int ssh_path(const char **ret) {
assert(ret);
const char *ssh = secure_getenv("SYSTEMD_SSH") ?: "ssh";
if (!path_is_valid(ssh))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "SSH path is not valid, refusing: %s", ssh);
*ret = ssh;
return 0;
}
static int varlink_connect_ssh_unix(sd_varlink **ret, const char *where) {
_cleanup_(pidref_done_sigkill_wait) PidRef pidref = PIDREF_NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(where, -EINVAL);
/* Connects to an SSH server via OpenSSH 9.4's -W switch to connect to a remote AF_UNIX socket. For
* now we do not expose this function directly, but only via varlink_connect_url(). */
const char *ssh;
r = ssh_path(&ssh);
if (r < 0)
return r;
const char *e = strchr(where, ':');
if (!e)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "SSH specification lacks a : separator between host and path, refusing: %s", where);
_cleanup_free_ char *h = strndup(where, e - where);
if (!h)
return log_oom_debug();
if (!path_is_absolute(e + 1))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Remote AF_UNIX socket path is not absolute, refusing: %s", e + 1);
_cleanup_free_ char *p = NULL;
r = path_simplify_alloc(e + 1, &p);
if (r < 0)
return r;
if (!path_is_normalized(p))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Specified path is not normalized, refusing: %s", p);
log_debug("Forking off SSH child process '%s -W %s %s'.", ssh, p, h);
_cleanup_close_ int client_fd = -EBADF, server_fd = -EBADF;
r = varlink_socketpair(&client_fd, &server_fd);
if (r < 0)
return r;
r = pidref_safe_fork_full(
"(sd-vlssh)",
/* stdio_fds= */ (int[]) { server_fd, server_fd, STDERR_FILENO },
/* except_fds= */ NULL,
/* n_except_fds= */ 0,
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_REOPEN_LOG|FORK_RLIMIT_NOFILE_SAFE|FORK_REARRANGE_STDIO,
&pidref);
if (r < 0)
return log_debug_errno(r, "Failed to spawn process: %m");
if (r == 0) {
/* Child */
execlp(ssh, "ssh", "-W", p, h, NULL);
log_debug_errno(errno, "Failed to invoke %s: %m", ssh);
_exit(EXIT_FAILURE);
}
server_fd = safe_close(server_fd);
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
r = varlink_new(&v);
if (r < 0)
return log_debug_errno(r, "Failed to create varlink object: %m");
r = json_stream_attach_fds(&v->stream, client_fd, client_fd);
if (r < 0)
return r;
TAKE_FD(client_fd);
v->exec_pidref = TAKE_PIDREF(pidref);
varlink_set_state(v, VARLINK_IDLE_CLIENT);
*ret = TAKE_PTR(v);
return 0;
}
static int varlink_connect_ssh_exec(sd_varlink **ret, const char *where) {
_cleanup_close_pair_ int input_pipe[2] = EBADF_PAIR, output_pipe[2] = EBADF_PAIR;
_cleanup_(pidref_done_sigkill_wait) PidRef pidref = PIDREF_NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(where, -EINVAL);
/* Connects to an SSH server to connect to a remote process' stdin/stdout. For now we do not expose
* this function directly, but only via varlink_connect_url(). */
const char *ssh;
r = ssh_path(&ssh);
if (r < 0)
return r;
const char *e = strchr(where, ':');
if (!e)
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "SSH specification lacks a : separator between host and path, refusing: %s", where);
_cleanup_free_ char *h = strndup(where, e - where);
if (!h)
return log_oom_debug();
_cleanup_strv_free_ char **cmdline = NULL;
r = strv_split_full(&cmdline, e + 1, /* separators= */ NULL, EXTRACT_CUNESCAPE|EXTRACT_UNQUOTE);
if (r < 0)
return log_debug_errno(r, "Failed to split command line: %m");
if (strv_isempty(cmdline))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Remote command line is empty, refusing.");
_cleanup_strv_free_ char **full_cmdline = NULL;
full_cmdline = strv_new("ssh", "-e", "none", "-T", h, "env", "SYSTEMD_VARLINK_LISTEN=-");
if (!full_cmdline)
return log_oom_debug();
r = strv_extend_strv_consume(&full_cmdline, TAKE_PTR(cmdline), /* filter_duplicates= */ false);
if (r < 0)
return log_oom_debug();
_cleanup_free_ char *j = NULL;
j = quote_command_line(full_cmdline, SHELL_ESCAPE_EMPTY);
if (!j)
return log_oom_debug();
log_debug("Forking off SSH child process: %s", j);
if (pipe2(input_pipe, O_CLOEXEC) < 0)
return log_debug_errno(errno, "Failed to allocate input pipe: %m");
if (pipe2(output_pipe, O_CLOEXEC) < 0)
return log_debug_errno(errno, "Failed to allocate output pipe: %m");
r = pidref_safe_fork_full(
"(sd-vlssh)",
/* stdio_fds= */ (int[]) { input_pipe[0], output_pipe[1], STDERR_FILENO },
/* except_fds= */ NULL,
/* n_except_fds= */ 0,
FORK_RESET_SIGNALS|FORK_CLOSE_ALL_FDS|FORK_DEATHSIG_SIGTERM|FORK_REOPEN_LOG|FORK_RLIMIT_NOFILE_SAFE|FORK_REARRANGE_STDIO,
&pidref);
if (r < 0)
return log_debug_errno(r, "Failed to spawn process: %m");
if (r == 0) {
/* Child */
execvp(ssh, full_cmdline);
log_debug_errno(errno, "Failed to invoke %s: %m", j);
_exit(EXIT_FAILURE);
}
input_pipe[0] = safe_close(input_pipe[0]);
output_pipe[1] = safe_close(output_pipe[1]);
r = fd_nonblock(input_pipe[1], true);
if (r < 0)
return log_debug_errno(r, "Failed to make input pipe non-blocking: %m");
r = fd_nonblock(output_pipe[0], true);
if (r < 0)
return log_debug_errno(r, "Failed to make output pipe non-blocking: %m");
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
r = varlink_new(&v);
if (r < 0)
return log_debug_errno(r, "Failed to create varlink object: %m");
r = json_stream_attach_fds(&v->stream, output_pipe[0], input_pipe[1]);
if (r < 0)
return r;
TAKE_FD(output_pipe[0]);
TAKE_FD(input_pipe[1]);
v->exec_pidref = TAKE_PIDREF(pidref);
varlink_set_state(v, VARLINK_IDLE_CLIENT);
*ret = TAKE_PTR(v);
return 0;
}
/* Do basic validation of the URL scheme (loosely following RFC 1738) */
static bool is_valid_url_scheme(const char *s) {
return !isempty(s) &&
strchr(LOWERCASE_LETTERS, s[0]) &&
in_charset(s, LOWERCASE_LETTERS DIGITS "+.-") &&
filename_is_valid(s);
}
_public_ int sd_varlink_connect_url(sd_varlink **ret, const char *url) {
_cleanup_free_ char *c = NULL;
const char *p;
enum {
SCHEME_UNIX,
SCHEME_EXEC,
SCHEME_SSH_UNIX,
SCHEME_SSH_EXEC,
} scheme;
int r;
assert_return(ret, -EINVAL);
assert_return(url, -EINVAL);
// FIXME: Maybe add support for vsock: URL schemes here.
/* The Varlink URL scheme is a bit underdefined. We support only the spec-defined unix: transport for
* now, plus exec:, ssh: transports we made up ourselves. Strictly speaking this shouldn't even be
* called "URL", since it has nothing to do with Internet URLs by RFC. */
p = startswith(url, "unix:");
if (p)
scheme = SCHEME_UNIX;
else if ((p = startswith(url, "exec:")))
scheme = SCHEME_EXEC;
else if ((p = STARTSWITH_SET(url, "ssh:", "ssh-unix:")))
scheme = SCHEME_SSH_UNIX;
else if ((p = startswith(url, "ssh-exec:")))
scheme = SCHEME_SSH_EXEC;
else {
/* scheme is not built-in: check if we have a bridge helper binary */
const char *colon = strchr(url, ':');
if (!colon)
return log_debug_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT),
"Invalid URL '%s': does not contain a ':'", url);
_cleanup_free_ char *scheme_name = strndup(url, colon - url);
if (!scheme_name)
return log_oom_debug();
if (!is_valid_url_scheme(scheme_name))
return log_debug_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT),
"URL scheme not valid as bridge name: %s", scheme_name);
const char *bridges_dir = secure_getenv("SYSTEMD_VARLINK_BRIDGES_DIR") ?: VARLINK_BRIDGES_DIR;
_cleanup_free_ char *bridge = path_join(bridges_dir, scheme_name);
if (!bridge)
return log_oom_debug();
if (access(bridge, X_OK) < 0) {
if (errno == ENOENT)
return log_debug_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "URL scheme '%s' not supported (and no auxiliary bridge binary is available).", scheme_name);
return log_debug_errno(errno, "Failed to look up varlink bridge binary '%s': %m", bridge);
}
return sd_varlink_connect_exec(ret, bridge, STRV_MAKE(bridge, url));
}
/* The varlink.org reference C library supports more than just file system paths. We might want to
* support that one day too. For now simply refuse that for our built-in schemes. It is fine for
* external scheme handled via plugins (see above). */
if (p[strcspn(p, ";?#")] != '\0')
return log_debug_errno(SYNTHETIC_ERRNO(EPROTONOSUPPORT), "URL parameterization with ';', '?', '#' not supported.");
if (scheme == SCHEME_SSH_UNIX)
return varlink_connect_ssh_unix(ret, p);
if (scheme == SCHEME_SSH_EXEC)
return varlink_connect_ssh_exec(ret, p);
if (scheme == SCHEME_EXEC || p[0] != '@') { /* no path validity checks for abstract namespace sockets */
if (!path_is_absolute(p))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Specified path not absolute, refusing.");
r = path_simplify_alloc(p, &c);
if (r < 0)
return r;
if (!path_is_normalized(c))
return log_debug_errno(SYNTHETIC_ERRNO(EINVAL), "Specified path is not normalized, refusing.");
}
if (scheme == SCHEME_EXEC)
return sd_varlink_connect_exec(ret, c, NULL);
return sd_varlink_connect_address(ret, c ?: p);
}
_public_ int sd_varlink_connect_fd_pair(sd_varlink **ret, int input_fd, int output_fd, const struct ucred *override_ucred) {
_cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
int r;
assert_return(ret, -EINVAL);
assert_return(input_fd >= 0, -EBADF);
assert_return(output_fd >= 0, -EBADF);
r = varlink_new(&v);
if (r < 0)
return log_debug_errno(r, "Failed to create varlink object: %m");
r = json_stream_connect_fd_pair(&v->stream, input_fd, output_fd);
if (r < 0)
return r;
(void) mark_varlink_socket(v->stream.input_fd, /* path= */ NULL, "client");
if (override_ucred)
json_stream_set_peer_ucred(&v->stream, override_ucred);
varlink_set_state(v, VARLINK_IDLE_CLIENT);
/* Note that if this function is called we assume the passed socket (if it is one) is already
* properly connected, i.e. any asynchronous connect() done on it already completed. Because of that
* we'll not set the 'connecting' boolean here, i.e. we don't need to avoid write()ing to the socket
* until the connection is fully set up. Behaviour here is hence a bit different from
* varlink_connect_address() above, as there we do handle asynchronous connections ourselves and
* avoid doing write() on it before we saw EPOLLOUT for the first time. */
*ret = TAKE_PTR(v);
return 0;
}
_public_ int sd_varlink_connect_fd(sd_varlink **ret, int fd) {
return sd_varlink_connect_fd_pair(ret, fd, fd, /* override_ucred= */ NULL);
}
static void varlink_clear_current(sd_varlink *v) {
assert(v);
/* Clears the currently processed incoming message */
v->current = sd_json_variant_unref(v->current);
v->current_collected = sd_json_variant_unref(v->current_collected);
v->current_method = NULL;
v->current_reply_flags = 0;
json_stream_close_input_fds(&v->stream);
v->previous = sd_json_variant_unref(v->previous);
close_many(v->previous_fds, v->n_previous_fds);
v->previous_fds = mfree(v->previous_fds);
v->n_previous_fds = 0;
if (v->sentinel != POINTER_MAX)
v->sentinel = mfree(v->sentinel);
else
v->sentinel = NULL;
}
static void varlink_clear(sd_varlink *v) {
assert(v);
/* Detach event sources first so the kernel no longer has epoll watches on the
* stream's fds, then free the stream — json_stream_done() closes the input/output
* fds, the cached peer_pidfd, the received input fds, and the queued output fds. */
sd_varlink_detach_event(v);
varlink_clear_current(v);
json_stream_done(&v->stream);
close_many(v->pushed_fds, v->n_pushed_fds);
v->pushed_fds = mfree(v->pushed_fds);
v->n_pushed_fds = 0;
pidref_done_sigterm_wait(&v->exec_pidref);
}
static sd_varlink* varlink_destroy(sd_varlink *v) {
if (!v)
return NULL;
/* If this is called the server object must already been unreffed here. Why that? because when we
* linked up the varlink connection with the server object we took one ref in each direction */
assert(!v->server);
varlink_clear(v);
return mfree(v);
}
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_varlink, sd_varlink, varlink_destroy);
static int varlink_test_disconnect(sd_varlink *v) {
assert(v);
/* Already disconnected? */
if (!VARLINK_STATE_IS_ALIVE(v->state))
return 0;
if (!json_stream_should_disconnect(&v->stream))
return 0;
varlink_set_state(v, VARLINK_PENDING_DISCONNECT);
return 1;
}
static int varlink_enqueue(sd_varlink *v, sd_json_variant *m) {
int r;
assert(v);
assert(m);
r = json_stream_enqueue_full(&v->stream, m, v->pushed_fds, v->n_pushed_fds);
if (r >= 0)
v->n_pushed_fds = 0; /* fds belong to the queue entry now */
/* We don't free v->pushed_fds so it can be reused for the next message. */
return r;
}
static int varlink_write(sd_varlink *v) {
assert(v);
if (!VARLINK_STATE_IS_ALIVE(v->state))
return 0;
return json_stream_write(&v->stream);
}
static int varlink_read(sd_varlink *v) {
assert(v);
if (!IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING, VARLINK_COLLECTING, VARLINK_IDLE_SERVER))
return 0;
if (v->current)
return 0;
return json_stream_read(&v->stream);
}
static int varlink_parse_message(sd_varlink *v) {
int r;
assert(v);
if (v->current)
return 0;
r = json_stream_parse(&v->stream, &v->current);
if (r <= 0)
return r;
if (json_stream_flags_set(&v->stream, JSON_STREAM_INPUT_SENSITIVE)) {
/* Mark the parameters subfield as sensitive right-away, if that's requested */
sd_json_variant *parameters = sd_json_variant_by_key(v->current, "parameters");
if (parameters)
sd_json_variant_sensitive(parameters);
}
return 1;
}
static int varlink_test_timeout(sd_varlink *v) {
assert(v);
usec_t deadline = json_stream_get_timeout(&v->stream);
if (deadline == USEC_INFINITY || now(CLOCK_MONOTONIC) < deadline)
return 0;
varlink_set_state(v, VARLINK_PENDING_TIMEOUT);
return 1;
}
static int varlink_dispatch_local_error(sd_varlink *v, const char *error) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *empty = NULL;
int r;
assert(v);
assert(error);
if (!v->reply_callback)
return 0;
r = sd_json_variant_new_object(&empty, NULL, 0);
if (r < 0)
return r;
r = v->reply_callback(v, empty, error, SD_VARLINK_REPLY_ERROR|SD_VARLINK_REPLY_LOCAL, v->userdata);
if (r < 0)
varlink_log_errno(v, r, "Reply callback returned error, ignoring: %m");
return 1;
}
static int varlink_dispatch_timeout(sd_varlink *v) {
assert(v);
if (v->state != VARLINK_PENDING_TIMEOUT)
return 0;
varlink_set_state(v, VARLINK_PROCESSING_TIMEOUT);
varlink_dispatch_local_error(v, SD_VARLINK_ERROR_TIMEOUT);
sd_varlink_close(v);
return 1;
}
static int varlink_dispatch_disconnect(sd_varlink *v) {
assert(v);
if (v->state != VARLINK_PENDING_DISCONNECT)
return 0;
varlink_set_state(v, VARLINK_PROCESSING_DISCONNECT);
varlink_dispatch_local_error(v, SD_VARLINK_ERROR_DISCONNECTED);
sd_varlink_close(v);
return 1;
}
static int varlink_normalize_incoming_parameters(sd_json_variant **framing, sd_json_variant **params) {
int r;
/* UAPI.20 specifies that receivers of Varlink messages MUST treat "parameters" identically no matter
* if it is missing, explicitly null, or an empty object. Here, we choose to normalize "parameters"
* to an empty object if it is missing or null, which makes sd_varlink behave predictably (i.e.
* sd_varlink_call and similar never return write NULL to ret_parameters if they return r >= 0) */
assert(params);
if (!*params || sd_json_variant_is_null(*params)) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *empty = NULL;
r = sd_json_variant_new_object(&empty, NULL, 0);
if (r < 0)
return r;
if (framing) {
r = sd_json_variant_set_field(framing, "parameters", empty);
if (r < 0)
return r;
}
return json_variant_unref_and_replace(*params, empty);
}
return 0;
}
static int varlink_dispatch_reply(sd_varlink *v) {
_cleanup_(sd_json_variant_unrefp) sd_json_variant *parameters = NULL, *error = NULL;
sd_varlink_reply_flags_t flags = 0;
sd_json_variant *e;
const char *k;
int r;
assert(v);
if (!IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE, VARLINK_CALLING, VARLINK_COLLECTING))
return 0;
if (!v->current)
return 0;
assert(v->n_pending > 0);
if (!sd_json_variant_is_object(v->current))
goto invalid;
JSON_VARIANT_OBJECT_FOREACH(k, e, v->current) {
if (streq(k, "error")) {
if (error)
goto invalid;
if (!sd_json_variant_is_string(e))
goto invalid;
error = sd_json_variant_ref(e);
flags |= SD_VARLINK_REPLY_ERROR;
} 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, "continues")) {
if (FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES))
goto invalid;
if (!sd_json_variant_is_boolean(e))
goto invalid;
if (sd_json_variant_boolean(e))
flags |= SD_VARLINK_REPLY_CONTINUES;
} else
goto invalid;
}
/* Replies with 'continue' set are only OK if we set 'more' when the method call was initiated */
if (!IN_SET(v->state, VARLINK_AWAITING_REPLY_MORE, VARLINK_COLLECTING) && FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES))
goto invalid;
/* An error is final */
if (error && FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES))
goto invalid;
r = varlink_normalize_incoming_parameters(&v->current, ¶meters);
if (r < 0)
goto invalid;
v->current_reply_flags = flags;
if (IN_SET(v->state, VARLINK_AWAITING_REPLY, VARLINK_AWAITING_REPLY_MORE)) {
varlink_set_state(v, VARLINK_PROCESSING_REPLY);
if (v->reply_callback) {
r = v->reply_callback(v, parameters, sd_json_variant_string(error), flags, v->userdata);
if (r < 0)
varlink_log_errno(v, r, "Reply callback returned error, ignoring: %m");
}
varlink_clear_current(v);
if (v->state == VARLINK_PROCESSING_REPLY) {
assert(v->n_pending > 0);
if (!FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES))
v->n_pending--;
varlink_set_state(v,
FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES) ? VARLINK_AWAITING_REPLY_MORE :
v->n_pending == 0 ? VARLINK_IDLE_CLIENT : VARLINK_AWAITING_REPLY);
}
} else if (v->state == VARLINK_COLLECTING)
varlink_set_state(v, VARLINK_COLLECTING_REPLY);
else {
assert(v->state == VARLINK_CALLING);
varlink_set_state(v, VARLINK_CALLED);
}
return 1;
invalid:
varlink_set_state(v, VARLINK_PROCESSING_FAILURE);
varlink_dispatch_local_error(v, SD_VARLINK_ERROR_PROTOCOL);
sd_varlink_close(v);
return 1;
}
static int generic_method_get_info(
sd_varlink *link,
sd_json_variant *parameters,
sd_varlink_method_flags_t flags,
void *userdata) {
_cleanup_strv_free_ char **interfaces = NULL;
int r;
assert(link);
assert(link->server);
r = sd_varlink_dispatch(link, parameters, /* dispatch_table= */ NULL, /* userdata= */ NULL);
if (r != 0)
return r;
sd_varlink_interface *interface;
HASHMAP_FOREACH(interface, link->server->interfaces) {
r = strv_extend(&interfaces, interface->name);
if (r < 0)
return r;
}
strv_sort(interfaces);
return sd_varlink_replybo(
link,
SD_JSON_BUILD_PAIR_STRING("vendor", strempty(link->server->vendor)),
SD_JSON_BUILD_PAIR_STRING("product", strempty(link->server->product)),
SD_JSON_BUILD_PAIR_STRING("version", strempty(link->server->version)),
SD_JSON_BUILD_PAIR_STRING("url", strempty(link->server->url)),
SD_JSON_BUILD_PAIR_STRV("interfaces", interfaces));
}
static int generic_method_get_interface_description(
sd_varlink *link,
sd_json_variant *parameters,
sd_varlink_method_flags_t flags,
void *userdata) {
static const sd_json_dispatch_field dispatch_table[] = {
{ "interface", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, 0, SD_JSON_MANDATORY },
{}