mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-29 05:28:00 +00:00
Code Issues Releases Wiki Activity
bind/lib/isc/tests/doh_test.c
Ondřej Surý 63fe9312ff Give the unit tests a big overhaul 
The unit tests contain a lot of duplicated code and here's an attempt
to reduce code duplication.

This commit does several things:

1. Remove #ifdef HAVE_CMOCKA - we already solve this with automake
   conditionals.

2. Create a set of ISC_TEST_* and ISC_*_TEST_ macros to wrap the test
   implementations, test lists, and the main test routine, so we don't
   have to repeat this all over again.  The macros were modeled after
   libuv test suite but adapted to cmocka as the test driver.

   A simple example of a unit test would be:

    ISC_RUN_TEST_IMPL(test1) { assert_true(true); }

    ISC_TEST_LIST_START
    ISC_TEST_ENTRY(test1)
    ISC_TEST_LIST_END

    ISC_TEST_MAIN (Discussion: Should this be ISC_TEST_RUN ?)

   For more complicated examples including group setup and teardown
   functions, and per-test setup and teardown functions.

3. The macros prefix the test functions and cmocka entries, so the name
   of the test can now match the tested function name, and we don't have
   to append `_test` because `run_test_` is automatically prepended to
   the main test function, and `setup_test_` and `teardown_test_` is
   prepended to setup and teardown function.

4. Update all the unit tests to use the new syntax and fix a few bits
   here and there.

