mirror/glibc
2
0
Fork 0
mirror of git://sourceware.org/git/glibc.git synced 2024-11-27 03:41:23 +08:00
Code Issues Packages Projects Releases Wiki Activity

support: Add resolver testing mode which does not patch _res

Browse Source
This commit is contained in:
Florian Weimer 2017-07-05 17:39:33 +02:00
parent d4165eedf5
commit cb3c27e87b
5 changed files with 549 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
ChangeLog
View File

@ -1,3 +1,18 @@
2017-07-05 Florian Weimer <fweimer@redhat.com>
* resolv/Makefile (tests-internal): Add tst-resolv-threads.
(tst-resolv-threads): Link with -ldl, -lresolv, -lpthread.
* resolv/tst-resolv-threads.c: New file.
2017-07-05 Florian Weimer <fweimer@redhat.com>
support: Add resolver testing mode which does not patch _res.
* support/resolv_test.h (struct resolv_redirect_config): Add
disable_redirect, server_address_overrides.
* support/resolv_test.c (make_server_sockets_for_address): New
function.
(resolv_test_start): Call it.
2017-07-05 Florian Weimer <fweimer@redhat.com>
* support/namespace.h (struct support_chroot_configuration)

6
resolv/Makefile
View File

@ -65,7 +65,9 @@ tests-internal += \
tst-resolv-res_init-thread \
# Needs resolv_context.
tests-internal += tst-resolv-res_ninit
tests-internal += \
tst-resolv-res_ninit \
tst-resolv-threads \
endif
@ -168,6 +170,8 @@ $(objpfx)tst-resolv-res_init-thread: $(libdl) $(objpfx)libresolv.so \
$(objpfx)tst-resolv-qtypes: $(objpfx)libresolv.so $(shared-thread-library)
$(objpfx)tst-resolv-rotate: $(objpfx)libresolv.so $(shared-thread-library)
$(objpfx)tst-resolv-search: $(objpfx)libresolv.so $(shared-thread-library)
$(objpfx)tst-resolv-threads: \
$(libdl) $(objpfx)libresolv.so $(shared-thread-library)
$(objpfx)tst-resolv-canonname: \
$(libdl) $(objpfx)libresolv.so $(shared-thread-library)

484
resolv/tst-resolv-threads.c Normal file
View File

