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 3001–4000 of 4,353

        return json_stream_acquire_peer_pid(&v->stream, ret);
}
 
_public_ int sd_varlink_get_peer_pidfd(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        return json_stream_acquire_peer_pidfd(&v->stream);
}
 
_public_ int sd_varlink_set_relative_timeout(sd_varlink *v, uint64_t timeout) {
        assert_return(v, -EINVAL);
 
        /* If set to 0, reset to default value */
        json_stream_set_timeout(&v->stream, timeout == 0 ? VARLINK_DEFAULT_TIMEOUT_USEC : timeout);
        return 0;
}
 
_public_ sd_varlink_server *sd_varlink_get_server(sd_varlink *v) {
        assert_return(v, NULL);
 
        return v->server;
}
 
_public_ int sd_varlink_set_description(sd_varlink *v, const char *description) {
        assert_return(v, -EINVAL);
 
        return json_stream_set_description(&v->stream, description);
}
 
_public_ const char* sd_varlink_get_description(sd_varlink *v) {
        assert_return(v, NULL);
 
        return json_stream_get_description(&v->stream);
}
 
static int defer_callback(sd_event_source *s, void *userdata) {
        sd_varlink *v = ASSERT_PTR(userdata);
 
        assert(s);
 
        (void) sd_varlink_process(v);
        return 1;
}
 
static int quit_callback(sd_event_source *event, void *userdata) {
        sd_varlink *v = ASSERT_PTR(userdata);
 
        assert(event);
 
        sd_varlink_flush(v);
        sd_varlink_close(v);
 
        return 1;
}
 
_public_ int sd_varlink_attach_event(sd_varlink *v, sd_event *e, int64_t priority) {
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(!json_stream_get_event(&v->stream), -EBUSY);
 
        r = json_stream_attach_event(&v->stream, e, priority);
        if (r < 0)
                return r;
 
        sd_event *event = json_stream_get_event(&v->stream);
 
        r = sd_event_add_exit(event, &v->quit_event_source, quit_callback, v);
        if (r < 0)
                goto fail;
 
        r = sd_event_source_set_priority(v->quit_event_source, priority);
        if (r < 0)
                goto fail;
 
        (void) sd_event_source_set_description(v->quit_event_source, "varlink-quit");
 
        r = sd_event_add_defer(event, &v->defer_event_source, defer_callback, v);
        if (r < 0)
                goto fail;
 
        r = sd_event_source_set_priority(v->defer_event_source, priority);
        if (r < 0)
                goto fail;
 
        (void) sd_event_source_set_description(v->defer_event_source, "varlink-defer");
 
        return 0;
 
fail:
        varlink_log_errno(v, r, "Failed to setup event source: %m");
        sd_varlink_detach_event(v);
        return r;
}
 
_public_ void sd_varlink_detach_event(sd_varlink *v) {
        if (!v)
                return;
 
        v->quit_event_source = sd_event_source_disable_unref(v->quit_event_source);
        v->defer_event_source = sd_event_source_disable_unref(v->defer_event_source);
        json_stream_detach_event(&v->stream);
}
 
_public_ sd_event* sd_varlink_get_event(sd_varlink *v) {
        assert_return(v, NULL);
 
        return json_stream_get_event(&v->stream);
}
 
_public_ int sd_varlink_push_fd(sd_varlink *v, int fd) {
        assert_return(v, -EINVAL);
        assert_return(fd >= 0, -EBADF);
 
        /* Takes an fd to send along with the *next* varlink message sent via this varlink connection. This
         * takes ownership of the specified fd. Use varlink_dup_fd() below to duplicate the fd first. */
 
        if (!json_stream_flags_set(&v->stream, JSON_STREAM_ALLOW_FD_PASSING_OUTPUT))
                return -EPERM;
 
        if (v->n_pushed_fds >= SCM_MAX_FD) /* Kernel doesn't support more than 253 fds per message, refuse early hence */
                return -ENOBUFS;
 
        if (!GREEDY_REALLOC(v->pushed_fds, v->n_pushed_fds + 1))
                return -ENOMEM;
 
        int i = (int) v->n_pushed_fds;
        v->pushed_fds[v->n_pushed_fds++] = fd;
        return i;
}
 
