commit 873e239a4c3d8ec235c27439c1bdc5bbf8aa1818 Author: Florian Weimer Date: Wed Oct 14 10:54:39 2020 +0200 support: Provide a way to reorder responses within the DNS test server diff --git a/support/Makefile b/support/Makefile index 3c940aa6a7bdfc99..37d5dcc92a5c6dee 100644 --- a/support/Makefile +++ b/support/Makefile @@ -35,6 +35,8 @@ libsupport-routines = \ ignore_stderr \ next_to_fault \ oom_error \ + resolv_response_context_duplicate \ + resolv_response_context_free \ resolv_test \ set_fortify_handler \ support-xfstat \ diff --git a/support/resolv_response_context_duplicate.c b/support/resolv_response_context_duplicate.c new file mode 100644 index 0000000000000000..f9c5c3462ad053ec --- /dev/null +++ b/support/resolv_response_context_duplicate.c @@ -0,0 +1,37 @@ +/* Duplicate a response context used in DNS resolver tests. + Copyright (C) 2020 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include +#include + +struct resolv_response_context * +resolv_response_context_duplicate (const struct resolv_response_context *ctx) +{ + struct resolv_response_context *result = xmalloc (sizeof (*result)); + memcpy (result, ctx, sizeof (*result)); + if (result->client_address != NULL) + { + result->client_address = xmalloc (result->client_address_length); + memcpy (result->client_address, ctx->client_address, + result->client_address_length); + } + result->query_buffer = xmalloc (result->query_length); + memcpy (result->query_buffer, ctx->query_buffer, result->query_length); + return result; +} diff --git a/support/resolv_response_context_free.c b/support/resolv_response_context_free.c new file mode 100644 index 0000000000000000..b88c05ffd4acfdd4 --- /dev/null +++ b/support/resolv_response_context_free.c @@ -0,0 +1,28 @@ +/* Free a response context used in DNS resolver tests. + Copyright (C) 2020 Free Software Foundation, Inc. + This file is part of the GNU C Library. + + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + The GNU C Library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with the GNU C Library; if not, see + . */ + +#include +#include + +void +resolv_response_context_free (struct resolv_response_context *ctx) +{ + free (ctx->query_buffer); + free (ctx->client_address); + free (ctx); +} diff --git a/support/resolv_test.c b/support/resolv_test.c index 28af227cb5ed901c..8cca4e6cf723de28 100644 --- a/support/resolv_test.c +++ b/support/resolv_test.c @@ -434,9 +434,9 @@ resolv_response_buffer (const struct resolv_response_builder *b) return result; } -static struct resolv_response_builder * -response_builder_allocate - (const unsigned char *query_buffer, size_t query_length) +struct resolv_response_builder * +resolv_response_builder_allocate (const unsigned char *query_buffer, + size_t query_length) { struct resolv_response_builder *b = xmalloc (sizeof (*b)); memset (b, 0, offsetof (struct resolv_response_builder, buffer)); @@ -445,8 +445,8 @@ response_builder_allocate return b; } -static void -response_builder_free (struct resolv_response_builder *b) +void +resolv_response_builder_free (struct resolv_response_builder *b) { tdestroy (b->compression_offsets, free); free (b); @@ -661,13 +661,17 @@ server_thread_udp_process_one (struct resolv_test *obj, int server_index) struct resolv_response_context ctx = { + .test = obj, + .client_address = &peer, + .client_address_length = peerlen, .query_buffer = query, .query_length = length, .server_index = server_index, .tcp = false, .edns = qinfo.edns, }; - struct resolv_response_builder *b = response_builder_allocate (query, length); + struct resolv_response_builder *b + = resolv_response_builder_allocate (query, length); obj->config.response_callback (&ctx, b, qinfo.qname, qinfo.qclass, qinfo.qtype); @@ -684,7 +688,7 @@ server_thread_udp_process_one (struct resolv_test *obj, int server_index) if (b->offset >= 12) printf ("info: UDP server %d: sending response:" " %zu bytes, RCODE %d (for %s/%u/%u)\n", - server_index, b->offset, b->buffer[3] & 0x0f, + ctx.server_index, b->offset, b->buffer[3] & 0x0f, qinfo.qname, qinfo.qclass, qinfo.qtype); else printf ("info: UDP server %d: sending response: %zu bytes" @@ -694,23 +698,31 @@ server_thread_udp_process_one (struct resolv_test *obj, int server_index) if (b->truncate_bytes > 0) printf ("info: truncated by %u bytes\n", b->truncate_bytes); } - size_t to_send = b->offset; - if (to_send < b->truncate_bytes) - to_send = 0; - else - to_send -= b->truncate_bytes; - - /* Ignore most errors here because the other end may have closed - the socket. */ - if (sendto (obj->servers[server_index].socket_udp, - b->buffer, to_send, 0, - (struct sockaddr *) &peer, peerlen) < 0) - TEST_VERIFY_EXIT (errno != EBADF); + resolv_response_send_udp (&ctx, b); } - response_builder_free (b); + resolv_response_builder_free (b); return true; } +void +resolv_response_send_udp (const struct resolv_response_context *ctx, + struct resolv_response_builder *b) +{ + TEST_VERIFY_EXIT (!ctx->tcp); + size_t to_send = b->offset; + if (to_send < b->truncate_bytes) + to_send = 0; + else + to_send -= b->truncate_bytes; + + /* Ignore most errors here because the other end may have closed + the socket. */ + if (sendto (ctx->test->servers[ctx->server_index].socket_udp, + b->buffer, to_send, 0, + ctx->client_address, ctx->client_address_length) < 0) + TEST_VERIFY_EXIT (errno != EBADF); +} + /* UDP thread_callback function. Variant for one thread per server. */ static void @@ -897,14 +909,15 @@ server_thread_tcp_client (void *arg) struct resolv_response_context ctx = { + .test = closure->obj, .query_buffer = query_buffer, .query_length = query_length, .server_index = closure->server_index, .tcp = true, .edns = qinfo.edns, }; - struct resolv_response_builder *b = response_builder_allocate - (query_buffer, query_length); + struct resolv_response_builder *b + = resolv_response_builder_allocate (query_buffer, query_length); closure->obj->config.response_callback (&ctx, b, qinfo.qname, qinfo.qclass, qinfo.qtype); @@ -936,7 +949,7 @@ server_thread_tcp_client (void *arg) writev_fully (closure->client_socket, buffers, 2); } bool close_flag = b->close; - response_builder_free (b); + resolv_response_builder_free (b); free (query_buffer); if (close_flag) break; diff --git a/support/resolv_test.h b/support/resolv_test.h index be736aead40cd0cc..ff5571dace92c936 100644 --- a/support/resolv_test.h +++ b/support/resolv_test.h @@ -35,25 +35,36 @@ struct resolv_edns_info uint16_t payload_size; }; +/* This opaque struct collects information about the resolver testing + currently in progress. */ +struct resolv_test; + /* This struct provides context information when the response callback specified in struct resolv_redirect_config is invoked. */ struct resolv_response_context { - const unsigned char *query_buffer; + struct resolv_test *test; + void *client_address; + size_t client_address_length; + unsigned char *query_buffer; size_t query_length; int server_index; bool tcp; struct resolv_edns_info edns; }; +/* Produces a deep copy of the context. */ +struct resolv_response_context * + resolv_response_context_duplicate (const struct resolv_response_context *); + +/* Frees the copy. For the context passed to the response function, + this happens implicitly. */ +void resolv_response_context_free (struct resolv_response_context *); + /* This opaque struct is used to construct responses from within the response callback function. */ struct resolv_response_builder; -/* This opaque struct collects information about the resolver testing - currently in progress. */ -struct resolv_test; - enum { /* Maximum number of test servers supported by the framework. */ @@ -188,6 +199,22 @@ void resolv_response_close (struct resolv_response_builder *); /* The size of the response packet built so far. */ size_t resolv_response_length (const struct resolv_response_builder *); +/* Allocates a response builder tied to a specific query packet, + starting at QUERY_BUFFER, containing QUERY_LENGTH bytes. */ +struct resolv_response_builder * + resolv_response_builder_allocate (const unsigned char *query_buffer, + size_t query_length); + +/* Deallocates a response buffer. */ +void resolv_response_builder_free (struct resolv_response_builder *); + +/* Sends a UDP response using a specific context. This can be used to + reorder or duplicate responses, along with + resolv_response_context_duplicate and + response_builder_allocate. */ +void resolv_response_send_udp (const struct resolv_response_context *, + struct resolv_response_builder *); + __END_DECLS #endif /* SUPPORT_RESOLV_TEST_H */