AuroraMiddleware/glibc
1
0
Fork 0
mirror of https://sourceware.org/git/glibc.git synced 2024-09-20 00:19:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
b9a558e790
glibc/resolv/tst-resolv-basic.c
Florian Weimer f4a6be2582 getaddrinfo: Fix error handling in gethosts [BZ #21915] [BZ #21922] 
The old code uses errno as the primary indicator for success or
failure.  This is wrong because errno is only set for specific
combinations of the status return value and the h_errno variable.
2017-09-01 09:34:29 +02:00

504 lines
18 KiB
C
Raw Blame History

/* Test basic nss_dns functionality and the resolver test harness itself.
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/>. */
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <support/check.h>
#include <support/check_nss.h>
#include <support/format_nss.h>
#include <support/resolv_test.h>
#include <support/support.h>
#define LONG_NAME \
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaax." \
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaay." \
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaz." \
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaat"
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);
/* The "t." prefix can be used to request TCP fallback. */
bool force_tcp;
if (strncmp ("t.", qname, 2) == 0)
force_tcp = true;
else
force_tcp = false;
const char *qname_compare;
if (force_tcp)
qname_compare = qname + 2;
else
qname_compare = qname;
enum {www, alias, nxdomain, long_name, nodata} requested_qname;
if (strcmp (qname_compare, "www.example") == 0)
requested_qname = www;
else if (strcmp (qname_compare, "alias.example") == 0)
requested_qname = alias;
else if (strcmp (qname_compare, "nxdomain.example") == 0)
requested_qname = nxdomain;
else if (strcmp (qname_compare, LONG_NAME) == 0)
requested_qname = long_name;
else if (strcmp (qname_compare, "nodata.example") == 0)
requested_qname = nodata;
else
{
support_record_failure ();
printf ("error: unexpected QNAME: %s\n", qname);
return;
}
TEST_VERIFY_EXIT (qclass == C_IN);
struct resolv_response_flags flags = {.tc = force_tcp && !ctx->tcp};
if (requested_qname == nxdomain)
flags.rcode = 3; /* NXDOMAIN */
resolv_response_init (b, flags);
resolv_response_add_question (b, qname, qclass, qtype);
if (requested_qname == nxdomain || flags.tc)
return;
resolv_response_section (b, ns_s_an);
switch (requested_qname)
{
case www:
case long_name:
resolv_response_open_record (b, qname, qclass, qtype, 0);
break;
case alias:
resolv_response_open_record (b, qname, qclass, T_CNAME, 0);
resolv_response_add_name (b, "www.example");
resolv_response_close_record (b);
resolv_response_open_record (b, "www.example", qclass, qtype, 0);
break;
case nodata:
return;
case nxdomain:
FAIL_EXIT1 ("unreachable");
}
switch (qtype)
{
case T_A:
{
char ipv4[4] = {192, 0, 2, 17};
ipv4[3] += requested_qname + 2 * ctx->tcp + 4 * ctx->server_index;
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, 0, 0, 0, 0, 1};
ipv6[15] += requested_qname + 2 * ctx->tcp + 4 * ctx->server_index;
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);
}
static void
check_h (const char *name, int family, const char *expected)
{
if (family == AF_INET)
{
char *query = xasprintf ("gethostbyname (\"%s\")", name);
check_hostent (query, gethostbyname (name), expected);
free (query);
}
{
char *query = xasprintf ("gethostbyname2 (\"%s\", %d)", name, family);
check_hostent (query, gethostbyname2 (name, family), expected);
free (query);
}
bool too_small = true;
for (unsigned int offset = 0; offset < 8; ++offset)
for (unsigned int size = 1; too_small; ++size)
{
char *buf = xmalloc (offset + size);
too_small = false;
struct hostent hostbuf;
struct hostent *result;
int herror;
if (family == AF_INET)
{
char *query = xasprintf ("gethostbyname (\"%s\") %u/%u",
name, offset, size);
int ret = gethostbyname_r
(name, &hostbuf, buf + offset, size, &result, &herror);
if (ret == 0)
{
h_errno = herror;
check_hostent (query, result, expected);
}
else if (ret == ERANGE)
too_small = true;
else
{
errno = ret;
FAIL_EXIT1 ("gethostbyname_r: %m");
}
free (query);
memset (buf, 0, offset + size);
}
char *query = xasprintf ("gethostbyname2 (\"%s\", %d) %u/%u",
name, family, offset, size);
int ret = gethostbyname2_r
(name, family, &hostbuf, buf + offset, size, &result, &herror);
if (ret == 0)
{
h_errno = herror;
check_hostent (query, result, expected);
}
else if (ret == ERANGE)
too_small = true;
else
{
errno = ret;
FAIL_EXIT1 ("gethostbyname_r: %m");
}
free (buf);
free (query);
}
}
static void
check_ai_hints (const char *name, const char *service,
struct addrinfo hints, const char *expected)
{
struct addrinfo *ai;
char *query = xasprintf ("%s:%s [%d]/0x%x", name, service,
hints.ai_family, hints.ai_flags);
int ret = getaddrinfo (name, service, &hints, &ai);
check_addrinfo (query, ai, ret, expected);
if (ret == 0)
freeaddrinfo (ai);
free (query);
}
static void
check_ai (const char *name, const char *service,
int family, const char *expected)
{
return check_ai_hints (name, service,
(struct addrinfo) { .ai_family = family, },
expected);
}
/* Test for bug 21295: getaddrinfo used to discard address information
instead of merging it. */
static void
test_bug_21295 (void)
{
/* The address order is unpredictable. There are two factors which
contribute to that: The stub resolver does not perform proper
response matching for A/AAAA queries (an A response could be
associated with an AAAA query and vice versa), and without
namespaces, system configuration could affect address
ordering. */
for (int do_tcp = 0; do_tcp < 2; ++do_tcp)
{
const struct addrinfo hints =
{
.ai_family = AF_INET6,
.ai_socktype = SOCK_STREAM,
.ai_flags = AI_V4MAPPED | AI_ALL,
};
const char *qname;
if (do_tcp)
qname = "t.www.example";
else
qname = "www.example";
struct addrinfo *ai = NULL;
int ret = getaddrinfo (qname, "80", &hints, &ai);
TEST_VERIFY_EXIT (ret == 0);
const char *expected_a;
const char *expected_b;
if (do_tcp)
{
expected_a = "flags: AI_V4MAPPED AI_ALL\n"
"address: STREAM/TCP 2001:db8::3 80\n"
"address: STREAM/TCP ::ffff:192.0.2.19 80\n";
expected_b = "flags: AI_V4MAPPED AI_ALL\n"
"address: STREAM/TCP ::ffff:192.0.2.19 80\n"
"address: STREAM/TCP 2001:db8::3 80\n";
}
else
{
expected_a = "flags: AI_V4MAPPED AI_ALL\n"
"address: STREAM/TCP 2001:db8::1 80\n"
"address: STREAM/TCP ::ffff:192.0.2.17 80\n";
expected_b = "flags: AI_V4MAPPED AI_ALL\n"
"address: STREAM/TCP ::ffff:192.0.2.17 80\n"
"address: STREAM/TCP 2001:db8::1 80\n";
}
char *actual = support_format_addrinfo (ai, ret);
if (!(strcmp (actual, expected_a) == 0
|| strcmp (actual, expected_b) == 0))
{
support_record_failure ();
printf ("error: %s: unexpected response (TCP: %d):\n%s\n",
__func__, do_tcp, actual);
}
free (actual);
freeaddrinfo (ai);
}
}
/* Run tests which do not expect any data. */
static void
test_nodata_nxdomain (void)
{
/* Iterate through different address families. */
int families[] = { AF_UNSPEC, AF_INET, AF_INET6, -1 };
for (int i = 0; families[i] >= 0; ++i)
/* If do_tcp, prepend "t." to the name to trigger TCP
fallback. */
for (int do_tcp = 0; do_tcp < 2; ++do_tcp)
/* If do_nxdomain, trigger an NXDOMAIN error (DNS failure),
otherwise use a NODATA response (empty but successful
answer). */
for (int do_nxdomain = 0; do_nxdomain < 2; ++do_nxdomain)
{
int family = families[i];
char *name = xasprintf ("%s%s.example",
do_tcp ? "t." : "",
do_nxdomain ? "nxdomain" : "nodata");
if (family != AF_UNSPEC)
{
if (do_nxdomain)
check_h (name, family, "error: HOST_NOT_FOUND\n");
else
check_h (name, family, "error: NO_ADDRESS\n");
}
const char *expected;
if (do_nxdomain)
expected = "error: Name or service not known\n";
else
expected = "error: No address associated with hostname\n";
check_ai (name, "80", family, expected);
struct addrinfo hints =
{
.ai_family = family,
.ai_flags = AI_V4MAPPED | AI_ALL,
};
check_ai_hints (name, "80", hints, expected);
hints.ai_flags |= AI_CANONNAME;
check_ai_hints (name, "80", hints, expected);
free (name);
}
}
static int
do_test (void)
{
struct resolv_test *aux = resolv_test_start
((struct resolv_redirect_config)
{
.response_callback = response,
});
check_h ("www.example", AF_INET,
"name: www.example\n"
"address: 192.0.2.17\n");
check_h ("alias.example", AF_INET,
"name: www.example\n"
"alias: alias.example\n"
"address: 192.0.2.18\n");
check_h ("www.example", AF_INET6,
"name: www.example\n"
"address: 2001:db8::1\n");
check_h ("alias.example", AF_INET6,
"name: www.example\n"
"alias: alias.example\n"
"address: 2001:db8::2\n");
check_h (LONG_NAME, AF_INET,
"name: " LONG_NAME "\n"
"address: 192.0.2.20\n");
check_ai ("www.example", "80", AF_UNSPEC,
"address: STREAM/TCP 192.0.2.17 80\n"
"address: DGRAM/UDP 192.0.2.17 80\n"
"address: RAW/IP 192.0.2.17 80\n"
"address: STREAM/TCP 2001:db8::1 80\n"
"address: DGRAM/UDP 2001:db8::1 80\n"
"address: RAW/IP 2001:db8::1 80\n");
check_ai_hints ("www.example", "80",
(struct addrinfo) { .ai_family = AF_UNSPEC,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 192.0.2.17 80\n"
"address: DGRAM/UDP 192.0.2.17 80\n"
"address: RAW/IP 192.0.2.17 80\n"
"address: STREAM/TCP 2001:db8::1 80\n"
"address: DGRAM/UDP 2001:db8::1 80\n"
"address: RAW/IP 2001:db8::1 80\n");
check_ai ("alias.example", "80", AF_UNSPEC,
"address: STREAM/TCP 192.0.2.18 80\n"
"address: DGRAM/UDP 192.0.2.18 80\n"
"address: RAW/IP 192.0.2.18 80\n"
"address: STREAM/TCP 2001:db8::2 80\n"
"address: DGRAM/UDP 2001:db8::2 80\n"
"address: RAW/IP 2001:db8::2 80\n");
check_ai_hints ("alias.example", "80",
(struct addrinfo) { .ai_family = AF_UNSPEC,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 192.0.2.18 80\n"
"address: DGRAM/UDP 192.0.2.18 80\n"
"address: RAW/IP 192.0.2.18 80\n"
"address: STREAM/TCP 2001:db8::2 80\n"
"address: DGRAM/UDP 2001:db8::2 80\n"
"address: RAW/IP 2001:db8::2 80\n");
check_ai (LONG_NAME, "80", AF_UNSPEC,
"address: STREAM/TCP 192.0.2.20 80\n"
"address: DGRAM/UDP 192.0.2.20 80\n"
"address: RAW/IP 192.0.2.20 80\n"
"address: STREAM/TCP 2001:db8::4 80\n"
"address: DGRAM/UDP 2001:db8::4 80\n"
"address: RAW/IP 2001:db8::4 80\n");
check_ai ("www.example", "80", AF_INET,
"address: STREAM/TCP 192.0.2.17 80\n"
"address: DGRAM/UDP 192.0.2.17 80\n"
"address: RAW/IP 192.0.2.17 80\n");
check_ai_hints ("www.example", "80",
(struct addrinfo) { .ai_family = AF_INET,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 192.0.2.17 80\n"
"address: DGRAM/UDP 192.0.2.17 80\n"
"address: RAW/IP 192.0.2.17 80\n");
check_ai ("alias.example", "80", AF_INET,
"address: STREAM/TCP 192.0.2.18 80\n"
"address: DGRAM/UDP 192.0.2.18 80\n"
"address: RAW/IP 192.0.2.18 80\n");
check_ai_hints ("alias.example", "80",
(struct addrinfo) { .ai_family = AF_INET,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 192.0.2.18 80\n"
"address: DGRAM/UDP 192.0.2.18 80\n"
"address: RAW/IP 192.0.2.18 80\n");
check_ai (LONG_NAME, "80", AF_INET,
"address: STREAM/TCP 192.0.2.20 80\n"
"address: DGRAM/UDP 192.0.2.20 80\n"
"address: RAW/IP 192.0.2.20 80\n");
check_ai ("www.example", "80", AF_INET6,
"address: STREAM/TCP 2001:db8::1 80\n"
"address: DGRAM/UDP 2001:db8::1 80\n"
"address: RAW/IP 2001:db8::1 80\n");
check_ai_hints ("www.example", "80",
(struct addrinfo) { .ai_family = AF_INET6,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 2001:db8::1 80\n"
"address: DGRAM/UDP 2001:db8::1 80\n"
"address: RAW/IP 2001:db8::1 80\n");
check_ai ("alias.example", "80", AF_INET6,
"address: STREAM/TCP 2001:db8::2 80\n"
"address: DGRAM/UDP 2001:db8::2 80\n"
"address: RAW/IP 2001:db8::2 80\n");
check_ai_hints ("alias.example", "80",
(struct addrinfo) { .ai_family = AF_INET6,
.ai_flags = AI_CANONNAME, },
"flags: AI_CANONNAME\n"
"canonname: www.example\n"
"address: STREAM/TCP 2001:db8::2 80\n"
"address: DGRAM/UDP 2001:db8::2 80\n"
"address: RAW/IP 2001:db8::2 80\n");
check_ai (LONG_NAME, "80", AF_INET6,
"address: STREAM/TCP 2001:db8::4 80\n"
"address: DGRAM/UDP 2001:db8::4 80\n"
"address: RAW/IP 2001:db8::4 80\n");
check_h ("t.www.example", AF_INET,
"name: t.www.example\n"
"address: 192.0.2.19\n");
check_h ("t.alias.example", AF_INET,
"name: www.example\n"
"alias: t.alias.example\n"
"address: 192.0.2.20\n");
check_h ("t.www.example", AF_INET6,
"name: t.www.example\n"
"address: 2001:db8::3\n");
check_h ("t.alias.example", AF_INET6,
"name: www.example\n"
"alias: t.alias.example\n"
"address: 2001:db8::4\n");
check_ai ("t.www.example", "80", AF_UNSPEC,
"address: STREAM/TCP 192.0.2.19 80\n"
"address: DGRAM/UDP 192.0.2.19 80\n"
"address: RAW/IP 192.0.2.19 80\n"
"address: STREAM/TCP 2001:db8::3 80\n"
"address: DGRAM/UDP 2001:db8::3 80\n"
"address: RAW/IP 2001:db8::3 80\n");
check_ai ("t.alias.example", "80", AF_UNSPEC,
"address: STREAM/TCP 192.0.2.20 80\n"
"address: DGRAM/UDP 192.0.2.20 80\n"
"address: RAW/IP 192.0.2.20 80\n"
"address: STREAM/TCP 2001:db8::4 80\n"
"address: DGRAM/UDP 2001:db8::4 80\n"
"address: RAW/IP 2001:db8::4 80\n");
check_ai ("t.www.example", "80", AF_INET,
"address: STREAM/TCP 192.0.2.19 80\n"
"address: DGRAM/UDP 192.0.2.19 80\n"
"address: RAW/IP 192.0.2.19 80\n");
check_ai ("t.alias.example", "80", AF_INET,
"address: STREAM/TCP 192.0.2.20 80\n"
"address: DGRAM/UDP 192.0.2.20 80\n"
"address: RAW/IP 192.0.2.20 80\n");
check_ai ("t.www.example", "80", AF_INET6,
"address: STREAM/TCP 2001:db8::3 80\n"
"address: DGRAM/UDP 2001:db8::3 80\n"
"address: RAW/IP 2001:db8::3 80\n");
check_ai ("t.alias.example", "80", AF_INET6,
"address: STREAM/TCP 2001:db8::4 80\n"
"address: DGRAM/UDP 2001:db8::4 80\n"
"address: RAW/IP 2001:db8::4 80\n");
test_bug_21295 ();
test_nodata_nxdomain ();
resolv_test_end (aux);
return 0;
}
#include <support/test-driver.c>
Reference in New Issue View Git Blame Copy Permalink