1 /* Test alias handling (mainly for gethostbyname).
2 Copyright (C) 2022-2023 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <https://www.gnu.org/licenses/>. */
18
19 #include <array_length.h>
20 #include <arpa/inet.h>
21 #include <netdb.h>
22 #include <stdbool.h>
23 #include <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 #include <support/check.h>
27 #include <support/check_nss.h>
28 #include <support/resolv_test.h>
29 #include <support/support.h>
30
31 #include "tst-resolv-maybe_insert_sig.h"
32
33 /* QNAME format:
34
35 aADDRESSES-cCNAMES.example.net
36
37 CNAMES is the length of the CNAME chain, ADDRESSES is the number of
38 addresses in the response. The special value 255 means that there
39 are no addresses, and the RCODE is NXDOMAIN. */
40 static void
41 response (const struct resolv_response_context *ctx,
42 struct resolv_response_builder *b,
43 const char *qname, uint16_t qclass, uint16_t qtype)
44 {
45 TEST_COMPARE (qclass, C_IN);
46 if (qtype != T_A)
47 TEST_COMPARE (qtype, T_AAAA);
48
49 unsigned int addresses, cnames;
50 char *tail;
51 if (sscanf (qname, "a%u-c%u%ms", &addresses, &cnames, &tail) == 3)
52 {
53 if (strcmp (tail, ".example.com") == 0
54 || strcmp (tail, ".example.net.example.net") == 0
55 || strcmp (tail, ".example.net.example.com") == 0)
56 /* These only happen after NXDOMAIN. */
57 TEST_VERIFY (addresses == 255);
58 else if (strcmp (tail, ".example.net") != 0)
59 FAIL_EXIT1 ("invalid QNAME: %s", qname);
60 }
61 free (tail);
62
63 int rcode;
64 if (addresses == 255)
65 {
66 /* Special case: Use no addresses with NXDOMAIN response. */
67 rcode = ns_r_nxdomain;
68 addresses = 0;
69 }
70 else
71 rcode = 0;
72
73 struct resolv_response_flags flags = { .rcode = rcode };
74 resolv_response_init (b, flags);
75 resolv_response_add_question (b, qname, qclass, qtype);
76 resolv_response_section (b, ns_s_an);
77 maybe_insert_sig (b, qname);
78
79 /* Provide the requested number of CNAME records. */
80 char *previous_name = (char *) qname;
81 for (int unique = 0; unique < cnames; ++unique)
82 {
83 resolv_response_open_record (b, previous_name, qclass, T_CNAME, 60);
84 char *new_name = xasprintf ("%d.alias.example", unique);
85 resolv_response_add_name (b, new_name);
86 resolv_response_close_record (b);
87
88 maybe_insert_sig (b, qname);
89
90 if (previous_name != qname)
91 free (previous_name);
92 previous_name = new_name;
93 }
94
95 for (int unique = 0; unique < addresses; ++unique)
96 {
97 resolv_response_open_record (b, previous_name, qclass, qtype, 60);
98
99 if (qtype == T_A)
100 {
101 char ipv4[4] = {192, 0, 2, 1 + unique};
102 resolv_response_add_data (b, &ipv4, sizeof (ipv4));
103 }
104 else if (qtype == T_AAAA)
105 {
106 char ipv6[16] =
107 {
108 0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
109 1 + unique
110 };
111 resolv_response_add_data (b, &ipv6, sizeof (ipv6));
112 }
113 resolv_response_close_record (b);
114 }
115
116 if (previous_name != qname)
117 free (previous_name);
118 }
119
120 static char *
121 make_qname (bool do_search, int cnames, int addresses)
122 {
123 return xasprintf ("a%d-c%d%s",
124 addresses, cnames, do_search ? "" : ".example.net");
125 }
126
127 static void
128 check_cnames_failure (int af, bool do_search, int cnames, int addresses)
129 {
130 char *qname = make_qname (do_search, cnames, addresses);
131
132 struct hostent *e;
133 if (af == AF_UNSPEC)
134 e = gethostbyname (qname);
135 else
136 e = gethostbyname2 (qname, af);
137
138 if (addresses == 0)
139 check_hostent (qname, e, "error: NO_RECOVERY\n");
140 else
141 check_hostent (qname, e, "error: HOST_NOT_FOUND\n");
142
143 free (qname);
144 }
145
146 static void
147 check (int af, bool do_search, int cnames, int addresses)
148 {
149 char *qname = make_qname (do_search, cnames, addresses);
150 char *fqdn = make_qname (false, cnames, addresses);
151
152 struct hostent *e;
153 if (af == AF_UNSPEC)
154 e = gethostbyname (qname);
155 else
156 e = gethostbyname2 (qname, af);
157 if (e == NULL)
158 FAIL_EXIT1 ("unexpected failure for %d, %d, %d", af, cnames, addresses);
159
160 if (af == AF_UNSPEC || af == AF_INET)
161 {
162 TEST_COMPARE (e->h_addrtype, AF_INET);
163 TEST_COMPARE (e->h_length, 4);
164 }
165 else
166 {
167 TEST_COMPARE (e->h_addrtype, AF_INET6);
168 TEST_COMPARE (e->h_length, 16);
169 }
170
171 for (int i = 0; i < addresses; ++i)
172 {
173 char ipv4[4] = {192, 0, 2, 1 + i};
174 char ipv6[16] =
175 { 0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1 + i };
176 char *expected = e->h_addrtype == AF_INET ? ipv4 : ipv6;
177 TEST_COMPARE_BLOB (e->h_addr_list[i], e->h_length,
178 expected, e->h_length);
179 }
180 TEST_VERIFY (e->h_addr_list[addresses] == NULL);
181
182
183 if (cnames == 0)
184 {
185 /* QNAME is fully qualified. */
186 TEST_COMPARE_STRING (e->h_name, fqdn);
187 TEST_VERIFY (e->h_aliases[0] == NULL);
188 }
189 else
190 {
191 /* Fully-qualified QNAME is demoted to an aliases. */
192 TEST_COMPARE_STRING (e->h_aliases[0], fqdn);
193
194 for (int i = 1; i <= cnames; ++i)
195 {
196 char *expected = xasprintf ("%d.alias.example", i - 1);
197 if (i == cnames)
198 TEST_COMPARE_STRING (e->h_name, expected);
199 else
200 TEST_COMPARE_STRING (e->h_aliases[i], expected);
201 free (expected);
202 }
203 TEST_VERIFY (e->h_aliases[cnames] == NULL);
204 }
205
206 free (fqdn);
207 free (qname);
208 }
209
210 static int
211 do_test (void)
212 {
213 struct resolv_test *obj = resolv_test_start
214 ((struct resolv_redirect_config)
215 {
216 .response_callback = response,
217 .search = { "example.net", "example.com" },
218 });
219
220 static const int families[] = { AF_UNSPEC, AF_INET, AF_INET6 };
221
222 for (int do_insert_sig = 0; do_insert_sig < 2; ++do_insert_sig)
223 {
224 insert_sig = do_insert_sig;
225
226 /* If do_search is true, a bare host name (for example, a1-c1)
227 is used. This exercises search path processing and FQDN
228 qualification. */
229 for (int do_search = 0; do_search < 2; ++do_search)
230 for (const int *paf = families; paf != array_end (families); ++paf)
231 {
232 for (int cnames = 0; cnames <= 100; ++cnames)
233 {
234 check_cnames_failure (*paf, do_search, cnames, 0);
235 /* Now with NXDOMAIN responses. */
236 check_cnames_failure (*paf, do_search, cnames, 255);
237 }
238
239 for (int cnames = 0; cnames <= 10; ++cnames)
240 for (int addresses = 1; addresses <= 10; ++addresses)
241 check (*paf, do_search, cnames, addresses);
242
243 /* The current implementation is limited to 47 aliases.
244 Addresses do not have such a limit. */
245 check (*paf, do_search, 47, 60);
246 }
247 }
248
249 resolv_test_end (obj);
250
251 return 0;
252 }
253
254 #include <support/test-driver.c>