_public_ int sd_varlink_push_dup_fd(sd_varlink *v, int fd) {
        _cleanup_close_ int dp = -1;
        int r;
 
        assert_return(v, -EINVAL);
        assert_return(fd >= 0, -EBADF);
 
        /* Like varlink_push_fd() but duplicates the specified fd instead of taking possession of it */
 
        dp = fcntl(fd, F_DUPFD_CLOEXEC, 3);
        if (dp < 0)
                return -errno;
 
        r = sd_varlink_push_fd(v, dp);
        if (r < 0)
                return r;
 
        TAKE_FD(dp);
        return r;
}
 
_public_ int sd_varlink_peek_fd(sd_varlink *v, size_t i) {
        assert_return(v, -EINVAL);
 
        /* Returns one of the file descriptors that were received along with the current message. This does
         * not duplicate the fd nor invalidate it, it hence remains in our possession. */
 
        if (!json_stream_flags_set(&v->stream, JSON_STREAM_ALLOW_FD_PASSING_INPUT))
                return -EPERM;
 
        return json_stream_peek_input_fd(&v->stream, i);
}
 
_public_ int sd_varlink_peek_dup_fd(sd_varlink *v, size_t i) {
        int fd;
 
        fd = sd_varlink_peek_fd(v, i);
        if (fd < 0)
                return fd;
 
        return RET_NERRNO(fcntl(fd, F_DUPFD_CLOEXEC, 3));
}
 
_public_ int sd_varlink_take_fd(sd_varlink *v, size_t i) {
        assert_return(v, -EINVAL);
 
        /* Similar to varlink_peek_fd() but the file descriptor's ownership is passed to the caller, and
         * we'll invalidate the reference to it under our possession. If called twice in a row will return
         * -EBADF */
 
        if (!json_stream_flags_set(&v->stream, JSON_STREAM_ALLOW_FD_PASSING_INPUT))
                return -EPERM;
 
        return json_stream_take_input_fd(&v->stream, i);
}
 
_public_ int sd_varlink_get_n_fds(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        if (!json_stream_flags_set(&v->stream, JSON_STREAM_ALLOW_FD_PASSING_INPUT))
                return -EPERM;
 
        return (int) json_stream_get_n_input_fds(&v->stream);
}
 
_public_ int sd_varlink_set_allow_fd_passing_input(sd_varlink *v, int b) {
        assert_return(v, -EINVAL);
 
        /* Server connections that haven't opted into FD_PASSING_INPUT_STRICT skip the
         * per-connection SO_PASSRIGHTS setsockopt — the listening server already configured
         * the socket option once at listen time. */
        bool with_sockopt = !v->server || FLAGS_SET(v->server->flags, SD_VARLINK_SERVER_FD_PASSING_INPUT_STRICT);
 
        return json_stream_set_allow_fd_passing_input(&v->stream, !!b, with_sockopt);
}
 
_public_ int sd_varlink_set_allow_fd_passing_output(sd_varlink *v, int b) {
        assert_return(v, -EINVAL);
 
        return json_stream_set_allow_fd_passing_output(&v->stream, !!b);
}
 
_public_ int sd_varlink_set_input_sensitive(sd_varlink *v) {
        assert_return(v, -EINVAL);
 
        json_stream_set_flags(&v->stream, JSON_STREAM_INPUT_SENSITIVE, true);
        return 0;
}
 
_public_ int sd_varlink_server_new(sd_varlink_server **ret, sd_varlink_server_flags_t flags) {
        _cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
        int r;
 
        assert_return(ret, -EINVAL);
        assert_return((flags & ~(SD_VARLINK_SERVER_ROOT_ONLY|
                                 SD_VARLINK_SERVER_MYSELF_ONLY|
                                 SD_VARLINK_SERVER_ACCOUNT_UID|
                                 SD_VARLINK_SERVER_INHERIT_USERDATA|
                                 SD_VARLINK_SERVER_INPUT_SENSITIVE|
                                 SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT|
                                 SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT|
                                 SD_VARLINK_SERVER_FD_PASSING_INPUT_STRICT|
                                 SD_VARLINK_SERVER_HANDLE_SIGINT|
                                 SD_VARLINK_SERVER_HANDLE_SIGTERM|
                                 SD_VARLINK_SERVER_UPGRADABLE)) == 0, -EINVAL);
 
        s = new(sd_varlink_server, 1);
        if (!s)
                return log_oom_debug();
 
        *s = (sd_varlink_server) {
                .n_ref = 1,
                .flags = flags,
                .connections_max = sd_varlink_server_connections_max(NULL),
                .connections_per_uid_max = sd_varlink_server_connections_per_uid_max(NULL),
        };
 
        r = sd_varlink_server_add_interface_many(
                        s,
                        &vl_interface_io_systemd,
                        &vl_interface_org_varlink_service);
        if (r < 0)
                return r;
 
        *ret = TAKE_PTR(s);
        return 0;
}
 
