1 /* Exercise low-level query functions with different QTYPEs.
2 Copyright (C) 2016-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 <resolv.h>
20 #include <string.h>
21 #include <support/check.h>
22 #include <support/check_nss.h>
23 #include <support/resolv_test.h>
24 #include <support/support.h>
25 #include <support/test-driver.h>
26 #include <support/xmemstream.h>
27
28 /* If true, the response function will send the actual response packet
29 over TCP instead of UDP. */
30 static volatile bool force_tcp;
31
32 /* Send back a fake resource record matching the QTYPE. */
33 static void
34 response (const struct resolv_response_context *ctx,
35 struct resolv_response_builder *b,
36 const char *qname, uint16_t qclass, uint16_t qtype)
37 {
38 if (force_tcp && ctx->tcp)
39 {
40 resolv_response_init (b, (struct resolv_response_flags) { .tc = 1 });
41 resolv_response_add_question (b, qname, qclass, qtype);
42 return;
43 }
44
45 resolv_response_init (b, (struct resolv_response_flags) { });
46 resolv_response_add_question (b, qname, qclass, qtype);
47 resolv_response_section (b, ns_s_an);
48 resolv_response_open_record (b, qname, qclass, qtype, 0);
49 resolv_response_add_data (b, &qtype, sizeof (qtype));
50 resolv_response_close_record (b);
51 }
52
53 static const char domain[] = "www.example.com";
54
55 static int
56 wrap_res_query (int type, unsigned char *answer, int answer_length)
57 {
58 return res_query (domain, C_IN, type, answer, answer_length);
59 }
60
61 static int
62 wrap_res_search (int type, unsigned char *answer, int answer_length)
63 {
64 return res_query (domain, C_IN, type, answer, answer_length);
65 }
66
67 static int
68 wrap_res_querydomain (int type, unsigned char *answer, int answer_length)
69 {
70 return res_querydomain ("www", "example.com", C_IN, type,
71 answer, answer_length);
72 }
73
74 static int
75 wrap_res_send (int type, unsigned char *answer, int answer_length)
76 {
77 unsigned char buf[512];
78 int ret = res_mkquery (QUERY, domain, C_IN, type,
79 (const unsigned char *) "", 0, NULL,
80 buf, sizeof (buf));
81 if (type < 0 || type >= 65536)
82 {
83 /* res_mkquery fails for out-of-range record types. */
84 TEST_VERIFY_EXIT (ret == -1);
85 return -1;
86 }
87 TEST_VERIFY_EXIT (ret > 12); /* DNS header length. */
88 return res_send (buf, ret, answer, answer_length);
89 }
90
91 static int
92 wrap_res_nquery (int type, unsigned char *answer, int answer_length)
93 {
94 return res_nquery (&_res, domain, C_IN, type, answer, answer_length);
95 }
96
97 static int
98 wrap_res_nsearch (int type, unsigned char *answer, int answer_length)
99 {
100 return res_nquery (&_res, domain, C_IN, type, answer, answer_length);
101 }
102
103 static int
104 wrap_res_nquerydomain (int type, unsigned char *answer, int answer_length)
105 {
106 return res_nquerydomain (&_res, "www", "example.com", C_IN, type,
107 answer, answer_length);
108 }
109
110 static int
111 wrap_res_nsend (int type, unsigned char *answer, int answer_length)
112 {
113 unsigned char buf[512];
114 int ret = res_nmkquery (&_res, QUERY, domain, C_IN, type,
115 (const unsigned char *) "", 0, NULL,
116 buf, sizeof (buf));
117 if (type < 0 || type >= 65536)
118 {
119 /* res_mkquery fails for out-of-range record types. */
120 TEST_VERIFY_EXIT (ret == -1);
121 return -1;
122 }
123 TEST_VERIFY_EXIT (ret > 12); /* DNS header length. */
124 return res_nsend (&_res, buf, ret, answer, answer_length);
125 }
126
127 static void
128 test_function (const char *fname,
129 int (*func) (int type,
130 unsigned char *answer, int answer_length))
131 {
132 unsigned char buf[512];
133 for (int tcp = 0; tcp < 2; ++tcp)
134 {
135 force_tcp = tcp;
136 for (unsigned int type = 1; type <= 65535; ++type)
137 {
138 if (test_verbose)
139 printf ("info: sending QTYPE %d with %s (tcp=%d)\n",
140 type, fname, tcp);
141 int ret = func (type, buf, sizeof (buf));
142 if (ret != 47)
143 FAIL_EXIT1 ("%s tcp=%d qtype=%d return value %d",
144 fname,tcp, type, ret);
145 /* One question, one answer record. */
146 TEST_VERIFY (memcmp (buf + 4, "\0\1\0\1\0\0\0\0", 8) == 0);
147 /* Question section. */
148 static const char qname[] = "\3www\7example\3com";
149 size_t qname_length = sizeof (qname);
150 TEST_VERIFY (memcmp (buf + 12, qname, qname_length) == 0);
151 /* RDATA part of answer. */
152 uint16_t type16 = type;
153 TEST_VERIFY (memcmp (buf + ret - 2, &type16, sizeof (type16)) == 0);
154 }
155 }
156
157 TEST_VERIFY (func (-1, buf, sizeof (buf) == -1));
158 TEST_VERIFY (func (65536, buf, sizeof (buf) == -1));
159 }
160
161 static int
162 do_test (void)
163 {
164 struct resolv_redirect_config config =
165 {
166 .response_callback = response,
167 };
168 struct resolv_test *obj = resolv_test_start (config);
169
170 test_function ("res_query", &wrap_res_query);
171 test_function ("res_search", &wrap_res_search);
172 test_function ("res_querydomain", &wrap_res_querydomain);
173 test_function ("res_send", &wrap_res_send);
174
175 test_function ("res_nquery", &wrap_res_nquery);
176 test_function ("res_nsearch", &wrap_res_nsearch);
177 test_function ("res_nquerydomain", &wrap_res_nquerydomain);
178 test_function ("res_nsend", &wrap_res_nsend);
179
180 resolv_test_end (obj);
181 return 0;
182 }
183
184 #define TIMEOUT 300
185 #include <support/test-driver.c>