Debian Codegraph @

src/shared/dns-rr.c

raw
1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
2
3 #include "alloc-util.h"
4 #include "bitmap.h"
5 #include "dns-answer.h" /* IWYU pragma: keep */
6 #include "dns-domain.h"
7 #include "dns-packet.h"
8 #include "dns-rr.h"
9 #include "dns-type.h"
10 #include "escape.h"
11 #include "hash-funcs.h"
12 #include "hexdecoct.h"
13 #include "json-util.h"
14 #include "math-util.h"
15 #include "memory-util.h"
16 #include "siphash24.h"
17 #include "string-table.h"
18 #include "string-util.h"
19 #include "strv.h"
20 #include "terminal-util.h"
21 #include "time-util.h"
22 #include "unaligned.h"
23
24 DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name) {
25 DnsResourceKey *k;
26 size_t l;
27
28 assert(name);
29
30 l = strlen(name);
31 k = malloc0(sizeof(DnsResourceKey) + l + 1);
32 if (!k)
33 return NULL;
34
35 k->n_ref = 1;
36 k->class = class;
37 k->type = type;
38
39 strcpy((char*) k + sizeof(DnsResourceKey), name);
40
41 return k;
42 }
43
44 DnsResourceKey* dns_resource_key_new_redirect(const DnsResourceKey *key, const DnsResourceRecord *cname) {
45 int r;
46
47 assert(key);
48 assert(cname);
49
50 assert(IN_SET(cname->key->type, DNS_TYPE_CNAME, DNS_TYPE_DNAME));
51
52 if (cname->key->type == DNS_TYPE_CNAME)
53 return dns_resource_key_new(key->class, key->type, cname->cname.name);
54 else {
55 _cleanup_free_ char *destination = NULL;
56 DnsResourceKey *k;
57
58 r = dns_name_change_suffix(dns_resource_key_name(key), dns_resource_key_name(cname->key), cname->dname.name, &destination);
59 if (r < 0)
60 return NULL;
61 if (r == 0)
62 return dns_resource_key_ref((DnsResourceKey*) key);
63
64 k = dns_resource_key_new_consume(key->class, key->type, destination);
65 if (!k)
66 return NULL;
67
68 TAKE_PTR(destination);
69 return k;
70 }
71 }
72
73 int dns_resource_key_new_append_suffix(DnsResourceKey **ret, DnsResourceKey *key, char *name) {
74 DnsResourceKey *new_key;
75 char *joined;
76 int r;
77
78 assert(ret);
79 assert(key);
80 assert(name);
81
82 if (dns_name_is_root(name)) {
83 *ret = dns_resource_key_ref(key);
84 return 0;
85 }
86
87 r = dns_name_concat(dns_resource_key_name(key), name, 0, &joined);
88 if (r < 0)
89 return r;
90
91 new_key = dns_resource_key_new_consume(key->class, key->type, joined);
92 if (!new_key) {
93 free(joined);
94 return -ENOMEM;
95 }
96
97 *ret = new_key;
98 return 0;
99 }
100
101 DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name) {
102 DnsResourceKey *k;
103
104 assert(name);
105
106 k = new(DnsResourceKey, 1);
107 if (!k)
108 return NULL;
109
110 *k = (DnsResourceKey) {
111 .n_ref = 1,
112 .class = class,
113 .type = type,
114 ._name = name,
115 };
116
117 return k;
118 }
119
120 DnsResourceKey* dns_resource_key_ref(DnsResourceKey *k) {
121
122 if (!k)
123 return NULL;
124
125 /* Static/const keys created with DNS_RESOURCE_KEY_CONST will
126 * set this to -1, they should not be reffed/unreffed */
127 assert(k->n_ref != UINT_MAX);
128
129 assert(k->n_ref > 0);
130 k->n_ref++;
131
132 return k;
133 }
134
135 DnsResourceKey* dns_resource_key_unref(DnsResourceKey *k) {
136 if (!k)
137 return NULL;
138
139 assert(k->n_ref != UINT_MAX);
140 assert(k->n_ref > 0);
141
142 if (k->n_ref == 1) {
143 free(k->_name);
144 free(k);
145 } else
146 k->n_ref--;
147
148 return NULL;
149 }
150
151 const char* dns_resource_key_name(const DnsResourceKey *key) {
152 const char *name;
153
154 if (!key)
155 return NULL;
156
157 if (key->_name)
158 name = key->_name;
159 else
160 name = (char*) key + sizeof(DnsResourceKey);
161
162 if (dns_name_is_root(name))
163 return ".";
164 else
165 return name;
166 }
167
168 bool dns_resource_key_is_address(const DnsResourceKey *key) {
169 assert(key);
170
171 /* Check if this is an A or AAAA resource key */
172
173 return key->class == DNS_CLASS_IN && IN_SET(key->type, DNS_TYPE_A, DNS_TYPE_AAAA);
174 }
175
176 bool dns_resource_key_is_dnssd_ptr(const DnsResourceKey *key) {
177 assert(key);
178
179 /* Check if this is a PTR resource key used in
180 Service Instance Enumeration as described in RFC6763 p4.1. */
181
182 if (key->type != DNS_TYPE_PTR)
183 return false;
184
185 return dns_name_endswith(dns_resource_key_name(key), "_tcp.local") ||
186 dns_name_endswith(dns_resource_key_name(key), "_udp.local");
187 }
188
189 bool dns_resource_key_is_dnssd_two_label_ptr(const DnsResourceKey *key) {
190 assert(key);
191
192 /* Check if this is a PTR resource key used in Service Instance
193 * Enumeration as described in RFC6763 § 4.1, excluding selective
194 * service names described in RFC6763 § 7.1. */
195
196 if (key->type != DNS_TYPE_PTR)
197 return false;
198
199 const char *name = dns_resource_key_name(key);
200 if (dns_name_parent(&name) <= 0)
201 return false;
202
203 return dns_name_equal(name, "_tcp.local") > 0 || dns_name_equal(name, "_udp.local") > 0;
204 }
205
206 int dns_resource_key_equal(const DnsResourceKey *a, const DnsResourceKey *b) {
207 int r;
208
209 if (a == b)
210 return 1;
211
212 r = dns_name_equal(dns_resource_key_name(a), dns_resource_key_name(b));
213 if (r <= 0)
214 return r;
215
216 if (a->class != b->class)
217 return 0;
218
219 if (a->type != b->type)
220 return 0;
221
222 return 1;
223 }
224
225 int dns_resource_key_match_rr(const DnsResourceKey *key, DnsResourceRecord *rr, const char *search_domain) {
226 int r;
227
228 assert(key);
229 assert(rr);
230
231 if (key == rr->key)
232 return 1;
233
234 /* Checks if an rr matches the specified key. If a search
235 * domain is specified, it will also be checked if the key
236 * with the search domain suffixed might match the RR. */
237
238 if (rr->key->class != key->class && key->class != DNS_CLASS_ANY)
239 return 0;
240
241 if (rr->key->type != key->type && key->type != DNS_TYPE_ANY)
242 return 0;
243
244 r = dns_name_equal(dns_resource_key_name(rr->key), dns_resource_key_name(key));
245 if (r != 0)
246 return r;
247
248 if (search_domain) {
249 _cleanup_free_ char *joined = NULL;
250
251 r = dns_name_concat(dns_resource_key_name(key), search_domain, 0, &joined);
252 if (r < 0)
253 return r;
254
255 return dns_name_equal(dns_resource_key_name(rr->key), joined);
256 }
257
258 return 0;
259 }
260
261 int dns_resource_key_match_cname_or_dname(const DnsResourceKey *key, const DnsResourceKey *cname, const char *search_domain) {
262 int r;
263
264 assert(key);
265 assert(cname);
266
267 if (cname->class != key->class && key->class != DNS_CLASS_ANY)
268 return 0;
269
270 if (!dns_type_may_redirect(key->type))
271 return 0;
272
273 if (cname->type == DNS_TYPE_CNAME)
274 r = dns_name_equal(dns_resource_key_name(key), dns_resource_key_name(cname));
275 else if (cname->type == DNS_TYPE_DNAME)
276 r = dns_name_endswith(dns_resource_key_name(key), dns_resource_key_name(cname));
277 else
278 return 0;
279
280 if (r != 0)
281 return r;
282
283 if (search_domain) {
284 _cleanup_free_ char *joined = NULL;
285
286 r = dns_name_concat(dns_resource_key_name(key), search_domain, 0, &joined);
287 if (r < 0)
288 return r;
289
290 if (cname->type == DNS_TYPE_CNAME)
291 return dns_name_equal(joined, dns_resource_key_name(cname));
292 else if (cname->type == DNS_TYPE_DNAME)
293 return dns_name_endswith(joined, dns_resource_key_name(cname));
294 }
295
296 return 0;
297 }
298
299 int dns_resource_key_match_soa(const DnsResourceKey *key, const DnsResourceKey *soa) {
300 assert(soa);
301 assert(key);
302
303 /* Checks whether 'soa' is a SOA record for the specified key. */
304
305 if (soa->class != key->class)
306 return 0;
307
308 if (soa->type != DNS_TYPE_SOA)
309 return 0;
310
311 return dns_name_endswith(dns_resource_key_name(key), dns_resource_key_name(soa));
312 }
313
314 void dns_resource_key_hash_func(const DnsResourceKey *k, struct siphash *state) {
315 assert(k);
316
317 dns_name_hash_func(dns_resource_key_name(k), state);
318 siphash24_compress_typesafe(k->class, state);
319 siphash24_compress_typesafe(k->type, state);
320 }
321
322 int dns_resource_key_compare_func(const DnsResourceKey *x, const DnsResourceKey *y) {
323 int r;
324
325 r = dns_name_compare_func(dns_resource_key_name(x), dns_resource_key_name(y));
326 if (r != 0)
327 return r;
328
329 r = CMP(x->type, y->type);
330 if (r != 0)
331 return r;
332
333 return CMP(x->class, y->class);
334 }
335
336 DEFINE_HASH_OPS(dns_resource_key_hash_ops, DnsResourceKey, dns_resource_key_hash_func, dns_resource_key_compare_func);
337
338 char* dns_resource_key_to_string(const DnsResourceKey *key, char *buf, size_t buf_size) {
339 const char *c, *t;
340 char *ans = buf;
341
342 /* If we cannot convert the CLASS/TYPE into a known string,
343 use the format recommended by RFC 3597, Section 5. */
344
345 c = dns_class_to_string(key->class);
346 t = dns_type_to_string(key->type);
347
348 (void) snprintf(buf, buf_size, "%s %s%s%.0u %s%s%.0u",
349 dns_resource_key_name(key),
350 strempty(c), c ? "" : "CLASS", c ? 0u : key->class,
351 strempty(t), t ? "" : "TYPE", t ? 0u : key->type);
352
353 return ans;
354 }
355
356 bool dns_resource_key_reduce(DnsResourceKey **a, DnsResourceKey **b) {
357 assert(a);
358 assert(b);
359
360 /* Try to replace one RR key by another if they are identical, thus saving a bit of memory. Note that we do
361 * this only for RR keys, not for RRs themselves, as they carry a lot of additional metadata (where they come
362 * from, validity data, and suchlike), and cannot be replaced so easily by other RRs that have the same
363 * superficial data. */
364
365 if (!*a)
366 return false;
367 if (!*b)
368 return false;
369
370 /* We refuse merging const keys */
371 if ((*a)->n_ref == UINT_MAX)
372 return false;
373 if ((*b)->n_ref == UINT_MAX)
374 return false;
375
376 /* Already the same? */
377 if (*a == *b)
378 return true;
379
380 /* Are they really identical? */
381 if (dns_resource_key_equal(*a, *b) <= 0)
382 return false;
383
384 /* Keep the one which already has more references. */
385 if ((*a)->n_ref > (*b)->n_ref)
386 DNS_RESOURCE_KEY_REPLACE(*b, dns_resource_key_ref(*a));
387 else
388 DNS_RESOURCE_KEY_REPLACE(*a, dns_resource_key_ref(*b));
389
390 return true;
391 }
392
393 DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key) {
394 DnsResourceRecord *rr;
395
396 rr = new(DnsResourceRecord, 1);
397 if (!rr)
398 return NULL;
399
400 *rr = (DnsResourceRecord) {
401 .n_ref = 1,
402 .key = dns_resource_key_ref(key),
403 .expiry = USEC_INFINITY,
404 .n_skip_labels_signer = UINT8_MAX,
405 .n_skip_labels_source = UINT8_MAX,
406 };
407
408 return rr;
409 }
410
411 DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name) {
412 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
413
414 key = dns_resource_key_new(class, type, name);
415 if (!key)
416 return NULL;
417
418 return dns_resource_record_new(key);
419 }
420
421 static DnsResourceRecord* dns_resource_record_free(DnsResourceRecord *rr) {
422 assert(rr);
423
424 if (rr->key) {
425 switch (rr->key->type) {
426
427 case DNS_TYPE_SRV:
428 free(rr->srv.name);
429 break;
430
431 case DNS_TYPE_PTR:
432 case DNS_TYPE_NS:
433 case DNS_TYPE_CNAME:
434 case DNS_TYPE_DNAME:
435 free(rr->ptr.name);
436 break;
437
438 case DNS_TYPE_HINFO:
439 free(rr->hinfo.cpu);
440 free(rr->hinfo.os);
441 break;
442
443 case DNS_TYPE_TXT:
444 case DNS_TYPE_SPF:
445 dns_txt_item_free_all(rr->txt.items);
446 break;
447
448 case DNS_TYPE_SOA:
449 free(rr->soa.mname);
450 free(rr->soa.rname);
451 break;
452
453 case DNS_TYPE_MX:
454 free(rr->mx.exchange);
455 break;
456
457 case DNS_TYPE_DS:
458 free(rr->ds.digest);
459 break;
460
461 case DNS_TYPE_SSHFP:
462 free(rr->sshfp.fingerprint);
463 break;
464
465 case DNS_TYPE_DNSKEY:
466 free(rr->dnskey.key);
467 break;
468
469 case DNS_TYPE_RRSIG:
470 free(rr->rrsig.signer);
471 free(rr->rrsig.signature);
472 break;
473
474 case DNS_TYPE_NSEC:
475 free(rr->nsec.next_domain_name);
476 bitmap_free(rr->nsec.types);
477 break;
478
479 case DNS_TYPE_NSEC3:
480 free(rr->nsec3.next_hashed_name);
481 free(rr->nsec3.salt);
482 bitmap_free(rr->nsec3.types);
483 break;
484
485 case DNS_TYPE_LOC:
486 case DNS_TYPE_A:
487 case DNS_TYPE_AAAA:
488 break;
489
490 case DNS_TYPE_TLSA:
491 free(rr->tlsa.data);
492 break;
493
494 case DNS_TYPE_SVCB:
495 case DNS_TYPE_HTTPS:
496 free(rr->svcb.target_name);
497 dns_svc_param_free_all(rr->svcb.params);
498 break;
499
500 case DNS_TYPE_CAA:
501 free(rr->caa.tag);
502 free(rr->caa.value);
503 break;
504
505 case DNS_TYPE_NAPTR:
506 free(rr->naptr.flags);
507 free(rr->naptr.services);
508 free(rr->naptr.regexp);
509 free(rr->naptr.replacement);
510 break;
511
512 case DNS_TYPE_OPENPGPKEY:
513 default:
514 if (!rr->unparsable)
515 free(rr->generic.data);
516 }
517
518 if (rr->unparsable)
519 free(rr->generic.data);
520
521 free(rr->wire_format);
522 dns_resource_key_unref(rr->key);
523 }
524
525 free(rr->to_string);
526 return mfree(rr);
527 }
528
529 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsResourceRecord, dns_resource_record, dns_resource_record_free);
530
531 int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *hostname) {
532 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
533 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
534 _cleanup_free_ char *ptr = NULL;
535 int r;
536
537 assert(ret);
538 assert(address);
539 assert(hostname);
540
541 r = dns_name_reverse(family, address, &ptr);
542 if (r < 0)
543 return r;
544
545 key = dns_resource_key_new_consume(DNS_CLASS_IN, DNS_TYPE_PTR, ptr);
546 if (!key)
547 return -ENOMEM;
548
549 ptr = NULL;
550
551 rr = dns_resource_record_new(key);
552 if (!rr)
553 return -ENOMEM;
554
555 rr->ptr.name = strdup(hostname);
556 if (!rr->ptr.name)
557 return -ENOMEM;
558
559 *ret = TAKE_PTR(rr);
560
561 return 0;
562 }
563
564 int dns_resource_record_new_address(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *name) {
565 DnsResourceRecord *rr;
566
567 assert(ret);
568 assert(address);
569 assert(family);
570
571 if (family == AF_INET) {
572
573 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_A, name);
574 if (!rr)
575 return -ENOMEM;
576
577 rr->a.in_addr = address->in;
578
579 } else if (family == AF_INET6) {
580
581 rr = dns_resource_record_new_full(DNS_CLASS_IN, DNS_TYPE_AAAA, name);
582 if (!rr)
583 return -ENOMEM;
584
585 rr->aaaa.in6_addr = address->in6;
586 } else
587 return -EAFNOSUPPORT;
588
589 *ret = rr;
590
591 return 0;
592 }
593
594 #define FIELD_EQUAL(a, b, field) \
595 ((a).field ## _size == (b).field ## _size && \
596 memcmp_safe((a).field, (b).field, (a).field ## _size) == 0)
597
598 int dns_resource_record_payload_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
599 int r;
600
601 /* Check if a and b are the same, but don't look at their keys */
602
603 if (a->unparsable != b->unparsable)
604 return 0;
605
606 switch (a->unparsable ? _DNS_TYPE_INVALID : a->key->type) {
607
608 case DNS_TYPE_SRV:
609 r = dns_name_equal(a->srv.name, b->srv.name);
610 if (r <= 0)
611 return r;
612
613 return a->srv.priority == b->srv.priority &&
614 a->srv.weight == b->srv.weight &&
615 a->srv.port == b->srv.port;
616
617 case DNS_TYPE_PTR:
618 case DNS_TYPE_NS:
619 case DNS_TYPE_CNAME:
620 case DNS_TYPE_DNAME:
621 return dns_name_equal(a->ptr.name, b->ptr.name);
622
623 case DNS_TYPE_HINFO:
624 return strcaseeq(a->hinfo.cpu, b->hinfo.cpu) &&
625 strcaseeq(a->hinfo.os, b->hinfo.os);
626
627 case DNS_TYPE_SPF: /* exactly the same as TXT */
628 case DNS_TYPE_TXT:
629 return dns_txt_item_equal(a->txt.items, b->txt.items);
630
631 case DNS_TYPE_A:
632 return memcmp(&a->a.in_addr, &b->a.in_addr, sizeof(struct in_addr)) == 0;
633
634 case DNS_TYPE_AAAA:
635 return memcmp(&a->aaaa.in6_addr, &b->aaaa.in6_addr, sizeof(struct in6_addr)) == 0;
636
637 case DNS_TYPE_SOA:
638 r = dns_name_equal(a->soa.mname, b->soa.mname);
639 if (r <= 0)
640 return r;
641 r = dns_name_equal(a->soa.rname, b->soa.rname);
642 if (r <= 0)
643 return r;
644
645 return a->soa.serial == b->soa.serial &&
646 a->soa.refresh == b->soa.refresh &&
647 a->soa.retry == b->soa.retry &&
648 a->soa.expire == b->soa.expire &&
649 a->soa.minimum == b->soa.minimum;
650
651 case DNS_TYPE_MX:
652 if (a->mx.priority != b->mx.priority)
653 return 0;
654
655 return dns_name_equal(a->mx.exchange, b->mx.exchange);
656
657 case DNS_TYPE_LOC:
658 assert(a->loc.version == b->loc.version);
659
660 return a->loc.size == b->loc.size &&
661 a->loc.horiz_pre == b->loc.horiz_pre &&
662 a->loc.vert_pre == b->loc.vert_pre &&
663 a->loc.latitude == b->loc.latitude &&
664 a->loc.longitude == b->loc.longitude &&
665 a->loc.altitude == b->loc.altitude;
666
667 case DNS_TYPE_DS:
668 return a->ds.key_tag == b->ds.key_tag &&
669 a->ds.algorithm == b->ds.algorithm &&
670 a->ds.digest_type == b->ds.digest_type &&
671 FIELD_EQUAL(a->ds, b->ds, digest);
672
673 case DNS_TYPE_SSHFP:
674 return a->sshfp.algorithm == b->sshfp.algorithm &&
675 a->sshfp.fptype == b->sshfp.fptype &&
676 FIELD_EQUAL(a->sshfp, b->sshfp, fingerprint);
677
678 case DNS_TYPE_DNSKEY:
679 return a->dnskey.flags == b->dnskey.flags &&
680 a->dnskey.protocol == b->dnskey.protocol &&
681 a->dnskey.algorithm == b->dnskey.algorithm &&
682 FIELD_EQUAL(a->dnskey, b->dnskey, key);
683
684 case DNS_TYPE_RRSIG:
685 /* do the fast comparisons first */
686 if (!(a->rrsig.type_covered == b->rrsig.type_covered &&
687 a->rrsig.algorithm == b->rrsig.algorithm &&
688 a->rrsig.labels == b->rrsig.labels &&
689 a->rrsig.original_ttl == b->rrsig.original_ttl &&
690 a->rrsig.expiration == b->rrsig.expiration &&
691 a->rrsig.inception == b->rrsig.inception &&
692 a->rrsig.key_tag == b->rrsig.key_tag &&
693 FIELD_EQUAL(a->rrsig, b->rrsig, signature)))
694 return false;
695
696 return dns_name_equal(a->rrsig.signer, b->rrsig.signer);
697
698 case DNS_TYPE_NSEC:
699 r = dns_name_equal(a->nsec.next_domain_name, b->nsec.next_domain_name);
700 if (r <= 0)
701 return r;
702
703 return bitmap_equal(a->nsec.types, b->nsec.types);
704
705 case DNS_TYPE_NSEC3:
706 return a->nsec3.algorithm == b->nsec3.algorithm &&
707 a->nsec3.flags == b->nsec3.flags &&
708 a->nsec3.iterations == b->nsec3.iterations &&
709 FIELD_EQUAL(a->nsec3, b->nsec3, salt) &&
710 FIELD_EQUAL(a->nsec3, b->nsec3, next_hashed_name) &&
711 bitmap_equal(a->nsec3.types, b->nsec3.types);
712
713 case DNS_TYPE_TLSA:
714 return a->tlsa.cert_usage == b->tlsa.cert_usage &&
715 a->tlsa.selector == b->tlsa.selector &&
716 a->tlsa.matching_type == b->tlsa.matching_type &&
717 FIELD_EQUAL(a->tlsa, b->tlsa, data);
718
719 case DNS_TYPE_SVCB:
720 case DNS_TYPE_HTTPS:
721
722 if (!(a->svcb.priority == b->svcb.priority &&
723 dns_svc_params_equal(a->svcb.params, b->svcb.params)))
724 return false;
725
726 return dns_name_equal(a->svcb.target_name, b->svcb.target_name);
727
728 case DNS_TYPE_CAA:
729 return a->caa.flags == b->caa.flags &&
730 streq(a->caa.tag, b->caa.tag) &&
731 FIELD_EQUAL(a->caa, b->caa, value);
732
733 case DNS_TYPE_NAPTR:
734 r = dns_name_equal(a->naptr.replacement, b->naptr.replacement);
735 if (r <= 0)
736 return r;
737
738 return a->naptr.order == b->naptr.order &&
739 a->naptr.preference == b->naptr.preference &&
740 streq(a->naptr.flags, b->naptr.flags) &&
741 streq(a->naptr.services, b->naptr.services) &&
742 streq(a->naptr.regexp, b->naptr.regexp);
743
744 case DNS_TYPE_OPENPGPKEY:
745 default:
746 return FIELD_EQUAL(a->generic, b->generic, data);
747 }
748 }
749
750 int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b) {
751 int r;
752
753 assert(a);
754 assert(b);
755
756 if (a == b)
757 return 1;
758
759 r = dns_resource_key_equal(a->key, b->key);
760 if (r <= 0)
761 return r;
762
763 return dns_resource_record_payload_equal(a, b);
764 }
765
766 static char* format_location(uint32_t latitude, uint32_t longitude, uint32_t altitude,
767 uint8_t size, uint8_t horiz_pre, uint8_t vert_pre) {
768 char *s;
769 char NS = latitude >= 1U<<31 ? 'N' : 'S';
770 char EW = longitude >= 1U<<31 ? 'E' : 'W';
771
772 int lat = latitude >= 1U<<31 ? (int) (latitude - (1U<<31)) : (int) ((1U<<31) - latitude);
773 int lon = longitude >= 1U<<31 ? (int) (longitude - (1U<<31)) : (int) ((1U<<31) - longitude);
774 double alt = altitude >= 10000000u ? altitude - 10000000u : -(double)(10000000u - altitude);
775 double siz = (size >> 4) * xexp10i(size & 0xF);
776 double hor = (horiz_pre >> 4) * xexp10i(horiz_pre & 0xF);
777 double ver = (vert_pre >> 4) * xexp10i(vert_pre & 0xF);
778
779 if (asprintf(&s, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
780 (lat / 60000 / 60),
781 (lat / 60000) % 60,
782 (lat % 60000) / 1000.,
783 NS,
784 (lon / 60000 / 60),
785 (lon / 60000) % 60,
786 (lon % 60000) / 1000.,
787 EW,
788 alt / 100.,
789 siz / 100.,
790 hor / 100.,
791 ver / 100.) < 0)
792 return NULL;
793
794 return s;
795 }
796
797 static int format_timestamp_dns(char *buf, size_t l, time_t sec) {
798 struct tm tm;
799 int r;
800
801 assert(buf);
802 assert(l > STRLEN("YYYYMMDDHHmmSS"));
803
804 r = localtime_or_gmtime_usec(sec * USEC_PER_SEC, /* utc= */ true, &tm);
805 if (r < 0)
806 return r;
807
808 if (strftime(buf, l, "%Y%m%d%H%M%S", &tm) <= 0)
809 return -EINVAL;
810
811 return 0;
812 }
813
814 static char *format_types(Bitmap *types) {
815 _cleanup_strv_free_ char **strv = NULL;
816 _cleanup_free_ char *str = NULL;
817 unsigned type;
818 int r;
819
820 BITMAP_FOREACH(type, types) {
821 if (dns_type_to_string(type))
822 r = strv_extend(&strv, dns_type_to_string(type));
823 else
824 r = strv_extendf(&strv, "TYPE%u", type);
825 if (r < 0)
826 return NULL;
827 }
828
829 str = strv_join(strv, " ");
830 if (!str)
831 return NULL;
832
833 return strjoin("( ", str, " )");
834 }
835
836 static char *format_txt(DnsTxtItem *first) {
837 size_t c = 1;
838 char *p, *s;
839
840 LIST_FOREACH(items, i, first)
841 c += i->length * 4 + 3;
842
843 p = s = new(char, c);
844 if (!s)
845 return NULL;
846
847 LIST_FOREACH(items, i, first) {
848 if (i != first)
849 *(p++) = ' ';
850
851 *(p++) = '"';
852
853 for (size_t j = 0; j < i->length; j++) {
854 if (i->data[j] < ' ' || i->data[j] == '"' || i->data[j] >= 127) {
855 *(p++) = '\\';
856 *(p++) = '0' + (i->data[j] / 100);
857 *(p++) = '0' + ((i->data[j] / 10) % 10);
858 *(p++) = '0' + (i->data[j] % 10);
859 } else
860 *(p++) = i->data[j];
861 }
862
863 *(p++) = '"';
864 }
865
866 *p = 0;
867 return s;
868 }
869
870 static char *format_svc_param_value(DnsSvcParam *i) {
871 _cleanup_free_ char *value = NULL;
872
873 assert(i);
874
875 switch (i->key) {
876 case DNS_SVC_PARAM_KEY_ALPN: {
877 size_t offset = 0;
878 _cleanup_strv_free_ char **values_strv = NULL;
879 while (offset < i->length) {
880 size_t sz = i->value[offset++];
881
882 char *alpn = cescape_length((char *)&i->value[offset], sz);
883 if (!alpn)
884 return NULL;
885
886 if (strv_push(&values_strv, alpn) < 0)
887 return NULL;
888
889 offset += sz;
890 }
891 value = strv_join(values_strv, ",");
892 if (!value)
893 return NULL;
894 break;
895
896 }
897 case DNS_SVC_PARAM_KEY_PORT: {
898 uint16_t port = unaligned_read_be16(i->value);
899 if (asprintf(&value, "%" PRIu16, port) < 0)
900 return NULL;
901 return TAKE_PTR(value);
902 }
903 case DNS_SVC_PARAM_KEY_IPV4HINT: {
904 const struct in_addr *addrs = i->value_in_addr;
905 _cleanup_strv_free_ char **values_strv = NULL;
906 for (size_t n = 0; n < i->length / sizeof (struct in_addr); n++) {
907 char *addr;
908 if (in_addr_to_string(AF_INET, (const union in_addr_union*) &addrs[n], &addr) < 0)
909 return NULL;
910 if (strv_push(&values_strv, addr) < 0)
911 return NULL;
912 }
913 return strv_join(values_strv, ",");
914 }
915 case DNS_SVC_PARAM_KEY_IPV6HINT: {
916 const struct in6_addr *addrs = i->value_in6_addr;
917 _cleanup_strv_free_ char **values_strv = NULL;
918 for (size_t n = 0; n < i->length / sizeof (struct in6_addr); n++) {
919 char *addr;
920 if (in_addr_to_string(AF_INET6, (const union in_addr_union*) &addrs[n], &addr) < 0)
921 return NULL;
922 if (strv_push(&values_strv, addr) < 0)
923 return NULL;
924 }
925 return strv_join(values_strv, ",");
926 }
927 default:
928 value = decescape((char*) &i->value, i->length, " ,");
929 if (!value)
930 return NULL;
931 }
932
933 char *qvalue;
934 if (asprintf(&qvalue, "\"%s\"", value) < 0)
935 return NULL;
936 return qvalue;
937 }
938
939 static char *format_svc_param(DnsSvcParam *i) {
940 const char *key = FORMAT_DNS_SVC_PARAM_KEY(i->key);
941 _cleanup_free_ char *value = NULL;
942
943 assert(i);
944
945 if (i->length == 0)
946 return strdup(key);
947
948 value = format_svc_param_value(i);
949 if (!value)
950 return NULL;
951
952 return strjoin(key, "=", value);
953 }
954
955 static char *format_svc_params(DnsSvcParam *first) {
956 _cleanup_strv_free_ char **params = NULL;
957
958 LIST_FOREACH(params, i, first) {
959 char *param = format_svc_param(i);
960 if (!param)
961 return NULL;
962 if (strv_push(&params, param) < 0)
963 return NULL;
964 }
965
966 return strv_join(params, " ");
967 }
968
969 uint16_t dnssec_keytag(DnsResourceRecord *dnskey, bool mask_revoke) {
970 const uint8_t *p;
971 uint32_t sum, f;
972
973 /* The algorithm from RFC 4034, Appendix B. */
974
975 assert(dnskey);
976 assert(dnskey->key->type == DNS_TYPE_DNSKEY);
977
978 f = (uint32_t) dnskey->dnskey.flags;
979
980 if (mask_revoke)
981 f &= ~DNSKEY_FLAG_REVOKE;
982
983 sum = f + ((((uint32_t) dnskey->dnskey.protocol) << 8) + (uint32_t) dnskey->dnskey.algorithm);
984
985 p = dnskey->dnskey.key;
986
987 for (size_t i = 0; i < dnskey->dnskey.key_size; i++)
988 sum += (i & 1) == 0 ? (uint32_t) p[i] << 8 : (uint32_t) p[i];
989
990 sum += (sum >> 16) & UINT32_C(0xFFFF);
991
992 return sum & UINT32_C(0xFFFF);
993 }
994
995 const char* dns_resource_record_to_string(DnsResourceRecord *rr) {
996 _cleanup_free_ char *s = NULL, *t = NULL;
997 char k[DNS_RESOURCE_KEY_STRING_MAX];
998 int r;
999
1000 assert(rr);
1001
1002 if (rr->to_string)
1003 return rr->to_string;
1004
1005 dns_resource_key_to_string(rr->key, k, sizeof(k));
1006
1007 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
1008
1009 case DNS_TYPE_SRV:
1010 r = asprintf(&s, "%s %u %u %u %s",
1011 k,
1012 rr->srv.priority,
1013 rr->srv.weight,
1014 rr->srv.port,
1015 strna(rr->srv.name));
1016 if (r < 0)
1017 return NULL;
1018 break;
1019
1020 case DNS_TYPE_PTR:
1021 case DNS_TYPE_NS:
1022 case DNS_TYPE_CNAME:
1023 case DNS_TYPE_DNAME:
1024 s = strjoin(k, " ", rr->ptr.name);
1025 if (!s)
1026 return NULL;
1027
1028 break;
1029
1030 case DNS_TYPE_HINFO:
1031 s = strjoin(k, " ", rr->hinfo.cpu, " ", rr->hinfo.os);
1032 if (!s)
1033 return NULL;
1034 break;
1035
1036 case DNS_TYPE_SPF: /* exactly the same as TXT */
1037 case DNS_TYPE_TXT:
1038 t = format_txt(rr->txt.items);
1039 if (!t)
1040 return NULL;
1041
1042 s = strjoin(k, " ", t);
1043 if (!s)
1044 return NULL;
1045 break;
1046
1047 case DNS_TYPE_A:
1048 r = in_addr_to_string(AF_INET, (const union in_addr_union*) &rr->a.in_addr, &t);
1049 if (r < 0)
1050 return NULL;
1051
1052 s = strjoin(k, " ", t);
1053 if (!s)
1054 return NULL;
1055 break;
1056
1057 case DNS_TYPE_AAAA:
1058 r = in_addr_to_string(AF_INET6, (const union in_addr_union*) &rr->aaaa.in6_addr, &t);
1059 if (r < 0)
1060 return NULL;
1061
1062 s = strjoin(k, " ", t);
1063 if (!s)
1064 return NULL;
1065 break;
1066
1067 case DNS_TYPE_SOA:
1068 r = asprintf(&s, "%s %s %s %u %u %u %u %u",
1069 k,
1070 strna(rr->soa.mname),
1071 strna(rr->soa.rname),
1072 rr->soa.serial,
1073 rr->soa.refresh,
1074 rr->soa.retry,
1075 rr->soa.expire,
1076 rr->soa.minimum);
1077 if (r < 0)
1078 return NULL;
1079 break;
1080
1081 case DNS_TYPE_MX:
1082 r = asprintf(&s, "%s %u %s",
1083 k,
1084 rr->mx.priority,
1085 rr->mx.exchange);
1086 if (r < 0)
1087 return NULL;
1088 break;
1089
1090 case DNS_TYPE_LOC:
1091 assert(rr->loc.version == 0);
1092
1093 t = format_location(rr->loc.latitude,
1094 rr->loc.longitude,
1095 rr->loc.altitude,
1096 rr->loc.size,
1097 rr->loc.horiz_pre,
1098 rr->loc.vert_pre);
1099 if (!t)
1100 return NULL;
1101
1102 s = strjoin(k, " ", t);
1103 if (!s)
1104 return NULL;
1105 break;
1106
1107 case DNS_TYPE_DS:
1108 t = hexmem(rr->ds.digest, rr->ds.digest_size);
1109 if (!t)
1110 return NULL;
1111
1112 r = asprintf(&s, "%s %u %u %u %s",
1113 k,
1114 rr->ds.key_tag,
1115 rr->ds.algorithm,
1116 rr->ds.digest_type,
1117 t);
1118 if (r < 0)
1119 return NULL;
1120 break;
1121
1122 case DNS_TYPE_SSHFP: {
1123 _cleanup_free_ char *alg = NULL, *key_type = NULL;
1124
1125 t = hexmem(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size);
1126 if (!t)
1127 return NULL;
1128
1129 r = sshfp_algorithm_to_string_alloc(rr->sshfp.algorithm, &alg);
1130 if (r < 0)
1131 return NULL;
1132
1133 r = sshfp_key_type_to_string_alloc(rr->sshfp.fptype, &key_type);
1134 if (r < 0)
1135 return NULL;
1136
1137 r = asprintf(&s, "%s "SSHFP_ALGORITHM_FMT" "SSHFP_KEY_TYPE_FMT" %s",
1138 k, alg, key_type, t);
1139 if (r < 0)
1140 return NULL;
1141 break;
1142 }
1143
1144 case DNS_TYPE_DNSKEY: {
1145 _cleanup_free_ char *alg = NULL;
1146 uint16_t key_tag;
1147
1148 key_tag = dnssec_keytag(rr, true);
1149
1150 r = dnssec_algorithm_to_string_alloc(rr->dnskey.algorithm, &alg);
1151 if (r < 0)
1152 return NULL;
1153
1154 r = asprintf(&t, "%s %u %u %s",
1155 k,
1156 rr->dnskey.flags,
1157 rr->dnskey.protocol,
1158 alg);
1159 if (r < 0)
1160 return NULL;
1161
1162 r = base64_append(&t, r,
1163 rr->dnskey.key, rr->dnskey.key_size,
1164 8, columns());
1165 if (r < 0)
1166 return NULL;
1167
1168 r = asprintf(&s, "%s\n"
1169 " -- Flags:%s%s%s\n"
1170 " -- Key tag: %u",
1171 t,
1172 rr->dnskey.flags & DNSKEY_FLAG_SEP ? " SEP" : "",
1173 rr->dnskey.flags & DNSKEY_FLAG_REVOKE ? " REVOKE" : "",
1174 rr->dnskey.flags & DNSKEY_FLAG_ZONE_KEY ? " ZONE_KEY" : "",
1175 key_tag);
1176 if (r < 0)
1177 return NULL;
1178
1179 break;
1180 }
1181
1182 case DNS_TYPE_RRSIG: {
1183 _cleanup_free_ char *alg = NULL;
1184 char expiration[STRLEN("YYYYMMDDHHmmSS") + 1], inception[STRLEN("YYYYMMDDHHmmSS") + 1];
1185 const char *type;
1186
1187 type = dns_type_to_string(rr->rrsig.type_covered);
1188
1189 r = dnssec_algorithm_to_string_alloc(rr->rrsig.algorithm, &alg);
1190 if (r < 0)
1191 return NULL;
1192
1193 r = format_timestamp_dns(expiration, sizeof(expiration), rr->rrsig.expiration);
1194 if (r < 0)
1195 return NULL;
1196
1197 r = format_timestamp_dns(inception, sizeof(inception), rr->rrsig.inception);
1198 if (r < 0)
1199 return NULL;
1200
1201 /* TYPE?? follows
1202 * http://tools.ietf.org/html/rfc3597#section-5 */
1203
1204 r = asprintf(&s, "%s %s%.*u %s %u %u %s %s %u %s",
1205 k,
1206 type ?: "TYPE",
1207 type ? 0 : 1, type ? 0u : (unsigned) rr->rrsig.type_covered,
1208 alg,
1209 rr->rrsig.labels,
1210 rr->rrsig.original_ttl,
1211 expiration,
1212 inception,
1213 rr->rrsig.key_tag,
1214 rr->rrsig.signer);
1215 if (r < 0)
1216 return NULL;
1217
1218 r = base64_append(&s, r,
1219 rr->rrsig.signature, rr->rrsig.signature_size,
1220 8, columns());
1221 if (r < 0)
1222 return NULL;
1223
1224 break;
1225 }
1226
1227 case DNS_TYPE_NSEC:
1228 t = format_types(rr->nsec.types);
1229 if (!t)
1230 return NULL;
1231
1232 r = asprintf(&s, "%s %s %s",
1233 k,
1234 rr->nsec.next_domain_name,
1235 t);
1236 if (r < 0)
1237 return NULL;
1238 break;
1239
1240 case DNS_TYPE_NSEC3: {
1241 _cleanup_free_ char *salt = NULL, *hash = NULL;
1242
1243 if (rr->nsec3.salt_size > 0) {
1244 salt = hexmem(rr->nsec3.salt, rr->nsec3.salt_size);
1245 if (!salt)
1246 return NULL;
1247 }
1248
1249 hash = base32hexmem(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size, false);
1250 if (!hash)
1251 return NULL;
1252
1253 t = format_types(rr->nsec3.types);
1254 if (!t)
1255 return NULL;
1256
1257 r = asprintf(&s, "%s %"PRIu8" %"PRIu8" %"PRIu16" %s %s %s",
1258 k,
1259 rr->nsec3.algorithm,
1260 rr->nsec3.flags,
1261 rr->nsec3.iterations,
1262 rr->nsec3.salt_size > 0 ? salt : "-",
1263 hash,
1264 t);
1265 if (r < 0)
1266 return NULL;
1267
1268 break;
1269 }
1270
1271 case DNS_TYPE_TLSA:
1272 t = hexmem(rr->tlsa.data, rr->tlsa.data_size);
1273 if (!t)
1274 return NULL;
1275
1276 r = asprintf(&s,
1277 "%s %u %u %u %s\n"
1278 " -- Cert. usage: %s\n"
1279 " -- Selector: %s\n"
1280 " -- Matching type: %s",
1281 k,
1282 rr->tlsa.cert_usage,
1283 rr->tlsa.selector,
1284 rr->tlsa.matching_type,
1285 t,
1286 tlsa_cert_usage_to_string(rr->tlsa.cert_usage),
1287 tlsa_selector_to_string(rr->tlsa.selector),
1288 tlsa_matching_type_to_string(rr->tlsa.matching_type));
1289 if (r < 0)
1290 return NULL;
1291
1292 break;
1293
1294 case DNS_TYPE_CAA:
1295 t = octescape(rr->caa.value, rr->caa.value_size);
1296 if (!t)
1297 return NULL;
1298
1299 r = asprintf(&s, "%s %u %s \"%s\"%s%s%s%.0u",
1300 k,
1301 rr->caa.flags,
1302 rr->caa.tag,
1303 t,
1304 rr->caa.flags ? "\n -- Flags:" : "",
1305 rr->caa.flags & CAA_FLAG_CRITICAL ? " critical" : "",
1306 rr->caa.flags & ~CAA_FLAG_CRITICAL ? " " : "",
1307 rr->caa.flags & ~CAA_FLAG_CRITICAL);
1308 if (r < 0)
1309 return NULL;
1310
1311 break;
1312
1313 case DNS_TYPE_SVCB:
1314 case DNS_TYPE_HTTPS:
1315 t = format_svc_params(rr->svcb.params);
1316 if (!t)
1317 return NULL;
1318 r = asprintf(&s, "%s %d %s %s", k, rr->svcb.priority,
1319 isempty(rr->svcb.target_name) ? "." : rr->svcb.target_name,
1320 t);
1321 if (r < 0)
1322 return NULL;
1323
1324 break;
1325
1326 case DNS_TYPE_OPENPGPKEY:
1327 r = asprintf(&s, "%s", k);
1328 if (r < 0)
1329 return NULL;
1330
1331 r = base64_append(&s, r,
1332 rr->generic.data, rr->generic.data_size,
1333 8, columns());
1334 if (r < 0)
1335 return NULL;
1336 break;
1337
1338 case DNS_TYPE_NAPTR: {
1339 _cleanup_free_ char *tt = NULL, *ttt = NULL;
1340
1341 t = octescape(rr->naptr.flags, SIZE_MAX);
1342 if (!t)
1343 return NULL;
1344
1345 tt = octescape(rr->naptr.services, SIZE_MAX);
1346 if (!tt)
1347 return NULL;
1348
1349 ttt = octescape(rr->naptr.regexp, SIZE_MAX);
1350 if (!ttt)
1351 return NULL;
1352
1353 if (asprintf(&s, "%" PRIu16 " %" PRIu16 " \"%s\" \"%s\" \"%s\" %s.",
1354 rr->naptr.order,
1355 rr->naptr.preference,
1356 t,
1357 tt,
1358 ttt,
1359 rr->naptr.replacement) < 0)
1360 return NULL;
1361 break;
1362 }
1363 default:
1364 /* Format as documented in RFC 3597, Section 5 */
1365 if (rr->generic.data_size == 0)
1366 r = asprintf(&s, "%s \\# 0", k);
1367 else {
1368 t = hexmem(rr->generic.data, rr->generic.data_size);
1369 if (!t)
1370 return NULL;
1371 r = asprintf(&s, "%s \\# %zu %s", k, rr->generic.data_size, t);
1372 }
1373 if (r < 0)
1374 return NULL;
1375 }
1376
1377 rr->to_string = s;
1378 return TAKE_PTR(s);
1379 }
1380
1381 ssize_t dns_resource_record_payload(DnsResourceRecord *rr, const void **ret) {
1382 assert(rr);
1383 assert(ret);
1384
1385 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
1386 case DNS_TYPE_SRV:
1387 case DNS_TYPE_PTR:
1388 case DNS_TYPE_NS:
1389 case DNS_TYPE_CNAME:
1390 case DNS_TYPE_DNAME:
1391 case DNS_TYPE_HINFO:
1392 case DNS_TYPE_SPF:
1393 case DNS_TYPE_TXT:
1394 case DNS_TYPE_SOA:
1395 case DNS_TYPE_MX:
1396 case DNS_TYPE_LOC:
1397 case DNS_TYPE_DS:
1398 case DNS_TYPE_DNSKEY:
1399 case DNS_TYPE_RRSIG:
1400 case DNS_TYPE_NSEC:
1401 case DNS_TYPE_NSEC3:
1402 return -EINVAL;
1403
1404 case DNS_TYPE_A:
1405 *ret = &rr->a.in_addr;
1406 return sizeof(rr->a.in_addr);
1407
1408 case DNS_TYPE_AAAA:
1409 *ret = &rr->aaaa.in6_addr;
1410 return sizeof(rr->aaaa.in6_addr);
1411
1412 case DNS_TYPE_SSHFP:
1413 *ret = rr->sshfp.fingerprint;
1414 return rr->sshfp.fingerprint_size;
1415
1416 case DNS_TYPE_TLSA:
1417 *ret = rr->tlsa.data;
1418 return rr->tlsa.data_size;
1419
1420 case DNS_TYPE_OPENPGPKEY:
1421 default:
1422 *ret = rr->generic.data;
1423 return rr->generic.data_size;
1424 }
1425 }
1426
1427 int dns_resource_record_to_wire_format(DnsResourceRecord *rr, bool canonical) {
1428
1429 _cleanup_(dns_packet_unref) DnsPacket packet = {
1430 .n_ref = 1,
1431 .protocol = DNS_PROTOCOL_DNS,
1432 .on_stack = true,
1433 .refuse_compression = true,
1434 .canonical_form = canonical,
1435 };
1436
1437 size_t start, rds;
1438 int r;
1439
1440 assert(rr);
1441
1442 /* Generates the RR in wire-format, optionally in the
1443 * canonical form as discussed in the DNSSEC RFC 4034, Section
1444 * 6.2. We allocate a throw-away DnsPacket object on the stack
1445 * here, because we need some book-keeping for memory
1446 * management, and can reuse the DnsPacket serializer, that
1447 * can generate the canonical form, too, but also knows label
1448 * compression and suchlike. */
1449
1450 if (rr->wire_format && rr->wire_format_canonical == canonical)
1451 return 0;
1452
1453 r = dns_packet_append_rr(&packet, rr, 0, &start, &rds);
1454 if (r < 0)
1455 return r;
1456
1457 assert(start == 0);
1458 assert(packet._data);
1459
1460 free(rr->wire_format);
1461 rr->wire_format = TAKE_PTR(packet._data);
1462 rr->wire_format_size = packet.size;
1463 rr->wire_format_rdata_offset = rds;
1464 rr->wire_format_canonical = canonical;
1465
1466 return 0;
1467 }
1468
1469 int dns_resource_record_signer(DnsResourceRecord *rr, const char **ret) {
1470 const char *n;
1471 int r;
1472
1473 assert(rr);
1474 assert(ret);
1475
1476 /* Returns the RRset's signer, if it is known. */
1477
1478 if (rr->n_skip_labels_signer == UINT8_MAX)
1479 return -ENODATA;
1480
1481 n = dns_resource_key_name(rr->key);
1482 r = dns_name_skip(n, rr->n_skip_labels_signer, &n);
1483 if (r < 0)
1484 return r;
1485 if (r == 0)
1486 return -EINVAL;
1487
1488 *ret = n;
1489 return 0;
1490 }
1491
1492 int dns_resource_record_source(DnsResourceRecord *rr, const char **ret) {
1493 const char *n;
1494 int r;
1495
1496 assert(rr);
1497 assert(ret);
1498
1499 /* Returns the RRset's synthesizing source, if it is known. */
1500
1501 if (rr->n_skip_labels_source == UINT8_MAX)
1502 return -ENODATA;
1503
1504 n = dns_resource_key_name(rr->key);
1505 r = dns_name_skip(n, rr->n_skip_labels_source, &n);
1506 if (r < 0)
1507 return r;
1508 if (r == 0)
1509 return -EINVAL;
1510
1511 *ret = n;
1512 return 0;
1513 }
1514
1515 int dns_resource_record_is_signer(DnsResourceRecord *rr, const char *zone) {
1516 const char *signer;
1517 int r;
1518
1519 assert(rr);
1520
1521 r = dns_resource_record_signer(rr, &signer);
1522 if (r < 0)
1523 return r;
1524
1525 return dns_name_equal(zone, signer);
1526 }
1527
1528 int dns_resource_record_is_synthetic(DnsResourceRecord *rr) {
1529 int r;
1530
1531 assert(rr);
1532
1533 /* Returns > 0 if the RR is generated from a wildcard, and is not the asterisk name itself */
1534
1535 if (rr->n_skip_labels_source == UINT8_MAX)
1536 return -ENODATA;
1537
1538 if (rr->n_skip_labels_source == 0)
1539 return 0;
1540
1541 if (rr->n_skip_labels_source > 1)
1542 return 1;
1543
1544 r = dns_name_startswith(dns_resource_key_name(rr->key), "*");
1545 if (r < 0)
1546 return r;
1547
1548 return !r;
1549 }
1550
1551 void dns_resource_record_hash_func(const DnsResourceRecord *rr, struct siphash *state) {
1552 assert(rr);
1553
1554 dns_resource_key_hash_func(rr->key, state);
1555
1556 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
1557
1558 case DNS_TYPE_SRV:
1559 siphash24_compress_typesafe(rr->srv.priority, state);
1560 siphash24_compress_typesafe(rr->srv.weight, state);
1561 siphash24_compress_typesafe(rr->srv.port, state);
1562 dns_name_hash_func(rr->srv.name, state);
1563 break;
1564
1565 case DNS_TYPE_PTR:
1566 case DNS_TYPE_NS:
1567 case DNS_TYPE_CNAME:
1568 case DNS_TYPE_DNAME:
1569 dns_name_hash_func(rr->ptr.name, state);
1570 break;
1571
1572 case DNS_TYPE_HINFO:
1573 string_hash_func(rr->hinfo.cpu, state);
1574 string_hash_func(rr->hinfo.os, state);
1575 break;
1576
1577 case DNS_TYPE_TXT:
1578 case DNS_TYPE_SPF: {
1579 LIST_FOREACH(items, j, rr->txt.items) {
1580 siphash24_compress_safe(j->data, j->length, state);
1581
1582 /* Add an extra NUL byte, so that "a" followed by "b" doesn't result in the same hash as "ab"
1583 * followed by "". */
1584 siphash24_compress_byte(0, state);
1585 }
1586 break;
1587 }
1588
1589 case DNS_TYPE_A:
1590 siphash24_compress_typesafe(rr->a.in_addr, state);
1591 break;
1592
1593 case DNS_TYPE_AAAA:
1594 siphash24_compress_typesafe(rr->aaaa.in6_addr, state);
1595 break;
1596
1597 case DNS_TYPE_SOA:
1598 dns_name_hash_func(rr->soa.mname, state);
1599 dns_name_hash_func(rr->soa.rname, state);
1600 siphash24_compress_typesafe(rr->soa.serial, state);
1601 siphash24_compress_typesafe(rr->soa.refresh, state);
1602 siphash24_compress_typesafe(rr->soa.retry, state);
1603 siphash24_compress_typesafe(rr->soa.expire, state);
1604 siphash24_compress_typesafe(rr->soa.minimum, state);
1605 break;
1606
1607 case DNS_TYPE_MX:
1608 siphash24_compress_typesafe(rr->mx.priority, state);
1609 dns_name_hash_func(rr->mx.exchange, state);
1610 break;
1611
1612 case DNS_TYPE_LOC:
1613 siphash24_compress_typesafe(rr->loc.version, state);
1614 siphash24_compress_typesafe(rr->loc.size, state);
1615 siphash24_compress_typesafe(rr->loc.horiz_pre, state);
1616 siphash24_compress_typesafe(rr->loc.vert_pre, state);
1617 siphash24_compress_typesafe(rr->loc.latitude, state);
1618 siphash24_compress_typesafe(rr->loc.longitude, state);
1619 siphash24_compress_typesafe(rr->loc.altitude, state);
1620 break;
1621
1622 case DNS_TYPE_SSHFP:
1623 siphash24_compress_typesafe(rr->sshfp.algorithm, state);
1624 siphash24_compress_typesafe(rr->sshfp.fptype, state);
1625 siphash24_compress_safe(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size, state);
1626 break;
1627
1628 case DNS_TYPE_DNSKEY:
1629 siphash24_compress_typesafe(rr->dnskey.flags, state);
1630 siphash24_compress_typesafe(rr->dnskey.protocol, state);
1631 siphash24_compress_typesafe(rr->dnskey.algorithm, state);
1632 siphash24_compress_safe(rr->dnskey.key, rr->dnskey.key_size, state);
1633 break;
1634
1635 case DNS_TYPE_RRSIG:
1636 siphash24_compress_typesafe(rr->rrsig.type_covered, state);
1637 siphash24_compress_typesafe(rr->rrsig.algorithm, state);
1638 siphash24_compress_typesafe(rr->rrsig.labels, state);
1639 siphash24_compress_typesafe(rr->rrsig.original_ttl, state);
1640 siphash24_compress_typesafe(rr->rrsig.expiration, state);
1641 siphash24_compress_typesafe(rr->rrsig.inception, state);
1642 siphash24_compress_typesafe(rr->rrsig.key_tag, state);
1643 dns_name_hash_func(rr->rrsig.signer, state);
1644 siphash24_compress_safe(rr->rrsig.signature, rr->rrsig.signature_size, state);
1645 break;
1646
1647 case DNS_TYPE_NSEC:
1648 dns_name_hash_func(rr->nsec.next_domain_name, state);
1649 /* FIXME: we leave out the type bitmap here. Hash
1650 * would be better if we'd take it into account
1651 * too. */
1652 break;
1653
1654 case DNS_TYPE_DS:
1655 siphash24_compress_typesafe(rr->ds.key_tag, state);
1656 siphash24_compress_typesafe(rr->ds.algorithm, state);
1657 siphash24_compress_typesafe(rr->ds.digest_type, state);
1658 siphash24_compress_safe(rr->ds.digest, rr->ds.digest_size, state);
1659 break;
1660
1661 case DNS_TYPE_NSEC3:
1662 siphash24_compress_typesafe(rr->nsec3.algorithm, state);
1663 siphash24_compress_typesafe(rr->nsec3.flags, state);
1664 siphash24_compress_typesafe(rr->nsec3.iterations, state);
1665 siphash24_compress_safe(rr->nsec3.salt, rr->nsec3.salt_size, state);
1666 siphash24_compress_safe(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size, state);
1667 /* FIXME: We leave the bitmaps out */
1668 break;
1669
1670 case DNS_TYPE_TLSA:
1671 siphash24_compress_typesafe(rr->tlsa.cert_usage, state);
1672 siphash24_compress_typesafe(rr->tlsa.selector, state);
1673 siphash24_compress_typesafe(rr->tlsa.matching_type, state);
1674 siphash24_compress_safe(rr->tlsa.data, rr->tlsa.data_size, state);
1675 break;
1676
1677 case DNS_TYPE_SVCB:
1678 case DNS_TYPE_HTTPS:
1679 dns_name_hash_func(rr->svcb.target_name, state);
1680 siphash24_compress_typesafe(rr->svcb.priority, state);
1681 LIST_FOREACH(params, j, rr->svcb.params) {
1682 siphash24_compress_typesafe(j->key, state);
1683 siphash24_compress_safe(j->value, j->length, state);
1684 }
1685 break;
1686
1687 case DNS_TYPE_CAA:
1688 siphash24_compress_typesafe(rr->caa.flags, state);
1689 string_hash_func(rr->caa.tag, state);
1690 siphash24_compress_safe(rr->caa.value, rr->caa.value_size, state);
1691 break;
1692
1693 case DNS_TYPE_NAPTR:
1694 siphash24_compress_typesafe(rr->naptr.order, state);
1695 siphash24_compress_typesafe(rr->naptr.preference, state);
1696 string_hash_func(rr->naptr.flags, state);
1697 string_hash_func(rr->naptr.services, state);
1698 string_hash_func(rr->naptr.regexp, state);
1699 dns_name_hash_func(rr->naptr.replacement, state);
1700 break;
1701
1702 case DNS_TYPE_OPENPGPKEY:
1703 default:
1704 siphash24_compress_safe(rr->generic.data, rr->generic.data_size, state);
1705 }
1706 }
1707
1708 int dns_resource_record_compare_func(const DnsResourceRecord *x, const DnsResourceRecord *y) {
1709 int r;
1710
1711 r = dns_resource_key_compare_func(x->key, y->key);
1712 if (r != 0)
1713 return r;
1714
1715 if (dns_resource_record_payload_equal(x, y) > 0)
1716 return 0;
1717
1718 /* We still use CMP() here, even though don't implement proper
1719 * ordering, since the hashtable doesn't need ordering anyway. */
1720 return CMP(x, y);
1721 }
1722
1723 DEFINE_HASH_OPS_WITH_KEY_DESTRUCTOR(
1724 dns_resource_record_hash_ops,
1725 DnsResourceRecord,
1726 dns_resource_record_hash_func,
1727 dns_resource_record_compare_func,
1728 dns_resource_record_unref);
1729
1730 DEFINE_HASH_OPS_FULL(
1731 dns_resource_record_hash_ops_by_key,
1732 DnsResourceKey,
1733 dns_resource_key_hash_func,
1734 dns_resource_key_compare_func,
1735 dns_resource_key_unref,
1736 DnsResourceRecord,
1737 dns_resource_record_unref);
1738
1739 DnsResourceRecord *dns_resource_record_copy(DnsResourceRecord *rr) {
1740 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *copy = NULL;
1741 DnsResourceRecord *t;
1742
1743 assert(rr);
1744
1745 copy = dns_resource_record_new(rr->key);
1746 if (!copy)
1747 return NULL;
1748
1749 copy->ttl = rr->ttl;
1750 copy->expiry = rr->expiry;
1751 copy->n_skip_labels_signer = rr->n_skip_labels_signer;
1752 copy->n_skip_labels_source = rr->n_skip_labels_source;
1753 copy->unparsable = rr->unparsable;
1754
1755 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
1756
1757 case DNS_TYPE_SRV:
1758 copy->srv.priority = rr->srv.priority;
1759 copy->srv.weight = rr->srv.weight;
1760 copy->srv.port = rr->srv.port;
1761 copy->srv.name = strdup(rr->srv.name);
1762 if (!copy->srv.name)
1763 return NULL;
1764 break;
1765
1766 case DNS_TYPE_PTR:
1767 case DNS_TYPE_NS:
1768 case DNS_TYPE_CNAME:
1769 case DNS_TYPE_DNAME:
1770 copy->ptr.name = strdup(rr->ptr.name);
1771 if (!copy->ptr.name)
1772 return NULL;
1773 break;
1774
1775 case DNS_TYPE_HINFO:
1776 copy->hinfo.cpu = strdup(rr->hinfo.cpu);
1777 if (!copy->hinfo.cpu)
1778 return NULL;
1779
1780 copy->hinfo.os = strdup(rr->hinfo.os);
1781 if (!copy->hinfo.os)
1782 return NULL;
1783 break;
1784
1785 case DNS_TYPE_TXT:
1786 case DNS_TYPE_SPF:
1787 copy->txt.items = dns_txt_item_copy(rr->txt.items);
1788 if (!copy->txt.items)
1789 return NULL;
1790 break;
1791
1792 case DNS_TYPE_A:
1793 copy->a = rr->a;
1794 break;
1795
1796 case DNS_TYPE_AAAA:
1797 copy->aaaa = rr->aaaa;
1798 break;
1799
1800 case DNS_TYPE_SOA:
1801 copy->soa.mname = strdup(rr->soa.mname);
1802 if (!copy->soa.mname)
1803 return NULL;
1804 copy->soa.rname = strdup(rr->soa.rname);
1805 if (!copy->soa.rname)
1806 return NULL;
1807 copy->soa.serial = rr->soa.serial;
1808 copy->soa.refresh = rr->soa.refresh;
1809 copy->soa.retry = rr->soa.retry;
1810 copy->soa.expire = rr->soa.expire;
1811 copy->soa.minimum = rr->soa.minimum;
1812 break;
1813
1814 case DNS_TYPE_MX:
1815 copy->mx.priority = rr->mx.priority;
1816 copy->mx.exchange = strdup(rr->mx.exchange);
1817 if (!copy->mx.exchange)
1818 return NULL;
1819 break;
1820
1821 case DNS_TYPE_LOC:
1822 copy->loc = rr->loc;
1823 break;
1824
1825 case DNS_TYPE_SSHFP:
1826 copy->sshfp.algorithm = rr->sshfp.algorithm;
1827 copy->sshfp.fptype = rr->sshfp.fptype;
1828 copy->sshfp.fingerprint = memdup(rr->sshfp.fingerprint, rr->sshfp.fingerprint_size);
1829 if (!copy->sshfp.fingerprint)
1830 return NULL;
1831 copy->sshfp.fingerprint_size = rr->sshfp.fingerprint_size;
1832 break;
1833
1834 case DNS_TYPE_DNSKEY:
1835 copy->dnskey.flags = rr->dnskey.flags;
1836 copy->dnskey.protocol = rr->dnskey.protocol;
1837 copy->dnskey.algorithm = rr->dnskey.algorithm;
1838 copy->dnskey.key = memdup(rr->dnskey.key, rr->dnskey.key_size);
1839 if (!copy->dnskey.key)
1840 return NULL;
1841 copy->dnskey.key_size = rr->dnskey.key_size;
1842 break;
1843
1844 case DNS_TYPE_RRSIG:
1845 copy->rrsig.type_covered = rr->rrsig.type_covered;
1846 copy->rrsig.algorithm = rr->rrsig.algorithm;
1847 copy->rrsig.labels = rr->rrsig.labels;
1848 copy->rrsig.original_ttl = rr->rrsig.original_ttl;
1849 copy->rrsig.expiration = rr->rrsig.expiration;
1850 copy->rrsig.inception = rr->rrsig.inception;
1851 copy->rrsig.key_tag = rr->rrsig.key_tag;
1852 copy->rrsig.signer = strdup(rr->rrsig.signer);
1853 if (!copy->rrsig.signer)
1854 return NULL;
1855 copy->rrsig.signature = memdup(rr->rrsig.signature, rr->rrsig.signature_size);
1856 if (!copy->rrsig.signature)
1857 return NULL;
1858 copy->rrsig.signature_size = rr->rrsig.signature_size;
1859 break;
1860
1861 case DNS_TYPE_NSEC:
1862 copy->nsec.next_domain_name = strdup(rr->nsec.next_domain_name);
1863 if (!copy->nsec.next_domain_name)
1864 return NULL;
1865 if (rr->nsec.types) {
1866 copy->nsec.types = bitmap_copy(rr->nsec.types);
1867 if (!copy->nsec.types)
1868 return NULL;
1869 }
1870 break;
1871
1872 case DNS_TYPE_DS:
1873 copy->ds.key_tag = rr->ds.key_tag;
1874 copy->ds.algorithm = rr->ds.algorithm;
1875 copy->ds.digest_type = rr->ds.digest_type;
1876 copy->ds.digest = memdup(rr->ds.digest, rr->ds.digest_size);
1877 if (!copy->ds.digest)
1878 return NULL;
1879 copy->ds.digest_size = rr->ds.digest_size;
1880 break;
1881
1882 case DNS_TYPE_NSEC3:
1883 copy->nsec3.algorithm = rr->nsec3.algorithm;
1884 copy->nsec3.flags = rr->nsec3.flags;
1885 copy->nsec3.iterations = rr->nsec3.iterations;
1886 copy->nsec3.salt = memdup(rr->nsec3.salt, rr->nsec3.salt_size);
1887 if (!copy->nsec3.salt)
1888 return NULL;
1889 copy->nsec3.salt_size = rr->nsec3.salt_size;
1890 copy->nsec3.next_hashed_name = memdup(rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size);
1891 if (!copy->nsec3.next_hashed_name)
1892 return NULL;
1893 copy->nsec3.next_hashed_name_size = rr->nsec3.next_hashed_name_size;
1894 if (rr->nsec3.types) {
1895 copy->nsec3.types = bitmap_copy(rr->nsec3.types);
1896 if (!copy->nsec3.types)
1897 return NULL;
1898 }
1899 break;
1900
1901 case DNS_TYPE_TLSA:
1902 copy->tlsa.cert_usage = rr->tlsa.cert_usage;
1903 copy->tlsa.selector = rr->tlsa.selector;
1904 copy->tlsa.matching_type = rr->tlsa.matching_type;
1905 copy->tlsa.data = memdup(rr->tlsa.data, rr->tlsa.data_size);
1906 if (!copy->tlsa.data)
1907 return NULL;
1908 copy->tlsa.data_size = rr->tlsa.data_size;
1909 break;
1910
1911 case DNS_TYPE_CAA:
1912 copy->caa.flags = rr->caa.flags;
1913 copy->caa.tag = strdup(rr->caa.tag);
1914 if (!copy->caa.tag)
1915 return NULL;
1916 copy->caa.value = memdup(rr->caa.value, rr->caa.value_size);
1917 if (!copy->caa.value)
1918 return NULL;
1919 copy->caa.value_size = rr->caa.value_size;
1920 break;
1921
1922 case DNS_TYPE_SVCB:
1923 case DNS_TYPE_HTTPS:
1924 copy->svcb.priority = rr->svcb.priority;
1925 copy->svcb.target_name = strdup(rr->svcb.target_name);
1926 if (!copy->svcb.target_name)
1927 return NULL;
1928 copy->svcb.params = dns_svc_params_copy(rr->svcb.params);
1929 if (rr->svcb.params && !copy->svcb.params)
1930 return NULL;
1931 break;
1932
1933 case DNS_TYPE_NAPTR:
1934 copy->naptr.order = rr->naptr.order;
1935 copy->naptr.preference = rr->naptr.preference;
1936 copy->naptr.flags = strdup(rr->naptr.flags);
1937 if (!copy->naptr.flags)
1938 return NULL;
1939 copy->naptr.services = strdup(rr->naptr.services);
1940 if (!copy->naptr.services)
1941 return NULL;
1942 copy->naptr.regexp = strdup(rr->naptr.regexp);
1943 if (!copy->naptr.regexp)
1944 return NULL;
1945 copy->naptr.replacement = strdup(rr->naptr.replacement);
1946 if (!copy->naptr.replacement)
1947 return NULL;
1948 break;
1949
1950 case DNS_TYPE_OPT:
1951 default:
1952 copy->generic.data = memdup(rr->generic.data, rr->generic.data_size);
1953 if (!copy->generic.data)
1954 return NULL;
1955 copy->generic.data_size = rr->generic.data_size;
1956 }
1957
1958 t = TAKE_PTR(copy);
1959
1960 return t;
1961 }
1962
1963 int dns_resource_record_clamp_ttl(DnsResourceRecord **rr, uint32_t max_ttl) {
1964 DnsResourceRecord *old_rr, *new_rr;
1965 uint32_t new_ttl;
1966
1967 assert(rr);
1968 old_rr = *rr;
1969
1970 if (old_rr->key->type == DNS_TYPE_OPT)
1971 return -EINVAL;
1972
1973 new_ttl = MIN(old_rr->ttl, max_ttl);
1974 if (new_ttl == old_rr->ttl)
1975 return 0;
1976
1977 if (old_rr->n_ref == 1) {
1978 /* Patch in place */
1979 old_rr->ttl = new_ttl;
1980 return 1;
1981 }
1982
1983 new_rr = dns_resource_record_copy(old_rr);
1984 if (!new_rr)
1985 return -ENOMEM;
1986
1987 new_rr->ttl = new_ttl;
1988
1989 DNS_RR_REPLACE(*rr, new_rr);
1990 return 1;
1991 }
1992
1993 bool dns_resource_record_is_link_local_address(DnsResourceRecord *rr) {
1994 assert(rr);
1995
1996 if (rr->key->class != DNS_CLASS_IN)
1997 return false;
1998
1999 if (rr->key->type == DNS_TYPE_A)
2000 return in4_addr_is_link_local(&rr->a.in_addr);
2001
2002 if (rr->key->type == DNS_TYPE_AAAA)
2003 return in6_addr_is_link_local(&rr->aaaa.in6_addr);
2004
2005 return false;
2006 }
2007
2008 int dns_resource_record_get_cname_target(DnsResourceKey *key, DnsResourceRecord *cname, char **ret) {
2009 _cleanup_free_ char *d = NULL;
2010 int r;
2011
2012 assert(key);
2013 assert(cname);
2014 assert(ret);
2015
2016 /* Checks if the RR `cname` is a CNAME/DNAME RR that matches the specified `key`. If so, returns the
2017 * target domain. If not, returns -EUNATCH */
2018
2019 if (key->class != cname->key->class && key->class != DNS_CLASS_ANY)
2020 return -EUNATCH;
2021
2022 if (!dns_type_may_redirect(key->type)) /* This key type is not subject to CNAME/DNAME redirection?
2023 * Then let's refuse right-away */
2024 return -EUNATCH;
2025
2026 if (cname->key->type == DNS_TYPE_CNAME) {
2027 r = dns_name_equal(dns_resource_key_name(key),
2028 dns_resource_key_name(cname->key));
2029 if (r < 0)
2030 return r;
2031 if (r == 0)
2032 return -EUNATCH; /* CNAME RR key doesn't actually match the original key */
2033
2034 d = strdup(cname->cname.name);
2035 if (!d)
2036 return -ENOMEM;
2037
2038 } else if (cname->key->type == DNS_TYPE_DNAME) {
2039
2040 r = dns_name_change_suffix(
2041 dns_resource_key_name(key),
2042 dns_resource_key_name(cname->key),
2043 cname->dname.name,
2044 &d);
2045 if (r < 0)
2046 return r;
2047 if (r == 0)
2048 return -EUNATCH; /* DNAME RR key doesn't actually match the original key */
2049
2050 } else
2051 return -EUNATCH; /* Not a CNAME/DNAME RR, hence doesn't match the proposition either */
2052
2053 *ret = TAKE_PTR(d);
2054 return 0;
2055 }
2056
2057 DnsTxtItem *dns_txt_item_free_all(DnsTxtItem *first) {
2058 LIST_FOREACH(items, i, first)
2059 free(i);
2060
2061 return NULL;
2062 }
2063
2064 DnsSvcParam *dns_svc_param_free_all(DnsSvcParam *first) {
2065 LIST_FOREACH(params, i, first)
2066 free(i);
2067
2068 return NULL;
2069 }
2070
2071 bool dns_txt_item_equal(DnsTxtItem *a, DnsTxtItem *b) {
2072 DnsTxtItem *bb = b;
2073
2074 if (a == b)
2075 return true;
2076
2077 LIST_FOREACH(items, aa, a) {
2078 if (!bb)
2079 return false;
2080
2081 if (memcmp_nn(aa->data, aa->length, bb->data, bb->length) != 0)
2082 return false;
2083
2084 bb = bb->items_next;
2085 }
2086
2087 return !bb;
2088 }
2089
2090 DnsTxtItem *dns_txt_item_copy(DnsTxtItem *first) {
2091 DnsTxtItem *copy = NULL, *end = NULL;
2092
2093 LIST_FOREACH(items, i, first) {
2094 DnsTxtItem *j;
2095
2096 j = memdup(i, offsetof(DnsTxtItem, data) + i->length + 1);
2097 if (!j)
2098 return dns_txt_item_free_all(copy);
2099
2100 LIST_INSERT_AFTER(items, copy, end, j);
2101 end = j;
2102 }
2103
2104 return copy;
2105 }
2106
2107 bool dns_svc_params_equal(DnsSvcParam *a, DnsSvcParam *b) {
2108 DnsSvcParam *bb = b;
2109
2110 if (a == b)
2111 return true;
2112
2113 LIST_FOREACH(params, aa, a) {
2114 if (!bb)
2115 return false;
2116
2117 if (aa->key != bb->key)
2118 return false;
2119
2120 if (memcmp_nn(aa->value, aa->length, bb->value, bb->length) != 0)
2121 return false;
2122
2123 bb = bb->params_next;
2124 }
2125
2126 return !bb;
2127 }
2128
2129 DnsSvcParam *dns_svc_params_copy(DnsSvcParam *first) {
2130 DnsSvcParam *copy = NULL, *end = NULL;
2131
2132 LIST_FOREACH(params, i, first) {
2133 DnsSvcParam *j;
2134
2135 j = memdup(i, offsetof(DnsSvcParam, value) + i->length);
2136 if (!j)
2137 return dns_svc_param_free_all(copy);
2138
2139 LIST_INSERT_AFTER(params, copy, end, j);
2140 end = j;
2141 }
2142
2143 return copy;
2144 }
2145
2146 int dns_txt_item_new_empty(DnsTxtItem **ret) {
2147 DnsTxtItem *i;
2148
2149 assert(ret);
2150
2151 /* RFC 6763, section 6.1 suggests to treat
2152 * empty TXT RRs as equivalent to a TXT record
2153 * with a single empty string. */
2154
2155 i = malloc0(offsetof(DnsTxtItem, data) + 1); /* for safety reasons we add an extra NUL byte */
2156 if (!i)
2157 return -ENOMEM;
2158
2159 *ret = i;
2160 return 0;
2161 }
2162
2163 int dns_resource_record_new_from_raw(DnsResourceRecord **ret, const void *data, size_t size) {
2164 _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
2165 int r;
2166
2167 r = dns_packet_new(&p, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX);
2168 if (r < 0)
2169 return r;
2170
2171 p->refuse_compression = true;
2172
2173 r = dns_packet_append_blob(p, data, size, NULL);
2174 if (r < 0)
2175 return r;
2176
2177 return dns_packet_read_rr(p, ret, NULL, NULL);
2178 }
2179
2180 int dns_resource_key_to_json(DnsResourceKey *key, sd_json_variant **ret) {
2181 assert(key);
2182 assert(ret);
2183
2184 return sd_json_buildo(
2185 ret,
2186 SD_JSON_BUILD_PAIR_INTEGER("class", key->class),
2187 SD_JSON_BUILD_PAIR_INTEGER("type", key->type),
2188 SD_JSON_BUILD_PAIR_STRING("name", dns_resource_key_name(key)));
2189 }
2190
2191 int dns_resource_key_from_json(sd_json_variant *v, DnsResourceKey **ret) {
2192 struct params {
2193 uint16_t type;
2194 uint16_t class;
2195 const char *name;
2196 };
2197
2198 static const sd_json_dispatch_field dispatch_table[] = {
2199 { "class", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct params, class), 0 },
2200 { "type", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16, offsetof(struct params, type), SD_JSON_MANDATORY },
2201 { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_const_string, offsetof(struct params, name), SD_JSON_MANDATORY },
2202 {}
2203 };
2204
2205 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
2206 struct params p = {
2207 .class = DNS_CLASS_IN,
2208 };
2209 int r;
2210
2211 assert(v);
2212 assert(ret);
2213
2214 r = sd_json_dispatch(v, dispatch_table, 0, &p);
2215 if (r < 0)
2216 return r;
2217
2218 r = dns_name_is_valid(p.name);
2219 if (r < 0)
2220 return r;
2221 if (r == 0)
2222 return -EBADMSG;
2223
2224 key = dns_resource_key_new(p.class, p.type, p.name);
2225 if (!key)
2226 return -ENOMEM;
2227
2228 *ret = TAKE_PTR(key);
2229 return 0;
2230 }
2231
2232 static int type_bitmap_to_json(Bitmap *b, sd_json_variant **ret) {
2233 _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
2234 unsigned t;
2235 int r;
2236
2237 assert(ret);
2238
2239 BITMAP_FOREACH(t, b) {
2240 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
2241
2242 r = sd_json_variant_new_unsigned(&v, t);
2243 if (r < 0)
2244 return r;
2245
2246 r = sd_json_variant_append_array(&l, v);
2247 if (r < 0)
2248 return r;
2249 }
2250
2251 if (!l)
2252 return sd_json_variant_new_array(ret, NULL, 0);
2253
2254 *ret = TAKE_PTR(l);
2255 return 0;
2256 }
2257
2258 static int txt_to_json(DnsTxtItem *items, sd_json_variant **ret) {
2259 sd_json_variant **elements = NULL;
2260 size_t n = 0;
2261 int r;
2262
2263 assert(ret);
2264
2265 LIST_FOREACH(items, i, items) {
2266 if (!GREEDY_REALLOC(elements, n + 1)) {
2267 r = -ENOMEM;
2268 goto finalize;
2269 }
2270
2271 r = sd_json_variant_new_octescape(elements + n, i->data, i->length);
2272 if (r < 0)
2273 goto finalize;
2274
2275 n++;
2276 }
2277
2278 r = sd_json_variant_new_array(ret, elements, n);
2279
2280 finalize:
2281 sd_json_variant_unref_many(elements, n);
2282 return r;
2283 }
2284
2285 static int svc_params_to_json(DnsSvcParam *params, sd_json_variant **ret) {
2286 _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
2287 int r;
2288
2289 assert(ret);
2290
2291 LIST_FOREACH(params, i, params) {
2292 _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
2293 r = sd_json_variant_new_base64(&v, i->value, i->length);
2294 if (r < 0)
2295 return r;
2296
2297 r = sd_json_variant_set_field(&w, FORMAT_DNS_SVC_PARAM_KEY(i->key), v);
2298 if (r < 0)
2299 return r;
2300 }
2301
2302 *ret = TAKE_PTR(w);
2303 return 0;
2304 }
2305
2306 int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
2307 _cleanup_(sd_json_variant_unrefp) sd_json_variant *k = NULL;
2308 int r;
2309
2310 assert(rr);
2311
2312 r = dns_resource_key_to_json(rr->key, &k);
2313 if (r < 0)
2314 return r;
2315
2316 switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
2317
2318 case DNS_TYPE_SRV:
2319 return sd_json_buildo(
2320 ret,
2321 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2322 SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->srv.priority),
2323 SD_JSON_BUILD_PAIR_UNSIGNED("weight", rr->srv.weight),
2324 SD_JSON_BUILD_PAIR_UNSIGNED("port", rr->srv.port),
2325 SD_JSON_BUILD_PAIR_STRING("name", rr->srv.name));
2326
2327 case DNS_TYPE_PTR:
2328 case DNS_TYPE_NS:
2329 case DNS_TYPE_CNAME:
2330 case DNS_TYPE_DNAME:
2331 return sd_json_buildo(
2332 ret,
2333 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2334 SD_JSON_BUILD_PAIR_STRING("name", rr->ptr.name));
2335
2336 case DNS_TYPE_HINFO:
2337 return sd_json_buildo(
2338 ret,
2339 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2340 SD_JSON_BUILD_PAIR_STRING("cpu", rr->hinfo.cpu),
2341 SD_JSON_BUILD_PAIR_STRING("os", rr->hinfo.os));
2342
2343 case DNS_TYPE_SPF:
2344 case DNS_TYPE_TXT: {
2345 _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
2346
2347 r = txt_to_json(rr->txt.items, &l);
2348 if (r < 0)
2349 return r;
2350
2351 return sd_json_buildo(
2352 ret,
2353 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2354 SD_JSON_BUILD_PAIR_VARIANT("items", l));
2355 }
2356
2357 case DNS_TYPE_A:
2358 return sd_json_buildo(
2359 ret,
2360 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2361 SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr->a.in_addr)));
2362
2363 case DNS_TYPE_AAAA:
2364 return sd_json_buildo(
2365 ret,
2366 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2367 SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr->aaaa.in6_addr)));
2368
2369 case DNS_TYPE_SOA:
2370 return sd_json_buildo(
2371 ret,
2372 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2373 SD_JSON_BUILD_PAIR_STRING("mname", rr->soa.mname),
2374 SD_JSON_BUILD_PAIR_STRING("rname", rr->soa.rname),
2375 SD_JSON_BUILD_PAIR_UNSIGNED("serial", rr->soa.serial),
2376 SD_JSON_BUILD_PAIR_UNSIGNED("refresh", rr->soa.refresh),
2377 SD_JSON_BUILD_PAIR_UNSIGNED("expire", rr->soa.retry),
2378 SD_JSON_BUILD_PAIR_UNSIGNED("minimum", rr->soa.minimum));
2379
2380 case DNS_TYPE_MX:
2381 return sd_json_buildo(
2382 ret,
2383 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2384 SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->mx.priority),
2385 SD_JSON_BUILD_PAIR_STRING("exchange", rr->mx.exchange));
2386 case DNS_TYPE_LOC:
2387 return sd_json_buildo(
2388 ret,
2389 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2390 SD_JSON_BUILD_PAIR_UNSIGNED("version", rr->loc.version),
2391 SD_JSON_BUILD_PAIR_UNSIGNED("size", rr->loc.size),
2392 SD_JSON_BUILD_PAIR_UNSIGNED("horiz_pre", rr->loc.horiz_pre),
2393 SD_JSON_BUILD_PAIR_UNSIGNED("vert_pre", rr->loc.vert_pre),
2394 SD_JSON_BUILD_PAIR_UNSIGNED("latitude", rr->loc.latitude),
2395 SD_JSON_BUILD_PAIR_UNSIGNED("longitude", rr->loc.longitude),
2396 SD_JSON_BUILD_PAIR_UNSIGNED("altitude", rr->loc.altitude));
2397
2398 case DNS_TYPE_DS:
2399 return sd_json_buildo(
2400 ret,
2401 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2402 SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->ds.key_tag),
2403 SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->ds.algorithm),
2404 SD_JSON_BUILD_PAIR_UNSIGNED("digestType", rr->ds.digest_type),
2405 SD_JSON_BUILD_PAIR_HEX("digest", rr->ds.digest, rr->ds.digest_size));
2406
2407 case DNS_TYPE_SSHFP:
2408 return sd_json_buildo(
2409 ret,
2410 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2411 SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->sshfp.algorithm),
2412 SD_JSON_BUILD_PAIR_UNSIGNED("fptype", rr->sshfp.fptype),
2413 SD_JSON_BUILD_PAIR_HEX("fingerprint", rr->sshfp.fingerprint, rr->sshfp.fingerprint_size));
2414
2415 case DNS_TYPE_DNSKEY:
2416 return sd_json_buildo(
2417 ret,
2418 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2419 SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->dnskey.flags),
2420 SD_JSON_BUILD_PAIR_UNSIGNED("protocol", rr->dnskey.protocol),
2421 SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->dnskey.algorithm),
2422 SD_JSON_BUILD_PAIR_BASE64("dnskey", rr->dnskey.key, rr->dnskey.key_size));
2423
2424 case DNS_TYPE_RRSIG:
2425 return sd_json_buildo(
2426 ret,
2427 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2428 SD_JSON_BUILD_PAIR_STRING("signer", rr->rrsig.signer),
2429 SD_JSON_BUILD_PAIR_UNSIGNED("typeCovered", rr->rrsig.type_covered),
2430 SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->rrsig.algorithm),
2431 SD_JSON_BUILD_PAIR_UNSIGNED("labels", rr->rrsig.labels),
2432 SD_JSON_BUILD_PAIR_UNSIGNED("originalTtl", rr->rrsig.original_ttl),
2433 SD_JSON_BUILD_PAIR_UNSIGNED("expiration", rr->rrsig.expiration),
2434 SD_JSON_BUILD_PAIR_UNSIGNED("inception", rr->rrsig.inception),
2435 SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->rrsig.key_tag),
2436 SD_JSON_BUILD_PAIR_BASE64("signature", rr->rrsig.signature, rr->rrsig.signature_size));
2437
2438 case DNS_TYPE_NSEC: {
2439 _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
2440
2441 r = type_bitmap_to_json(rr->nsec.types, &bm);
2442 if (r < 0)
2443 return r;
2444
2445 return sd_json_buildo(
2446 ret,
2447 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2448 SD_JSON_BUILD_PAIR_STRING("nextDomain", rr->nsec.next_domain_name),
2449 SD_JSON_BUILD_PAIR_VARIANT("types", bm));
2450 }
2451
2452 case DNS_TYPE_NSEC3: {
2453 _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
2454
2455 r = type_bitmap_to_json(rr->nsec3.types, &bm);
2456 if (r < 0)
2457 return r;
2458
2459 return sd_json_buildo(
2460 ret,
2461 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2462 SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->nsec3.algorithm),
2463 SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->nsec3.flags),
2464 SD_JSON_BUILD_PAIR_UNSIGNED("iterations", rr->nsec3.iterations),
2465 SD_JSON_BUILD_PAIR_HEX("salt", rr->nsec3.salt, rr->nsec3.salt_size),
2466 SD_JSON_BUILD_PAIR_BASE32HEX("hash", rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size),
2467 SD_JSON_BUILD_PAIR_VARIANT("types", bm));
2468 }
2469
2470 case DNS_TYPE_TLSA:
2471 return sd_json_buildo(
2472 ret,
2473 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2474 SD_JSON_BUILD_PAIR_UNSIGNED("certUsage", rr->tlsa.cert_usage),
2475 SD_JSON_BUILD_PAIR_UNSIGNED("selector", rr->tlsa.selector),
2476 SD_JSON_BUILD_PAIR_UNSIGNED("matchingType", rr->tlsa.matching_type),
2477 SD_JSON_BUILD_PAIR_HEX("data", rr->tlsa.data, rr->tlsa.data_size));
2478
2479 case DNS_TYPE_SVCB:
2480 case DNS_TYPE_HTTPS: {
2481 _cleanup_(sd_json_variant_unrefp) sd_json_variant *p = NULL;
2482 r = svc_params_to_json(rr->svcb.params, &p);
2483 if (r < 0)
2484 return r;
2485
2486 return sd_json_buildo(
2487 ret,
2488 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2489 SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->svcb.priority),
2490 SD_JSON_BUILD_PAIR_STRING("target", rr->svcb.target_name),
2491 SD_JSON_BUILD_PAIR_VARIANT("svcparams", p));
2492 }
2493
2494 case DNS_TYPE_CAA:
2495 return sd_json_buildo(
2496 ret,
2497 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2498 SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->caa.flags),
2499 SD_JSON_BUILD_PAIR_STRING("tag", rr->caa.tag),
2500 SD_JSON_BUILD_PAIR_OCTESCAPE("value", rr->caa.value, rr->caa.value_size));
2501
2502 case DNS_TYPE_NAPTR:
2503 return sd_json_buildo(
2504 ret,
2505 SD_JSON_BUILD_PAIR_VARIANT("key", k),
2506 SD_JSON_BUILD_PAIR_UNSIGNED("order", rr->naptr.order),
2507 SD_JSON_BUILD_PAIR_UNSIGNED("preference", rr->naptr.preference),
2508 /* NB: we name this flags field here naptrFlags, because there's already another "flags" field (for example in CAA) which has a different type */
2509 SD_JSON_BUILD_PAIR_STRING("naptrFlags", rr->naptr.flags),
2510 SD_JSON_BUILD_PAIR_STRING("services", rr->naptr.services),
2511 SD_JSON_BUILD_PAIR_STRING("regexp", rr->naptr.regexp),
2512 SD_JSON_BUILD_PAIR_STRING("replacement", rr->naptr.replacement));
2513
2514 default:
2515 /* Can't provide broken-down format */
2516 if (ret)
2517 *ret = NULL;
2518 return 0;
2519 }
2520 }
2521
2522 int dns_resource_record_from_json(sd_json_variant *v, DnsResourceRecord **ret) {
2523 int r;
2524
2525 assert(v);
2526
2527 sd_json_variant *k = sd_json_variant_by_key(v, "key");
2528 if (!k)
2529 return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Resource record entry lacks key field, refusing.");
2530
2531 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
2532 r = dns_resource_key_from_json(k, &key);
2533 if (r < 0)
2534 return r;
2535
2536 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
2537 rr = dns_resource_record_new(key);
2538 if (!rr)
2539 return log_oom_debug();
2540
2541 /* Note, for now we only support the most common subset of RRs for decoding here. Please send patches for more. */
2542 switch (key->type) {
2543
2544 case DNS_TYPE_PTR:
2545 case DNS_TYPE_NS:
2546 case DNS_TYPE_CNAME:
2547 case DNS_TYPE_DNAME: {
2548 _cleanup_free_ char *name = NULL;
2549
2550 static const struct sd_json_dispatch_field table[] = {
2551 { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_MANDATORY },
2552 { "key", SD_JSON_VARIANT_OBJECT, NULL, 0, SD_JSON_MANDATORY },
2553 {}
2554 };
2555
2556 r = sd_json_dispatch(v, table, /* flags= */ 0, &name);
2557 if (r < 0)
2558 return r;
2559
2560 r = dns_name_is_valid(name);
2561 if (r < 0)
2562 return r;
2563 if (r == 0)
2564 return -EBADMSG;
2565
2566 rr->ptr.name = TAKE_PTR(name);
2567 break;
2568 }
2569
2570 case DNS_TYPE_A: {
2571 struct in_addr addr = {};
2572
2573 static const struct sd_json_dispatch_field table[] = {
2574 { "address", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0, SD_JSON_MANDATORY },
2575 { "key", SD_JSON_VARIANT_OBJECT, NULL, 0, SD_JSON_MANDATORY },
2576 {}
2577 };
2578
2579 r = sd_json_dispatch(v, table, /* flags= */ 0, &addr);
2580 if (r < 0)
2581 return r;
2582
2583 rr->a.in_addr = addr;
2584 break;
2585 }
2586
2587 case DNS_TYPE_AAAA: {
2588 struct in6_addr addr = {};
2589
2590 static const struct sd_json_dispatch_field table[] = {
2591 { "address", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0, SD_JSON_MANDATORY },
2592 { "key", SD_JSON_VARIANT_OBJECT, NULL, 0, SD_JSON_MANDATORY },
2593 {}
2594 };
2595
2596 r = sd_json_dispatch(v, table, /* flags= */ 0, &addr);
2597 if (r < 0)
2598 return r;
2599
2600 rr->aaaa.in6_addr = addr;
2601 break;
2602 }
2603
2604 default:
2605 return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Decoding DNS type %s is currently not supported.", dns_type_to_string(key->type));
2606 }
2607
2608 if (ret)
2609 *ret = TAKE_PTR(rr);
2610 return 0;
2611 }
2612
2613 static const char* const dnssec_algorithm_table[_DNSSEC_ALGORITHM_MAX_DEFINED] = {
2614 /* Mnemonics as listed on https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml */
2615 [DNSSEC_ALGORITHM_RSAMD5] = "RSAMD5",
2616 [DNSSEC_ALGORITHM_DH] = "DH",
2617 [DNSSEC_ALGORITHM_DSA] = "DSA",
2618 [DNSSEC_ALGORITHM_ECC] = "ECC",
2619 [DNSSEC_ALGORITHM_RSASHA1] = "RSASHA1",
2620 [DNSSEC_ALGORITHM_DSA_NSEC3_SHA1] = "DSA-NSEC3-SHA1",
2621 [DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1] = "RSASHA1-NSEC3-SHA1",
2622 [DNSSEC_ALGORITHM_RSASHA256] = "RSASHA256",
2623 [DNSSEC_ALGORITHM_RSASHA512] = "RSASHA512",
2624 [DNSSEC_ALGORITHM_ECC_GOST] = "ECC-GOST",
2625 [DNSSEC_ALGORITHM_ECDSAP256SHA256] = "ECDSAP256SHA256",
2626 [DNSSEC_ALGORITHM_ECDSAP384SHA384] = "ECDSAP384SHA384",
2627 [DNSSEC_ALGORITHM_ED25519] = "ED25519",
2628 [DNSSEC_ALGORITHM_ED448] = "ED448",
2629 [DNSSEC_ALGORITHM_INDIRECT] = "INDIRECT",
2630 [DNSSEC_ALGORITHM_PRIVATEDNS] = "PRIVATEDNS",
2631 [DNSSEC_ALGORITHM_PRIVATEOID] = "PRIVATEOID",
2632 };
2633 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_algorithm, int, 255);
2634
2635 static const char* const dnssec_digest_table[_DNSSEC_DIGEST_MAX_DEFINED] = {
2636 /* Names as listed on https://www.iana.org/assignments/ds-rr-types/ds-rr-types.xhtml */
2637 [DNSSEC_DIGEST_SHA1] = "SHA-1",
2638 [DNSSEC_DIGEST_SHA256] = "SHA-256",
2639 [DNSSEC_DIGEST_GOST_R_34_11_94] = "GOST_R_34.11-94",
2640 [DNSSEC_DIGEST_SHA384] = "SHA-384",
2641 };
2642 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_digest, int, 255);
2643
2644 static const char* const sshfp_algorithm_table[_SSHFP_ALGORITHM_MAX_DEFINED] = {
2645 [SSHFP_ALGORITHM_RSA] = "RSA", /* RFC 4255 */
2646 [SSHFP_ALGORITHM_DSA] = "DSA", /* RFC 4255 */
2647 [SSHFP_ALGORITHM_ECDSA] = "ECDSA", /* RFC 6594 */
2648 [SSHFP_ALGORITHM_ED25519] = "Ed25519", /* RFC 7479 */
2649 [SSHFP_ALGORITHM_ED448] = "Ed448", /* RFC 8709 */
2650 };
2651 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sshfp_algorithm, int, 255);
2652
2653 static const char* const sshfp_key_type_table[_SSHFP_KEY_TYPE_MAX_DEFINED] = {
2654 [SSHFP_KEY_TYPE_SHA1] = "SHA-1", /* RFC 4255 */
2655 [SSHFP_KEY_TYPE_SHA256] = "SHA-256", /* RFC 4255 */
2656 };
2657 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sshfp_key_type, int, 255);
2658
2659 int dns_json_dispatch_resource_key(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
2660 DnsResourceKey **k = ASSERT_PTR(userdata);
2661 int r;
2662
2663 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *nk = NULL;
2664 r = dns_resource_key_from_json(variant, &nk);
2665 if (r < 0)
2666 return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid resource record key.", strna(name));
2667
2668 DNS_RESOURCE_KEY_REPLACE(*k, TAKE_PTR(nk));
2669 return 0;
2670 }