static sd_varlink_server* varlink_server_destroy(sd_varlink_server *s) {
        char *m;
 
        if (!s)
                return NULL;
 
        sd_varlink_server_shutdown(s);
 
        while ((m = hashmap_steal_first_key(s->methods)))
                free(m);
 
        while ((m = hashmap_steal_first_key(s->fiber_methods)))
                free(m);
 
        hashmap_free(s->methods);
        hashmap_free(s->fiber_methods);
        hashmap_free(s->interfaces);
        hashmap_free(s->symbols);
        hashmap_free(s->by_uid);
 
        sd_event_unref(s->event);
 
        free(s->description);
        free(s->vendor);
        free(s->product);
        free(s->version);
        free(s->url);
 
        return mfree(s);
}
 
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_varlink_server, sd_varlink_server, varlink_server_destroy);
 
_public_ int sd_varlink_server_set_info(
                sd_varlink_server *s,
                const char *vendor,
                const char *product,
                const char *version,
                const char *url) {
 
        assert_return(s, -EINVAL);
 
        _cleanup_free_ char
                *a = vendor ? strdup(vendor) : NULL,
                *b = product ? strdup(product) : NULL,
                *c = version ? strdup(version) : NULL,
                *d = url ? strdup(url) : NULL;
        if ((vendor && !a) || (product && !b) || (version && !c) || (url && !d))
                return log_oom_debug();
 
        free_and_replace(s->vendor, a);
        free_and_replace(s->product, b);
        free_and_replace(s->version, c);
        free_and_replace(s->url, d);
 
        return 0;
}
 
static int validate_connection(sd_varlink_server *server, const struct ucred *ucred) {
        int allowed = -1;
 
        assert(server);
        assert(ucred);
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_ROOT_ONLY))
                allowed = ucred->uid == 0;
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_MYSELF_ONLY))
                allowed = allowed > 0 || ucred->uid == getuid();
 
        if (allowed == 0) { /* Allow access when it is explicitly allowed or when neither
                             * VARLINK_SERVER_ROOT_ONLY nor VARLINK_SERVER_MYSELF_ONLY are specified. */
                varlink_server_log(server, "Unprivileged client attempted connection, refusing.");
                return 0;
        }
 
        if (server->n_connections >= server->connections_max) {
                varlink_server_log(server, "Connection limit of %u reached, refusing.", server->connections_max);
                return 0;
        }
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_ACCOUNT_UID)) {
                unsigned c;
 
                if (!uid_is_valid(ucred->uid)) {
                        varlink_server_log(server, "Client with invalid UID attempted connection, refusing.");
                        return 0;
                }
 
                c = PTR_TO_UINT(hashmap_get(server->by_uid, UID_TO_PTR(ucred->uid)));
                if (c >= server->connections_per_uid_max) {
                        varlink_server_log(server, "Per-UID connection limit of %u for '" UID_FMT "' reached, refusing.",
                                           server->connections_per_uid_max, ucred->uid);
                        return 0;
                }
        }
 
        return 1;
}
 
static int count_connection(sd_varlink_server *server, const struct ucred *ucred) {
        unsigned c;
        int r;
 
        assert(server);
        assert(ucred);
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_ACCOUNT_UID)) {
                assert(uid_is_valid(ucred->uid));
 
                r = hashmap_ensure_allocated(&server->by_uid, NULL);
                if (r < 0)
                        return varlink_server_log_errno(server, r, "Failed to allocate UID hash table: %m");
 
                c = PTR_TO_UINT(hashmap_get(server->by_uid, UID_TO_PTR(ucred->uid)));
 
                varlink_server_log(server, "Connections of user " UID_FMT ": %u (of %u max)",
                                   ucred->uid, c, server->connections_per_uid_max);
 
                r = hashmap_replace(server->by_uid, UID_TO_PTR(ucred->uid), UINT_TO_PTR(c + 1));
                if (r < 0)
                        return varlink_server_log_errno(server, r, "Failed to increment counter in UID hash table: %m");
        }
 
        server->n_connections++;
 
        return 0;
}
 