@ -0,0 +1,484 @@
/* Test basic nss_dns functionality with multiple threads.
Copyright (C) 2016-2017 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
<http://www.gnu.org/licenses/>. */
/* Unlike tst-resolv-basic, this test does not overwrite the _res
structure and relies on namespaces to achieve the redirection to
the test servers with a custom /etc/resolv.conf file. */
#include <dlfcn.h>
#include <errno.h>
#include <gnu/lib-names.h>
#include <netdb.h>
#include <resolv/resolv-internal.h>
#include <resolv/resolv_context.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/namespace.h>
#include <support/resolv_test.h>
#include <support/support.h>
#include <support/temp_file.h>
#include <support/test-driver.h>
#include <support/xthread.h>
#include <support/xunistd.h>
/* Each client thread sends this many queries. */
enum { queries_per_thread = 500 };
/* Return a small positive number identifying this thread. */
static int
get_thread_number (void)
{
static int __thread local;
if (local != 0)
return local;
static int global = 1;
local = __atomic_fetch_add (&global, 1, __ATOMIC_RELAXED);
return local;
}
static void
response (const struct resolv_response_context *ctx,
struct resolv_response_builder *b,
const char *qname, uint16_t qclass, uint16_t qtype)
{
TEST_VERIFY_EXIT (qname != NULL);
int counter = 0;
int thread = 0;
int dummy = 0;
TEST_VERIFY (sscanf (qname, "counter%d.thread%d.example.com%n",
&counter, &thread, &dummy) == 2);
TEST_VERIFY (dummy > 0);
struct resolv_response_flags flags = { 0 };
resolv_response_init (b, flags);
resolv_response_add_question (b, qname, qclass, qtype);
resolv_response_section (b, ns_s_an);
resolv_response_open_record (b, qname, qclass, qtype, 0);
switch (qtype)
{
case T_A:
{
char ipv4[4] = {10, 0, counter, thread};
resolv_response_add_data (b, &ipv4, sizeof (ipv4));
}
break;
case T_AAAA:
{
char ipv6[16]
= {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0,
counter, 0, thread, 0, 0};
resolv_response_add_data (b, &ipv6, sizeof (ipv6));
}
break;
default:
support_record_failure ();
printf ("error: unexpected QTYPE: %s/%u/%u\n",
qname, qclass, qtype);
}
resolv_response_close_record (b);
}
/* Check that the resolver configuration for this thread has an
extended resolver configuration. */
static void
check_have_conf (void)
{
struct resolv_context *ctx = __resolv_context_get ();
TEST_VERIFY_EXIT (ctx != NULL);
TEST_VERIFY (ctx->conf != NULL);
__resolv_context_put (ctx);
}
/* Verify that E matches the expected response for FAMILY and
COUNTER. */
static void
check_hostent (const char *caller, const char *function, const char *qname,
int ret, struct hostent *e, int family, int counter)
{
if (ret != 0)
{
errno = ret;
support_record_failure ();
printf ("error: %s: %s for %s failed: %m\n", caller, function, qname);
return;
}
TEST_VERIFY_EXIT (e != NULL);
TEST_VERIFY (strcmp (qname, e->h_name) == 0);
TEST_VERIFY (e->h_addrtype == family);
TEST_VERIFY_EXIT (e->h_addr_list[0] != NULL);
TEST_VERIFY (e->h_addr_list[1] == NULL);
switch (family)
{
case AF_INET:
{
char addr[4] = {10, 0, counter, get_thread_number ()};
TEST_VERIFY (e->h_length == sizeof (addr));
TEST_VERIFY (memcmp (e->h_addr_list[0], addr, sizeof (addr)) == 0);
}
break;
case AF_INET6:
{
char addr[16]
= {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0,
0, counter, 0, get_thread_number (), 0, 0};
TEST_VERIFY (e->h_length == sizeof (addr));
TEST_VERIFY (memcmp (e->h_addr_list[0], addr, sizeof (addr)) == 0);
}
break;
default:
FAIL_EXIT1 ("%s: invalid address family %d", caller, family);
}
check_have_conf ();
}
/* Check a getaddrinfo result. */
static void
check_addrinfo (const char *caller, const char *qname,
int ret, struct addrinfo *ai, int family, int counter)
{
if (ret != 0)
{
support_record_failure ();
printf ("error: %s: getaddrinfo for %s failed: %s\n",
caller, qname, gai_strerror (ret));
return;
}
TEST_VERIFY_EXIT (ai != NULL);
/* Check that available data matches the requirements. */
bool have_ipv4 = false;
bool have_ipv6 = false;
for (struct addrinfo *p = ai; p != NULL; p = p->ai_next)
{
TEST_VERIFY (p->ai_socktype == SOCK_STREAM);
TEST_VERIFY (p->ai_protocol == IPPROTO_TCP);
TEST_VERIFY_EXIT (p->ai_addr != NULL);
TEST_VERIFY (p->ai_addr->sa_family == p->ai_family);
switch (p->ai_family)
{
case AF_INET:
{
TEST_VERIFY (!have_ipv4);
have_ipv4 = true;
struct sockaddr_in *sa = (struct sockaddr_in *) p->ai_addr;
TEST_VERIFY (p->ai_addrlen == sizeof (*sa));
char addr[4] = {10, 0, counter, get_thread_number ()};
TEST_VERIFY (memcmp (&sa->sin_addr, addr, sizeof (addr)) == 0);
TEST_VERIFY (ntohs (sa->sin_port) == 80);
}
break;
case AF_INET6:
{
TEST_VERIFY (!have_ipv6);
have_ipv6 = true;
struct sockaddr_in6 *sa = (struct sockaddr_in6 *) p->ai_addr;
TEST_VERIFY (p->ai_addrlen == sizeof (*sa));
char addr[16]
= {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0,
0, counter, 0, get_thread_number (), 0, 0};
TEST_VERIFY (memcmp (&sa->sin6_addr, addr, sizeof (addr)) == 0);
TEST_VERIFY (ntohs (sa->sin6_port) == 80);
}
break;
default:
FAIL_EXIT1 ("%s: invalid address family %d", caller, family);
}
}
switch (family)
{
case AF_INET:
TEST_VERIFY (have_ipv4);
TEST_VERIFY (!have_ipv6);
break;
case AF_INET6:
TEST_VERIFY (!have_ipv4);
TEST_VERIFY (have_ipv6);
break;
case AF_UNSPEC:
TEST_VERIFY (have_ipv4);
TEST_VERIFY (have_ipv6);
break;
default:
FAIL_EXIT1 ("%s: invalid address family %d", caller, family);
}
check_have_conf ();
}
/* This barrier ensures that all test threads begin their work
simultaneously. */
static pthread_barrier_t barrier;
/* Test gethostbyname2_r (if do_2 is false) or gethostbyname2_r with
AF_INET (if do_2 is true). */
static void *
byname (bool do_2)
{
int this_thread = get_thread_number ();
xpthread_barrier_wait (&barrier);
for (int i = 0; i < queries_per_thread; ++i)
{
char qname[100];
snprintf (qname, sizeof (qname), "counter%d.thread%d.example.com",
i, this_thread);
struct hostent storage;
char buf[1000];
struct hostent *e = NULL;
int herrno;
int ret;
if (do_2)
ret = gethostbyname_r (qname, &storage, buf, sizeof (buf),
&e, &herrno);
else
ret = gethostbyname2_r (qname, AF_INET, &storage, buf, sizeof (buf),
&e, &herrno);
check_hostent (__func__, do_2 ? "gethostbyname2_r" : "gethostbyname_r",
qname, ret, e, AF_INET, i);
}
check_have_conf ();
return NULL;
}
/* Test gethostbyname_r. */
static void *
thread_byname (void *closure)
{
return byname (false);
}
/* Test gethostbyname2_r with AF_INET. */
static void *
thread_byname2 (void *closure)
{
return byname (true);
}
/* Call gethostbyname_r with RES_USE_INET6 (if do_2 is false), or
gethostbyname_r with AF_INET6 (if do_2 is true). */
static void *
byname_inet6 (bool do_2)
{
int this_thread = get_thread_number ();
xpthread_barrier_wait (&barrier);
if (!do_2)
{
res_init ();
_res.options |= DEPRECATED_RES_USE_INET6;
TEST_VERIFY (strcmp (_res.defdname, "example.com") == 0);
}
for (int i = 0; i < queries_per_thread; ++i)
{
char qname[100];
snprintf (qname, sizeof (qname), "counter%d.thread%d.example.com",
i, this_thread);
struct hostent storage;
char buf[1000];
struct hostent *e = NULL;
int herrno;
int ret;
if (do_2)
ret = gethostbyname2_r (qname, AF_INET6, &storage, buf, sizeof (buf),
&e, &herrno);
else
ret = gethostbyname_r (qname, &storage, buf, sizeof (buf),
&e, &herrno);
check_hostent (__func__,
do_2 ? "gethostbyname2_r" : "gethostbyname_r",
qname, ret, e, AF_INET6, i);
}
return NULL;
}
/* Test gethostbyname_r with AF_INET6. */
static void *
thread_byname_inet6 (void *closure)
{
return byname_inet6 (false);
}
/* Test gethostbyname2_r with AF_INET6. */
static void *
thread_byname2_af_inet6 (void *closure)
{
return byname_inet6 (true);
}
/* Run getaddrinfo tests for FAMILY. */
static void *
gai (int family, bool do_inet6)
{
int this_thread = get_thread_number ();
xpthread_barrier_wait (&barrier);
if (do_inet6)
{
res_init ();
_res.options |= DEPRECATED_RES_USE_INET6;
check_have_conf ();
}
for (int i = 0; i < queries_per_thread; ++i)
{
char qname[100];
snprintf (qname, sizeof (qname), "counter%d.thread%d.example.com",
i, this_thread);
struct addrinfo hints =
{
.ai_family = family,
.ai_socktype = SOCK_STREAM,
.ai_protocol = IPPROTO_TCP,
};
struct addrinfo *ai;
int ret = getaddrinfo (qname, "80", &hints, &ai);
check_addrinfo (__func__, qname, ret, ai, family, i);
if (ret == 0)
freeaddrinfo (ai);
}
return NULL;
}
/* Test getaddrinfo with AF_INET. */
static void *
thread_gai_inet (void *closure)
{
return gai (AF_INET, false);
}
/* Test getaddrinfo with AF_INET6. */
static void *
thread_gai_inet6 (void *closure)
{
return gai (AF_INET6, false);
}
/* Test getaddrinfo with AF_UNSPEC. */
static void *
thread_gai_unspec (void *closure)
{
return gai (AF_UNSPEC, false);
}
/* Test getaddrinfo with AF_INET. */
static void *
thread_gai_inet_inet6 (void *closure)
{
return gai (AF_INET, true);
}
/* Test getaddrinfo with AF_INET6. */
static void *
thread_gai_inet6_inet6 (void *closure)
{
return gai (AF_INET6, true);
}
/* Test getaddrinfo with AF_UNSPEC. */
static void *
thread_gai_unspec_inet6 (void *closure)
{
return gai (AF_UNSPEC, true);
}
/* Description of the chroot environment used to run the tests. */
static struct support_chroot *chroot_env;
/* Set up the chroot environment. */
static void
prepare (int argc, char **argv)
{
chroot_env = support_chroot_create
((struct support_chroot_configuration)
{
.resolv_conf =
"search example.com\n"
"nameserver 127.0.0.1\n"
"nameserver 127.0.0.2\n"
"nameserver 127.0.0.3\n",
});
}
static int
do_test (void)
{
support_become_root ();
if (!support_enter_network_namespace ())
return EXIT_UNSUPPORTED;
if (!support_can_chroot ())
return EXIT_UNSUPPORTED;
/* Load the shared object outside of the chroot. */
TEST_VERIFY (dlopen (LIBNSS_DNS_SO, RTLD_LAZY) != NULL);
xchroot (chroot_env->path_chroot);
TEST_VERIFY_EXIT (chdir ("/") == 0);
struct sockaddr_in server_address =
{
.sin_family = AF_INET,
.sin_addr = { .s_addr = htonl (INADDR_LOOPBACK) },
.sin_port = htons (53)
};
const struct sockaddr *server_addresses[1] =
{ (const struct sockaddr *) &server_address };
struct resolv_test *aux = resolv_test_start
((struct resolv_redirect_config)
{
.response_callback = response,
.nscount = 1,
.disable_redirect = true,
.server_address_overrides = server_addresses,
});
enum { thread_count = 10 };
xpthread_barrier_init (&barrier, NULL, thread_count + 1);
pthread_t threads[thread_count];
typedef void *(*thread_func) (void *);
thread_func thread_funcs[thread_count] =
{
thread_byname,
thread_byname2,
thread_byname_inet6,
thread_byname2_af_inet6,
thread_gai_inet,
thread_gai_inet6,
thread_gai_unspec,
thread_gai_inet_inet6,
thread_gai_inet6_inet6,
thread_gai_unspec_inet6,
};
for (int i = 0; i < thread_count; ++i)
threads[i] = xpthread_create (NULL, thread_funcs[i], NULL);
xpthread_barrier_wait (&barrier); /* Start the test threads. */
for (int i = 0; i < thread_count; ++i)
xpthread_join (threads[i]);
resolv_test_end (aux);
support_chroot_free (chroot_env);
return 0;
}
#define PREPARE prepare
#include <support/test-driver.c>

