From 6a5722c6d1d8b761204cc8f041e7e82c492a4137 Mon Sep 17 00:00:00 2001 From: Kurt Himebauch <136133082+xXJSONDeruloXx@users.noreply.github.com> Date: Thu, 5 Nov 2026 18:27:08 -0500 Subject: [PATCH] fix(preload): answer NETLINK_ROUTE queries inside a session (#2141) * fix(preload): answer NETLINK_ROUTE queries inside a session ip(8) could not run in a session: the app's SELinux domain has no netlink_route_socket bind permission, so iproute2 failed at bind and never saw the link that getifaddrs() and /proc/net already expose. Serve NETLINK_ROUTE from the same etc/droiddeck-net snapshot: an AF_UNIX socketpair backs the netlink fd, link/addr/route dumps and route get are synthesised, writes return EPERM, and multicast subscriptions keep failing with EACCES so consumers that wait for link events keep their fallback. Replies carry the port id reported by getsockname() and recvmsg() rewrites the source address to AF_NETLINK/pid 0. iproute2's dump loop requires both before it accepts a message or NLMSG_DONE; when either is missing every message is skipped silently and the process blocks in recvmsg(). * fix(preload): keep socket() and send() semantics for emulated netlink * fix(preload): deliver netlink replies with the caller's blocking mode * fix(preload): preserve NETLINK_ROUTE protocol and fd semantics - Send ACKs for successful queries and honor NETLINK_CAP_ACK - Reject unsupported subscriptions and apply socket timeouts - Track socket identity and shared references across dup and close - Support kernel connect and rewrite recvfrom source addresses - Resolve local and connected routes before default gateways - Add netlink and iproute2 regression tests * fix(preload): handle netlink request limits and socket lifecycle - Collect large sendmsg requests without falling back to UNIX sockets - Reject oversized replies explicitly instead of returning partial results - Allocate unique port IDs and reject duplicate bindings - Honor socket flags and restore inherited sockets across exec - Validate socket types and report netlink socket identity - Replace the fixed socket table with a dynamic registry - Add regression tests for batching, port conflicts and exec inheritance * fix(preload): optimize netlink tracking and support link name queries - Add lock-free fd tracking to bypass netlink locks on ordinary sockets - Move descriptor restoration to initialization and explicit discovery paths - Support RTM_GETLINK lookups via IFLA_IFNAME with correct error codes - Add regression coverage for hot-path overhead and name-based queries * fix(preload): accept unterminated netlink interface names - Copy IFLA_IFNAME into a bounded, NUL-terminated buffer before lookup - Match kernel string length validation and ERANGE errors - Add regression coverage for unterminated names and boundary cases * fix(preload): pin peers for netlink replies * fix(preload): make autobind idempotent * fix(preload): isolate forked netlink cleanup * fix(preload): avoid interposed fd scans * perf(preload): skip PID checks for untracked fds * fix(preload): verify peer before replay --------- Co-authored-by: uubooster-team --- tools/linuxfs/preload/lock.c | 7 + tools/linuxfs/preload/net.c | 8 + tools/linuxfs/preload/netif.c | 1533 +++++++++++++++++++++++++++ tools/linuxfs/preload/ntsync.c | 37 +- tools/linuxfs/preload/udevmon.c | 50 +- tools/tests/netlink_stubs.c | 59 ++ tools/tests/test_binfmt_preload.py | 3 +- tools/tests/test_cdp_guard.py | 3 +- tools/tests/test_netlink_preload.py | 1238 +++++++++++++++++++++ 9 files changed, 2927 insertions(+), 11 deletions(-) create mode 100644 tools/tests/netlink_stubs.c create mode 100644 tools/tests/test_netlink_preload.py diff --git a/tools/linuxfs/preload/lock.c b/tools/linuxfs/preload/lock.c index b802fded6e..c3a272f139 100644 --- a/tools/linuxfs/preload/lock.c +++ b/tools/linuxfs/preload/lock.c @@ -54,6 +54,9 @@ static int is_lock_query(int cmd) { } } +int bl_nl_before_dup(int fd, void **state) __attribute__((visibility("hidden"))); +void bl_nl_after_dup(void *state, int fd) __attribute__((visibility("hidden"))); + int fcntl(int fd, int cmd, ...) { static int (*real_fcntl)(int, int, ...); va_list ap; @@ -69,7 +72,11 @@ int fcntl(int fd, int cmd, ...) { errno = ENOSYS; return -1; } + void *nl_state = NULL; + int duplicate = cmd == F_DUPFD || cmd == F_DUPFD_CLOEXEC; + if (duplicate && bl_nl_before_dup(fd, &nl_state) != 0) return -1; result = real_fcntl(fd, cmd, arg); + if (duplicate) bl_nl_after_dup(nl_state, result); if (result >= 0 || !unsupported(errno)) return result; if (is_lock_command(cmd)) return 0; if (is_lock_query(cmd) && arg != NULL) { diff --git a/tools/linuxfs/preload/net.c b/tools/linuxfs/preload/net.c index 73b8c9c8b1..4946db7f9c 100644 --- a/tools/linuxfs/preload/net.c +++ b/tools/linuxfs/preload/net.c @@ -111,10 +111,16 @@ typedef int (*accept4_fn)(int, struct sockaddr *, socklen_t *, int); static unsigned guarded_port(void); __attribute__((visibility("hidden"))) int bl_udevmon_stand_in(int fd); +__attribute__((visibility("hidden"))) int bl_nl_bind(int fd, const struct sockaddr *addr, + socklen_t len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_connect(int fd, const struct sockaddr *addr, + socklen_t len, int *rc); int bind(int fd, const struct sockaddr *addr, socklen_t len) { static bind_fn real; + int nl_rc; if (!real) real = (bind_fn)dlsym(RTLD_NEXT, "bind"); + if (bl_nl_bind(fd, addr, len, &nl_rc)) return nl_rc; if (bl_udevmon_stand_in(fd)) { if (addr == NULL || len < sizeof(struct sockaddr_nl) || addr->sa_family != AF_NETLINK) { errno = EINVAL; @@ -223,6 +229,8 @@ static int guest_peer(int fd) { int connect(int fd, const struct sockaddr *addr, socklen_t len) { static connect_fn real; + int nl_rc; + if (bl_nl_connect(fd, addr, len, &nl_rc)) return nl_rc; if (!real) real = (connect_fn)dlsym(RTLD_NEXT, "connect"); bind_before_loopback_connect(fd, addr, len); unsigned peer = loopback_family(addr, len) ? addr_port(addr, len) : 0; diff --git a/tools/linuxfs/preload/netif.c b/tools/linuxfs/preload/netif.c index 308af34437..55da3c21e1 100644 --- a/tools/linuxfs/preload/netif.c +++ b/tools/linuxfs/preload/netif.c @@ -5,21 +5,31 @@ #define _GNU_SOURCE 1 #include #include +#include #include #include #include +#include +#include +#include +#include +#include #include #include #include #include #include #include +#include #include #include #include #include #include #include +#include +#include +#include #include #include @@ -619,3 +629,1526 @@ FILE *fopen64(const char *path, const char *mode) { if (real == NULL) real = (fopen_fn) dlsym(RTLD_NEXT, "fopen64"); return open_stream(real, path, mode, __builtin_return_address(0)); } + +#define NL_REQUEST_MAX 1024 +#define NL_REPLY_MAX 4096 + +#ifndef IFF_LOWER_UP +#define IFF_LOWER_UP 0x10000 +#endif + +#ifndef IF_OPER_UP +#define IF_OPER_UP 6 +#endif + +#ifndef SO_DOMAIN +#define SO_DOMAIN 39 +#endif + +#ifndef SO_PROTOCOL +#define SO_PROTOCOL 38 +#endif + +struct nl_socket { + int peer; + int reservation; + dev_t device; + ino_t inode; + ino_t peer_inode; + ino_t reservation_inode; + unsigned port; + unsigned references; + int type; + int cap_ack; + struct nl_socket *next; +}; + +struct nl_fd { + int fd; + struct nl_socket *socket; + struct nl_fd *next; +}; + +#define NL_FD_PAGE_SIZE 1024 +#define NL_FD_BUCKETS 256 +#define NL_FD_WORD_BITS (sizeof(unsigned long) * CHAR_BIT) + +struct nl_fd_page { + unsigned number; + unsigned long bits[NL_FD_PAGE_SIZE / NL_FD_WORD_BITS]; + struct nl_fd_page *next; +}; + +struct nl_metadata { + uint64_t nonce; + uint32_t port; + uint32_t type; + uint32_t cap_ack; + char magic[12]; +}; + +_Static_assert(sizeof(struct nl_metadata) == 32, "netlink socket metadata ABI"); + +struct nl_packet { + struct nl_packet *next; + size_t len; + unsigned char data[]; +}; + +struct nl_reply { + unsigned char data[NL_REPLY_MAX]; + size_t len; + int overflow; +}; + +static const char nl_client_magic[12] = "bl-nl-c-v1"; +static const char nl_peer_magic[12] = "bl-nl-p-v1"; +static const char nl_reservation_magic[12] = "bl-nl-r-v1"; +static struct nl_socket *nl_sockets; +static struct nl_fd *nl_fds; +static struct nl_fd_page *nl_fd_pages[NL_FD_BUCKETS]; +static unsigned nl_fd_count; +static int nl_fd_index_incomplete; +static unsigned nl_next_port = 0x80000000u; +static pthread_mutex_t nl_sockets_lock = PTHREAD_MUTEX_INITIALIZER; +static pid_t nl_owner; +static __thread unsigned nl_reply_port; +static __thread int nl_reply_capped; + +static void nl_lock_before_fork(void) { pthread_mutex_lock(&nl_sockets_lock); } +static void nl_unlock_after_fork(void) { pthread_mutex_unlock(&nl_sockets_lock); } +static void nl_reset_after_fork(void) { + pthread_mutex_init(&nl_sockets_lock, NULL); + nl_owner = getpid(); +} +static int nl_foreign(void) { return getpid() != nl_owner; } +static void nl_restore_inherited(void); + +__attribute__((constructor)) static void nl_sockets_init(void) { + nl_owner = getpid(); + pthread_atfork(nl_lock_before_fork, nl_unlock_after_fork, nl_reset_after_fork); + nl_restore_inherited(); +} + +static struct nl_fd_page *nl_fd_page_of(int fd) { + unsigned number = (unsigned) fd / NL_FD_PAGE_SIZE; + struct nl_fd_page *page = + __atomic_load_n(&nl_fd_pages[number % NL_FD_BUCKETS], __ATOMIC_ACQUIRE); + for (; page; page = page->next) { + if (page->number == number) return page; + } + return NULL; +} + +static int nl_tracked(int fd) { + if (fd < 0 || __atomic_load_n(&nl_fd_count, __ATOMIC_ACQUIRE) == 0) return 0; + struct nl_fd_page *page = nl_fd_page_of(fd); + unsigned offset = (unsigned) fd % NL_FD_PAGE_SIZE; + if (page && (__atomic_load_n(&page->bits[offset / NL_FD_WORD_BITS], __ATOMIC_ACQUIRE) + & (1ul << (offset % NL_FD_WORD_BITS)))) return 1; + return __atomic_load_n(&nl_fd_index_incomplete, __ATOMIC_ACQUIRE); +} + +static void nl_register(struct nl_fd *entry) { + struct nl_fd_page *page = nl_fd_page_of(entry->fd); + if (page == NULL) { + page = calloc(1, sizeof(*page)); + if (page) { + page->number = (unsigned) entry->fd / NL_FD_PAGE_SIZE; + unsigned bucket = page->number % NL_FD_BUCKETS; + page->next = nl_fd_pages[bucket]; + __atomic_store_n(&nl_fd_pages[bucket], page, __ATOMIC_RELEASE); + } else { + __atomic_store_n(&nl_fd_index_incomplete, 1, __ATOMIC_RELEASE); + } + } + entry->next = nl_fds; + nl_fds = entry; + if (page) { + unsigned offset = (unsigned) entry->fd % NL_FD_PAGE_SIZE; + __atomic_fetch_or(&page->bits[offset / NL_FD_WORD_BITS], + 1ul << (offset % NL_FD_WORD_BITS), __ATOMIC_RELEASE); + } + __atomic_fetch_add(&nl_fd_count, 1, __ATOMIC_RELEASE); +} + +static int nl_identity(int fd, dev_t device, ino_t inode) { + struct stat status; + return fstat(fd, &status) == 0 && S_ISSOCK(status.st_mode) + && status.st_dev == device && status.st_ino == inode; +} + +static int nl_address(int fd, int peer, struct sockaddr_un *addr, struct nl_metadata *metadata, + const char *magic) { + static int (*real_name)(int, struct sockaddr *, socklen_t *); + static int (*real_peer)(int, struct sockaddr *, socklen_t *); + if (real_name == NULL) real_name = (int (*)(int, struct sockaddr *, socklen_t *)) + dlsym(RTLD_NEXT, "getsockname"); + if (real_peer == NULL) real_peer = (int (*)(int, struct sockaddr *, socklen_t *)) + dlsym(RTLD_NEXT, "getpeername"); + socklen_t len = sizeof(*addr); + memset(addr, 0, sizeof(*addr)); + int result = (peer ? real_peer : real_name)(fd, (struct sockaddr *) addr, &len); + if (result != 0 || len != offsetof(struct sockaddr_un, sun_path) + 1 + sizeof(*metadata) + || addr->sun_family != AF_UNIX || addr->sun_path[0] != '\0') return 0; + memcpy(metadata, addr->sun_path + 1, sizeof(*metadata)); + return memcmp(metadata->magic, magic, sizeof(metadata->magic)) == 0; +} + +static int nl_bind_address(int fd, struct nl_metadata *metadata, struct sockaddr_un *addr) { + static int (*real_bind)(int, const struct sockaddr *, socklen_t); + if (real_bind == NULL) real_bind = (int (*)(int, const struct sockaddr *, socklen_t)) + dlsym(RTLD_NEXT, "bind"); + memset(addr, 0, sizeof(*addr)); + addr->sun_family = AF_UNIX; + memcpy(addr->sun_path + 1, metadata, sizeof(*metadata)); + return real_bind(fd, (const struct sockaddr *) addr, + offsetof(struct sockaddr_un, sun_path) + 1 + sizeof(*metadata)); +} + +static int nl_connect_address(int fd, const struct sockaddr_un *addr) { + static int (*real_connect)(int, const struct sockaddr *, socklen_t); + if (real_connect == NULL) real_connect = (int (*)(int, const struct sockaddr *, socklen_t)) + dlsym(RTLD_NEXT, "connect"); + return real_connect(fd, (const struct sockaddr *) addr, + offsetof(struct sockaddr_un, sun_path) + 1 + sizeof(struct nl_metadata)); +} + +static void nl_close_peer(struct nl_socket *socket) { + if (socket->peer < 0) return; + if (!nl_identity(socket->peer, socket->device, socket->peer_inode)) return; + static int (*real_close)(int); + if (real_close == NULL) real_close = (int (*)(int)) dlsym(RTLD_NEXT, "close"); + if (real_close) real_close(socket->peer); +} + +static int nl_reserve_port(struct nl_socket *socket, unsigned port) { + static int (*real_socket)(int, int, int); + static int (*real_close)(int); + if (real_socket == NULL) real_socket = (int (*)(int, int, int)) dlsym(RTLD_NEXT, "socket"); + if (real_close == NULL) real_close = (int (*)(int)) dlsym(RTLD_NEXT, "close"); + int descriptor = real_socket(AF_UNIX, SOCK_DGRAM, 0); + if (descriptor < 0) return -1; + struct nl_metadata metadata = { .port = port }; + struct sockaddr_un addr; + struct stat status; + memcpy(metadata.magic, nl_reservation_magic, sizeof(metadata.magic)); + if (nl_bind_address(descriptor, &metadata, &addr) != 0 || fstat(descriptor, &status) != 0) { + int saved = errno; + real_close(descriptor); + errno = saved; + return -1; + } + socket->reservation = descriptor; + socket->reservation_inode = status.st_ino; + return 0; +} + +static void nl_close_reservation(struct nl_socket *socket) { + if (socket->reservation < 0 + || !nl_identity(socket->reservation, socket->device, socket->reservation_inode)) return; + static int (*real_close)(int); + if (real_close == NULL) real_close = (int (*)(int)) dlsym(RTLD_NEXT, "close"); + if (real_close) real_close(socket->reservation); + socket->reservation = -1; +} + +static int nl_replay_packets(int peer, struct nl_packet *packets) { + static ssize_t (*real_send)(int, const void *, size_t, int); + if (real_send == NULL) real_send = (ssize_t (*)(int, const void *, size_t, int)) + dlsym(RTLD_NEXT, "send"); + int error = 0; + while (packets) { + struct nl_packet *packet = packets; + packets = packet->next; + if (real_send(peer, packet->data, packet->len, MSG_DONTWAIT | MSG_NOSIGNAL) < 0 && error == 0) + error = errno; + free(packet); + } + if (error) errno = error; + return error ? -1 : 0; +} + +static void nl_discard_packets(struct nl_packet *packets) { + while (packets) { + struct nl_packet *next = packets->next; + free(packets); + packets = next; + } +} + +static int nl_save_packets(int fd, struct nl_packet **packets) { + static ssize_t (*real_recv)(int, void *, size_t, int); + if (real_recv == NULL) real_recv = (ssize_t (*)(int, void *, size_t, int)) + dlsym(RTLD_NEXT, "recv"); + struct nl_packet **tail = packets; + *packets = NULL; + for (;;) { + ssize_t len = real_recv(fd, NULL, 0, MSG_PEEK | MSG_TRUNC | MSG_DONTWAIT); + if (len < 0) return errno == EAGAIN || errno == EWOULDBLOCK ? 0 : -1; + if ((size_t) len > SIZE_MAX - sizeof(struct nl_packet)) { + errno = EMSGSIZE; + return -1; + } + struct nl_packet *packet = malloc(sizeof(*packet) + (size_t) len); + if (packet == NULL) return -1; + ssize_t received = real_recv(fd, packet->data, (size_t) len, MSG_DONTWAIT); + if (received < 0) { + int saved = errno; + free(packet); + errno = saved; + return -1; + } + packet->len = (size_t) received; + packet->next = NULL; + *tail = packet; + tail = &packet->next; + } +} + +static int nl_replace_peer(int fd, struct nl_socket *socket, unsigned port, int capped) { + static int (*real_socket)(int, int, int); + static int (*real_close)(int); + if (real_socket == NULL) real_socket = (int (*)(int, int, int)) dlsym(RTLD_NEXT, "socket"); + if (real_close == NULL) real_close = (int (*)(int)) dlsym(RTLD_NEXT, "close"); + struct sockaddr_un client_addr, peer_addr; + struct nl_metadata client, peer = { .port = port, .type = socket->type, .cap_ack = capped }; + if (!nl_address(fd, 0, &client_addr, &client, nl_client_magic)) { + errno = EINVAL; + return -1; + } + int descriptor = real_socket(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC, 0); + if (descriptor < 0) return -1; + struct nl_packet *packets = NULL; + struct stat status; + if (fstat(descriptor, &status) != 0) goto failed; + peer.nonce = status.st_ino; + memcpy(peer.magic, nl_peer_magic, sizeof(peer.magic)); + if (nl_bind_address(descriptor, &peer, &peer_addr) != 0 + || nl_save_packets(fd, &packets) != 0) goto failed; + if (nl_connect_address(fd, &peer_addr) != 0 + || nl_connect_address(descriptor, &client_addr) != 0) goto failed; + struct timeval timeout; + socklen_t timeout_len = sizeof(timeout); + static int (*real_getopt)(int, int, int, void *, socklen_t *); + static int (*real_setopt)(int, int, int, const void *, socklen_t); + if (real_getopt == NULL) real_getopt = (int (*)(int, int, int, void *, socklen_t *)) + dlsym(RTLD_NEXT, "getsockopt"); + if (real_setopt == NULL) real_setopt = (int (*)(int, int, int, const void *, socklen_t)) + dlsym(RTLD_NEXT, "setsockopt"); + if (real_getopt(fd, SOL_SOCKET, SO_SNDTIMEO, &timeout, &timeout_len) == 0) + real_setopt(descriptor, SOL_SOCKET, SO_SNDTIMEO, &timeout, timeout_len); + int send_buffer; + socklen_t buffer_len = sizeof(send_buffer); + if (real_getopt(fd, SOL_SOCKET, SO_SNDBUF, &send_buffer, &buffer_len) == 0) { + send_buffer /= 2; + real_setopt(descriptor, SOL_SOCKET, SO_SNDBUF, &send_buffer, sizeof(send_buffer)); + } + int replayed = nl_replay_packets(descriptor, packets); + int saved = errno; + nl_close_peer(socket); + socket->peer = descriptor; + socket->peer_inode = status.st_ino; + socket->port = port; + socket->cap_ack = capped; + errno = saved; + return replayed; +failed: { + int saved = errno; + if (socket->peer >= 0 && nl_identity(socket->peer, socket->device, socket->peer_inode)) + nl_replay_packets(socket->peer, packets); + else + nl_discard_packets(packets); + real_close(descriptor); + errno = saved; + return -1; +} +} + +static void nl_release(struct nl_socket *socket) { + if (--socket->references != 0) return; + for (struct nl_socket **entry = &nl_sockets; *entry; entry = &(*entry)->next) { + if (*entry != socket) continue; + *entry = socket->next; + break; + } + nl_close_peer(socket); + nl_close_reservation(socket); + free(socket); +} + +static void nl_remove(struct nl_fd **entry) { + struct nl_fd *removed = *entry; + *entry = removed->next; + struct nl_fd *alias; + for (alias = nl_fds; alias; alias = alias->next) { + if (alias->fd == removed->fd) break; + } + struct nl_fd_page *page = nl_fd_page_of(removed->fd); + if (alias == NULL && page) { + unsigned offset = (unsigned) removed->fd % NL_FD_PAGE_SIZE; + __atomic_fetch_and(&page->bits[offset / NL_FD_WORD_BITS], + ~(1ul << (offset % NL_FD_WORD_BITS)), __ATOMIC_RELEASE); + } + __atomic_fetch_sub(&nl_fd_count, 1, __ATOMIC_RELEASE); + nl_release(removed->socket); + free(removed); +} + +static struct nl_fd *nl_restore(int fd) { + struct sockaddr_un client_addr, peer_addr; + struct nl_metadata client, peer; + struct stat status; + if (!nl_address(fd, 0, &client_addr, &client, nl_client_magic) + || !nl_address(fd, 1, &peer_addr, &peer, nl_peer_magic) + || (peer.type != SOCK_RAW && peer.type != SOCK_DGRAM) + || client.type != peer.type || peer.cap_ack > 1 + || fstat(fd, &status) != 0 || client.nonce != (uint64_t) status.st_ino) return NULL; + struct nl_fd *entry = malloc(sizeof(*entry)); + if (entry == NULL) return NULL; + struct nl_socket *socket; + for (socket = nl_sockets; socket; socket = socket->next) { + if (socket->device == status.st_dev && socket->inode == status.st_ino) break; + } + if (socket == NULL) { + socket = calloc(1, sizeof(*socket)); + if (socket == NULL) { + free(entry); + return NULL; + } + socket->peer = -1; + socket->reservation = -1; + socket->device = status.st_dev; + socket->inode = status.st_ino; + socket->type = peer.type; + if (nl_replace_peer(fd, socket, peer.port, peer.cap_ack) != 0) { + free(socket); + free(entry); + return NULL; + } + socket->next = nl_sockets; + nl_sockets = socket; + } + socket->references++; + entry->fd = fd; + entry->socket = socket; + nl_register(entry); + return entry; +} + +static struct nl_fd *nl_find(int fd) { + if (fd < 0) return NULL; + for (struct nl_fd **entry = &nl_fds; *entry; entry = &(*entry)->next) { + if ((*entry)->fd != fd) continue; + struct nl_socket *socket = (*entry)->socket; + if (nl_identity(fd, socket->device, socket->inode)) return *entry; + nl_remove(entry); + break; + } + return NULL; +} + +static void nl_discover(int fd) { + int saved = errno; + if (nl_tracked(fd)) { + pthread_mutex_lock(&nl_sockets_lock); + int found = nl_find(fd) != NULL; + pthread_mutex_unlock(&nl_sockets_lock); + if (found) { + errno = saved; + return; + } + } + struct sockaddr_un addr; + struct nl_metadata metadata; + if (nl_address(fd, 0, &addr, &metadata, nl_client_magic)) { + pthread_mutex_lock(&nl_sockets_lock); + if (nl_find(fd) == NULL) nl_restore(fd); + pthread_mutex_unlock(&nl_sockets_lock); + } + errno = saved; +} + +static void nl_restore_inherited(void) { + int directory = (int) syscall(SYS_openat, AT_FDCWD, "/proc/self/fd", + O_RDONLY | O_DIRECTORY | O_CLOEXEC); + if (directory < 0) return; + int *descriptors = NULL; + size_t count = 0, capacity = 0; + union { + max_align_t alignment; + unsigned char bytes[4096]; + } buffer; + long length; + while ((length = syscall(SYS_getdents64, directory, buffer.bytes, sizeof(buffer.bytes))) > 0) { + size_t offset = 0; + while (offset < (size_t) length) { + struct dirent *entry = (struct dirent *) (buffer.bytes + offset); + size_t minimum = offsetof(struct dirent, d_name) + 1; + if (entry->d_reclen < minimum || entry->d_reclen > (size_t) length - offset) break; + char *end; + long descriptor = strtol(entry->d_name, &end, 10); + if (end != entry->d_name && !*end && descriptor >= 0 && descriptor <= INT_MAX && + descriptor != directory) { + if (count == capacity) { + size_t enlarged = capacity ? capacity * 2 : 16; + int *allocated = realloc(descriptors, enlarged * sizeof(*descriptors)); + if (allocated == NULL) { + offset = (size_t) length; + break; + } + descriptors = allocated; + capacity = enlarged; + } + descriptors[count++] = (int) descriptor; + } + offset += entry->d_reclen; + } + } + int saved = errno; + syscall(SYS_close, directory); + errno = saved; + for (size_t index = 0; index < count; index++) { + nl_discover(descriptors[index]); + } + for (size_t index = 0; index < count; index++) { + int descriptor = descriptors[index]; + struct sockaddr_un addr; + struct nl_metadata metadata; + if (!nl_address(descriptor, 0, &addr, &metadata, nl_reservation_magic)) continue; + struct stat status; + if (fstat(descriptor, &status) != 0) continue; + struct nl_socket *socket; + for (socket = nl_sockets; socket; socket = socket->next) { + if (socket->port == metadata.port) break; + } + if (socket) { + socket->reservation = descriptor; + socket->reservation_inode = status.st_ino; + } else { + static int (*real_close)(int); + if (real_close == NULL) real_close = (int (*)(int)) dlsym(RTLD_NEXT, "close"); + real_close(descriptor); + } + } + free(descriptors); +} + +static int nl_nonblocking(int fd) { + static int (*real_fcntl)(int, int, ...); + int flags; + if (real_fcntl == NULL) real_fcntl = (int (*)(int, int, ...)) dlsym(RTLD_NEXT, "fcntl"); + if (real_fcntl == NULL) return 0; + flags = real_fcntl(fd, F_GETFL); + return flags >= 0 && (flags & O_NONBLOCK) != 0; +} + +static int nl_peer_of(int fd) { + int peer = -1; + if (!nl_tracked(fd)) return peer; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry) { + struct sockaddr_un addr; + struct nl_metadata metadata; + struct nl_socket *socket = entry->socket; + if (nl_address(fd, 1, &addr, &metadata, nl_peer_magic)) { + if ((metadata.nonce == socket->peer_inode + && nl_identity(socket->peer, socket->device, socket->peer_inode)) + || nl_replace_peer(fd, socket, metadata.port, metadata.cap_ack) == 0) { + if (socket->port != 0 && (socket->reservation < 0 + || !nl_identity(socket->reservation, socket->device, socket->reservation_inode))) + nl_reserve_port(socket, socket->port); + peer = socket->peer; + } + } + } + pthread_mutex_unlock(&nl_sockets_lock); + return peer; +} + +static int nl_dup_peer_of(int fd, unsigned *port, int *capped) { + static int (*real_fcntl)(int, int, ...); + int peer = -1; + if (!nl_tracked(fd)) return peer; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry) { + if (real_fcntl == NULL) + real_fcntl = (int (*)(int, int, ...)) dlsym(RTLD_NEXT, "fcntl"); + if (real_fcntl == NULL) { + errno = ENOSYS; + } else { + peer = real_fcntl(entry->socket->peer, F_DUPFD_CLOEXEC, 0); + if (peer >= 0) { + if (port) *port = entry->socket->port; + if (capped) *capped = entry->socket->cap_ack; + } + } + } else { + errno = EBADF; + } + pthread_mutex_unlock(&nl_sockets_lock); + return peer; +} + +static unsigned nl_port_of(int fd) { + unsigned port = 0; + if (!nl_tracked(fd)) return port; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry) port = entry->socket->port; + pthread_mutex_unlock(&nl_sockets_lock); + return port; +} + +__attribute__((visibility("hidden"))) int bl_nl_socket(int type, int *fd); +__attribute__((visibility("hidden"))) int bl_nl_bind(int fd, const struct sockaddr *addr, + socklen_t len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_getsockname(int fd, struct sockaddr *addr, + socklen_t *len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_owns(int fd); +__attribute__((visibility("hidden"))) void bl_nl_closed(int fd); +__attribute__((visibility("hidden"))) void bl_nl_range_closed(unsigned int first, unsigned int last); +__attribute__((visibility("hidden"))) int bl_nl_before_dup(int fd, void **state); +__attribute__((visibility("hidden"))) void bl_nl_after_dup(void *state, int fd); +__attribute__((visibility("hidden"))) int bl_nl_connect(int fd, const struct sockaddr *addr, + socklen_t len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_getpeername(int fd, struct sockaddr *addr, + socklen_t *len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_setsockopt(int fd, int level, int option, + const void *value, socklen_t len, + int (*real)(int, int, int, const void *, socklen_t), + int *rc); +__attribute__((visibility("hidden"))) int bl_nl_getsockopt(int fd, int level, int option, + void *value, socklen_t *len, + int (*real)(int, int, int, void *, socklen_t *), + int *rc); +__attribute__((visibility("hidden"))) void bl_nl_received(struct msghdr *msg); +__attribute__((visibility("hidden"))) int bl_nl_recvmsg(int fd, struct msghdr *msg, int flags, + ssize_t (*real)(int, struct msghdr *, int), + ssize_t *rc); + +int bl_nl_owns(int fd) { return nl_peer_of(fd) >= 0; } + +int bl_nl_socket(int type, int *fd) { + int kind = type & 0xf; + *fd = -1; + if (type & ~(0xf | SOCK_CLOEXEC | SOCK_NONBLOCK)) { + errno = EINVAL; + return 1; + } + if (kind != SOCK_RAW && kind != SOCK_DGRAM) { + errno = kind >= 11 ? EINVAL : ESOCKTNOSUPPORT; + return 1; + } + int pair[2]; + struct stat client_status, peer_status; + struct nl_fd *entry = malloc(sizeof(*entry)); + struct nl_socket *socket = calloc(1, sizeof(*socket)); + if (entry == NULL || socket == NULL) { + free(entry); + free(socket); + errno = ENOMEM; + return 1; + } + int flags = type & (SOCK_CLOEXEC | SOCK_NONBLOCK); + if (socketpair(AF_UNIX, SOCK_DGRAM | flags, 0, pair) != 0) { + free(entry); + free(socket); + return 1; + } + if (fcntl(pair[1], F_SETFD, FD_CLOEXEC) != 0 || fcntl(pair[1], F_SETFL, 0) != 0 + || fstat(pair[0], &client_status) != 0 || fstat(pair[1], &peer_status) != 0) + goto failed; + struct nl_metadata client = { .nonce = client_status.st_ino, .type = kind }; + struct nl_metadata peer = { .nonce = peer_status.st_ino, .type = kind }; + struct sockaddr_un addr; + memcpy(client.magic, nl_client_magic, sizeof(client.magic)); + memcpy(peer.magic, nl_peer_magic, sizeof(peer.magic)); + if (nl_bind_address(pair[0], &client, &addr) != 0 + || nl_bind_address(pair[1], &peer, &addr) != 0) goto failed; + socket->peer = pair[1]; + socket->reservation = -1; + socket->device = client_status.st_dev; + socket->inode = client_status.st_ino; + socket->peer_inode = peer_status.st_ino; + socket->type = kind; + socket->references = 1; + entry->fd = pair[0]; + entry->socket = socket; + pthread_mutex_lock(&nl_sockets_lock); + socket->next = nl_sockets; + nl_sockets = socket; + nl_register(entry); + pthread_mutex_unlock(&nl_sockets_lock); + *fd = pair[0]; + return 1; +failed: { + int saved = errno; + close(pair[0]); + close(pair[1]); + free(entry); + free(socket); + errno = saved; + return 1; + } +} + +static int nl_bind_port(int fd, unsigned requested, int automatic) { + int result = -1; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry) { + struct nl_socket *socket = entry->socket; + if (socket->port != 0) { + if (automatic || requested == socket->port) result = 0; + else errno = EINVAL; + } else { + unsigned port = requested ? requested : (unsigned) getpid(); + for (;;) { + struct nl_socket *other; + for (other = nl_sockets; other; other = other->next) { + if (other != socket && other->port == port) break; + } + if (other == NULL) { + if (nl_reserve_port(socket, port) == 0) { + result = nl_replace_peer(fd, socket, port, socket->cap_ack); + if (result != 0) nl_close_reservation(socket); + break; + } + if (errno != EADDRINUSE || requested != 0) break; + } + if (requested != 0) { + errno = EADDRINUSE; + break; + } + port = nl_next_port++; + if (port == 0) port = nl_next_port++; + } + } + } else { + errno = EBADF; + } + pthread_mutex_unlock(&nl_sockets_lock); + return result; +} + +static int nl_autobind(int fd) { + return nl_bind_port(fd, 0, 1); +} + +int bl_nl_bind(int fd, const struct sockaddr *addr, socklen_t len, int *rc) { + const struct sockaddr_nl *nl; + if (addr && len >= sizeof(sa_family_t) && addr->sa_family == AF_NETLINK) nl_discover(fd); + if (!bl_nl_owns(fd)) return 0; + if (addr == NULL || len < sizeof(struct sockaddr_nl) || addr->sa_family != AF_NETLINK) { + errno = EINVAL; + *rc = -1; + return 1; + } + nl = (const struct sockaddr_nl *) addr; + if (nl->nl_groups != 0) { + errno = EACCES; + *rc = -1; + return 1; + } + *rc = nl_bind_port(fd, nl->nl_pid, 0); + return 1; +} + +int bl_nl_getsockname(int fd, struct sockaddr *addr, socklen_t *len, int *rc) { + struct sockaddr_nl nl; + socklen_t size; + if (!bl_nl_owns(fd)) return 0; + if (addr == NULL || len == NULL) { + errno = EFAULT; + *rc = -1; + return 1; + } + memset(&nl, 0, sizeof(nl)); + nl.nl_family = AF_NETLINK; + nl.nl_pid = nl_port_of(fd); + size = *len < sizeof(nl) ? *len : (socklen_t) sizeof(nl); + memcpy(addr, &nl, size); + *len = sizeof(nl); + *rc = 0; + return 1; +} + +void bl_nl_closed(int fd) { + if (!nl_tracked(fd)) return; + if (nl_foreign()) return; + bl_nl_range_closed((unsigned int) fd, (unsigned int) fd); +} + +void bl_nl_range_closed(unsigned int first, unsigned int last) { + if (__atomic_load_n(&nl_fd_count, __ATOMIC_ACQUIRE) == 0) return; + if (nl_foreign()) return; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd **entry = &nl_fds; + while (*entry) { + if ((unsigned int) (*entry)->fd >= first && (unsigned int) (*entry)->fd <= last) + nl_remove(entry); + else + entry = &(*entry)->next; + } + pthread_mutex_unlock(&nl_sockets_lock); +} + +int bl_nl_before_dup(int fd, void **state) { + *state = NULL; + if (!nl_tracked(fd)) return 0; + if (nl_foreign()) return 0; + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry) { + struct nl_fd *reserved = malloc(sizeof(*reserved)); + if (reserved == NULL) { + pthread_mutex_unlock(&nl_sockets_lock); + errno = ENOMEM; + return -1; + } + reserved->socket = entry->socket; + entry->socket->references++; + *state = reserved; + } + pthread_mutex_unlock(&nl_sockets_lock); + return 0; +} + +void bl_nl_after_dup(void *state, int fd) { + int saved = errno; + struct nl_fd *reserved = state; + if (reserved == NULL && !nl_tracked(fd)) { + errno = saved; + return; + } + if (nl_foreign()) { + errno = saved; + return; + } + pthread_mutex_lock(&nl_sockets_lock); + if (reserved && fd >= 0) { + reserved->fd = fd; + nl_register(reserved); + } + if (fd >= 0) { + for (struct nl_fd **entry = &nl_fds; *entry; entry = &(*entry)->next) { + if ((*entry)->fd != fd || *entry == reserved) continue; + nl_remove(entry); + break; + } + } + if (reserved && fd < 0) { + nl_release(reserved->socket); + free(reserved); + } + pthread_mutex_unlock(&nl_sockets_lock); + errno = saved; +} + +int dup(int fd) { + static int (*real)(int); + void *state; + if (real == NULL) real = (int (*)(int)) dlsym(RTLD_NEXT, "dup"); + if (bl_nl_before_dup(fd, &state) != 0) return -1; + int result = real(fd); + bl_nl_after_dup(state, result); + return result; +} + +static int nl_destination(const struct sockaddr *addr, socklen_t len) { + if (addr == NULL || len < sizeof(struct sockaddr_nl)) return -EINVAL; + if (addr->sa_family != AF_NETLINK) return -EAFNOSUPPORT; + const struct sockaddr_nl *destination = (const struct sockaddr_nl *) addr; + if (destination->nl_groups != 0) return -EACCES; + return destination->nl_pid == 0 ? 0 : -ECONNREFUSED; +} + +int bl_nl_connect(int fd, const struct sockaddr *addr, socklen_t len, int *rc) { + if (addr && len >= sizeof(sa_family_t) && addr->sa_family == AF_NETLINK) nl_discover(fd); + if (!bl_nl_owns(fd)) return 0; + int disconnect = addr && len >= sizeof(sa_family_t) && addr->sa_family == AF_UNSPEC; + int error = disconnect ? 0 : nl_destination(addr, len); + if (error) { + errno = addr == NULL ? EFAULT : -error; + *rc = -1; + return 1; + } + *rc = disconnect ? 0 : nl_autobind(fd); + return 1; +} + +static void nl_source_name(struct sockaddr *addr, socklen_t *len) { + struct sockaddr_nl source; + memset(&source, 0, sizeof(source)); + source.nl_family = AF_NETLINK; + socklen_t capacity = *len < sizeof(source) ? *len : (socklen_t) sizeof(source); + if (capacity > 0) memcpy(addr, &source, capacity); + *len = sizeof(source); +} + +int bl_nl_getpeername(int fd, struct sockaddr *addr, socklen_t *len, int *rc) { + if (!bl_nl_owns(fd)) return 0; + if (addr == NULL || len == NULL) { + errno = EFAULT; + *rc = -1; + } else { + nl_source_name(addr, len); + *rc = 0; + } + return 1; +} + +int bl_nl_setsockopt(int fd, int level, int option, const void *value, socklen_t len, + int (*real)(int, int, int, const void *, socklen_t), int *rc) { + if (level == SOL_NETLINK) nl_discover(fd); + int peer = nl_peer_of(fd); + if (peer < 0) return 0; + if (level != SOL_NETLINK) { + *rc = real(fd, level, option, value, len); + if (*rc == 0 && level == SOL_SOCKET + && (option == SO_SNDTIMEO || option == SO_SNDBUF)) + *rc = real(peer, level, option, value, len); + return 1; + } + if (option != NETLINK_CAP_ACK && option != NETLINK_EXT_ACK) { + errno = option == NETLINK_ADD_MEMBERSHIP || option == NETLINK_DROP_MEMBERSHIP + ? EACCES : ENOPROTOOPT; + *rc = -1; + } else if (value == NULL || len < sizeof(int)) { + errno = value == NULL ? EFAULT : EINVAL; + *rc = -1; + } else { + if (option == NETLINK_CAP_ACK) { + int enabled; + memcpy(&enabled, value, sizeof(enabled)); + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry && nl_replace_peer(fd, entry->socket, entry->socket->port, enabled != 0) != 0) { + pthread_mutex_unlock(&nl_sockets_lock); + *rc = -1; + return 1; + } + pthread_mutex_unlock(&nl_sockets_lock); + } + *rc = 0; + } + return 1; +} + +int bl_nl_getsockopt(int fd, int level, int option, void *value, socklen_t *len, + int (*real)(int, int, int, void *, socklen_t *), int *rc) { + if (level != SOL_SOCKET || (option != SO_TYPE && option != SO_DOMAIN && option != SO_PROTOCOL)) + return 0; + if (!nl_tracked(fd)) { + if (option != SO_DOMAIN) return 0; + *rc = real(fd, level, option, value, len); + if (*rc != 0) return 1; + int domain = AF_UNIX; + if (value && len && *len >= sizeof(domain)) memcpy(&domain, value, sizeof(domain)); + if (domain != AF_UNIX) return 1; + nl_discover(fd); + if (!nl_tracked(fd)) return 1; + } + pthread_mutex_lock(&nl_sockets_lock); + struct nl_fd *entry = nl_find(fd); + if (entry == NULL) { + pthread_mutex_unlock(&nl_sockets_lock); + return 0; + } + int result = option == SO_TYPE ? entry->socket->type : + option == SO_DOMAIN ? AF_NETLINK : NETLINK_ROUTE; + pthread_mutex_unlock(&nl_sockets_lock); + if (len == NULL || (value == NULL && *len > 0)) { + errno = EFAULT; + *rc = -1; + } else if (*len > INT_MAX) { + errno = EINVAL; + *rc = -1; + } else { + socklen_t capacity = *len < sizeof(result) ? *len : (socklen_t) sizeof(result); + if (capacity) memcpy(value, &result, capacity); + *len = capacity; + *rc = 0; + } + return 1; +} + +void bl_nl_received(struct msghdr *msg) { + for (struct cmsghdr *control = CMSG_FIRSTHDR(msg); control; control = CMSG_NXTHDR(msg, control)) { + if (control->cmsg_len < CMSG_LEN(0)) break; + if (control->cmsg_level != SOL_SOCKET || control->cmsg_type != SCM_RIGHTS) continue; + size_t count = (control->cmsg_len - CMSG_LEN(0)) / sizeof(int); + for (size_t index = 0; index < count; index++) { + int descriptor; + memcpy(&descriptor, CMSG_DATA(control) + index * sizeof(descriptor), sizeof(descriptor)); + nl_discover(descriptor); + } + } +} + +int bl_nl_recvmsg(int fd, struct msghdr *msg, int flags, + ssize_t (*real)(int, struct msghdr *, int), ssize_t *rc) { + ssize_t result; + socklen_t capacity = 0; + if (!bl_nl_owns(fd)) return 0; + if (msg && msg->msg_name) capacity = msg->msg_namelen; + result = real(fd, msg, flags); + if (result >= 0 && msg && msg->msg_name) { + msg->msg_namelen = capacity; + nl_source_name(msg->msg_name, &msg->msg_namelen); + } + *rc = result; + return 1; +} + +ssize_t recvfrom(int fd, void *buffer, size_t length, int flags, + struct sockaddr *addr, socklen_t *addrlen) { + static ssize_t (*real)(int, void *, size_t, int, struct sockaddr *, socklen_t *); + if (real == NULL) + real = (ssize_t (*)(int, void *, size_t, int, struct sockaddr *, socklen_t *)) + dlsym(RTLD_NEXT, "recvfrom"); + int owned = bl_nl_owns(fd); + socklen_t capacity = owned && addr && addrlen ? *addrlen : 0; + ssize_t result = real(fd, buffer, length, flags, addr, addrlen); + if (result >= 0 && owned && addr && addrlen) { + *addrlen = capacity; + nl_source_name(addr, addrlen); + } + return result; +} + +static unsigned char *reply_start(struct nl_reply *out, uint16_t type, uint16_t flags, + uint32_t seq, size_t payload) { + size_t offset = NLMSG_ALIGN(out->len); + struct nlmsghdr *header; + if (payload > sizeof(out->data) + || offset + NLMSG_SPACE(payload) > sizeof(out->data)) { + out->overflow = 1; + return NULL; + } + header = (struct nlmsghdr *) (out->data + offset); + memset(header, 0, NLMSG_SPACE(payload)); + header->nlmsg_len = NLMSG_LENGTH(payload); + header->nlmsg_type = type; + header->nlmsg_flags = flags; + header->nlmsg_seq = seq; + header->nlmsg_pid = nl_reply_port; + out->len = offset + NLMSG_ALIGN(header->nlmsg_len); + return (unsigned char *) header; +} + +static void reply_attr(struct nl_reply *out, unsigned char *message, int type, + const void *data, size_t len) { + struct nlmsghdr *header = (struct nlmsghdr *) message; + size_t base = (size_t) (message - out->data); + size_t offset = NLMSG_ALIGN(header->nlmsg_len); + size_t total = RTA_ALIGN(RTA_LENGTH(len)); + struct rtattr *attr; + if (base + offset + total > sizeof(out->data)) { + out->overflow = 1; + return; + } + attr = (struct rtattr *) (message + offset); + attr->rta_type = (unsigned short) type; + attr->rta_len = (unsigned short) RTA_LENGTH(len); + if (len > 0) memcpy(RTA_DATA(attr), data, len); + header->nlmsg_len = (unsigned) (offset + total); + out->len = base + NLMSG_ALIGN(header->nlmsg_len); +} + +static void reply_done(struct nl_reply *out, uint32_t seq) { + unsigned char *message = reply_start(out, NLMSG_DONE, NLM_F_MULTI, seq, sizeof(int)); + int code = 0; + if (message == NULL) return; + memcpy(NLMSG_DATA((struct nlmsghdr *) message), &code, sizeof(code)); +} + +static void reply_error(struct nl_reply *out, const struct nlmsghdr *request, int error) { + int capped = error == 0 || nl_reply_capped; + size_t extra = capped ? 0 : request->nlmsg_len - NLMSG_HDRLEN; + unsigned char *message = reply_start(out, NLMSG_ERROR, capped ? NLM_F_CAPPED : 0, + request->nlmsg_seq, sizeof(struct nlmsgerr) + extra); + struct nlmsgerr *reply; + if (message == NULL) return; + reply = (struct nlmsgerr *) NLMSG_DATA((struct nlmsghdr *) message); + memset(reply, 0, sizeof(*reply)); + reply->error = error; + reply->msg = *request; + if (extra) memcpy(reply + 1, NLMSG_DATA(request), extra); +} + +static void network_of(const struct link_addr *addr, unsigned char *out) { + unsigned char mask[16]; + int len = addr->family == AF_INET ? 4 : 16; + prefix_mask(addr->family, addr->prefix, mask); + for (int i = 0; i < len; i++) out[i] = (unsigned char) (addr->bytes[i] & mask[i]); +} + +static void broadcast_of(const struct link_addr *addr, unsigned char *out) { + unsigned char mask[16]; + prefix_mask(AF_INET, addr->prefix, mask); + for (int i = 0; i < 4; i++) out[i] = (unsigned char) (addr->bytes[i] | (unsigned char) ~mask[i]); +} + +static const struct link_addr *first_addr(const struct link *link, int family) { + for (int i = 0; i < link->addr_count; i++) { + if (link->addrs[i].family == family) return &link->addrs[i]; + } + return NULL; +} + +static void reply_link(struct nl_reply *out, const struct link *link, int loopback, + uint32_t seq, uint16_t flags) { + struct ifinfomsg info; + const char *name; + unsigned mtu; + unsigned char state = IF_OPER_UP; + unsigned char *message; + memset(&info, 0, sizeof(info)); + info.ifi_family = AF_UNSPEC; + info.ifi_type = loopback ? ARPHRD_LOOPBACK : ARPHRD_ETHER; + info.ifi_index = loopback ? LO_INDEX : (link ? (int) link->index : 2); + info.ifi_flags = IFF_UP | IFF_RUNNING | IFF_LOWER_UP + | (loopback ? IFF_LOOPBACK : (IFF_BROADCAST | IFF_MULTICAST)); + info.ifi_change = 0xffffffff; + message = reply_start(out, RTM_NEWLINK, flags, seq, sizeof(info)); + if (message == NULL) return; + memcpy(NLMSG_DATA((struct nlmsghdr *) message), &info, sizeof(info)); + name = loopback ? LO_NAME : (link ? link->name : "eth0"); + mtu = loopback ? LO_MTU : (unsigned) (link ? link->mtu : 1500); + reply_attr(out, message, IFLA_IFNAME, name, strlen(name) + 1); + reply_attr(out, message, IFLA_MTU, &mtu, sizeof(mtu)); + reply_attr(out, message, IFLA_OPERSTATE, &state, sizeof(state)); + if (!loopback && link && (link->mac[0] | link->mac[1] | link->mac[2] + | link->mac[3] | link->mac[4] | link->mac[5])) { + reply_attr(out, message, IFLA_ADDRESS, link->mac, 6); + } +} + +static void reply_addr(struct nl_reply *out, const struct link_addr *addr, unsigned index, + int loopback, uint32_t seq, uint16_t flags) { + struct ifaddrmsg info; + int size = addr->family == AF_INET ? 4 : 16; + unsigned char *message; + memset(&info, 0, sizeof(info)); + info.ifa_family = (unsigned char) addr->family; + info.ifa_prefixlen = (unsigned char) addr->prefix; + info.ifa_flags = IFA_F_PERMANENT; + info.ifa_scope = (unsigned char) (loopback ? RT_SCOPE_HOST + : (is_link_local(addr) ? RT_SCOPE_LINK : RT_SCOPE_UNIVERSE)); + info.ifa_index = index; + message = reply_start(out, RTM_NEWADDR, flags, seq, sizeof(info)); + if (message == NULL) return; + memcpy(NLMSG_DATA((struct nlmsghdr *) message), &info, sizeof(info)); + reply_attr(out, message, IFA_LOCAL, addr->bytes, size); + reply_attr(out, message, IFA_ADDRESS, addr->bytes, size); + if (!loopback && addr->family == AF_INET && addr->prefix <= 30) { + unsigned char broadcast[4]; + broadcast_of(addr, broadcast); + reply_attr(out, message, IFA_BROADCAST, broadcast, 4); + } +} + +static void reply_route(struct nl_reply *out, int family, int destination_length, + const unsigned char *destination, const unsigned char *gateway, + const unsigned char *source, unsigned index, int protocol, int scope, + int type, uint32_t seq, uint16_t flags) { + struct rtmsg info; + int size = family == AF_INET ? 4 : 16; + unsigned char *message; + memset(&info, 0, sizeof(info)); + info.rtm_family = (unsigned char) family; + info.rtm_dst_len = (unsigned char) destination_length; + info.rtm_table = type == RTN_LOCAL ? RT_TABLE_LOCAL : RT_TABLE_MAIN; + info.rtm_protocol = (unsigned char) protocol; + info.rtm_scope = (unsigned char) scope; + info.rtm_type = (unsigned char) type; + message = reply_start(out, RTM_NEWROUTE, flags, seq, sizeof(info)); + if (message == NULL) return; + memcpy(NLMSG_DATA((struct nlmsghdr *) message), &info, sizeof(info)); + if (destination_length > 0 && destination) reply_attr(out, message, RTA_DST, destination, size); + if (gateway) reply_attr(out, message, RTA_GATEWAY, gateway, size); + if (source) reply_attr(out, message, RTA_PREFSRC, source, size); + reply_attr(out, message, RTA_OIF, &index, sizeof(index)); +} + +static void reply_addrs(struct nl_reply *out, const struct link *link, int family, uint32_t seq) { + if (family == AF_UNSPEC || family == AF_INET) + reply_addr(out, &LO_V4, LO_INDEX, 1, seq, NLM_F_MULTI); + if (family == AF_UNSPEC || family == AF_INET6) + reply_addr(out, &LO_V6, LO_INDEX, 1, seq, NLM_F_MULTI); + if (link == NULL) return; + for (int i = 0; i < link->addr_count; i++) { + if (family != AF_UNSPEC && link->addrs[i].family != family) continue; + reply_addr(out, &link->addrs[i], link->index, 0, seq, NLM_F_MULTI); + } +} + +static void reply_routes(struct nl_reply *out, const struct link *link, int family, uint32_t seq) { + if (link == NULL) return; + for (int pass = 0; pass < 2; pass++) { + int current = pass == 0 ? AF_INET : AF_INET6; + const struct link_addr *source; + if (family != AF_UNSPEC && family != current) continue; + source = first_addr(link, current); + for (int i = 0; i < link->gateway_count; i++) { + if (link->gateways[i].family != current) continue; + reply_route(out, current, 0, NULL, link->gateways[i].bytes, + source ? source->bytes : NULL, link->index, RTPROT_STATIC, + RT_SCOPE_UNIVERSE, RTN_UNICAST, seq, NLM_F_MULTI); + } + for (int i = 0; i < link->addr_count; i++) { + unsigned char network[16]; + if (link->addrs[i].family != current) continue; + network_of(&link->addrs[i], network); + reply_route(out, current, link->addrs[i].prefix, network, NULL, + link->addrs[i].bytes, link->index, RTPROT_KERNEL, + RT_SCOPE_LINK, RTN_UNICAST, seq, NLM_F_MULTI); + } + } +} + +static const struct rtattr *request_attr(const struct nlmsghdr *request, size_t offset, int type) { + int length; + const struct rtattr *attr; + if (request->nlmsg_len < NLMSG_HDRLEN + offset) return NULL; + length = (int) (request->nlmsg_len - NLMSG_HDRLEN - offset); + attr = (const struct rtattr *) ((const unsigned char *) NLMSG_DATA(request) + offset); + for (; RTA_OK(attr, length); attr = RTA_NEXT(attr, length)) { + if ((int) attr->rta_type == type) return attr; + } + return NULL; +} + +static int address_matches(const unsigned char *destination, const struct link_addr *addr) { + unsigned char mask[16]; + int size = addr->family == AF_INET ? 4 : 16; + prefix_mask(addr->family, addr->prefix, mask); + for (int index = 0; index < size; index++) { + if ((destination[index] & mask[index]) != (addr->bytes[index] & mask[index])) return 0; + } + return 1; +} + +static int reply_route_get(struct nl_reply *out, const struct link *link, + const struct nlmsghdr *request) { + if (request->nlmsg_len < NLMSG_LENGTH(sizeof(struct rtmsg))) return -EINVAL; + const struct rtmsg *info = (const struct rtmsg *) NLMSG_DATA(request); + int family = info->rtm_family; + if (family != AF_INET && family != AF_INET6) return -EAFNOSUPPORT; + int size = family == AF_INET ? 4 : 16; + const struct rtattr *destination_attr = request_attr(request, sizeof(struct rtmsg), RTA_DST); + unsigned char zero[16] = { 0 }; + if (destination_attr && RTA_PAYLOAD(destination_attr) < (size_t) size) return -EINVAL; + const unsigned char *destination = destination_attr ? RTA_DATA(destination_attr) : zero; + const struct link_addr *loopback = family == AF_INET ? &LO_V4 : &LO_V6; + const struct link_addr *source = NULL; + const struct link_addr *gateway = NULL; + int local = address_matches(destination, loopback); + if (local) source = loopback; + for (int index = 0; link && !local && index < link->addr_count; index++) { + const struct link_addr *addr = &link->addrs[index]; + if (addr->family != family) continue; + if (memcmp(destination, addr->bytes, size) == 0) { + source = addr; + local = 1; + break; + } + if (address_matches(destination, addr) && (!source || addr->prefix > source->prefix)) + source = addr; + } + if (source) { + reply_route(out, family, size * 8, destination, NULL, source->bytes, + local ? LO_INDEX : link->index, RTPROT_KERNEL, + local ? RT_SCOPE_HOST : RT_SCOPE_LINK, + local ? RTN_LOCAL : RTN_UNICAST, request->nlmsg_seq, 0); + return 0; + } + for (int i = 0; link && i < link->gateway_count; i++) { + if (link->gateways[i].family == family) { + gateway = &link->gateways[i]; + break; + } + } + if (gateway == NULL) return -ENETUNREACH; + source = first_addr(link, family); + for (int index = 0; index < link->addr_count; index++) { + if (link->addrs[index].family == family && !is_link_local(&link->addrs[index])) { + source = &link->addrs[index]; + break; + } + } + reply_route(out, family, size * 8, destination, + gateway->bytes, source ? source->bytes : NULL, link->index, RTPROT_STATIC, + RT_SCOPE_UNIVERSE, RTN_UNICAST, request->nlmsg_seq, 0); + return 0; +} + +static void reply_request(const struct nlmsghdr *request, const struct link *link, + struct nl_reply *out) { + int dump = (request->nlmsg_flags & NLM_F_DUMP) != 0; + int error = 0; + uint16_t flags = dump ? NLM_F_MULTI : 0; + switch (request->nlmsg_type) { + case RTM_GETLINK: { + int index = 0; + if (request->nlmsg_len >= NLMSG_LENGTH(sizeof(struct ifinfomsg))) + index = ((const struct ifinfomsg *) NLMSG_DATA(request))->ifi_index; + if (!dump && index == 0) { + const struct rtattr *name_attr = request_attr(request, sizeof(struct ifinfomsg), IFLA_IFNAME); + size_t payload = name_attr ? RTA_PAYLOAD(name_attr) : 0; + const char *data = name_attr ? RTA_DATA(name_attr) : NULL; + size_t length = payload; + if (length && data[length - 1] == '\0') length--; + if (name_attr == NULL) { + error = -EINVAL; + } else if (payload == 0 || length >= IFNAMSIZ) { + error = -ERANGE; + } else { + char name[IFNAMSIZ]; + memcpy(name, data, length); + name[length] = '\0'; + if (strcmp(name, LO_NAME) == 0) + index = LO_INDEX; + else if (link && strcmp(name, link->name) == 0) + index = (int) link->index; + else + error = -ENODEV; + } + } + if (dump) { + reply_link(out, NULL, 1, request->nlmsg_seq, flags); + if (link) reply_link(out, link, 0, request->nlmsg_seq, flags); + reply_done(out, request->nlmsg_seq); + } else if (!error && (index == LO_INDEX || (link && index == (int) link->index))) { + reply_link(out, link, index == LO_INDEX, request->nlmsg_seq, 0); + } else if (!error) { + error = -ENODEV; + } + break; + } + case RTM_GETADDR: { + int family = AF_UNSPEC; + if (request->nlmsg_len >= NLMSG_LENGTH(sizeof(struct ifaddrmsg))) + family = ((const struct ifaddrmsg *) NLMSG_DATA(request))->ifa_family; + if (dump) { + reply_addrs(out, link, family, request->nlmsg_seq); + reply_done(out, request->nlmsg_seq); + } else { + error = -EOPNOTSUPP; + } + break; + } + case RTM_GETROUTE: { + int family = AF_UNSPEC; + if (request->nlmsg_len >= NLMSG_LENGTH(sizeof(struct rtmsg))) + family = ((const struct rtmsg *) NLMSG_DATA(request))->rtm_family; + if (dump) { + reply_routes(out, link, family, request->nlmsg_seq); + reply_done(out, request->nlmsg_seq); + } else { + error = reply_route_get(out, link, request); + } + break; + } + case RTM_GETNEIGH: + if (dump) reply_done(out, request->nlmsg_seq); + else error = -EOPNOTSUPP; + break; + default: + error = -EPERM; + break; + } + if (error || (!dump && (request->nlmsg_flags & NLM_F_ACK))) + reply_error(out, request, error); +} + +static void build_reply(const void *data, size_t len, struct nl_reply *out) { + struct link link; + int have = load_link(&link); + size_t offset = 0; + out->len = 0; + out->overflow = 0; + while (offset + sizeof(struct nlmsghdr) <= len) { + const struct nlmsghdr *request = + (const struct nlmsghdr *) ((const unsigned char *) data + offset); + if (request->nlmsg_len < sizeof(struct nlmsghdr) || offset + request->nlmsg_len > len) + break; + reply_request(request, have ? &link : NULL, out); + offset += NLMSG_ALIGN(request->nlmsg_len); + } +} + +static ssize_t send_raw(int fd, const void *data, size_t len, int extra) { + static ssize_t (*real)(int, const void *, size_t, int); + if (real == NULL) real = (ssize_t (*)(int, const void *, size_t, int)) dlsym(RTLD_NEXT, "send"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, data, len, MSG_NOSIGNAL | extra); +} + +static int deliver(int fd, const void *data, size_t len, int flags, ssize_t *rc) { + struct nl_reply reply; + int peer; + int extra = 0; + if (nl_peer_of(fd) < 0) return 0; + if (nl_autobind(fd) != 0) { + *rc = -1; + return 1; + } + if (nl_peer_of(fd) < 0) { + errno = EBADF; + *rc = -1; + return 1; + } + peer = nl_dup_peer_of(fd, &nl_reply_port, &nl_reply_capped); + if (peer < 0) { + *rc = -1; + return 1; + } + build_reply(data, len, &reply); + if (reply.overflow) { + int saved = EMSGSIZE; + close(peer); + errno = saved; + *rc = -1; + return 1; + } + if (reply.len == 0) { + struct nlmsghdr *request = (struct nlmsghdr *) data; + if (len < sizeof(struct nlmsghdr)) { + int saved = EINVAL; + close(peer); + errno = saved; + *rc = -1; + return 1; + } + reply.len = 0; + nl_reply_capped = 1; + reply_error(&reply, request, -EOPNOTSUPP); + } + if ((flags & MSG_DONTWAIT) || nl_nonblocking(fd)) extra = MSG_DONTWAIT; + *rc = send_raw(peer, reply.data, reply.len, extra) < 0 ? -1 : (ssize_t) len; + int saved = errno; + close(peer); + errno = saved; + return 1; +} + +static int collect(const struct msghdr *msg, unsigned char *small, size_t capacity, + unsigned char **buffer, size_t *length) { + size_t used = 0; + if (msg == NULL || (msg->msg_iovlen && msg->msg_iov == NULL)) { + errno = EFAULT; + return 0; + } + if (msg->msg_iovlen > IOV_MAX) { + errno = EMSGSIZE; + return 0; + } + for (size_t index = 0; index < msg->msg_iovlen; index++) { + const struct iovec *part = &msg->msg_iov[index]; + if (part->iov_len && part->iov_base == NULL) { + errno = EFAULT; + return 0; + } + if (part->iov_len > (size_t) SSIZE_MAX - used) { + errno = EMSGSIZE; + return 0; + } + used += part->iov_len; + } + if (used == 0) { + errno = EINVAL; + return 0; + } + *buffer = used <= capacity ? small : malloc(used); + if (*buffer == NULL) { + errno = ENOMEM; + return 0; + } + *length = used; + used = 0; + for (size_t index = 0; index < msg->msg_iovlen; index++) { + const struct iovec *part = &msg->msg_iov[index]; + if (part->iov_len) memcpy(*buffer + used, part->iov_base, part->iov_len); + used += part->iov_len; + } + return 1; +} + +static ssize_t sendmsg_request(int fd, const struct msghdr *msg, int flags) { + unsigned char small[NL_REQUEST_MAX]; + unsigned char *buffer; + size_t length = 0; + if (!collect(msg, small, sizeof(small), &buffer, &length)) { + return -1; + } + ssize_t result; + int handled = deliver(fd, buffer, length, flags, &result); + int saved = errno; + if (buffer != small) free(buffer); + if (!handled) { + saved = EBADF; + result = -1; + } + errno = saved; + return result; +} + +ssize_t sendmsg(int fd, const struct msghdr *msg, int flags) { + static ssize_t (*real)(int, const struct msghdr *, int); + if (bl_nl_owns(fd)) { + int error = msg && msg->msg_name ? nl_destination(msg->msg_name, msg->msg_namelen) : 0; + if (error) { + errno = -error; + return -1; + } + return sendmsg_request(fd, msg, flags); + } + if (real == NULL) real = (ssize_t (*)(int, const struct msghdr *, int)) dlsym(RTLD_NEXT, "sendmsg"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, msg, flags); +} + +ssize_t sendto(int fd, const void *buffer, size_t length, int flags, + const struct sockaddr *addr, socklen_t addrlen) { + static ssize_t (*real)(int, const void *, size_t, int, const struct sockaddr *, socklen_t); + ssize_t rc; + if (bl_nl_owns(fd)) { + int error = addr ? nl_destination(addr, addrlen) : 0; + if (error) { + errno = -error; + return -1; + } + if (deliver(fd, buffer, length, flags, &rc)) return rc; + } + if (real == NULL) + real = (ssize_t (*)(int, const void *, size_t, int, const struct sockaddr *, socklen_t)) + dlsym(RTLD_NEXT, "sendto"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, buffer, length, flags, addr, addrlen); +} + +ssize_t send(int fd, const void *buffer, size_t length, int flags) { + static ssize_t (*real)(int, const void *, size_t, int); + ssize_t rc; + if (bl_nl_owns(fd) && deliver(fd, buffer, length, flags, &rc)) return rc; + if (real == NULL) real = (ssize_t (*)(int, const void *, size_t, int)) dlsym(RTLD_NEXT, "send"); + if (real == NULL) { + errno = ENOSYS; + return -1; + } + return real(fd, buffer, length, flags); +} diff --git a/tools/linuxfs/preload/ntsync.c b/tools/linuxfs/preload/ntsync.c index 7454ce15d6..6e012e3b6b 100644 --- a/tools/linuxfs/preload/ntsync.c +++ b/tools/linuxfs/preload/ntsync.c @@ -1442,16 +1442,25 @@ static void ns_received(struct msghdr *msg) { int bl_udevmon_recvmsg(int fd, struct msghdr *msg, int flags, ssize_t (*real_recvmsg)(int, struct msghdr *, int), ssize_t *result) __attribute__((visibility("hidden"))); +int bl_nl_recvmsg(int fd, struct msghdr *msg, int flags, ssize_t (*real_recvmsg)(int, struct msghdr *, int), + ssize_t *result) __attribute__((visibility("hidden"))); +void bl_nl_received(struct msghdr *msg) __attribute__((visibility("hidden"))); +void bl_nl_closed(int fd) __attribute__((visibility("hidden"))); +void bl_nl_range_closed(unsigned int first, unsigned int last) __attribute__((visibility("hidden"))); +int bl_nl_before_dup(int fd, void **state) __attribute__((visibility("hidden"))); +void bl_nl_after_dup(void *state, int fd) __attribute__((visibility("hidden"))); ssize_t recvmsg(int fd, struct msghdr *msg, int flags) { static ssize_t (*real)(int, struct msghdr *, int); if (!real) real = (ssize_t (*)(int, struct msghdr *, int))dlsym(RTLD_NEXT, "recvmsg"); ssize_t answered; + if (msg && bl_nl_recvmsg(fd, msg, flags, real, &answered)) return answered; if (msg && bl_udevmon_recvmsg(fd, msg, flags, real, &answered)) return answered; ssize_t r = real(fd, msg, flags); - if (r >= 0 && msg && msg->msg_control && msg->msg_controllen && ns_on()) { + if (r >= 0 && msg && msg->msg_control && msg->msg_controllen) { int saved = errno; - ns_received(msg); + bl_nl_received(msg); + if (ns_on()) ns_received(msg); errno = saved; } return r; @@ -1465,6 +1474,7 @@ int close(int fd) { if (fd >= 0) bl_fsync_fds_closed((unsigned int)fd, (unsigned int)fd); bl_venc_closed(fd); bl_vdec_closed(fd); + bl_nl_closed(fd); uint64_t *t = __atomic_load_n(&ns_fdt, __ATOMIC_ACQUIRE); if (t && fd >= 0 && fd < NS_FDS && __atomic_load_n(&t[fd], __ATOMIC_ACQUIRE)) ns_forget(fd); int saved = errno; @@ -1480,19 +1490,29 @@ int close(int fd) { int dup2(int oldfd, int newfd) { static int (*real)(int, int); if (!real) real = (int (*)(int, int))dlsym(RTLD_NEXT, "dup2"); + if (oldfd == newfd) return real(oldfd, newfd); + void *nl_state; + if (bl_nl_before_dup(oldfd, &nl_state) != 0) return -1; if (oldfd != newfd && newfd >= 0) bl_fsync_fds_closed((unsigned int)newfd, (unsigned int)newfd); uint64_t *t = __atomic_load_n(&ns_fdt, __ATOMIC_ACQUIRE); if (t && oldfd != newfd && newfd >= 0 && newfd < NS_FDS && __atomic_load_n(&t[newfd], __ATOMIC_ACQUIRE)) ns_forget(newfd); - return real(oldfd, newfd); + int result = real(oldfd, newfd); + bl_nl_after_dup(nl_state, result); + return result; } int dup3(int oldfd, int newfd, int flags) { static int (*real)(int, int, int); if (!real) real = (int (*)(int, int, int))dlsym(RTLD_NEXT, "dup3"); + if (oldfd == newfd) return real(oldfd, newfd, flags); + void *nl_state; + if (bl_nl_before_dup(oldfd, &nl_state) != 0) return -1; if (oldfd != newfd && newfd >= 0) bl_fsync_fds_closed((unsigned int)newfd, (unsigned int)newfd); uint64_t *t = __atomic_load_n(&ns_fdt, __ATOMIC_ACQUIRE); if (t && oldfd != newfd && newfd >= 0 && newfd < NS_FDS && __atomic_load_n(&t[newfd], __ATOMIC_ACQUIRE)) ns_forget(newfd); - return real(oldfd, newfd, flags); + int result = real(oldfd, newfd, flags); + bl_nl_after_dup(nl_state, result); + return result; } static void ns_forget_range(unsigned int first, unsigned int last) { @@ -1513,7 +1533,9 @@ int close_range(unsigned int first, unsigned int last, int flags) { errno = ENOSYS; return -1; } - return real(first, last, flags); + int result = real(first, last, flags); + if (result == 0 && !(flags & CLOSE_RANGE_CLOEXEC)) bl_nl_range_closed(first, last); + return result; } void closefrom(int lowfd) { @@ -1523,7 +1545,10 @@ void closefrom(int lowfd) { bl_fsync_fds_closed((unsigned int)lowfd, ~0u); ns_forget_range((unsigned int)lowfd, ~0u); } - if (real) real(lowfd); + if (real) { + real(lowfd); + if (lowfd >= 0) bl_nl_range_closed((unsigned int)lowfd, ~0u); + } } static void ns_fork_prepare(void) { diff --git a/tools/linuxfs/preload/udevmon.c b/tools/linuxfs/preload/udevmon.c index f0e171a863..2d4e9bf70d 100644 --- a/tools/linuxfs/preload/udevmon.c +++ b/tools/linuxfs/preload/udevmon.c @@ -102,6 +102,21 @@ static int make_stand_in(int type) { return -1; } +__attribute__((visibility("hidden"))) int bl_nl_socket(int type, int *fd); +__attribute__((visibility("hidden"))) int bl_nl_owns(int fd); +__attribute__((visibility("hidden"))) int bl_nl_getsockname(int fd, struct sockaddr *addr, + socklen_t *len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_getpeername(int fd, struct sockaddr *addr, + socklen_t *len, int *rc); +__attribute__((visibility("hidden"))) int bl_nl_setsockopt(int fd, int level, int option, + const void *value, socklen_t len, + int (*real)(int, int, int, const void *, socklen_t), + int *rc); +__attribute__((visibility("hidden"))) int bl_nl_getsockopt(int fd, int level, int option, + void *value, socklen_t *len, + int (*real)(int, int, int, void *, socklen_t *), + int *rc); + int socket(int domain, int type, int protocol) { static int (*real_socket)(int, int, int); int fd; @@ -111,6 +126,11 @@ int socket(int domain, int type, int protocol) { errno = ENOSYS; return -1; } + if (domain == AF_NETLINK && protocol == NETLINK_ROUTE) { + int route_fd; + bl_nl_socket(type, &route_fd); + return route_fd; + } fd = real_socket(domain, type, protocol); if (fd >= 0 || domain != AF_NETLINK || protocol != NETLINK_KOBJECT_UEVENT) return fd; @@ -129,7 +149,9 @@ __attribute__((visibility("hidden"))) int bl_udevmon_stand_in(int fd) { int getsockname(int fd, struct sockaddr *addr, socklen_t *len) { static int (*real_getsockname)(int, struct sockaddr *, socklen_t *); struct sockaddr_nl nl; + int route_rc; + if (bl_nl_getsockname(fd, addr, len, &route_rc)) return route_rc; if (is_stand_in(fd)) { if (addr == NULL || len == NULL) { errno = EFAULT; @@ -150,21 +172,43 @@ int getsockname(int fd, struct sockaddr *addr, socklen_t *len) { return real_getsockname(fd, addr, len); } +int getpeername(int fd, struct sockaddr *addr, socklen_t *len) { + static int (*real)(int, struct sockaddr *, socklen_t *); + int route_rc; + if (bl_nl_getpeername(fd, addr, len, &route_rc)) return route_rc; + if (real == NULL) real = dlsym(RTLD_NEXT, "getpeername"); + return real(fd, addr, len); +} + int setsockopt(int fd, int level, int optname, const void *optval, socklen_t optlen) { static int (*real_setsockopt)(int, int, int, const void *, socklen_t); + int route_rc; + if (real_setsockopt == NULL) real_setsockopt = dlsym(RTLD_NEXT, "setsockopt"); + if (real_setsockopt == NULL) { + errno = ENOSYS; + return -1; + } + if (bl_nl_setsockopt(fd, level, optname, optval, optlen, real_setsockopt, &route_rc)) return route_rc; if (is_stand_in(fd)) { if (level == SOL_NETLINK) return 0; if (level == SOL_SOCKET && (optname == SO_ATTACH_FILTER || optname == SO_DETACH_FILTER)) return 0; } - if (real_setsockopt == NULL) real_setsockopt = dlsym(RTLD_NEXT, "setsockopt"); - if (real_setsockopt == NULL) { + return real_setsockopt(fd, level, optname, optval, optlen); +} + +int getsockopt(int fd, int level, int option, void *value, socklen_t *len) { + static int (*real)(int, int, int, void *, socklen_t *); + int route_rc; + if (real == NULL) real = dlsym(RTLD_NEXT, "getsockopt"); + if (real == NULL) { errno = ENOSYS; return -1; } - return real_setsockopt(fd, level, optname, optval, optlen); + if (bl_nl_getsockopt(fd, level, option, value, len, real, &route_rc)) return route_rc; + return real(fd, level, option, value, len); } struct monitor_netlink_header { diff --git a/tools/tests/netlink_stubs.c b/tools/tests/netlink_stubs.c new file mode 100644 index 0000000000..58ba3bc61c --- /dev/null +++ b/tools/tests/netlink_stubs.c @@ -0,0 +1,59 @@ +#include +#include + +int bl_nl_socket(int type, int *fd) { + (void)type; + *fd = -1; + errno = ENOSYS; + return 1; +} + +int bl_nl_owns(int fd) { + (void)fd; + return 0; +} + +int bl_nl_bind(int fd, const struct sockaddr *addr, socklen_t len, int *rc) { + (void)fd; + (void)addr; + (void)len; + (void)rc; + return 0; +} + +int bl_nl_connect(int fd, const struct sockaddr *addr, socklen_t len, int *rc) { + return bl_nl_bind(fd, addr, len, rc); +} + +int bl_nl_getsockname(int fd, struct sockaddr *addr, socklen_t *len, int *rc) { + (void)len; + return bl_nl_bind(fd, addr, 0, rc); +} + +int bl_nl_getpeername(int fd, struct sockaddr *addr, socklen_t *len, int *rc) { + return bl_nl_getsockname(fd, addr, len, rc); +} + +int bl_nl_setsockopt(int fd, int level, int option, const void *value, socklen_t len, + int (*real)(int, int, int, const void *, socklen_t), int *rc) { + (void)fd; + (void)level; + (void)option; + (void)value; + (void)len; + (void)real; + (void)rc; + return 0; +} + +int bl_nl_getsockopt(int fd, int level, int option, void *value, socklen_t *len, + int (*real)(int, int, int, void *, socklen_t *), int *rc) { + (void)fd; + (void)level; + (void)option; + (void)value; + (void)len; + (void)real; + (void)rc; + return 0; +} diff --git a/tools/tests/test_binfmt_preload.py b/tools/tests/test_binfmt_preload.py index 2a7ed72769..063345edb2 100644 --- a/tools/tests/test_binfmt_preload.py +++ b/tools/tests/test_binfmt_preload.py @@ -60,7 +60,8 @@ class BinfmtPreloadTest(unittest.TestCase): cls.library = cls.tmp / "libbinfmt.so" subprocess.run(["gcc", "-shared", "-fPIC", "-O2", "-Wall", "-Wextra", "-Werror", "-DBINFMT_TEST", '-DBINFMT_HANDLER="%s"' % cls.handler, "-o", str(cls.library), - "-pthread"] + [str(PRELOAD / name) for name in ("binfmt.c", "net.c", "udevmon.c", "pathcache.c", "perms.c", "webhelper.c")] + ["-ldl"], + "-pthread"] + [str(PRELOAD / name) for name in ("binfmt.c", "net.c", "udevmon.c", "pathcache.c", "perms.c", "webhelper.c")] + + [str(Path(__file__).with_name("netlink_stubs.c")), "-ldl"], check=True) source = cls.tmp / "program.c" source.write_text(PROGRAM) diff --git a/tools/tests/test_cdp_guard.py b/tools/tests/test_cdp_guard.py index 48196c1679..8185abed8a 100644 --- a/tools/tests/test_cdp_guard.py +++ b/tools/tests/test_cdp_guard.py @@ -16,7 +16,8 @@ class CdpGuardTest(unittest.TestCase): def setUpClass(cls): cls.build = tempfile.TemporaryDirectory() cls.library = Path(cls.build.name) / "net.so" - subprocess.run(["cc", "-shared", "-fPIC", "-O2", str(SOURCE), str(SOURCE.parent / "binfmt.c"), str(SOURCE.parent / "webhelper.c"), "-x", "c", "-", "-ldl", + subprocess.run(["cc", "-shared", "-fPIC", "-O2", str(SOURCE), str(SOURCE.parent / "binfmt.c"), str(SOURCE.parent / "webhelper.c"), + str(Path(__file__).with_name("netlink_stubs.c")), "-x", "c", "-", "-ldl", "-o", str(cls.library)], input=b"int bl_udevmon_stand_in(int fd) { return 0; }", check=True, capture_output=True) diff --git a/tools/tests/test_netlink_preload.py b/tools/tests/test_netlink_preload.py new file mode 100644 index 0000000000..64c3b9c97a --- /dev/null +++ b/tools/tests/test_netlink_preload.py @@ -0,0 +1,1238 @@ +import errno +import os +from pathlib import Path +import shutil +import subprocess +import sys +import tempfile +import unittest + +PRELOAD = Path(__file__).resolve().parents[1] / "linuxfs/preload" + +SHIM = r""" +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef SYS_close_range +#define SYS_close_range 436 +#endif + +static pthread_mutex_t *netlink_mutex; +static __thread int probe_mode; +static __thread unsigned probe_counts[5]; + +void test_probe_begin(int capture) { + memset(probe_counts, 0, sizeof(probe_counts)); + probe_mode = capture ? 1 : 2; +} + +void test_probe_end(unsigned *counts) { + probe_mode = 0; + memcpy(counts, probe_counts, sizeof(probe_counts)); +} + +int pthread_mutex_lock(pthread_mutex_t *mutex) { + static int (*real)(pthread_mutex_t *); + if (!real) real = dlsym(RTLD_NEXT, "pthread_mutex_lock"); + if (probe_mode == 1) netlink_mutex = mutex; + if (probe_mode == 2 && mutex == netlink_mutex) probe_counts[0]++; + return real(mutex); +} + +int getsockname(int fd, struct sockaddr *addr, socklen_t *len) { + static int (*real)(int, struct sockaddr *, socklen_t *); + if (!real) real = dlsym(RTLD_NEXT, "getsockname"); + if (probe_mode == 2) probe_counts[1]++; + return real(fd, addr, len); +} + +int getpeername(int fd, struct sockaddr *addr, socklen_t *len) { + static int (*real)(int, struct sockaddr *, socklen_t *); + if (!real) real = dlsym(RTLD_NEXT, "getpeername"); + if (probe_mode == 2) probe_counts[2]++; + return real(fd, addr, len); +} + +int fstat(int fd, struct stat *status) { + static int (*real)(int, struct stat *); + if (!real) real = dlsym(RTLD_NEXT, "fstat"); + if (probe_mode == 2) probe_counts[3]++; + return real(fd, status); +} + +#ifdef __GLIBC__ +int __fxstat(int version, int fd, struct stat *status) { + static int (*real)(int, int, struct stat *); + if (!real) real = dlsym(RTLD_NEXT, "__fxstat"); + if (probe_mode == 2) probe_counts[3]++; + return real(version, fd, status); +} +#endif + +int getsockopt(int fd, int level, int option, void *value, socklen_t *len) { + static int (*real)(int, int, int, void *, socklen_t *); + if (!real) real = dlsym(RTLD_NEXT, "getsockopt"); + if (probe_mode == 2) probe_counts[4]++; + return real(fd, level, option, value, len); +} + +FILE *fopen(const char *path, const char *mode) { + static FILE *(*real)(const char *, const char *); + if (!real) real = dlsym(RTLD_NEXT, "fopen"); + const char *snapshot = getenv("NETLINK_TEST_SNAPSHOT"); + if (snapshot && !strcmp(path, "/etc/droiddeck-net")) path = snapshot; + return real(path, mode); +} + +int close_range(unsigned int first, unsigned int last, int flags) { + return syscall(SYS_close_range, (long)first, (long)last, (long)flags, 0L, 0L, 0L); +} + +void closefrom(int first) { + syscall(SYS_close_range, (long)first, (long)~0u, 0L, 0L, 0L, 0L); +} +""" + +PROGRAM = r""" +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +static void require(int condition, const char *label) { + if (!condition) { + fprintf(stderr, "%s: errno=%d\n", label, errno); + exit(1); + } +} + +static int route_socket(void) { + int descriptor = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + struct sockaddr_nl address = {.nl_family = AF_NETLINK}; + require(descriptor >= 0, "socket"); + require(bind(descriptor, (struct sockaddr *)&address, sizeof(address)) == 0, "bind"); + return descriptor; +} + +static unsigned port_of(int descriptor) { + struct sockaddr_nl address; + socklen_t length = sizeof(address); + require(getsockname(descriptor, (struct sockaddr *)&address, &length) == 0, "getsockname"); + require(length == sizeof(address) && address.nl_family == AF_NETLINK, "socket identity"); + return address.nl_pid; +} + +static void send_link(int descriptor, int index, unsigned flags) { + struct { + struct nlmsghdr header; + struct ifinfomsg info; + } query = { + .header = {.nlmsg_len = sizeof(query), .nlmsg_type = RTM_GETLINK, + .nlmsg_flags = NLM_F_REQUEST | flags, .nlmsg_seq = 42}, + .info = {.ifi_index = index} + }; + struct sockaddr_nl destination = {.nl_family = AF_NETLINK}; + require(sendto(descriptor, &query, sizeof(query), 0, + (struct sockaddr *)&destination, sizeof(destination)) == sizeof(query), "send link"); +} + +struct autobind_sender { + int descriptor; + pthread_barrier_t *barrier; +}; + +static ssize_t receive(int descriptor, unsigned char *buffer, size_t capacity); + +static void *send_after_barrier(void *argument) { + struct autobind_sender *sender = argument; + int result = pthread_barrier_wait(sender->barrier); + require(result == 0 || result == PTHREAD_BARRIER_SERIAL_THREAD, "autobind barrier"); + send_link(sender->descriptor, 1, NLM_F_ACK); + return NULL; +} + +static void autobind_race_test(void) { + for (int round = 0; round < 50; round++) { + int descriptor = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + require(descriptor >= 0 && port_of(descriptor) == 0, "unbound netlink socket"); + pthread_barrier_t barrier; + require(pthread_barrier_init(&barrier, NULL, 2) == 0, "autobind barrier init"); + struct autobind_sender sender = {.descriptor = descriptor, .barrier = &barrier}; + pthread_t first, second; + require(pthread_create(&first, NULL, send_after_barrier, &sender) == 0, "autobind first thread"); + require(pthread_create(&second, NULL, send_after_barrier, &sender) == 0, "autobind second thread"); + require(pthread_join(first, NULL) == 0 && pthread_join(second, NULL) == 0, "autobind threads"); + require(pthread_barrier_destroy(&barrier) == 0, "autobind barrier destroy"); + require(port_of(descriptor) != 0, "concurrent autobind assigned one port"); + close(descriptor); + } +} + +static void vfork_close_range_test(void) { + int descriptor = route_socket(); + pid_t child = vfork(); + require(child >= 0, "vfork"); + if (child == 0) { + _exit(close_range(3, ~0u, 0) == 0 ? 0 : 1); + } + int status; + require(waitpid(child, &status, 0) == child && WIFEXITED(status) && WEXITSTATUS(status) == 0, + "vfork close range child"); + send_link(descriptor, 1, NLM_F_ACK); + unsigned char buffer[4096]; + ssize_t received = receive(descriptor, buffer, sizeof(buffer)); + require(received > 0 && ((struct nlmsghdr *) buffer)->nlmsg_type == RTM_NEWLINK, + "netlink bookkeeping survives vfork close range"); + close(descriptor); +} + +static void named_link_test(const char *name, const char *mode) { + int descriptor = route_socket(); + struct { + struct nlmsghdr header; + struct ifinfomsg info; + struct rtattr attr; + char name[IFNAMSIZ + 1]; + } query = { + .header = {.nlmsg_type = RTM_GETLINK, .nlmsg_flags = NLM_F_REQUEST, .nlmsg_seq = 42}, + .attr = {.rta_type = IFLA_IFNAME} + }; + size_t length = strlen(name) + 1; + require(length <= sizeof(query.name), "name length"); + memcpy(query.name, name, length); + if (!strcmp(mode, "unterminated")) length--; + if (!strcmp(mode, "oversized")) { + memset(query.name, 'x', sizeof(query.name)); + query.name[sizeof(query.name) - 1] = '\0'; + length = sizeof(query.name); + } + query.attr.rta_len = RTA_LENGTH(length); + query.header.nlmsg_len = NLMSG_LENGTH(sizeof(query.info)) + RTA_SPACE(length); + if (!strcmp(mode, "missing")) query.header.nlmsg_len = NLMSG_LENGTH(sizeof(query.info)); + if (!strcmp(mode, "index")) query.info.ifi_index = 1; + struct sockaddr_nl destination = {.nl_family = AF_NETLINK}; + require(sendto(descriptor, &query, query.header.nlmsg_len, 0, + (struct sockaddr *)&destination, sizeof(destination)) == query.header.nlmsg_len, + "send named link"); + unsigned char buffer[4096]; + require(recv(descriptor, buffer, sizeof(buffer), MSG_DONTWAIT) > 0, "receive named link"); + struct nlmsghdr *header = (struct nlmsghdr *)buffer; + require(header->nlmsg_seq == 42, "named link sequence"); + if (header->nlmsg_type == NLMSG_ERROR) { + printf("error %d\n", ((struct nlmsgerr *)NLMSG_DATA(header))->error); + } else { + require(header->nlmsg_type == RTM_NEWLINK, "named link reply"); + struct ifinfomsg *info = NLMSG_DATA(header); + int remaining = IFLA_PAYLOAD(header); + const char *reply_name = NULL; + for (struct rtattr *attr = IFLA_RTA(info); RTA_OK(attr, remaining); + attr = RTA_NEXT(attr, remaining)) { + if (attr->rta_type == IFLA_IFNAME) reply_name = RTA_DATA(attr); + } + require(reply_name != NULL, "reply interface name"); + printf("link %d %s\n", info->ifi_index, reply_name); + } + close(descriptor); +} + +static ssize_t receive(int descriptor, unsigned char *buffer, size_t capacity) { + struct sockaddr_nl address; + memset(&address, 0xff, sizeof(address)); + socklen_t length = sizeof(address); + ssize_t received = recvfrom(descriptor, buffer, capacity, MSG_DONTWAIT, + (struct sockaddr *)&address, &length); + require(received > 0, "recvfrom"); + require(length == sizeof(address) && address.nl_family == AF_NETLINK && address.nl_pid == 0, + "kernel source"); + return received; +} + +static void usable(int descriptor) { + send_link(descriptor, 1, 0); + unsigned port = port_of(descriptor); + unsigned char buffer[4096]; + receive(descriptor, buffer, sizeof(buffer)); + struct nlmsghdr *header = (struct nlmsghdr *)buffer; + require(header->nlmsg_type == RTM_NEWLINK && header->nlmsg_pid == port, "usable socket"); +} + +static void socket_info(int descriptor, int kind) { + int value; + socklen_t length = sizeof(value); + require(getsockopt(descriptor, SOL_SOCKET, SO_TYPE, &value, &length) == 0 + && length == sizeof(value) && value == kind, "reported socket type"); + length = sizeof(value); + require(getsockopt(descriptor, SOL_SOCKET, SO_DOMAIN, &value, &length) == 0 + && value == AF_NETLINK, "reported socket domain"); + length = sizeof(value); + require(getsockopt(descriptor, SOL_SOCKET, SO_PROTOCOL, &value, &length) == 0 + && value == NETLINK_ROUTE, "reported socket protocol"); + length = 1; + require(getsockopt(descriptor, SOL_SOCKET, SO_TYPE, &value, &length) == 0 + && length == 1, "short socket option"); + require(getsockopt(descriptor, SOL_SOCKET, SO_TYPE, NULL, &length) == -1 + && errno == EFAULT, "invalid socket option buffer"); +} + +static void (*probe_begin)(int); +static void (*probe_end)(unsigned *); + +static void *ordinary_traffic(void *argument) { + int kind = (int)(uintptr_t)argument; + unsigned counts[5]; + probe_begin(0); + int listener = socket(AF_INET, kind, 0); + int client = socket(AF_INET, kind, 0); + require(listener >= 0 && client >= 0, "ordinary sockets"); + struct sockaddr_in address = {.sin_family = AF_INET, .sin_addr.s_addr = htonl(INADDR_LOOPBACK)}; + require(bind(listener, (struct sockaddr *)&address, sizeof(address)) == 0, "ordinary bind"); + socklen_t length = sizeof(address); + require(getsockname(listener, (struct sockaddr *)&address, &length) == 0, "ordinary address"); + if (kind == SOCK_STREAM) require(listen(listener, 1) == 0, "ordinary listen"); + require(connect(client, (struct sockaddr *)&address, sizeof(address)) == 0, "ordinary connect"); + int server = kind == SOCK_STREAM ? accept(listener, NULL, NULL) : listener; + require(server >= 0, "ordinary server"); + probe_end(counts); + require(counts[0] == 0, "ordinary setup avoids netlink lock"); + + probe_begin(0); + const int rounds = 32; + for (int round = 0; round < rounds; round++) { + char buffer; + require(send(client, "x", 1, 0) == 1, "ordinary send"); + require(recv(server, &buffer, 1, 0) == 1 && buffer == 'x', "ordinary recv"); + struct sockaddr *destination = kind == SOCK_DGRAM ? (struct sockaddr *)&address : NULL; + socklen_t destination_length = destination ? sizeof(address) : 0; + require(sendto(client, "y", 1, 0, destination, destination_length) == 1, "ordinary sendto"); + struct sockaddr_storage source; + length = sizeof(source); + require(recvfrom(server, &buffer, 1, 0, (struct sockaddr *)&source, &length) == 1 + && buffer == 'y', "ordinary recvfrom"); + struct iovec part = {.iov_base = "z", .iov_len = 1}; + struct msghdr message = {.msg_name = destination, .msg_namelen = destination_length, + .msg_iov = &part, .msg_iovlen = 1}; + require(sendmsg(client, &message, 0) == 1, "ordinary sendmsg"); + part.iov_base = &buffer; + message.msg_name = &source; + message.msg_namelen = sizeof(source); + require(recvmsg(server, &message, 0) == 1 && buffer == 'z', "ordinary recvmsg"); + length = sizeof(source); + require(getpeername(client, (struct sockaddr *)&source, &length) == 0, "ordinary peer"); + const int options[] = {SO_TYPE, SO_DOMAIN, SO_PROTOCOL}; + const int expected[] = {kind, AF_INET, kind == SOCK_DGRAM ? IPPROTO_UDP : IPPROTO_TCP}; + for (size_t index = 0; index < sizeof(options) / sizeof(options[0]); index++) { + int value; + length = sizeof(value); + require(getsockopt(client, SOL_SOCKET, options[index], &value, &length) == 0 + && value == expected[index], "ordinary socket option"); + } + int enabled = 1; + require(setsockopt(client, SOL_SOCKET, SO_KEEPALIVE, &enabled, sizeof(enabled)) == 0, + "ordinary setsockopt"); + int alias = dup(client); + require(alias >= 0 && dup2(client, alias) == alias + && dup3(client, alias, O_CLOEXEC) == alias, "ordinary duplicates"); + close(alias); + alias = fcntl(client, F_DUPFD, 0); + require(alias >= 0, "ordinary fcntl duplicate"); + close(alias); + alias = fcntl(client, F_DUPFD_CLOEXEC, 0); + require(alias >= 0, "ordinary cloexec duplicate"); + close(alias); + } + probe_end(counts); + require(counts[0] == 0, "ordinary traffic avoids netlink lock"); + require(counts[1] == 0, "ordinary traffic avoids restoration getsockname"); + 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(client); + close(server); + if (server != listener) close(listener); + return NULL; +} + +static void hotpath_test(int active) { + probe_begin = dlsym(RTLD_DEFAULT, "test_probe_begin"); + probe_end = dlsym(RTLD_DEFAULT, "test_probe_end"); + require(probe_begin && probe_end, "probe symbols"); + unsigned counts[5]; + probe_begin(1); + int descriptor = route_socket(); + probe_end(counts); + if (!active) close(descriptor); + pthread_t threads[4]; + for (size_t index = 0; index < sizeof(threads) / sizeof(threads[0]); index++) { + int kind = index % 2 ? SOCK_STREAM : SOCK_DGRAM; + require(pthread_create(&threads[index], NULL, ordinary_traffic, (void *)(uintptr_t)kind) == 0, + "traffic thread"); + } + for (size_t index = 0; index < sizeof(threads) / sizeof(threads[0]); index++) + require(pthread_join(threads[index], NULL) == 0, "join traffic thread"); + if (active) { + usable(descriptor); + close(descriptor); + } +} + +static void transferred_test(const char *mode) { + int transport[2]; + require(socketpair(AF_UNIX, SOCK_DGRAM, 0, transport) == 0, "rights transport"); + pid_t child = fork(); + require(child >= 0, "rights fork"); + if (child == 0) { + close(transport[0]); + unsigned port; + struct iovec part = {.iov_base = &port, .iov_len = sizeof(port)}; + union { + struct cmsghdr align; + unsigned char bytes[CMSG_SPACE(sizeof(int))]; + } control; + struct msghdr message = {.msg_iov = &part, .msg_iovlen = 1, + .msg_control = control.bytes, .msg_controllen = sizeof(control.bytes)}; + ssize_t received = !strcmp(mode, "received") ? recvmsg(transport[1], &message, 0) : + syscall(SYS_recvmsg, (long)transport[1], &message, 0L, 0L, 0L, 0L); + require(received == sizeof(port), "rights receive"); + struct cmsghdr *header = CMSG_FIRSTHDR(&message); + require(header && header->cmsg_level == SOL_SOCKET && header->cmsg_type == SCM_RIGHTS + && header->cmsg_len == CMSG_LEN(sizeof(int)), "rights header"); + int descriptor; + memcpy(&descriptor, CMSG_DATA(header), sizeof(descriptor)); + struct sockaddr_nl address = {.nl_family = AF_NETLINK}; + if (!strcmp(mode, "domain")) { + int domain; + socklen_t length = sizeof(domain); + require(getsockopt(descriptor, SOL_SOCKET, SO_DOMAIN, &domain, &length) == 0 + && domain == AF_NETLINK, "rights domain discovery"); + } else if (!strcmp(mode, "bind")) { + address.nl_pid = port; + require(bind(descriptor, (struct sockaddr *)&address, sizeof(address)) == 0, + "rights bind discovery"); + } else if (!strcmp(mode, "connect")) { + require(connect(descriptor, (struct sockaddr *)&address, sizeof(address)) == 0, + "rights connect discovery"); + } else if (!strcmp(mode, "option")) { + int enabled = 1; + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_EXT_ACK, &enabled, sizeof(enabled)) == 0, + "rights option discovery"); + } + usable(descriptor); + require(port_of(descriptor) == port, "rights port retained"); + socket_info(descriptor, SOCK_RAW); + close(descriptor); + close(transport[1]); + _exit(0); + } + close(transport[1]); + int descriptor = route_socket(); + unsigned port = port_of(descriptor); + struct iovec part = {.iov_base = &port, .iov_len = sizeof(port)}; + union { + struct cmsghdr align; + unsigned char bytes[CMSG_SPACE(sizeof(int))]; + } control = {0}; + struct msghdr message = {.msg_iov = &part, .msg_iovlen = 1, + .msg_control = control.bytes, .msg_controllen = sizeof(control.bytes)}; + struct cmsghdr *header = CMSG_FIRSTHDR(&message); + header->cmsg_level = SOL_SOCKET; + header->cmsg_type = SCM_RIGHTS; + header->cmsg_len = CMSG_LEN(sizeof(descriptor)); + memcpy(CMSG_DATA(header), &descriptor, sizeof(descriptor)); + require(sendmsg(transport[0], &message, 0) == sizeof(port), "rights send"); + int status; + require(waitpid(child, &status, 0) == child && WIFEXITED(status) && WEXITSTATUS(status) == 0, + "rights child"); + usable(descriptor); + close(descriptor); + close(transport[0]); +} + +static void socket_types_test(void) { + const int kinds[] = {SOCK_RAW, SOCK_DGRAM}; + for (size_t index = 0; index < sizeof(kinds) / sizeof(kinds[0]); index++) { + int descriptor = socket(AF_NETLINK, kinds[index], NETLINK_ROUTE); + require(descriptor >= 0, "supported socket type"); + require(port_of(descriptor) == 0, "unbound port"); + require((fcntl(descriptor, F_GETFD) & FD_CLOEXEC) == 0, "caller cloexec flag"); + socket_info(descriptor, kinds[index]); + usable(descriptor); + close(descriptor); + descriptor = socket(AF_NETLINK, kinds[index] | SOCK_CLOEXEC | SOCK_NONBLOCK, NETLINK_ROUTE); + require(descriptor >= 0 && (fcntl(descriptor, F_GETFD) & FD_CLOEXEC) + && (fcntl(descriptor, F_GETFL) & O_NONBLOCK), "requested socket flags"); + socket_info(descriptor, kinds[index]); + close(descriptor); + } + require(socket(AF_NETLINK, SOCK_STREAM, NETLINK_ROUTE) == -1 + && errno == ESOCKTNOSUPPORT, "stream rejected"); + require(socket(AF_NETLINK, SOCK_SEQPACKET, NETLINK_ROUTE) == -1 + && errno == ESOCKTNOSUPPORT, "seqpacket rejected"); + require(socket(AF_NETLINK, SOCK_RAW | 0x40000000, NETLINK_ROUTE) == -1 + && errno == EINVAL, "unknown socket flag rejected"); + require(socket(AF_NETLINK, 15, NETLINK_ROUTE) == -1 && errno == EINVAL, "invalid socket type"); +} + +static void ports_test(int forked) { + int descriptors[32]; + unsigned ports[32]; + for (int index = 0; index < 32; index++) { + descriptors[index] = route_socket(); + ports[index] = port_of(descriptors[index]); + require(ports[index] != 0, "bound port"); + for (int previous = 0; previous < index; previous++) + require(ports[index] != ports[previous], "unique automatic port"); + } + int duplicate = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE); + require(duplicate >= 0, "explicit bind socket"); + struct sockaddr_nl address = {.nl_family = AF_NETLINK, .nl_pid = ports[0]}; + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == EADDRINUSE && port_of(duplicate) == 0, "duplicate explicit port"); + if (forked) { + pid_t child = fork(); + require(child >= 0, "port fork"); + if (child == 0) { + for (int index = 0; index < 32; index++) close(descriptors[index]); + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == EADDRINUSE, "cross process duplicate port"); + close(duplicate); + _exit(0); + } + int status; + require(waitpid(child, &status, 0) == child && WIFEXITED(status) && WEXITSTATUS(status) == 0, + "port child"); + } + int alias = dup(descriptors[0]); + close(descriptors[0]); + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == EADDRINUSE, "alias keeps port reserved"); + close(alias); + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == 0 + && port_of(duplicate) == ports[0], "closed port reused"); + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == 0, "same port rebind"); + address.nl_pid = 0; + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == -1 && errno == EINVAL, + "explicit zero port rebind denied"); + address.nl_pid = ports[0] + 1; + require(bind(duplicate, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == EINVAL && port_of(duplicate) == ports[0], "different port rebind denied"); + usable(duplicate); + close(duplicate); + for (int index = 1; index < 32; index++) { + usable(descriptors[index]); + close(descriptors[index]); + } +} + +static void batch_test(int oversized) { + int descriptor = route_socket(); + struct query { + struct nlmsghdr header; + struct ifinfomsg info; + } queries[128]; + int count = oversized ? 128 : 40; + for (int index = 0; index < count; index++) { + memset(&queries[index], 0, sizeof(queries[index])); + queries[index].header.nlmsg_len = sizeof(queries[index]); + queries[index].header.nlmsg_type = RTM_GETLINK; + queries[index].header.nlmsg_flags = NLM_F_REQUEST; + queries[index].header.nlmsg_seq = index + 1; + queries[index].info.ifi_index = 1; + } + struct iovec parts[2] = { + {.iov_base = queries, .iov_len = 256}, + {.iov_base = (unsigned char *)queries + 256, .iov_len = count * sizeof(queries[0]) - 256} + }; + struct sockaddr_nl address = {.nl_family = AF_NETLINK}; + struct msghdr message = {.msg_name = &address, .msg_namelen = sizeof(address), + .msg_iov = parts, .msg_iovlen = 2}; + ssize_t sent = sendmsg(descriptor, &message, 0); + unsigned char buffer[8192]; + if (oversized) { + require(sent == -1 && errno == EMSGSIZE, "oversized reply rejected"); + require(recv(descriptor, buffer, sizeof(buffer), MSG_DONTWAIT) == -1 && errno == EAGAIN, + "no partial batch reply"); + } else { + require(sent == count * sizeof(queries[0]), "large scatter gather request"); + int remaining = (int)receive(descriptor, buffer, sizeof(buffer)); + int replies = 0; + for (struct nlmsghdr *header = (struct nlmsghdr *)buffer; + NLMSG_OK(header, remaining); header = NLMSG_NEXT(header, remaining)) { + require(header->nlmsg_type == RTM_NEWLINK && header->nlmsg_seq == (unsigned)replies + 1, + "batch reply sequence"); + replies++; + } + require(replies == count, "complete batch"); + } + parts[0].iov_base = NULL; + require(sendmsg(descriptor, &message, 0) == -1 && errno == EFAULT, "invalid iov base"); + parts[0].iov_base = queries; + parts[0].iov_len = SIZE_MAX; + require(sendmsg(descriptor, &message, 0) == -1 && errno == EMSGSIZE, "iov length overflow"); + require(sendmsg(descriptor, NULL, 0) == -1 && errno == EFAULT, "invalid message"); + usable(descriptor); + close(descriptor); +} + +static void inherited_test(int argc, char **argv) { + require(argc == 6, "inherited arguments"); + int descriptor = atoi(argv[2]), closed = atoi(argv[4]), datagram = atoi(argv[5]); + unsigned port = (unsigned)strtoul(argv[3], NULL, 10); + require(fcntl(closed, F_GETFD) == -1 && errno == EBADF, "cloexec descriptor closed"); + require(port_of(descriptor) == port && !(fcntl(descriptor, F_GETFD) & FD_CLOEXEC), + "inherited bound port"); + socket_info(descriptor, SOCK_RAW); + socket_info(datagram, SOCK_DGRAM); + require(fcntl(datagram, F_GETFL) & O_NONBLOCK, "inherited nonblocking flag"); + unsigned char buffer[4096]; + receive(descriptor, buffer, sizeof(buffer)); + require(((struct nlmsghdr *)buffer)->nlmsg_type == RTM_NEWLINK, "queued reply survives exec"); + send_link(descriptor, 9999, NLM_F_ACK); + receive(descriptor, buffer, sizeof(buffer)); + require(((struct nlmsghdr *)buffer)->nlmsg_type == NLMSG_ERROR + && (((struct nlmsghdr *)buffer)->nlmsg_flags & NLM_F_CAPPED), "cap ack survives exec"); + usable(descriptor); + usable(datagram); + int fresh = route_socket(); + require(port_of(fresh) != port && port_of(fresh) != port_of(datagram), "ports after exec"); + close(fresh); + close(descriptor); + close(datagram); +} + +static void exec_test(const char *program, int forked) { + int descriptor = route_socket(); + int enabled = 1; + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_CAP_ACK, &enabled, sizeof(enabled)) == 0, + "inherited cap ack"); + unsigned port = port_of(descriptor); + int alias = fcntl(descriptor, F_DUPFD, 100); + int closed = fcntl(descriptor, F_DUPFD_CLOEXEC, 200); + require(alias >= 100 && closed >= 200, "exec aliases"); + close(descriptor); + int datagram = socket(AF_NETLINK, SOCK_DGRAM | SOCK_NONBLOCK, NETLINK_ROUTE); + require(datagram >= 0, "exec datagram"); + send_link(alias, 1, 0); + char descriptor_arg[32], port_arg[32], closed_arg[32], datagram_arg[32]; + snprintf(descriptor_arg, sizeof(descriptor_arg), "%d", alias); + snprintf(port_arg, sizeof(port_arg), "%u", port); + snprintf(closed_arg, sizeof(closed_arg), "%d", closed); + snprintf(datagram_arg, sizeof(datagram_arg), "%d", datagram); + char *arguments[] = {(char *)program, "inherited", descriptor_arg, port_arg, closed_arg, datagram_arg, NULL}; + if (forked) { + pid_t child = fork(); + require(child >= 0, "exec fork"); + if (child > 0) { + int status; + require(waitpid(child, &status, 0) == child && WIFEXITED(status) && WEXITSTATUS(status) == 0, + "exec child"); + usable(alias); + usable(datagram); + close(alias); + close(closed); + close(datagram); + return; + } + } + execv(program, arguments); + require(0, "exec"); +} + +static void cloexec_test(const char *program) { + int descriptor = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE); + require(descriptor >= 0, "cloexec socket"); + struct sockaddr_nl address = {.nl_family = AF_NETLINK, .nl_pid = (unsigned)getpid()}; + require(bind(descriptor, (struct sockaddr *)&address, sizeof(address)) == 0, "cloexec bind"); + char port_arg[32]; + snprintf(port_arg, sizeof(port_arg), "%u", address.nl_pid); + char *arguments[] = {(char *)program, "rebind_after_exec", port_arg, NULL}; + execv(program, arguments); + require(0, "cloexec exec"); +} + +static void ack_test(const char *mode) { + int descriptor = route_socket(); + int capped = !strcmp(mode, "capped"); + if (capped) { + int enabled = 1; + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_CAP_ACK, &enabled, sizeof(enabled)) == 0, + "cap ack"); + } + int rejected = !strcmp(mode, "error") || capped; + send_link(descriptor, rejected ? 9999 : 1, NLM_F_ACK); + unsigned char buffer[4096]; + int remaining = (int)receive(descriptor, buffer, sizeof(buffer)); + int acknowledgements = 0, links = 0; + for (struct nlmsghdr *header = (struct nlmsghdr *)buffer; + NLMSG_OK(header, remaining); header = NLMSG_NEXT(header, remaining)) { + require(header->nlmsg_seq == 42 && header->nlmsg_pid == port_of(descriptor), "ack identity"); + if (header->nlmsg_type == RTM_NEWLINK) links++; + if (header->nlmsg_type != NLMSG_ERROR) continue; + struct nlmsgerr *reply = NLMSG_DATA(header); + require(reply->error == (rejected ? -ENODEV : 0), "ack error"); + require(reply->msg.nlmsg_type == RTM_GETLINK && reply->msg.nlmsg_seq == 42, "ack request"); + require(!!(header->nlmsg_flags & NLM_F_CAPPED) == (!rejected || capped), "ack capped flag"); + size_t extra = rejected && !capped ? sizeof(struct ifinfomsg) : 0; + require(header->nlmsg_len == NLMSG_LENGTH(sizeof(*reply) + extra), "ack payload length"); + acknowledgements++; + } + require(acknowledgements == 1 && links == !rejected, "one acknowledgement"); + close(descriptor); +} + +static void options_test(void) { + int descriptor = route_socket(); + int group = RTNLGRP_LINK; + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_ADD_MEMBERSHIP, &group, sizeof(group)) == -1 + && errno == EACCES, "membership denied"); + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_PKTINFO, &group, sizeof(group)) == -1 + && errno == ENOPROTOOPT, "unsupported option"); + require(setsockopt(descriptor, SOL_NETLINK, NETLINK_EXT_ACK, &group, sizeof(group)) == 0, "ext ack"); + struct timeval timeout = {.tv_usec = 30000}; + require(setsockopt(descriptor, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout)) == 0, "receive timeout"); + memset(&timeout, 0, sizeof(timeout)); + socklen_t length = sizeof(timeout); + require(getsockopt(descriptor, SOL_SOCKET, SO_RCVTIMEO, &timeout, &length) == 0 + && timeout.tv_usec > 0, "timeout retained"); + unsigned char buffer[4096]; + require(recv(descriptor, buffer, sizeof(buffer), 0) == -1 + && (errno == EAGAIN || errno == EWOULDBLOCK), "receive times out"); + close(descriptor); +} + +static void dump_test(void) { + int descriptor = route_socket(); + send_link(descriptor, 0, NLM_F_DUMP | NLM_F_ACK); + unsigned char buffer[4096]; + int remaining = (int)receive(descriptor, buffer, sizeof(buffer)); + int links = 0, done = 0; + for (struct nlmsghdr *header = (struct nlmsghdr *)buffer; + NLMSG_OK(header, remaining); header = NLMSG_NEXT(header, remaining)) { + require(header->nlmsg_seq == 42 && (header->nlmsg_flags & NLM_F_MULTI), "dump header"); + if (header->nlmsg_type == RTM_NEWLINK) links++; + else { + require(header->nlmsg_type == NLMSG_DONE && *(int *)NLMSG_DATA(header) == 0, + "dump completion"); + done++; + } + } + require(links == 2 && done == 1, "dump results"); + close(descriptor); +} + +static void send_timeout_test(int nonblocking) { + int descriptor = route_socket(); + if (nonblocking) { + require(fcntl(descriptor, F_SETFL, O_NONBLOCK) == 0, "nonblocking"); + } else { + struct timeval timeout = {.tv_usec = 30000}; + require(setsockopt(descriptor, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(timeout)) == 0, + "send timeout"); + } + struct { + struct nlmsghdr header; + struct ifinfomsg info; + } query = { + .header = {.nlmsg_len = sizeof(query), .nlmsg_type = RTM_GETLINK, + .nlmsg_flags = NLM_F_REQUEST, .nlmsg_seq = 42}, + .info = {.ifi_index = 1} + }; + for (int count = 0; count < 10000; count++) { + ssize_t result = send(descriptor, &query, sizeof(query), 0); + if (result == -1) { + require(errno == EAGAIN || errno == EWOULDBLOCK, "full queue would block"); + close(descriptor); + return; + } + require(result == sizeof(query), "queued send"); + } + require(0, "queue filled"); +} + +static void connect_test(void) { + int descriptor = route_socket(); + struct sockaddr_nl address = {.nl_family = AF_NETLINK}; + socklen_t length = sizeof(address); + require(getpeername(descriptor, (struct sockaddr *)&address, &length) == 0 + && address.nl_family == AF_NETLINK && address.nl_pid == 0, "default kernel peer"); + require(connect(descriptor, (struct sockaddr *)&address, sizeof(address)) == 0, "connect kernel"); + memset(&address, 0xff, sizeof(address)); + length = sizeof(address); + require(getpeername(descriptor, (struct sockaddr *)&address, &length) == 0 + && length == sizeof(address) && address.nl_family == AF_NETLINK + && address.nl_pid == 0 && address.nl_groups == 0, "kernel peer"); + usable(descriptor); + address.nl_pid = 1234; + require(connect(descriptor, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == ECONNREFUSED, "userspace peer refused"); + address.nl_pid = 0; + address.nl_groups = 1; + require(connect(descriptor, (struct sockaddr *)&address, sizeof(address)) == -1 + && errno == EACCES, "multicast peer denied"); + struct sockaddr disconnect = {.sa_family = AF_UNSPEC}; + require(connect(descriptor, &disconnect, sizeof(disconnect)) == 0, "disconnect"); + length = sizeof(address); + require(getpeername(descriptor, (struct sockaddr *)&address, &length) == 0 + && address.nl_family == AF_NETLINK && address.nl_pid == 0, "disconnected default peer"); + close(descriptor); +} + +static void receive_test(void) { + int descriptor = route_socket(); + send_link(descriptor, 1, 0); + unsigned char buffer[4096]; + struct sockaddr_nl address; + memset(&address, 0xff, sizeof(address)); + socklen_t length = sizeof(sa_family_t); + require(recvfrom(descriptor, buffer, sizeof(buffer), MSG_PEEK, + (struct sockaddr *)&address, &length) > 0 + && length == sizeof(address) && address.nl_family == AF_NETLINK + && address.nl_pid == (unsigned)-1, "truncated source"); + struct iovec part = {.iov_base = buffer, .iov_len = sizeof(buffer)}; + struct msghdr message = {.msg_name = &address, .msg_namelen = sizeof(address), + .msg_iov = &part, .msg_iovlen = 1}; + require(recvmsg(descriptor, &message, 0) > 0 && message.msg_namelen == sizeof(address) + && address.nl_family == AF_NETLINK && address.nl_pid == 0, "recvmsg source"); + memset(&address, 0xff, sizeof(address)); + length = sizeof(address); + require(recvfrom(descriptor, buffer, sizeof(buffer), MSG_DONTWAIT, + (struct sockaddr *)&address, &length) == -1 && errno == EAGAIN + && address.nl_family == (unsigned short)-1, "failed receive preserves source"); + close(descriptor); +} + +static void duplicate_test(const char *mode) { + int descriptor = route_socket(); + unsigned port = port_of(descriptor); + int duplicate; + if (!strcmp(mode, "dup")) duplicate = dup(descriptor); + else if (!strcmp(mode, "high_dup")) { + struct rlimit limit; + require(getrlimit(RLIMIT_NOFILE, &limit) == 0, "descriptor limit"); + int minimum = limit.rlim_cur > 262144 ? 262144 : (int)(limit.rlim_cur / 2); + duplicate = fcntl(descriptor, F_DUPFD, minimum); + require(duplicate >= minimum, "high descriptor duplicate"); + } + else if (!strcmp(mode, "fcntl")) duplicate = fcntl(descriptor, F_DUPFD, 20); + else if (!strcmp(mode, "fcntl_cloexec")) duplicate = fcntl(descriptor, F_DUPFD_CLOEXEC, 20); + else { + int target = open("/dev/null", O_RDONLY); + require(target >= 0, "dup target"); + duplicate = !strcmp(mode, "dup2") ? dup2(descriptor, target) : + dup3(descriptor, target, O_CLOEXEC); + } + require(duplicate >= 0 && port_of(duplicate) == port, "duplicate identity"); + require(dup2(descriptor, descriptor) == descriptor, "dup2 same fd"); + require(dup2(-1, descriptor) == -1 && errno == EBADF, "failed replacement"); + usable(descriptor); + close(descriptor); + usable(duplicate); + close(duplicate); + for (int pass = 0; pass < 16; pass++) { + descriptor = route_socket(); + usable(descriptor); + close(descriptor); + } +} + +static void replacement_test(int raw) { + int descriptor = route_socket(); + int pair[2]; + require(socketpair(AF_UNIX, SOCK_DGRAM, 0, pair) == 0, "unix pair"); + int result = raw ? (int)syscall(SYS_dup3, (long)pair[0], (long)descriptor, 0L, 0L, 0L, 0L) : + dup2(pair[0], descriptor); + require(result == descriptor, "replace descriptor"); + struct sockaddr_storage address; + socklen_t length = sizeof(address); + require(getsockname(descriptor, (struct sockaddr *)&address, &length) == 0 + && address.ss_family == AF_UNIX, "replacement identity"); + const char payload[] = "unix payload"; + require(send(descriptor, payload, sizeof(payload), MSG_DONTWAIT) == sizeof(payload), "unix send"); + char buffer[64]; + require(recv(pair[1], buffer, sizeof(buffer), MSG_DONTWAIT) == sizeof(payload) + && !memcmp(buffer, payload, sizeof(payload)), "unix receive"); + close(descriptor); + close(pair[0]); + close(pair[1]); +} + +static void shared_test(int forked) { + int descriptor = route_socket(); + if (forked) { + pid_t child = fork(); + require(child >= 0, "fork"); + if (child == 0) { + usable(descriptor); + close(descriptor); + _exit(0); + } + int status; + require(waitpid(child, &status, 0) == child && WIFEXITED(status) && WEXITSTATUS(status) == 0, + "child socket"); + usable(descriptor); + } else { + int alias = dup(descriptor); + require(alias >= 0 && dup2(descriptor, alias) == alias, "replace same socket alias"); + int other = route_socket(); + require(dup2(descriptor, other) == other, "replace other socket"); + close(descriptor); + usable(alias); + close(alias); + usable(other); + close(other); + return; + } + close(descriptor); +} + +static void close_range_test(const char *mode) { + int descriptor = route_socket(); + if (!strcmp(mode, "closefrom")) { + void (*close_from)(int) = dlsym(RTLD_DEFAULT, "closefrom"); + require(close_from != NULL, "closefrom symbol"); + close_from(descriptor); + } else { + int (*close_range_fn)(unsigned int, unsigned int, int) = dlsym(RTLD_DEFAULT, "close_range"); + require(close_range_fn != NULL, "close_range symbol"); + if (!strcmp(mode, "cloexec")) { + require(close_range_fn(descriptor, descriptor, 4) == 0, "close_range cloexec"); + usable(descriptor); + close(descriptor); + } else { + require(close_range_fn(descriptor, descriptor, 1) == -1 && errno == EINVAL, + "invalid close_range"); + usable(descriptor); + require(close_range_fn(descriptor, descriptor, 0) == 0, "close_range"); + } + } + for (int pass = 0; pass < 16; pass++) { + descriptor = route_socket(); + usable(descriptor); + close(descriptor); + } +} + +static void route_test(const char *destination) { + int descriptor = route_socket(); + int family = strchr(destination, ':') ? AF_INET6 : AF_INET; + int size = family == AF_INET ? 4 : 16; + struct { + struct nlmsghdr header; + struct rtmsg info; + struct rtattr attr; + unsigned char destination[16]; + } query = { + .header = {.nlmsg_type = RTM_GETROUTE, .nlmsg_flags = NLM_F_REQUEST, .nlmsg_seq = 42}, + .info = {.rtm_family = family, .rtm_dst_len = size * 8}, + .attr = {.rta_type = RTA_DST, .rta_len = RTA_LENGTH(size)} + }; + query.header.nlmsg_len = NLMSG_LENGTH(sizeof(query.info)) + RTA_SPACE(size); + require(inet_pton(family, destination, query.destination) == 1, "destination"); + struct sockaddr_nl address = {.nl_family = AF_NETLINK}; + require(sendto(descriptor, &query, query.header.nlmsg_len, 0, + (struct sockaddr *)&address, sizeof(address)) == query.header.nlmsg_len, "route send"); + unsigned char buffer[4096]; + receive(descriptor, buffer, sizeof(buffer)); + struct nlmsghdr *header = (struct nlmsghdr *)buffer; + if (header->nlmsg_type == NLMSG_ERROR) { + printf("error %d\n", ((struct nlmsgerr *)NLMSG_DATA(header))->error); + } else { + require(header->nlmsg_type == RTM_NEWROUTE, "route reply"); + struct rtmsg *info = NLMSG_DATA(header); + int remaining = RTM_PAYLOAD(header); + unsigned interface = 0; + char gateway[INET6_ADDRSTRLEN] = "-", source[INET6_ADDRSTRLEN] = "-"; + for (struct rtattr *attr = RTM_RTA(info); RTA_OK(attr, remaining); + attr = RTA_NEXT(attr, remaining)) { + if (attr->rta_type == RTA_OIF) memcpy(&interface, RTA_DATA(attr), sizeof(interface)); + if (attr->rta_type == RTA_GATEWAY) inet_ntop(family, RTA_DATA(attr), gateway, sizeof(gateway)); + if (attr->rta_type == RTA_PREFSRC) inet_ntop(family, RTA_DATA(attr), source, sizeof(source)); + } + printf("route %u %u %u %u %s %s\n", info->rtm_type, info->rtm_scope, + info->rtm_table, interface, gateway, source); + } + close(descriptor); +} + +int main(int argc, char **argv) { + require(argc >= 2, "mode"); + if (!strcmp(argv[1], "ack") || !strcmp(argv[1], "error") || !strcmp(argv[1], "capped")) + ack_test(argv[1]); + else if (!strcmp(argv[1], "options")) options_test(); + else if (!strcmp(argv[1], "dump")) dump_test(); + else if (!strcmp(argv[1], "send_timeout")) send_timeout_test(0); + 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], "replace")) replacement_test(0); + else if (!strcmp(argv[1], "raw_replace")) replacement_test(1); + else if (!strcmp(argv[1], "shared")) shared_test(0); + else if (!strcmp(argv[1], "fork")) shared_test(1); + else if (!strcmp(argv[1], "socket_types")) socket_types_test(); + else if (!strcmp(argv[1], "hotpath")) { + require(argc == 3, "hotpath arguments"); + hotpath_test(atoi(argv[2])); + } + else if (!strcmp(argv[1], "transferred")) { + require(argc == 3, "transfer arguments"); + transferred_test(argv[2]); + } + else if (!strcmp(argv[1], "named_link")) { + require(argc == 4, "named link arguments"); + named_link_test(argv[2], argv[3]); + } + else if (!strcmp(argv[1], "autobind_race")) autobind_race_test(); + else if (!strcmp(argv[1], "vfork_close_range")) vfork_close_range_test(); + else if (!strcmp(argv[1], "ports")) ports_test(0); + else if (!strcmp(argv[1], "cross_process_ports")) ports_test(1); + else if (!strcmp(argv[1], "batch")) batch_test(0); + else if (!strcmp(argv[1], "oversized_batch")) batch_test(1); + else if (!strcmp(argv[1], "exec")) exec_test(argv[0], 0); + else if (!strcmp(argv[1], "fork_exec")) exec_test(argv[0], 1); + else if (!strcmp(argv[1], "inherited")) inherited_test(argc, argv); + else if (!strcmp(argv[1], "all_cloexec")) cloexec_test(argv[0]); + else if (!strcmp(argv[1], "rebind_after_exec")) { + require(argc == 3, "rebind arguments"); + int descriptor = route_socket(); + require(port_of(descriptor) == (unsigned)strtoul(argv[2], NULL, 10), "exec releases closed ports"); + usable(descriptor); + close(descriptor); + } + else if (!strcmp(argv[1], "range") || !strcmp(argv[1], "cloexec") || !strcmp(argv[1], "closefrom")) + close_range_test(argv[1]); + else if (!strcmp(argv[1], "route")) { + require(argc >= 3, "route destination"); + route_test(argv[2]); + } else duplicate_test(argv[1]); + return 0; +} +""" + +SNAPSHOT = """if wlan0 2 1500 +mac 02:11:22:33:44:55 +addr 192.168.1.10 24 +addr 192.168.1.130 25 +addr fe80::10 64 +addr 2001:db8::10 64 +gw 192.168.1.1 +gw 2001:db8::1 +""" + + +@unittest.skipUnless(sys.platform.startswith("linux") and shutil.which("cc"), "needs Linux and a C compiler") +class NetlinkPreloadTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.temp = tempfile.TemporaryDirectory() + cls.directory = Path(cls.temp.name) + cls.preload = cls.directory / "libblsession.so" + cls.shim = cls.directory / "libshim.so" + cls.program = cls.directory / "program" + (cls.directory / "shim.c").write_text(SHIM) + (cls.directory / "program.c").write_text(PROGRAM) + subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", + "-o", str(cls.preload), *map(str, sorted(PRELOAD.glob("*.c"))), "-ldl"], check=True) + subprocess.run(["cc", "-shared", "-fPIC", "-O2", "-Wall", "-pthread", "-o", str(cls.shim), + str(cls.directory / "shim.c"), "-ldl"], check=True) + subprocess.run(["cc", "-O2", "-Wall", "-pthread", "-o", str(cls.program), + str(cls.directory / "program.c"), "-ldl"], check=True) + cls.snapshot = cls.directory / "snapshot" + cls.snapshot.write_text(SNAPSHOT) + cls.direct = cls.directory / "direct" + cls.direct.write_text("\n".join(line for line in SNAPSHOT.splitlines() if not line.startswith("gw ")) + "\n") + cls.offline = cls.directory / "offline" + cls.offline.write_text("") + + @classmethod + def tearDownClass(cls): + cls.temp.cleanup() + + def run_program(self, mode, *arguments, snapshot=None): + env = dict(os.environ, LD_PRELOAD=f"{self.preload}:{self.shim}", + NETLINK_TEST_SNAPSHOT=str(snapshot or self.snapshot), + BL_SYSV_DIR=str(self.directory / "sysv")) + result = subprocess.run([str(self.program), mode, *arguments], env=env, + capture_output=True, text=True, timeout=5) + self.assertEqual(0, result.returncode, result.stdout + result.stderr) + return result.stdout.strip().split() + + def test_successful_queries_acknowledge_requests(self): + self.run_program("ack") + + def test_failed_queries_return_only_one_error(self): + self.run_program("error") + + def test_cap_ack_omits_the_request_payload(self): + self.run_program("capped") + + def test_socket_types_flags_and_identity_match_netlink(self): + self.run_program("socket_types") + + def test_ordinary_socket_paths_do_not_lock_or_probe_for_netlink(self): + for active in ("0", "1"): + with self.subTest(netlink_active=active): + self.run_program("hotpath", active) + + def test_transferred_sockets_restore_on_receipt_or_netlink_specific_operations(self): + for mode in ("received", "domain", "bind", "connect", "option"): + with self.subTest(discovery=mode): + self.run_program("transferred", mode) + + def test_getlink_resolves_names_and_prefers_a_nonzero_index(self): + for name, mode, expected in (("wlan0", "name", ["link", "2", "wlan0"]), + ("lo", "name", ["link", "1", "lo"]), + ("unknown", "index", ["link", "1", "lo"]), + ("unknown", "name", ["error", str(-errno.ENODEV)]), + ("wlan0", "missing", ["error", str(-errno.EINVAL)]), + ("wlan0", "unterminated", ["link", "2", "wlan0"]), + ("lo", "unterminated", ["link", "1", "lo"]), + ("unknown", "unterminated", ["error", str(-errno.ENODEV)]), + ("x" * 15, "name", ["error", str(-errno.ENODEV)]), + ("x" * 15, "unterminated", ["error", str(-errno.ENODEV)]), + ("x" * 16, "unterminated", ["error", str(-errno.ERANGE)]), + ("", "name", ["error", str(-errno.ENODEV)]), + ("", "unterminated", ["error", str(-errno.ERANGE)]), + ("wlan0", "oversized", ["error", str(-errno.ERANGE)])): + with self.subTest(name=name, mode=mode): + self.assertEqual(expected, self.run_program("named_link", name, mode)) + self.assertEqual(["error", str(-errno.ENODEV)], + self.run_program("named_link", "wlan0", "name", snapshot=self.offline)) + + def test_more_than_eight_sockets_get_unique_ports_and_release_them(self): + self.run_program("ports") + + def test_concurrent_implicit_binds_are_idempotent(self): + self.run_program("autobind_race") + + def test_vfork_close_range_does_not_mutate_parent_bookkeeping(self): + self.run_program("vfork_close_range") + + def test_explicit_ports_cannot_collide_across_processes(self): + self.run_program("cross_process_ports") + + def test_large_scatter_gather_requests_receive_all_their_replies(self): + self.run_program("batch") + + def test_reply_overflow_and_invalid_iovecs_fail_without_unix_fallback(self): + self.run_program("oversized_batch") + + def test_non_cloexec_sockets_and_queued_replies_survive_exec(self): + self.run_program("exec") + + def test_fork_exec_does_not_break_the_parents_socket(self): + self.run_program("fork_exec") + + def test_cloexec_sockets_release_their_ports_after_exec(self): + self.run_program("all_cloexec") + + def test_subscription_is_denied_and_receive_timeout_is_applied(self): + self.run_program("options") + + def test_dump_keeps_multipart_completion(self): + self.run_program("dump") + + def test_full_reply_queues_respect_send_timeout_and_nonblocking_mode(self): + for mode in ("send_timeout", "nonblocking"): + with self.subTest(mode=mode): + self.run_program(mode) + + def test_kernel_connect_and_disconnect(self): + self.run_program("connect") + + def test_receive_sources_and_truncation(self): + self.run_program("receive") + + def test_duplicates_share_the_socket_until_the_last_close(self): + for mode in ("dup", "dup2", "dup3", "fcntl", "fcntl_cloexec", "high_dup"): + with self.subTest(mode=mode): + self.run_program(mode) + + def test_replacing_a_route_fd_does_not_intercept_unix_traffic(self): + self.run_program("replace") + + def test_untracked_replacement_is_detected_by_socket_identity(self): + self.run_program("raw_replace") + + def test_replacing_other_netlink_descriptors_preserves_shared_state(self): + self.run_program("shared") + + def test_forked_sockets_remain_usable_in_both_processes(self): + self.run_program("fork") + + def test_range_closes_release_slots_but_failures_and_cloexec_do_not(self): + for mode in ("range", "cloexec", "closefrom"): + with self.subTest(mode=mode): + self.run_program(mode) + + def test_loopback_and_own_addresses_are_local_routes(self): + for destination, source in (("127.0.0.2", "127.0.0.1"), ("::1", "::1"), + ("192.168.1.10", "192.168.1.10"), ("2001:db8::10", "2001:db8::10")): + with self.subTest(destination=destination): + self.assertEqual(["route", "2", "254", "255", "1", "-", source], + self.run_program("route", destination)) + + def test_connected_routes_choose_the_longest_prefix_without_a_gateway(self): + for destination, source in (("192.168.1.11", "192.168.1.10"), + ("192.168.1.131", "192.168.1.130"), + ("fe80::11", "fe80::10"), ("2001:db8::11", "2001:db8::10")): + with self.subTest(destination=destination): + self.assertEqual(["route", "1", "253", "254", "2", "-", source], + self.run_program("route", destination, snapshot=self.direct)) + + def test_other_destinations_use_a_default_gateway(self): + self.assertEqual(["route", "1", "0", "254", "2", "192.168.1.1", "192.168.1.10"], + self.run_program("route", "8.8.8.8")) + self.assertEqual(["route", "1", "0", "254", "2", "2001:db8::1", "2001:db8::10"], + self.run_program("route", "2001:db9::1")) + + def test_without_a_gateway_only_off_link_destinations_are_unreachable(self): + self.assertEqual(["error", str(-errno.ENETUNREACH)], + self.run_program("route", "8.8.8.8", snapshot=self.direct)) + self.assertEqual(["route", "2", "254", "255", "1", "-", "127.0.0.1"], + self.run_program("route", "127.0.0.1", snapshot=self.offline)) + + @unittest.skipUnless(shutil.which("ip"), "needs iproute2") + def test_iproute2_dumps_and_lookups_accept_the_replies(self): + env = dict(os.environ, LD_PRELOAD=f"{self.preload}:{self.shim}", + NETLINK_TEST_SNAPSHOT=str(self.snapshot), + BL_SYSV_DIR=str(self.directory / "sysv")) + queries = ((["link", "show"], "wlan0"), + (["link", "show", "wlan0"], "wlan0"), + (["-d", "link", "show", "dev", "wlan0"], "wlan0"), + (["link", "show", "lo"], "lo"), + (["addr", "show"], "192.168.1.10/24"), + (["route", "show"], "default via 192.168.1.1 dev wlan0"), + (["route", "get", "127.0.0.1"], "local 127.0.0.1 dev lo"), + (["route", "get", "192.168.1.11"], "192.168.1.11 dev wlan0"), + (["-6", "route", "get", "fe80::11"], "fe80::11 dev wlan0")) + for arguments, expected in queries: + with self.subTest(arguments=arguments): + result = subprocess.run([shutil.which("ip"), *arguments], env=env, + capture_output=True, text=True, timeout=5) + self.assertEqual(0, result.returncode, result.stdout + result.stderr) + self.assertIn(expected, result.stdout) + + +if __name__ == "__main__": + unittest.main()