HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/libsystemd/sd-varlink/test-varlink.c
Git blob: 169a5f372b1455dddd234535c54e2a67d852519b
Lines 1001–1728 of 1,728
sd_event_source *source;
ASSERT_OK(sd_event_add_defer(sd_varlink_get_event(link), &source, fiber_stashed_deferred_reply, sd_varlink_ref(link)));
ASSERT_OK(sd_event_source_set_enabled(source, SD_EVENT_ONESHOT));
return 0;
}
static int reply_fiber_stash(sd_varlink *link, sd_json_variant *parameters, const char *error_id, sd_varlink_reply_flags_t flags, void *userdata) {
ASSERT_NULL(error_id);
ASSERT_STREQ(sd_json_variant_string(sd_json_variant_by_key(parameters, "result")), "stashed");
ASSERT_OK(sd_event_exit(sd_varlink_get_event(link), EXIT_SUCCESS));
return 0;
}
TEST(fiber_stash) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_default(&e));
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
ASSERT_OK(sd_varlink_server_new(&s, 0));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(varlink_server_bind_fiber(s, "io.test.FiberStash", method_fiber_stash));
int connfd[2];
ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, connfd));
ASSERT_OK(sd_varlink_server_add_connection(s, connfd[0], /* ret= */ NULL));
_cleanup_(sd_varlink_unrefp) sd_varlink *c = NULL;
ASSERT_OK(sd_varlink_connect_fd(&c, connfd[1]));
ASSERT_OK(sd_varlink_attach_event(c, e, 0));
ASSERT_OK(sd_varlink_bind_reply(c, reply_fiber_stash));
ASSERT_OK(sd_varlink_invoke(c, "io.test.FiberStash", /* parameters= */ NULL));
ASSERT_OK(sd_event_loop(e));
}
static int method_with_fd_sentinel(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_close_ int fd1 = -EBADF, fd2 = -EBADF;
ASSERT_TRUE(FLAGS_SET(flags, SD_VARLINK_METHOD_MORE));
/* Set a sentinel so sd_varlink_reply() defers sending: each reply and its pushed fds are captured in
* the queue, and the last one is sent as the final reply when the callback returns. */
ASSERT_OK(sd_varlink_set_sentinel(link, /* error_id= */ NULL));
/* First reply: push one fd with "alpha" content */
ASSERT_OK(fd1 = memfd_new_and_seal_string("data", "alpha"));
ASSERT_OK_EQ(sd_varlink_push_fd(link, fd1), 0);
TAKE_FD(fd1);
ASSERT_OK(sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_INTEGER("index", 0)));
/* Second reply: push one fd with "beta" content */
ASSERT_OK(fd2 = memfd_new_and_seal_string("data", "beta"));
ASSERT_OK_EQ(sd_varlink_push_fd(link, fd2), 0);
TAKE_FD(fd2);
ASSERT_OK(sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_INTEGER("index", 1)));
return 0;
}
static int reply_sentinel_fd(sd_varlink *link, sd_json_variant *parameters, const char *error_id, sd_varlink_reply_flags_t flags, void *userdata) {
int *state = ASSERT_PTR(sd_varlink_get_userdata(link));
if (*state == 0) {
/* First reply: should carry "continues" flag and fd with "alpha" */
ASSERT_NULL(error_id);
ASSERT_TRUE(FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES));
ASSERT_EQ(sd_json_variant_integer(sd_json_variant_by_key(parameters, "index")), 0);
int fd;
ASSERT_OK(fd = sd_varlink_peek_fd(link, 0));
test_fd(fd, "alpha", STRLEN("alpha"));
(*state)++;
} else if (*state == 1) {
/* Second (final) reply: no "continues" flag, fd with "beta" */
ASSERT_NULL(error_id);
ASSERT_FALSE(FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES));
ASSERT_EQ(sd_json_variant_integer(sd_json_variant_by_key(parameters, "index")), 1);
int fd;
ASSERT_OK(fd = sd_varlink_peek_fd(link, 0));
test_fd(fd, "beta", STRLEN("beta"));
ASSERT_OK(sd_event_exit(sd_varlink_get_event(link), EXIT_SUCCESS));
} else
assert_not_reached();
return 0;
}
TEST(sentinel_with_fds) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_default(&e));
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT|SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.FDSentinel", method_with_fd_sentinel));
int connfd[2];
ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, connfd));
ASSERT_OK(sd_varlink_server_add_connection(s, connfd[0], /* ret= */ NULL));
_cleanup_(sd_varlink_unrefp) sd_varlink *c = NULL;
ASSERT_OK(sd_varlink_connect_fd(&c, connfd[1]));
ASSERT_OK(sd_varlink_set_allow_fd_passing_input(c, true));
ASSERT_OK(sd_varlink_set_allow_fd_passing_output(c, true));
ASSERT_OK(sd_varlink_attach_event(c, e, 0));
int state = 0;
sd_varlink_set_userdata(c, &state);
ASSERT_OK(sd_varlink_bind_reply(c, reply_sentinel_fd));
ASSERT_OK(sd_varlink_observe(c, "io.test.FDSentinel", /* parameters= */ NULL));
ASSERT_OK(sd_event_loop(e));
}
static int method_with_notify_then_error(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
/* Send a notify first, then return an error. The notify should be received before the error. */
ASSERT_OK(sd_varlink_notifybo(link, SD_JSON_BUILD_PAIR_STRING("status", "in-progress")));
return sd_varlink_error(link, "io.test.OperationFailed", /* parameters= */ NULL);
}
static int reply_notify_then_error(sd_varlink *link, sd_json_variant *parameters, const char *error_id, sd_varlink_reply_flags_t flags, void *userdata) {
int *state = ASSERT_PTR(sd_varlink_get_userdata(link));
if (*state == 0) {
/* First callback: should be the notify (no error, has "more" flag) */
ASSERT_NULL(error_id);
ASSERT_TRUE(FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES));
ASSERT_STREQ(sd_json_variant_string(sd_json_variant_by_key(parameters, "status")), "in-progress");
(*state)++;
} else if (*state == 1) {
/* Second callback: should be the error */
ASSERT_STREQ(error_id, "io.test.OperationFailed");
ASSERT_FALSE(FLAGS_SET(flags, SD_VARLINK_REPLY_CONTINUES));
ASSERT_OK(sd_event_exit(sd_varlink_get_event(link), EXIT_SUCCESS));
} else
assert_not_reached();
return 0;
}
TEST(notify_then_error) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_new(&e));
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
ASSERT_OK(sd_varlink_server_new(&s, 0));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.NotifyThenError", method_with_notify_then_error));
int connfd[2];
ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, connfd));
ASSERT_OK(sd_varlink_server_add_connection(s, connfd[0], /* ret= */ NULL));
_cleanup_(sd_varlink_unrefp) sd_varlink *c = NULL;
ASSERT_OK(sd_varlink_connect_fd(&c, connfd[1]));
ASSERT_OK(sd_varlink_attach_event(c, e, 0));
int state = 0;
sd_varlink_set_userdata(c, &state);
ASSERT_OK(sd_varlink_bind_reply(c, reply_notify_then_error));
ASSERT_OK(sd_varlink_observe(c, "io.test.NotifyThenError", /* parameters= */ NULL));
ASSERT_OK(sd_event_loop(e));
}
static int method_upgrade(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
_cleanup_close_ int input_fd = -EBADF, output_fd = -EBADF;
int r;
ASSERT_TRUE(FLAGS_SET(flags, SD_VARLINK_METHOD_UPGRADE));
r = sd_varlink_reply_and_upgrade(link, /* parameters= */ NULL, &input_fd, &output_fd);
if (r < 0)
return r;
/* After upgrade, do raw I/O: read until the client shuts down its write side (giving us a clean
* EOF), reverse what we got, and write it back. Use suspending I/O so other fibers (the client)
* can make progress while we're waiting on the socket. */
char buf[64] = {};
ssize_t n = ASSERT_OK(loop_read(input_fd, buf, sizeof(buf) - 1, /* do_poll= */ true));
ASSERT_GT(n, 0);
/* Reverse the received bytes */
for (ssize_t i = 0; i < n / 2; i++)
SWAP_TWO(buf[i], buf[n - 1 - i]);
ASSERT_OK(loop_write(output_fd, buf, n));
return 0;
}
static int method_upgrade_without_flag(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
int input_fd = -EBADF, output_fd = -EBADF;
/* Calling reply_and_upgrade without the client requesting it should fail with -EPROTO */
ASSERT_ERROR(sd_varlink_reply_and_upgrade(link, /* parameters= */ NULL, &input_fd, &output_fd), EPROTO);
return sd_varlink_reply(link, /* parameters= */ NULL);
}
static int upgrade_client_fiber(void *arg) {
_cleanup_(sd_varlink_flush_close_unrefp) sd_varlink *c = NULL;
_cleanup_close_ int input_fd = -EBADF, output_fd = -EBADF;
sd_json_variant *o = NULL;
const char *error_id = NULL;
ASSERT_OK(sd_varlink_connect_address(&c, arg));
ASSERT_OK(sd_varlink_set_description(c, "upgrade-client"));
ASSERT_OK(sd_varlink_call_and_upgrade(c, "io.test.Upgrade", /* parameters= */ NULL, &o, &error_id, &input_fd, &output_fd));
ASSERT_NULL(error_id);
ASSERT_GE(input_fd, 0);
ASSERT_GE(output_fd, 0);
ASSERT_NE(input_fd, output_fd); /* library dups for bidirectional sockets */
/* Send a test string, shut down write side so server sees EOF, then read the reversed reply */
static const char msg[] = "Hello!";
ASSERT_OK(loop_write(output_fd, msg, strlen(msg)));
ASSERT_OK_ERRNO(shutdown(output_fd, SHUT_WR));
char buf[64] = {};
ssize_t n = ASSERT_OK(loop_read(input_fd, buf, strlen(msg), /* do_poll= */ true));
ASSERT_EQ((size_t) n, strlen(msg));
ASSERT_STREQ(buf, "!olleH");
/* Also test that a regular call (without upgrade flag) correctly rejects reply_and_upgrade on
* the server side, and still works as a normal call */
_cleanup_(sd_varlink_flush_close_unrefp) sd_varlink *c2 = NULL;
ASSERT_OK(sd_varlink_connect_address(&c2, arg));
ASSERT_OK(sd_varlink_set_description(c2, "no-upgrade-client"));
ASSERT_OK(sd_varlink_call(c2, "io.test.UpgradeWithoutFlag", /* parameters= */ NULL, &o, &error_id));
ASSERT_NULL(error_id);
ASSERT_OK(sd_event_exit(sd_fiber_get_event(), EXIT_SUCCESS));
return 0;
}
TEST(upgrade) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_future_unrefp) sd_future *f = NULL;
const char *sp;
ASSERT_OK(mkdtemp_malloc("/tmp/varlink-test-XXXXXX", &tmpdir));
sp = strjoina(tmpdir, "/socket");
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_UPGRADABLE));
ASSERT_OK(sd_varlink_server_set_description(s, "upgrade-server"));
/* The method does raw I/O on the upgraded socket — bind it as a fiber method so it can
* suspend on loop_read()/loop_write() and the client fiber can make progress concurrently. */
ASSERT_OK(varlink_server_bind_fiber(s, "io.test.Upgrade", method_upgrade));
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.UpgradeWithoutFlag", method_upgrade_without_flag));
ASSERT_OK(sd_varlink_server_listen_address(s, sp, 0600));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_fiber_new(e, "upgrade-client", upgrade_client_fiber, (void*) sp, /* destroy= */ NULL, &f));
/* Run the event loop. Exits on idle once the client fiber completes and all server connections
* have been torn down. */
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(f));
}
static int upgrade_pipelining_client_fiber(void *arg) {
union sockaddr_union sa = {};
_cleanup_close_ int fd = -EBADF;
/* Connect a raw socket and pipeline: upgrade JSON + \0 + raw data in a single write.
* This tests that the server's byte-by-byte reading (SD_VARLINK_SERVER_UPGRADABLE)
* doesn't consume the raw data into the varlink input buffer. */
fd = socket(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0);
ASSERT_FD(fd);
int addrlen = sockaddr_un_set_path(&sa.un, arg);
ASSERT_OK(addrlen);
ASSERT_OK_ERRNO(connect(fd, &sa.sa, addrlen));
/* Build pipelined message: upgrade JSON + \0 + raw payload, all in one write */
static const char upgrade_msg[] = "{\"method\":\"io.test.Upgrade\",\"upgrade\":true}";
static const char raw_payload[] = "Pipelined!";
char send_buf[sizeof(upgrade_msg) + sizeof(raw_payload)]; /* includes \0 from upgrade_msg as delimiter */
memcpy(send_buf, upgrade_msg, sizeof(upgrade_msg)); /* copies trailing \0 = varlink delimiter */
memcpy(send_buf + sizeof(upgrade_msg), raw_payload, sizeof(raw_payload) - 1);
size_t total = sizeof(upgrade_msg) + strlen(raw_payload);
ASSERT_OK(loop_write(fd, send_buf, total));
/* Shut down write side so server's method_upgrade sees EOF after raw payload */
ASSERT_OK_ERRNO(shutdown(fd, SHUT_WR));
/* Read everything: upgrade reply (JSON + \0) + reversed raw payload. The server closes the
* connection after writing, so loop_read() reads until EOF and gets it all. */
char buf[256] = {};
ssize_t n = ASSERT_OK(loop_read(fd, buf, sizeof(buf) - 1, /* do_poll= */ true));
ASSERT_GT(n, 0);
/* Split at the \0 delimiter between JSON reply and raw payload */
char *delim = memchr(buf, 0, n);
ASSERT_NOT_NULL(delim);
char *raw = delim + 1;
size_t raw_size = (size_t) n - (size_t)(raw - buf);
ASSERT_EQ(raw_size, strlen(raw_payload));
ASSERT_STREQ(strndupa_safe(raw, raw_size), "!denilepiP");
ASSERT_OK(sd_event_exit(sd_fiber_get_event(), EXIT_SUCCESS));
return 0;
}
TEST(upgrade_pipelining) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_future_unrefp) sd_future *f = NULL;
const char *sp;
ASSERT_OK(mkdtemp_malloc("/tmp/varlink-test-XXXXXX", &tmpdir));
sp = strjoina(tmpdir, "/socket");
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_UPGRADABLE));
ASSERT_OK(sd_varlink_server_set_description(s, "upgrade-pipelining-server"));
/* method_upgrade does raw I/O on the upgraded socket, so bind as a fiber method. */
ASSERT_OK(varlink_server_bind_fiber(s, "io.test.Upgrade", method_upgrade));
ASSERT_OK(sd_varlink_server_listen_address(s, sp, 0600));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_fiber_new(e, "upgrade-pipelining-client", upgrade_pipelining_client_fiber, (void*) sp, /* destroy= */ NULL, &f));
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(f));
}
/* Stashes the fds handed to the asynchronous upgrade callback so the raw-I/O fiber can pick them up.
* A single connection is upgraded per test run, so globals are sufficient. */
static int respond_upgrade_input_fd = -EBADF;
static int respond_upgrade_output_fd = -EBADF;
static int respond_upgrade_io_fiber(void *arg) {
_cleanup_close_ int input_fd = TAKE_FD(respond_upgrade_input_fd), output_fd = TAKE_FD(respond_upgrade_output_fd);
/* Same reverse-echo raw protocol as method_upgrade(), but reached through the asynchronous
* upgrade callback instead of a synchronous fiber method: read until the client shuts down its
* write side, reverse the bytes, and write them back. */
char buf[64] = {};
ssize_t n = ASSERT_OK(loop_read(input_fd, buf, sizeof(buf) - 1, /* do_poll= */ true));
ASSERT_GT(n, 0);
for (ssize_t i = 0; i < n / 2; i++)
SWAP_TWO(buf[i], buf[n - 1 - i]);
ASSERT_OK(loop_write(output_fd, buf, n));
return 0;
}
static int respond_upgrade_callback(sd_varlink *link, int input_fd, int output_fd, void *userdata) {
sd_event *e = ASSERT_PTR(userdata);
/* The upgrade callback is invoked from sd_varlink_process() in the main event loop (not a
* fiber), so it must not block on raw I/O. Hand the connection's fds to a floating fiber that
* speaks the raw protocol, allowing the client fiber to make progress concurrently. Ownership of
* the fds is transferred to us regardless of what happens next, so stash them before spawning. */
respond_upgrade_input_fd = input_fd;
respond_upgrade_output_fd = output_fd;
ASSERT_OK(sd_fiber_new(e, "respond-upgrade-io", respond_upgrade_io_fiber, /* userdata= */ NULL, /* destroy= */ NULL, /* ret= */ NULL));
return 0;
}
static int method_respond_upgrade(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
int r;
ASSERT_TRUE(FLAGS_SET(flags, SD_VARLINK_METHOD_UPGRADE));
/* Register the async upgrade callback, then enqueue the final reply. Unlike
* sd_varlink_reply_and_upgrade(), sd_varlink_respond_and_upgradebo() returns immediately without
* blocking: the reply is flushed by the event loop and the fds are subsequently handed to
* respond_upgrade_callback(). This is why the method may be bound as a regular (non-fiber) method. */
ASSERT_OK(sd_varlink_bind_upgrade(link, respond_upgrade_callback));
r = sd_varlink_respond_and_upgradebo(
link,
SD_JSON_BUILD_PAIR_STRING("greeting", "aloha"));
if (r < 0)
return r;
return 0;
}
static int respond_upgrade_client_fiber(void *arg) {
_cleanup_(sd_varlink_flush_close_unrefp) sd_varlink *c = NULL;
_cleanup_close_ int input_fd = -EBADF, output_fd = -EBADF;
sd_json_variant *o = NULL;
const char *error_id = NULL;
ASSERT_OK(sd_varlink_connect_address(&c, arg));
ASSERT_OK(sd_varlink_set_description(c, "respond-upgrade-client"));
ASSERT_OK(sd_varlink_call_and_upgrade(c, "io.test.RespondUpgrade", /* parameters= */ NULL, &o, &error_id, &input_fd, &output_fd));
ASSERT_NULL(error_id);
/* The reply parameters enqueued asynchronously by the server must have arrived intact. */
ASSERT_STREQ(sd_json_variant_string(sd_json_variant_by_key(o, "greeting")), "aloha");
ASSERT_GE(input_fd, 0);
ASSERT_GE(output_fd, 0);
ASSERT_NE(input_fd, output_fd); /* library dups for bidirectional sockets */
/* Send a test string, shut down write side so the server sees EOF, then read the reversed reply */
static const char msg[] = "Hello!";
ASSERT_OK(loop_write(output_fd, msg, strlen(msg)));
ASSERT_OK_ERRNO(shutdown(output_fd, SHUT_WR));
char buf[64] = {};
ssize_t n = ASSERT_OK(loop_read(input_fd, buf, strlen(msg), /* do_poll= */ true));
ASSERT_EQ((size_t) n, strlen(msg));
ASSERT_STREQ(buf, "!olleH");
ASSERT_OK(sd_event_exit(sd_fiber_get_event(), EXIT_SUCCESS));
return 0;
}
TEST(respond_upgrade) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_future_unrefp) sd_future *f = NULL;
const char *sp;
ASSERT_OK(mkdtemp_malloc("/tmp/varlink-test-XXXXXX", &tmpdir));
sp = strjoina(tmpdir, "/socket");
ASSERT_OK(sd_event_new(&e));
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_UPGRADABLE|SD_VARLINK_SERVER_INHERIT_USERDATA));
ASSERT_OK(sd_varlink_server_set_description(s, "respond-upgrade-server"));
/* The event loop is propagated to the async upgrade callback via the connection userdata (inherited
* from the server) so the callback can spawn the raw-I/O fiber. */
sd_varlink_server_set_userdata(s, e);
/* Unlike TEST(upgrade), this is a *regular* (non-fiber) method: it drives the asynchronous
* sd_varlink_respond_and_upgradebo() API, which never blocks the event loop on a single client. */
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.RespondUpgrade", method_respond_upgrade));
ASSERT_OK(sd_varlink_server_listen_address(s, sp, 0600));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_fiber_new(e, "respond-upgrade-client", respond_upgrade_client_fiber, (void*) sp, /* destroy= */ NULL, &f));
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(f));
}
typedef struct ExecDirServer {
sd_varlink_server *server;
const char *name;
} ExecDirServer;
static int method_execute_dir_ping(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
ExecDirServer *srv = ASSERT_PTR(userdata);
return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_STRING("name", srv->name));
}
static int execute_dir_reply(sd_varlink *link, sd_json_variant *parameters, const char *error_id, sd_varlink_reply_flags_t flags, void *userdata) {
size_t *count = ASSERT_PTR(userdata);
ASSERT_NULL(error_id);
ASSERT_NOT_NULL(sd_json_variant_by_key(parameters, "name"));
(*count)++;
return 0;
}
typedef struct ExecDirClientArgs {
const char *tmpdir;
size_t n_servers;
size_t *reply_count;
} ExecDirClientArgs;
static int execute_dir_client_fiber(void *arg) {
ExecDirClientArgs *a = ASSERT_PTR(arg);
ASSERT_OK_EQ(varlink_execute_directory(
a->tmpdir,
"io.test.ExecDirPing",
/* parameters= */ NULL,
/* more= */ false,
/* timeout_usec= */ USEC_INFINITY,
execute_dir_reply,
a->reply_count), (ssize_t) a->n_servers);
ASSERT_EQ(*a->reply_count, a->n_servers);
/* Calling the helper against a non-existent directory must fail. */
_cleanup_free_ char *nope = NULL;
ASSERT_OK(asprintf(&nope, "%s/does-not-exist", a->tmpdir));
ASSERT_FAIL(varlink_execute_directory(
nope,
"io.test.ExecDirPing",
/* parameters= */ NULL,
/* more= */ false,
/* timeout_usec= */ USEC_INFINITY,
execute_dir_reply,
a->reply_count));
/* An empty directory must simply return 0 and not invoke the reply callback. */
_cleanup_free_ char *empty = ASSERT_PTR(path_join(a->tmpdir, "empty"));
ASSERT_OK_ERRNO(mkdir(empty, 0755));
size_t count_before = *a->reply_count;
ASSERT_OK_ZERO(varlink_execute_directory(
empty,
"io.test.ExecDirPing",
/* parameters= */ NULL,
/* more= */ false,
/* timeout_usec= */ USEC_INFINITY,
execute_dir_reply,
a->reply_count));
ASSERT_EQ(*a->reply_count, count_before);
ASSERT_OK(sd_event_exit(sd_fiber_get_event(), EXIT_SUCCESS));
return 0;
}
TEST(execute_directory) {
_cleanup_(rm_rf_physical_and_freep) char *tmpdir = NULL;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_future_unrefp) sd_future *f = NULL;
static const char * const names[] = { "alpha", "beta", "gamma" };
ExecDirServer servers[ELEMENTSOF(names)] = {};
size_t reply_count = 0;
ASSERT_OK(mkdtemp_malloc("/tmp/varlink-execdir-XXXXXX", &tmpdir));
ASSERT_OK(sd_event_new(&e));
for (size_t i = 0; i < ELEMENTSOF(names); i++) {
ExecDirServer *eds = servers + i;
servers[i].name = names[i];
_cleanup_free_ char *j = ASSERT_PTR(path_join(tmpdir, names[i]));
ASSERT_OK(varlink_server_new(&eds->server,
SD_VARLINK_SERVER_INHERIT_USERDATA,
eds));
ASSERT_OK(sd_varlink_server_bind_method(eds->server, "io.test.ExecDirPing", method_execute_dir_ping));
ASSERT_OK(sd_varlink_server_listen_address(eds->server, j, 0600));
ASSERT_OK(sd_varlink_server_attach_event(eds->server, e, 0));
}
ExecDirClientArgs args = {
.tmpdir = tmpdir,
.n_servers = ELEMENTSOF(names),
.reply_count = &reply_count,
};
ASSERT_OK(sd_fiber_new(e, "execute-dir-client", execute_dir_client_fiber, &args, NULL, &f));
ASSERT_OK(sd_event_loop(e));
ASSERT_OK(sd_future_result(f));
FOREACH_ELEMENT(eds, servers)
eds->server = sd_varlink_server_unref(eds->server);
}
#define CTRUNC_N_FDS 64U
static int method_ctrunc(sd_varlink *link, sd_json_variant *parameters, sd_varlink_method_flags_t flags, void *userdata) {
/* Peek the first fd the client supposedly sent. With SCM_RIGHTS truncated by the kernel
* because the receiver hit RLIMIT_NOFILE, sd_varlink_peek_fd() returns -ENXIO once we
* walk past the last successfully installed fd. We're forcing the missing-fd case here,
* so we expect to fail and let varlink translate -ENXIO into io.systemd.System for the
* peer. */
int fd = sd_varlink_peek_fd(link, CTRUNC_N_FDS - 1);
if (fd < 0)
return fd;
return sd_varlink_replybo(link, SD_JSON_BUILD_PAIR_INTEGER("ok", 1));
}
static int reply_ctrunc(sd_varlink *link, sd_json_variant *parameters, const char *error_id, sd_varlink_reply_flags_t flags, void *userdata) {
/* We expect a clean system error back rather than a hanging connection: the server
* dropped the truncated fds and our handler surfaced -ENXIO, which varlink wraps as
* io.systemd.System. */
ASSERT_STREQ(error_id, SD_VARLINK_ERROR_SYSTEM);
ASSERT_ERROR(sd_varlink_error_to_errno(error_id, parameters), ENXIO);
ASSERT_OK(sd_event_exit(sd_varlink_get_event(link), EXIT_SUCCESS));
return 0;
}
TEST(ctrunc) {
int r;
_cleanup_(sd_event_unrefp) sd_event *e = NULL;
ASSERT_OK(sd_event_default(&e));
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_ALLOW_FD_PASSING_INPUT|SD_VARLINK_SERVER_ALLOW_FD_PASSING_OUTPUT));
ASSERT_OK(sd_varlink_server_attach_event(s, e, 0));
ASSERT_OK(sd_varlink_server_bind_method(s, "io.test.CTrunc", method_ctrunc));
int connfd[2];
ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM|SOCK_NONBLOCK|SOCK_CLOEXEC, 0, connfd));
ASSERT_OK(sd_varlink_server_add_connection(s, connfd[0], /* ret= */ NULL));
_cleanup_(sd_varlink_unrefp) sd_varlink *c = NULL;
ASSERT_OK(sd_varlink_connect_fd(&c, connfd[1]));
ASSERT_OK(sd_varlink_set_allow_fd_passing_input(c, true));
ASSERT_OK(sd_varlink_set_allow_fd_passing_output(c, true));
ASSERT_OK(sd_varlink_attach_event(c, e, 0));
ASSERT_OK(sd_varlink_bind_reply(c, reply_ctrunc));
/* Open a batch of memfds we'll attach to the call. We push duplicates so the originals
* keep occupying fd table slots after the stream sends and closes the dup'd copies,
* making the receiver hit RLIMIT_NOFILE when it tries to install the incoming fds. */
int originals[CTRUNC_N_FDS];
for (size_t i = 0; i < CTRUNC_N_FDS; i++)
originals[i] = -EBADF;
CLEANUP_ELEMENTS(originals, close_many_unset);
for (size_t i = 0; i < CTRUNC_N_FDS; i++) {
originals[i] = ASSERT_OK(memfd_new_and_seal_string("ctrunc", "x"));
ASSERT_OK_EQ(sd_varlink_push_dup_fd(c, originals[i]), (int) i);
}
/* Constrain RLIMIT_NOFILE so the server can't install every received fd. The kernel
* will then drop the remaining fds from the SCM_RIGHTS message and set MSG_CTRUNC,
* which is precisely what an LSM denial (or a real fd-table-full peer) looks like to
* the receive side. Pick the new limit slightly above our current open-fd count so
* the kernel can install only a handful of received fds before failing the rest. */
struct rlimit orig_rl;
ASSERT_OK_ERRNO(getrlimit(RLIMIT_NOFILE, &orig_rl));
size_t n_open = 0;
_cleanup_closedir_ DIR *d = ASSERT_NOT_NULL(opendir("/proc/self/fd"));
FOREACH_DIRENT_ALL(de, d, break)
if (!dot_or_dot_dot(de->d_name))
n_open++;
/* n_open currently includes the CTRUNC_N_FDS dup'd fds that the stream will close once
* the message has been sent. After the send, we'll be back down to n_open - CTRUNC_N_FDS
* fds. Set the limit just slightly above that, so the kernel can install only a handful
* of the CTRUNC_N_FDS incoming fds before failing the rest with MSG_CTRUNC. */
ASSERT_GT(n_open, CTRUNC_N_FDS);
struct rlimit new_rl = {
.rlim_cur = n_open - CTRUNC_N_FDS + 8,
.rlim_max = orig_rl.rlim_max,
};
ASSERT_OK_ERRNO(setrlimit(RLIMIT_NOFILE, &new_rl));
r = sd_varlink_invoke(c, "io.test.CTrunc", /* parameters= */ NULL);
if (r >= 0)
r = sd_event_loop(e);
ASSERT_OK_ERRNO(setrlimit(RLIMIT_NOFILE, &orig_rl));
ASSERT_OK(r);
}
static void disconnect_callback(sd_varlink_server *server, sd_varlink *link, void *userdata) {
unsigned *counter = ASSERT_PTR(userdata);
(*counter)++;
}
TEST(add_connection_failure_cleanup) {
_cleanup_(sd_varlink_server_unrefp) sd_varlink_server *s = NULL;
_cleanup_close_pair_ int fds[2] = EBADF_PAIR;
const struct ucred ucred = {
.pid = getpid(),
.uid = getuid(),
.gid = getgid(),
};
ASSERT_OK(sd_varlink_server_new(&s, SD_VARLINK_SERVER_ACCOUNT_UID));
unsigned c = 0;
ASSERT_OK(sd_varlink_server_bind_disconnect(s, disconnect_callback));
ASSERT_NULL(sd_varlink_server_set_userdata(s, &c));
ASSERT_OK(sd_varlink_server_set_connections_per_uid_max(s, 1));
ASSERT_OK_ERRNO(socketpair(AF_UNIX, SOCK_STREAM|SOCK_CLOEXEC, 0, fds));
int bad_fd = ASSERT_OK(memfd_new("closed-fd"));
ASSERT_OK_ERRNO(close(bad_fd));
ASSERT_ERROR(sd_varlink_server_add_connection_pair(s, fds[0], bad_fd, &ucred, /* ret= */ NULL), EBADF);
ASSERT_EQ(sd_varlink_server_current_connections(s), 0U);
ASSERT_EQ(c, 0U); /* The disconnect callback is not called. */
sd_varlink *v = NULL;
ASSERT_OK(sd_varlink_server_add_connection(s, fds[0], &v));
TAKE_FD(fds[0]);
ASSERT_NOT_NULL(v);
ASSERT_EQ(sd_varlink_server_current_connections(s), 1U);
ASSERT_EQ(c, 0U); /* The disconnect callback is not called yet. */
ASSERT_OK_POSITIVE(sd_varlink_close(v));
ASSERT_EQ(sd_varlink_server_current_connections(s), 0U);
ASSERT_EQ(c, 1U); /* The disconnect callback is called when the connection is closed. */
}
DEFINE_TEST_MAIN(LOG_DEBUG);