HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/sd-varlink.c
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") ||