5. In the future, we can separate the test declarations and test
   implementations which are going to greatly help with uncluttering the
   bigger unit tests like doh_test and netmgr_test, because the test
   implementations are not declared static (see `ISC_RUN_TEST_DECLARE`
   and `ISC_RUN_TEST_IMPL` for more details.

NOTE: This heavily relies on preprocessor macros, but the result greatly
outweighs all the negatives of using the macros.  There's less
duplicated code, the tests are more uniform and the implementation can
be more flexible.
2022-05-28 14:52:56 -07:00

2311 lines
59 KiB
C
Raw Blame History

/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* SPDX-License-Identifier: MPL-2.0
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <inttypes.h>
#include <sched.h> /* IWYU pragma: keep */
#include <setjmp.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <time.h>
#include <unistd.h>
#define UNIT_TESTING
#include <cmocka.h>
#include <isc/atomic.h>
#include <isc/buffer.h>
#include <isc/condition.h>
#include <isc/mutex.h>
#include <isc/netmgr.h>
#include <isc/nonce.h>
#include <isc/os.h>
#include <isc/print.h>
#include <isc/refcount.h>
#include <isc/sockaddr.h>
#include <isc/thread.h>
#include <isc/uv.h>
#include "uv_wrap.h"
#define KEEP_BEFORE
#include "../netmgr/http.c"
#include "../netmgr/netmgr-int.h"
#include "../netmgr/socket.c"
#include "../netmgr_p.h"
#include <isc/test.h>
#define MAX_NM 2
static isc_sockaddr_t tcp_listen_addr;
static uint64_t send_magic = 0;
static uint64_t stop_magic = 0;
static uv_buf_t send_msg = { .base = (char *)&send_magic,
.len = sizeof(send_magic) };
static atomic_int_fast64_t active_cconnects = 0;
static atomic_int_fast64_t nsends = 0;
static atomic_int_fast64_t ssends = 0;
static atomic_int_fast64_t sreads = 0;
static atomic_int_fast64_t csends = 0;
static atomic_int_fast64_t creads = 0;
static atomic_int_fast64_t ctimeouts = 0;
static atomic_int_fast64_t total_sends = 0;
static atomic_bool was_error = false;
static bool reuse_supported = true;
static bool noanswer = false;
static atomic_bool POST = true;
static atomic_bool slowdown = false;
static atomic_bool use_TLS = false;
static isc_tlsctx_t *server_tlsctx = NULL;
static isc_tlsctx_t *client_tlsctx = NULL;
static isc_tlsctx_client_session_cache_t *client_sess_cache = NULL;
static isc_quota_t listener_quota;
static atomic_bool check_listener_quota = false;
static isc_nm_http_endpoints_t *endpoints = NULL;
static bool skip_long_tests = false;
/* Timeout for soft-timeout tests (0.05 seconds) */
#define T_SOFT 50
#define NSENDS 100
#define NWRITES 10
#define CHECK_RANGE_FULL(v) \
{ \
int __v = atomic_load(&v); \
assert_true(__v >= atomic_load(&total_sends)); \
}
#define CHECK_RANGE_HALF(v) \
{ \
int __v = atomic_load(&v); \
assert_true(__v >= atomic_load(&total_sends) / 2); \
}
/* Enable this to print values while running tests */
#undef PRINT_DEBUG
#ifdef PRINT_DEBUG
#define X(v) fprintf(stderr, #v " = %" PRIu64 "\n", atomic_load(&v))
#else
#define X(v)
#endif
#define SKIP_IN_CI \
if (skip_long_tests) { \
skip(); \
return; \
}
typedef struct csdata {
isc_nm_recv_cb_t reply_cb;
void *cb_arg;
isc_region_t region;
} csdata_t;
static void
connect_send_cb(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
csdata_t data;
REQUIRE(VALID_NMHANDLE(handle));
(void)atomic_fetch_sub(&active_cconnects, 1);
memmove(&data, arg, sizeof(data));
isc_mem_put(handle->sock->mgr->mctx, arg, sizeof(data));
if (result != ISC_R_SUCCESS) {
goto error;
}
result = isc__nm_http_request(handle, &data.region, data.reply_cb,
data.cb_arg);
if (result != ISC_R_SUCCESS) {
goto error;
}
isc_mem_put(handle->sock->mgr->mctx, data.region.base,
data.region.length);
return;
error:
data.reply_cb(handle, result, NULL, data.cb_arg);
isc_mem_put(handle->sock->mgr->mctx, data.region.base,
data.region.length);
if (result == ISC_R_TOOMANYOPENFILES) {
atomic_store(&slowdown, true);
} else {
atomic_store(&was_error, true);
}
}
static void
connect_send_request(isc_nm_t *mgr, const char *uri, bool post,
isc_region_t *region, isc_nm_recv_cb_t cb, void *cbarg,
bool tls, unsigned int timeout) {
isc_region_t copy;
csdata_t *data = NULL;
isc_tlsctx_t *ctx = NULL;
copy = (isc_region_t){ .base = isc_mem_get(mgr->mctx, region->length),
.length = region->length };
memmove(copy.base, region->base, region->length);
data = isc_mem_get(mgr->mctx, sizeof(*data));
*data = (csdata_t){ .reply_cb = cb, .cb_arg = cbarg, .region = copy };
if (tls) {
ctx = client_tlsctx;
}
isc_nm_httpconnect(mgr, NULL, &tcp_listen_addr, uri, post,
connect_send_cb, data, ctx, client_sess_cache,
timeout);
}
static int
setup_ephemeral_port(isc_sockaddr_t *addr, sa_family_t family) {
isc_result_t result;
socklen_t addrlen = sizeof(*addr);
int fd;
int r;
isc_sockaddr_fromin6(addr, &in6addr_loopback, 0);
fd = socket(AF_INET6, family, 0);
if (fd < 0) {
perror("setup_ephemeral_port: socket()");
return (-1);
}
r = bind(fd, (const struct sockaddr *)&addr->type.sa,
sizeof(addr->type.sin6));
if (r != 0) {
perror("setup_ephemeral_port: bind()");
isc__nm_closesocket(fd);
return (r);
}
r = getsockname(fd, (struct sockaddr *)&addr->type.sa, &addrlen);
if (r != 0) {
perror("setup_ephemeral_port: getsockname()");
isc__nm_closesocket(fd);
return (r);
}
result = isc__nm_socket_reuse(fd);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTIMPLEMENTED) {
fprintf(stderr,
"setup_ephemeral_port: isc__nm_socket_reuse(): %s",
isc_result_totext(result));
close(fd);
return (-1);
}
result = isc__nm_socket_reuse_lb(fd);
if (result != ISC_R_SUCCESS && result != ISC_R_NOTIMPLEMENTED) {
fprintf(stderr,
"setup_ephemeral_port: isc__nm_socket_reuse_lb(): %s",
isc_result_totext(result));
close(fd);
return (-1);
}
if (result == ISC_R_NOTIMPLEMENTED) {
reuse_supported = false;
}
#if IPV6_RECVERR
#define setsockopt_on(socket, level, name) \
setsockopt(socket, level, name, &(int){ 1 }, sizeof(int))
r = setsockopt_on(fd, IPPROTO_IPV6, IPV6_RECVERR);
if (r != 0) {
perror("setup_ephemeral_port");
close(fd);
return (r);
}
#endif
return (fd);
}
/* Generic */
static void
noop_read_cb(isc_nmhandle_t *handle, isc_result_t result, isc_region_t *region,
void *cbarg) {
UNUSED(handle);
UNUSED(result);
UNUSED(region);
UNUSED(cbarg);
}
thread_local uint8_t tcp_buffer_storage[4096];
thread_local size_t tcp_buffer_length = 0;
static int
setup_test(void **state) {
char *env_workers = getenv("ISC_TASK_WORKERS");
size_t nworkers;
uv_os_sock_t tcp_listen_sock = -1;
isc_nm_t **nm = NULL;
tcp_listen_addr = (isc_sockaddr_t){ .length = 0 };
tcp_listen_sock = setup_ephemeral_port(&tcp_listen_addr, SOCK_STREAM);
if (tcp_listen_sock < 0) {
return (-1);
}
close(tcp_listen_sock);
tcp_listen_sock = -1;
if (env_workers != NULL) {
workers = atoi(env_workers);
} else {
workers = isc_os_ncpus();
}
INSIST(workers > 0);
nworkers = ISC_MAX(ISC_MIN(workers, 32), 1);
if (!reuse_supported || getenv("CI") != NULL) {
skip_long_tests = true;
}
atomic_store(&total_sends, NSENDS * NWRITES);
atomic_store(&nsends, atomic_load(&total_sends));
atomic_store(&csends, 0);
atomic_store(&creads, 0);
atomic_store(&sreads, 0);
atomic_store(&ssends, 0);
atomic_store(&ctimeouts, 0);
atomic_store(&active_cconnects, 0);
atomic_store(&was_error, false);
atomic_store(&POST, false);
atomic_store(&use_TLS, false);
noanswer = false;
isc_nonce_buf(&send_magic, sizeof(send_magic));
isc_nonce_buf(&stop_magic, sizeof(stop_magic));
if (send_magic == stop_magic) {
return (-1);
}
nm = isc_mem_get(mctx, MAX_NM * sizeof(nm[0]));
for (size_t i = 0; i < MAX_NM; i++) {
isc__netmgr_create(mctx, nworkers, &nm[i]);
assert_non_null(nm[i]);
}
server_tlsctx = NULL;
isc_tlsctx_createserver(NULL, NULL, &server_tlsctx);
isc_tlsctx_enable_http2server_alpn(server_tlsctx);
client_tlsctx = NULL;
isc_tlsctx_createclient(&client_tlsctx);
isc_tlsctx_enable_http2client_alpn(client_tlsctx);
client_sess_cache = isc_tlsctx_client_session_cache_new(
mctx, client_tlsctx,
ISC_TLSCTX_CLIENT_SESSION_CACHE_DEFAULT_SIZE);
isc_quota_init(&listener_quota, 0);
atomic_store(&check_listener_quota, false);
INSIST(endpoints == NULL);
endpoints = isc_nm_http_endpoints_new(mctx);
*state = nm;
return (0);
}
static int
teardown_test(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
for (size_t i = 0; i < MAX_NM; i++) {
isc__netmgr_destroy(&nm[i]);
assert_null(nm[i]);
}
isc_mem_put(mctx, nm, MAX_NM * sizeof(nm[0]));
if (server_tlsctx != NULL) {
isc_tlsctx_free(&server_tlsctx);
}
if (client_tlsctx != NULL) {
isc_tlsctx_free(&client_tlsctx);
}
isc_tlsctx_client_session_cache_detach(&client_sess_cache);
isc_quota_destroy(&listener_quota);
isc_nm_http_endpoints_detach(&endpoints);
return (0);
}
thread_local size_t nwrites = NWRITES;
static void
sockaddr_to_url(isc_sockaddr_t *sa, const bool https, char *outbuf,
size_t outbuf_len, const char *append) {
isc_nm_http_makeuri(https, sa, NULL, 0, append, outbuf, outbuf_len);
}
static isc_quota_t *
init_listener_quota(size_t nthreads) {
isc_quota_t *quotap = NULL;
if (atomic_load(&check_listener_quota)) {
unsigned max_quota = ISC_MAX(nthreads / 2, 1);
isc_quota_max(&listener_quota, max_quota);
quotap = &listener_quota;
}
return (quotap);
}
static void
doh_receive_reply_cb(isc_nmhandle_t *handle, isc_result_t eresult,
isc_region_t *region, void *cbarg) {
assert_non_null(handle);
UNUSED(cbarg);
UNUSED(region);
if (eresult == ISC_R_SUCCESS) {
(void)atomic_fetch_sub(&nsends, 1);
atomic_fetch_add(&csends, 1);
atomic_fetch_add(&creads, 1);
} else {
/* We failed to connect; try again */
atomic_store(&was_error, true);
}
}
static void
doh_reply_sent_cb(isc_nmhandle_t *handle, isc_result_t eresult, void *cbarg) {
UNUSED(eresult);
UNUSED(cbarg);
assert_non_null(handle);
if (eresult == ISC_R_SUCCESS) {
atomic_fetch_add(&ssends, 1);
}
}
static void
doh_receive_request_cb(isc_nmhandle_t *handle, isc_result_t eresult,
isc_region_t *region, void *cbarg) {
uint64_t magic = 0;
UNUSED(cbarg);
assert_non_null(handle);
if (eresult != ISC_R_SUCCESS) {
atomic_store(&was_error, true);
return;
}
atomic_fetch_add(&sreads, 1);
memmove(tcp_buffer_storage + tcp_buffer_length, region->base,
region->length);
tcp_buffer_length += region->length;
while (tcp_buffer_length >= sizeof(magic)) {
magic = *(uint64_t *)tcp_buffer_storage;
assert_true(magic == stop_magic || magic == send_magic);
tcp_buffer_length -= sizeof(magic);
memmove(tcp_buffer_storage, tcp_buffer_storage + sizeof(magic),
tcp_buffer_length);
if (magic == send_magic) {
if (!noanswer) {
isc_nm_send(handle, region, doh_reply_sent_cb,
NULL);
}
return;
} else if (magic == stop_magic) {
/*
* We are done, so we don't send anything back.
* There should be no more packets in the buffer.
*/
assert_int_equal(tcp_buffer_length, 0);
}
}
}
ISC_RUN_TEST_IMPL(mock_doh_uv_tcp_bind) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
WILL_RETURN(uv_tcp_bind, UV_EADDRINUSE);
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, &listen_sock);
assert_int_not_equal(result, ISC_R_SUCCESS);
assert_null(listen_sock);
RESET_RETURN;
}
static void
doh_noop(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
connect_send_request(connect_nm, req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
isc__netmgr_shutdown(connect_nm);
assert_int_equal(0, atomic_load(&csends));
assert_int_equal(0, atomic_load(&creads));
assert_int_equal(0, atomic_load(&sreads));
assert_int_equal(0, atomic_load(&ssends));
}
ISC_RUN_TEST_IMPL(doh_noop_POST) {
atomic_store(&POST, true);
doh_noop(state);
}
ISC_RUN_TEST_IMPL(doh_noop_GET) {
atomic_store(&POST, false);
doh_noop(state);
}
static void
doh_noresponse(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
noop_read_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
connect_send_request(connect_nm, req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
noop_read_cb, NULL, atomic_load(&use_TLS), 30000);
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
isc__netmgr_shutdown(connect_nm);
}
ISC_RUN_TEST_IMPL(doh_noresponse_POST) {
atomic_store(&POST, true);
doh_noresponse(state);
}
ISC_RUN_TEST_IMPL(doh_noresponse_GET) {
atomic_store(&POST, false);
doh_noresponse(state);
}
static void
timeout_query_sent_cb(isc_nmhandle_t *handle, isc_result_t eresult,
void *cbarg) {
UNUSED(eresult);
UNUSED(cbarg);
assert_non_null(handle);
if (eresult == ISC_R_SUCCESS) {
atomic_fetch_add(&csends, 1);
}
isc_nmhandle_detach(&handle);
}
static void
timeout_retry_cb(isc_nmhandle_t *handle, isc_result_t eresult,
isc_region_t *region, void *arg) {
UNUSED(region);
UNUSED(arg);
assert_non_null(handle);
atomic_fetch_add(&ctimeouts, 1);
if (eresult == ISC_R_TIMEDOUT && atomic_load(&ctimeouts) < 5) {
isc_nmhandle_settimeout(handle, T_SOFT);
return;
}
isc_nmhandle_detach(&handle);
}
static void
timeout_request_cb(isc_nmhandle_t *handle, isc_result_t result, void *arg) {
isc_nmhandle_t *sendhandle = NULL;
isc_nmhandle_t *readhandle = NULL;
REQUIRE(VALID_NMHANDLE(handle));
if (result != ISC_R_SUCCESS) {
goto error;
}
isc_nmhandle_attach(handle, &sendhandle);
isc_nm_send(handle,
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
timeout_query_sent_cb, arg);
isc_nmhandle_attach(handle, &readhandle);
isc_nm_read(handle, timeout_retry_cb, NULL);
return;
error:
atomic_store(&was_error, true);
}
static void
doh_timeout_recovery(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
isc_tlsctx_t *ctx = atomic_load(&use_TLS) ? server_tlsctx : NULL;
char req_url[256];
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, NULL, NULL, endpoints,
0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
/*
* Accept connections but don't send responses, forcing client
* reads to time out.
*/
noanswer = true;
/*
* Shorten all the TCP client timeouts to 0.05 seconds.
* timeout_retry_cb() will give up after five timeouts.
*/
isc_nm_settimeouts(connect_nm, T_SOFT, T_SOFT, T_SOFT, T_SOFT);
sockaddr_to_url(&tcp_listen_addr, false, req_url, sizeof(req_url),
ISC_NM_HTTP_DEFAULT_PATH);
isc_nm_httpconnect(connect_nm, NULL, &tcp_listen_addr, req_url,
atomic_load(&POST), timeout_request_cb, NULL, ctx,
client_sess_cache, T_SOFT);
/*
* Sleep until sends reaches 5.
*/
for (size_t i = 0; i < 1000; i++) {
if (atomic_load(&ctimeouts) == 5) {
break;
}
isc_test_nap(1);
}
assert_true(atomic_load(&ctimeouts) == 5);
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
isc__netmgr_shutdown(connect_nm);
}
ISC_RUN_TEST_IMPL(doh_timeout_recovery_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_timeout_recovery(state);
}
ISC_RUN_TEST_IMPL(doh_timeout_recovery_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_timeout_recovery(state);
}
static void
doh_receive_send_reply_cb(isc_nmhandle_t *handle, isc_result_t eresult,
isc_region_t *region, void *cbarg) {
isc_nmhandle_t *thandle = NULL;
assert_non_null(handle);
UNUSED(region);
isc_nmhandle_attach(handle, &thandle);
if (eresult == ISC_R_SUCCESS) {
int_fast64_t sends = atomic_fetch_sub(&nsends, 1);
atomic_fetch_add(&csends, 1);
atomic_fetch_add(&creads, 1);
if (sends > 0 && cbarg == NULL) {
size_t i;
for (i = 0; i < NWRITES / 2; i++) {
eresult = isc__nm_http_request(
handle,
&(isc_region_t){
.base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_send_reply_cb, (void *)1);
if (eresult == ISC_R_CANCELED) {
break;
}
assert_true(eresult == ISC_R_SUCCESS);
}
}
} else {
atomic_store(&was_error, true);
}
isc_nmhandle_detach(&thandle);
}
static isc_threadresult_t
doh_connect_thread(isc_threadarg_t arg) {
isc_nm_t *connect_nm = (isc_nm_t *)arg;
char req_url[256];
int64_t sends = atomic_load(&nsends);
sockaddr_to_url(&tcp_listen_addr, atomic_load(&use_TLS), req_url,
sizeof(req_url), ISC_NM_HTTP_DEFAULT_PATH);
while (sends > 0) {
/*
* We need to back off and slow down if we start getting
* errors, to prevent a thundering herd problem.
*/
int_fast64_t active = atomic_fetch_add(&active_cconnects, 1);
if (atomic_load(&slowdown) || active > workers) {
isc_test_nap(active - workers);
atomic_store(&slowdown, false);
}
connect_send_request(
connect_nm, req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_send_reply_cb, NULL, atomic_load(&use_TLS),
30000);
sends = atomic_load(&nsends);
}
return ((isc_threadresult_t)0);
}
static void
doh_recv_one(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, 1);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
sockaddr_to_url(&tcp_listen_addr, atomic_load(&use_TLS), req_url,
sizeof(req_url), ISC_NM_HTTP_DEFAULT_PATH);
connect_send_request(connect_nm, req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, NULL, atomic_load(&use_TLS),
30000);
while (atomic_load(&nsends) > 0) {
if (atomic_load(&was_error)) {
break;
}
isc_thread_yield();
}
while (atomic_load(&ssends) != 1 || atomic_load(&sreads) != 1 ||
atomic_load(&csends) != 1)
{
if (atomic_load(&was_error)) {
break;
}
isc_thread_yield();
}
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
isc__netmgr_shutdown(connect_nm);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
assert_int_equal(atomic_load(&csends), 1);
assert_int_equal(atomic_load(&creads), 1);
assert_int_equal(atomic_load(&sreads), 1);
assert_int_equal(atomic_load(&ssends), 1);
}
ISC_RUN_TEST_IMPL(doh_recv_one_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_POST_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_GET_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_one(state);
}
ISC_RUN_TEST_IMPL(doh_recv_one_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_one(state);
}
static void
doh_connect_send_two_requests_cb(isc_nmhandle_t *handle, isc_result_t result,
void *arg) {
REQUIRE(VALID_NMHANDLE(handle));
if (result != ISC_R_SUCCESS) {
goto error;
}
result = isc__nm_http_request(
handle,
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, arg);
if (result != ISC_R_SUCCESS) {
goto error;
}
result = isc__nm_http_request(
handle,
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, arg);
if (result != ISC_R_SUCCESS) {
goto error;
}
return;
error:
atomic_store(&was_error, true);
}
static void
doh_recv_two(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
isc_tlsctx_t *ctx = NULL;
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, 2);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
sockaddr_to_url(&tcp_listen_addr, atomic_load(&use_TLS), req_url,
sizeof(req_url), ISC_NM_HTTP_DEFAULT_PATH);
if (atomic_load(&use_TLS)) {
ctx = client_tlsctx;
}
isc_nm_httpconnect(connect_nm, NULL, &tcp_listen_addr, req_url,
atomic_load(&POST), doh_connect_send_two_requests_cb,
NULL, ctx, client_sess_cache, 5000);
while (atomic_load(&nsends) > 0) {
if (atomic_load(&was_error)) {
break;
}
isc_thread_yield();
}
while (atomic_load(&ssends) != 2 || atomic_load(&sreads) != 2 ||
atomic_load(&csends) != 2)
{
if (atomic_load(&was_error)) {
break;
}
isc_thread_yield();
}
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
isc__netmgr_shutdown(connect_nm);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
assert_int_equal(atomic_load(&csends), 2);
assert_int_equal(atomic_load(&creads), 2);
assert_int_equal(atomic_load(&sreads), 2);
assert_int_equal(atomic_load(&ssends), 2);
}
ISC_RUN_TEST_IMPL(doh_recv_two_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_POST_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_GET_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_two(state);
}
ISC_RUN_TEST_IMPL(doh_recv_two_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_two(state);
}
static void
doh_recv_send(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
size_t nthreads = ISC_MAX(ISC_MIN(workers, 32), 1);
isc_thread_t threads[32] = { 0 };
isc_quota_t *quotap = init_listener_quota(workers);
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_create(doh_connect_thread, connect_nm, &threads[i]);
}
/* wait for the all responses from the server */
while (atomic_load(&ssends) < atomic_load(&total_sends)) {
if (atomic_load(&was_error)) {
break;
}
isc_test_nap(1);
}
for (size_t i = 0; i < nthreads; i++) {
isc_thread_join(threads[i], NULL);
}
isc__netmgr_shutdown(connect_nm);
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
CHECK_RANGE_FULL(csends);
CHECK_RANGE_FULL(creads);
CHECK_RANGE_FULL(sreads);
CHECK_RANGE_FULL(ssends);
}
ISC_RUN_TEST_IMPL(doh_recv_send_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_POST_TLS) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&use_TLS, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_GET_TLS) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&use_TLS, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&use_TLS, true);
atomic_store(&check_listener_quota, true);
doh_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_send_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&use_TLS, true);
atomic_store(&check_listener_quota, true);
doh_recv_send(state);
}
static void
doh_recv_half_send(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
size_t nthreads = ISC_MAX(ISC_MIN(workers, 32), 1);
isc_thread_t threads[32] = { 0 };
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, atomic_load(&total_sends) / 2);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_create(doh_connect_thread, connect_nm, &threads[i]);
}
while (atomic_load(&nsends) > 0) {
isc_thread_yield();
}
isc__netmgr_shutdown(connect_nm);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_join(threads[i], NULL);
}
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
CHECK_RANGE_HALF(csends);
CHECK_RANGE_HALF(creads);
CHECK_RANGE_HALF(sreads);
CHECK_RANGE_HALF(ssends);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_POST_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_GET_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_recv_half_send_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_recv_half_send(state);
}
static void
doh_half_recv_send(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
size_t nthreads = ISC_MAX(ISC_MIN(workers, 32), 1);
isc_thread_t threads[32] = { 0 };
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, atomic_load(&total_sends) / 2);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_create(doh_connect_thread, connect_nm, &threads[i]);
}
while (atomic_load(&nsends) > 0) {
isc_thread_yield();
}
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_join(threads[i], NULL);
}
isc__netmgr_shutdown(connect_nm);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
CHECK_RANGE_HALF(csends);
CHECK_RANGE_HALF(creads);
CHECK_RANGE_HALF(sreads);
CHECK_RANGE_HALF(ssends);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_POST_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_GET_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_half_recv_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_send_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_half_recv_send(state);
}
static void
doh_half_recv_half_send(void **state) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
size_t nthreads = ISC_MAX(ISC_MIN(workers, 32), 1);
isc_thread_t threads[32] = { 0 };
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, atomic_load(&total_sends) / 2);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap,
atomic_load(&use_TLS) ? server_tlsctx : NULL,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_create(doh_connect_thread, connect_nm, &threads[i]);
}
while (atomic_load(&nsends) > 0) {
isc_thread_yield();
}
isc__netmgr_shutdown(connect_nm);
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
for (size_t i = 0; i < nthreads; i++) {
isc_thread_join(threads[i], NULL);
}
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
CHECK_RANGE_HALF(csends);
CHECK_RANGE_HALF(creads);
CHECK_RANGE_HALF(sreads);
CHECK_RANGE_HALF(ssends);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_POST) {
SKIP_IN_CI;
atomic_store(&POST, true);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_GET) {
SKIP_IN_CI;
atomic_store(&POST, false);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_POST_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_GET_TLS) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_POST_quota) {
SKIP_IN_CI;
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_GET_quota) {
SKIP_IN_CI;
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_POST_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, true);
atomic_store(&check_listener_quota, true);
doh_half_recv_half_send(state);
}
ISC_RUN_TEST_IMPL(doh_half_recv_half_send_GET_TLS_quota) {
SKIP_IN_CI;
atomic_store(&use_TLS, true);
atomic_store(&POST, false);
atomic_store(&check_listener_quota, true);
doh_half_recv_half_send(state);
}
/* See: GL #2858, !5319 */
ISC_RUN_TEST_IMPL(doh_bad_connect_uri) {
isc_nm_t **nm = (isc_nm_t **)*state;
isc_nm_t *listen_nm = nm[0];
isc_nm_t *connect_nm = nm[1];
isc_result_t result = ISC_R_SUCCESS;
isc_nmsocket_t *listen_sock = NULL;
char req_url[256];
isc_quota_t *quotap = init_listener_quota(workers);
atomic_store(&total_sends, 1);
atomic_store(&nsends, atomic_load(&total_sends));
result = isc_nm_http_endpoints_add(endpoints, ISC_NM_HTTP_DEFAULT_PATH,
doh_receive_request_cb, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
result = isc_nm_listenhttp(listen_nm, ISC_NM_LISTEN_ALL,
&tcp_listen_addr, 0, quotap, server_tlsctx,
endpoints, 0, &listen_sock);
assert_int_equal(result, ISC_R_SUCCESS);
/*
* "https://::1:XXXX/dns-query" is a bad URI, it should be
* "https://[::1]:XXXX/dns-query"
*/
(void)snprintf(req_url, sizeof(req_url), "https://::1:%u/%s",
isc_sockaddr_getport(&tcp_listen_addr),
ISC_NM_HTTP_DEFAULT_PATH);
connect_send_request(connect_nm, req_url, atomic_load(&POST),
&(isc_region_t){ .base = (uint8_t *)send_msg.base,
.length = send_msg.len },
doh_receive_reply_cb, NULL, true, 30000);
while (atomic_load(&nsends) > 0) {
if (atomic_load(&was_error)) {
break;
}
isc_thread_yield();
}
isc_nm_stoplistening(listen_sock);
isc_nmsocket_close(&listen_sock);
assert_null(listen_sock);
isc__netmgr_shutdown(connect_nm);
X(total_sends);
X(csends);
X(creads);
X(sreads);
X(ssends);
/* As we used an ill-formed URI, there ought to be an error. */
assert_true(atomic_load(&was_error));
assert_int_equal(atomic_load(&csends), 0);
assert_int_equal(atomic_load(&creads), 0);
assert_int_equal(atomic_load(&sreads), 0);
assert_int_equal(atomic_load(&ssends), 0);
}
ISC_RUN_TEST_IMPL(doh_parse_GET_query_string) {
UNUSED(state);
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] =
"dns=AAABAAABAAAAAAAAAWE-"
"NjJjaGFyYWN0ZXJsYWJlbC1tYWtlcy1iYXNlNjR1cmwtZGlzdGluY3"
"QtZnJvbS1zdGFuZGFyZC1iYXNlNjQHZXhhbXBsZQNjb20AAAEAAQ";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == strlen(str) - 4);
assert_true(memcmp(queryp, str + 4, len) == 0);
}
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] =
"?dns=AAABAAABAAAAAAAAAWE-"
"NjJjaGFyYWN0ZXJsYWJlbC1tYWtlcy1iYXNlNjR1cmwtZGlzdGluY3"
"QtZnJvbS1zdGFuZGFyZC1iYXNlNjQHZXhhbXBsZQNjb20AAAEAAQ&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == strlen(str) - 6);
assert_true(memcmp(queryp, str + 5, len) == 0);
}
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123&dns=567";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == 3);
assert_true(memcmp(queryp, "567", 3) == 0);
}
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?name1=123&dns=567&name2=123&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == 3);
assert_true(memcmp(queryp, "567", 3) == 0);
}
/* complex, but still valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] =
"?title=%D0%92%D1%96%D0%B4%D1%81%D0%BE%D1%82%D0%BA%D0%"
"BE%D0%B2%D0%B5_%D0%BA%D0%BE%D0%B4%D1%83%D0%B2%D0%B0%"
"D0%BD%D0%BD%D1%8F&dns=123&veaction=edit&section=0";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == 3);
assert_true(memcmp(queryp, "123", 3) == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] =
"?title=%D0%92%D1%96%D0%B4%D1%81%D0%BE%D1%82%D0%BA%D0%"
"BE%D0%B2%D0%B5_%D0%BA%D0%BE%D0%B4%D1%83%D0%B2%D0%B0%"
"D0%BD%D0%BD%D1%8F&veaction=edit&section=0";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123&&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123%12&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == 6);
assert_true(memcmp(queryp, "123%12", 6) == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123%ZZ&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123%%&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* invalid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123%AZ&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_false(ret);
assert_null(queryp);
assert_true(len == 0);
}
/* valid */
{
bool ret;
const char *queryp = NULL;
size_t len = 0;
char str[] = "?dns=123%0AZ&";
ret = isc__nm_parse_httpquery(str, &queryp, &len);
assert_true(ret);
assert_non_null(queryp);
assert_true(len > 0);
assert_true(len == 7);
assert_true(memcmp(queryp, "123%0AZ", 7) == 0);
}
}
ISC_RUN_TEST_IMPL(doh_base64url_to_base64) {
UNUSED(state);
char *res;
size_t res_len = 0;
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4=";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw==";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhc3U";
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3U=";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw==";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "PDw_Pz8-Pg";
char res_test[] = "PDw/Pz8+Pg==";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char test[] = "PDw_Pz8-Pg";
char res_test[] = "PDw/Pz8+Pg==";
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
NULL);
assert_non_null(res);
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* invalid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
res_len = 0;
res = isc__nm_base64url_to_base64(mctx, test, 0, &res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "";
res_len = 0;
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "PDw_Pz8-Pg==";
res_len = 0;
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "PDw_Pz8-Pg%3D%3D"; /* percent encoded "==" at the
end */
res_len = 0;
res = isc__nm_base64url_to_base64(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
res_len = 0;
res = isc__nm_base64url_to_base64(mctx, NULL, 31231, &res_len);
assert_null(res);
assert_true(res_len == 0);
}
}
ISC_RUN_TEST_IMPL(doh_base64_to_base64url) {
char *res;
size_t res_len = 0;
UNUSED(state);
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4";
char test[] = "YW55IGNhcm5hbCBwbGVhc3VyZS4=";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw";
char test[] = "YW55IGNhcm5hbCBwbGVhcw==";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
char test[] = "YW55IGNhcm5hbCBwbGVhc3Vy";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhc3U";
char test[] = "YW55IGNhcm5hbCBwbGVhc3U=";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "YW55IGNhcm5hbCBwbGVhcw";
char test[] = "YW55IGNhcm5hbCBwbGVhcw==";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "PDw_Pz8-Pg";
char test[] = "PDw/Pz8+Pg==";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_non_null(res);
assert_true(res_len == strlen(res_test));
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* valid */
{
char res_test[] = "PDw_Pz8-Pg";
char test[] = "PDw/Pz8+Pg==";
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
NULL);
assert_non_null(res);
assert_true(strcmp(res, res_test) == 0);
isc_mem_free(mctx, res);
}
/* invalid */
{
char test[] = "YW55IGNhcm5hbCBwbGVhcw";
res_len = 0;
res = isc__nm_base64_to_base64url(mctx, test, 0, &res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "";
res_len = 0;
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "PDw_Pz8-Pg==";
res_len = 0;
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
char test[] = "PDw_Pz8-Pg%3D%3D"; /* percent encoded "==" at the
end */
res_len = 0;
res = isc__nm_base64_to_base64url(mctx, test, strlen(test),
&res_len);
assert_null(res);
assert_true(res_len == 0);
}
/* invalid */
{
res_len = 0;
res = isc__nm_base64_to_base64url(mctx, NULL, 31231, &res_len);
assert_null(res);
assert_true(res_len == 0);
}
}
ISC_RUN_TEST_IMPL(doh_path_validation) {
UNUSED(state);
assert_true(isc_nm_http_path_isvalid("/"));
assert_true(isc_nm_http_path_isvalid(ISC_NM_HTTP_DEFAULT_PATH));
assert_false(isc_nm_http_path_isvalid("laaaa"));
assert_false(isc_nm_http_path_isvalid(""));
assert_false(isc_nm_http_path_isvalid("//"));
assert_true(isc_nm_http_path_isvalid("/lala///"));
assert_true(isc_nm_http_path_isvalid("/lalaaaaaa"));
assert_true(isc_nm_http_path_isvalid("/lalaaa/la/la/la"));
assert_true(isc_nm_http_path_isvalid("/la/a"));
assert_true(isc_nm_http_path_isvalid("/la+la"));
assert_true(isc_nm_http_path_isvalid("/la&la/la*la/l-a_/la!/la\'"));
assert_true(isc_nm_http_path_isvalid("/la/(la)/la"));
assert_true(isc_nm_http_path_isvalid("/la,la,la"));
assert_true(isc_nm_http_path_isvalid("/la-'la'-la"));
assert_true(isc_nm_http_path_isvalid("/la:la=la"));
assert_true(isc_nm_http_path_isvalid("/l@l@l@"));
assert_false(isc_nm_http_path_isvalid("/#lala"));
assert_true(isc_nm_http_path_isvalid("/lala;la"));
assert_false(
isc_nm_http_path_isvalid("la&la/laalaala*lala/l-al_a/lal!/"));
assert_true(isc_nm_http_path_isvalid("/Lal/lAla.jpg"));
/* had to replace ? with ! because it does not verify a query string */
assert_true(isc_nm_http_path_isvalid("/watch!v=oavMtUWDBTM"));
assert_false(isc_nm_http_path_isvalid("/watch?v=dQw4w9WgXcQ"));
assert_true(isc_nm_http_path_isvalid("/datatracker.ietf.org/doc/html/"
"rfc2616"));
assert_true(isc_nm_http_path_isvalid("/doc/html/rfc8484"));
assert_true(isc_nm_http_path_isvalid("/123"));
}
ISC_RUN_TEST_IMPL(doh_connect_makeuri) {
struct in_addr localhostv4 = { .s_addr = ntohl(INADDR_LOOPBACK) };
isc_sockaddr_t sa;
char uri[256];
UNUSED(state);
/* Firstly, test URI generation using isc_sockaddr_t */
isc_sockaddr_fromin(&sa, &localhostv4, 0);
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("https://127.0.0.1:443/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("http://127.0.0.1:80/dns-query", uri) == 0);
/*
* The port value should be ignored, because we can get one from
* the isc_sockaddr_t object.
*/
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, NULL, 44343, ISC_NM_HTTP_DEFAULT_PATH,
uri, sizeof(uri));
assert_true(strcmp("https://127.0.0.1:443/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, NULL, 8080, ISC_NM_HTTP_DEFAULT_PATH,
uri, sizeof(uri));
assert_true(strcmp("http://127.0.0.1:80/dns-query", uri) == 0);
/* IPv6 */
isc_sockaddr_fromin6(&sa, &in6addr_loopback, 0);
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("https://[::1]:443/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("http://[::1]:80/dns-query", uri) == 0);
/*
* The port value should be ignored, because we can get one from
* the isc_sockaddr_t object.
*/
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, NULL, 44343, ISC_NM_HTTP_DEFAULT_PATH,
uri, sizeof(uri));
assert_true(strcmp("https://[::1]:443/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, NULL, 8080, ISC_NM_HTTP_DEFAULT_PATH,
uri, sizeof(uri));
assert_true(strcmp("http://[::1]:80/dns-query", uri) == 0);
/* Try to set the port numbers. */
isc_sockaddr_setport(&sa, 44343);
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("https://[::1]:44343/dns-query", uri) == 0);
isc_sockaddr_setport(&sa, 8080);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, NULL, 0, ISC_NM_HTTP_DEFAULT_PATH, uri,
sizeof(uri));
assert_true(strcmp("http://[::1]:8080/dns-query", uri) == 0);
/*
* Try to make a URI using a hostname and a port number. The
* isc_sockaddr_t object will be ignored.
*/
isc_sockaddr_any(&sa);
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, "example.com", 0,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("https://example.com:443/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, "example.com", 0,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("http://example.com:80/dns-query", uri) == 0);
/* Try to set the port numbers. */
isc_sockaddr_setport(&sa, 443);
uri[0] = '\0';
isc_nm_http_makeuri(true, &sa, "example.com", 44343,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("https://example.com:44343/dns-query", uri) == 0);
isc_sockaddr_setport(&sa, 80);
uri[0] = '\0';
isc_nm_http_makeuri(false, &sa, "example.com", 8080,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("http://example.com:8080/dns-query", uri) == 0);
/* IPv4 as the hostname - nothing fancy here */
uri[0] = '\0';
isc_nm_http_makeuri(false, NULL, "127.0.0.1", 8080,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("http://127.0.0.1:8080/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(true, NULL, "127.0.0.1", 44343,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("https://127.0.0.1:44343/dns-query", uri) == 0);
/*
* A peculiar edge case: IPv6 given as the hostname (notice
* the brackets)
*/
uri[0] = '\0';
isc_nm_http_makeuri(false, NULL, "::1", 8080, ISC_NM_HTTP_DEFAULT_PATH,
uri, sizeof(uri));
assert_true(strcmp("http://[::1]:8080/dns-query", uri) == 0);
uri[0] = '\0';
isc_nm_http_makeuri(true, NULL, "[::1]", 44343,
ISC_NM_HTTP_DEFAULT_PATH, uri, sizeof(uri));
assert_true(strcmp("https://[::1]:44343/dns-query", uri) == 0);
}
ISC_TEST_LIST_START
ISC_TEST_ENTRY_CUSTOM(mock_doh_uv_tcp_bind, setup_test, teardown_test)
ISC_TEST_ENTRY(doh_parse_GET_query_string)
ISC_TEST_ENTRY(doh_base64url_to_base64)
ISC_TEST_ENTRY(doh_base64_to_base64url)
ISC_TEST_ENTRY(doh_path_validation)
ISC_TEST_ENTRY(doh_connect_makeuri)
ISC_TEST_ENTRY_CUSTOM(doh_noop_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_noop_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_noresponse_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_noresponse_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_timeout_recovery_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_timeout_recovery_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_POST_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_GET_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_POST_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_GET_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_POST_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_one_GET_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_POST_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_GET_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_POST_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_GET_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_POST_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_two_GET_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_GET_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_POST_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_GET_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_POST_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_GET_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_send_POST_TLS_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_GET_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_POST_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_GET_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_POST_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_GET_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_recv_half_send_POST_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_GET_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_POST_TLS, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_GET_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_POST_quota, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_GET_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_send_POST_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_GET, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_POST, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_GET_TLS, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_POST_TLS, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_GET_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_POST_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_GET_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_half_recv_half_send_POST_TLS_quota, setup_test,
teardown_test)
ISC_TEST_ENTRY_CUSTOM(doh_bad_connect_uri, setup_test, teardown_test)
ISC_TEST_LIST_END
ISC_TEST_MAIN
Reference in New Issue View Git Blame Copy Permalink