| // SPDX-License-Identifier: GPL-2.0-only | |
| /* | |
| * Exercise UDP software checksums over multiple spliced pipe fragments. | |
| * All traffic stays on loopback; no privileges or external services are needed. | |
| * Exit status: 0 = pass, 1 = failure, 4 = all cases skipped. | |
| */ | |
| #define _GNU_SOURCE | |
| #include <arpa/inet.h> | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <poll.h> | |
| #include <stdbool.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <sys/socket.h> | |
| #include <time.h> | |
| #include <unistd.h> | |
| #include "kselftest.h" | |
| #define TIMEOUT_MS 200 | |
| struct test_case { | |
| const char *name; | |
| const char *body; | |
| const char *prefix; | |
| size_t fragments[3]; | |
| bool ordinary; | |
| bool page_tail; | |
| }; | |
| static const struct test_case cases[] = { | |
| { "ordinary-control", "abcDEFGH", "", { 3, 5 }, true, false }, | |
| { "uniform-odd-fragments", "BBBBBBBB", "", { 3, 5 }, false, false }, | |
| { "even-fragments", "abcdEFGH", "", { 4, 4 }, false, false }, | |
| { "odd-fragments", "abcDEFGH", "", { 3, 5 }, false, false }, | |
| { "odd-prefix-odd-fragments", "abcDEFGH", "P", { 3, 5 }, false, false }, | |
| { "even-prefix-odd-fragments", "abcDEFGH", "PQ", { 3, 5 }, false, false }, | |
| { "page-tail-odd-fragments", "abcDEFGH", "", { 3, 5 }, false, true }, | |
| { "three-fragments", "abcDEFGhijkl", "", { 3, 4, 5 }, false, false }, | |
| { "odd-prefix-three-fragments", | |
| "abcDEFGhijkl", | |
| "P", | |
| { 3, 4, 5 }, | |
| false, | |
| false }, | |
| }; | |
| static const char *const families[] = { "IPv4", "IPv6", "IPv4-mapped" }; | |
| static int error(const char *what) | |
| { | |
| ksft_perror(what); | |
| return 1; | |
| } | |
| static bool unavailable(void) | |
| { | |
| return errno == EAFNOSUPPORT || errno == EPROTONOSUPPORT || | |
| errno == EADDRNOTAVAIL; | |
| } | |
| static long long now_ms(void) | |
| { | |
| struct timespec ts; | |
| if (clock_gettime(CLOCK_MONOTONIC, &ts)) | |
| ksft_exit_fail_perror("clock_gettime"); | |
| return (long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000; | |
| } | |
| static int receive_one(int fd, const char *expected, size_t length) | |
| { | |
| struct pollfd pfd = { .fd = fd, .events = POLLIN }; | |
| long long deadline = now_ms() + TIMEOUT_MS; | |
| int remaining, ret; | |
| char received[64]; | |
| ssize_t count; | |
| for (;;) { | |
| remaining = deadline - now_ms(); | |
| if (remaining < 0) | |
| remaining = 0; | |
| ret = poll(&pfd, 1, remaining); | |
| if (ret < 0) { | |
| if (errno == EINTR) | |
| continue; | |
| return error("poll"); | |
| } | |
| if (!ret) { | |
| ksft_print_msg("no datagram within %d ms after send\n", | |
| TIMEOUT_MS); | |
| return 1; | |
| } | |
| count = recv(fd, received, sizeof(received), | |
| MSG_DONTWAIT | MSG_TRUNC); | |
| if (count < 0) { | |
| if (errno == EINTR || errno == EAGAIN) | |
| continue; | |
| return error("recv"); | |
| } | |
| break; | |
| } | |
| if (count != (ssize_t)length || memcmp(received, expected, length)) { | |
| ksft_print_msg("received %zd bytes; expected %zu matching\n", | |
| count, length); | |
| return 1; | |
| } | |
| count = recv(fd, received, sizeof(received), MSG_DONTWAIT | MSG_TRUNC); | |
| if (count >= 0) { | |
| ksft_print_msg("unexpected extra datagram (%zd bytes)\n", | |
| count); | |
| return 1; | |
| } | |
| if (errno != EAGAIN) | |
| return error("extra-datagram check"); | |
| return 0; | |
| } | |
| /* Separate source pipes prevent adjacent small writes merging into one buffer. */ | |
| static int append_fragment(int dest, const char *data, size_t length) | |
| { | |
| int source[2], ret = 1; | |
| if (pipe2(source, O_NONBLOCK | O_CLOEXEC)) | |
| return error("source pipe"); | |
| if (write(source[1], data, length) != (ssize_t)length) { | |
| error("source write"); | |
| goto out; | |
| } | |
| if (splice(source[0], NULL, dest, NULL, length, SPLICE_F_NONBLOCK) != | |
| (ssize_t)length) { | |
| error("pipe-to-pipe splice"); | |
| goto out; | |
| } | |
| ret = 0; | |
| out: | |
| close(source[0]); | |
| close(source[1]); | |
| return ret; | |
| } | |
| static int pipe_capacity(int fd, unsigned int slots, const char **skip_reason) | |
| { | |
| long required = slots * sysconf(_SC_PAGESIZE); | |
| int capacity = fcntl(fd, F_GETPIPE_SZ); | |
| if (capacity < 0) | |
| return error("query pipe capacity"); | |
| if (capacity >= required || | |
| fcntl(fd, F_SETPIPE_SZ, required) >= required) | |
| return 0; | |
| ksft_print_msg("cannot reserve %u pipe slots: %s\n", slots, | |
| strerror(errno)); | |
| *skip_reason = "required pipe capacity unavailable"; | |
| return KSFT_SKIP; | |
| } | |
| /* Leave three bytes at a page's end, followed by five bytes on the next page. */ | |
| static int append_page_tail(int dest, const char *body, | |
| const char **skip_reason) | |
| { | |
| long page = sysconf(_SC_PAGESIZE); | |
| int source[2], ret = 1; | |
| char *data; | |
| if (page < 8) { | |
| ksft_print_msg("invalid page size %ld\n", page); | |
| return 1; | |
| } | |
| data = malloc(page + 5); | |
| if (!data) | |
| return error("malloc"); | |
| memset(data, 'x', page - 3); | |
| memcpy(data + page - 3, body, 8); | |
| if (pipe2(source, O_NONBLOCK | O_CLOEXEC)) { | |
| error("page-tail source pipe"); | |
| goto free_data; | |
| } | |
| ret = pipe_capacity(source[1], 2, skip_reason); | |
| if (ret) | |
| goto out; | |
| ret = 1; | |
| if (write(source[1], data, page + 5) != page + 5) { | |
| error("page-tail write"); | |
| goto out; | |
| } | |
| if (read(source[0], data, page - 3) != page - 3) { | |
| error("page-tail discard"); | |
| goto out; | |
| } | |
| if (splice(source[0], NULL, dest, NULL, 8, SPLICE_F_NONBLOCK) != 8) { | |
| error("page-tail pipe-to-pipe splice"); | |
| goto out; | |
| } | |
| ret = 0; | |
| out: | |
| close(source[0]); | |
| close(source[1]); | |
| free_data: | |
| free(data); | |
| return ret; | |
| } | |
| static int run_case(unsigned int family, bool connected, | |
| const struct test_case *test, const char **skip_reason) | |
| { | |
| size_t body_length = strlen(test->body), offset = 0; | |
| int tx_family = family == 0 ? AF_INET : AF_INET6; | |
| int rx_family = family == 1 ? AF_INET6 : AF_INET; | |
| int rx = -1, tx = -1, pipefd[2] = { -1, -1 }; | |
| size_t prefix_length = strlen(test->prefix); | |
| struct sockaddr_storage address = { 0 }; | |
| socklen_t address_length; | |
| struct sockaddr_in6 *v6; | |
| struct sockaddr_in *v4; | |
| int ret = 1, zero = 0; | |
| char expected[64]; | |
| unsigned int i; | |
| ssize_t count; | |
| v4 = (struct sockaddr_in *)&address; | |
| v6 = (struct sockaddr_in6 *)&address; | |
| *skip_reason = "address family unavailable"; | |
| memcpy(expected, test->prefix, prefix_length); | |
| memcpy(expected + prefix_length, test->body, body_length); | |
| rx = socket(rx_family, SOCK_DGRAM | SOCK_CLOEXEC, 0); | |
| if (rx < 0) { | |
| ret = unavailable() ? KSFT_SKIP : error("receive socket"); | |
| goto out; | |
| } | |
| if (rx_family == AF_INET) { | |
| v4->sin_family = AF_INET; | |
| v4->sin_addr.s_addr = htonl(INADDR_LOOPBACK); | |
| address_length = sizeof(*v4); | |
| } else { | |
| v6->sin6_family = AF_INET6; | |
| v6->sin6_addr = in6addr_loopback; | |
| address_length = sizeof(*v6); | |
| } | |
| if (bind(rx, (struct sockaddr *)&address, address_length)) { | |
| ret = unavailable() ? KSFT_SKIP : error("bind loopback"); | |
| goto out; | |
| } | |
| if (getsockname(rx, (struct sockaddr *)&address, &address_length)) { | |
| error("getsockname"); | |
| goto out; | |
| } | |
| if (family == 2) { | |
| unsigned short port = v4->sin_port; | |
| memset(&address, 0, sizeof(address)); | |
| v6->sin6_family = AF_INET6; | |
| v6->sin6_port = port; | |
| inet_pton(AF_INET6, "::ffff:127.0.0.1", &v6->sin6_addr); | |
| address_length = sizeof(*v6); | |
| } | |
| tx = socket(tx_family, SOCK_DGRAM | SOCK_CLOEXEC, 0); | |
| if (tx < 0) { | |
| ret = unavailable() ? KSFT_SKIP : error("send socket"); | |
| goto out; | |
| } | |
| if (family == 2 && | |
| setsockopt(tx, IPPROTO_IPV6, IPV6_V6ONLY, &zero, sizeof(zero))) { | |
| error("disable IPV6_V6ONLY"); | |
| goto out; | |
| } | |
| if (connected && | |
| connect(tx, (struct sockaddr *)&address, address_length)) { | |
| error("connect"); | |
| goto out; | |
| } | |
| if (test->ordinary) { | |
| count = sendto(tx, expected, prefix_length + body_length, 0, | |
| (struct sockaddr *)&address, address_length); | |
| if (count != (ssize_t)(prefix_length + body_length)) { | |
| error("ordinary sendto"); | |
| goto out; | |
| } | |
| } else { | |
| if (pipe2(pipefd, O_NONBLOCK | O_CLOEXEC)) { | |
| error("assembled pipe"); | |
| goto out; | |
| } | |
| ret = pipe_capacity(pipefd[1], test->fragments[2] ? 3 : 2, | |
| skip_reason); | |
| if (ret) | |
| goto out; | |
| ret = 1; | |
| if (test->page_tail) { | |
| ret = append_page_tail(pipefd[1], test->body, | |
| skip_reason); | |
| if (ret) | |
| goto out; | |
| ret = 1; | |
| } else { | |
| for (i = 0; i < ARRAY_SIZE(test->fragments); i++) { | |
| if (!test->fragments[i]) | |
| break; | |
| if (append_fragment(pipefd[1], | |
| test->body + offset, | |
| test->fragments[i])) | |
| goto out; | |
| offset += test->fragments[i]; | |
| } | |
| } | |
| /* Even an empty prefix establishes the destination and UDP cork. */ | |
| count = sendto(tx, test->prefix, prefix_length, MSG_MORE, | |
| (struct sockaddr *)&address, address_length); | |
| if (count != (ssize_t)prefix_length) { | |
| error("prime sendto(MSG_MORE)"); | |
| goto out; | |
| } | |
| count = splice(pipefd[0], NULL, tx, NULL, body_length, | |
| SPLICE_F_NONBLOCK | SPLICE_F_MORE); | |
| if (count != (ssize_t)body_length) { | |
| ksft_print_msg("socket splice: %zd, expected %zu: %s\n", | |
| count, body_length, | |
| count < 0 ? strerror(errno) : | |
| "short transfer"); | |
| goto out; | |
| } | |
| if (sendto(tx, "", 0, 0, (struct sockaddr *)&address, | |
| address_length)) { | |
| error("commit sendto"); | |
| goto out; | |
| } | |
| } | |
| ret = receive_one(rx, expected, prefix_length + body_length); | |
| out: | |
| if (pipefd[0] >= 0) { | |
| close(pipefd[0]); | |
| close(pipefd[1]); | |
| } | |
| if (tx >= 0) | |
| close(tx); | |
| if (rx >= 0) | |
| close(rx); | |
| return ret; | |
| } | |
| int main(void) | |
| { | |
| unsigned int family, connected, i; | |
| const char *connection, *skip; | |
| int ret; | |
| ksft_print_header(); | |
| ksft_set_plan(ARRAY_SIZE(families) * 2 * ARRAY_SIZE(cases)); | |
| for (family = 0; family < ARRAY_SIZE(families); family++) { | |
| for (connected = 0; connected < 2; connected++) { | |
| connection = connected ? "connected" : "unconnected"; | |
| for (i = 0; i < ARRAY_SIZE(cases); i++) { | |
| ret = run_case(family, connected, &cases[i], | |
| &skip); | |
| if (ret == KSFT_SKIP) | |
| ksft_test_result_skip("%s %s %s: %s\n", | |
| families[family], | |
| connection, | |
| cases[i].name, | |
| skip); | |
| else | |
| ksft_test_result(!ret, "%s %s %s\n", | |
| families[family], | |
| connection, | |
| cases[i].name); | |
| } | |
| } | |
| } | |
| if (!ksft_get_pass_cnt() && !ksft_get_fail_cnt()) { | |
| /* ksft_exit_skip() would add a result beyond the plan. */ | |
| ksft_print_cnts(); | |
| return KSFT_SKIP; | |
| } | |
| ksft_finished(); | |
| } |