37
support/resolv_test.c
View File

@ -1004,6 +1004,29 @@ make_server_sockets (struct resolv_test_server *server)
}
}
/* Like make_server_sockets, but the caller supplies the address to
use. */
static void
make_server_sockets_for_address (struct resolv_test_server *server,
const struct sockaddr *addr)
{
server->socket_udp = xsocket (AF_INET, SOCK_DGRAM, IPPROTO_UDP);
server->socket_tcp = xsocket (AF_INET, SOCK_STREAM, IPPROTO_TCP);
if (addr->sa_family == AF_INET)
server->address = *(const struct sockaddr_in *) addr;
else
/* We cannot store the server address in the socket. This should
not matter if disable_redirect is used. */
server->address = (struct sockaddr_in) { .sin_family = 0, };
xbind (server->socket_udp,
(struct sockaddr *)&server->address, sizeof (server->address));
xbind (server->socket_tcp,
(struct sockaddr *)&server->address, sizeof (server->address));
xlisten (server->socket_tcp, 5);
}
/* One-time initialization of NSS. */
static void
resolv_redirect_once (void)
@ -1064,11 +1087,17 @@ resolv_test_start (struct resolv_redirect_config config)
.lock = PTHREAD_MUTEX_INITIALIZER,
};
resolv_test_init ();
if (!config.disable_redirect)
resolv_test_init ();
/* Create all the servers, to reserve the necessary ports. */
for (int server_index = 0; server_index < config.nscount; ++server_index)
make_server_sockets (obj->servers + server_index);
if (config.disable_redirect && config.server_address_overrides != NULL)
make_server_sockets_for_address
(obj->servers + server_index,
config.server_address_overrides[server_index]);
else
make_server_sockets (obj->servers + server_index);
/* Start server threads. Disable the server ports, as
requested. */
@ -1095,6 +1124,9 @@ resolv_test_start (struct resolv_redirect_config config)
if (config.single_thread_udp)
start_server_thread_udp_single (obj);
if (config.disable_redirect)
return obj;
int timeout = 1;
/* Initialize libresolv. */
@ -1129,6 +1161,7 @@ resolv_test_start (struct resolv_redirect_config config)
}
for (int server_index = 0; server_index < config.nscount; ++server_index)
{
TEST_VERIFY_EXIT (obj->servers[server_index].address.sin_port != 0);
_res.nsaddr_list[server_index] = obj->servers[server_index].address;
if (test_verbose)
{

10
support/resolv_test.h
View File

@ -93,6 +93,16 @@ struct resolv_redirect_config
may results in more predictable ordering of queries and
responses. */
bool single_thread_udp;
/* Do not rewrite the _res variable or change NSS defaults. Use
server_address_overrides below to tell the testing framework on
which addresses to create the servers. */
bool disable_redirect;
/* Use these addresses for creating the DNS servers. The array must
have ns_count (or resolv_max_test_servers) sockaddr * elements if
not NULL. */
const struct sockaddr *const *server_address_overrides;
};
/* Configure NSS to use, nss_dns only for aplicable databases, and try