1 /* Test the RES_NOAAAA resolver option.
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 <errno.h>
20 #include <netdb.h>
21 #include <resolv.h>
22 #include <stdlib.h>
23 #include <support/check.h>
24 #include <support/check_nss.h>
25 #include <support/resolv_test.h>
26 #include <support/support.h>
27
28 /* Used to keep track of the number of queries. */
29 static volatile unsigned int queries;
30
31 static void
32 response (const struct resolv_response_context *ctx,
33 struct resolv_response_builder *b,
34 const char *qname, uint16_t qclass, uint16_t qtype)
35 {
36 /* Each test should only send one query. */
37 ++queries;
38 TEST_COMPARE (queries, 1);
39
40 /* AAAA queries are supposed to be disabled. */
41 TEST_VERIFY (qtype != T_AAAA);
42 TEST_COMPARE (qclass, C_IN);
43
44 /* The only other query type besides A is PTR. */
45 if (qtype != T_A)
46 TEST_COMPARE (qtype, T_PTR);
47
48 int an, ns, ar;
49 char *tail;
50 if (sscanf (qname, "an%d.ns%d.ar%d.%ms", &an, &ns, &ar, &tail) != 4)
51 FAIL_EXIT1 ("invalid QNAME: %s\n", qname);
52 TEST_COMPARE_STRING (tail, "example");
53 free (tail);
54
55 if (an < 0 || ns < 0 || ar < 0)
56 {
57 struct resolv_response_flags flags = { .rcode = NXDOMAIN, };
58 resolv_response_init (b, flags);
59 resolv_response_add_question (b, qname, qclass, qtype);
60 return;
61 }
62
63 struct resolv_response_flags flags = {};
64 resolv_response_init (b, flags);
65 resolv_response_add_question (b, qname, qclass, qtype);
66
67 resolv_response_section (b, ns_s_an);
68 for (int i = 0; i < an; ++i)
69 {
70 resolv_response_open_record (b, qname, qclass, qtype, 60);
71 switch (qtype)
72 {
73 case T_A:
74 {
75 char ipv4[4] = {192, 0, 2, i + 1};
76 resolv_response_add_data (b, &ipv4, sizeof (ipv4));
77 }
78 break;
79
80 case T_PTR:
81 {
82 char *name = xasprintf ("ptr-%d", i);
83 resolv_response_add_name (b, name);
84 free (name);
85 }
86 break;
87 }
88 resolv_response_close_record (b);
89 }
90
91 resolv_response_section (b, ns_s_ns);
92 for (int i = 0; i < ns; ++i)
93 {
94 resolv_response_open_record (b, qname, qclass, T_NS, 60);
95 char *name = xasprintf ("ns%d.example.net", i);
96 resolv_response_add_name (b, name);
97 free (name);
98 resolv_response_close_record (b);
99 }
100
101 resolv_response_section (b, ns_s_ar);
102 int addr = 1;
103 for (int i = 0; i < ns; ++i)
104 {
105 char *name = xasprintf ("ns%d.example.net", i);
106 for (int j = 0; j < ar; ++j)
107 {
108 resolv_response_open_record (b, name, qclass, T_A, 60);
109 char ipv4[4] = {192, 0, 2, addr};
110 resolv_response_add_data (b, &ipv4, sizeof (ipv4));
111 resolv_response_close_record (b);
112
113 resolv_response_open_record (b, name, qclass, T_AAAA, 60);
114 char ipv6[16]
115 = {0x20, 0x01, 0xd, 0xb8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, addr};
116 resolv_response_add_data (b, &ipv6, sizeof (ipv6));
117 resolv_response_close_record (b);
118
119 ++addr;
120 }
121 free (name);
122 }
123 }
124
125 /* Number of modes. Lowest bit encodes *n* function vs implicit _res
126 argument. The mode numbers themselves are arbitrary. */
127 enum { mode_count = 8 };
128
129 /* res_send-like modes do not perform error translation. */
130 enum { first_send_mode = 6 };
131
132 static int
133 libresolv_query (unsigned int mode, const char *qname, uint16_t qtype,
134 unsigned char *buf, size_t buflen)
135 {
136 int saved_errno = errno;
137
138 TEST_VERIFY_EXIT (mode < mode_count);
139
140 switch (mode)
141 {
142 case 0:
143 return res_query (qname, C_IN, qtype, buf, buflen);
144 case 1:
145 return res_nquery (&_res, qname, C_IN, qtype, buf, buflen);
146 case 2:
147 return res_search (qname, C_IN, qtype, buf, buflen);
148 case 3:
149 return res_nsearch (&_res, qname, C_IN, qtype, buf, buflen);
150 case 4:
151 return res_querydomain (qname, "", C_IN, qtype, buf, buflen);
152 case 5:
153 return res_nquerydomain (&_res, qname, "", C_IN, qtype, buf, buflen);
154 case 6:
155 {
156 unsigned char querybuf[512];
157 int ret = res_mkquery (QUERY, qname, C_IN, qtype,
158 NULL, 0, NULL, querybuf, sizeof (querybuf));
159 TEST_VERIFY_EXIT (ret > 0);
160 errno = saved_errno;
161 return res_send (querybuf, ret, buf, buflen);
162 }
163 case 7:
164 {
165 unsigned char querybuf[512];
166 int ret = res_nmkquery (&_res, QUERY, qname, C_IN, qtype,
167 NULL, 0, NULL, querybuf, sizeof (querybuf));
168 TEST_VERIFY_EXIT (ret > 0);
169 errno = saved_errno;
170 return res_nsend (&_res, querybuf, ret, buf, buflen);
171 }
172 }
173 __builtin_unreachable ();
174 }
175
176 static int
177 do_test (void)
178 {
179 struct resolv_test *obj = resolv_test_start
180 ((struct resolv_redirect_config)
181 {
182 .response_callback = response
183 });
184
185 _res.options |= RES_NOAAAA;
186
187 check_hostent ("an1.ns2.ar1.example",
188 gethostbyname ("an1.ns2.ar1.example"),
189 "name: an1.ns2.ar1.example\n"
190 "address: 192.0.2.1\n");
191 queries = 0;
192 check_hostent ("an0.ns2.ar1.example",
193 gethostbyname ("an0.ns2.ar1.example"),
194 "error: NO_ADDRESS\n");
195 queries = 0;
196 check_hostent ("an-1.ns2.ar1.example",
197 gethostbyname ("an-1.ns2.ar1.example"),
198 "error: HOST_NOT_FOUND\n");
199 queries = 0;
200
201 check_hostent ("an1.ns2.ar1.example AF_INET",
202 gethostbyname2 ("an1.ns2.ar1.example", AF_INET),
203 "name: an1.ns2.ar1.example\n"
204 "address: 192.0.2.1\n");
205 queries = 0;
206 check_hostent ("an0.ns2.ar1.example AF_INET",
207 gethostbyname2 ("an0.ns2.ar1.example", AF_INET),
208 "error: NO_ADDRESS\n");
209 queries = 0;
210 check_hostent ("an-1.ns2.ar1.example AF_INET",
211 gethostbyname2 ("an-1.ns2.ar1.example", AF_INET),
212 "error: HOST_NOT_FOUND\n");
213 queries = 0;
214
215 check_hostent ("an1.ns2.ar1.example AF_INET6",
216 gethostbyname2 ("an1.ns2.ar1.example", AF_INET6),
217 "error: NO_ADDRESS\n");
218 queries = 0;
219 check_hostent ("an0.ns2.ar1.example AF_INET6",
220 gethostbyname2 ("an0.ns2.ar1.example", AF_INET6),
221 "error: NO_ADDRESS\n");
222 queries = 0;
223 check_hostent ("an-1.ns2.ar1.example AF_INET6",
224 gethostbyname2 ("an-1.ns2.ar1.example", AF_INET6),
225 "error: HOST_NOT_FOUND\n");
226 queries = 0;
227
228 /* Multiple addresses. */
229 check_hostent ("an2.ns0.ar0.example",
230 gethostbyname ("an2.ns0.ar0.example"),
231 "name: an2.ns0.ar0.example\n"
232 "address: 192.0.2.1\n"
233 "address: 192.0.2.2\n");
234 queries = 0;
235 check_hostent ("an2.ns0.ar0.example AF_INET6",
236 gethostbyname2 ("an2.ns0.ar0.example", AF_INET6),
237 "error: NO_ADDRESS\n");
238 queries = 0;
239
240 /* getaddrinfo checks with one address. */
241 struct addrinfo *ai;
242 int ret;
243 ret = getaddrinfo ("an1.ns2.ar1.example", "80",
244 &(struct addrinfo)
245 {
246 .ai_family = AF_INET,
247 .ai_socktype = SOCK_STREAM,
248 }, &ai);
249 check_addrinfo ("an1.ns2.ar1.example (AF_INET)", ai, ret,
250 "address: STREAM/TCP 192.0.2.1 80\n");
251 freeaddrinfo (ai);
252 queries = 0;
253 ret = getaddrinfo ("an1.ns2.ar1.example", "80",
254 &(struct addrinfo)
255 {
256 .ai_family = AF_INET6,
257 .ai_socktype = SOCK_STREAM,
258 }, &ai);
259 check_addrinfo ("an1.ns2.ar1.example (AF_INET6)", ai, ret,
260 "error: No address associated with hostname\n");
261 queries = 0;
262 ret = getaddrinfo ("an1.ns2.ar1.example", "80",
263 &(struct addrinfo)
264 {
265 .ai_family = AF_UNSPEC,
266 .ai_socktype = SOCK_STREAM,
267 }, &ai);
268 check_addrinfo ("an1.ns2.ar1.example (AF_UNSPEC)", ai, ret,
269 "address: STREAM/TCP 192.0.2.1 80\n");
270 freeaddrinfo (ai);
271 queries = 0;
272
273 /* getaddrinfo checks with three addresses. */
274 ret = getaddrinfo ("an3.ns2.ar1.example", "80",
275 &(struct addrinfo)
276 {
277 .ai_family = AF_INET,
278 .ai_socktype = SOCK_STREAM,
279 }, &ai);
280 check_addrinfo ("an3.ns2.ar1.example (AF_INET)", ai, ret,
281 "address: STREAM/TCP 192.0.2.1 80\n"
282 "address: STREAM/TCP 192.0.2.2 80\n"
283 "address: STREAM/TCP 192.0.2.3 80\n");
284 freeaddrinfo (ai);
285 queries = 0;
286 ret = getaddrinfo ("an3.ns2.ar1.example", "80",
287 &(struct addrinfo)
288 {
289 .ai_family = AF_INET6,
290 .ai_socktype = SOCK_STREAM,
291 }, &ai);
292 check_addrinfo ("an3.ns2.ar1.example (AF_INET6)", ai, ret,
293 "error: No address associated with hostname\n");
294 queries = 0;
295 ret = getaddrinfo ("an3.ns2.ar1.example", "80",
296 &(struct addrinfo)
297 {
298 .ai_family = AF_UNSPEC,
299 .ai_socktype = SOCK_STREAM,
300 }, &ai);
301 check_addrinfo ("an3.ns2.ar1.example (AF_UNSPEC)", ai, ret,
302 "address: STREAM/TCP 192.0.2.1 80\n"
303 "address: STREAM/TCP 192.0.2.2 80\n"
304 "address: STREAM/TCP 192.0.2.3 80\n");
305 freeaddrinfo (ai);
306 queries = 0;
307
308 /* getaddrinfo checks with no address. */
309 ret = getaddrinfo ("an0.ns2.ar1.example", "80",
310 &(struct addrinfo)
311 {
312 .ai_family = AF_INET,
313 .ai_socktype = SOCK_STREAM,
314 }, &ai);
315 check_addrinfo ("an0.ns2.ar1.example (AF_INET)", ai, ret,
316 "error: No address associated with hostname\n");
317 queries = 0;
318 ret = getaddrinfo ("an0.ns2.ar1.example", "80",
319 &(struct addrinfo)
320 {
321 .ai_family = AF_INET6,
322 .ai_socktype = SOCK_STREAM,
323 }, &ai);
324 check_addrinfo ("an0.ns2.ar1.example (AF_INET6)", ai, ret,
325 "error: No address associated with hostname\n");
326 queries = 0;
327 ret = getaddrinfo ("an0.ns2.ar1.example", "80",
328 &(struct addrinfo)
329 {
330 .ai_family = AF_UNSPEC,
331 .ai_socktype = SOCK_STREAM,
332 }, &ai);
333 check_addrinfo ("an-1.ns2.ar1.example (AF_UNSPEC)", ai, ret,
334 "error: No address associated with hostname\n");
335 queries = 0;
336
337 /* getaddrinfo checks with NXDOMAIN. */
338 ret = getaddrinfo ("an-1.ns2.ar1.example", "80",
339 &(struct addrinfo)
340 {
341 .ai_family = AF_INET,
342 .ai_socktype = SOCK_STREAM,
343 }, &ai);
344 check_addrinfo ("an-1.ns2.ar1.example (AF_INET)", ai, ret,
345 "error: Name or service not known\n");
346 queries = 0;
347 ret = getaddrinfo ("an-1.ns2.ar1.example", "80",
348 &(struct addrinfo)
349 {
350 .ai_family = AF_INET6,
351 .ai_socktype = SOCK_STREAM,
352 }, &ai);
353 check_addrinfo ("an-1.ns2.ar1.example (AF_INET6)", ai, ret,
354 "error: Name or service not known\n");
355 queries = 0;
356 ret = getaddrinfo ("an-1.ns2.ar1.example", "80",
357 &(struct addrinfo)
358 {
359 .ai_family = AF_UNSPEC,
360 .ai_socktype = SOCK_STREAM,
361 }, &ai);
362 check_addrinfo ("an-1.ns2.ar1.example (AF_UNSPEC)", ai, ret,
363 "error: Name or service not known\n");
364 queries = 0;
365
366 for (unsigned int mode = 0; mode < mode_count; ++mode)
367 {
368 unsigned char *buf;
369 int ret;
370
371 /* Response for A. */
372 buf = malloc (512);
373 ret = libresolv_query (mode, "an1.ns2.ar1.example", T_A, buf, 512);
374 TEST_VERIFY_EXIT (ret > 0);
375 check_dns_packet ("an1.ns2.ar1.example A", buf, ret,
376 "name: an1.ns2.ar1.example\n"
377 "address: 192.0.2.1\n");
378 free (buf);
379 queries = 0;
380
381 /* NODATA response for A. */
382 buf = malloc (512);
383 errno = 0;
384 ret = libresolv_query (mode, "an0.ns2.ar1.example", T_A, buf, 512);
385 if (mode < first_send_mode)
386 {
387 TEST_COMPARE (ret, -1);
388 TEST_COMPARE (errno, 0);
389 TEST_COMPARE (h_errno, NO_ADDRESS);
390 }
391 else
392 {
393 TEST_VERIFY_EXIT (ret > 0);
394 TEST_COMPARE (((HEADER *)buf)->rcode, 0);
395 check_dns_packet ("an1.ns2.ar1.example A", buf, ret,
396 "name: an0.ns2.ar1.example\n");
397 }
398 free (buf);
399 queries = 0;
400
401 /* NXDOMAIN response for A. */
402 buf = malloc (512);
403 errno = 0;
404 ret = libresolv_query (mode, "an-1.ns2.ar1.example", T_A, buf, 512);
405 if (mode < first_send_mode)
406 {
407 TEST_COMPARE (ret, -1);
408 TEST_COMPARE (errno, 0);
409 TEST_COMPARE (h_errno, HOST_NOT_FOUND);
410 }
411 else
412 {
413 TEST_VERIFY_EXIT (ret > 0);
414 TEST_COMPARE (((HEADER *)buf)->rcode, NXDOMAIN);
415 check_dns_packet ("an1.ns2.ar1.example A", buf, ret,
416 "name: an-1.ns2.ar1.example\n");
417 }
418 free (buf);
419 queries = 0;
420
421 /* Response for PTR. */
422 buf = malloc (512);
423 ret = libresolv_query (mode, "an1.ns2.ar1.example", T_PTR, buf, 512);
424 TEST_VERIFY_EXIT (ret > 0);
425 check_dns_packet ("an1.ns2.ar1.example PTR", buf, ret,
426 "name: an1.ns2.ar1.example\n"
427 "data: an1.ns2.ar1.example PTR ptr-0\n");
428 free (buf);
429 queries = 0;
430
431 /* NODATA response for PTR. */
432 buf = malloc (512);
433 errno = 0;
434 ret = libresolv_query (mode, "an0.ns2.ar1.example", T_PTR, buf, 512);
435 if (mode < first_send_mode)
436 {
437 TEST_COMPARE (ret, -1);
438 TEST_COMPARE (errno, 0);
439 TEST_COMPARE (h_errno, NO_ADDRESS);
440 }
441 else
442 {
443 TEST_VERIFY_EXIT (ret > 0);
444 TEST_COMPARE (((HEADER *)buf)->rcode, 0);
445 check_dns_packet ("an1.ns2.ar1.example PTR", buf, ret,
446 "name: an0.ns2.ar1.example\n");
447 }
448 free (buf);
449 queries = 0;
450
451 /* NXDOMAIN response for PTR. */
452 buf = malloc (512);
453 errno = 0;
454 ret = libresolv_query (mode, "an-1.ns2.ar1.example", T_PTR, buf, 512);
455 if (mode < first_send_mode)
456 {
457 TEST_COMPARE (ret, -1);
458 TEST_COMPARE (errno, 0);
459 TEST_COMPARE (h_errno, HOST_NOT_FOUND);
460 }
461 else
462 {
463 TEST_VERIFY_EXIT (ret > 0);
464 TEST_COMPARE (((HEADER *)buf)->rcode, NXDOMAIN);
465 check_dns_packet ("an1.ns2.ar1.example PTR", buf, ret,
466 "name: an-1.ns2.ar1.example\n");
467 }
468 free (buf);
469 queries = 0;
470
471 /* NODATA response for AAAA. */
472 buf = malloc (512);
473 errno = 0;
474 ret = libresolv_query (mode, "an1.ns2.ar1.example", T_AAAA, buf, 512);
475 if (mode < first_send_mode)
476 {
477 TEST_COMPARE (ret, -1);
478 TEST_COMPARE (errno, 0);
479 TEST_COMPARE (h_errno, NO_ADDRESS);
480 }
481 else
482 {
483 TEST_VERIFY_EXIT (ret > 0);
484 TEST_COMPARE (((HEADER *)buf)->rcode, 0);
485 check_dns_packet ("an1.ns2.ar1.example A", buf, ret,
486 "name: an1.ns2.ar1.example\n");
487 }
488 free (buf);
489 queries = 0;
490
491 /* NODATA response for AAAA (original is already NODATA). */
492 buf = malloc (512);
493 errno = 0;
494 ret = libresolv_query (mode, "an0.ns2.ar1.example", T_AAAA, buf, 512);
495 if (mode < first_send_mode)
496 {
497 TEST_COMPARE (ret, -1);
498 TEST_COMPARE (errno, 0);
499 TEST_COMPARE (h_errno, NO_ADDRESS);
500 }
501 else
502 {
503 TEST_VERIFY_EXIT (ret > 0);
504 TEST_COMPARE (((HEADER *)buf)->rcode, 0);
505 check_dns_packet ("an0.ns2.ar1.example A", buf, ret,
506 "name: an0.ns2.ar1.example\n");
507 }
508 free (buf);
509 queries = 0;
510
511 /* NXDOMAIN response. */
512 buf = malloc (512);
513 errno = 0;
514 ret = libresolv_query (mode, "an-1.ns2.ar1.example", T_AAAA, buf, 512);
515 if (mode < first_send_mode)
516 {
517 TEST_COMPARE (ret, -1);
518 TEST_COMPARE (errno, 0);
519 TEST_COMPARE (h_errno, HOST_NOT_FOUND);
520 }
521 else
522 {
523 TEST_VERIFY_EXIT (ret > 0);
524 TEST_COMPARE (((HEADER *)buf)->rcode, NXDOMAIN);
525 check_dns_packet ("an-1.ns2.ar1.example A", buf, ret,
526 "name: an-1.ns2.ar1.example\n");
527 }
528 free (buf);
529 queries = 0;
530 }
531
532 resolv_test_end (obj);
533
534 return 0;
535 }
536
537 #include <support/test-driver.c>