1 /* Test reverse DNS lookup.
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 <arpa/inet.h>
20 #include <errno.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/next_to_fault.h>
29 #include <support/resolv_test.h>
30 #include <support/support.h>
31
32 #include "tst-resolv-maybe_insert_sig.h"
33
34 /* QNAME format:
35
36 ADDRESSES.CNAMES...(lots of 0s)...8.b.d.0.1.0.0.2.ip6.arpa.
37 CNAMES|ADDRESSES.2.0.192.in-addr-arpa.
38
39 For the IPv4 reverse lookup, the address count is in the lower
40 bits.
41
42 CNAMES is the length of the CNAME chain, ADDRESSES is the number of
43 addresses in the response. The special value 15 means that there
44 are no addresses, and the RCODE is NXDOMAIN. */
45 static void
46 response (const struct resolv_response_context *ctx,
47 struct resolv_response_builder *b,
48 const char *qname, uint16_t qclass, uint16_t qtype)
49 {
50 TEST_COMPARE (qclass, C_IN);
51 TEST_COMPARE (qtype, T_PTR);
52
53 unsigned int addresses, cnames, bits;
54 char *tail;
55 if (strstr (qname, "ip6.arpa") != NULL
56 && sscanf (qname, "%x.%x.%ms", &addresses, &cnames, &tail) == 3)
57 TEST_COMPARE_STRING (tail, "\
58 0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.0.8.b.d.0.1.0.0.2.ip6.arpa");
59 else if (sscanf (qname, "%u.%ms", &bits, &tail) == 2)
60 {
61 TEST_COMPARE_STRING (tail, "2.0.192.in-addr.arpa");
62 addresses = bits & 0x0f;
63 cnames = bits >> 4;
64 }
65 else
66 FAIL_EXIT1 ("invalid QNAME: %s", qname);
67 free (tail);
68
69 int rcode;
70 if (addresses == 15)
71 {
72 /* Special case: Use no addresses with NXDOMAIN response. */
73 rcode = ns_r_nxdomain;
74 addresses = 0;
75 }
76 else
77 rcode = 0;
78
79 struct resolv_response_flags flags = { .rcode = rcode };
80 resolv_response_init (b, flags);
81 resolv_response_add_question (b, qname, qclass, qtype);
82 resolv_response_section (b, ns_s_an);
83 maybe_insert_sig (b, qname);
84
85 /* Provide the requested number of CNAME records. */
86 char *previous_name = (char *) qname;
87 for (int unique = 0; unique < cnames; ++unique)
88 {
89 resolv_response_open_record (b, previous_name, qclass, T_CNAME, 60);
90 char *new_name = xasprintf ("%d.alias.example", unique);
91 resolv_response_add_name (b, new_name);
92 resolv_response_close_record (b);
93
94 maybe_insert_sig (b, qname);
95
96 if (previous_name != qname)
97 free (previous_name);
98 previous_name = new_name;
99 }
100
101 for (int unique = 0; unique < addresses; ++unique)
102 {
103 resolv_response_open_record (b, previous_name, qclass, T_PTR, 60);
104 char *ptr = xasprintf ("unique-%d.cnames-%u.addresses-%u.example",
105 unique, cnames, addresses);
106 resolv_response_add_name (b, ptr);
107 free (ptr);
108 resolv_response_close_record (b);
109 }
110
111 if (previous_name != qname)
112 free (previous_name);
113 }
114
115 /* Used to check that gethostbyaddr_r does not write past the buffer
116 end. */
117 static struct support_next_to_fault ntf;
118
119 /* Perform a gethostbyaddr call and check the result. */
120 static void
121 check_gethostbyaddr (const char *address, const char *expected)
122 {
123 unsigned char bytes[16];
124 unsigned int byteslen;
125 int family;
126 if (strchr (address, ':') != NULL)
127 {
128 family = AF_INET6;
129 byteslen = 16;
130 }
131 else
132 {
133 family = AF_INET;
134 byteslen = 4;
135 }
136 TEST_COMPARE (inet_pton (family, address, bytes), 1);
137
138 struct hostent *e = gethostbyaddr (bytes, byteslen, family);
139 check_hostent (address, e, expected);
140
141 if (e == NULL)
142 return;
143
144 /* Try gethostbyaddr_r with increasing sizes until success. First
145 compute a reasonable minimum buffer size, to avoid many pointless
146 attempts. */
147 size_t minimum_size = strlen (e->h_name);
148 for (int i = 0; e->h_addr_list[i] != NULL; ++i)
149 minimum_size += e->h_length + sizeof (char *);
150 for (int i = 0; e->h_aliases[i] != NULL; ++i)
151 minimum_size += strlen (e->h_aliases[i]) + 1 + sizeof (char *);
152
153 /* Gradually increase the size until success. */
154 for (size_t size = minimum_size; size < ntf.length; ++size)
155 {
156 struct hostent result;
157 int herrno;
158 int ret = gethostbyaddr_r (bytes, byteslen, family, &result,
159 ntf.buffer + ntf.length - size, size,
160 &e, &herrno);
161 if (ret == ERANGE)
162 /* Retry with larger size. */
163 TEST_COMPARE (herrno, NETDB_INTERNAL);
164 else if (ret == 0)
165 {
166 TEST_VERIFY (size > minimum_size);
167 check_hostent (address, e, expected);
168 return;
169 }
170 else
171 FAIL_EXIT1 ("Unexpected gethostbyaddr_r failure: %d", ret);
172 }
173
174 FAIL_EXIT1 ("gethostbyaddr_r always failed for: %s", address);
175 }
176
177 /* Perform a getnameinfo call and check the result. */
178 static void
179 check_getnameinfo (const char *address, const char *expected)
180 {
181 struct sockaddr_in sin = { };
182 struct sockaddr_in6 sin6 = { };
183 void *sa;
184 socklen_t salen;
185 if (strchr (address, ':') != NULL)
186 {
187 sin6.sin6_family = AF_INET6;
188 TEST_COMPARE (inet_pton (AF_INET6, address, &sin6.sin6_addr), 1);
189 sin6.sin6_port = htons (80);
190 sa = &sin6;
191 salen = sizeof (sin6);
192 }
193 else
194 {
195 sin.sin_family = AF_INET;
196 TEST_COMPARE (inet_pton (AF_INET, address, &sin.sin_addr), 1);
197 sin.sin_port = htons (80);
198 sa = &sin;
199 salen = sizeof (sin);
200 }
201
202 char host[64];
203 char service[64];
204 int ret = getnameinfo (sa, salen, host,
205 sizeof (host), service, sizeof (service),
206 NI_NAMEREQD | NI_NUMERICSERV);
207 switch (ret)
208 {
209 case 0:
210 TEST_COMPARE_STRING (host, expected);
211 TEST_COMPARE_STRING (service, "80");
212 break;
213 case EAI_SYSTEM:
214 TEST_COMPARE_STRING (strerror (errno), expected);
215 break;
216 default:
217 TEST_COMPARE_STRING (gai_strerror (ret), expected);
218 }
219 }
220
221 static int
222 do_test (void)
223 {
224 /* Some reasonably upper bound for the maximum response size. */
225 ntf = support_next_to_fault_allocate (4096);
226
227 struct resolv_test *obj = resolv_test_start
228 ((struct resolv_redirect_config)
229 {
230 .response_callback = response
231 });
232
233 for (int do_insert_sig = 0; do_insert_sig < 2; ++do_insert_sig)
234 {
235 insert_sig = do_insert_sig;
236
237 /* No PTR record, RCODE=0. */
238 check_gethostbyaddr ("192.0.2.0", "error: NO_RECOVERY\n");
239 check_getnameinfo ("192.0.2.0", "Name or service not known");
240 check_gethostbyaddr ("192.0.2.16", "error: NO_RECOVERY\n");
241 check_getnameinfo ("192.0.2.16", "Name or service not known");
242 check_gethostbyaddr ("192.0.2.32", "error: NO_RECOVERY\n");
243 check_getnameinfo ("192.0.2.32", "Name or service not known");
244 check_gethostbyaddr ("2001:db8::", "error: NO_RECOVERY\n");
245 check_getnameinfo ("2001:db8::", "Name or service not known");
246 check_gethostbyaddr ("2001:db8::10", "error: NO_RECOVERY\n");
247 check_getnameinfo ("2001:db8::10", "Name or service not known");
248 check_gethostbyaddr ("2001:db8::20", "error: NO_RECOVERY\n");
249 check_getnameinfo ("2001:db8::20", "Name or service not known");
250
251 /* No PTR record, NXDOMAIN. */
252 check_gethostbyaddr ("192.0.2.15", "error: HOST_NOT_FOUND\n");
253 check_getnameinfo ("192.0.2.15", "Name or service not known");
254 check_gethostbyaddr ("192.0.2.31", "error: HOST_NOT_FOUND\n");
255 check_getnameinfo ("192.0.2.31", "Name or service not known");
256 check_gethostbyaddr ("192.0.2.47", "error: HOST_NOT_FOUND\n");
257 check_getnameinfo ("192.0.2.47", "Name or service not known");
258 check_gethostbyaddr ("2001:db8::f", "error: HOST_NOT_FOUND\n");
259 check_getnameinfo ("2001:db8::f", "Name or service not known");
260 check_gethostbyaddr ("2001:db8::1f", "error: HOST_NOT_FOUND\n");
261 check_getnameinfo ("2001:db8::1f", "Name or service not known");
262 check_gethostbyaddr ("2001:db8::2f", "error: HOST_NOT_FOUND\n");
263 check_getnameinfo ("2001:db8::2f", "Name or service not known");
264
265 /* Actual response data. Only the first PTR record is returned. */
266 check_gethostbyaddr ("192.0.2.1",
267 "name: unique-0.cnames-0.addresses-1.example\n"
268 "address: 192.0.2.1\n");
269 check_getnameinfo ("192.0.2.1",
270 "unique-0.cnames-0.addresses-1.example");
271 check_gethostbyaddr ("192.0.2.17",
272 "name: unique-0.cnames-1.addresses-1.example\n"
273 "address: 192.0.2.17\n");
274 check_getnameinfo ("192.0.2.17",
275 "unique-0.cnames-1.addresses-1.example");
276 check_gethostbyaddr ("192.0.2.18",
277 "name: unique-0.cnames-1.addresses-2.example\n"
278 "address: 192.0.2.18\n");
279 check_getnameinfo ("192.0.2.18",
280 "unique-0.cnames-1.addresses-2.example");
281 check_gethostbyaddr ("192.0.2.33",
282 "name: unique-0.cnames-2.addresses-1.example\n"
283 "address: 192.0.2.33\n");
284 check_getnameinfo ("192.0.2.33",
285 "unique-0.cnames-2.addresses-1.example");
286 check_gethostbyaddr ("192.0.2.34",
287 "name: unique-0.cnames-2.addresses-2.example\n"
288 "address: 192.0.2.34\n");
289 check_getnameinfo ("192.0.2.34",
290 "unique-0.cnames-2.addresses-2.example");
291
292 /* Same for IPv6 addresses. */
293 check_gethostbyaddr ("2001:db8::1",
294 "name: unique-0.cnames-0.addresses-1.example\n"
295 "address: 2001:db8::1\n");
296 check_getnameinfo ("2001:db8::1",
297 "unique-0.cnames-0.addresses-1.example");
298 check_gethostbyaddr ("2001:db8::11",
299 "name: unique-0.cnames-1.addresses-1.example\n"
300 "address: 2001:db8::11\n");
301 check_getnameinfo ("2001:db8::11",
302 "unique-0.cnames-1.addresses-1.example");
303 check_gethostbyaddr ("2001:db8::12",
304 "name: unique-0.cnames-1.addresses-2.example\n"
305 "address: 2001:db8::12\n");
306 check_getnameinfo ("2001:db8::12",
307 "unique-0.cnames-1.addresses-2.example");
308 check_gethostbyaddr ("2001:db8::21",
309 "name: unique-0.cnames-2.addresses-1.example\n"
310 "address: 2001:db8::21\n");
311 check_getnameinfo ("2001:db8::21",
312 "unique-0.cnames-2.addresses-1.example");
313 check_gethostbyaddr ("2001:db8::22",
314 "name: unique-0.cnames-2.addresses-2.example\n"
315 "address: 2001:db8::22\n");
316 check_getnameinfo ("2001:db8::22",
317 "unique-0.cnames-2.addresses-2.example");
318 }
319
320 resolv_test_end (obj);
321
322 support_next_to_fault_free (&ntf);
323 return 0;
324 }
325
326 #include <support/test-driver.c>