diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-06 00:53:35 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-05-06 00:53:35 +0000 |
commit | 69c6a41ffb878ef98c9378ed4b1634a404cfaa7f (patch) | |
tree | b2a4f704565d62fbb129ab9dc3b35977c50e6e7f /tests/contrib/test_net.c | |
parent | Initial commit. (diff) | |
download | knot-upstream.tar.xz knot-upstream.zip |
Adding upstream version 2.7.6.upstream/2.7.6upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'tests/contrib/test_net.c')
-rw-r--r-- | tests/contrib/test_net.c | 759 |
1 files changed, 759 insertions, 0 deletions
diff --git a/tests/contrib/test_net.c b/tests/contrib/test_net.c new file mode 100644 index 0000000..9583362 --- /dev/null +++ b/tests/contrib/test_net.c @@ -0,0 +1,759 @@ +/* Copyright (C) 2015 CZ.NIC, z.s.p.o. <knot-dns@labs.nic.cz> + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see <http://www.gnu.org/licenses/>. +*/ + +#include <tap/basic.h> + +#include <assert.h> +#include <fcntl.h> +#include <poll.h> +#include <pthread.h> +#include <signal.h> +#include <stdbool.h> +#include <string.h> + +#include "libknot/errcode.h" +#include "contrib/net.h" +#include "contrib/sockaddr.h" + +#undef ENABLE_NET_UNREACHABLE_TEST +//#define ENABLE_NET_UNREACHABLE_TEST + +const int TIMEOUT = 5000; +const int TIMEOUT_SHORT = 500; + +/*! + * \brief Get loopback socket address with unset port. + */ +static struct sockaddr_storage addr_local(void) +{ + struct sockaddr_storage addr = { 0 }; + struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *)&addr; + + addr6->sin6_family = AF_INET6; + addr6->sin6_addr = in6addr_loopback; + + return addr; +} + +#ifdef ENABLE_NET_UNREACHABLE_TEST +/*! + * \brief Get unreachable IPv6 address. + * + * Allocated from 100::/64 (Discard-Only Address Block). + */ +static struct sockaddr_storage addr_unreachable(void) +{ + struct sockaddr_storage addr = { 0 }; + sockaddr_set(&addr, AF_INET6, "100::b1ac:h01e", 42); + + return addr; +} +#endif + +/*! + * \brief Get address of a socket. + */ +static struct sockaddr_storage addr_from_socket(int sock) +{ + struct sockaddr_storage addr = { 0 }; + socklen_t len = sizeof(addr); + getsockname(sock, (struct sockaddr *)&addr, &len); + + return addr; +} + +static const char *socktype_name(int type) +{ + switch (type) { + case SOCK_STREAM: return "TCP"; + case SOCK_DGRAM: return "UDP"; + default: return "unknown"; + } +} + +static bool socktype_is_stream(int type) +{ + return type == SOCK_STREAM; +} + +/* -- mock server ---------------------------------------------------------- */ + +#define LISTEN_BACKLOG 5 + +struct server_ctx; +typedef struct server_ctx server_ctx_t; + +typedef void (*server_cb)(int sock, void *data); + +/*! + * \brief Server context. + */ +struct server_ctx { + int sock; + int type; + bool terminate; + server_cb handler; + void *handler_data; + + pthread_t thr; + pthread_mutex_t mx; +}; + +static int poll_read(int sock) +{ + struct pollfd pfd = { .fd = sock, .events = POLLIN }; + return poll(&pfd, 1, TIMEOUT); +} + +static void server_handle(server_ctx_t *ctx) +{ + int remote = ctx->sock; + + assert(ctx->type == SOCK_STREAM || ctx->type == SOCK_DGRAM); + + if (socktype_is_stream(ctx->type)) { + remote = accept(ctx->sock, 0, 0); + if (remote < 0) { + return; + } + } + + pthread_mutex_lock(&ctx->mx); + server_cb handler = ctx->handler; + pthread_mutex_unlock(&ctx->mx); + handler(remote, ctx->handler_data); + + if (socktype_is_stream(ctx->type)) { + close(remote); + } +} + +/*! + * \brief Simple server. + * + * Terminated when a one-byte message is delivered. + */ +static void *server_main(void *_ctx) +{ + server_ctx_t *ctx = _ctx; + + for (;;) { + pthread_mutex_lock(&ctx->mx); + bool terminate = ctx->terminate; + pthread_mutex_unlock(&ctx->mx); + if (terminate) { + break; + } + + int r = poll_read(ctx->sock); + if (r == -1) { + if (errno == EINTR) { + continue; + } else { + break; + } + } else if (r == 0) { + continue; + } + + assert(r == 1); + server_handle(ctx); + } + + return NULL; +} + +static bool server_start(server_ctx_t *ctx, int sock, int type, + server_cb handler, void *handler_data) +{ + memset(ctx, 0, sizeof(*ctx)); + + ctx->sock = sock; + ctx->type = type; + ctx->handler = handler; + ctx->handler_data = handler_data; + + ctx->terminate = false; + + pthread_mutex_init(&ctx->mx, NULL); + return (pthread_create(&ctx->thr, NULL, server_main, ctx) == 0); +} + +static void server_stop(server_ctx_t *ctx) +{ + pthread_mutex_lock(&ctx->mx); + ctx->terminate = true; + pthread_mutex_unlock(&ctx->mx); + + pthread_kill(ctx->thr, SIGUSR1); + pthread_join(ctx->thr, NULL); +} + +/* -- tests ---------------------------------------------------------------- */ + +static void handler_echo(int sock, void *_server) +{ + server_ctx_t *server = _server; + uint8_t buffer[16] = { 0 }; + + struct sockaddr_storage remote = { 0 }; + struct sockaddr_storage *addr = NULL; + if (!socktype_is_stream(server->type)) { + addr = &remote; + } + + int in = net_recv(sock, buffer, sizeof(buffer), addr, TIMEOUT); + if (in <= 0) { + return; + } + + net_send(sock, buffer, in, (struct sockaddr *)addr, TIMEOUT); +} + +static void test_connected_one(const struct sockaddr_storage *server_addr, + const struct sockaddr_storage *source_addr, + int type, const char *name, const char *addr_name) +{ + int r; + + int client = net_connected_socket(type, (struct sockaddr *)server_addr, NULL); + ok(client >= 0, "%s, %s: client, create connected socket", name, addr_name); + + const uint8_t out[] = "test message"; + const size_t out_len = sizeof(out); + if (socktype_is_stream(type)) { + r = net_stream_send(client, out, out_len, TIMEOUT); + } else { + r = net_dgram_send(client, out, out_len, NULL); + } + ok(r == out_len, "%s, %s: client, send message", name, addr_name); + + r = net_is_connected(client); + ok(r, "%s, %s: client, is connected", name, addr_name); + + uint8_t in[128] = { 0 }; + if (socktype_is_stream(type)) { + r = net_stream_recv(client, in, sizeof(in), TIMEOUT); + } else { + r = net_dgram_recv(client, in, sizeof(in), TIMEOUT); + } + ok(r == out_len && memcmp(out, in, out_len) == 0, + "%s, %s: client, receive message", name, addr_name); + + close(client); +} + +static void test_connected(int type) +{ + const char *name = socktype_name(type); + const struct sockaddr_storage empty_addr = { 0 }; + const struct sockaddr_storage local_addr = addr_local(); + + int r; + + // setup server + + int server = net_bound_socket(type, (struct sockaddr *)&local_addr, 0); + ok(server >= 0, "%s: server, create bound socket", name); + + if (socktype_is_stream(type)) { + r = listen(server, LISTEN_BACKLOG); + ok(r == 0, "%s: server, start listening", name); + } + + server_ctx_t server_ctx = { 0 }; + r = server_start(&server_ctx, server, type, handler_echo, &server_ctx); + ok(r, "%s: server, start", name); + + const struct sockaddr_storage server_addr = addr_from_socket(server); + + // connected socket, send and receive + + test_connected_one(&server_addr, NULL, type, name, "NULL source"); + test_connected_one(&server_addr, &empty_addr, type, name, "zero source"); + test_connected_one(&server_addr, &local_addr, type, name, "valid source"); + + // cleanup + + server_stop(&server_ctx); + close(server); +} + +static void handler_noop(int sock, void *data) +{ +} + +static void test_unconnected(void) +{ + int r = 0; + int sock = -1; + const struct sockaddr_storage local = addr_local(); + + uint8_t buffer[] = { 'k', 'n', 'o', 't' }; + ssize_t buffer_len = sizeof(buffer); + + // server + + int server = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&local, 0); + ok(server >= 0, "UDP, create server socket"); + + server_ctx_t server_ctx = { 0 }; + r = server_start(&server_ctx, server, SOCK_DGRAM, handler_noop, NULL); + ok(r, "UDP, start server"); + + // UDP + + sock = net_unbound_socket(SOCK_DGRAM, (struct sockaddr *)&local); + ok(sock >= 0, "UDP, create unbound socket"); + + ok(!net_is_connected(sock), "UDP, is not connected"); + + r = net_dgram_send(sock, buffer, buffer_len, NULL); + ok(r == KNOT_ECONN, "UDP, send failure on unconnected socket"); + + r = net_dgram_recv(sock, buffer, buffer_len, TIMEOUT_SHORT); + ok(r == KNOT_ETIMEOUT, "UDP, receive timeout on unconnected socket"); + + struct sockaddr_storage server_addr = addr_from_socket(server); + r = net_dgram_send(sock, buffer, buffer_len, (struct sockaddr *)&server_addr); + ok(r == buffer_len, "UDP, send on defined address"); + + close(sock); + + // TCP + + sock = net_unbound_socket(SOCK_STREAM, (struct sockaddr *)&local); + ok(sock >= 0, "TCP, create unbound socket"); + + ok(!net_is_connected(sock), "TCP, is not connected"); + +#ifdef __linux__ + const int expected = KNOT_ECONN; + const char *expected_msg = "failure"; + const int expected_timeout = TIMEOUT; +#else + const int expected = KNOT_ETIMEOUT; + const char *expected_msg = "timeout"; + const int expected_timeout = TIMEOUT_SHORT; +#endif + + r = net_stream_send(sock, buffer, buffer_len, expected_timeout); + ok(r == expected, "TCP, send %s on unconnected socket", expected_msg); + + r = net_stream_recv(sock, buffer, sizeof(buffer), expected_timeout); + ok(r == expected, "TCP, receive %s on unconnected socket", expected_msg); + + close(sock); + + // server termination + + server_stop(&server_ctx); + close(server); +} + +static void test_refused(void) +{ + int r = -1; + + struct sockaddr_storage addr = { 0 }; + uint8_t buffer[1] = { 0 }; + int server, client; + + // unreachable remote + +#ifdef ENABLE_NET_UNREACHABLE_TEST + addr = addr_unreachable(); + + client = net_connected_socket(SOCK_STREAM, &addr, NULL); + ok(client >= 0, "client, connected"); + + tv = TIMEOUT_SHORT; + r = net_stream_send(client, (uint8_t *)"", 1, &tv); + ok(r == KNOT_ETIMEOUT, "client, timeout on write"); + close(client); + + client = net_connected_socket(SOCK_STREAM, &addr, NULL); + ok(client >= 0, "client, connected"); + + tv = TIMEOUT_SHORT; + r = net_stream_recv(client, buffer, sizeof(buffer), &tv); + ok(r == KNOT_ETIMEOUT, "client, timeout on read"); + close(client); +#else + skip("unreachable tests disabled"); +#endif + + // listening, not accepting + + addr = addr_local(); + server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr, 0); + ok(server >= 0, "server, create server"); + addr = addr_from_socket(server); + + r = listen(server, LISTEN_BACKLOG); + ok(r == 0, "server, start listening"); + + client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL); + ok(client >= 0, "client, connect"); + + r = net_stream_send(client, (uint8_t *)"", 1, TIMEOUT); + ok(r == 1, "client, successful write"); + + r = net_stream_recv(client, buffer, sizeof(buffer), TIMEOUT_SHORT); + ok(r == KNOT_ETIMEOUT, "client, timeout on read"); + + close(client); + + // listening, closed immediately + + client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL); + ok(client >= 0, "client, connect"); + + r = close(server); + ok(r == 0, "server, close socket"); + + r = net_stream_send(client, (uint8_t *)"", 1, TIMEOUT); + ok(r == KNOT_ECONN, "client, refused on write"); + + close(client); +} + +struct dns_handler_ctx { + const uint8_t *expected; + int len; + bool raw; + bool success; +}; + +static void _sync(int remote, int send) +{ + uint8_t buf[1] = { 0 }; + int r; + if (send) { + r = net_stream_send(remote, buf, sizeof(buf), TIMEOUT); + } else { + r = net_stream_recv(remote, buf, sizeof(buf), TIMEOUT); + + } + assert(r == sizeof(buf)); + (void)r; +} + +static void sync_signal(int remote) +{ + _sync(remote, true); +} + +static void sync_wait(int remote) +{ + _sync(remote, false); +} + +static void handler_dns(int sock, void *_ctx) +{ + struct dns_handler_ctx *ctx = _ctx; + + uint8_t in[16] = { 0 }; + int in_len = 0; + + sync_signal(sock); + + if (ctx->raw) { + in_len = net_stream_recv(sock, in, sizeof(in), TIMEOUT); + } else { + in_len = net_dns_tcp_recv(sock, in, sizeof(in), TIMEOUT); + } + + ctx->success = in_len == ctx->len && + (ctx->len < 0 || memcmp(in, ctx->expected, in_len) == 0); +} + +static void dns_send_hello(int sock) +{ + net_dns_tcp_send(sock, (uint8_t *)"wimbgunts", 9, TIMEOUT); +} + +static void dns_send_fragmented(int sock) +{ + struct fragment { const uint8_t *data; size_t len; }; + + const struct fragment fragments[] = { + { (uint8_t *)"\x00", 1 }, + { (uint8_t *)"\x08""qu", 3 }, + { (uint8_t *)"oopisk", 6 }, + { NULL } + }; + + for (const struct fragment *f = fragments; f->len > 0; f++) { + net_stream_send(sock, f->data, f->len, TIMEOUT); + } +} + +static void dns_send_incomplete(int sock) +{ + net_stream_send(sock, (uint8_t *)"\x00\x08""korm", 6, TIMEOUT); +} + +static void dns_send_trailing(int sock) +{ + net_stream_send(sock, (uint8_t *)"\x00\x05""bloitxx", 9, TIMEOUT); +} + +static void test_dns_tcp(void) +{ + struct testcase { + const char *name; + const uint8_t *expected; + size_t expected_len; + bool expected_raw; + void (*send_callback)(int sock); + }; + + const struct testcase testcases[] = { + { "single DNS", (uint8_t *)"wimbgunts", 9, false, dns_send_hello }, + { "single RAW", (uint8_t *)"\x00\x09""wimbgunts", 11, true, dns_send_hello }, + { "fragmented", (uint8_t *)"quoopisk", 8, false, dns_send_fragmented }, + { "incomplete", NULL, KNOT_ECONN, false, dns_send_incomplete }, + { "trailing garbage", (uint8_t *)"bloit", 5, false, dns_send_trailing }, + { NULL } + }; + + for (const struct testcase *t = testcases; t->name != NULL; t++) { + struct dns_handler_ctx handler_ctx = { + .expected = t->expected, + .len = t->expected_len, + .raw = t->expected_raw, + .success = false + }; + + struct sockaddr_storage addr = addr_local(); + int server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr, 0); + ok(server >= 0, "%s, server, create socket", t->name); + + int r = listen(server, LISTEN_BACKLOG); + ok(r == 0, "%s, server, start listening", t->name); + + server_ctx_t server_ctx = { 0 }; + r = server_start(&server_ctx, server, SOCK_STREAM, handler_dns, &handler_ctx); + ok(r, "%s, server, start handler", t->name); + + addr = addr_from_socket(server); + int client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr, NULL); + ok(client >= 0, "%s, client, create connected socket", t->name); + + sync_wait(client); + t->send_callback(client); + + close(client); + server_stop(&server_ctx); + close(server); + + ok(handler_ctx.success, "%s, expected result", t->name); + } +} + +static bool socket_is_blocking(int sock) +{ + return fcntl(sock, F_GETFL, O_NONBLOCK) == 0; +} + +static void test_nonblocking_mode(int type) +{ + const char *name = socktype_name(type); + const struct sockaddr_storage addr = addr_local(); + + int client = net_unbound_socket(type, (struct sockaddr *)&addr); + ok(client >= 0, "%s: unbound, create", name); + ok(!socket_is_blocking(client), "%s: unbound, nonblocking mode", name); + close(client); + + int server = net_bound_socket(type, (struct sockaddr *)&addr, 0); + ok(server >= 0, "%s: bound, create", name); + ok(!socket_is_blocking(server), "%s: bound, nonblocking mode", name); + + if (socktype_is_stream(type)) { + int r = listen(server, LISTEN_BACKLOG); + ok(r == 0, "%s: bound, start listening", name); + } + + struct sockaddr_storage server_addr = addr_from_socket(server); + client = net_connected_socket(type, (struct sockaddr *)&server_addr, NULL); + ok(client >= 0, "%s: connected, create", name); + ok(!socket_is_blocking(client), "%s: connected, nonblocking mode", name); + + close(client); + close(server); +} + +static void test_nonblocking_accept(void) +{ + int r; + + // create server + + struct sockaddr_storage addr_server = addr_local(); + + int server = net_bound_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, 0); + ok(server >= 0, "server, create socket"); + + r = listen(server, LISTEN_BACKLOG); + ok(r == 0, "server, start listening"); + + addr_server = addr_from_socket(server); + + // create client + + int client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, NULL); + ok(client >= 0, "client, create connected socket"); + + struct sockaddr_storage addr_client = addr_from_socket(client); + + // accept connection + + r = poll_read(server); + ok(r == 1, "server, pending connection"); + + struct sockaddr_storage addr_accepted = { 0 }; + int accepted = net_accept(server, &addr_accepted); + ok(accepted >= 0, "server, accept connection"); + + ok(!socket_is_blocking(accepted), "accepted, nonblocking mode"); + + ok(sockaddr_cmp((struct sockaddr *)&addr_client, + (struct sockaddr *)&addr_accepted) == 0, + "accepted, correct address"); + + close(client); + + // client reconnect + + close(client); + client = net_connected_socket(SOCK_STREAM, (struct sockaddr *)&addr_server, NULL); + ok(client >= 0, "client, reconnect"); + + r = poll_read(server); + ok(r == 1, "server, pending connection"); + + accepted = net_accept(server, NULL); + ok(accepted >= 0, "server, accept connection (no remote address)"); + + ok(!socket_is_blocking(accepted), "accepted, nonblocking mode"); + + // cleanup + + close(client); + close(server); +} + +static void test_socket_types(void) +{ + struct sockaddr_storage addr = addr_local(); + + struct testcase { + const char *name; + int type; + bool is_stream; + }; + + const struct testcase testcases[] = { + { "UDP", SOCK_DGRAM, false }, + { "TCP", SOCK_STREAM, true }, + { NULL } + }; + + for (const struct testcase *t = testcases; t->name != NULL; t++) { + int sock = net_unbound_socket(t->type, (struct sockaddr *)&addr); + ok(sock >= 0, "%s, create socket", t->name); + + is_int(t->type, net_socktype(sock), "%s, socket type", t->name); + + ok(net_is_stream(sock) == t->is_stream, "%s, is stream", t->name); + + close(sock); + } + + is_int(AF_UNSPEC, net_socktype(-1), "invalid, socket type"); + ok(!net_is_stream(-1), "invalid, is stream"); +} + +static void test_bind_multiple(void) +{ + const struct sockaddr_storage addr = addr_local(); + + // bind first socket + + int sock_one = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&addr, NET_BIND_MULTIPLE); + if (sock_one == KNOT_ENOTSUP) { + skip("not supported on this system"); + return; + } + ok(sock_one >= 0, "bind first socket"); + + // bind second socket to the same address + + const struct sockaddr_storage addr_one = addr_from_socket(sock_one); + int sock_two = net_bound_socket(SOCK_DGRAM, (struct sockaddr *)&addr_one, NET_BIND_MULTIPLE); + ok(sock_two >= 0, "bind second socket"); + + // compare sockets + + ok(sock_one != sock_two, "descriptors are different"); + + const struct sockaddr_storage addr_two = addr_from_socket(sock_two); + ok(sockaddr_cmp((struct sockaddr *)&addr_one, + (struct sockaddr *)&addr_two) == 0, + "addresses are the same"); + + close(sock_one); + close(sock_two); +} + +static void signal_noop(int sig) +{ +} + +int main(int argc, char *argv[]) +{ + plan_lazy(); + + signal(SIGUSR1, signal_noop); + + diag("nonblocking mode"); + test_nonblocking_mode(SOCK_DGRAM); + test_nonblocking_mode(SOCK_STREAM); + test_nonblocking_accept(); + + diag("socket types"); + test_socket_types(); + + diag("connected sockets"); + test_connected(SOCK_DGRAM); + test_connected(SOCK_STREAM); + + diag("unconnected sockets"); + test_unconnected(); + + diag("refused connections"); + test_refused(); + + diag("DNS messages over TCP"); + test_dns_tcp(); + + diag("flag NET_BIND_MULTIPLE"); + test_bind_multiple(); + + return 0; +} |