]> git.ipfire.org Git - thirdparty/systemd.git/blame_incremental - src/resolve/resolved-dns-packet.c
projects / thirdparty / systemd.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
update TODO
[thirdparty/systemd.git] / src / resolve / resolved-dns-packet.c
... / ...
CommitLineData
1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2014 Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20 ***/
21
22#include "utf8.h"
23#include "util.h"
24#include "strv.h"
25#include "unaligned.h"
26#include "resolved-dns-domain.h"
27#include "resolved-dns-packet.h"
28
29int dns_packet_new(DnsPacket **ret, DnsProtocol protocol, size_t mtu) {
30 DnsPacket *p;
31 size_t a;
32
33 assert(ret);
34
35 if (mtu <= 0)
36 a = DNS_PACKET_SIZE_START;
37 else
38 a = mtu;
39
40 if (a < DNS_PACKET_HEADER_SIZE)
41 a = DNS_PACKET_HEADER_SIZE;
42
43 /* round up to next page size */
44 a = PAGE_ALIGN(ALIGN(sizeof(DnsPacket)) + a) - ALIGN(sizeof(DnsPacket));
45
46 /* make sure we never allocate more than useful */
47 if (a > DNS_PACKET_SIZE_MAX)
48 a = DNS_PACKET_SIZE_MAX;
49
50 p = malloc0(ALIGN(sizeof(DnsPacket)) + a);
51 if (!p)
52 return -ENOMEM;
53
54 p->size = p->rindex = DNS_PACKET_HEADER_SIZE;
55 p->allocated = a;
56 p->protocol = protocol;
57 p->n_ref = 1;
58
59 *ret = p;
60
61 return 0;
62}
63
64int dns_packet_new_query(DnsPacket **ret, DnsProtocol protocol, size_t mtu) {
65 DnsPacket *p;
66 DnsPacketHeader *h;
67 int r;
68
69 assert(ret);
70
71 r = dns_packet_new(&p, protocol, mtu);
72 if (r < 0)
73 return r;
74
75 h = DNS_PACKET_HEADER(p);
76
77 if (protocol == DNS_PROTOCOL_LLMNR)
78 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
79 0 /* opcode */,
80 0 /* c */,
81 0 /* tc */,
82 0 /* t */,
83 0 /* ra */,
84 0 /* ad */,
85 0 /* cd */,
86 0 /* rcode */));
87 else
88 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
89 0 /* opcode */,
90 0 /* aa */,
91 0 /* tc */,
92 1 /* rd (ask for recursion) */,
93 0 /* ra */,
94 0 /* ad */,
95 0 /* cd */,
96 0 /* rcode */));
97
98 *ret = p;
99 return 0;
100}
101
102DnsPacket *dns_packet_ref(DnsPacket *p) {
103
104 if (!p)
105 return NULL;
106
107 assert(p->n_ref > 0);
108 p->n_ref++;
109 return p;
110}
111
112static void dns_packet_free(DnsPacket *p) {
113 char *s;
114
115 assert(p);
116
117 dns_question_unref(p->question);
118 dns_answer_unref(p->answer);
119
120 while ((s = hashmap_steal_first_key(p->names)))
121 free(s);
122 hashmap_free(p->names);
123
124 free(p->_data);
125 free(p);
126}
127
128DnsPacket *dns_packet_unref(DnsPacket *p) {
129 if (!p)
130 return NULL;
131
132 assert(p->n_ref > 0);
133
134 if (p->n_ref == 1)
135 dns_packet_free(p);
136 else
137 p->n_ref--;
138
139 return NULL;
140}
141
142int dns_packet_validate(DnsPacket *p) {
143 assert(p);
144
145 if (p->size < DNS_PACKET_HEADER_SIZE)
146 return -EBADMSG;
147
148 if (p->size > DNS_PACKET_SIZE_MAX)
149 return -EBADMSG;
150
151 return 1;
152}
153
154int dns_packet_validate_reply(DnsPacket *p) {
155 int r;
156
157 assert(p);
158
159 r = dns_packet_validate(p);
160 if (r < 0)
161 return r;
162
163 if (DNS_PACKET_QR(p) != 1)
164 return 0;
165
166 if (DNS_PACKET_OPCODE(p) != 0)
167 return -EBADMSG;
168
169 /* RFC 4795, Section 2.1.1. says to discard all replies with QDCOUNT != 1 */
170 if (p->protocol == DNS_PROTOCOL_LLMNR &&
171 DNS_PACKET_QDCOUNT(p) != 1)
172 return -EBADMSG;
173
174 return 1;
175}
176
177int dns_packet_validate_query(DnsPacket *p) {
178 int r;
179
180 assert(p);
181
182 r = dns_packet_validate(p);
183 if (r < 0)
184 return r;
185
186 if (DNS_PACKET_QR(p) != 0)
187 return 0;
188
189 if (DNS_PACKET_OPCODE(p) != 0)
190 return -EBADMSG;
191
192 if (DNS_PACKET_TC(p))
193 return -EBADMSG;
194
195 /* RFC 4795, Section 2.1.1. says to discard all queries with QDCOUNT != 1 */
196 if (p->protocol == DNS_PROTOCOL_LLMNR &&
197 DNS_PACKET_QDCOUNT(p) != 1)
198 return -EBADMSG;
199
200 /* RFC 4795, Section 2.1.1. says to discard all queries with ANCOUNT != 0 */
201 if (DNS_PACKET_ANCOUNT(p) > 0)
202 return -EBADMSG;
203
204 /* RFC 4795, Section 2.1.1. says to discard all queries with NSCOUNT != 0 */
205 if (DNS_PACKET_NSCOUNT(p) > 0)
206 return -EBADMSG;
207
208 return 1;
209}
210
211static int dns_packet_extend(DnsPacket *p, size_t add, void **ret, size_t *start) {
212 assert(p);
213
214 if (p->size + add > p->allocated) {
215 size_t a;
216
217 a = PAGE_ALIGN((p->size + add) * 2);
218 if (a > DNS_PACKET_SIZE_MAX)
219 a = DNS_PACKET_SIZE_MAX;
220
221 if (p->size + add > a)
222 return -EMSGSIZE;
223
224 if (p->_data) {
225 void *d;
226
227 d = realloc(p->_data, a);
228 if (!d)
229 return -ENOMEM;
230
231 p->_data = d;
232 } else {
233 p->_data = malloc(a);
234 if (!p->_data)
235 return -ENOMEM;
236
237 memcpy(p->_data, (uint8_t*) p + ALIGN(sizeof(DnsPacket)), p->size);
238 memzero((uint8_t*) p->_data + p->size, a - p->size);
239 }
240
241 p->allocated = a;
242 }
243
244 if (start)
245 *start = p->size;
246
247 if (ret)
248 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->size;
249
250 p->size += add;
251 return 0;
252}
253
254static void dns_packet_truncate(DnsPacket *p, size_t sz) {
255 Iterator i;
256 char *s;
257 void *n;
258
259 assert(p);
260
261 if (p->size <= sz)
262 return;
263
264 HASHMAP_FOREACH_KEY(s, n, p->names, i) {
265
266 if (PTR_TO_SIZE(n) < sz)
267 continue;
268
269 hashmap_remove(p->names, s);
270 free(s);
271 }
272
273 p->size = sz;
274}
275
276int dns_packet_append_blob(DnsPacket *p, const void *d, size_t l, size_t *start) {
277 void *q;
278 int r;
279
280 assert(p);
281
282 r = dns_packet_extend(p, l, &q, start);
283 if (r < 0)
284 return r;
285
286 memcpy(q, d, l);
287 return 0;
288}
289
290int dns_packet_append_uint8(DnsPacket *p, uint8_t v, size_t *start) {
291 void *d;
292 int r;
293
294 assert(p);
295
296 r = dns_packet_extend(p, sizeof(uint8_t), &d, start);
297 if (r < 0)
298 return r;
299
300 ((uint8_t*) d)[0] = v;
301
302 return 0;
303}
304
305int dns_packet_append_uint16(DnsPacket *p, uint16_t v, size_t *start) {
306 void *d;
307 int r;
308
309 assert(p);
310
311 r = dns_packet_extend(p, sizeof(uint16_t), &d, start);
312 if (r < 0)
313 return r;
314
315 unaligned_write_be16(d, v);
316
317 return 0;
318}
319
320int dns_packet_append_uint32(DnsPacket *p, uint32_t v, size_t *start) {
321 void *d;
322 int r;
323
324 assert(p);
325
326 r = dns_packet_extend(p, sizeof(uint32_t), &d, start);
327 if (r < 0)
328 return r;
329
330 unaligned_write_be32(d, v);
331
332 return 0;
333}
334
335int dns_packet_append_string(DnsPacket *p, const char *s, size_t *start) {
336 void *d;
337 size_t l;
338 int r;
339
340 assert(p);
341 assert(s);
342
343 l = strlen(s);
344 if (l > 255)
345 return -E2BIG;
346
347 r = dns_packet_extend(p, 1 + l, &d, start);
348 if (r < 0)
349 return r;
350
351 ((uint8_t*) d)[0] = (uint8_t) l;
352 memcpy(((uint8_t*) d) + 1, s, l);
353
354 return 0;
355}
356
357int dns_packet_append_label(DnsPacket *p, const char *d, size_t l, size_t *start) {
358 void *w;
359 int r;
360
361 assert(p);
362 assert(d);
363
364 if (l > DNS_LABEL_MAX)
365 return -E2BIG;
366
367 r = dns_packet_extend(p, 1 + l, &w, start);
368 if (r < 0)
369 return r;
370
371 ((uint8_t*) w)[0] = (uint8_t) l;
372 memcpy(((uint8_t*) w) + 1, d, l);
373
374 return 0;
375}
376
377int dns_packet_append_name(DnsPacket *p, const char *name,
378 bool allow_compression, size_t *start) {
379 size_t saved_size;
380 int r;
381
382 assert(p);
383 assert(name);
384
385 saved_size = p->size;
386
387 while (*name) {
388 _cleanup_free_ char *s = NULL;
389 char label[DNS_LABEL_MAX];
390 size_t n = 0;
391 int k;
392
393 if (allow_compression)
394 n = PTR_TO_SIZE(hashmap_get(p->names, name));
395 if (n > 0) {
396 assert(n < p->size);
397
398 if (n < 0x4000) {
399 r = dns_packet_append_uint16(p, 0xC000 | n, NULL);
400 if (r < 0)
401 goto fail;
402
403 goto done;
404 }
405 }
406
407 s = strdup(name);
408 if (!s) {
409 r = -ENOMEM;
410 goto fail;
411 }
412
413 r = dns_label_unescape(&name, label, sizeof(label));
414 if (r < 0)
415 goto fail;
416
417 if (p->protocol == DNS_PROTOCOL_DNS)
418 k = dns_label_apply_idna(label, r, label, sizeof(label));
419 else
420 k = dns_label_undo_idna(label, r, label, sizeof(label));
421 if (k < 0) {
422 r = k;
423 goto fail;
424 }
425 if (k > 0)
426 r = k;
427
428 r = dns_packet_append_label(p, label, r, &n);
429 if (r < 0)
430 goto fail;
431
432 if (allow_compression) {
433 r = hashmap_ensure_allocated(&p->names, &dns_name_hash_ops);
434 if (r < 0)
435 goto fail;
436
437 r = hashmap_put(p->names, s, SIZE_TO_PTR(n));
438 if (r < 0)
439 goto fail;
440
441 s = NULL;
442 }
443 }
444
445 r = dns_packet_append_uint8(p, 0, NULL);
446 if (r < 0)
447 return r;
448
449done:
450 if (start)
451 *start = saved_size;
452
453 return 0;
454
455fail:
456 dns_packet_truncate(p, saved_size);
457 return r;
458}
459
460int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *k, size_t *start) {
461 size_t saved_size;
462 int r;
463
464 assert(p);
465 assert(k);
466
467 saved_size = p->size;
468
469 r = dns_packet_append_name(p, DNS_RESOURCE_KEY_NAME(k), true, NULL);
470 if (r < 0)
471 goto fail;
472
473 r = dns_packet_append_uint16(p, k->type, NULL);
474 if (r < 0)
475 goto fail;
476
477 r = dns_packet_append_uint16(p, k->class, NULL);
478 if (r < 0)
479 goto fail;
480
481 if (start)
482 *start = saved_size;
483
484 return 0;
485
486fail:
487 dns_packet_truncate(p, saved_size);
488 return r;
489}
490
491int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, size_t *start) {
492 size_t saved_size, rdlength_offset, end, rdlength;
493 int r;
494
495 assert(p);
496 assert(rr);
497
498 saved_size = p->size;
499
500 r = dns_packet_append_key(p, rr->key, NULL);
501 if (r < 0)
502 goto fail;
503
504 r = dns_packet_append_uint32(p, rr->ttl, NULL);
505 if (r < 0)
506 goto fail;
507
508 /* Initially we write 0 here */
509 r = dns_packet_append_uint16(p, 0, &rdlength_offset);
510 if (r < 0)
511 goto fail;
512
513 switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
514
515 case DNS_TYPE_SRV:
516 r = dns_packet_append_uint16(p, rr->srv.priority, NULL);
517 if (r < 0)
518 goto fail;
519
520 r = dns_packet_append_uint16(p, rr->srv.weight, NULL);
521 if (r < 0)
522 goto fail;
523
524 r = dns_packet_append_uint16(p, rr->srv.port, NULL);
525 if (r < 0)
526 goto fail;
527
528 r = dns_packet_append_name(p, rr->srv.name, true, NULL);
529 break;
530
531 case DNS_TYPE_PTR:
532 case DNS_TYPE_NS:
533 case DNS_TYPE_CNAME:
534 case DNS_TYPE_DNAME:
535 r = dns_packet_append_name(p, rr->ptr.name, true, NULL);
536 break;
537
538 case DNS_TYPE_HINFO:
539 r = dns_packet_append_string(p, rr->hinfo.cpu, NULL);
540 if (r < 0)
541 goto fail;
542
543 r = dns_packet_append_string(p, rr->hinfo.os, NULL);
544 break;
545
546 case DNS_TYPE_SPF: /* exactly the same as TXT */
547 case DNS_TYPE_TXT: {
548 char **s;
549
550 STRV_FOREACH(s, rr->txt.strings) {
551 r = dns_packet_append_string(p, *s, NULL);
552 if (r < 0)
553 goto fail;
554 }
555
556 r = 0;
557 break;
558 }
559
560 case DNS_TYPE_A:
561 r = dns_packet_append_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
562 break;
563
564 case DNS_TYPE_AAAA:
565 r = dns_packet_append_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
566 break;
567
568 case DNS_TYPE_SOA:
569 r = dns_packet_append_name(p, rr->soa.mname, true, NULL);
570 if (r < 0)
571 goto fail;
572
573 r = dns_packet_append_name(p, rr->soa.rname, true, NULL);
574 if (r < 0)
575 goto fail;
576
577 r = dns_packet_append_uint32(p, rr->soa.serial, NULL);
578 if (r < 0)
579 goto fail;
580
581 r = dns_packet_append_uint32(p, rr->soa.refresh, NULL);
582 if (r < 0)
583 goto fail;
584
585 r = dns_packet_append_uint32(p, rr->soa.retry, NULL);
586 if (r < 0)
587 goto fail;
588
589 r = dns_packet_append_uint32(p, rr->soa.expire, NULL);
590 if (r < 0)
591 goto fail;
592
593 r = dns_packet_append_uint32(p, rr->soa.minimum, NULL);
594 break;
595
596 case DNS_TYPE_MX:
597 r = dns_packet_append_uint16(p, rr->mx.priority, NULL);
598 if (r < 0)
599 goto fail;
600
601 r = dns_packet_append_name(p, rr->mx.exchange, true, NULL);
602 break;
603
604 case DNS_TYPE_LOC:
605 r = dns_packet_append_uint8(p, rr->loc.version, NULL);
606 if (r < 0)
607 goto fail;
608
609 r = dns_packet_append_uint8(p, rr->loc.size, NULL);
610 if (r < 0)
611 goto fail;
612
613 r = dns_packet_append_uint8(p, rr->loc.horiz_pre, NULL);
614 if (r < 0)
615 goto fail;
616
617 r = dns_packet_append_uint8(p, rr->loc.vert_pre, NULL);
618 if (r < 0)
619 goto fail;
620
621 r = dns_packet_append_uint32(p, rr->loc.latitude, NULL);
622 if (r < 0)
623 goto fail;
624
625 r = dns_packet_append_uint32(p, rr->loc.longitude, NULL);
626 if (r < 0)
627 goto fail;
628
629 r = dns_packet_append_uint32(p, rr->loc.altitude, NULL);
630 break;
631
632 case DNS_TYPE_SSHFP:
633 r = dns_packet_append_uint8(p, rr->sshfp.algorithm, NULL);
634 if (r < 0)
635 goto fail;
636
637 r = dns_packet_append_uint8(p, rr->sshfp.fptype, NULL);
638 if (r < 0)
639 goto fail;
640
641 r = dns_packet_append_blob(p, rr->sshfp.key, rr->sshfp.key_size, NULL);
642 break;
643
644 case DNS_TYPE_DNSKEY:
645 r = dns_packet_append_uint16(p, dnskey_to_flags(rr), NULL);
646 if (r < 0)
647 goto fail;
648
649 r = dns_packet_append_uint8(p, 3u, NULL);
650 if (r < 0)
651 goto fail;
652
653 r = dns_packet_append_uint8(p, rr->dnskey.algorithm, NULL);
654 if (r < 0)
655 goto fail;
656
657 r = dns_packet_append_blob(p, rr->dnskey.key, rr->dnskey.key_size, NULL);
658 break;
659
660 case DNS_TYPE_RRSIG:
661 r = dns_packet_append_uint16(p, rr->rrsig.type_covered, NULL);
662 if (r < 0)
663 goto fail;
664
665 r = dns_packet_append_uint8(p, rr->rrsig.algorithm, NULL);
666 if (r < 0)
667 goto fail;
668
669 r = dns_packet_append_uint8(p, rr->rrsig.labels, NULL);
670 if (r < 0)
671 goto fail;
672
673 r = dns_packet_append_uint32(p, rr->rrsig.original_ttl, NULL);
674 if (r < 0)
675 goto fail;
676
677 r = dns_packet_append_uint32(p, rr->rrsig.expiration, NULL);
678 if (r < 0)
679 goto fail;
680
681 r = dns_packet_append_uint32(p, rr->rrsig.inception, NULL);
682 if (r < 0)
683 goto fail;
684
685 r = dns_packet_append_uint8(p, rr->rrsig.key_tag, NULL);
686 if (r < 0)
687 goto fail;
688
689 r = dns_packet_append_name(p, rr->rrsig.signer, false, NULL);
690 if (r < 0)
691 goto fail;
692
693 r = dns_packet_append_blob(p, rr->rrsig.signature, rr->rrsig.signature_size, NULL);
694 break;
695
696 case _DNS_TYPE_INVALID: /* unparseable */
697 default:
698
699 r = dns_packet_append_blob(p, rr->generic.data, rr->generic.size, NULL);
700 break;
701 }
702 if (r < 0)
703 goto fail;
704
705 /* Let's calculate the actual data size and update the field */
706 rdlength = p->size - rdlength_offset - sizeof(uint16_t);
707 if (rdlength > 0xFFFF) {
708 r = ENOSPC;
709 goto fail;
710 }
711
712 end = p->size;
713 p->size = rdlength_offset;
714 r = dns_packet_append_uint16(p, rdlength, NULL);
715 if (r < 0)
716 goto fail;
717 p->size = end;
718
719 if (start)
720 *start = saved_size;
721
722 return 0;
723
724fail:
725 dns_packet_truncate(p, saved_size);
726 return r;
727}
728
729
730int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start) {
731 assert(p);
732
733 if (p->rindex + sz > p->size)
734 return -EMSGSIZE;
735
736 if (ret)
737 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->rindex;
738
739 if (start)
740 *start = p->rindex;
741
742 p->rindex += sz;
743 return 0;
744}
745
746void dns_packet_rewind(DnsPacket *p, size_t idx) {
747 assert(p);
748 assert(idx <= p->size);
749 assert(idx >= DNS_PACKET_HEADER_SIZE);
750
751 p->rindex = idx;
752}
753
754int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start) {
755 const void *q;
756 int r;
757
758 assert(p);
759 assert(d);
760
761 r = dns_packet_read(p, sz, &q, start);
762 if (r < 0)
763 return r;
764
765 memcpy(d, q, sz);
766 return 0;
767}
768
769int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start) {
770 const void *d;
771 int r;
772
773 assert(p);
774
775 r = dns_packet_read(p, sizeof(uint8_t), &d, start);
776 if (r < 0)
777 return r;
778
779 *ret = ((uint8_t*) d)[0];
780 return 0;
781}
782
783int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start) {
784 const void *d;
785 int r;
786
787 assert(p);
788
789 r = dns_packet_read(p, sizeof(uint16_t), &d, start);
790 if (r < 0)
791 return r;
792
793 *ret = unaligned_read_be16(d);
794
795 return 0;
796}
797
798int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start) {
799 const void *d;
800 int r;
801
802 assert(p);
803
804 r = dns_packet_read(p, sizeof(uint32_t), &d, start);
805 if (r < 0)
806 return r;
807
808 *ret = unaligned_read_be32(d);
809
810 return 0;
811}
812
813int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start) {
814 size_t saved_rindex;
815 const void *d;
816 char *t;
817 uint8_t c;
818 int r;
819
820 assert(p);
821
822 saved_rindex = p->rindex;
823
824 r = dns_packet_read_uint8(p, &c, NULL);
825 if (r < 0)
826 goto fail;
827
828 r = dns_packet_read(p, c, &d, NULL);
829 if (r < 0)
830 goto fail;
831
832 if (memchr(d, 0, c)) {
833 r = -EBADMSG;
834 goto fail;
835 }
836
837 t = strndup(d, c);
838 if (!t) {
839 r = -ENOMEM;
840 goto fail;
841 }
842
843 if (!utf8_is_valid(t)) {
844 free(t);
845 r = -EBADMSG;
846 goto fail;
847 }
848
849 *ret = t;
850
851 if (start)
852 *start = saved_rindex;
853
854 return 0;
855
856fail:
857 dns_packet_rewind(p, saved_rindex);
858 return r;
859}
860
861int dns_packet_read_name(DnsPacket *p, char **_ret,
862 bool allow_compression, size_t *start) {
863 size_t saved_rindex, after_rindex = 0, jump_barrier;
864 _cleanup_free_ char *ret = NULL;
865 size_t n = 0, allocated = 0;
866 bool first = true;
867 int r;
868
869 assert(p);
870 assert(_ret);
871
872 saved_rindex = p->rindex;
873 jump_barrier = p->rindex;
874
875 for (;;) {
876 uint8_t c, d;
877
878 r = dns_packet_read_uint8(p, &c, NULL);
879 if (r < 0)
880 goto fail;
881
882 if (c == 0)
883 /* End of name */
884 break;
885 else if (c <= 63) {
886 _cleanup_free_ char *t = NULL;
887 const char *label;
888
889 /* Literal label */
890 r = dns_packet_read(p, c, (const void**) &label, NULL);
891 if (r < 0)
892 goto fail;
893
894 r = dns_label_escape(label, c, &t);
895 if (r < 0)
896 goto fail;
897
898 if (!GREEDY_REALLOC(ret, allocated, n + !first + strlen(t) + 1)) {
899 r = -ENOMEM;
900 goto fail;
901 }
902
903 if (!first)
904 ret[n++] = '.';
905 else
906 first = false;
907
908 memcpy(ret + n, t, r);
909 n += r;
910 continue;
911 } else if (allow_compression && (c & 0xc0) == 0xc0) {
912 uint16_t ptr;
913
914 /* Pointer */
915 r = dns_packet_read_uint8(p, &d, NULL);
916 if (r < 0)
917 goto fail;
918
919 ptr = (uint16_t) (c & ~0xc0) << 8 | (uint16_t) d;
920 if (ptr < DNS_PACKET_HEADER_SIZE || ptr >= jump_barrier) {
921 r = -EBADMSG;
922 goto fail;
923 }
924
925 if (after_rindex == 0)
926 after_rindex = p->rindex;
927
928 /* Jumps are limited to a "prior occurence" (RFC-1035 4.1.4) */
929 jump_barrier = ptr;
930 p->rindex = ptr;
931 } else {
932 r = -EBADMSG;
933 goto fail;
934 }
935 }
936
937 if (!GREEDY_REALLOC(ret, allocated, n + 1)) {
938 r = -ENOMEM;
939 goto fail;
940 }
941
942 ret[n] = 0;
943
944 if (after_rindex != 0)
945 p->rindex= after_rindex;
946
947 *_ret = ret;
948 ret = NULL;
949
950 if (start)
951 *start = saved_rindex;
952
953 return 0;
954
955fail:
956 dns_packet_rewind(p, saved_rindex);
957 return r;
958}
959
960int dns_packet_read_key(DnsPacket *p, DnsResourceKey **ret, size_t *start) {
961 _cleanup_free_ char *name = NULL;
962 uint16_t class, type;
963 DnsResourceKey *key;
964 size_t saved_rindex;
965 int r;
966
967 assert(p);
968 assert(ret);
969
970 saved_rindex = p->rindex;
971
972 r = dns_packet_read_name(p, &name, true, NULL);
973 if (r < 0)
974 goto fail;
975
976 r = dns_packet_read_uint16(p, &type, NULL);
977 if (r < 0)
978 goto fail;
979
980 r = dns_packet_read_uint16(p, &class, NULL);
981 if (r < 0)
982 goto fail;
983
984 key = dns_resource_key_new_consume(class, type, name);
985 if (!key) {
986 r = -ENOMEM;
987 goto fail;
988 }
989
990 name = NULL;
991 *ret = key;
992
993 if (start)
994 *start = saved_rindex;
995
996 return 0;
997fail:
998 dns_packet_rewind(p, saved_rindex);
999 return r;
1000}
1001
1002static int dns_packet_read_public_key(DnsPacket *p, size_t length,
1003 void **dp, size_t *lengthp,
1004 size_t *start) {
1005 int r;
1006 const void *d;
1007 void *d2;
1008
1009 r = dns_packet_read(p, length, &d, NULL);
1010 if (r < 0)
1011 return r;
1012
1013 d2 = memdup(d, length);
1014 if (!d2)
1015 return -ENOMEM;
1016
1017 *dp = d2;
1018 *lengthp = length;
1019 return 0;
1020}
1021
1022static bool loc_size_ok(uint8_t size) {
1023 uint8_t m = size >> 4, e = size & 0xF;
1024
1025 return m <= 9 && e <= 9 && (m > 0 || e == 0);
1026}
1027
1028static int dnskey_parse_flags(DnsResourceRecord *rr, uint16_t flags) {
1029 assert(rr);
1030
1031 if (flags & ~(DNSKEY_FLAG_SEP | DNSKEY_FLAG_ZONE_KEY))
1032 return -EBADMSG;
1033
1034 rr->dnskey.zone_key_flag = flags & DNSKEY_FLAG_ZONE_KEY;
1035 rr->dnskey.sep_flag = flags & DNSKEY_FLAG_SEP;
1036 return 0;
1037}
1038
1039int dns_packet_read_rr(DnsPacket *p, DnsResourceRecord **ret, size_t *start) {
1040 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1041 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1042 size_t saved_rindex, offset;
1043 uint16_t rdlength;
1044 const void *d;
1045 int r;
1046
1047 assert(p);
1048 assert(ret);
1049
1050 saved_rindex = p->rindex;
1051
1052 r = dns_packet_read_key(p, &key, NULL);
1053 if (r < 0)
1054 goto fail;
1055
1056 if (key->class == DNS_CLASS_ANY ||
1057 key->type == DNS_TYPE_ANY) {
1058 r = -EBADMSG;
1059 goto fail;
1060 }
1061
1062 rr = dns_resource_record_new(key);
1063 if (!rr) {
1064 r = -ENOMEM;
1065 goto fail;
1066 }
1067
1068 r = dns_packet_read_uint32(p, &rr->ttl, NULL);
1069 if (r < 0)
1070 goto fail;
1071
1072 r = dns_packet_read_uint16(p, &rdlength, NULL);
1073 if (r < 0)
1074 goto fail;
1075
1076 if (p->rindex + rdlength > p->size) {
1077 r = -EBADMSG;
1078 goto fail;
1079 }
1080
1081 offset = p->rindex;
1082
1083 switch (rr->key->type) {
1084
1085 case DNS_TYPE_SRV:
1086 r = dns_packet_read_uint16(p, &rr->srv.priority, NULL);
1087 if (r < 0)
1088 goto fail;
1089 r = dns_packet_read_uint16(p, &rr->srv.weight, NULL);
1090 if (r < 0)
1091 goto fail;
1092 r = dns_packet_read_uint16(p, &rr->srv.port, NULL);
1093 if (r < 0)
1094 goto fail;
1095 r = dns_packet_read_name(p, &rr->srv.name, true, NULL);
1096 break;
1097
1098 case DNS_TYPE_PTR:
1099 case DNS_TYPE_NS:
1100 case DNS_TYPE_CNAME:
1101 case DNS_TYPE_DNAME:
1102 r = dns_packet_read_name(p, &rr->ptr.name, true, NULL);
1103 break;
1104
1105 case DNS_TYPE_HINFO:
1106 r = dns_packet_read_string(p, &rr->hinfo.cpu, NULL);
1107 if (r < 0)
1108 goto fail;
1109
1110 r = dns_packet_read_string(p, &rr->hinfo.os, NULL);
1111 break;
1112
1113 case DNS_TYPE_SPF: /* exactly the same as TXT */
1114 case DNS_TYPE_TXT: {
1115 char *s;
1116
1117 /* RFC 1035 says that TXT must be at least one
1118 string. Reject empty records. */
1119 if (!rdlength) {
1120 r = -EBADMSG;
1121 goto fail;
1122 }
1123
1124 while (p->rindex < offset + rdlength) {
1125 r = dns_packet_read_string(p, &s, NULL);
1126 if (r < 0)
1127 goto fail;
1128
1129 r = strv_consume(&rr->txt.strings, s);
1130 if (r < 0)
1131 goto fail;
1132 }
1133
1134 r = 0;
1135 break;
1136 }
1137
1138 case DNS_TYPE_A:
1139 r = dns_packet_read_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
1140 break;
1141
1142 case DNS_TYPE_AAAA:
1143 r = dns_packet_read_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
1144 break;
1145
1146 case DNS_TYPE_SOA:
1147 r = dns_packet_read_name(p, &rr->soa.mname, true, NULL);
1148 if (r < 0)
1149 goto fail;
1150
1151 r = dns_packet_read_name(p, &rr->soa.rname, true, NULL);
1152 if (r < 0)
1153 goto fail;
1154
1155 r = dns_packet_read_uint32(p, &rr->soa.serial, NULL);
1156 if (r < 0)
1157 goto fail;
1158
1159 r = dns_packet_read_uint32(p, &rr->soa.refresh, NULL);
1160 if (r < 0)
1161 goto fail;
1162
1163 r = dns_packet_read_uint32(p, &rr->soa.retry, NULL);
1164 if (r < 0)
1165 goto fail;
1166
1167 r = dns_packet_read_uint32(p, &rr->soa.expire, NULL);
1168 if (r < 0)
1169 goto fail;
1170
1171 r = dns_packet_read_uint32(p, &rr->soa.minimum, NULL);
1172 break;
1173
1174 case DNS_TYPE_MX:
1175 r = dns_packet_read_uint16(p, &rr->mx.priority, NULL);
1176 if (r < 0)
1177 goto fail;
1178
1179 r = dns_packet_read_name(p, &rr->mx.exchange, true, NULL);
1180 break;
1181
1182 case DNS_TYPE_LOC: {
1183 uint8_t t;
1184 size_t pos;
1185
1186 r = dns_packet_read_uint8(p, &t, &pos);
1187 if (r < 0)
1188 goto fail;
1189
1190 if (t == 0) {
1191 rr->loc.version = t;
1192
1193 r = dns_packet_read_uint8(p, &rr->loc.size, NULL);
1194 if (r < 0)
1195 goto fail;
1196
1197 if (!loc_size_ok(rr->loc.size)) {
1198 r = -EBADMSG;
1199 goto fail;
1200 }
1201
1202 r = dns_packet_read_uint8(p, &rr->loc.horiz_pre, NULL);
1203 if (r < 0)
1204 goto fail;
1205
1206 if (!loc_size_ok(rr->loc.horiz_pre)) {
1207 r = -EBADMSG;
1208 goto fail;
1209 }
1210
1211 r = dns_packet_read_uint8(p, &rr->loc.vert_pre, NULL);
1212 if (r < 0)
1213 goto fail;
1214
1215 if (!loc_size_ok(rr->loc.vert_pre)) {
1216 r = -EBADMSG;
1217 goto fail;
1218 }
1219
1220 r = dns_packet_read_uint32(p, &rr->loc.latitude, NULL);
1221 if (r < 0)
1222 goto fail;
1223
1224 r = dns_packet_read_uint32(p, &rr->loc.longitude, NULL);
1225 if (r < 0)
1226 goto fail;
1227
1228 r = dns_packet_read_uint32(p, &rr->loc.altitude, NULL);
1229 if (r < 0)
1230 goto fail;
1231
1232 break;
1233 } else {
1234 dns_packet_rewind(p, pos);
1235 rr->unparseable = true;
1236 goto unparseable;
1237 }
1238 }
1239
1240 case DNS_TYPE_SSHFP:
1241 r = dns_packet_read_uint8(p, &rr->sshfp.algorithm, NULL);
1242 if (r < 0)
1243 goto fail;
1244
1245 r = dns_packet_read_uint8(p, &rr->sshfp.fptype, NULL);
1246 if (r < 0)
1247 goto fail;
1248
1249 r = dns_packet_read_public_key(p, rdlength - 2,
1250 &rr->sshfp.key, &rr->sshfp.key_size,
1251 NULL);
1252 break;
1253
1254 case DNS_TYPE_DNSKEY: {
1255 uint16_t flags;
1256 uint8_t proto;
1257
1258 r = dns_packet_read_uint16(p, &flags, NULL);
1259 if (r < 0)
1260 goto fail;
1261
1262 r = dnskey_parse_flags(rr, flags);
1263 if (r < 0)
1264 goto fail;
1265
1266 r = dns_packet_read_uint8(p, &proto, NULL);
1267 if (r < 0)
1268 goto fail;
1269
1270 /* protocol is required to be always 3 */
1271 if (proto != 3) {
1272 r = -EBADMSG;
1273 goto fail;
1274 }
1275
1276 r = dns_packet_read_uint8(p, &rr->dnskey.algorithm, NULL);
1277 if (r < 0)
1278 goto fail;
1279
1280 r = dns_packet_read_public_key(p, rdlength - 4,
1281 &rr->dnskey.key, &rr->dnskey.key_size,
1282 NULL);
1283 break;
1284 }
1285
1286 case DNS_TYPE_RRSIG:
1287 r = dns_packet_read_uint16(p, &rr->rrsig.type_covered, NULL);
1288 if (r < 0)
1289 goto fail;
1290
1291 r = dns_packet_read_uint8(p, &rr->rrsig.algorithm, NULL);
1292 if (r < 0)
1293 goto fail;
1294
1295 r = dns_packet_read_uint8(p, &rr->rrsig.labels, NULL);
1296 if (r < 0)
1297 goto fail;
1298
1299 r = dns_packet_read_uint32(p, &rr->rrsig.original_ttl, NULL);
1300 if (r < 0)
1301 goto fail;
1302
1303 r = dns_packet_read_uint32(p, &rr->rrsig.expiration, NULL);
1304 if (r < 0)
1305 goto fail;
1306
1307 r = dns_packet_read_uint32(p, &rr->rrsig.inception, NULL);
1308 if (r < 0)
1309 goto fail;
1310
1311 r = dns_packet_read_uint16(p, &rr->rrsig.key_tag, NULL);
1312 if (r < 0)
1313 goto fail;
1314
1315 r = dns_packet_read_name(p, &rr->rrsig.signer, false, NULL);
1316 if (r < 0)
1317 goto fail;
1318
1319 r = dns_packet_read_public_key(p, offset + rdlength - p->rindex,
1320 &rr->rrsig.signature, &rr->rrsig.signature_size,
1321 NULL);
1322 break;
1323
1324 default:
1325 unparseable:
1326 r = dns_packet_read(p, rdlength, &d, NULL);
1327 if (r < 0)
1328 goto fail;
1329
1330 rr->generic.data = memdup(d, rdlength);
1331 if (!rr->generic.data) {
1332 r = -ENOMEM;
1333 goto fail;
1334 }
1335
1336 rr->generic.size = rdlength;
1337 break;
1338 }
1339 if (r < 0)
1340 goto fail;
1341 if (p->rindex != offset + rdlength) {
1342 r = -EBADMSG;
1343 goto fail;
1344 }
1345
1346 *ret = rr;
1347 rr = NULL;
1348
1349 if (start)
1350 *start = saved_rindex;
1351
1352 return 0;
1353fail:
1354 dns_packet_rewind(p, saved_rindex);
1355 return r;
1356}
1357
1358int dns_packet_extract(DnsPacket *p) {
1359 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
1360 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1361 size_t saved_rindex;
1362 unsigned n, i;
1363 int r;
1364
1365 if (p->extracted)
1366 return 0;
1367
1368 saved_rindex = p->rindex;
1369 dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
1370
1371 n = DNS_PACKET_QDCOUNT(p);
1372 if (n > 0) {
1373 question = dns_question_new(n);
1374 if (!question) {
1375 r = -ENOMEM;
1376 goto finish;
1377 }
1378
1379 for (i = 0; i < n; i++) {
1380 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1381
1382 r = dns_packet_read_key(p, &key, NULL);
1383 if (r < 0)
1384 goto finish;
1385
1386 r = dns_question_add(question, key);
1387 if (r < 0)
1388 goto finish;
1389 }
1390 }
1391
1392 n = DNS_PACKET_RRCOUNT(p);
1393 if (n > 0) {
1394 answer = dns_answer_new(n);
1395 if (!answer) {
1396 r = -ENOMEM;
1397 goto finish;
1398 }
1399
1400 for (i = 0; i < n; i++) {
1401 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1402
1403 r = dns_packet_read_rr(p, &rr, NULL);
1404 if (r < 0)
1405 goto finish;
1406
1407 r = dns_answer_add(answer, rr);
1408 if (r < 0)
1409 goto finish;
1410 }
1411 }
1412
1413 p->question = question;
1414 question = NULL;
1415
1416 p->answer = answer;
1417 answer = NULL;
1418
1419 p->extracted = true;
1420
1421 r = 0;
1422
1423finish:
1424 p->rindex = saved_rindex;
1425 return r;
1426}
1427
1428static const char* const dns_rcode_table[_DNS_RCODE_MAX_DEFINED] = {
1429 [DNS_RCODE_SUCCESS] = "SUCCESS",
1430 [DNS_RCODE_FORMERR] = "FORMERR",
1431 [DNS_RCODE_SERVFAIL] = "SERVFAIL",
1432 [DNS_RCODE_NXDOMAIN] = "NXDOMAIN",
1433 [DNS_RCODE_NOTIMP] = "NOTIMP",
1434 [DNS_RCODE_REFUSED] = "REFUSED",
1435 [DNS_RCODE_YXDOMAIN] = "YXDOMAIN",
1436 [DNS_RCODE_YXRRSET] = "YRRSET",
1437 [DNS_RCODE_NXRRSET] = "NXRRSET",
1438 [DNS_RCODE_NOTAUTH] = "NOTAUTH",
1439 [DNS_RCODE_NOTZONE] = "NOTZONE",
1440 [DNS_RCODE_BADVERS] = "BADVERS",
1441 [DNS_RCODE_BADKEY] = "BADKEY",
1442 [DNS_RCODE_BADTIME] = "BADTIME",
1443 [DNS_RCODE_BADMODE] = "BADMODE",
1444 [DNS_RCODE_BADNAME] = "BADNAME",
1445 [DNS_RCODE_BADALG] = "BADALG",
1446 [DNS_RCODE_BADTRUNC] = "BADTRUNC",
1447};
1448DEFINE_STRING_TABLE_LOOKUP(dns_rcode, int);
1449
1450static const char* const dns_protocol_table[_DNS_PROTOCOL_MAX] = {
1451 [DNS_PROTOCOL_DNS] = "dns",
1452 [DNS_PROTOCOL_MDNS] = "mdns",
1453 [DNS_PROTOCOL_LLMNR] = "llmnr",
1454};
1455DEFINE_STRING_TABLE_LOOKUP(dns_protocol, DnsProtocol);
1456
1457static const char* const dnssec_algorithm_table[_DNSSEC_ALGORITHM_MAX_DEFINED] = {
1458 [DNSSEC_ALGORITHM_RSAMD5] = "RSAMD5",
1459 [DNSSEC_ALGORITHM_DH] = "DH",
1460 [DNSSEC_ALGORITHM_DSA] = "DSA",
1461 [DNSSEC_ALGORITHM_ECC] = "ECC",
1462 [DNSSEC_ALGORITHM_RSASHA1] = "RSASHA1",
1463 [DNSSEC_ALGORITHM_INDIRECT] = "INDIRECT",
1464 [DNSSEC_ALGORITHM_PRIVATEDNS] = "PRIVATEDNS",
1465 [DNSSEC_ALGORITHM_PRIVATEOID] = "PRIVATEOID",
1466};
1467DEFINE_STRING_TABLE_LOOKUP(dnssec_algorithm, int);
Unnamed repository; edit this file 'description' to name the repository.