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()