From 92742f37c11d359848cee907f5125ce4f83f8b6e Mon Sep 17 00:00:00 2001 From: MaxsTechReview Date: Sun, 8 Nov 2026 18:40:57 -0500 Subject: [PATCH] fix(preload): answer netlink requests sent with write and writev (#2304) --- tools/linuxfs/preload/netif.c | 28 +++++++++++++ tools/tests/test_netlink_preload.py | 64 +++++++++++++++++++++++++++++ 2 files changed, 92 insertions(+) diff --git a/tools/linuxfs/preload/netif.c b/tools/linuxfs/preload/netif.c index d7f56e32ab..aeeeb9eb24 100644 --- a/tools/linuxfs/preload/netif.c +++ b/tools/linuxfs/preload/netif.c @@ -29,6 +29,7 @@ #include #include #include +#include #include #include #include @@ -1655,6 +1656,7 @@ static void reply_attr(struct nl_reply *out, unsigned char *message, int type, return; } attr = (struct rtattr *) (message + offset); + memset(attr, 0, total); attr->rta_type = (unsigned short) type; attr->rta_len = (unsigned short) RTA_LENGTH(len); if (len > 0) memcpy(RTA_DATA(attr), data, len); @@ -2155,3 +2157,29 @@ ssize_t send(int fd, const void *buffer, size_t length, int flags) { } return real(fd, buffer, length, flags); } + +ssize_t write(int fd, const void *buffer, size_t length) { + static ssize_t (*real)(int, const void *, size_t); + ssize_t rc; + if (bl_nl_owns(fd) && deliver(fd, buffer, length, 0, &rc)) return rc; + if (real == NULL) real = (ssize_t (*)(int, const void *, size_t)) dlsym(RTLD_NEXT, "write"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, buffer, length); +} + +ssize_t writev(int fd, const struct iovec *iov, int iovcnt) { + static ssize_t (*real)(int, const struct iovec *, int); + if (iovcnt >= 0 && bl_nl_owns(fd)) { + struct msghdr msg = { .msg_iov = (struct iovec *) iov, .msg_iovlen = (size_t) iovcnt }; + return sendmsg_request(fd, &msg, 0); + } + if (real == NULL) real = (ssize_t (*)(int, const struct iovec *, int)) dlsym(RTLD_NEXT, "writev"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, iov, iovcnt); +} diff --git a/tools/tests/test_netlink_preload.py b/tools/tests/test_netlink_preload.py index 64c3b9c97a..aedbdbd733 100644 --- a/tools/tests/test_netlink_preload.py +++ b/tools/tests/test_netlink_preload.py @@ -118,6 +118,7 @@ PROGRAM = r""" #include #include #include +#include #include #include @@ -317,6 +318,8 @@ static void *ordinary_traffic(void *argument) { probe_end(counts); require(counts[0] == 0, "ordinary setup avoids netlink lock"); + int pipes[2]; + require(pipe(pipes) == 0, "ordinary pipe setup"); probe_begin(0); const int rounds = 32; for (int round = 0; round < rounds; round++) { @@ -338,6 +341,15 @@ static void *ordinary_traffic(void *argument) { message.msg_name = &source; message.msg_namelen = sizeof(source); require(recvmsg(server, &message, 0) == 1 && buffer == 'z', "ordinary recvmsg"); + require(write(client, "w", 1) == 1, "ordinary write"); + require(read(server, &buffer, 1) == 1 && buffer == 'w', "ordinary read"); + char pair[2]; + struct iovec pieces[2] = {{.iov_base = "v", .iov_len = 1}, {.iov_base = "u", .iov_len = 1}}; + require(writev(client, pieces, 2) == 2, "ordinary writev"); + require(recv(server, pair, 2, MSG_WAITALL) == 2 && pair[0] == 'v' && pair[1] == 'u', + "ordinary writev data"); + require(write(pipes[1], "p", 1) == 1 && read(pipes[0], &buffer, 1) == 1 && buffer == 'p', + "ordinary pipe"); length = sizeof(source); require(getpeername(client, (struct sockaddr *)&source, &length) == 0, "ordinary peer"); const int options[] = {SO_TYPE, SO_DOMAIN, SO_PROTOCOL}; @@ -368,6 +380,8 @@ static void *ordinary_traffic(void *argument) { require(counts[2] == (unsigned)rounds, "ordinary traffic has only requested getpeername"); require(counts[3] == 0, "ordinary traffic avoids restoration fstat"); require(counts[4] == (unsigned)rounds * 3, "ordinary socket options use one syscall each"); + close(pipes[0]); + close(pipes[1]); close(client); close(server); if (server != listener) close(listener); @@ -798,6 +812,52 @@ static void connect_test(void) { close(descriptor); } +static ssize_t link_reply(int descriptor, const char *path, unsigned char *buffer, size_t capacity) { + struct { + struct nlmsghdr header; + struct ifinfomsg info; + } query = { + .header = {.nlmsg_len = sizeof(query), .nlmsg_type = RTM_GETLINK, + .nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK, .nlmsg_seq = 42}, + .info = {.ifi_index = 1} + }; + struct iovec parts[2] = {{.iov_base = &query.header, .iov_len = sizeof(query.header)}, + {.iov_base = &query.info, .iov_len = sizeof(query.info)}}; + struct msghdr message = {.msg_iov = parts, .msg_iovlen = 2}; + ssize_t sent; + if (!strcmp(path, "send")) sent = send(descriptor, &query, sizeof(query), 0); + else if (!strcmp(path, "sendmsg")) sent = sendmsg(descriptor, &message, 0); + else if (!strcmp(path, "write")) sent = write(descriptor, &query, sizeof(query)); + else sent = writev(descriptor, parts, 2); + require(sent == sizeof(query), path); + ssize_t received = read(descriptor, buffer, capacity); + require(received > 0, "read reply"); + return received; +} + +static void write_test(void) { + const char *paths[] = {"send", "sendmsg", "write", "writev"}; + unsigned char expected[4096]; + int descriptor = route_socket(); + ssize_t expected_length = link_reply(descriptor, paths[0], expected, sizeof(expected)); + struct nlmsghdr *header = (struct nlmsghdr *)expected; + require(header->nlmsg_type == RTM_NEWLINK && header->nlmsg_seq == 42 + && header->nlmsg_pid == port_of(descriptor), "send reply"); + require(expected_length > (ssize_t)NLMSG_ALIGN(header->nlmsg_len), "acknowledged reply"); + struct nlmsghdr *acknowledgement = (struct nlmsghdr *)(expected + NLMSG_ALIGN(header->nlmsg_len)); + require(acknowledgement->nlmsg_type == NLMSG_ERROR + && ((struct nlmsgerr *)NLMSG_DATA(acknowledgement))->error == 0, "send acknowledgement"); + for (size_t index = 1; index < sizeof(paths) / sizeof(paths[0]); index++) { + unsigned char buffer[4096]; + ssize_t length = link_reply(descriptor, paths[index], buffer, sizeof(buffer)); + require(length == expected_length, "reply length"); + require(!memcmp(buffer, expected, length), "reply bytes"); + } + require(recv(descriptor, expected, sizeof(expected), MSG_DONTWAIT) == -1 && errno == EAGAIN, + "no extra replies"); + close(descriptor); +} + static void receive_test(void) { int descriptor = route_socket(); send_link(descriptor, 1, 0); @@ -985,6 +1045,7 @@ int main(int argc, char **argv) { else if (!strcmp(argv[1], "nonblocking")) send_timeout_test(1); else if (!strcmp(argv[1], "connect")) connect_test(); else if (!strcmp(argv[1], "receive")) receive_test(); + else if (!strcmp(argv[1], "write")) write_test(); else if (!strcmp(argv[1], "replace")) replacement_test(0); else if (!strcmp(argv[1], "raw_replace")) replacement_test(1); else if (!strcmp(argv[1], "shared")) shared_test(0); @@ -1160,6 +1221,9 @@ class NetlinkPreloadTest(unittest.TestCase): def test_kernel_connect_and_disconnect(self): self.run_program("connect") + def test_write_and_writev_requests_get_the_same_replies_as_send(self): + self.run_program("write") + def test_receive_sources_and_truncation(self): self.run_program("receive")