_public_ int sd_varlink_server_add_connection_pair(
                sd_varlink_server *server,
                int input_fd,
                int output_fd,
                const struct ucred *override_ucred,
                sd_varlink **ret) {
 
        _cleanup_(sd_varlink_unrefp) sd_varlink *v = NULL;
        struct ucred ucred = UCRED_INVALID;
        bool ucred_acquired;
        int r;
 
        assert_return(server, -EINVAL);
        assert_return(input_fd >= 0, -EBADF);
        assert_return(output_fd >= 0, -EBADF);
 
        if ((server->flags & (SD_VARLINK_SERVER_ROOT_ONLY|SD_VARLINK_SERVER_MYSELF_ONLY|SD_VARLINK_SERVER_ACCOUNT_UID)) != 0) {
 
                if (override_ucred)
                        ucred = *override_ucred;
                else {
                        if (input_fd != output_fd)
                                return varlink_server_log_errno(server, SYNTHETIC_ERRNO(EOPNOTSUPP), "Cannot determine peer identity of connection with separate input/output, refusing.");
 
                        r = getpeercred(input_fd, &ucred);
                        if (r < 0)
                                return varlink_server_log_errno(server, r, "Failed to acquire peer credentials of incoming socket, refusing: %m");
                }
 
                ucred_acquired = true;
 
                r = validate_connection(server, &ucred);
                if (r < 0)
                        return r;
                if (r == 0)
                        return -EPERM;
        } else
                ucred_acquired = false;
 
        r = varlink_new(&v);
        if (r < 0)
                return varlink_server_log_errno(server, r, "Failed to allocate connection object: %m");
 
        r = count_connection(server, &ucred);
        if (r < 0)
                return r;
 
        /* Link up the server and the connection, and take reference in both directions. Note that the
         * reference on the connection is left dangling. It will be dropped when the connection is closed,
         * which happens in varlink_close(), including in the event loop quit callback. */
        v->server = sd_varlink_server_ref(server);
        sd_varlink_ref(v);
 
        if (ucred_acquired)
                json_stream_set_peer_ucred(&v->stream, &ucred);
 
        r = json_stream_attach_fds(&v->stream, input_fd, output_fd);
        if (r < 0) {
                sd_varlink_close(v);
                return r;
        }
 
        if (server->flags & SD_VARLINK_SERVER_INHERIT_USERDATA)
                v->userdata = server->userdata;
 
        /* If the server might receive a protocol upgrade method, switch the input path to
         * byte-bounded reads so we don't accidentally consume post-upgrade bytes. */
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_UPGRADABLE))
                json_stream_set_flags(&v->stream, JSON_STREAM_BOUNDED_READS, true);
 
        _cleanup_free_ char *desc = NULL;
        if (asprintf(&desc, "%s-%i-%i", varlink_server_description(server), input_fd, output_fd) >= 0)
                json_stream_set_description(&v->stream, desc);
 
        (void) sd_varlink_set_allow_fd_passing_input(v, FLAGS_SET(server->flags, SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT));
        (void) sd_varlink_set_allow_fd_passing_output(v, FLAGS_SET(server->flags, SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT));
 
        if (server->event) {
                r = sd_varlink_attach_event(v, server->event, server->event_priority);
                if (r < 0) {
                        varlink_log_errno(v, r, "Failed to attach new connection: %m");
                        /* Detach the fds from the connection so the caller (the connect callback)
                         * can decide what to do with them. The original fd value(s) the caller
                         * passed in are still owned by the caller; we just stop the connection
                         * from closing them on shutdown. */
                        TAKE_FD(v->stream.input_fd);
                        TAKE_FD(v->stream.output_fd);
                        sd_varlink_close(v);
                        return r;
                }
        }
 
        varlink_set_state(v, VARLINK_IDLE_SERVER);
 
        (void) mark_varlink_socket(input_fd, /* path= */ NULL, "server");
 
        if (ret)
                *ret = v;
 
        return 0;
}
 
