]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/resolve/resolved-dns-packet.c
projects / thirdparty / systemd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge pull request #30284 from YHNdnzj/fstab-wantedby-defaultdeps
[thirdparty/systemd.git] / src / resolve / resolved-dns-packet.c
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #if HAVE_GCRYPT
4 # include <gcrypt.h>
5 #endif
6
7 #include "alloc-util.h"
8 #include "dns-domain.h"
9 #include "memory-util.h"
10 #include "resolved-dns-packet.h"
11 #include "set.h"
12 #include "stdio-util.h"
13 #include "string-table.h"
14 #include "strv.h"
15 #include "unaligned.h"
16 #include "utf8.h"
17
18 #define EDNS0_OPT_DO (1<<15)
19
20 assert_cc(DNS_PACKET_SIZE_START > DNS_PACKET_HEADER_SIZE);
21
22 typedef struct DnsPacketRewinder {
23 DnsPacket *packet;
24 size_t saved_rindex;
25 } DnsPacketRewinder;
26
27 static void rewind_dns_packet(DnsPacketRewinder *rewinder) {
28 if (rewinder->packet)
29 dns_packet_rewind(rewinder->packet, rewinder->saved_rindex);
30 }
31
32 #define REWINDER_INIT(p) { \
33 .packet = (p), \
34 .saved_rindex = (p)->rindex, \
35 }
36 #define CANCEL_REWINDER(rewinder) do { (rewinder).packet = NULL; } while (0)
37
38 int dns_packet_new(
39 DnsPacket **ret,
40 DnsProtocol protocol,
41 size_t min_alloc_dsize,
42 size_t max_size) {
43
44 DnsPacket *p;
45 size_t a;
46
47 assert(ret);
48 assert(max_size >= DNS_PACKET_HEADER_SIZE);
49
50 if (max_size > DNS_PACKET_SIZE_MAX)
51 max_size = DNS_PACKET_SIZE_MAX;
52
53 /* The caller may not check what is going to be truly allocated, so do not allow to
54 * allocate a DNS packet bigger than DNS_PACKET_SIZE_MAX.
55 */
56 if (min_alloc_dsize > DNS_PACKET_SIZE_MAX)
57 return log_error_errno(SYNTHETIC_ERRNO(EFBIG),
58 "Requested packet data size too big: %zu",
59 min_alloc_dsize);
60
61 /* When dns_packet_new() is called with min_alloc_dsize == 0, allocate more than the
62 * absolute minimum (which is the dns packet header size), to avoid
63 * resizing immediately again after appending the first data to the packet.
64 */
65 if (min_alloc_dsize < DNS_PACKET_HEADER_SIZE)
66 a = DNS_PACKET_SIZE_START;
67 else
68 a = min_alloc_dsize;
69
70 /* round up to next page size */
71 a = PAGE_ALIGN(ALIGN(sizeof(DnsPacket)) + a) - ALIGN(sizeof(DnsPacket));
72
73 /* make sure we never allocate more than useful */
74 if (a > max_size)
75 a = max_size;
76
77 p = malloc0(ALIGN(sizeof(DnsPacket)) + a);
78 if (!p)
79 return -ENOMEM;
80
81 *p = (DnsPacket) {
82 .n_ref = 1,
83 .protocol = protocol,
84 .size = DNS_PACKET_HEADER_SIZE,
85 .rindex = DNS_PACKET_HEADER_SIZE,
86 .allocated = a,
87 .max_size = max_size,
88 .opt_start = SIZE_MAX,
89 .opt_size = SIZE_MAX,
90 };
91
92 *ret = p;
93
94 return 0;
95 }
96
97 void dns_packet_set_flags(DnsPacket *p, bool dnssec_checking_disabled, bool truncated) {
98
99 DnsPacketHeader *h;
100
101 assert(p);
102
103 h = DNS_PACKET_HEADER(p);
104
105 switch (p->protocol) {
106 case DNS_PROTOCOL_LLMNR:
107 assert(!truncated);
108
109 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
110 0 /* opcode */,
111 0 /* c */,
112 0 /* tc */,
113 0 /* t */,
114 0 /* ra */,
115 0 /* ad */,
116 0 /* cd */,
117 0 /* rcode */));
118 break;
119
120 case DNS_PROTOCOL_MDNS:
121 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
122 0 /* opcode */,
123 0 /* aa */,
124 truncated /* tc */,
125 0 /* rd (ask for recursion) */,
126 0 /* ra */,
127 0 /* ad */,
128 0 /* cd */,
129 0 /* rcode */));
130 break;
131
132 default:
133 assert(!truncated);
134
135 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
136 0 /* opcode */,
137 0 /* aa */,
138 0 /* tc */,
139 1 /* rd (ask for recursion) */,
140 0 /* ra */,
141 0 /* ad */,
142 dnssec_checking_disabled /* cd */,
143 0 /* rcode */));
144 }
145 }
146
147 int dns_packet_new_query(DnsPacket **ret, DnsProtocol protocol, size_t min_alloc_dsize, bool dnssec_checking_disabled) {
148 DnsPacket *p;
149 int r;
150
151 assert(ret);
152
153 r = dns_packet_new(&p, protocol, min_alloc_dsize, DNS_PACKET_SIZE_MAX);
154 if (r < 0)
155 return r;
156
157 /* Always set the TC bit to 0 initially.
158 * If there are multiple packets later, we'll update the bit shortly before sending.
159 */
160 dns_packet_set_flags(p, dnssec_checking_disabled, false);
161
162 *ret = p;
163 return 0;
164 }
165
166 int dns_packet_dup(DnsPacket **ret, DnsPacket *p) {
167 DnsPacket *c;
168 int r;
169
170 assert(ret);
171 assert(p);
172
173 r = dns_packet_validate(p);
174 if (r < 0)
175 return r;
176
177 c = malloc(ALIGN(sizeof(DnsPacket)) + p->size);
178 if (!c)
179 return -ENOMEM;
180
181 *c = (DnsPacket) {
182 .n_ref = 1,
183 .protocol = p->protocol,
184 .size = p->size,
185 .rindex = DNS_PACKET_HEADER_SIZE,
186 .allocated = p->size,
187 .max_size = p->max_size,
188 .opt_start = SIZE_MAX,
189 .opt_size = SIZE_MAX,
190 };
191
192 memcpy(DNS_PACKET_DATA(c), DNS_PACKET_DATA(p), p->size);
193
194 *ret = c;
195 return 0;
196 }
197
198 DnsPacket *dns_packet_ref(DnsPacket *p) {
199
200 if (!p)
201 return NULL;
202
203 assert(!p->on_stack);
204
205 assert(p->n_ref > 0);
206 p->n_ref++;
207 return p;
208 }
209
210 static void dns_packet_free(DnsPacket *p) {
211 char *s;
212
213 assert(p);
214
215 dns_question_unref(p->question);
216 dns_answer_unref(p->answer);
217 dns_resource_record_unref(p->opt);
218
219 while ((s = hashmap_steal_first_key(p->names)))
220 free(s);
221 hashmap_free(p->names);
222
223 free(p->_data);
224
225 if (!p->on_stack)
226 free(p);
227 }
228
229 DnsPacket *dns_packet_unref(DnsPacket *p) {
230 if (!p)
231 return NULL;
232
233 assert(p->n_ref > 0);
234
235 dns_packet_unref(p->more);
236
237 if (p->n_ref == 1)
238 dns_packet_free(p);
239 else
240 p->n_ref--;
241
242 return NULL;
243 }
244
245 int dns_packet_validate(DnsPacket *p) {
246 assert(p);
247
248 if (p->size < DNS_PACKET_HEADER_SIZE)
249 return -EBADMSG;
250
251 if (p->size > DNS_PACKET_SIZE_MAX)
252 return -EBADMSG;
253
254 return 1;
255 }
256
257 int dns_packet_validate_reply(DnsPacket *p) {
258 int r;
259
260 assert(p);
261
262 r = dns_packet_validate(p);
263 if (r < 0)
264 return r;
265
266 if (DNS_PACKET_QR(p) != 1)
267 return 0;
268
269 if (DNS_PACKET_OPCODE(p) != 0)
270 return -EBADMSG;
271
272 switch (p->protocol) {
273
274 case DNS_PROTOCOL_LLMNR:
275 /* RFC 4795, Section 2.1.1. says to discard all replies with QDCOUNT != 1 */
276 if (DNS_PACKET_QDCOUNT(p) != 1)
277 return -EBADMSG;
278
279 break;
280
281 case DNS_PROTOCOL_MDNS:
282 /* RFC 6762, Section 18 */
283 if (DNS_PACKET_RCODE(p) != 0)
284 return -EBADMSG;
285
286 break;
287
288 default:
289 break;
290 }
291
292 return 1;
293 }
294
295 int dns_packet_validate_query(DnsPacket *p) {
296 int r;
297
298 assert(p);
299
300 r = dns_packet_validate(p);
301 if (r < 0)
302 return r;
303
304 if (DNS_PACKET_QR(p) != 0)
305 return 0;
306
307 if (DNS_PACKET_OPCODE(p) != 0)
308 return -EBADMSG;
309
310 switch (p->protocol) {
311
312 case DNS_PROTOCOL_LLMNR:
313 case DNS_PROTOCOL_DNS:
314 if (DNS_PACKET_TC(p)) /* mDNS query may have truncation flag. */
315 return -EBADMSG;
316
317 /* RFC 4795, Section 2.1.1. says to discard all queries with QDCOUNT != 1 */
318 if (DNS_PACKET_QDCOUNT(p) != 1)
319 return -EBADMSG;
320
321 /* RFC 4795, Section 2.1.1. says to discard all queries with ANCOUNT != 0 */
322 if (DNS_PACKET_ANCOUNT(p) > 0)
323 return -EBADMSG;
324
325 /* RFC 4795, Section 2.1.1. says to discard all queries with NSCOUNT != 0 */
326 if (DNS_PACKET_NSCOUNT(p) > 0)
327 return -EBADMSG;
328
329 break;
330
331 case DNS_PROTOCOL_MDNS:
332 /* RFC 6762, Section 18 specifies that messages with non-zero RCODE
333 * must be silently ignored, and that we must ignore the values of
334 * AA, RD, RA, AD, and CD bits. */
335 if (DNS_PACKET_RCODE(p) != 0)
336 return -EBADMSG;
337
338 break;
339
340 default:
341 break;
342 }
343
344 return 1;
345 }
346
347 static int dns_packet_extend(DnsPacket *p, size_t add, void **ret, size_t *start) {
348 assert(p);
349
350 if (p->size + add > p->allocated) {
351 size_t a, ms;
352
353 a = PAGE_ALIGN((p->size + add) * 2);
354
355 ms = dns_packet_size_max(p);
356 if (a > ms)
357 a = ms;
358
359 if (p->size + add > a)
360 return -EMSGSIZE;
361
362 if (p->_data) {
363 void *d;
364
365 d = realloc(p->_data, a);
366 if (!d)
367 return -ENOMEM;
368
369 p->_data = d;
370 } else {
371 p->_data = malloc(a);
372 if (!p->_data)
373 return -ENOMEM;
374
375 memcpy(p->_data, (uint8_t*) p + ALIGN(sizeof(DnsPacket)), p->size);
376 memzero((uint8_t*) p->_data + p->size, a - p->size);
377 }
378
379 p->allocated = a;
380 }
381
382 if (start)
383 *start = p->size;
384
385 if (ret)
386 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->size;
387
388 p->size += add;
389 return 0;
390 }
391
392 void dns_packet_truncate(DnsPacket *p, size_t sz) {
393 char *s;
394 void *n;
395
396 assert(p);
397
398 if (p->size <= sz)
399 return;
400
401 HASHMAP_FOREACH_KEY(n, s, p->names) {
402
403 if (PTR_TO_SIZE(n) < sz)
404 continue;
405
406 hashmap_remove(p->names, s);
407 free(s);
408 }
409
410 p->size = sz;
411 }
412
413 int dns_packet_append_blob(DnsPacket *p, const void *d, size_t l, size_t *start) {
414 void *q;
415 int r;
416
417 assert(p);
418
419 r = dns_packet_extend(p, l, &q, start);
420 if (r < 0)
421 return r;
422
423 memcpy_safe(q, d, l);
424 return 0;
425 }
426
427 int dns_packet_append_uint8(DnsPacket *p, uint8_t v, size_t *start) {
428 void *d;
429 int r;
430
431 assert(p);
432
433 r = dns_packet_extend(p, sizeof(uint8_t), &d, start);
434 if (r < 0)
435 return r;
436
437 ((uint8_t*) d)[0] = v;
438
439 return 0;
440 }
441
442 int dns_packet_append_uint16(DnsPacket *p, uint16_t v, size_t *start) {
443 void *d;
444 int r;
445
446 assert(p);
447
448 r = dns_packet_extend(p, sizeof(uint16_t), &d, start);
449 if (r < 0)
450 return r;
451
452 unaligned_write_be16(d, v);
453
454 return 0;
455 }
456
457 int dns_packet_append_uint32(DnsPacket *p, uint32_t v, size_t *start) {
458 void *d;
459 int r;
460
461 assert(p);
462
463 r = dns_packet_extend(p, sizeof(uint32_t), &d, start);
464 if (r < 0)
465 return r;
466
467 unaligned_write_be32(d, v);
468
469 return 0;
470 }
471
472 int dns_packet_append_string(DnsPacket *p, const char *s, size_t *start) {
473 assert(p);
474 assert(s);
475
476 return dns_packet_append_raw_string(p, s, strlen(s), start);
477 }
478
479 int dns_packet_append_raw_string(DnsPacket *p, const void *s, size_t size, size_t *start) {
480 void *d;
481 int r;
482
483 assert(p);
484 assert(s || size == 0);
485
486 if (size > 255)
487 return -E2BIG;
488
489 r = dns_packet_extend(p, 1 + size, &d, start);
490 if (r < 0)
491 return r;
492
493 ((uint8_t*) d)[0] = (uint8_t) size;
494
495 memcpy_safe(((uint8_t*) d) + 1, s, size);
496
497 return 0;
498 }
499
500 int dns_packet_append_label(DnsPacket *p, const char *d, size_t l, bool canonical_candidate, size_t *start) {
501 uint8_t *w;
502 int r;
503
504 /* Append a label to a packet. Optionally, does this in DNSSEC
505 * canonical form, if this label is marked as a candidate for
506 * it, and the canonical form logic is enabled for the
507 * packet */
508
509 assert(p);
510 assert(d);
511
512 if (l > DNS_LABEL_MAX)
513 return -E2BIG;
514
515 r = dns_packet_extend(p, 1 + l, (void**) &w, start);
516 if (r < 0)
517 return r;
518
519 *(w++) = (uint8_t) l;
520
521 if (p->canonical_form && canonical_candidate)
522 /* Generate in canonical form, as defined by DNSSEC
523 * RFC 4034, Section 6.2, i.e. all lower-case. */
524 for (size_t i = 0; i < l; i++)
525 w[i] = (uint8_t) ascii_tolower(d[i]);
526 else
527 /* Otherwise, just copy the string unaltered. This is
528 * essential for DNS-SD, where the casing of labels
529 * matters and needs to be retained. */
530 memcpy(w, d, l);
531
532 return 0;
533 }
534
535 int dns_packet_append_name(
536 DnsPacket *p,
537 const char *name,
538 bool allow_compression,
539 bool canonical_candidate,
540 size_t *start) {
541
542 size_t saved_size;
543 int r;
544
545 assert(p);
546 assert(name);
547
548 if (p->refuse_compression)
549 allow_compression = false;
550
551 saved_size = p->size;
552
553 while (!dns_name_is_root(name)) {
554 const char *z = name;
555 char label[DNS_LABEL_MAX+1];
556 size_t n = 0;
557
558 if (allow_compression)
559 n = PTR_TO_SIZE(hashmap_get(p->names, name));
560 if (n > 0) {
561 assert(n < p->size);
562
563 if (n < 0x4000) {
564 r = dns_packet_append_uint16(p, 0xC000 | n, NULL);
565 if (r < 0)
566 goto fail;
567
568 goto done;
569 }
570 }
571
572 r = dns_label_unescape(&name, label, sizeof label, 0);
573 if (r < 0)
574 goto fail;
575
576 r = dns_packet_append_label(p, label, r, canonical_candidate, &n);
577 if (r < 0)
578 goto fail;
579
580 if (allow_compression) {
581 _cleanup_free_ char *s = NULL;
582
583 s = strdup(z);
584 if (!s) {
585 r = -ENOMEM;
586 goto fail;
587 }
588
589 r = hashmap_ensure_put(&p->names, &dns_name_hash_ops, s, SIZE_TO_PTR(n));
590 if (r < 0)
591 goto fail;
592
593 TAKE_PTR(s);
594 }
595 }
596
597 r = dns_packet_append_uint8(p, 0, NULL);
598 if (r < 0)
599 return r;
600
601 done:
602 if (start)
603 *start = saved_size;
604
605 return 0;
606
607 fail:
608 dns_packet_truncate(p, saved_size);
609 return r;
610 }
611
612 int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *k, const DnsAnswerFlags flags, size_t *start) {
613 size_t saved_size;
614 uint16_t class;
615 int r;
616
617 assert(p);
618 assert(k);
619
620 saved_size = p->size;
621
622 r = dns_packet_append_name(p, dns_resource_key_name(k), true, true, NULL);
623 if (r < 0)
624 goto fail;
625
626 r = dns_packet_append_uint16(p, k->type, NULL);
627 if (r < 0)
628 goto fail;
629
630 class = flags & DNS_ANSWER_CACHE_FLUSH ? k->class | MDNS_RR_CACHE_FLUSH_OR_QU : k->class;
631 r = dns_packet_append_uint16(p, class, NULL);
632 if (r < 0)
633 goto fail;
634
635 if (start)
636 *start = saved_size;
637
638 return 0;
639
640 fail:
641 dns_packet_truncate(p, saved_size);
642 return r;
643 }
644
645 static int dns_packet_append_type_window(DnsPacket *p, uint8_t window, uint8_t length, const uint8_t *types, size_t *start) {
646 size_t saved_size;
647 int r;
648
649 assert(p);
650 assert(types);
651 assert(length > 0);
652
653 saved_size = p->size;
654
655 r = dns_packet_append_uint8(p, window, NULL);
656 if (r < 0)
657 goto fail;
658
659 r = dns_packet_append_uint8(p, length, NULL);
660 if (r < 0)
661 goto fail;
662
663 r = dns_packet_append_blob(p, types, length, NULL);
664 if (r < 0)
665 goto fail;
666
667 if (start)
668 *start = saved_size;
669
670 return 0;
671 fail:
672 dns_packet_truncate(p, saved_size);
673 return r;
674 }
675
676 static int dns_packet_append_types(DnsPacket *p, Bitmap *types, size_t *start) {
677 uint8_t window = 0;
678 uint8_t entry = 0;
679 uint8_t bitmaps[32] = {};
680 unsigned n;
681 size_t saved_size;
682 int r;
683
684 assert(p);
685
686 saved_size = p->size;
687
688 BITMAP_FOREACH(n, types) {
689 assert(n <= 0xffff);
690
691 if ((n >> 8) != window && bitmaps[entry / 8] != 0) {
692 r = dns_packet_append_type_window(p, window, entry / 8 + 1, bitmaps, NULL);
693 if (r < 0)
694 goto fail;
695
696 zero(bitmaps);
697 }
698
699 window = n >> 8;
700 entry = n & 255;
701
702 bitmaps[entry / 8] |= 1 << (7 - (entry % 8));
703 }
704
705 if (bitmaps[entry / 8] != 0) {
706 r = dns_packet_append_type_window(p, window, entry / 8 + 1, bitmaps, NULL);
707 if (r < 0)
708 goto fail;
709 }
710
711 if (start)
712 *start = saved_size;
713
714 return 0;
715 fail:
716 dns_packet_truncate(p, saved_size);
717 return r;
718 }
719
720 /* Append the OPT pseudo-RR described in RFC6891 */
721 int dns_packet_append_opt(
722 DnsPacket *p,
723 uint16_t max_udp_size,
724 bool edns0_do,
725 bool include_rfc6975,
726 const char *nsid,
727 int rcode,
728 size_t *ret_start) {
729
730 size_t saved_size;
731 int r;
732
733 assert(p);
734 /* we must never advertise supported packet size smaller than the legacy max */
735 assert(max_udp_size >= DNS_PACKET_UNICAST_SIZE_MAX);
736 assert(rcode >= 0);
737 assert(rcode <= _DNS_RCODE_MAX);
738
739 if (p->opt_start != SIZE_MAX)
740 return -EBUSY;
741
742 assert(p->opt_size == SIZE_MAX);
743
744 saved_size = p->size;
745
746 /* empty name */
747 r = dns_packet_append_uint8(p, 0, NULL);
748 if (r < 0)
749 return r;
750
751 /* type */
752 r = dns_packet_append_uint16(p, DNS_TYPE_OPT, NULL);
753 if (r < 0)
754 goto fail;
755
756 /* class: maximum udp packet that can be received */
757 r = dns_packet_append_uint16(p, max_udp_size, NULL);
758 if (r < 0)
759 goto fail;
760
761 /* extended RCODE and VERSION */
762 r = dns_packet_append_uint16(p, ((uint16_t) rcode & 0x0FF0) << 4, NULL);
763 if (r < 0)
764 goto fail;
765
766 /* flags: DNSSEC OK (DO), see RFC3225 */
767 r = dns_packet_append_uint16(p, edns0_do ? EDNS0_OPT_DO : 0, NULL);
768 if (r < 0)
769 goto fail;
770
771 if (edns0_do && include_rfc6975) {
772 /* If DO is on and this is requested, also append RFC6975 Algorithm data. This is supposed to
773 * be done on queries, not on replies, hencer callers should turn this off when finishing off
774 * replies. */
775
776 static const uint8_t rfc6975[] = {
777
778 0, 5, /* OPTION_CODE: DAU */
779 #if PREFER_OPENSSL || (HAVE_GCRYPT && GCRYPT_VERSION_NUMBER >= 0x010600)
780 0, 7, /* LIST_LENGTH */
781 #else
782 0, 6, /* LIST_LENGTH */
783 #endif
784 DNSSEC_ALGORITHM_RSASHA1,
785 DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1,
786 DNSSEC_ALGORITHM_RSASHA256,
787 DNSSEC_ALGORITHM_RSASHA512,
788 DNSSEC_ALGORITHM_ECDSAP256SHA256,
789 DNSSEC_ALGORITHM_ECDSAP384SHA384,
790 #if PREFER_OPENSSL || (HAVE_GCRYPT && GCRYPT_VERSION_NUMBER >= 0x010600)
791 DNSSEC_ALGORITHM_ED25519,
792 #endif
793
794 0, 6, /* OPTION_CODE: DHU */
795 0, 3, /* LIST_LENGTH */
796 DNSSEC_DIGEST_SHA1,
797 DNSSEC_DIGEST_SHA256,
798 DNSSEC_DIGEST_SHA384,
799
800 0, 7, /* OPTION_CODE: N3U */
801 0, 1, /* LIST_LENGTH */
802 NSEC3_ALGORITHM_SHA1,
803 };
804
805 r = dns_packet_append_uint16(p, sizeof(rfc6975), NULL); /* RDLENGTH */
806 if (r < 0)
807 goto fail;
808
809 r = dns_packet_append_blob(p, rfc6975, sizeof(rfc6975), NULL); /* the payload, as defined above */
810
811 } else if (nsid) {
812
813 if (strlen(nsid) > UINT16_MAX - 4) {
814 r = -E2BIG;
815 goto fail;
816 }
817
818 r = dns_packet_append_uint16(p, 4 + strlen(nsid), NULL); /* RDLENGTH */
819 if (r < 0)
820 goto fail;
821
822 r = dns_packet_append_uint16(p, 3, NULL); /* OPTION-CODE: NSID */
823 if (r < 0)
824 goto fail;
825
826 r = dns_packet_append_uint16(p, strlen(nsid), NULL); /* OPTION-LENGTH */
827 if (r < 0)
828 goto fail;
829
830 r = dns_packet_append_blob(p, nsid, strlen(nsid), NULL);
831 } else
832 r = dns_packet_append_uint16(p, 0, NULL);
833 if (r < 0)
834 goto fail;
835
836 DNS_PACKET_HEADER(p)->arcount = htobe16(DNS_PACKET_ARCOUNT(p) + 1);
837
838 p->opt_start = saved_size;
839 p->opt_size = p->size - saved_size;
840
841 if (ret_start)
842 *ret_start = saved_size;
843
844 return 0;
845
846 fail:
847 dns_packet_truncate(p, saved_size);
848 return r;
849 }
850
851 int dns_packet_truncate_opt(DnsPacket *p) {
852 assert(p);
853
854 if (p->opt_start == SIZE_MAX) {
855 assert(p->opt_size == SIZE_MAX);
856 return 0;
857 }
858
859 assert(p->opt_size != SIZE_MAX);
860 assert(DNS_PACKET_ARCOUNT(p) > 0);
861
862 if (p->opt_start + p->opt_size != p->size)
863 return -EBUSY;
864
865 dns_packet_truncate(p, p->opt_start);
866 DNS_PACKET_HEADER(p)->arcount = htobe16(DNS_PACKET_ARCOUNT(p) - 1);
867 p->opt_start = p->opt_size = SIZE_MAX;
868
869 return 1;
870 }
871
872 int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, const DnsAnswerFlags flags, size_t *start, size_t *rdata_start) {
873
874 size_t saved_size, rdlength_offset, end, rdlength, rds;
875 uint32_t ttl;
876 int r;
877
878 assert(p);
879 assert(rr);
880
881 saved_size = p->size;
882
883 r = dns_packet_append_key(p, rr->key, flags, NULL);
884 if (r < 0)
885 goto fail;
886
887 ttl = flags & DNS_ANSWER_GOODBYE ? 0 : rr->ttl;
888 r = dns_packet_append_uint32(p, ttl, NULL);
889 if (r < 0)
890 goto fail;
891
892 /* Initially we write 0 here */
893 r = dns_packet_append_uint16(p, 0, &rdlength_offset);
894 if (r < 0)
895 goto fail;
896
897 rds = p->size - saved_size;
898
899 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
900
901 case DNS_TYPE_SRV:
902 r = dns_packet_append_uint16(p, rr->srv.priority, NULL);
903 if (r < 0)
904 goto fail;
905
906 r = dns_packet_append_uint16(p, rr->srv.weight, NULL);
907 if (r < 0)
908 goto fail;
909
910 r = dns_packet_append_uint16(p, rr->srv.port, NULL);
911 if (r < 0)
912 goto fail;
913
914 /* RFC 2782 states "Unless and until permitted by future standards action, name compression
915 * is not to be used for this field." Hence we turn off compression here. */
916 r = dns_packet_append_name(p, rr->srv.name, /* allow_compression= */ false, /* canonical_candidate= */ true, NULL);
917 break;
918
919 case DNS_TYPE_PTR:
920 case DNS_TYPE_NS:
921 case DNS_TYPE_CNAME:
922 case DNS_TYPE_DNAME:
923 r = dns_packet_append_name(p, rr->ptr.name, true, true, NULL);
924 break;
925
926 case DNS_TYPE_HINFO:
927 r = dns_packet_append_string(p, rr->hinfo.cpu, NULL);
928 if (r < 0)
929 goto fail;
930
931 r = dns_packet_append_string(p, rr->hinfo.os, NULL);
932 break;
933
934 case DNS_TYPE_SPF: /* exactly the same as TXT */
935 case DNS_TYPE_TXT:
936
937 if (!rr->txt.items) {
938 /* RFC 6763, section 6.1 suggests to generate
939 * single empty string for an empty array. */
940
941 r = dns_packet_append_raw_string(p, NULL, 0, NULL);
942 if (r < 0)
943 goto fail;
944 } else
945 LIST_FOREACH(items, i, rr->txt.items) {
946 r = dns_packet_append_raw_string(p, i->data, i->length, NULL);
947 if (r < 0)
948 goto fail;
949 }
950
951 r = 0;
952 break;
953
954 case DNS_TYPE_A:
955 r = dns_packet_append_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
956 break;
957
958 case DNS_TYPE_AAAA:
959 r = dns_packet_append_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
960 break;
961
962 case DNS_TYPE_SOA:
963 r = dns_packet_append_name(p, rr->soa.mname, true, true, NULL);
964 if (r < 0)
965 goto fail;
966
967 r = dns_packet_append_name(p, rr->soa.rname, true, true, NULL);
968 if (r < 0)
969 goto fail;
970
971 r = dns_packet_append_uint32(p, rr->soa.serial, NULL);
972 if (r < 0)
973 goto fail;
974
975 r = dns_packet_append_uint32(p, rr->soa.refresh, NULL);
976 if (r < 0)
977 goto fail;
978
979 r = dns_packet_append_uint32(p, rr->soa.retry, NULL);
980 if (r < 0)
981 goto fail;
982
983 r = dns_packet_append_uint32(p, rr->soa.expire, NULL);
984 if (r < 0)
985 goto fail;
986
987 r = dns_packet_append_uint32(p, rr->soa.minimum, NULL);
988 break;
989
990 case DNS_TYPE_MX:
991 r = dns_packet_append_uint16(p, rr->mx.priority, NULL);
992 if (r < 0)
993 goto fail;
994
995 r = dns_packet_append_name(p, rr->mx.exchange, true, true, NULL);
996 break;
997
998 case DNS_TYPE_LOC:
999 r = dns_packet_append_uint8(p, rr->loc.version, NULL);
1000 if (r < 0)
1001 goto fail;
1002
1003 r = dns_packet_append_uint8(p, rr->loc.size, NULL);
1004 if (r < 0)
1005 goto fail;
1006
1007 r = dns_packet_append_uint8(p, rr->loc.horiz_pre, NULL);
1008 if (r < 0)
1009 goto fail;
1010
1011 r = dns_packet_append_uint8(p, rr->loc.vert_pre, NULL);
1012 if (r < 0)
1013 goto fail;
1014
1015 r = dns_packet_append_uint32(p, rr->loc.latitude, NULL);
1016 if (r < 0)
1017 goto fail;
1018
1019 r = dns_packet_append_uint32(p, rr->loc.longitude, NULL);
1020 if (r < 0)
1021 goto fail;
1022
1023 r = dns_packet_append_uint32(p, rr->loc.altitude, NULL);
1024 break;
1025
1026 case DNS_TYPE_DS:
1027 r = dns_packet_append_uint16(p, rr->ds.key_tag, NULL);
1028 if (r < 0)
1029 goto fail;
1030
1031 r = dns_packet_append_uint8(p, rr->ds.algorithm, NULL);
1032 if (r < 0)
1033 goto fail;
1034
1035 r = dns_packet_append_uint8(p, rr->ds.digest_type, NULL);
1036 if (r < 0)
1037 goto fail;
1038
1039 r = dns_packet_append_blob(p, rr->ds.digest, rr->ds.digest_size, NULL);
1040 break;
1041
1042 case DNS_TYPE_SSHFP:
1043 r = dns_packet_append_uint8(p, rr->sshfp.algorithm, NULL);
1044 if (r < 0)
1045 goto fail;
1046
1047 r = dns_packet_append_uint8(p, rr->sshfp.fptype, NULL);
1048 if (r < 0)
1049 goto fail;
1050
1051 r = dns_packet_append_blob(p, rr->sshfp.fingerprint, rr->sshfp.fingerprint_size, NULL);
1052 break;
1053
1054 case DNS_TYPE_DNSKEY:
1055 r = dns_packet_append_uint16(p, rr->dnskey.flags, NULL);
1056 if (r < 0)
1057 goto fail;
1058
1059 r = dns_packet_append_uint8(p, rr->dnskey.protocol, NULL);
1060 if (r < 0)
1061 goto fail;
1062
1063 r = dns_packet_append_uint8(p, rr->dnskey.algorithm, NULL);
1064 if (r < 0)
1065 goto fail;
1066
1067 r = dns_packet_append_blob(p, rr->dnskey.key, rr->dnskey.key_size, NULL);
1068 break;
1069
1070 case DNS_TYPE_RRSIG:
1071 r = dns_packet_append_uint16(p, rr->rrsig.type_covered, NULL);
1072 if (r < 0)
1073 goto fail;
1074
1075 r = dns_packet_append_uint8(p, rr->rrsig.algorithm, NULL);
1076 if (r < 0)
1077 goto fail;
1078
1079 r = dns_packet_append_uint8(p, rr->rrsig.labels, NULL);
1080 if (r < 0)
1081 goto fail;
1082
1083 r = dns_packet_append_uint32(p, rr->rrsig.original_ttl, NULL);
1084 if (r < 0)
1085 goto fail;
1086
1087 r = dns_packet_append_uint32(p, rr->rrsig.expiration, NULL);
1088 if (r < 0)
1089 goto fail;
1090
1091 r = dns_packet_append_uint32(p, rr->rrsig.inception, NULL);
1092 if (r < 0)
1093 goto fail;
1094
1095 r = dns_packet_append_uint16(p, rr->rrsig.key_tag, NULL);
1096 if (r < 0)
1097 goto fail;
1098
1099 r = dns_packet_append_name(p, rr->rrsig.signer, false, true, NULL);
1100 if (r < 0)
1101 goto fail;
1102
1103 r = dns_packet_append_blob(p, rr->rrsig.signature, rr->rrsig.signature_size, NULL);
1104 break;
1105
1106 case DNS_TYPE_NSEC:
1107 r = dns_packet_append_name(p, rr->nsec.next_domain_name, false, false, NULL);
1108 if (r < 0)
1109 goto fail;
1110
1111 r = dns_packet_append_types(p, rr->nsec.types, NULL);
1112 if (r < 0)
1113 goto fail;
1114
1115 break;
1116
1117 case DNS_TYPE_NSEC3:
1118 r = dns_packet_append_uint8(p, rr->nsec3.algorithm, NULL);
1119 if (r < 0)
1120 goto fail;
1121
1122 r = dns_packet_append_uint8(p, rr->nsec3.flags, NULL);
1123 if (r < 0)
1124 goto fail;
1125
1126 r = dns_packet_append_uint16(p, rr->nsec3.iterations, NULL);
1127 if (r < 0)
1128 goto fail;
1129
1130 r = dns_packet_append_uint8(p, rr->nsec3.salt_size, NULL);
1131 if (r < 0)
1132 goto fail;
1133
1134 r = dns_packet_append_blob(p, rr->nsec3.salt, rr->nsec3.salt_size, NULL);
1135 if (r < 0)
1136 goto fail;
1137
1138 r = dns_packet_append_uint8(p, rr->nsec3.next_hashed_name_size, NULL);
1139 if (r < 0)
1140 goto fail;
1141
1142 r = dns_packet_append_blob(p, rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size, NULL);
1143 if (r < 0)
1144 goto fail;
1145
1146 r = dns_packet_append_types(p, rr->nsec3.types, NULL);
1147 if (r < 0)
1148 goto fail;
1149
1150 break;
1151
1152 case DNS_TYPE_TLSA:
1153 r = dns_packet_append_uint8(p, rr->tlsa.cert_usage, NULL);
1154 if (r < 0)
1155 goto fail;
1156
1157 r = dns_packet_append_uint8(p, rr->tlsa.selector, NULL);
1158 if (r < 0)
1159 goto fail;
1160
1161 r = dns_packet_append_uint8(p, rr->tlsa.matching_type, NULL);
1162 if (r < 0)
1163 goto fail;
1164
1165 r = dns_packet_append_blob(p, rr->tlsa.data, rr->tlsa.data_size, NULL);
1166 break;
1167
1168 case DNS_TYPE_CAA:
1169 r = dns_packet_append_uint8(p, rr->caa.flags, NULL);
1170 if (r < 0)
1171 goto fail;
1172
1173 r = dns_packet_append_string(p, rr->caa.tag, NULL);
1174 if (r < 0)
1175 goto fail;
1176
1177 r = dns_packet_append_blob(p, rr->caa.value, rr->caa.value_size, NULL);
1178 break;
1179
1180 case DNS_TYPE_OPT:
1181 case DNS_TYPE_OPENPGPKEY:
1182 case _DNS_TYPE_INVALID: /* unparsable */
1183 default:
1184
1185 r = dns_packet_append_blob(p, rr->generic.data, rr->generic.data_size, NULL);
1186 break;
1187 }
1188 if (r < 0)
1189 goto fail;
1190
1191 /* Let's calculate the actual data size and update the field */
1192 rdlength = p->size - rdlength_offset - sizeof(uint16_t);
1193 if (rdlength > 0xFFFF) {
1194 r = -ENOSPC;
1195 goto fail;
1196 }
1197
1198 end = p->size;
1199 p->size = rdlength_offset;
1200 r = dns_packet_append_uint16(p, rdlength, NULL);
1201 if (r < 0)
1202 goto fail;
1203 p->size = end;
1204
1205 if (start)
1206 *start = saved_size;
1207
1208 if (rdata_start)
1209 *rdata_start = rds;
1210
1211 return 0;
1212
1213 fail:
1214 dns_packet_truncate(p, saved_size);
1215 return r;
1216 }
1217
1218 int dns_packet_append_question(DnsPacket *p, DnsQuestion *q) {
1219 DnsResourceKey *key;
1220 int r;
1221
1222 assert(p);
1223
1224 DNS_QUESTION_FOREACH(key, q) {
1225 r = dns_packet_append_key(p, key, 0, NULL);
1226 if (r < 0)
1227 return r;
1228 }
1229
1230 return 0;
1231 }
1232
1233 int dns_packet_append_answer(DnsPacket *p, DnsAnswer *a, unsigned *completed) {
1234 DnsResourceRecord *rr;
1235 DnsAnswerFlags flags;
1236 int r;
1237
1238 assert(p);
1239
1240 DNS_ANSWER_FOREACH_FLAGS(rr, flags, a) {
1241 r = dns_packet_append_rr(p, rr, flags, NULL, NULL);
1242 if (r < 0)
1243 return r;
1244
1245 if (completed)
1246 (*completed)++;
1247 }
1248
1249 return 0;
1250 }
1251
1252 int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start) {
1253 assert(p);
1254 assert(p->rindex <= p->size);
1255
1256 if (sz > p->size - p->rindex)
1257 return -EMSGSIZE;
1258
1259 if (ret)
1260 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->rindex;
1261
1262 if (start)
1263 *start = p->rindex;
1264
1265 p->rindex += sz;
1266 return 0;
1267 }
1268
1269 void dns_packet_rewind(DnsPacket *p, size_t idx) {
1270 assert(p);
1271 assert(idx <= p->size);
1272 assert(idx >= DNS_PACKET_HEADER_SIZE);
1273
1274 p->rindex = idx;
1275 }
1276
1277 int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start) {
1278 const void *q;
1279 int r;
1280
1281 assert(p);
1282 assert(d);
1283
1284 r = dns_packet_read(p, sz, &q, start);
1285 if (r < 0)
1286 return r;
1287
1288 memcpy(d, q, sz);
1289 return 0;
1290 }
1291
1292 static int dns_packet_read_memdup(
1293 DnsPacket *p, size_t size,
1294 void **ret, size_t *ret_size,
1295 size_t *ret_start) {
1296
1297 const void *src;
1298 size_t start;
1299 int r;
1300
1301 assert(p);
1302 assert(ret);
1303
1304 r = dns_packet_read(p, size, &src, &start);
1305 if (r < 0)
1306 return r;
1307
1308 if (size <= 0)
1309 *ret = NULL;
1310 else {
1311 void *copy;
1312
1313 copy = memdup(src, size);
1314 if (!copy)
1315 return -ENOMEM;
1316
1317 *ret = copy;
1318 }
1319
1320 if (ret_size)
1321 *ret_size = size;
1322 if (ret_start)
1323 *ret_start = start;
1324
1325 return 0;
1326 }
1327
1328 int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start) {
1329 const void *d;
1330 int r;
1331
1332 assert(p);
1333
1334 r = dns_packet_read(p, sizeof(uint8_t), &d, start);
1335 if (r < 0)
1336 return r;
1337
1338 *ret = ((uint8_t*) d)[0];
1339 return 0;
1340 }
1341
1342 int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start) {
1343 const void *d;
1344 int r;
1345
1346 assert(p);
1347
1348 r = dns_packet_read(p, sizeof(uint16_t), &d, start);
1349 if (r < 0)
1350 return r;
1351
1352 if (ret)
1353 *ret = unaligned_read_be16(d);
1354
1355 return 0;
1356 }
1357
1358 int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start) {
1359 const void *d;
1360 int r;
1361
1362 assert(p);
1363
1364 r = dns_packet_read(p, sizeof(uint32_t), &d, start);
1365 if (r < 0)
1366 return r;
1367
1368 *ret = unaligned_read_be32(d);
1369
1370 return 0;
1371 }
1372
1373 int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start) {
1374 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1375 _cleanup_free_ char *t = NULL;
1376 const void *d;
1377 uint8_t c;
1378 int r;
1379
1380 assert(p);
1381
1382 r = dns_packet_read_uint8(p, &c, NULL);
1383 if (r < 0)
1384 return r;
1385
1386 r = dns_packet_read(p, c, &d, NULL);
1387 if (r < 0)
1388 return r;
1389
1390 r = make_cstring(d, c, MAKE_CSTRING_REFUSE_TRAILING_NUL, &t);
1391 if (r < 0)
1392 return r;
1393
1394 if (!utf8_is_valid(t))
1395 return -EBADMSG;
1396
1397 *ret = TAKE_PTR(t);
1398
1399 if (start)
1400 *start = rewinder.saved_rindex;
1401 CANCEL_REWINDER(rewinder);
1402
1403 return 0;
1404 }
1405
1406 int dns_packet_read_raw_string(DnsPacket *p, const void **ret, size_t *size, size_t *start) {
1407 assert(p);
1408
1409 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1410 uint8_t c;
1411 int r;
1412
1413 r = dns_packet_read_uint8(p, &c, NULL);
1414 if (r < 0)
1415 return r;
1416
1417 r = dns_packet_read(p, c, ret, NULL);
1418 if (r < 0)
1419 return r;
1420
1421 if (size)
1422 *size = c;
1423 if (start)
1424 *start = rewinder.saved_rindex;
1425 CANCEL_REWINDER(rewinder);
1426
1427 return 0;
1428 }
1429
1430 int dns_packet_read_name(
1431 DnsPacket *p,
1432 char **ret,
1433 bool allow_compression,
1434 size_t *ret_start) {
1435
1436 assert(p);
1437
1438 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1439 size_t after_rindex = 0, jump_barrier = p->rindex;
1440 _cleanup_free_ char *name = NULL;
1441 bool first = true;
1442 size_t n = 0;
1443 int r;
1444
1445 if (p->refuse_compression)
1446 allow_compression = false;
1447
1448 for (;;) {
1449 uint8_t c, d;
1450
1451 r = dns_packet_read_uint8(p, &c, NULL);
1452 if (r < 0)
1453 return r;
1454
1455 if (c == 0)
1456 /* End of name */
1457 break;
1458 else if (c <= 63) {
1459 const char *label;
1460
1461 /* Literal label */
1462 r = dns_packet_read(p, c, (const void**) &label, NULL);
1463 if (r < 0)
1464 return r;
1465
1466 if (!GREEDY_REALLOC(name, n + !first + DNS_LABEL_ESCAPED_MAX))
1467 return -ENOMEM;
1468
1469 if (first)
1470 first = false;
1471 else
1472 name[n++] = '.';
1473
1474 r = dns_label_escape(label, c, name + n, DNS_LABEL_ESCAPED_MAX);
1475 if (r < 0)
1476 return r;
1477
1478 n += r;
1479 continue;
1480 } else if (allow_compression && FLAGS_SET(c, 0xc0)) {
1481 uint16_t ptr;
1482
1483 /* Pointer */
1484 r = dns_packet_read_uint8(p, &d, NULL);
1485 if (r < 0)
1486 return r;
1487
1488 ptr = (uint16_t) (c & ~0xc0) << 8 | (uint16_t) d;
1489 if (ptr < DNS_PACKET_HEADER_SIZE || ptr >= jump_barrier)
1490 return -EBADMSG;
1491
1492 if (after_rindex == 0)
1493 after_rindex = p->rindex;
1494
1495 /* Jumps are limited to a "prior occurrence" (RFC-1035 4.1.4) */
1496 jump_barrier = ptr;
1497 p->rindex = ptr;
1498 } else
1499 return -EBADMSG;
1500 }
1501
1502 if (!GREEDY_REALLOC(name, n + 1))
1503 return -ENOMEM;
1504
1505 name[n] = 0;
1506
1507 if (after_rindex != 0)
1508 p->rindex= after_rindex;
1509
1510 if (ret)
1511 *ret = TAKE_PTR(name);
1512 if (ret_start)
1513 *ret_start = rewinder.saved_rindex;
1514
1515 CANCEL_REWINDER(rewinder);
1516
1517 return 0;
1518 }
1519
1520 static int dns_packet_read_type_window(DnsPacket *p, Bitmap **types, size_t *start) {
1521 assert(p);
1522 assert(types);
1523
1524 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1525 uint8_t window, length;
1526 const uint8_t *bitmap;
1527 uint8_t bit = 0;
1528 bool found = false;
1529 int r;
1530
1531 r = bitmap_ensure_allocated(types);
1532 if (r < 0)
1533 return r;
1534
1535 r = dns_packet_read_uint8(p, &window, NULL);
1536 if (r < 0)
1537 return r;
1538
1539 r = dns_packet_read_uint8(p, &length, NULL);
1540 if (r < 0)
1541 return r;
1542
1543 if (length == 0 || length > 32)
1544 return -EBADMSG;
1545
1546 r = dns_packet_read(p, length, (const void **)&bitmap, NULL);
1547 if (r < 0)
1548 return r;
1549
1550 for (uint8_t i = 0; i < length; i++) {
1551 uint8_t bitmask = 1 << 7;
1552
1553 if (!bitmap[i]) {
1554 found = false;
1555 bit += 8;
1556 continue;
1557 }
1558
1559 found = true;
1560
1561 for (; bitmask; bit++, bitmask >>= 1)
1562 if (bitmap[i] & bitmask) {
1563 uint16_t n;
1564
1565 n = (uint16_t) window << 8 | (uint16_t) bit;
1566
1567 /* Ignore pseudo-types. see RFC4034 section 4.1.2 */
1568 if (dns_type_is_pseudo(n))
1569 continue;
1570
1571 r = bitmap_set(*types, n);
1572 if (r < 0)
1573 return r;
1574 }
1575 }
1576
1577 if (!found)
1578 return -EBADMSG;
1579
1580 if (start)
1581 *start = rewinder.saved_rindex;
1582 CANCEL_REWINDER(rewinder);
1583
1584 return 0;
1585 }
1586
1587 static int dns_packet_read_type_windows(DnsPacket *p, Bitmap **types, size_t size, size_t *start) {
1588 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1589 int r;
1590
1591 while (p->rindex - rewinder.saved_rindex < size) {
1592 r = dns_packet_read_type_window(p, types, NULL);
1593 if (r < 0)
1594 return r;
1595
1596 assert(p->rindex >= rewinder.saved_rindex);
1597
1598 /* don't read past end of current RR */
1599 if (p->rindex - rewinder.saved_rindex > size)
1600 return -EBADMSG;
1601 }
1602
1603 if (p->rindex - rewinder.saved_rindex != size)
1604 return -EBADMSG;
1605
1606 if (start)
1607 *start = rewinder.saved_rindex;
1608 CANCEL_REWINDER(rewinder);
1609
1610 return 0;
1611 }
1612
1613 int dns_packet_read_key(
1614 DnsPacket *p,
1615 DnsResourceKey **ret,
1616 bool *ret_cache_flush_or_qu,
1617 size_t *ret_start) {
1618
1619 assert(p);
1620
1621 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1622 _cleanup_free_ char *name = NULL;
1623 bool cache_flush_or_qu = false;
1624 uint16_t class, type;
1625 int r;
1626
1627 r = dns_packet_read_name(p, &name, true, NULL);
1628 if (r < 0)
1629 return r;
1630
1631 r = dns_packet_read_uint16(p, &type, NULL);
1632 if (r < 0)
1633 return r;
1634
1635 r = dns_packet_read_uint16(p, &class, NULL);
1636 if (r < 0)
1637 return r;
1638
1639 if (p->protocol == DNS_PROTOCOL_MDNS) {
1640 /* See RFC6762, sections 5.4 and 10.2 */
1641
1642 if (type != DNS_TYPE_OPT && (class & MDNS_RR_CACHE_FLUSH_OR_QU)) {
1643 class &= ~MDNS_RR_CACHE_FLUSH_OR_QU;
1644 cache_flush_or_qu = true;
1645 }
1646 }
1647
1648 if (ret) {
1649 DnsResourceKey *key;
1650
1651 key = dns_resource_key_new_consume(class, type, name);
1652 if (!key)
1653 return -ENOMEM;
1654
1655 TAKE_PTR(name);
1656 *ret = key;
1657 }
1658
1659 if (ret_cache_flush_or_qu)
1660 *ret_cache_flush_or_qu = cache_flush_or_qu;
1661 if (ret_start)
1662 *ret_start = rewinder.saved_rindex;
1663
1664 CANCEL_REWINDER(rewinder);
1665 return 0;
1666 }
1667
1668 static bool loc_size_ok(uint8_t size) {
1669 uint8_t m = size >> 4, e = size & 0xF;
1670
1671 return m <= 9 && e <= 9 && (m > 0 || e == 0);
1672 }
1673
1674 int dns_packet_read_rr(
1675 DnsPacket *p,
1676 DnsResourceRecord **ret,
1677 bool *ret_cache_flush,
1678 size_t *ret_start) {
1679
1680 assert(p);
1681
1682 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
1683 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1684 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1685 size_t offset;
1686 uint16_t rdlength;
1687 bool cache_flush;
1688 int r;
1689
1690 r = dns_packet_read_key(p, &key, &cache_flush, NULL);
1691 if (r < 0)
1692 return r;
1693
1694 if (!dns_class_is_valid_rr(key->class) || !dns_type_is_valid_rr(key->type))
1695 return -EBADMSG;
1696
1697 rr = dns_resource_record_new(key);
1698 if (!rr)
1699 return -ENOMEM;
1700
1701 r = dns_packet_read_uint32(p, &rr->ttl, NULL);
1702 if (r < 0)
1703 return r;
1704
1705 /* RFC 2181, Section 8, suggests to
1706 * treat a TTL with the MSB set as a zero TTL. */
1707 if (rr->ttl & UINT32_C(0x80000000))
1708 rr->ttl = 0;
1709
1710 r = dns_packet_read_uint16(p, &rdlength, NULL);
1711 if (r < 0)
1712 return r;
1713
1714 if (rdlength > p->size - p->rindex)
1715 return -EBADMSG;
1716
1717 offset = p->rindex;
1718
1719 switch (rr->key->type) {
1720
1721 case DNS_TYPE_SRV:
1722 r = dns_packet_read_uint16(p, &rr->srv.priority, NULL);
1723 if (r < 0)
1724 return r;
1725 r = dns_packet_read_uint16(p, &rr->srv.weight, NULL);
1726 if (r < 0)
1727 return r;
1728 r = dns_packet_read_uint16(p, &rr->srv.port, NULL);
1729 if (r < 0)
1730 return r;
1731
1732 /* RFC 2782 states "Unless and until permitted by future standards action, name compression
1733 * is not to be used for this field." Nonetheless, we support it here, in the interest of
1734 * increasing compatibility with implementations that do not implement this correctly. After
1735 * all we didn't do this right once upon a time ourselves (see
1736 * https://github.com/systemd/systemd/issues/9793). */
1737 r = dns_packet_read_name(p, &rr->srv.name, /* allow_compression= */ true, NULL);
1738 break;
1739
1740 case DNS_TYPE_PTR:
1741 case DNS_TYPE_NS:
1742 case DNS_TYPE_CNAME:
1743 case DNS_TYPE_DNAME:
1744 r = dns_packet_read_name(p, &rr->ptr.name, true, NULL);
1745 break;
1746
1747 case DNS_TYPE_HINFO:
1748 r = dns_packet_read_string(p, &rr->hinfo.cpu, NULL);
1749 if (r < 0)
1750 return r;
1751
1752 r = dns_packet_read_string(p, &rr->hinfo.os, NULL);
1753 break;
1754
1755 case DNS_TYPE_SPF: /* exactly the same as TXT */
1756 case DNS_TYPE_TXT:
1757 if (rdlength <= 0) {
1758 r = dns_txt_item_new_empty(&rr->txt.items);
1759 if (r < 0)
1760 return r;
1761 } else {
1762 DnsTxtItem *last = NULL;
1763
1764 while (p->rindex - offset < rdlength) {
1765 DnsTxtItem *i;
1766 const void *data;
1767 size_t sz;
1768
1769 r = dns_packet_read_raw_string(p, &data, &sz, NULL);
1770 if (r < 0)
1771 return r;
1772
1773 i = malloc0(offsetof(DnsTxtItem, data) + sz + 1); /* extra NUL byte at the end */
1774 if (!i)
1775 return -ENOMEM;
1776
1777 memcpy(i->data, data, sz);
1778 i->length = sz;
1779
1780 LIST_INSERT_AFTER(items, rr->txt.items, last, i);
1781 last = i;
1782 }
1783 }
1784
1785 r = 0;
1786 break;
1787
1788 case DNS_TYPE_A:
1789 r = dns_packet_read_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
1790 break;
1791
1792 case DNS_TYPE_AAAA:
1793 r = dns_packet_read_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
1794 break;
1795
1796 case DNS_TYPE_SOA:
1797 r = dns_packet_read_name(p, &rr->soa.mname, true, NULL);
1798 if (r < 0)
1799 return r;
1800
1801 r = dns_packet_read_name(p, &rr->soa.rname, true, NULL);
1802 if (r < 0)
1803 return r;
1804
1805 r = dns_packet_read_uint32(p, &rr->soa.serial, NULL);
1806 if (r < 0)
1807 return r;
1808
1809 r = dns_packet_read_uint32(p, &rr->soa.refresh, NULL);
1810 if (r < 0)
1811 return r;
1812
1813 r = dns_packet_read_uint32(p, &rr->soa.retry, NULL);
1814 if (r < 0)
1815 return r;
1816
1817 r = dns_packet_read_uint32(p, &rr->soa.expire, NULL);
1818 if (r < 0)
1819 return r;
1820
1821 r = dns_packet_read_uint32(p, &rr->soa.minimum, NULL);
1822 break;
1823
1824 case DNS_TYPE_MX:
1825 r = dns_packet_read_uint16(p, &rr->mx.priority, NULL);
1826 if (r < 0)
1827 return r;
1828
1829 r = dns_packet_read_name(p, &rr->mx.exchange, true, NULL);
1830 break;
1831
1832 case DNS_TYPE_LOC: {
1833 uint8_t t;
1834 size_t pos;
1835
1836 r = dns_packet_read_uint8(p, &t, &pos);
1837 if (r < 0)
1838 return r;
1839
1840 if (t == 0) {
1841 rr->loc.version = t;
1842
1843 r = dns_packet_read_uint8(p, &rr->loc.size, NULL);
1844 if (r < 0)
1845 return r;
1846
1847 if (!loc_size_ok(rr->loc.size))
1848 return -EBADMSG;
1849
1850 r = dns_packet_read_uint8(p, &rr->loc.horiz_pre, NULL);
1851 if (r < 0)
1852 return r;
1853
1854 if (!loc_size_ok(rr->loc.horiz_pre))
1855 return -EBADMSG;
1856
1857 r = dns_packet_read_uint8(p, &rr->loc.vert_pre, NULL);
1858 if (r < 0)
1859 return r;
1860
1861 if (!loc_size_ok(rr->loc.vert_pre))
1862 return -EBADMSG;
1863
1864 r = dns_packet_read_uint32(p, &rr->loc.latitude, NULL);
1865 if (r < 0)
1866 return r;
1867
1868 r = dns_packet_read_uint32(p, &rr->loc.longitude, NULL);
1869 if (r < 0)
1870 return r;
1871
1872 r = dns_packet_read_uint32(p, &rr->loc.altitude, NULL);
1873 if (r < 0)
1874 return r;
1875
1876 break;
1877 } else {
1878 dns_packet_rewind(p, pos);
1879 rr->unparsable = true;
1880 goto unparsable;
1881 }
1882 }
1883
1884 case DNS_TYPE_DS:
1885 r = dns_packet_read_uint16(p, &rr->ds.key_tag, NULL);
1886 if (r < 0)
1887 return r;
1888
1889 r = dns_packet_read_uint8(p, &rr->ds.algorithm, NULL);
1890 if (r < 0)
1891 return r;
1892
1893 r = dns_packet_read_uint8(p, &rr->ds.digest_type, NULL);
1894 if (r < 0)
1895 return r;
1896
1897 if (rdlength < 4)
1898 return -EBADMSG;
1899
1900 r = dns_packet_read_memdup(p, rdlength - 4,
1901 &rr->ds.digest, &rr->ds.digest_size,
1902 NULL);
1903 if (r < 0)
1904 return r;
1905
1906 if (rr->ds.digest_size <= 0)
1907 /* the accepted size depends on the algorithm, but for now
1908 just ensure that the value is greater than zero */
1909 return -EBADMSG;
1910
1911 break;
1912
1913 case DNS_TYPE_SSHFP:
1914 r = dns_packet_read_uint8(p, &rr->sshfp.algorithm, NULL);
1915 if (r < 0)
1916 return r;
1917
1918 r = dns_packet_read_uint8(p, &rr->sshfp.fptype, NULL);
1919 if (r < 0)
1920 return r;
1921
1922 if (rdlength < 2)
1923 return -EBADMSG;
1924
1925 r = dns_packet_read_memdup(p, rdlength - 2,
1926 &rr->sshfp.fingerprint, &rr->sshfp.fingerprint_size,
1927 NULL);
1928
1929 if (rr->sshfp.fingerprint_size <= 0)
1930 /* the accepted size depends on the algorithm, but for now
1931 just ensure that the value is greater than zero */
1932 return -EBADMSG;
1933
1934 break;
1935
1936 case DNS_TYPE_DNSKEY:
1937 r = dns_packet_read_uint16(p, &rr->dnskey.flags, NULL);
1938 if (r < 0)
1939 return r;
1940
1941 r = dns_packet_read_uint8(p, &rr->dnskey.protocol, NULL);
1942 if (r < 0)
1943 return r;
1944
1945 r = dns_packet_read_uint8(p, &rr->dnskey.algorithm, NULL);
1946 if (r < 0)
1947 return r;
1948
1949 if (rdlength < 4)
1950 return -EBADMSG;
1951
1952 r = dns_packet_read_memdup(p, rdlength - 4,
1953 &rr->dnskey.key, &rr->dnskey.key_size,
1954 NULL);
1955
1956 if (rr->dnskey.key_size <= 0)
1957 /* the accepted size depends on the algorithm, but for now
1958 just ensure that the value is greater than zero */
1959 return -EBADMSG;
1960
1961 break;
1962
1963 case DNS_TYPE_RRSIG:
1964 r = dns_packet_read_uint16(p, &rr->rrsig.type_covered, NULL);
1965 if (r < 0)
1966 return r;
1967
1968 r = dns_packet_read_uint8(p, &rr->rrsig.algorithm, NULL);
1969 if (r < 0)
1970 return r;
1971
1972 r = dns_packet_read_uint8(p, &rr->rrsig.labels, NULL);
1973 if (r < 0)
1974 return r;
1975
1976 r = dns_packet_read_uint32(p, &rr->rrsig.original_ttl, NULL);
1977 if (r < 0)
1978 return r;
1979
1980 r = dns_packet_read_uint32(p, &rr->rrsig.expiration, NULL);
1981 if (r < 0)
1982 return r;
1983
1984 r = dns_packet_read_uint32(p, &rr->rrsig.inception, NULL);
1985 if (r < 0)
1986 return r;
1987
1988 r = dns_packet_read_uint16(p, &rr->rrsig.key_tag, NULL);
1989 if (r < 0)
1990 return r;
1991
1992 r = dns_packet_read_name(p, &rr->rrsig.signer, false, NULL);
1993 if (r < 0)
1994 return r;
1995
1996 if (rdlength < p->rindex - offset)
1997 return -EBADMSG;
1998
1999 r = dns_packet_read_memdup(p, offset + rdlength - p->rindex,
2000 &rr->rrsig.signature, &rr->rrsig.signature_size,
2001 NULL);
2002
2003 if (rr->rrsig.signature_size <= 0)
2004 /* the accepted size depends on the algorithm, but for now
2005 just ensure that the value is greater than zero */
2006 return -EBADMSG;
2007
2008 break;
2009
2010 case DNS_TYPE_NSEC: {
2011
2012 /*
2013 * RFC6762, section 18.14 explicitly states mDNS should use name compression.
2014 * This contradicts RFC3845, section 2.1.1
2015 */
2016
2017 bool allow_compressed = p->protocol == DNS_PROTOCOL_MDNS;
2018
2019 r = dns_packet_read_name(p, &rr->nsec.next_domain_name, allow_compressed, NULL);
2020 if (r < 0)
2021 return r;
2022
2023 if (rdlength < p->rindex - offset)
2024 return -EBADMSG;
2025
2026 r = dns_packet_read_type_windows(p, &rr->nsec.types, offset + rdlength - p->rindex, NULL);
2027
2028 /* We accept empty NSEC bitmaps. The bit indicating the presence of the NSEC record itself
2029 * is redundant and in e.g., RFC4956 this fact is used to define a use for NSEC records
2030 * without the NSEC bit set. */
2031
2032 break;
2033 }
2034 case DNS_TYPE_NSEC3: {
2035 uint8_t size;
2036
2037 r = dns_packet_read_uint8(p, &rr->nsec3.algorithm, NULL);
2038 if (r < 0)
2039 return r;
2040
2041 r = dns_packet_read_uint8(p, &rr->nsec3.flags, NULL);
2042 if (r < 0)
2043 return r;
2044
2045 r = dns_packet_read_uint16(p, &rr->nsec3.iterations, NULL);
2046 if (r < 0)
2047 return r;
2048
2049 /* this may be zero */
2050 r = dns_packet_read_uint8(p, &size, NULL);
2051 if (r < 0)
2052 return r;
2053
2054 r = dns_packet_read_memdup(p, size, &rr->nsec3.salt, &rr->nsec3.salt_size, NULL);
2055 if (r < 0)
2056 return r;
2057
2058 r = dns_packet_read_uint8(p, &size, NULL);
2059 if (r < 0)
2060 return r;
2061
2062 if (size <= 0)
2063 return -EBADMSG;
2064
2065 r = dns_packet_read_memdup(p, size,
2066 &rr->nsec3.next_hashed_name, &rr->nsec3.next_hashed_name_size,
2067 NULL);
2068 if (r < 0)
2069 return r;
2070
2071 if (rdlength < p->rindex - offset)
2072 return -EBADMSG;
2073
2074 r = dns_packet_read_type_windows(p, &rr->nsec3.types, offset + rdlength - p->rindex, NULL);
2075
2076 /* empty non-terminals can have NSEC3 records, so empty bitmaps are allowed */
2077
2078 break;
2079 }
2080
2081 case DNS_TYPE_TLSA:
2082 r = dns_packet_read_uint8(p, &rr->tlsa.cert_usage, NULL);
2083 if (r < 0)
2084 return r;
2085
2086 r = dns_packet_read_uint8(p, &rr->tlsa.selector, NULL);
2087 if (r < 0)
2088 return r;
2089
2090 r = dns_packet_read_uint8(p, &rr->tlsa.matching_type, NULL);
2091 if (r < 0)
2092 return r;
2093
2094 if (rdlength < 3)
2095 return -EBADMSG;
2096
2097 r = dns_packet_read_memdup(p, rdlength - 3,
2098 &rr->tlsa.data, &rr->tlsa.data_size,
2099 NULL);
2100
2101 if (rr->tlsa.data_size <= 0)
2102 /* the accepted size depends on the algorithm, but for now
2103 just ensure that the value is greater than zero */
2104 return -EBADMSG;
2105
2106 break;
2107
2108 case DNS_TYPE_CAA:
2109 r = dns_packet_read_uint8(p, &rr->caa.flags, NULL);
2110 if (r < 0)
2111 return r;
2112
2113 r = dns_packet_read_string(p, &rr->caa.tag, NULL);
2114 if (r < 0)
2115 return r;
2116
2117 if (rdlength < p->rindex - offset)
2118 return -EBADMSG;
2119
2120 r = dns_packet_read_memdup(p,
2121 rdlength + offset - p->rindex,
2122 &rr->caa.value, &rr->caa.value_size, NULL);
2123
2124 break;
2125
2126 case DNS_TYPE_OPT: /* we only care about the header of OPT for now. */
2127 case DNS_TYPE_OPENPGPKEY:
2128 default:
2129 unparsable:
2130 r = dns_packet_read_memdup(p, rdlength, &rr->generic.data, &rr->generic.data_size, NULL);
2131
2132 break;
2133 }
2134 if (r < 0)
2135 return r;
2136 if (p->rindex - offset != rdlength)
2137 return -EBADMSG;
2138
2139 if (ret)
2140 *ret = TAKE_PTR(rr);
2141 if (ret_cache_flush)
2142 *ret_cache_flush = cache_flush;
2143 if (ret_start)
2144 *ret_start = rewinder.saved_rindex;
2145
2146 CANCEL_REWINDER(rewinder);
2147 return 0;
2148 }
2149
2150 static bool opt_is_good(DnsResourceRecord *rr, bool *rfc6975) {
2151 const uint8_t* p;
2152 bool found_dau_dhu_n3u = false;
2153 size_t l;
2154
2155 /* Checks whether the specified OPT RR is well-formed and whether it contains RFC6975 data (which is not OK in
2156 * a reply). */
2157
2158 assert(rr);
2159 assert(rr->key->type == DNS_TYPE_OPT);
2160
2161 /* Check that the version is 0 */
2162 if (((rr->ttl >> 16) & UINT32_C(0xFF)) != 0) {
2163 *rfc6975 = false;
2164 return true; /* if it's not version 0, it's OK, but we will ignore the OPT field contents */
2165 }
2166
2167 p = rr->opt.data;
2168 l = rr->opt.data_size;
2169 while (l > 0) {
2170 uint16_t option_code, option_length;
2171
2172 /* At least four bytes for OPTION-CODE and OPTION-LENGTH are required */
2173 if (l < 4U)
2174 return false;
2175
2176 option_code = unaligned_read_be16(p);
2177 option_length = unaligned_read_be16(p + 2);
2178
2179 if (l < option_length + 4U)
2180 return false;
2181
2182 /* RFC 6975 DAU, DHU or N3U fields found. */
2183 if (IN_SET(option_code, 5, 6, 7))
2184 found_dau_dhu_n3u = true;
2185
2186 p += option_length + 4U;
2187 l -= option_length + 4U;
2188 }
2189
2190 *rfc6975 = found_dau_dhu_n3u;
2191 return true;
2192 }
2193
2194 static int dns_packet_extract_question(DnsPacket *p, DnsQuestion **ret_question) {
2195 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
2196 unsigned n;
2197 int r;
2198
2199 n = DNS_PACKET_QDCOUNT(p);
2200 if (n > 0) {
2201 question = dns_question_new(n);
2202 if (!question)
2203 return -ENOMEM;
2204
2205 _cleanup_set_free_ Set *keys = NULL; /* references to keys are kept by Question */
2206
2207 keys = set_new(&dns_resource_key_hash_ops);
2208 if (!keys)
2209 return log_oom();
2210
2211 r = set_reserve(keys, n * 2); /* Higher multipliers give slightly higher efficiency through
2212 * hash collisions, but the gains quickly drop off after 2. */
2213 if (r < 0)
2214 return r;
2215
2216 for (unsigned i = 0; i < n; i++) {
2217 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
2218 bool qu;
2219
2220 r = dns_packet_read_key(p, &key, &qu, NULL);
2221 if (r < 0)
2222 return r;
2223
2224 if (!dns_type_is_valid_query(key->type))
2225 return -EBADMSG;
2226
2227 r = set_put(keys, key);
2228 if (r < 0)
2229 return r;
2230 if (r == 0)
2231 /* Already in the Question, let's skip */
2232 continue;
2233
2234 r = dns_question_add_raw(question, key, qu ? DNS_QUESTION_WANTS_UNICAST_REPLY : 0);
2235 if (r < 0)
2236 return r;
2237 }
2238 }
2239
2240 *ret_question = TAKE_PTR(question);
2241
2242 return 0;
2243 }
2244
2245 static int dns_packet_extract_answer(DnsPacket *p, DnsAnswer **ret_answer) {
2246 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
2247 unsigned n;
2248 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *previous = NULL;
2249 bool bad_opt = false;
2250 int r;
2251
2252 n = DNS_PACKET_RRCOUNT(p);
2253 if (n == 0)
2254 return 0;
2255
2256 answer = dns_answer_new(n);
2257 if (!answer)
2258 return -ENOMEM;
2259
2260 for (unsigned i = 0; i < n; i++) {
2261 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
2262 bool cache_flush = false;
2263 size_t start;
2264
2265 if (p->rindex == p->size && p->opt) {
2266 /* If we reached the end of the packet already, but there are still more RRs
2267 * declared, then that's a corrupt packet. Let's accept the packet anyway, since it's
2268 * apparently a common bug in routers. Let's however suppress OPT support in this
2269 * case, so that we force the rest of the logic into lowest DNS baseline support. Or
2270 * to say this differently: if the DNS server doesn't even get the RR counts right,
2271 * it's highly unlikely it gets EDNS right. */
2272 log_debug("More resource records declared in packet than included, suppressing OPT.");
2273 bad_opt = true;
2274 break;
2275 }
2276
2277 r = dns_packet_read_rr(p, &rr, &cache_flush, &start);
2278 if (r < 0)
2279 return r;
2280
2281 /* Try to reduce memory usage a bit */
2282 if (previous)
2283 dns_resource_key_reduce(&rr->key, &previous->key);
2284
2285 if (rr->key->type == DNS_TYPE_OPT) {
2286 bool has_rfc6975;
2287
2288 if (p->opt || bad_opt) {
2289 /* Multiple OPT RRs? if so, let's ignore all, because there's
2290 * something wrong with the server, and if one is valid we wouldn't
2291 * know which one. */
2292 log_debug("Multiple OPT RRs detected, ignoring all.");
2293 bad_opt = true;
2294 continue;
2295 }
2296
2297 if (!dns_name_is_root(dns_resource_key_name(rr->key))) {
2298 /* If the OPT RR is not owned by the root domain, then it is bad,
2299 * let's ignore it. */
2300 log_debug("OPT RR is not owned by root domain, ignoring.");
2301 bad_opt = true;
2302 continue;
2303 }
2304
2305 if (i < DNS_PACKET_ANCOUNT(p) + DNS_PACKET_NSCOUNT(p)) {
2306 /* OPT RR is in the wrong section? Some Belkin routers do this. This
2307 * is a hint the EDNS implementation is borked, like the Belkin one
2308 * is, hence ignore it. */
2309 log_debug("OPT RR in wrong section, ignoring.");
2310 bad_opt = true;
2311 continue;
2312 }
2313
2314 if (!opt_is_good(rr, &has_rfc6975)) {
2315 log_debug("Malformed OPT RR, ignoring.");
2316 bad_opt = true;
2317 continue;
2318 }
2319
2320 if (DNS_PACKET_QR(p)) {
2321 /* Additional checks for responses */
2322
2323 if (!DNS_RESOURCE_RECORD_OPT_VERSION_SUPPORTED(rr))
2324 /* If this is a reply and we don't know the EDNS version
2325 * then something is weird... */
2326 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2327 "EDNS version newer that our request, bad server.");
2328
2329 if (has_rfc6975) {
2330 /* If the OPT RR contains RFC6975 algorithm data, then this
2331 * is indication that the server just copied the OPT it got
2332 * from us (which contained that data) back into the reply.
2333 * If so, then it doesn't properly support EDNS, as RFC6975
2334 * makes it very clear that the algorithm data should only
2335 * be contained in questions, never in replies. Crappy
2336 * Belkin routers copy the OPT data for example, hence let's
2337 * detect this so that we downgrade early. */
2338 log_debug("OPT RR contains RFC6975 data, ignoring.");
2339 bad_opt = true;
2340 continue;
2341 }
2342 }
2343
2344 p->opt = dns_resource_record_ref(rr);
2345 p->opt_start = start;
2346 assert(p->rindex >= start);
2347 p->opt_size = p->rindex - start;
2348 } else {
2349 DnsAnswerFlags flags = 0;
2350
2351 if (p->protocol == DNS_PROTOCOL_MDNS) {
2352 flags |= DNS_ANSWER_REFUSE_TTL_NO_MATCH;
2353 if (!cache_flush)
2354 flags |= DNS_ANSWER_SHARED_OWNER;
2355 }
2356
2357 /* According to RFC 4795, section 2.9. only the RRs from the Answer section shall be
2358 * cached. Hence mark only those RRs as cacheable by default, but not the ones from
2359 * the Additional or Authority sections.
2360 * This restriction does not apply to mDNS records (RFC 6762). */
2361 if (i < DNS_PACKET_ANCOUNT(p))
2362 flags |= DNS_ANSWER_CACHEABLE|DNS_ANSWER_SECTION_ANSWER;
2363 else if (i < DNS_PACKET_ANCOUNT(p) + DNS_PACKET_NSCOUNT(p))
2364 flags |= DNS_ANSWER_SECTION_AUTHORITY;
2365 else {
2366 flags |= DNS_ANSWER_SECTION_ADDITIONAL;
2367 if (p->protocol == DNS_PROTOCOL_MDNS)
2368 flags |= DNS_ANSWER_CACHEABLE;
2369 }
2370
2371 r = dns_answer_add(answer, rr, p->ifindex, flags, NULL);
2372 if (r < 0)
2373 return r;
2374 }
2375
2376 /* Remember this RR, so that we can potentially merge its ->key object with the
2377 * next RR. Note that we only do this if we actually decided to keep the RR around.
2378 */
2379 DNS_RR_REPLACE(previous, dns_resource_record_ref(rr));
2380 }
2381
2382 if (bad_opt) {
2383 p->opt = dns_resource_record_unref(p->opt);
2384 p->opt_start = p->opt_size = SIZE_MAX;
2385 }
2386
2387 *ret_answer = TAKE_PTR(answer);
2388
2389 return 0;
2390 }
2391
2392 int dns_packet_extract(DnsPacket *p) {
2393 assert(p);
2394
2395 if (p->extracted)
2396 return 0;
2397
2398 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
2399 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
2400 _unused_ _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
2401 int r;
2402
2403 dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
2404
2405 r = dns_packet_extract_question(p, &question);
2406 if (r < 0)
2407 return r;
2408
2409 r = dns_packet_extract_answer(p, &answer);
2410 if (r < 0)
2411 return r;
2412
2413 if (p->rindex < p->size) {
2414 log_debug("Trailing garbage in packet, suppressing OPT.");
2415 p->opt = dns_resource_record_unref(p->opt);
2416 p->opt_start = p->opt_size = SIZE_MAX;
2417 }
2418
2419 p->question = TAKE_PTR(question);
2420 p->answer = TAKE_PTR(answer);
2421 p->extracted = true;
2422
2423 /* no CANCEL, always rewind */
2424 return 0;
2425 }
2426
2427 int dns_packet_is_reply_for(DnsPacket *p, const DnsResourceKey *key) {
2428 int r;
2429
2430 assert(p);
2431 assert(key);
2432
2433 /* Checks if the specified packet is a reply for the specified
2434 * key and the specified key is the only one in the question
2435 * section. */
2436
2437 if (DNS_PACKET_QR(p) != 1)
2438 return 0;
2439
2440 /* Let's unpack the packet, if that hasn't happened yet. */
2441 r = dns_packet_extract(p);
2442 if (r < 0)
2443 return r;
2444
2445 if (!p->question)
2446 return 0;
2447
2448 if (p->question->n_keys != 1)
2449 return 0;
2450
2451 return dns_resource_key_equal(dns_question_first_key(p->question), key);
2452 }
2453
2454 int dns_packet_patch_max_udp_size(DnsPacket *p, uint16_t max_udp_size) {
2455 assert(p);
2456 assert(max_udp_size >= DNS_PACKET_UNICAST_SIZE_MAX);
2457
2458 if (p->opt_start == SIZE_MAX) /* No OPT section, nothing to patch */
2459 return 0;
2460
2461 assert(p->opt_size != SIZE_MAX);
2462 assert(p->opt_size >= 5);
2463
2464 unaligned_write_be16(DNS_PACKET_DATA(p) + p->opt_start + 3, max_udp_size);
2465 return 1;
2466 }
2467
2468 static int patch_rr(DnsPacket *p, usec_t age) {
2469 _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
2470 size_t ttl_index;
2471 uint32_t ttl;
2472 uint16_t type, rdlength;
2473 int r;
2474
2475 /* Patches the RR at the current rindex, subtracts the specified time from the TTL */
2476
2477 r = dns_packet_read_name(p, NULL, true, NULL);
2478 if (r < 0)
2479 return r;
2480
2481 r = dns_packet_read_uint16(p, &type, NULL);
2482 if (r < 0)
2483 return r;
2484
2485 r = dns_packet_read_uint16(p, NULL, NULL);
2486 if (r < 0)
2487 return r;
2488
2489 r = dns_packet_read_uint32(p, &ttl, &ttl_index);
2490 if (r < 0)
2491 return r;
2492
2493 if (type != DNS_TYPE_OPT) { /* The TTL of the OPT field is not actually a TTL, skip it */
2494 ttl = LESS_BY(ttl * USEC_PER_SEC, age) / USEC_PER_SEC;
2495 unaligned_write_be32(DNS_PACKET_DATA(p) + ttl_index, ttl);
2496 }
2497
2498 r = dns_packet_read_uint16(p, &rdlength, NULL);
2499 if (r < 0)
2500 return r;
2501
2502 r = dns_packet_read(p, rdlength, NULL, NULL);
2503 if (r < 0)
2504 return r;
2505
2506 CANCEL_REWINDER(rewinder);
2507 return 0;
2508 }
2509
2510 int dns_packet_patch_ttls(DnsPacket *p, usec_t timestamp) {
2511 assert(p);
2512 assert(timestamp_is_set(timestamp));
2513
2514 /* Adjusts all TTLs in the packet by subtracting the time difference between now and the specified timestamp */
2515
2516 _unused_ _cleanup_(rewind_dns_packet) DnsPacketRewinder rewinder = REWINDER_INIT(p);
2517 unsigned n;
2518 usec_t k;
2519 int r;
2520
2521 k = now(CLOCK_BOOTTIME);
2522 assert(k >= timestamp);
2523 k -= timestamp;
2524
2525 dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
2526
2527 n = DNS_PACKET_QDCOUNT(p);
2528 for (unsigned i = 0; i < n; i++) {
2529 r = dns_packet_read_key(p, NULL, NULL, NULL);
2530 if (r < 0)
2531 return r;
2532 }
2533
2534 n = DNS_PACKET_RRCOUNT(p);
2535 for (unsigned i = 0; i < n; i++) {
2536
2537 /* DNS servers suck, hence the RR count is in many servers off. If we reached the end
2538 * prematurely, accept that, exit early */
2539 if (p->rindex == p->size)
2540 break;
2541
2542 r = patch_rr(p, k);
2543 if (r < 0)
2544 return r;
2545 }
2546
2547 return 0;
2548 }
2549
2550 static void dns_packet_hash_func(const DnsPacket *s, struct siphash *state) {
2551 assert(s);
2552
2553 siphash24_compress(&s->size, sizeof(s->size), state);
2554 siphash24_compress(DNS_PACKET_DATA((DnsPacket*) s), s->size, state);
2555 }
2556
2557 static int dns_packet_compare_func(const DnsPacket *x, const DnsPacket *y) {
2558 int r;
2559
2560 r = CMP(x->size, y->size);
2561 if (r != 0)
2562 return r;
2563
2564 return memcmp(DNS_PACKET_DATA((DnsPacket*) x), DNS_PACKET_DATA((DnsPacket*) y), x->size);
2565 }
2566
2567 DEFINE_HASH_OPS(dns_packet_hash_ops, DnsPacket, dns_packet_hash_func, dns_packet_compare_func);
2568
2569 bool dns_packet_equal(const DnsPacket *a, const DnsPacket *b) {
2570 return dns_packet_compare_func(a, b) == 0;
2571 }
2572
2573 int dns_packet_has_nsid_request(DnsPacket *p) {
2574 bool has_nsid = false;
2575 const uint8_t *d;
2576 size_t l;
2577
2578 assert(p);
2579
2580 if (!p->opt)
2581 return false;
2582
2583 d = p->opt->opt.data;
2584 l = p->opt->opt.data_size;
2585
2586 while (l > 0) {
2587 uint16_t code, length;
2588
2589 if (l < 4U)
2590 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2591 "EDNS0 variable part has invalid size.");
2592
2593 code = unaligned_read_be16(d);
2594 length = unaligned_read_be16(d + 2);
2595
2596 if (l < 4U + length)
2597 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2598 "Truncated option in EDNS0 variable part.");
2599
2600 if (code == 3) {
2601 if (has_nsid)
2602 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2603 "Duplicate NSID option in EDNS0 variable part.");
2604
2605 if (length != 0)
2606 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG),
2607 "Non-empty NSID option in DNS request.");
2608
2609 has_nsid = true;
2610 }
2611
2612 d += 4U + length;
2613 l -= 4U + length;
2614 }
2615
2616 return has_nsid;
2617 }
2618
2619 size_t dns_packet_size_unfragmented(DnsPacket *p) {
2620 assert(p);
2621
2622 if (p->fragsize == 0) /* Wasn't fragmented */
2623 return p->size;
2624
2625 /* The fragment size (p->fragsize) covers the whole (fragmented) IP packet, while the regular packet
2626 * size (p->size) only covers the DNS part. Thus, subtract the UDP header from the largest fragment
2627 * size, in order to determine which size of DNS packet would have gone through without
2628 * fragmenting. */
2629
2630 return LESS_BY(p->fragsize, udp_header_size(p->family));
2631 }
2632
2633 static const char* const dns_rcode_table[_DNS_RCODE_MAX_DEFINED] = {
2634 [DNS_RCODE_SUCCESS] = "SUCCESS",
2635 [DNS_RCODE_FORMERR] = "FORMERR",
2636 [DNS_RCODE_SERVFAIL] = "SERVFAIL",
2637 [DNS_RCODE_NXDOMAIN] = "NXDOMAIN",
2638 [DNS_RCODE_NOTIMP] = "NOTIMP",
2639 [DNS_RCODE_REFUSED] = "REFUSED",
2640 [DNS_RCODE_YXDOMAIN] = "YXDOMAIN",
2641 [DNS_RCODE_YXRRSET] = "YRRSET",
2642 [DNS_RCODE_NXRRSET] = "NXRRSET",
2643 [DNS_RCODE_NOTAUTH] = "NOTAUTH",
2644 [DNS_RCODE_NOTZONE] = "NOTZONE",
2645 [DNS_RCODE_BADVERS] = "BADVERS",
2646 [DNS_RCODE_BADKEY] = "BADKEY",
2647 [DNS_RCODE_BADTIME] = "BADTIME",
2648 [DNS_RCODE_BADMODE] = "BADMODE",
2649 [DNS_RCODE_BADNAME] = "BADNAME",
2650 [DNS_RCODE_BADALG] = "BADALG",
2651 [DNS_RCODE_BADTRUNC] = "BADTRUNC",
2652 [DNS_RCODE_BADCOOKIE] = "BADCOOKIE",
2653 };
2654 DEFINE_STRING_TABLE_LOOKUP(dns_rcode, int);
2655
2656 const char *format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]) {
2657 const char *p = dns_rcode_to_string(i);
2658 if (p)
2659 return p;
2660
2661 return snprintf_ok(buf, DECIMAL_STR_MAX(int), "%i", i);
2662 }
2663
2664 static const char* const dns_protocol_table[_DNS_PROTOCOL_MAX] = {
2665 [DNS_PROTOCOL_DNS] = "dns",
2666 [DNS_PROTOCOL_MDNS] = "mdns",
2667 [DNS_PROTOCOL_LLMNR] = "llmnr",
2668 };
2669 DEFINE_STRING_TABLE_LOOKUP(dns_protocol, DnsProtocol);
Unnamed repository; edit this file 'description' to name the repository.