Debian Codegraph @

glib/gio/tests/resolver-parsing.c

raw
1 /*
2 * Copyright (c) 2021 Igalia S.L.
3 *
4 * SPDX-License-Identifier: LGPL-2.1-or-later
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General
17 * Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 *
19 * Authors: Patrick Griffis <[email protected]>
20 */
21
22 #include "config.h"
23
24 #include <glib.h>
25 #include <gio/gnetworking.h>
26
27 #define GIO_COMPILATION
28 #include "gthreadedresolver.h"
29 #undef GIO_COMPILATION
30
31 #ifdef HAVE_DN_COMP
32 static void
33 dns_builder_add_uint8 (GByteArray *builder,
34 guint8 value)
35 {
36 g_byte_array_append (builder, &value, 1);
37 }
38
39 static void
40 dns_builder_add_uint16 (GByteArray *builder,
41 guint16 value)
42 {
43 dns_builder_add_uint8 (builder, (value >> 8) & 0xFF);
44 dns_builder_add_uint8 (builder, (value) & 0xFF);
45 }
46
47 static void
48 dns_builder_add_uint32 (GByteArray *builder,
49 guint32 value)
50 {
51 dns_builder_add_uint8 (builder, (value >> 24) & 0xFF);
52 dns_builder_add_uint8 (builder, (value >> 16) & 0xFF);
53 dns_builder_add_uint8 (builder, (value >> 8) & 0xFF);
54 dns_builder_add_uint8 (builder, (value) & 0xFF);
55 }
56
57 static void
58 dns_builder_add_length_prefixed_string (GByteArray *builder,
59 const char *string)
60 {
61 guint8 length;
62
63 g_assert (strlen (string) <= G_MAXUINT8);
64
65 length = (guint8) strlen (string);
66 dns_builder_add_uint8 (builder, length);
67
68 /* Don't include trailing NUL */
69 g_byte_array_append (builder, (const guchar *)string, length);
70 }
71
72 static void
73 dns_builder_add_domain (GByteArray *builder,
74 const char *string)
75 {
76 int ret;
77 guchar buffer[256];
78
79 ret = dn_comp (string, buffer, sizeof (buffer), NULL, NULL);
80 g_assert (ret != -1);
81
82 g_byte_array_append (builder, buffer, ret);
83 }
84
85 /* Append an invalid domain name to the DNS response. This is implemented by
86 * appending a single label followed by a pointer back to that label. This is
87 * invalid regardless of any other context in the response as its expansion is
88 * infinite.
89 *
90 * See https://datatracker.ietf.org/doc/html/rfc1035#section-4.1.4
91 *
92 * In order to create a pointer to the label, the label’s final offset in the
93 * DNS response must be known. The current length of @builder, plus @offset, is
94 * used for this. Hence, @offset is the additional offset (in bytes) to add, and
95 * typically corresponds to the length of the parent #GByteArray that @builder
96 * will eventually be added to. Potentially plus 2 bytes for the rdlength, as
97 * per dns_builder_add_answer_data(). */
98 static void
99 dns_builder_add_invalid_domain (GByteArray *builder,
100 gsize offset)
101 {
102 offset += builder->len;
103 g_assert ((offset & 0xc0) == 0);
104
105 dns_builder_add_uint8 (builder, 1);
106 dns_builder_add_uint8 (builder, 'f');
107 dns_builder_add_uint8 (builder, 0xc0 | offset);
108 }
109
110 static void
111 dns_builder_add_answer_data (GByteArray *builder,
112 GByteArray *answer)
113 {
114 dns_builder_add_uint16 (builder, answer->len); /* rdlength */
115 g_byte_array_append (builder, answer->data, answer->len);
116 }
117
118 static GByteArray *
119 dns_header (void)
120 {
121 GByteArray *answer = g_byte_array_sized_new (2046);
122
123 /* Start with a header, we ignore everything except ancount.
124 https://datatracker.ietf.org/doc/html/rfc1035#section-4.1.1 */
125 dns_builder_add_uint16 (answer, 0); /* ID */
126 dns_builder_add_uint16 (answer, 0); /* |QR| Opcode |AA|TC|RD|RA| Z | RCODE | */
127 dns_builder_add_uint16 (answer, 0); /* QDCOUNT */
128 dns_builder_add_uint16 (answer, 1); /* ANCOUNT (1 answer) */
129 dns_builder_add_uint16 (answer, 0); /* NSCOUNT */
130 dns_builder_add_uint16 (answer, 0); /* ARCOUNT */
131
132 return g_steal_pointer (&answer);
133 }
134
135 static void
136 assert_query_fails (const gchar *rrname,
137 GResolverRecordType record_type,
138 GByteArray *answer)
139 {
140 GList *records = NULL;
141 GError *local_error = NULL;
142
143 records = g_resolver_records_from_res_query (rrname,
144 g_resolver_record_type_to_rrtype (record_type),
145 answer->data,
146 answer->len,
147 0,
148 &local_error);
149
150 g_assert_error (local_error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_INTERNAL);
151 g_assert_null (records);
152 g_clear_error (&local_error);
153 }
154
155 static void
156 assert_query_succeeds (const gchar *rrname,
157 GResolverRecordType record_type,
158 GByteArray *answer,
159 const gchar *expected_answer_variant_str)
160 {
161 GList *records = NULL;
162 GVariant *answer_variant, *expected_answer_variant = NULL;
163 GError *local_error = NULL;
164
165 records = g_resolver_records_from_res_query (rrname,
166 g_resolver_record_type_to_rrtype (record_type),
167 answer->data,
168 answer->len,
169 0,
170 &local_error);
171
172 g_assert_no_error (local_error);
173 g_assert_nonnull (records);
174
175 /* Test the results. */
176 answer_variant = records->data;
177 expected_answer_variant = g_variant_new_parsed (expected_answer_variant_str);
178 g_assert_cmpvariant (answer_variant, expected_answer_variant);
179
180 g_variant_unref (expected_answer_variant);
181 g_list_free_full (records, (GDestroyNotify) g_variant_unref);
182 }
183 #endif /* HAVE_DN_COMP */
184
185 static void
186 test_invalid_header (void)
187 {
188 const struct
189 {
190 const guint8 *answer;
191 gsize answer_len;
192 GResolverError expected_error_code;
193 }
194 vectors[] =
195 {
196 /* No answer: */
197 { (const guint8 *) "", 0, G_RESOLVER_ERROR_NOT_FOUND },
198 /* Definitely too short to be a valid header: */
199 { (const guint8 *) "\x20", 1, G_RESOLVER_ERROR_INTERNAL },
200 /* One byte too short to be a valid header: */
201 { (const guint8 *) "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 11, G_RESOLVER_ERROR_INTERNAL },
202 /* Valid header indicating no answers: */
203 { (const guint8 *) "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00", 12, G_RESOLVER_ERROR_NOT_FOUND },
204 };
205 gsize i;
206
207 for (i = 0; i < G_N_ELEMENTS (vectors); i++)
208 {
209 GList *records = NULL;
210 GError *local_error = NULL;
211
212 records = g_resolver_records_from_res_query ("example.org",
213 g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_NS),
214 vectors[i].answer,
215 vectors[i].answer_len,
216 0,
217 &local_error);
218
219 g_assert_error (local_error, G_RESOLVER_ERROR, (gint) vectors[i].expected_error_code);
220 g_assert_null (records);
221 g_clear_error (&local_error);
222 }
223 }
224
225 static void
226 test_unknown_record_type (void)
227 {
228 #ifndef HAVE_DN_COMP
229 g_test_skip ("The dn_comp() function was not available.");
230 return;
231 #else
232 GByteArray *answer = NULL;
233 GList *records = NULL;
234 GError *local_error = NULL;
235 const guint type_id = 20; /* ISDN, not supported anywhere */
236
237 /* An answer with an unsupported type chosen from
238 * https://en.wikipedia.org/wiki/List_of_DNS_record_types#[1]_Obsolete_record_types */
239 answer = dns_header ();
240 dns_builder_add_domain (answer, "example.org");
241 dns_builder_add_uint16 (answer, type_id);
242 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
243 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
244 dns_builder_add_uint16 (answer, 0); /* rdlength */
245
246 records = g_resolver_records_from_res_query ("example.org",
247 type_id,
248 answer->data,
249 answer->len,
250 0,
251 &local_error);
252
253 g_assert_error (local_error, G_RESOLVER_ERROR, G_RESOLVER_ERROR_NOT_FOUND);
254 g_assert_null (records);
255 g_clear_error (&local_error);
256
257 g_byte_array_free (answer, TRUE);
258 #endif
259 }
260
261 static void
262 test_mx_valid (void)
263 {
264 #ifndef HAVE_DN_COMP
265 g_test_skip ("The dn_comp() function was not available.");
266 return;
267 #else
268 GByteArray *answer = NULL, *mx_rdata = NULL;
269
270 answer = dns_header ();
271
272 /* Resource record */
273 dns_builder_add_domain (answer, "example.org");
274 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_MX));
275 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
276 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
277
278 /* MX rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.9 */
279 mx_rdata = g_byte_array_new ();
280 dns_builder_add_uint16 (mx_rdata, 0); /* preference */
281 dns_builder_add_domain (mx_rdata, "mail.example.org");
282 dns_builder_add_answer_data (answer, mx_rdata);
283 g_byte_array_unref (mx_rdata);
284
285 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_MX, answer,
286 "(@q 0, 'mail.example.org')");
287
288 g_byte_array_free (answer, TRUE);
289 #endif
290 }
291
292 static void
293 test_mx_invalid (void)
294 {
295 #ifndef HAVE_DN_COMP
296 g_test_skip ("The dn_comp() function was not available.");
297 return;
298 #else
299 GByteArray *answer = NULL, *mx_rdata = NULL;
300
301 answer = dns_header ();
302
303 /* Resource record */
304 dns_builder_add_domain (answer, "example.org");
305 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_MX));
306 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
307 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
308
309 /* MX rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.9
310 *
311 * Use an invalid domain to trigger parsing failure. */
312 mx_rdata = g_byte_array_new ();
313 dns_builder_add_uint16 (mx_rdata, 0); /* preference */
314 dns_builder_add_invalid_domain (mx_rdata, answer->len + 2);
315 dns_builder_add_answer_data (answer, mx_rdata);
316 g_byte_array_unref (mx_rdata);
317
318 assert_query_fails ("example.org", G_RESOLVER_RECORD_MX, answer);
319
320 g_byte_array_free (answer, TRUE);
321 #endif
322 }
323
324 static void
325 test_mx_invalid_too_short (void)
326 {
327 #ifndef HAVE_DN_COMP
328 g_test_skip ("The dn_comp() function was not available.");
329 return;
330 #else
331 GByteArray *answer = NULL, *mx_rdata = NULL;
332
333 answer = dns_header ();
334
335 /* Resource record */
336 dns_builder_add_domain (answer, "example.org");
337 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_MX));
338 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
339 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
340
341 /* MX rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.9
342 *
343 * Miss out the domain field to trigger failure */
344 mx_rdata = g_byte_array_new ();
345 dns_builder_add_uint16 (mx_rdata, 0); /* preference */
346 /* missing domain field */
347 dns_builder_add_answer_data (answer, mx_rdata);
348 g_byte_array_unref (mx_rdata);
349
350 assert_query_fails ("example.org", G_RESOLVER_RECORD_MX, answer);
351
352 g_byte_array_free (answer, TRUE);
353 #endif
354 }
355
356 static void
357 test_mx_invalid_too_short2 (void)
358 {
359 #ifndef HAVE_DN_COMP
360 g_test_skip ("The dn_comp() function was not available.");
361 return;
362 #else
363 GByteArray *answer = NULL, *mx_rdata = NULL;
364
365 answer = dns_header ();
366
367 /* Resource record */
368 dns_builder_add_domain (answer, "example.org");
369 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_MX));
370 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
371 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
372
373 /* MX rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.9
374 *
375 * Miss out all fields to trigger failure */
376 mx_rdata = g_byte_array_new ();
377 /* missing preference and domain fields */
378 dns_builder_add_answer_data (answer, mx_rdata);
379 g_byte_array_unref (mx_rdata);
380
381 assert_query_fails ("example.org", G_RESOLVER_RECORD_MX, answer);
382
383 g_byte_array_free (answer, TRUE);
384 #endif
385 }
386
387 static void
388 test_ns_valid (void)
389 {
390 #ifndef HAVE_DN_COMP
391 g_test_skip ("The dn_comp() function was not available.");
392 return;
393 #else
394 GByteArray *answer = NULL, *ns_rdata = NULL;
395
396 answer = dns_header ();
397
398 /* Resource record */
399 dns_builder_add_domain (answer, "example.org");
400 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_NS));
401 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
402 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
403
404 /* NS rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.11 */
405 ns_rdata = g_byte_array_new ();
406 dns_builder_add_domain (ns_rdata, "ns.example.org");
407 dns_builder_add_answer_data (answer, ns_rdata);
408 g_byte_array_unref (ns_rdata);
409
410 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_NS, answer,
411 "('ns.example.org',)");
412
413 g_byte_array_free (answer, TRUE);
414 #endif
415 }
416
417 static void
418 test_ns_invalid (void)
419 {
420 #ifndef HAVE_DN_COMP
421 g_test_skip ("The dn_comp() function was not available.");
422 return;
423 #else
424 GByteArray *answer = NULL, *ns_rdata = NULL;
425
426 answer = dns_header ();
427
428 /* Resource record */
429 dns_builder_add_domain (answer, "example.org");
430 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_NS));
431 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
432 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
433
434 /* NS rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.11
435 *
436 * Use an invalid domain to trigger parsing failure. */
437 ns_rdata = g_byte_array_new ();
438 dns_builder_add_invalid_domain (ns_rdata, answer->len + 2);
439 dns_builder_add_answer_data (answer, ns_rdata);
440 g_byte_array_unref (ns_rdata);
441
442 assert_query_fails ("example.org", G_RESOLVER_RECORD_NS, answer);
443
444 g_byte_array_free (answer, TRUE);
445 #endif
446 }
447
448 static void
449 test_soa_valid (void)
450 {
451 #ifndef HAVE_DN_COMP
452 g_test_skip ("The dn_comp() function was not available.");
453 return;
454 #else
455 GByteArray *answer = NULL, *soa_rdata = NULL;
456
457 answer = dns_header ();
458
459 /* Resource record */
460 dns_builder_add_domain (answer, "example.org");
461 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SOA));
462 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
463 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
464
465 /* SOA rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.13 */
466 soa_rdata = g_byte_array_new ();
467 dns_builder_add_domain (soa_rdata, "mname.example.org");
468 dns_builder_add_domain (soa_rdata, "rname.example.org");
469 dns_builder_add_uint32 (soa_rdata, 0); /* serial */
470 dns_builder_add_uint32 (soa_rdata, 0); /* refresh */
471 dns_builder_add_uint32 (soa_rdata, 0); /* retry */
472 dns_builder_add_uint32 (soa_rdata, 0); /* expire */
473 dns_builder_add_uint32 (soa_rdata, 0); /* minimum */
474 dns_builder_add_answer_data (answer, soa_rdata);
475 g_byte_array_unref (soa_rdata);
476
477 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_SOA, answer,
478 "('mname.example.org', 'rname.example.org', @u 0, @u 0, @u 0, @u 0, @u 0)");
479
480 g_byte_array_free (answer, TRUE);
481 #endif
482 }
483
484 static void
485 test_soa_invalid_mname (void)
486 {
487 #ifndef HAVE_DN_COMP
488 g_test_skip ("The dn_comp() function was not available.");
489 return;
490 #else
491 GByteArray *answer = NULL, *soa_rdata = NULL;
492
493 answer = dns_header ();
494
495 /* Resource record */
496 dns_builder_add_domain (answer, "example.org");
497 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SOA));
498 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
499 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
500
501 /* SOA rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.13
502 *
503 * Use an invalid domain to trigger parsing failure. */
504 soa_rdata = g_byte_array_new ();
505 dns_builder_add_invalid_domain (soa_rdata, answer->len + 2); /* mname */
506 dns_builder_add_domain (soa_rdata, "rname.example.org");
507 dns_builder_add_uint32 (soa_rdata, 0); /* serial */
508 dns_builder_add_uint32 (soa_rdata, 0); /* refresh */
509 dns_builder_add_uint32 (soa_rdata, 0); /* retry */
510 dns_builder_add_uint32 (soa_rdata, 0); /* expire */
511 dns_builder_add_uint32 (soa_rdata, 0); /* minimum */
512 dns_builder_add_answer_data (answer, soa_rdata);
513 g_byte_array_unref (soa_rdata);
514
515 assert_query_fails ("example.org", G_RESOLVER_RECORD_SOA, answer);
516
517 g_byte_array_free (answer, TRUE);
518 #endif
519 }
520
521 static void
522 test_soa_invalid_rname (void)
523 {
524 #ifndef HAVE_DN_COMP
525 g_test_skip ("The dn_comp() function was not available.");
526 return;
527 #else
528 GByteArray *answer = NULL, *soa_rdata = NULL;
529
530 answer = dns_header ();
531
532 /* Resource record */
533 dns_builder_add_domain (answer, "example.org");
534 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SOA));
535 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
536 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
537
538 /* SOA rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.13
539 *
540 * Use an invalid domain to trigger parsing failure. */
541 soa_rdata = g_byte_array_new ();
542 dns_builder_add_domain (soa_rdata, "mname.example.org");
543 dns_builder_add_invalid_domain (soa_rdata, answer->len + 2); /* rname */
544 dns_builder_add_uint32 (soa_rdata, 0); /* serial */
545 dns_builder_add_uint32 (soa_rdata, 0); /* refresh */
546 dns_builder_add_uint32 (soa_rdata, 0); /* retry */
547 dns_builder_add_uint32 (soa_rdata, 0); /* expire */
548 dns_builder_add_uint32 (soa_rdata, 0); /* minimum */
549 dns_builder_add_answer_data (answer, soa_rdata);
550 g_byte_array_unref (soa_rdata);
551
552 assert_query_fails ("example.org", G_RESOLVER_RECORD_SOA, answer);
553
554 g_byte_array_free (answer, TRUE);
555 #endif
556 }
557
558 static void
559 test_soa_invalid_too_short (void)
560 {
561 #ifndef HAVE_DN_COMP
562 g_test_skip ("The dn_comp() function was not available.");
563 return;
564 #else
565 GByteArray *answer = NULL, *soa_rdata = NULL;
566
567 answer = dns_header ();
568
569 /* Resource record */
570 dns_builder_add_domain (answer, "example.org");
571 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SOA));
572 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
573 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
574
575 /* SOA rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.13
576 *
577 * Miss out one of the fields to trigger a failure. */
578 soa_rdata = g_byte_array_new ();
579 dns_builder_add_domain (soa_rdata, "mname.example.org");
580 dns_builder_add_domain (soa_rdata, "rname.example.org");
581 dns_builder_add_uint32 (soa_rdata, 0); /* serial */
582 dns_builder_add_uint32 (soa_rdata, 0); /* refresh */
583 dns_builder_add_uint32 (soa_rdata, 0); /* retry */
584 dns_builder_add_uint32 (soa_rdata, 0); /* expire */
585 /* missing minimum field */
586 dns_builder_add_answer_data (answer, soa_rdata);
587 g_byte_array_unref (soa_rdata);
588
589 assert_query_fails ("example.org", G_RESOLVER_RECORD_SOA, answer);
590
591 g_byte_array_free (answer, TRUE);
592 #endif
593 }
594
595 static void
596 test_txt_valid (void)
597 {
598 #ifndef HAVE_DN_COMP
599 g_test_skip ("The dn_comp() function was not available.");
600 return;
601 #else
602 GByteArray *answer = NULL, *txt_rdata = NULL;
603
604 answer = dns_header ();
605
606 /* Resource record */
607 dns_builder_add_domain (answer, "example.org");
608 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_TXT));
609 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
610 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
611
612 /* TXT rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.14 */
613 txt_rdata = g_byte_array_new ();
614 dns_builder_add_length_prefixed_string (txt_rdata, "some test content");
615 dns_builder_add_answer_data (answer, txt_rdata);
616 g_byte_array_unref (txt_rdata);
617
618 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_TXT, answer,
619 "(['some test content'],)");
620
621 g_byte_array_free (answer, TRUE);
622 #endif
623 }
624
625 static void
626 test_txt_valid_multiple_strings (void)
627 {
628 #ifndef HAVE_DN_COMP
629 g_test_skip ("The dn_comp() function was not available.");
630 return;
631 #else
632 GByteArray *answer = NULL, *txt_rdata = NULL;
633
634 answer = dns_header ();
635
636 /* Resource record */
637 dns_builder_add_domain (answer, "example.org");
638 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_TXT));
639 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
640 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
641
642 /* TXT rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.14 */
643 txt_rdata = g_byte_array_new ();
644 dns_builder_add_length_prefixed_string (txt_rdata, "some test content");
645 dns_builder_add_length_prefixed_string (txt_rdata, "more test content");
646 dns_builder_add_answer_data (answer, txt_rdata);
647 g_byte_array_unref (txt_rdata);
648
649 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_TXT, answer,
650 "(['some test content', 'more test content'],)");
651
652 g_byte_array_free (answer, TRUE);
653 #endif
654 }
655
656 static void
657 test_txt_invalid_empty (void)
658 {
659 #ifndef HAVE_DN_COMP
660 g_test_skip ("The dn_comp() function was not available.");
661 return;
662 #else
663 GByteArray *answer = NULL, *txt_rdata = NULL;
664
665 answer = dns_header ();
666
667 /* Resource record */
668 dns_builder_add_domain (answer, "example.org");
669 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_TXT));
670 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
671 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
672
673 /* TXT rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.14
674 *
675 * Provide zero character strings (i.e. an empty rdata section) to trigger
676 * failure. */
677 txt_rdata = g_byte_array_new ();
678 dns_builder_add_answer_data (answer, txt_rdata);
679 g_byte_array_unref (txt_rdata);
680
681 assert_query_fails ("example.org", G_RESOLVER_RECORD_TXT, answer);
682
683 g_byte_array_free (answer, TRUE);
684 #endif
685 }
686
687 static void
688 test_txt_invalid_overflow (void)
689 {
690 #ifndef HAVE_DN_COMP
691 g_test_skip ("The dn_comp() function was not available.");
692 return;
693 #else
694 GByteArray *answer = NULL, *txt_rdata = NULL;
695
696 answer = dns_header ();
697
698 /* Resource record */
699 dns_builder_add_domain (answer, "example.org");
700 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_TXT));
701 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
702 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
703
704 /* TXT rdata, https://datatracker.ietf.org/doc/html/rfc1035#section-3.3.14
705 *
706 * Use a character string whose length exceeds the remaining length in the
707 * answer record, to trigger failure. */
708 txt_rdata = g_byte_array_new ();
709 dns_builder_add_uint8 (txt_rdata, 10); /* length, but no content */
710 dns_builder_add_answer_data (answer, txt_rdata);
711 g_byte_array_unref (txt_rdata);
712
713 assert_query_fails ("example.org", G_RESOLVER_RECORD_TXT, answer);
714
715 g_byte_array_free (answer, TRUE);
716 #endif
717 }
718
719 static void
720 test_srv_valid (void)
721 {
722 #ifndef HAVE_DN_COMP
723 g_test_skip ("The dn_comp() function was not available.");
724 return;
725 #else
726 GByteArray *answer = NULL, *srv_rdata = NULL;
727
728 answer = dns_header ();
729
730 /* Resource record */
731 dns_builder_add_domain (answer, "example.org");
732 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SRV));
733 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
734 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
735
736 /* SRV rdata, https://datatracker.ietf.org/doc/html/rfc2782 */
737 srv_rdata = g_byte_array_new ();
738 dns_builder_add_uint16 (srv_rdata, 0); /* priority */
739 dns_builder_add_uint16 (srv_rdata, 0); /* weight */
740 dns_builder_add_uint16 (srv_rdata, 0); /* port */
741 dns_builder_add_domain (srv_rdata, "target.example.org");
742 dns_builder_add_answer_data (answer, srv_rdata);
743 g_byte_array_unref (srv_rdata);
744
745 assert_query_succeeds ("example.org", G_RESOLVER_RECORD_SRV, answer,
746 "(@q 0, @q 0, @q 0, 'target.example.org')");
747
748 g_byte_array_free (answer, TRUE);
749 #endif
750 }
751
752 static void
753 test_srv_invalid (void)
754 {
755 #ifndef HAVE_DN_COMP
756 g_test_skip ("The dn_comp() function was not available.");
757 return;
758 #else
759 GByteArray *answer = NULL, *srv_rdata = NULL;
760
761 answer = dns_header ();
762
763 /* Resource record */
764 dns_builder_add_domain (answer, "example.org");
765 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SRV));
766 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
767 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
768
769 /* SRV rdata, https://datatracker.ietf.org/doc/html/rfc2782
770 *
771 * Use an invalid domain to trigger parsing failure. */
772 srv_rdata = g_byte_array_new ();
773 dns_builder_add_uint16 (srv_rdata, 0); /* priority */
774 dns_builder_add_uint16 (srv_rdata, 0); /* weight */
775 dns_builder_add_uint16 (srv_rdata, 0); /* port */
776 dns_builder_add_invalid_domain (srv_rdata, answer->len + 2);
777 dns_builder_add_answer_data (answer, srv_rdata);
778 g_byte_array_unref (srv_rdata);
779
780 assert_query_fails ("example.org", G_RESOLVER_RECORD_SRV, answer);
781
782 g_byte_array_free (answer, TRUE);
783 #endif
784 }
785
786 static void
787 test_srv_invalid_too_short (void)
788 {
789 #ifndef HAVE_DN_COMP
790 g_test_skip ("The dn_comp() function was not available.");
791 return;
792 #else
793 GByteArray *answer = NULL, *srv_rdata = NULL;
794
795 answer = dns_header ();
796
797 /* Resource record */
798 dns_builder_add_domain (answer, "example.org");
799 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SRV));
800 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
801 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
802
803 /* SRV rdata, https://datatracker.ietf.org/doc/html/rfc2782
804 *
805 * Miss out the target field to trigger failure */
806 srv_rdata = g_byte_array_new ();
807 dns_builder_add_uint16 (srv_rdata, 0); /* priority */
808 dns_builder_add_uint16 (srv_rdata, 0); /* weight */
809 dns_builder_add_uint16 (srv_rdata, 0); /* port */
810 /* missing target field */
811 dns_builder_add_answer_data (answer, srv_rdata);
812 g_byte_array_unref (srv_rdata);
813
814 assert_query_fails ("example.org", G_RESOLVER_RECORD_SRV, answer);
815
816 g_byte_array_free (answer, TRUE);
817 #endif
818 }
819
820 static void
821 test_srv_invalid_too_short2 (void)
822 {
823 #ifndef HAVE_DN_COMP
824 g_test_skip ("The dn_comp() function was not available.");
825 return;
826 #else
827 GByteArray *answer = NULL, *srv_rdata = NULL;
828
829 answer = dns_header ();
830
831 /* Resource record */
832 dns_builder_add_domain (answer, "example.org");
833 dns_builder_add_uint16 (answer, g_resolver_record_type_to_rrtype (G_RESOLVER_RECORD_SRV));
834 dns_builder_add_uint16 (answer, 1); /* qclass=C_IN */
835 dns_builder_add_uint32 (answer, 0); /* ttl (ignored) */
836
837 /* SRV rdata, https://datatracker.ietf.org/doc/html/rfc2782
838 *
839 * Miss out the target and port fields to trigger failure */
840 srv_rdata = g_byte_array_new ();
841 dns_builder_add_uint16 (srv_rdata, 0); /* priority */
842 dns_builder_add_uint16 (srv_rdata, 0); /* weight */
843 /* missing port and target fields */
844 dns_builder_add_answer_data (answer, srv_rdata);
845 g_byte_array_unref (srv_rdata);
846
847 assert_query_fails ("example.org", G_RESOLVER_RECORD_SRV, answer);
848
849 g_byte_array_free (answer, TRUE);
850 #endif
851 }
852
853 int
854 main (int argc,
855 char *argv[])
856 {
857 g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
858
859 g_test_add_func ("/gresolver/invalid-header", test_invalid_header);
860 g_test_add_func ("/gresolver/unknown-record-type", test_unknown_record_type);
861 g_test_add_func ("/gresolver/mx/valid", test_mx_valid);
862 g_test_add_func ("/gresolver/mx/invalid", test_mx_invalid);
863 g_test_add_func ("/gresolver/mx/invalid/too-short", test_mx_invalid_too_short);
864 g_test_add_func ("/gresolver/mx/invalid/too-short2", test_mx_invalid_too_short2);
865 g_test_add_func ("/gresolver/ns/valid", test_ns_valid);
866 g_test_add_func ("/gresolver/ns/invalid", test_ns_invalid);
867 g_test_add_func ("/gresolver/soa/valid", test_soa_valid);
868 g_test_add_func ("/gresolver/soa/invalid/mname", test_soa_invalid_mname);
869 g_test_add_func ("/gresolver/soa/invalid/rname", test_soa_invalid_rname);
870 g_test_add_func ("/gresolver/soa/invalid/too-short", test_soa_invalid_too_short);
871 g_test_add_func ("/gresolver/srv/valid", test_srv_valid);
872 g_test_add_func ("/gresolver/srv/invalid", test_srv_invalid);
873 g_test_add_func ("/gresolver/srv/invalid/too-short", test_srv_invalid_too_short);
874 g_test_add_func ("/gresolver/srv/invalid/too-short2", test_srv_invalid_too_short2);
875 g_test_add_func ("/gresolver/txt/valid", test_txt_valid);
876 g_test_add_func ("/gresolver/txt/valid/multiple-strings", test_txt_valid_multiple_strings);
877 g_test_add_func ("/gresolver/txt/invalid/empty", test_txt_invalid_empty);
878 g_test_add_func ("/gresolver/txt/invalid/overflow", test_txt_invalid_overflow);
879
880 return g_test_run ();
881 }