_public_ int sd_varlink_server_add_connection(sd_varlink_server *server, int fd, sd_varlink **ret) {
        return sd_varlink_server_add_connection_pair(server, fd, fd, /* override_ucred= */ NULL, ret);
}
 
VarlinkServerSocket* varlink_server_socket_free(VarlinkServerSocket *ss) {
        if (!ss)
                return NULL;
 
        sd_event_source_disable_unref(ss->event_source);
        free(ss->address);
        return mfree(ss);
}
 
static int connect_callback(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
        VarlinkServerSocket *ss = ASSERT_PTR(userdata);
        _cleanup_close_ int cfd = -EBADF;
        sd_varlink *v = NULL;
        int r;
 
        assert(source);
 
        varlink_server_log(ss->server, "New incoming connection.");
 
        cfd = accept4(fd, NULL, NULL, SOCK_NONBLOCK|SOCK_CLOEXEC);
        if (cfd < 0) {
                if (ERRNO_IS_ACCEPT_AGAIN(errno))
                        return 0;
 
                return varlink_server_log_errno(ss->server, errno, "Failed to accept incoming socket: %m");
        }
 
        r = sd_varlink_server_add_connection(ss->server, cfd, &v);
        if (r < 0)
                return 0;
 
        TAKE_FD(cfd);
 
        if (FLAGS_SET(ss->server->flags, SD_VARLINK_SERVER_INPUT_SENSITIVE))
                sd_varlink_set_input_sensitive(v);
 
        if (ss->server->connect_callback) {
                r = ss->server->connect_callback(ss->server, v, ss->server->userdata);
                if (r < 0) {
                        varlink_log_errno(v, r, "Connection callback returned error, disconnecting client: %m");
                        sd_varlink_close(v);
                        return 0;
                }
        }
 
        return 0;
}
 
static int varlink_server_create_listen_fd_socket(sd_varlink_server *s, int fd, VarlinkServerSocket **ret_ss) {
        _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
        int r;
 
        assert(s);
        assert(fd >= 0);
        assert(ret_ss);
 
        ss = new(VarlinkServerSocket, 1);
        if (!ss)
                return log_oom_debug();
 
        *ss = (VarlinkServerSocket) {
                .server = s,
                .fd = fd,
        };
 
        if (s->event) {
                r = varlink_server_add_socket_event_source(s, ss);
                if (r < 0)
                        return r;
        }
 
        *ret_ss = TAKE_PTR(ss);
        return 0;
}
 
_public_ int sd_varlink_server_listen_fd(sd_varlink_server *s, int fd) {
        _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
        int r;
 
        assert_return(s, -EINVAL);
        assert_return(fd >= 0, -EBADF);
 
        r = fd_nonblock(fd, true);
        if (r < 0)
                return r;
 
        r = fd_cloexec(fd, true);
        if (r < 0)
                return r;
 
        /* If fd passing is disabled on server, and SD_VARLINK_SERVER_FD_PASSING_INPUT_STRICT flag is set,
         * turn off SO_PASSRIGHTS immediately on listening socket. The conditionalization behind a flag
         * is needed to retain backwards compat, where implementations would register a connection callback
         * to enable fd passing after accept(), which might race with clients wrt SO_PASSRIGHTS state. */
        if (FLAGS_SET(s->flags, SD_VARLINK_SERVER_FD_PASSING_INPUT_STRICT))
                (void) setsockopt_int(fd, SOL_SOCKET, SO_PASSRIGHTS, FLAGS_SET(s->flags, SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT));
 
        r = varlink_server_create_listen_fd_socket(s, fd, &ss);
        if (r < 0)
                return r;
 
        (void) mark_varlink_socket(ss->fd, /* path= */ NULL, "listen");
 
        LIST_PREPEND(sockets, s->sockets, TAKE_PTR(ss));
        return 0;
}
 
static mode_t default_listen_mode(sd_varlink_server_flags_t flags) {
        /* NB: we use 0644 rather than 0600 here, because it's the "w" flag that controls connect()
         * privileges, but leaving the "r" flag on allows others to read our xattrs, which is good because it
         * makes our sockets recognizable as varlink, even if not connectible. */
        return (flags & (SD_VARLINK_SERVER_ROOT_ONLY|SD_VARLINK_SERVER_MYSELF_ONLY)) != 0 ? 0644 : 0666;
}
 
