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 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, &parameters);
        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 },
                {}