_public_ int sd_varlink_server_listen_address(sd_varlink_server *s, const char *address, mode_t m) {
        _cleanup_(varlink_server_socket_freep) VarlinkServerSocket *ss = NULL;
        union sockaddr_union sockaddr;
        socklen_t sockaddr_len;
        _cleanup_close_ int fd = -EBADF;
        int r;
 
        assert_return(s, -EINVAL);
        assert_return(address, -EINVAL);
 
        /* NB: we resolve m being MODE_INVALID before checking SD_VARLINK_SERVER_MODE_MKDIR_0755, since that
         * flag is not defined for MODE_INVALID (if we'd check we'd see it always set...) */
        if (m == MODE_INVALID)
                m = default_listen_mode(s->flags);
 
        assert_return((m & ~(0777|SD_VARLINK_SERVER_MODE_MKDIR_0755)) == 0, -EINVAL);
 
        /* Validate that the definition of our flag doesn't collide with the official mode_t bits. Thankfully
         * the bit values of mode_t flags are fairly well established (POSIX and all), hence we should be
         * safe here. */
        assert_cc(((S_IFMT|07777) & SD_VARLINK_SERVER_MODE_MKDIR_0755) == 0);
 
        if (FLAGS_SET(m, SD_VARLINK_SERVER_MODE_MKDIR_0755) && path_is_absolute(address)) {
                r = mkdir_parents(address, 0755);
                if (r < 0)
                        return r;
        }
 
        r = sockaddr_un_set_path(&sockaddr.un, address);
        if (r < 0)
                return r;
        sockaddr_len = r;
 
        fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC|SOCK_NONBLOCK, 0);
        if (fd < 0)
                return -errno;
 
        fd = fd_move_above_stdio(fd);
 
        (void) mark_varlink_socket(fd, /* path= */ NULL, "listen");
 
        /* See the comment in sd_varlink_server_listen_fd() */
        if (FLAGS_SET(s->flags, SD_VARLINK_SERVER_FD_PASSING_INPUT_STRICT))
                (void) setsockopt_int(fd, SOL_SOCKET, SO_PASSRIGHTS, FLAGS_SET(s->flags, SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT));
 
        (void) sockaddr_un_unlink(&sockaddr.un);
 
        WITH_UMASK(~m & 0777)
                r = RET_NERRNO(bind(fd, &sockaddr.sa, sockaddr_len));
        if (r < 0)
                return r;
 
        if (path_is_absolute(address))
                (void) mark_varlink_socket(AT_FDCWD, address, "entrypoint");
 
        if (listen(fd, SOMAXCONN_DELUXE) < 0)
                return -errno;
 
        r = varlink_server_create_listen_fd_socket(s, fd, &ss);
        if (r < 0)
                return r;
 
        r = free_and_strdup(&ss->address, address);
        if (r < 0)
                return r;
 
        LIST_PREPEND(sockets, s->sockets, TAKE_PTR(ss));
        TAKE_FD(fd);
        return 0;
}
 
_public_ int sd_varlink_server_add_connection_stdio(sd_varlink_server *s, sd_varlink **ret) {
        _cleanup_close_ int input_fd = -EBADF, output_fd = -EBADF;
        int r;
 
        assert_return(s, -EINVAL);
 
        input_fd = fcntl(STDIN_FILENO, F_DUPFD_CLOEXEC, 3);
        if (input_fd < 0)
                return -errno;
 
        output_fd = fcntl(STDOUT_FILENO, F_DUPFD_CLOEXEC, 3);
        if (output_fd < 0)
                return -errno;
 
        r = rearrange_stdio(-EBADF, -EBADF, STDERR_FILENO);
        if (r < 0)
                return r;
 
        r = fd_nonblock(input_fd, true);
        if (r < 0)
                return r;
 
        r = fd_nonblock(output_fd, true);
        if (r < 0)
                return r;
 
        struct stat input_st;
        if (fstat(input_fd, &input_st) < 0)
                return -errno;
 
        struct stat output_st;
        if (fstat(output_fd, &output_st) < 0)
                return -errno;
 
        /* If stdin/stdout are both pipes and have the same owning uid/gid then let's synthesize a "struct
         * ucred" from the owning UID/GID, since we got them passed in with such ownership. We'll not fill in
         * the PID however, since there's no way to know which process created a pipe. */
        struct ucred ucred, *pucred;
        if (S_ISFIFO(input_st.st_mode) &&
            S_ISFIFO(output_st.st_mode) &&
            input_st.st_uid == output_st.st_uid &&
            input_st.st_gid == output_st.st_gid) {
                ucred = (struct ucred) {
                        .uid = input_st.st_uid,
                        .gid = input_st.st_gid,
                };
                pucred = &ucred;
        } else
                pucred = NULL;
 
        r = sd_varlink_server_add_connection_pair(s, input_fd, output_fd, pucred, ret);
        if (r < 0)
                return r;
 
        TAKE_FD(input_fd);
        TAKE_FD(output_fd);
 
        return 0;
}
 
_public_ int sd_varlink_server_listen_name(sd_varlink_server *s, const char *name) {
        _cleanup_strv_free_ char **names = NULL;
        int r, m, n = 0;
 
        assert_return(s, -EINVAL);
        assert_return(name, -EINVAL);
 
        /* Adds all passed fds marked as "name" to our varlink server. These fds can either refer to a
         * listening socket or to a connection socket.
         *
         * See https://uapi-group.org/specifications/specs/varlink/#socket-activation for the environment
         * variables this is backed by and the recommended "varlink" identifier in $LISTEN_FDNAMES. */
 
        m = sd_listen_fds_with_names(/* unset_environment= */ false, &names);
        if (m < 0)
                return m;
 
        for (int i = 0; i < m; i++) {
                int b, fd;
                socklen_t l = sizeof(b);
 
                if (!streq(names[i], name))
                        continue;
 
                fd = SD_LISTEN_FDS_START + i;
 
                if (getsockopt(fd, SOL_SOCKET, SO_ACCEPTCONN, &b, &l) < 0)
                        return -errno;
 
                assert(l == sizeof(b));
 
                if (b) /* Listening socket? */
                        r = sd_varlink_server_listen_fd(s, fd);
                else /* Otherwise assume connection socket */
                        r = sd_varlink_server_add_connection(s, fd, NULL);
                if (r < 0)
                        return r;
 
                n++;
        }
 
        return n;
}
 
_public_ int sd_varlink_server_listen_auto(sd_varlink_server *s) {
        int r, n;
 
        assert_return(s, -EINVAL);
 
        n = sd_varlink_server_listen_name(s, "varlink");
        if (n < 0)
                return n;
 
        /* Let's listen on an explicitly specified address */
        const char *e = secure_getenv("SYSTEMD_VARLINK_LISTEN");
        if (e) {
                if (streq(e, "-"))
                        r = sd_varlink_server_add_connection_stdio(s, /* ret= */ NULL);
                else
                        r = sd_varlink_server_listen_address(s, e, default_listen_mode(s->flags));
                if (r < 0)
                        return r;
 
                n++;
        }
 
        return n;
}
 
_public_ void* sd_varlink_server_set_userdata(sd_varlink_server *s, void *userdata) {
        void *ret;
 
        assert_return(s, NULL);
 
        ret = s->userdata;
        s->userdata = userdata;
 
        return ret;
}
 
_public_ void* sd_varlink_server_get_userdata(sd_varlink_server *s) {
        assert_return(s, NULL);
 
        return s->userdata;
}
 
_public_ int sd_varlink_server_loop_auto(sd_varlink_server *server) {
        _cleanup_(sd_event_unrefp) sd_event *event = NULL;
        int r;
 
        assert_return(server, -EINVAL);
        assert_return(!server->event, -EBUSY);
 
        /* Runs a sd_varlink service event loop populated with a passed fd. Exits on the last connection. */
 
        r = sd_event_new(&event);
        if (r < 0)
                return r;
 
        r = sd_varlink_server_set_exit_on_idle(server, true);
        if (r < 0)
                return r;
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_HANDLE_SIGINT)) {
                r = sd_event_add_signal(event, /* ret= */ NULL, SIGINT|SD_EVENT_SIGNAL_PROCMASK, /* callback= */ NULL, /* userdata= */ NULL);
                if (r < 0)
                        return r;
        }
 
        if (FLAGS_SET(server->flags, SD_VARLINK_SERVER_HANDLE_SIGTERM)) {
                r = sd_event_add_signal(event, /* ret= */ NULL, SIGTERM|SD_EVENT_SIGNAL_PROCMASK, /* callback= */ NULL, /* userdata= */ NULL);
                if (r < 0)
                        return r;
        }
 
        r = sd_varlink_server_attach_event(server, event, 0);
        if (r < 0)
                return r;
 
        r = sd_varlink_server_listen_auto(server);
        if (r < 0)
                return r;
 
        return sd_event_loop(event);
}
 
static VarlinkServerSocket* varlink_server_socket_destroy(VarlinkServerSocket *ss) {
        if (!ss)
                return NULL;
 
        if (ss->server)
                LIST_REMOVE(sockets, ss->server->sockets, ss);
 
        sd_event_source_disable_unref(ss->event_source);
 
        free(ss->address);
        safe_close(ss->fd);
 
        return mfree(ss);
}
 
_public_ int sd_varlink_server_shutdown(sd_varlink_server *s) {
        assert_return(s, -EINVAL);
 
        while (s->sockets)
                varlink_server_socket_destroy(s->sockets);
 
        return 0;
}
 
static void varlink_server_test_exit_on_idle(sd_varlink_server *s) {
        assert(s);
 
        if (s->exit_on_idle && s->event && s->n_connections == 0) {
                varlink_server_log(s, "Exit-on-idle triggered.");
                (void) sd_event_exit(s->event, 0);
        }
}
 
_public_ int sd_varlink_server_set_exit_on_idle(sd_varlink_server *s, int b) {
        assert_return(s, -EINVAL);
 
        s->exit_on_idle = b;
        varlink_server_test_exit_on_idle(s);
        return 0;
}
 
int varlink_server_add_socket_event_source(sd_varlink_server *s, VarlinkServerSocket *ss) {
        _cleanup_(sd_event_source_unrefp) sd_event_source *es = NULL;
        int r;
 
        assert(s);
        assert(s->event);
        assert(ss);
        assert(ss->server == s);
        assert(ss->fd >= 0);
        assert(!ss->event_source);
 
        r = sd_event_add_io(s->event, &es, ss->fd, EPOLLIN, connect_callback, ss);
        if (r < 0)
                return r;
 
        r = sd_event_source_set_priority(es, s->event_priority);
        if (r < 0)
                return r;
 
        ss->event_source = TAKE_PTR(es);
        return 0;
}
 
_public_ int sd_varlink_server_attach_event(sd_varlink_server *s, sd_event *e, int64_t priority) {
        int r;
 
        assert_return(s, -EINVAL);
        assert_return(!s->event, -EBUSY);
 
        if (e)
                s->event = sd_event_ref(e);
        else {
                r = sd_event_default(&s->event);
                if (r < 0)
                        return r;
        }
 
        s->event_priority = priority;
 
        LIST_FOREACH(sockets, ss, s->sockets) {
                r = varlink_server_add_socket_event_source(s, ss);
                if (r < 0)
                        goto fail;
        }
 
        return 0;
 
fail:
        sd_varlink_server_detach_event(s);
        return r;
}
 
_public_ int sd_varlink_server_detach_event(sd_varlink_server *s) {
        assert_return(s, -EINVAL);
 
        LIST_FOREACH(sockets, ss, s->sockets)
                ss->event_source = sd_event_source_disable_unref(ss->event_source);
 
        s->event = sd_event_unref(s->event);
        return 0;
}
 
_public_ sd_event* sd_varlink_server_get_event(sd_varlink_server *s) {
        assert_return(s, NULL);
 
        return s->event;
}
 
static bool varlink_symbol_in_interface(const char *method, const char *interface) {
        const char *p;
 
        assert(method);
        assert(interface);
 
        p = startswith(method, interface);
        if (!p)
                return false;
 
        if (*p != '.')
                return false;
 
        return !strchr(p+1, '.');
}
 
static int varlink_server_bind_internal(sd_varlink_server *s, Hashmap **methods, const char *method, sd_varlink_method_t callback) {
        _cleanup_free_ char *m = NULL;
        int r;
 
        assert(s);
        assert(methods);
        assert(method);
        assert(callback);
 
        if (varlink_symbol_in_interface(method, "org.varlink.service") ||