1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
5 #include "alloc-util.h"
6 #include "dns-domain.h"
10 #include "memory-util.h"
11 #include "resolved-dns-dnssec.h"
12 #include "resolved-dns-packet.h"
13 #include "resolved-dns-rr.h"
14 #include "string-table.h"
15 #include "string-util.h"
17 #include "terminal-util.h"
18 #include "unaligned.h"
20 DnsResourceKey
* dns_resource_key_new(uint16_t class, uint16_t type
, const char *name
) {
27 k
= malloc0(sizeof(DnsResourceKey
) + l
+ 1);
35 strcpy((char*) k
+ sizeof(DnsResourceKey
), name
);
40 DnsResourceKey
* dns_resource_key_new_redirect(const DnsResourceKey
*key
, const DnsResourceRecord
*cname
) {
46 assert(IN_SET(cname
->key
->type
, DNS_TYPE_CNAME
, DNS_TYPE_DNAME
));
48 if (cname
->key
->type
== DNS_TYPE_CNAME
)
49 return dns_resource_key_new(key
->class, key
->type
, cname
->cname
.name
);
51 _cleanup_free_
char *destination
= NULL
;
54 r
= dns_name_change_suffix(dns_resource_key_name(key
), dns_resource_key_name(cname
->key
), cname
->dname
.name
, &destination
);
58 return dns_resource_key_ref((DnsResourceKey
*) key
);
60 k
= dns_resource_key_new_consume(key
->class, key
->type
, destination
);
64 TAKE_PTR(destination
);
69 int dns_resource_key_new_append_suffix(DnsResourceKey
**ret
, DnsResourceKey
*key
, char *name
) {
70 DnsResourceKey
*new_key
;
78 if (dns_name_is_root(name
)) {
79 *ret
= dns_resource_key_ref(key
);
83 r
= dns_name_concat(dns_resource_key_name(key
), name
, 0, &joined
);
87 new_key
= dns_resource_key_new_consume(key
->class, key
->type
, joined
);
97 DnsResourceKey
* dns_resource_key_new_consume(uint16_t class, uint16_t type
, char *name
) {
102 k
= new(DnsResourceKey
, 1);
106 *k
= (DnsResourceKey
) {
116 DnsResourceKey
* dns_resource_key_ref(DnsResourceKey
*k
) {
121 /* Static/const keys created with DNS_RESOURCE_KEY_CONST will
122 * set this to -1, they should not be reffed/unreffed */
123 assert(k
->n_ref
!= UINT_MAX
);
125 assert(k
->n_ref
> 0);
131 DnsResourceKey
* dns_resource_key_unref(DnsResourceKey
*k
) {
135 assert(k
->n_ref
!= UINT_MAX
);
136 assert(k
->n_ref
> 0);
147 const char* dns_resource_key_name(const DnsResourceKey
*key
) {
156 name
= (char*) key
+ sizeof(DnsResourceKey
);
158 if (dns_name_is_root(name
))
164 bool dns_resource_key_is_address(const DnsResourceKey
*key
) {
167 /* Check if this is an A or AAAA resource key */
169 return key
->class == DNS_CLASS_IN
&& IN_SET(key
->type
, DNS_TYPE_A
, DNS_TYPE_AAAA
);
172 bool dns_resource_key_is_dnssd_ptr(const DnsResourceKey
*key
) {
175 /* Check if this is a PTR resource key used in
176 Service Instance Enumeration as described in RFC6763 p4.1. */
178 if (key
->type
!= DNS_TYPE_PTR
)
181 return dns_name_endswith(dns_resource_key_name(key
), "_tcp.local") ||
182 dns_name_endswith(dns_resource_key_name(key
), "_udp.local");
185 bool dns_resource_key_is_dnssd_two_label_ptr(const DnsResourceKey
*key
) {
188 /* Check if this is a PTR resource key used in Service Instance
189 * Enumeration as described in RFC6763 § 4.1, excluding selective
190 * service names described in RFC6763 § 7.1. */
192 if (key
->type
!= DNS_TYPE_PTR
)
195 const char *name
= dns_resource_key_name(key
);
196 if (dns_name_parent(&name
) <= 0)
199 return dns_name_equal(name
, "_tcp.local") > 0 || dns_name_equal(name
, "_udp.local") > 0;
202 int dns_resource_key_equal(const DnsResourceKey
*a
, const DnsResourceKey
*b
) {
208 r
= dns_name_equal(dns_resource_key_name(a
), dns_resource_key_name(b
));
212 if (a
->class != b
->class)
215 if (a
->type
!= b
->type
)
221 int dns_resource_key_match_rr(const DnsResourceKey
*key
, DnsResourceRecord
*rr
, const char *search_domain
) {
230 /* Checks if an rr matches the specified key. If a search
231 * domain is specified, it will also be checked if the key
232 * with the search domain suffixed might match the RR. */
234 if (rr
->key
->class != key
->class && key
->class != DNS_CLASS_ANY
)
237 if (rr
->key
->type
!= key
->type
&& key
->type
!= DNS_TYPE_ANY
)
240 r
= dns_name_equal(dns_resource_key_name(rr
->key
), dns_resource_key_name(key
));
245 _cleanup_free_
char *joined
= NULL
;
247 r
= dns_name_concat(dns_resource_key_name(key
), search_domain
, 0, &joined
);
251 return dns_name_equal(dns_resource_key_name(rr
->key
), joined
);
257 int dns_resource_key_match_cname_or_dname(const DnsResourceKey
*key
, const DnsResourceKey
*cname
, const char *search_domain
) {
263 if (cname
->class != key
->class && key
->class != DNS_CLASS_ANY
)
266 if (!dns_type_may_redirect(key
->type
))
269 if (cname
->type
== DNS_TYPE_CNAME
)
270 r
= dns_name_equal(dns_resource_key_name(key
), dns_resource_key_name(cname
));
271 else if (cname
->type
== DNS_TYPE_DNAME
)
272 r
= dns_name_endswith(dns_resource_key_name(key
), dns_resource_key_name(cname
));
280 _cleanup_free_
char *joined
= NULL
;
282 r
= dns_name_concat(dns_resource_key_name(key
), search_domain
, 0, &joined
);
286 if (cname
->type
== DNS_TYPE_CNAME
)
287 return dns_name_equal(joined
, dns_resource_key_name(cname
));
288 else if (cname
->type
== DNS_TYPE_DNAME
)
289 return dns_name_endswith(joined
, dns_resource_key_name(cname
));
295 int dns_resource_key_match_soa(const DnsResourceKey
*key
, const DnsResourceKey
*soa
) {
299 /* Checks whether 'soa' is a SOA record for the specified key. */
301 if (soa
->class != key
->class)
304 if (soa
->type
!= DNS_TYPE_SOA
)
307 return dns_name_endswith(dns_resource_key_name(key
), dns_resource_key_name(soa
));
310 static void dns_resource_key_hash_func(const DnsResourceKey
*k
, struct siphash
*state
) {
313 dns_name_hash_func(dns_resource_key_name(k
), state
);
314 siphash24_compress_typesafe(k
->class, state
);
315 siphash24_compress_typesafe(k
->type
, state
);
318 static int dns_resource_key_compare_func(const DnsResourceKey
*x
, const DnsResourceKey
*y
) {
321 r
= dns_name_compare_func(dns_resource_key_name(x
), dns_resource_key_name(y
));
325 r
= CMP(x
->type
, y
->type
);
329 return CMP(x
->class, y
->class);
332 DEFINE_HASH_OPS(dns_resource_key_hash_ops
, DnsResourceKey
, dns_resource_key_hash_func
, dns_resource_key_compare_func
);
334 char* dns_resource_key_to_string(const DnsResourceKey
*key
, char *buf
, size_t buf_size
) {
338 /* If we cannot convert the CLASS/TYPE into a known string,
339 use the format recommended by RFC 3597, Section 5. */
341 c
= dns_class_to_string(key
->class);
342 t
= dns_type_to_string(key
->type
);
344 (void) snprintf(buf
, buf_size
, "%s %s%s%.0u %s%s%.0u",
345 dns_resource_key_name(key
),
346 strempty(c
), c
? "" : "CLASS", c
? 0u : key
->class,
347 strempty(t
), t
? "" : "TYPE", t
? 0u : key
->type
);
352 bool dns_resource_key_reduce(DnsResourceKey
**a
, DnsResourceKey
**b
) {
356 /* Try to replace one RR key by another if they are identical, thus saving a bit of memory. Note that we do
357 * this only for RR keys, not for RRs themselves, as they carry a lot of additional metadata (where they come
358 * from, validity data, and suchlike), and cannot be replaced so easily by other RRs that have the same
359 * superficial data. */
366 /* We refuse merging const keys */
367 if ((*a
)->n_ref
== UINT_MAX
)
369 if ((*b
)->n_ref
== UINT_MAX
)
372 /* Already the same? */
376 /* Are they really identical? */
377 if (dns_resource_key_equal(*a
, *b
) <= 0)
380 /* Keep the one which already has more references. */
381 if ((*a
)->n_ref
> (*b
)->n_ref
)
382 DNS_RESOURCE_KEY_REPLACE(*b
, dns_resource_key_ref(*a
));
384 DNS_RESOURCE_KEY_REPLACE(*a
, dns_resource_key_ref(*b
));
389 DnsResourceRecord
* dns_resource_record_new(DnsResourceKey
*key
) {
390 DnsResourceRecord
*rr
;
392 rr
= new(DnsResourceRecord
, 1);
396 *rr
= (DnsResourceRecord
) {
398 .key
= dns_resource_key_ref(key
),
399 .expiry
= USEC_INFINITY
,
400 .n_skip_labels_signer
= UINT8_MAX
,
401 .n_skip_labels_source
= UINT8_MAX
,
407 DnsResourceRecord
* dns_resource_record_new_full(uint16_t class, uint16_t type
, const char *name
) {
408 _cleanup_(dns_resource_key_unrefp
) DnsResourceKey
*key
= NULL
;
410 key
= dns_resource_key_new(class, type
, name
);
414 return dns_resource_record_new(key
);
417 static DnsResourceRecord
* dns_resource_record_free(DnsResourceRecord
*rr
) {
421 switch (rr
->key
->type
) {
441 dns_txt_item_free_all(rr
->txt
.items
);
450 free(rr
->mx
.exchange
);
458 free(rr
->sshfp
.fingerprint
);
461 case DNS_TYPE_DNSKEY
:
462 free(rr
->dnskey
.key
);
466 free(rr
->rrsig
.signer
);
467 free(rr
->rrsig
.signature
);
471 free(rr
->nsec
.next_domain_name
);
472 bitmap_free(rr
->nsec
.types
);
476 free(rr
->nsec3
.next_hashed_name
);
477 free(rr
->nsec3
.salt
);
478 bitmap_free(rr
->nsec3
.types
);
492 free(rr
->svcb
.target_name
);
493 dns_svc_param_free_all(rr
->svcb
.params
);
502 free(rr
->naptr
.flags
);
503 free(rr
->naptr
.services
);
504 free(rr
->naptr
.regexp
);
505 free(rr
->naptr
.replacement
);
508 case DNS_TYPE_OPENPGPKEY
:
511 free(rr
->generic
.data
);
515 free(rr
->generic
.data
);
517 free(rr
->wire_format
);
518 dns_resource_key_unref(rr
->key
);
525 DEFINE_TRIVIAL_REF_UNREF_FUNC(DnsResourceRecord
, dns_resource_record
, dns_resource_record_free
);
527 int dns_resource_record_new_reverse(DnsResourceRecord
**ret
, int family
, const union in_addr_union
*address
, const char *hostname
) {
528 _cleanup_(dns_resource_key_unrefp
) DnsResourceKey
*key
= NULL
;
529 _cleanup_(dns_resource_record_unrefp
) DnsResourceRecord
*rr
= NULL
;
530 _cleanup_free_
char *ptr
= NULL
;
537 r
= dns_name_reverse(family
, address
, &ptr
);
541 key
= dns_resource_key_new_consume(DNS_CLASS_IN
, DNS_TYPE_PTR
, ptr
);
547 rr
= dns_resource_record_new(key
);
551 rr
->ptr
.name
= strdup(hostname
);
560 int dns_resource_record_new_address(DnsResourceRecord
**ret
, int family
, const union in_addr_union
*address
, const char *name
) {
561 DnsResourceRecord
*rr
;
567 if (family
== AF_INET
) {
569 rr
= dns_resource_record_new_full(DNS_CLASS_IN
, DNS_TYPE_A
, name
);
573 rr
->a
.in_addr
= address
->in
;
575 } else if (family
== AF_INET6
) {
577 rr
= dns_resource_record_new_full(DNS_CLASS_IN
, DNS_TYPE_AAAA
, name
);
581 rr
->aaaa
.in6_addr
= address
->in6
;
583 return -EAFNOSUPPORT
;
590 #define FIELD_EQUAL(a, b, field) \
591 ((a).field ## _size == (b).field ## _size && \
592 memcmp_safe((a).field, (b).field, (a).field ## _size) == 0)
594 int dns_resource_record_payload_equal(const DnsResourceRecord
*a
, const DnsResourceRecord
*b
) {
597 /* Check if a and b are the same, but don't look at their keys */
599 if (a
->unparsable
!= b
->unparsable
)
602 switch (a
->unparsable
? _DNS_TYPE_INVALID
: a
->key
->type
) {
605 r
= dns_name_equal(a
->srv
.name
, b
->srv
.name
);
609 return a
->srv
.priority
== b
->srv
.priority
&&
610 a
->srv
.weight
== b
->srv
.weight
&&
611 a
->srv
.port
== b
->srv
.port
;
617 return dns_name_equal(a
->ptr
.name
, b
->ptr
.name
);
620 return strcaseeq(a
->hinfo
.cpu
, b
->hinfo
.cpu
) &&
621 strcaseeq(a
->hinfo
.os
, b
->hinfo
.os
);
623 case DNS_TYPE_SPF
: /* exactly the same as TXT */
625 return dns_txt_item_equal(a
->txt
.items
, b
->txt
.items
);
628 return memcmp(&a
->a
.in_addr
, &b
->a
.in_addr
, sizeof(struct in_addr
)) == 0;
631 return memcmp(&a
->aaaa
.in6_addr
, &b
->aaaa
.in6_addr
, sizeof(struct in6_addr
)) == 0;
634 r
= dns_name_equal(a
->soa
.mname
, b
->soa
.mname
);
637 r
= dns_name_equal(a
->soa
.rname
, b
->soa
.rname
);
641 return a
->soa
.serial
== b
->soa
.serial
&&
642 a
->soa
.refresh
== b
->soa
.refresh
&&
643 a
->soa
.retry
== b
->soa
.retry
&&
644 a
->soa
.expire
== b
->soa
.expire
&&
645 a
->soa
.minimum
== b
->soa
.minimum
;
648 if (a
->mx
.priority
!= b
->mx
.priority
)
651 return dns_name_equal(a
->mx
.exchange
, b
->mx
.exchange
);
654 assert(a
->loc
.version
== b
->loc
.version
);
656 return a
->loc
.size
== b
->loc
.size
&&
657 a
->loc
.horiz_pre
== b
->loc
.horiz_pre
&&
658 a
->loc
.vert_pre
== b
->loc
.vert_pre
&&
659 a
->loc
.latitude
== b
->loc
.latitude
&&
660 a
->loc
.longitude
== b
->loc
.longitude
&&
661 a
->loc
.altitude
== b
->loc
.altitude
;
664 return a
->ds
.key_tag
== b
->ds
.key_tag
&&
665 a
->ds
.algorithm
== b
->ds
.algorithm
&&
666 a
->ds
.digest_type
== b
->ds
.digest_type
&&
667 FIELD_EQUAL(a
->ds
, b
->ds
, digest
);
670 return a
->sshfp
.algorithm
== b
->sshfp
.algorithm
&&
671 a
->sshfp
.fptype
== b
->sshfp
.fptype
&&
672 FIELD_EQUAL(a
->sshfp
, b
->sshfp
, fingerprint
);
674 case DNS_TYPE_DNSKEY
:
675 return a
->dnskey
.flags
== b
->dnskey
.flags
&&
676 a
->dnskey
.protocol
== b
->dnskey
.protocol
&&
677 a
->dnskey
.algorithm
== b
->dnskey
.algorithm
&&
678 FIELD_EQUAL(a
->dnskey
, b
->dnskey
, key
);
681 /* do the fast comparisons first */
682 if (!(a
->rrsig
.type_covered
== b
->rrsig
.type_covered
&&
683 a
->rrsig
.algorithm
== b
->rrsig
.algorithm
&&
684 a
->rrsig
.labels
== b
->rrsig
.labels
&&
685 a
->rrsig
.original_ttl
== b
->rrsig
.original_ttl
&&
686 a
->rrsig
.expiration
== b
->rrsig
.expiration
&&
687 a
->rrsig
.inception
== b
->rrsig
.inception
&&
688 a
->rrsig
.key_tag
== b
->rrsig
.key_tag
&&
689 FIELD_EQUAL(a
->rrsig
, b
->rrsig
, signature
)))
692 return dns_name_equal(a
->rrsig
.signer
, b
->rrsig
.signer
);
695 r
= dns_name_equal(a
->nsec
.next_domain_name
, b
->nsec
.next_domain_name
);
699 return bitmap_equal(a
->nsec
.types
, b
->nsec
.types
);
702 return a
->nsec3
.algorithm
== b
->nsec3
.algorithm
&&
703 a
->nsec3
.flags
== b
->nsec3
.flags
&&
704 a
->nsec3
.iterations
== b
->nsec3
.iterations
&&
705 FIELD_EQUAL(a
->nsec3
, b
->nsec3
, salt
) &&
706 FIELD_EQUAL(a
->nsec3
, b
->nsec3
, next_hashed_name
) &&
707 bitmap_equal(a
->nsec3
.types
, b
->nsec3
.types
);
710 return a
->tlsa
.cert_usage
== b
->tlsa
.cert_usage
&&
711 a
->tlsa
.selector
== b
->tlsa
.selector
&&
712 a
->tlsa
.matching_type
== b
->tlsa
.matching_type
&&
713 FIELD_EQUAL(a
->tlsa
, b
->tlsa
, data
);
718 if (!(a
->svcb
.priority
== b
->svcb
.priority
&&
719 dns_svc_params_equal(a
->svcb
.params
, b
->svcb
.params
)))
722 return dns_name_equal(a
->svcb
.target_name
, b
->svcb
.target_name
);
725 return a
->caa
.flags
== b
->caa
.flags
&&
726 streq(a
->caa
.tag
, b
->caa
.tag
) &&
727 FIELD_EQUAL(a
->caa
, b
->caa
, value
);
730 r
= dns_name_equal(a
->naptr
.replacement
, b
->naptr
.replacement
);
734 return a
->naptr
.order
== b
->naptr
.order
&&
735 a
->naptr
.preference
== b
->naptr
.preference
&&
736 streq(a
->naptr
.flags
, b
->naptr
.flags
) &&
737 streq(a
->naptr
.services
, b
->naptr
.services
) &&
738 streq(a
->naptr
.regexp
, b
->naptr
.regexp
);
740 case DNS_TYPE_OPENPGPKEY
:
742 return FIELD_EQUAL(a
->generic
, b
->generic
, data
);
746 int dns_resource_record_equal(const DnsResourceRecord
*a
, const DnsResourceRecord
*b
) {
755 r
= dns_resource_key_equal(a
->key
, b
->key
);
759 return dns_resource_record_payload_equal(a
, b
);
762 static char* format_location(uint32_t latitude
, uint32_t longitude
, uint32_t altitude
,
763 uint8_t size
, uint8_t horiz_pre
, uint8_t vert_pre
) {
765 char NS
= latitude
>= 1U<<31 ? 'N' : 'S';
766 char EW
= longitude
>= 1U<<31 ? 'E' : 'W';
768 int lat
= latitude
>= 1U<<31 ? (int) (latitude
- (1U<<31)) : (int) ((1U<<31) - latitude
);
769 int lon
= longitude
>= 1U<<31 ? (int) (longitude
- (1U<<31)) : (int) ((1U<<31) - longitude
);
770 double alt
= altitude
>= 10000000u ? altitude
- 10000000u : -(double)(10000000u - altitude
);
771 double siz
= (size
>> 4) * exp10((double) (size
& 0xF));
772 double hor
= (horiz_pre
>> 4) * exp10((double) (horiz_pre
& 0xF));
773 double ver
= (vert_pre
>> 4) * exp10((double) (vert_pre
& 0xF));
775 if (asprintf(&s
, "%d %d %.3f %c %d %d %.3f %c %.2fm %.2fm %.2fm %.2fm",
778 (lat
% 60000) / 1000.,
782 (lon
% 60000) / 1000.,
793 static int format_timestamp_dns(char *buf
, size_t l
, time_t sec
) {
797 assert(l
> STRLEN("YYYYMMDDHHmmSS"));
799 if (!gmtime_r(&sec
, &tm
))
802 if (strftime(buf
, l
, "%Y%m%d%H%M%S", &tm
) <= 0)
808 static char *format_types(Bitmap
*types
) {
809 _cleanup_strv_free_
char **strv
= NULL
;
810 _cleanup_free_
char *str
= NULL
;
814 BITMAP_FOREACH(type
, types
) {
815 if (dns_type_to_string(type
)) {
816 r
= strv_extend(&strv
, dns_type_to_string(type
));
822 r
= asprintf(&t
, "TYPE%u", type
);
826 r
= strv_consume(&strv
, t
);
832 str
= strv_join(strv
, " ");
836 return strjoin("( ", str
, " )");
839 static char *format_txt(DnsTxtItem
*first
) {
843 LIST_FOREACH(items
, i
, first
)
844 c
+= i
->length
* 4 + 3;
846 p
= s
= new(char, c
);
850 LIST_FOREACH(items
, i
, first
) {
856 for (size_t j
= 0; j
< i
->length
; j
++) {
857 if (i
->data
[j
] < ' ' || i
->data
[j
] == '"' || i
->data
[j
] >= 127) {
859 *(p
++) = '0' + (i
->data
[j
] / 100);
860 *(p
++) = '0' + ((i
->data
[j
] / 10) % 10);
861 *(p
++) = '0' + (i
->data
[j
] % 10);
873 static char *format_svc_param_value(DnsSvcParam
*i
) {
874 _cleanup_free_
char *value
= NULL
;
879 case DNS_SVC_PARAM_KEY_ALPN
: {
881 _cleanup_strv_free_
char **values_strv
= NULL
;
882 while (offset
< i
->length
) {
883 size_t sz
= (uint8_t) i
->value
[offset
++];
885 char *alpn
= cescape_length((char *)&i
->value
[offset
], sz
);
889 if (strv_push(&values_strv
, alpn
) < 0)
894 value
= strv_join(values_strv
, ",");
900 case DNS_SVC_PARAM_KEY_PORT
: {
901 uint16_t port
= unaligned_read_be16(i
->value
);
902 if (asprintf(&value
, "%" PRIu16
, port
) < 0)
904 return TAKE_PTR(value
);
906 case DNS_SVC_PARAM_KEY_IPV4HINT
: {
907 const struct in_addr
*addrs
= i
->value_in_addr
;
908 _cleanup_strv_free_
char **values_strv
= NULL
;
909 for (size_t n
= 0; n
< i
->length
/ sizeof (struct in_addr
); n
++) {
911 if (in_addr_to_string(AF_INET
, (const union in_addr_union
*) &addrs
[n
], &addr
) < 0)
913 if (strv_push(&values_strv
, addr
) < 0)
916 return strv_join(values_strv
, ",");
918 case DNS_SVC_PARAM_KEY_IPV6HINT
: {
919 const struct in6_addr
*addrs
= i
->value_in6_addr
;
920 _cleanup_strv_free_
char **values_strv
= NULL
;
921 for (size_t n
= 0; n
< i
->length
/ sizeof (struct in6_addr
); n
++) {
923 if (in_addr_to_string(AF_INET6
, (const union in_addr_union
*) &addrs
[n
], &addr
) < 0)
925 if (strv_push(&values_strv
, addr
) < 0)
928 return strv_join(values_strv
, ",");
931 value
= decescape((char *)&i
->value
, " ,", i
->length
);
939 if (asprintf(&qvalue
, "\"%s\"", value
) < 0)
944 static char *format_svc_param(DnsSvcParam
*i
) {
945 const char *key
= FORMAT_DNS_SVC_PARAM_KEY(i
->key
);
946 _cleanup_free_
char *value
= NULL
;
953 value
= format_svc_param_value(i
);
957 return strjoin(key
, "=", value
);
960 static char *format_svc_params(DnsSvcParam
*first
) {
961 _cleanup_strv_free_
char **params
= NULL
;
963 LIST_FOREACH(params
, i
, first
) {
964 char *param
= format_svc_param(i
);
967 if (strv_push(¶ms
, param
) < 0)
971 return strv_join(params
, " ");
974 const char *dns_resource_record_to_string(DnsResourceRecord
*rr
) {
975 _cleanup_free_
char *s
= NULL
, *t
= NULL
;
976 char k
[DNS_RESOURCE_KEY_STRING_MAX
];
982 return rr
->to_string
;
984 dns_resource_key_to_string(rr
->key
, k
, sizeof(k
));
986 switch (rr
->unparsable
? _DNS_TYPE_INVALID
: rr
->key
->type
) {
989 r
= asprintf(&s
, "%s %u %u %u %s",
994 strna(rr
->srv
.name
));
1001 case DNS_TYPE_CNAME
:
1002 case DNS_TYPE_DNAME
:
1003 s
= strjoin(k
, " ", rr
->ptr
.name
);
1009 case DNS_TYPE_HINFO
:
1010 s
= strjoin(k
, " ", rr
->hinfo
.cpu
, " ", rr
->hinfo
.os
);
1015 case DNS_TYPE_SPF
: /* exactly the same as TXT */
1017 t
= format_txt(rr
->txt
.items
);
1021 s
= strjoin(k
, " ", t
);
1027 r
= in_addr_to_string(AF_INET
, (const union in_addr_union
*) &rr
->a
.in_addr
, &t
);
1031 s
= strjoin(k
, " ", t
);
1037 r
= in_addr_to_string(AF_INET6
, (const union in_addr_union
*) &rr
->aaaa
.in6_addr
, &t
);
1041 s
= strjoin(k
, " ", t
);
1047 r
= asprintf(&s
, "%s %s %s %u %u %u %u %u",
1049 strna(rr
->soa
.mname
),
1050 strna(rr
->soa
.rname
),
1061 r
= asprintf(&s
, "%s %u %s",
1070 assert(rr
->loc
.version
== 0);
1072 t
= format_location(rr
->loc
.latitude
,
1081 s
= strjoin(k
, " ", t
);
1087 t
= hexmem(rr
->ds
.digest
, rr
->ds
.digest_size
);
1091 r
= asprintf(&s
, "%s %u %u %u %s",
1101 case DNS_TYPE_SSHFP
:
1102 t
= hexmem(rr
->sshfp
.fingerprint
, rr
->sshfp
.fingerprint_size
);
1106 r
= asprintf(&s
, "%s %u %u %s",
1108 rr
->sshfp
.algorithm
,
1115 case DNS_TYPE_DNSKEY
: {
1116 _cleanup_free_
char *alg
= NULL
;
1119 key_tag
= dnssec_keytag(rr
, true);
1121 r
= dnssec_algorithm_to_string_alloc(rr
->dnskey
.algorithm
, &alg
);
1125 r
= asprintf(&t
, "%s %u %u %s",
1128 rr
->dnskey
.protocol
,
1133 r
= base64_append(&t
, r
,
1134 rr
->dnskey
.key
, rr
->dnskey
.key_size
,
1139 r
= asprintf(&s
, "%s\n"
1140 " -- Flags:%s%s%s\n"
1143 rr
->dnskey
.flags
& DNSKEY_FLAG_SEP
? " SEP" : "",
1144 rr
->dnskey
.flags
& DNSKEY_FLAG_REVOKE
? " REVOKE" : "",
1145 rr
->dnskey
.flags
& DNSKEY_FLAG_ZONE_KEY
? " ZONE_KEY" : "",
1153 case DNS_TYPE_RRSIG
: {
1154 _cleanup_free_
char *alg
= NULL
;
1155 char expiration
[STRLEN("YYYYMMDDHHmmSS") + 1], inception
[STRLEN("YYYYMMDDHHmmSS") + 1];
1158 type
= dns_type_to_string(rr
->rrsig
.type_covered
);
1160 r
= dnssec_algorithm_to_string_alloc(rr
->rrsig
.algorithm
, &alg
);
1164 r
= format_timestamp_dns(expiration
, sizeof(expiration
), rr
->rrsig
.expiration
);
1168 r
= format_timestamp_dns(inception
, sizeof(inception
), rr
->rrsig
.inception
);
1173 * http://tools.ietf.org/html/rfc3597#section-5 */
1175 r
= asprintf(&s
, "%s %s%.*u %s %u %u %s %s %u %s",
1178 type
? 0 : 1, type
? 0u : (unsigned) rr
->rrsig
.type_covered
,
1181 rr
->rrsig
.original_ttl
,
1189 r
= base64_append(&s
, r
,
1190 rr
->rrsig
.signature
, rr
->rrsig
.signature_size
,
1199 t
= format_types(rr
->nsec
.types
);
1203 r
= asprintf(&s
, "%s %s %s",
1205 rr
->nsec
.next_domain_name
,
1211 case DNS_TYPE_NSEC3
: {
1212 _cleanup_free_
char *salt
= NULL
, *hash
= NULL
;
1214 if (rr
->nsec3
.salt_size
> 0) {
1215 salt
= hexmem(rr
->nsec3
.salt
, rr
->nsec3
.salt_size
);
1220 hash
= base32hexmem(rr
->nsec3
.next_hashed_name
, rr
->nsec3
.next_hashed_name_size
, false);
1224 t
= format_types(rr
->nsec3
.types
);
1228 r
= asprintf(&s
, "%s %"PRIu8
" %"PRIu8
" %"PRIu16
" %s %s %s",
1230 rr
->nsec3
.algorithm
,
1232 rr
->nsec3
.iterations
,
1233 rr
->nsec3
.salt_size
> 0 ? salt
: "-",
1243 t
= hexmem(rr
->tlsa
.data
, rr
->tlsa
.data_size
);
1249 " -- Cert. usage: %s\n"
1250 " -- Selector: %s\n"
1251 " -- Matching type: %s",
1253 rr
->tlsa
.cert_usage
,
1255 rr
->tlsa
.matching_type
,
1257 tlsa_cert_usage_to_string(rr
->tlsa
.cert_usage
),
1258 tlsa_selector_to_string(rr
->tlsa
.selector
),
1259 tlsa_matching_type_to_string(rr
->tlsa
.matching_type
));
1266 t
= octescape(rr
->caa
.value
, rr
->caa
.value_size
);
1270 r
= asprintf(&s
, "%s %u %s \"%s\"%s%s%s%.0u",
1275 rr
->caa
.flags
? "\n -- Flags:" : "",
1276 rr
->caa
.flags
& CAA_FLAG_CRITICAL
? " critical" : "",
1277 rr
->caa
.flags
& ~CAA_FLAG_CRITICAL
? " " : "",
1278 rr
->caa
.flags
& ~CAA_FLAG_CRITICAL
);
1285 case DNS_TYPE_HTTPS
:
1286 t
= format_svc_params(rr
->svcb
.params
);
1289 r
= asprintf(&s
, "%s %d %s %s", k
, rr
->svcb
.priority
,
1290 isempty(rr
->svcb
.target_name
) ? "." : rr
->svcb
.target_name
,
1297 case DNS_TYPE_OPENPGPKEY
:
1298 r
= asprintf(&s
, "%s", k
);
1302 r
= base64_append(&s
, r
,
1303 rr
->generic
.data
, rr
->generic
.data_size
,
1309 case DNS_TYPE_NAPTR
: {
1310 _cleanup_free_
char *tt
= NULL
, *ttt
= NULL
;
1312 t
= octescape(rr
->naptr
.flags
, SIZE_MAX
);
1316 tt
= octescape(rr
->naptr
.services
, SIZE_MAX
);
1320 ttt
= octescape(rr
->naptr
.regexp
, SIZE_MAX
);
1324 if (asprintf(&s
, "%" PRIu16
" %" PRIu16
" \"%s\" \"%s\" \"%s\" %s.",
1326 rr
->naptr
.preference
,
1330 rr
->naptr
.replacement
) < 0)
1335 /* Format as documented in RFC 3597, Section 5 */
1336 if (rr
->generic
.data_size
== 0)
1337 r
= asprintf(&s
, "%s \\# 0", k
);
1339 t
= hexmem(rr
->generic
.data
, rr
->generic
.data_size
);
1342 r
= asprintf(&s
, "%s \\# %zu %s", k
, rr
->generic
.data_size
, t
);
1353 ssize_t
dns_resource_record_payload(DnsResourceRecord
*rr
, void **out
) {
1357 switch (rr
->unparsable
? _DNS_TYPE_INVALID
: rr
->key
->type
) {
1361 case DNS_TYPE_CNAME
:
1362 case DNS_TYPE_DNAME
:
1363 case DNS_TYPE_HINFO
:
1372 case DNS_TYPE_DNSKEY
:
1373 case DNS_TYPE_RRSIG
:
1375 case DNS_TYPE_NSEC3
:
1378 case DNS_TYPE_SSHFP
:
1379 *out
= rr
->sshfp
.fingerprint
;
1380 return rr
->sshfp
.fingerprint_size
;
1383 *out
= rr
->tlsa
.data
;
1384 return rr
->tlsa
.data_size
;
1386 case DNS_TYPE_OPENPGPKEY
:
1388 *out
= rr
->generic
.data
;
1389 return rr
->generic
.data_size
;
1393 int dns_resource_record_to_wire_format(DnsResourceRecord
*rr
, bool canonical
) {
1395 _cleanup_(dns_packet_unref
) DnsPacket packet
= {
1397 .protocol
= DNS_PROTOCOL_DNS
,
1399 .refuse_compression
= true,
1400 .canonical_form
= canonical
,
1408 /* Generates the RR in wire-format, optionally in the
1409 * canonical form as discussed in the DNSSEC RFC 4034, Section
1410 * 6.2. We allocate a throw-away DnsPacket object on the stack
1411 * here, because we need some book-keeping for memory
1412 * management, and can reuse the DnsPacket serializer, that
1413 * can generate the canonical form, too, but also knows label
1414 * compression and suchlike. */
1416 if (rr
->wire_format
&& rr
->wire_format_canonical
== canonical
)
1419 r
= dns_packet_append_rr(&packet
, rr
, 0, &start
, &rds
);
1424 assert(packet
._data
);
1426 free(rr
->wire_format
);
1427 rr
->wire_format
= TAKE_PTR(packet
._data
);
1428 rr
->wire_format_size
= packet
.size
;
1429 rr
->wire_format_rdata_offset
= rds
;
1430 rr
->wire_format_canonical
= canonical
;
1435 int dns_resource_record_signer(DnsResourceRecord
*rr
, const char **ret
) {
1442 /* Returns the RRset's signer, if it is known. */
1444 if (rr
->n_skip_labels_signer
== UINT8_MAX
)
1447 n
= dns_resource_key_name(rr
->key
);
1448 r
= dns_name_skip(n
, rr
->n_skip_labels_signer
, &n
);
1458 int dns_resource_record_source(DnsResourceRecord
*rr
, const char **ret
) {
1465 /* Returns the RRset's synthesizing source, if it is known. */
1467 if (rr
->n_skip_labels_source
== UINT8_MAX
)
1470 n
= dns_resource_key_name(rr
->key
);
1471 r
= dns_name_skip(n
, rr
->n_skip_labels_source
, &n
);
1481 int dns_resource_record_is_signer(DnsResourceRecord
*rr
, const char *zone
) {
1487 r
= dns_resource_record_signer(rr
, &signer
);
1491 return dns_name_equal(zone
, signer
);
1494 int dns_resource_record_is_synthetic(DnsResourceRecord
*rr
) {
1499 /* Returns > 0 if the RR is generated from a wildcard, and is not the asterisk name itself */
1501 if (rr
->n_skip_labels_source
== UINT8_MAX
)
1504 if (rr
->n_skip_labels_source
== 0)
1507 if (rr
->n_skip_labels_source
> 1)
1510 r
= dns_name_startswith(dns_resource_key_name(rr
->key
), "*");
1517 void dns_resource_record_hash_func(const DnsResourceRecord
*rr
, struct siphash
*state
) {
1520 dns_resource_key_hash_func(rr
->key
, state
);
1522 switch (rr
->unparsable
? _DNS_TYPE_INVALID
: rr
->key
->type
) {
1525 siphash24_compress_typesafe(rr
->srv
.priority
, state
);
1526 siphash24_compress_typesafe(rr
->srv
.weight
, state
);
1527 siphash24_compress_typesafe(rr
->srv
.port
, state
);
1528 dns_name_hash_func(rr
->srv
.name
, state
);
1533 case DNS_TYPE_CNAME
:
1534 case DNS_TYPE_DNAME
:
1535 dns_name_hash_func(rr
->ptr
.name
, state
);
1538 case DNS_TYPE_HINFO
:
1539 string_hash_func(rr
->hinfo
.cpu
, state
);
1540 string_hash_func(rr
->hinfo
.os
, state
);
1544 case DNS_TYPE_SPF
: {
1545 LIST_FOREACH(items
, j
, rr
->txt
.items
) {
1546 siphash24_compress_safe(j
->data
, j
->length
, state
);
1548 /* Add an extra NUL byte, so that "a" followed by "b" doesn't result in the same hash as "ab"
1549 * followed by "". */
1550 siphash24_compress_byte(0, state
);
1556 siphash24_compress_typesafe(rr
->a
.in_addr
, state
);
1560 siphash24_compress_typesafe(rr
->aaaa
.in6_addr
, state
);
1564 dns_name_hash_func(rr
->soa
.mname
, state
);
1565 dns_name_hash_func(rr
->soa
.rname
, state
);
1566 siphash24_compress_typesafe(rr
->soa
.serial
, state
);
1567 siphash24_compress_typesafe(rr
->soa
.refresh
, state
);
1568 siphash24_compress_typesafe(rr
->soa
.retry
, state
);
1569 siphash24_compress_typesafe(rr
->soa
.expire
, state
);
1570 siphash24_compress_typesafe(rr
->soa
.minimum
, state
);
1574 siphash24_compress_typesafe(rr
->mx
.priority
, state
);
1575 dns_name_hash_func(rr
->mx
.exchange
, state
);
1579 siphash24_compress_typesafe(rr
->loc
.version
, state
);
1580 siphash24_compress_typesafe(rr
->loc
.size
, state
);
1581 siphash24_compress_typesafe(rr
->loc
.horiz_pre
, state
);
1582 siphash24_compress_typesafe(rr
->loc
.vert_pre
, state
);
1583 siphash24_compress_typesafe(rr
->loc
.latitude
, state
);
1584 siphash24_compress_typesafe(rr
->loc
.longitude
, state
);
1585 siphash24_compress_typesafe(rr
->loc
.altitude
, state
);
1588 case DNS_TYPE_SSHFP
:
1589 siphash24_compress_typesafe(rr
->sshfp
.algorithm
, state
);
1590 siphash24_compress_typesafe(rr
->sshfp
.fptype
, state
);
1591 siphash24_compress_safe(rr
->sshfp
.fingerprint
, rr
->sshfp
.fingerprint_size
, state
);
1594 case DNS_TYPE_DNSKEY
:
1595 siphash24_compress_typesafe(rr
->dnskey
.flags
, state
);
1596 siphash24_compress_typesafe(rr
->dnskey
.protocol
, state
);
1597 siphash24_compress_typesafe(rr
->dnskey
.algorithm
, state
);
1598 siphash24_compress_safe(rr
->dnskey
.key
, rr
->dnskey
.key_size
, state
);
1601 case DNS_TYPE_RRSIG
:
1602 siphash24_compress_typesafe(rr
->rrsig
.type_covered
, state
);
1603 siphash24_compress_typesafe(rr
->rrsig
.algorithm
, state
);
1604 siphash24_compress_typesafe(rr
->rrsig
.labels
, state
);
1605 siphash24_compress_typesafe(rr
->rrsig
.original_ttl
, state
);
1606 siphash24_compress_typesafe(rr
->rrsig
.expiration
, state
);
1607 siphash24_compress_typesafe(rr
->rrsig
.inception
, state
);
1608 siphash24_compress_typesafe(rr
->rrsig
.key_tag
, state
);
1609 dns_name_hash_func(rr
->rrsig
.signer
, state
);
1610 siphash24_compress_safe(rr
->rrsig
.signature
, rr
->rrsig
.signature_size
, state
);
1614 dns_name_hash_func(rr
->nsec
.next_domain_name
, state
);
1615 /* FIXME: we leave out the type bitmap here. Hash
1616 * would be better if we'd take it into account
1621 siphash24_compress_typesafe(rr
->ds
.key_tag
, state
);
1622 siphash24_compress_typesafe(rr
->ds
.algorithm
, state
);
1623 siphash24_compress_typesafe(rr
->ds
.digest_type
, state
);
1624 siphash24_compress_safe(rr
->ds
.digest
, rr
->ds
.digest_size
, state
);
1627 case DNS_TYPE_NSEC3
:
1628 siphash24_compress_typesafe(rr
->nsec3
.algorithm
, state
);
1629 siphash24_compress_typesafe(rr
->nsec3
.flags
, state
);
1630 siphash24_compress_typesafe(rr
->nsec3
.iterations
, state
);
1631 siphash24_compress_safe(rr
->nsec3
.salt
, rr
->nsec3
.salt_size
, state
);
1632 siphash24_compress_safe(rr
->nsec3
.next_hashed_name
, rr
->nsec3
.next_hashed_name_size
, state
);
1633 /* FIXME: We leave the bitmaps out */
1637 siphash24_compress_typesafe(rr
->tlsa
.cert_usage
, state
);
1638 siphash24_compress_typesafe(rr
->tlsa
.selector
, state
);
1639 siphash24_compress_typesafe(rr
->tlsa
.matching_type
, state
);
1640 siphash24_compress_safe(rr
->tlsa
.data
, rr
->tlsa
.data_size
, state
);
1644 case DNS_TYPE_HTTPS
:
1645 dns_name_hash_func(rr
->svcb
.target_name
, state
);
1646 siphash24_compress_typesafe(rr
->svcb
.priority
, state
);
1647 LIST_FOREACH(params
, j
, rr
->svcb
.params
) {
1648 siphash24_compress_typesafe(j
->key
, state
);
1649 siphash24_compress_safe(j
->value
, j
->length
, state
);
1654 siphash24_compress_typesafe(rr
->caa
.flags
, state
);
1655 string_hash_func(rr
->caa
.tag
, state
);
1656 siphash24_compress_safe(rr
->caa
.value
, rr
->caa
.value_size
, state
);
1659 case DNS_TYPE_NAPTR
:
1660 siphash24_compress_typesafe(rr
->naptr
.order
, state
);
1661 siphash24_compress_typesafe(rr
->naptr
.preference
, state
);
1662 string_hash_func(rr
->naptr
.flags
, state
);
1663 string_hash_func(rr
->naptr
.services
, state
);
1664 string_hash_func(rr
->naptr
.regexp
, state
);
1665 dns_name_hash_func(rr
->naptr
.replacement
, state
);
1668 case DNS_TYPE_OPENPGPKEY
:
1670 siphash24_compress_safe(rr
->generic
.data
, rr
->generic
.data_size
, state
);
1675 int dns_resource_record_compare_func(const DnsResourceRecord
*x
, const DnsResourceRecord
*y
) {
1678 r
= dns_resource_key_compare_func(x
->key
, y
->key
);
1682 if (dns_resource_record_payload_equal(x
, y
) > 0)
1685 /* We still use CMP() here, even though don't implement proper
1686 * ordering, since the hashtable doesn't need ordering anyway. */
1690 DEFINE_HASH_OPS(dns_resource_record_hash_ops
, DnsResourceRecord
, dns_resource_record_hash_func
, dns_resource_record_compare_func
);
1692 DnsResourceRecord
*dns_resource_record_copy(DnsResourceRecord
*rr
) {
1693 _cleanup_(dns_resource_record_unrefp
) DnsResourceRecord
*copy
= NULL
;
1694 DnsResourceRecord
*t
;
1698 copy
= dns_resource_record_new(rr
->key
);
1702 copy
->ttl
= rr
->ttl
;
1703 copy
->expiry
= rr
->expiry
;
1704 copy
->n_skip_labels_signer
= rr
->n_skip_labels_signer
;
1705 copy
->n_skip_labels_source
= rr
->n_skip_labels_source
;
1706 copy
->unparsable
= rr
->unparsable
;
1708 switch (rr
->unparsable
? _DNS_TYPE_INVALID
: rr
->key
->type
) {
1711 copy
->srv
.priority
= rr
->srv
.priority
;
1712 copy
->srv
.weight
= rr
->srv
.weight
;
1713 copy
->srv
.port
= rr
->srv
.port
;
1714 copy
->srv
.name
= strdup(rr
->srv
.name
);
1715 if (!copy
->srv
.name
)
1721 case DNS_TYPE_CNAME
:
1722 case DNS_TYPE_DNAME
:
1723 copy
->ptr
.name
= strdup(rr
->ptr
.name
);
1724 if (!copy
->ptr
.name
)
1728 case DNS_TYPE_HINFO
:
1729 copy
->hinfo
.cpu
= strdup(rr
->hinfo
.cpu
);
1730 if (!copy
->hinfo
.cpu
)
1733 copy
->hinfo
.os
= strdup(rr
->hinfo
.os
);
1734 if (!copy
->hinfo
.os
)
1740 copy
->txt
.items
= dns_txt_item_copy(rr
->txt
.items
);
1741 if (!copy
->txt
.items
)
1750 copy
->aaaa
= rr
->aaaa
;
1754 copy
->soa
.mname
= strdup(rr
->soa
.mname
);
1755 if (!copy
->soa
.mname
)
1757 copy
->soa
.rname
= strdup(rr
->soa
.rname
);
1758 if (!copy
->soa
.rname
)
1760 copy
->soa
.serial
= rr
->soa
.serial
;
1761 copy
->soa
.refresh
= rr
->soa
.refresh
;
1762 copy
->soa
.retry
= rr
->soa
.retry
;
1763 copy
->soa
.expire
= rr
->soa
.expire
;
1764 copy
->soa
.minimum
= rr
->soa
.minimum
;
1768 copy
->mx
.priority
= rr
->mx
.priority
;
1769 copy
->mx
.exchange
= strdup(rr
->mx
.exchange
);
1770 if (!copy
->mx
.exchange
)
1775 copy
->loc
= rr
->loc
;
1778 case DNS_TYPE_SSHFP
:
1779 copy
->sshfp
.algorithm
= rr
->sshfp
.algorithm
;
1780 copy
->sshfp
.fptype
= rr
->sshfp
.fptype
;
1781 copy
->sshfp
.fingerprint
= memdup(rr
->sshfp
.fingerprint
, rr
->sshfp
.fingerprint_size
);
1782 if (!copy
->sshfp
.fingerprint
)
1784 copy
->sshfp
.fingerprint_size
= rr
->sshfp
.fingerprint_size
;
1787 case DNS_TYPE_DNSKEY
:
1788 copy
->dnskey
.flags
= rr
->dnskey
.flags
;
1789 copy
->dnskey
.protocol
= rr
->dnskey
.protocol
;
1790 copy
->dnskey
.algorithm
= rr
->dnskey
.algorithm
;
1791 copy
->dnskey
.key
= memdup(rr
->dnskey
.key
, rr
->dnskey
.key_size
);
1792 if (!copy
->dnskey
.key
)
1794 copy
->dnskey
.key_size
= rr
->dnskey
.key_size
;
1797 case DNS_TYPE_RRSIG
:
1798 copy
->rrsig
.type_covered
= rr
->rrsig
.type_covered
;
1799 copy
->rrsig
.algorithm
= rr
->rrsig
.algorithm
;
1800 copy
->rrsig
.labels
= rr
->rrsig
.labels
;
1801 copy
->rrsig
.original_ttl
= rr
->rrsig
.original_ttl
;
1802 copy
->rrsig
.expiration
= rr
->rrsig
.expiration
;
1803 copy
->rrsig
.inception
= rr
->rrsig
.inception
;
1804 copy
->rrsig
.key_tag
= rr
->rrsig
.key_tag
;
1805 copy
->rrsig
.signer
= strdup(rr
->rrsig
.signer
);
1806 if (!copy
->rrsig
.signer
)
1808 copy
->rrsig
.signature
= memdup(rr
->rrsig
.signature
, rr
->rrsig
.signature_size
);
1809 if (!copy
->rrsig
.signature
)
1811 copy
->rrsig
.signature_size
= rr
->rrsig
.signature_size
;
1815 copy
->nsec
.next_domain_name
= strdup(rr
->nsec
.next_domain_name
);
1816 if (!copy
->nsec
.next_domain_name
)
1818 if (rr
->nsec
.types
) {
1819 copy
->nsec
.types
= bitmap_copy(rr
->nsec
.types
);
1820 if (!copy
->nsec
.types
)
1826 copy
->ds
.key_tag
= rr
->ds
.key_tag
;
1827 copy
->ds
.algorithm
= rr
->ds
.algorithm
;
1828 copy
->ds
.digest_type
= rr
->ds
.digest_type
;
1829 copy
->ds
.digest
= memdup(rr
->ds
.digest
, rr
->ds
.digest_size
);
1830 if (!copy
->ds
.digest
)
1832 copy
->ds
.digest_size
= rr
->ds
.digest_size
;
1835 case DNS_TYPE_NSEC3
:
1836 copy
->nsec3
.algorithm
= rr
->nsec3
.algorithm
;
1837 copy
->nsec3
.flags
= rr
->nsec3
.flags
;
1838 copy
->nsec3
.iterations
= rr
->nsec3
.iterations
;
1839 copy
->nsec3
.salt
= memdup(rr
->nsec3
.salt
, rr
->nsec3
.salt_size
);
1840 if (!copy
->nsec3
.salt
)
1842 copy
->nsec3
.salt_size
= rr
->nsec3
.salt_size
;
1843 copy
->nsec3
.next_hashed_name
= memdup(rr
->nsec3
.next_hashed_name
, rr
->nsec3
.next_hashed_name_size
);
1844 if (!copy
->nsec3
.next_hashed_name
)
1846 copy
->nsec3
.next_hashed_name_size
= rr
->nsec3
.next_hashed_name_size
;
1847 if (rr
->nsec3
.types
) {
1848 copy
->nsec3
.types
= bitmap_copy(rr
->nsec3
.types
);
1849 if (!copy
->nsec3
.types
)
1855 copy
->tlsa
.cert_usage
= rr
->tlsa
.cert_usage
;
1856 copy
->tlsa
.selector
= rr
->tlsa
.selector
;
1857 copy
->tlsa
.matching_type
= rr
->tlsa
.matching_type
;
1858 copy
->tlsa
.data
= memdup(rr
->tlsa
.data
, rr
->tlsa
.data_size
);
1859 if (!copy
->tlsa
.data
)
1861 copy
->tlsa
.data_size
= rr
->tlsa
.data_size
;
1865 copy
->caa
.flags
= rr
->caa
.flags
;
1866 copy
->caa
.tag
= strdup(rr
->caa
.tag
);
1869 copy
->caa
.value
= memdup(rr
->caa
.value
, rr
->caa
.value_size
);
1870 if (!copy
->caa
.value
)
1872 copy
->caa
.value_size
= rr
->caa
.value_size
;
1876 case DNS_TYPE_HTTPS
:
1877 copy
->svcb
.priority
= rr
->svcb
.priority
;
1878 copy
->svcb
.target_name
= strdup(rr
->svcb
.target_name
);
1879 if (!copy
->svcb
.target_name
)
1881 copy
->svcb
.params
= dns_svc_params_copy(rr
->svcb
.params
);
1882 if (rr
->svcb
.params
&& !copy
->svcb
.params
)
1886 case DNS_TYPE_NAPTR
:
1887 copy
->naptr
.order
= rr
->naptr
.order
;
1888 copy
->naptr
.preference
= rr
->naptr
.preference
;
1889 copy
->naptr
.flags
= strdup(rr
->naptr
.flags
);
1890 if (!copy
->naptr
.flags
)
1892 copy
->naptr
.services
= strdup(rr
->naptr
.services
);
1893 if (!copy
->naptr
.services
)
1895 copy
->naptr
.regexp
= strdup(rr
->naptr
.regexp
);
1896 if (!copy
->naptr
.regexp
)
1898 copy
->naptr
.replacement
= strdup(rr
->naptr
.replacement
);
1899 if (!copy
->naptr
.replacement
)
1905 copy
->generic
.data
= memdup(rr
->generic
.data
, rr
->generic
.data_size
);
1906 if (!copy
->generic
.data
)
1908 copy
->generic
.data_size
= rr
->generic
.data_size
;
1917 int dns_resource_record_clamp_ttl(DnsResourceRecord
**rr
, uint32_t max_ttl
) {
1918 DnsResourceRecord
*old_rr
, *new_rr
;
1924 if (old_rr
->key
->type
== DNS_TYPE_OPT
)
1927 new_ttl
= MIN(old_rr
->ttl
, max_ttl
);
1928 if (new_ttl
== old_rr
->ttl
)
1931 if (old_rr
->n_ref
== 1) {
1932 /* Patch in place */
1933 old_rr
->ttl
= new_ttl
;
1937 new_rr
= dns_resource_record_copy(old_rr
);
1941 new_rr
->ttl
= new_ttl
;
1943 DNS_RR_REPLACE(*rr
, new_rr
);
1947 bool dns_resource_record_is_link_local_address(DnsResourceRecord
*rr
) {
1950 if (rr
->key
->class != DNS_CLASS_IN
)
1953 if (rr
->key
->type
== DNS_TYPE_A
)
1954 return in4_addr_is_link_local(&rr
->a
.in_addr
);
1956 if (rr
->key
->type
== DNS_TYPE_AAAA
)
1957 return in6_addr_is_link_local(&rr
->aaaa
.in6_addr
);
1962 int dns_resource_record_get_cname_target(DnsResourceKey
*key
, DnsResourceRecord
*cname
, char **ret
) {
1963 _cleanup_free_
char *d
= NULL
;
1969 /* Checks if the RR `cname` is a CNAME/DNAME RR that matches the specified `key`. If so, returns the
1970 * target domain. If not, returns -EUNATCH */
1972 if (key
->class != cname
->key
->class && key
->class != DNS_CLASS_ANY
)
1975 if (!dns_type_may_redirect(key
->type
)) /* This key type is not subject to CNAME/DNAME redirection?
1976 * Then let's refuse right-away */
1979 if (cname
->key
->type
== DNS_TYPE_CNAME
) {
1980 r
= dns_name_equal(dns_resource_key_name(key
),
1981 dns_resource_key_name(cname
->key
));
1985 return -EUNATCH
; /* CNAME RR key doesn't actually match the original key */
1987 d
= strdup(cname
->cname
.name
);
1991 } else if (cname
->key
->type
== DNS_TYPE_DNAME
) {
1993 r
= dns_name_change_suffix(
1994 dns_resource_key_name(key
),
1995 dns_resource_key_name(cname
->key
),
2001 return -EUNATCH
; /* DNAME RR key doesn't actually match the original key */
2004 return -EUNATCH
; /* Not a CNAME/DNAME RR, hence doesn't match the proposition either */
2010 DnsTxtItem
*dns_txt_item_free_all(DnsTxtItem
*first
) {
2011 LIST_FOREACH(items
, i
, first
)
2017 DnsSvcParam
*dns_svc_param_free_all(DnsSvcParam
*first
) {
2018 LIST_FOREACH(params
, i
, first
)
2024 bool dns_txt_item_equal(DnsTxtItem
*a
, DnsTxtItem
*b
) {
2030 LIST_FOREACH(items
, aa
, a
) {
2034 if (memcmp_nn(aa
->data
, aa
->length
, bb
->data
, bb
->length
) != 0)
2037 bb
= bb
->items_next
;
2043 DnsTxtItem
*dns_txt_item_copy(DnsTxtItem
*first
) {
2044 DnsTxtItem
*copy
= NULL
, *end
= NULL
;
2046 LIST_FOREACH(items
, i
, first
) {
2049 j
= memdup(i
, offsetof(DnsTxtItem
, data
) + i
->length
+ 1);
2051 return dns_txt_item_free_all(copy
);
2053 LIST_INSERT_AFTER(items
, copy
, end
, j
);
2060 bool dns_svc_params_equal(DnsSvcParam
*a
, DnsSvcParam
*b
) {
2061 DnsSvcParam
*bb
= b
;
2066 LIST_FOREACH(params
, aa
, a
) {
2070 if (aa
->key
!= bb
->key
)
2073 if (memcmp_nn(aa
->value
, aa
->length
, bb
->value
, bb
->length
) != 0)
2076 bb
= bb
->params_next
;
2082 DnsSvcParam
*dns_svc_params_copy(DnsSvcParam
*first
) {
2083 DnsSvcParam
*copy
= NULL
, *end
= NULL
;
2085 LIST_FOREACH(params
, i
, first
) {
2088 j
= memdup(i
, offsetof(DnsSvcParam
, value
) + i
->length
);
2090 return dns_svc_param_free_all(copy
);
2092 LIST_INSERT_AFTER(params
, copy
, end
, j
);
2099 int dns_txt_item_new_empty(DnsTxtItem
**ret
) {
2104 /* RFC 6763, section 6.1 suggests to treat
2105 * empty TXT RRs as equivalent to a TXT record
2106 * with a single empty string. */
2108 i
= malloc0(offsetof(DnsTxtItem
, data
) + 1); /* for safety reasons we add an extra NUL byte */
2116 int dns_resource_record_new_from_raw(DnsResourceRecord
**ret
, const void *data
, size_t size
) {
2117 _cleanup_(dns_packet_unrefp
) DnsPacket
*p
= NULL
;
2120 r
= dns_packet_new(&p
, DNS_PROTOCOL_DNS
, 0, DNS_PACKET_SIZE_MAX
);
2124 p
->refuse_compression
= true;
2126 r
= dns_packet_append_blob(p
, data
, size
, NULL
);
2130 return dns_packet_read_rr(p
, ret
, NULL
, NULL
);
2133 int dns_resource_key_to_json(DnsResourceKey
*key
, JsonVariant
**ret
) {
2137 return json_build(ret
,
2139 JSON_BUILD_PAIR("class", JSON_BUILD_INTEGER(key
->class)),
2140 JSON_BUILD_PAIR("type", JSON_BUILD_INTEGER(key
->type
)),
2141 JSON_BUILD_PAIR("name", JSON_BUILD_STRING(dns_resource_key_name(key
)))));
2144 int dns_resource_key_from_json(JsonVariant
*v
, DnsResourceKey
**ret
) {
2145 _cleanup_(dns_resource_key_unrefp
) DnsResourceKey
*key
= NULL
;
2146 uint16_t type
= 0, class = 0;
2147 const char *name
= NULL
;
2150 JsonDispatch dispatch_table
[] = {
2151 { "class", _JSON_VARIANT_TYPE_INVALID
, json_dispatch_uint16
, PTR_TO_SIZE(&class), JSON_MANDATORY
},
2152 { "type", _JSON_VARIANT_TYPE_INVALID
, json_dispatch_uint16
, PTR_TO_SIZE(&type
), JSON_MANDATORY
},
2153 { "name", JSON_VARIANT_STRING
, json_dispatch_const_string
, PTR_TO_SIZE(&name
), JSON_MANDATORY
},
2160 r
= json_dispatch(v
, dispatch_table
, 0, NULL
);
2164 key
= dns_resource_key_new(class, type
, name
);
2168 *ret
= TAKE_PTR(key
);
2172 static int type_bitmap_to_json(Bitmap
*b
, JsonVariant
**ret
) {
2173 _cleanup_(json_variant_unrefp
) JsonVariant
*l
= NULL
;
2179 BITMAP_FOREACH(t
, b
) {
2180 _cleanup_(json_variant_unrefp
) JsonVariant
*v
= NULL
;
2182 r
= json_variant_new_unsigned(&v
, t
);
2186 r
= json_variant_append_array(&l
, v
);
2192 return json_variant_new_array(ret
, NULL
, 0);
2198 static int txt_to_json(DnsTxtItem
*items
, JsonVariant
**ret
) {
2199 JsonVariant
**elements
= NULL
;
2205 LIST_FOREACH(items
, i
, items
) {
2206 if (!GREEDY_REALLOC(elements
, n
+ 1)) {
2211 r
= json_variant_new_octescape(elements
+ n
, i
->data
, i
->length
);
2218 r
= json_variant_new_array(ret
, elements
, n
);
2221 json_variant_unref_many(elements
, n
);
2225 static int svc_params_to_json(DnsSvcParam
*params
, JsonVariant
**ret
) {
2226 JsonVariant
**elements
= NULL
;
2232 LIST_FOREACH(params
, i
, params
) {
2233 if (!GREEDY_REALLOC(elements
, n
+ 1)) {
2238 r
= json_variant_new_base64(elements
+ n
, i
->value
, i
->length
);
2245 r
= json_variant_new_array(ret
, elements
, n
);
2247 json_variant_unref_many(elements
, n
);
2251 int dns_resource_record_to_json(DnsResourceRecord
*rr
, JsonVariant
**ret
) {
2252 _cleanup_(json_variant_unrefp
) JsonVariant
*k
= NULL
;
2258 r
= dns_resource_key_to_json(rr
->key
, &k
);
2262 switch (rr
->unparsable
? _DNS_TYPE_INVALID
: rr
->key
->type
) {
2265 return json_build(ret
,
2267 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2268 JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr
->srv
.priority
)),
2269 JSON_BUILD_PAIR("weight", JSON_BUILD_UNSIGNED(rr
->srv
.weight
)),
2270 JSON_BUILD_PAIR("port", JSON_BUILD_UNSIGNED(rr
->srv
.port
)),
2271 JSON_BUILD_PAIR("name", JSON_BUILD_STRING(rr
->srv
.name
))));
2275 case DNS_TYPE_CNAME
:
2276 case DNS_TYPE_DNAME
:
2277 return json_build(ret
,
2279 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2280 JSON_BUILD_PAIR("name", JSON_BUILD_STRING(rr
->ptr
.name
))));
2282 case DNS_TYPE_HINFO
:
2283 return json_build(ret
,
2285 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2286 JSON_BUILD_PAIR("cpu", JSON_BUILD_STRING(rr
->hinfo
.cpu
)),
2287 JSON_BUILD_PAIR("os", JSON_BUILD_STRING(rr
->hinfo
.os
))));
2290 case DNS_TYPE_TXT
: {
2291 _cleanup_(json_variant_unrefp
) JsonVariant
*l
= NULL
;
2293 r
= txt_to_json(rr
->txt
.items
, &l
);
2297 return json_build(ret
,
2299 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2300 JSON_BUILD_PAIR("items", JSON_BUILD_VARIANT(l
))));
2304 return json_build(ret
,
2306 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2307 JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr
->a
.in_addr
))));
2310 return json_build(ret
,
2312 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2313 JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr
->aaaa
.in6_addr
))));
2316 return json_build(ret
,
2318 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2319 JSON_BUILD_PAIR("mname", JSON_BUILD_STRING(rr
->soa
.mname
)),
2320 JSON_BUILD_PAIR("rname", JSON_BUILD_STRING(rr
->soa
.rname
)),
2321 JSON_BUILD_PAIR("serial", JSON_BUILD_UNSIGNED(rr
->soa
.serial
)),
2322 JSON_BUILD_PAIR("refresh", JSON_BUILD_UNSIGNED(rr
->soa
.refresh
)),
2323 JSON_BUILD_PAIR("expire", JSON_BUILD_UNSIGNED(rr
->soa
.retry
)),
2324 JSON_BUILD_PAIR("minimum", JSON_BUILD_UNSIGNED(rr
->soa
.minimum
))));
2327 return json_build(ret
,
2329 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2330 JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr
->mx
.priority
)),
2331 JSON_BUILD_PAIR("exchange", JSON_BUILD_STRING(rr
->mx
.exchange
))));
2333 return json_build(ret
,
2335 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2336 JSON_BUILD_PAIR("version", JSON_BUILD_UNSIGNED(rr
->loc
.version
)),
2337 JSON_BUILD_PAIR("size", JSON_BUILD_UNSIGNED(rr
->loc
.size
)),
2338 JSON_BUILD_PAIR("horiz_pre", JSON_BUILD_UNSIGNED(rr
->loc
.horiz_pre
)),
2339 JSON_BUILD_PAIR("vert_pre", JSON_BUILD_UNSIGNED(rr
->loc
.vert_pre
)),
2340 JSON_BUILD_PAIR("latitude", JSON_BUILD_UNSIGNED(rr
->loc
.latitude
)),
2341 JSON_BUILD_PAIR("longitude", JSON_BUILD_UNSIGNED(rr
->loc
.longitude
)),
2342 JSON_BUILD_PAIR("altitude", JSON_BUILD_UNSIGNED(rr
->loc
.altitude
))));
2345 return json_build(ret
,
2347 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2348 JSON_BUILD_PAIR("keyTag", JSON_BUILD_UNSIGNED(rr
->ds
.key_tag
)),
2349 JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr
->ds
.algorithm
)),
2350 JSON_BUILD_PAIR("digestType", JSON_BUILD_UNSIGNED(rr
->ds
.digest_type
)),
2351 JSON_BUILD_PAIR("digest", JSON_BUILD_HEX(rr
->ds
.digest
, rr
->ds
.digest_size
))));
2353 case DNS_TYPE_SSHFP
:
2354 return json_build(ret
,
2356 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2357 JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr
->sshfp
.algorithm
)),
2358 JSON_BUILD_PAIR("fptype", JSON_BUILD_UNSIGNED(rr
->sshfp
.fptype
)),
2359 JSON_BUILD_PAIR("fingerprint", JSON_BUILD_HEX(rr
->sshfp
.fingerprint
, rr
->sshfp
.fingerprint_size
))));
2361 case DNS_TYPE_DNSKEY
:
2362 return json_build(ret
,
2364 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2365 JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr
->dnskey
.flags
)),
2366 JSON_BUILD_PAIR("protocol", JSON_BUILD_UNSIGNED(rr
->dnskey
.protocol
)),
2367 JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr
->dnskey
.algorithm
)),
2368 JSON_BUILD_PAIR("dnskey", JSON_BUILD_BASE64(rr
->dnskey
.key
, rr
->dnskey
.key_size
))));
2371 case DNS_TYPE_RRSIG
:
2372 return json_build(ret
,
2374 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2375 JSON_BUILD_PAIR("signer", JSON_BUILD_STRING(rr
->rrsig
.signer
)),
2376 JSON_BUILD_PAIR("typeCovered", JSON_BUILD_UNSIGNED(rr
->rrsig
.type_covered
)),
2377 JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr
->rrsig
.algorithm
)),
2378 JSON_BUILD_PAIR("labels", JSON_BUILD_UNSIGNED(rr
->rrsig
.labels
)),
2379 JSON_BUILD_PAIR("originalTtl", JSON_BUILD_UNSIGNED(rr
->rrsig
.original_ttl
)),
2380 JSON_BUILD_PAIR("expiration", JSON_BUILD_UNSIGNED(rr
->rrsig
.expiration
)),
2381 JSON_BUILD_PAIR("inception", JSON_BUILD_UNSIGNED(rr
->rrsig
.inception
)),
2382 JSON_BUILD_PAIR("keyTag", JSON_BUILD_UNSIGNED(rr
->rrsig
.key_tag
)),
2383 JSON_BUILD_PAIR("signature", JSON_BUILD_BASE64(rr
->rrsig
.signature
, rr
->rrsig
.signature_size
))));
2385 case DNS_TYPE_NSEC
: {
2386 _cleanup_(json_variant_unrefp
) JsonVariant
*bm
= NULL
;
2388 r
= type_bitmap_to_json(rr
->nsec
.types
, &bm
);
2392 return json_build(ret
,
2394 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2395 JSON_BUILD_PAIR("nextDomain", JSON_BUILD_STRING(rr
->nsec
.next_domain_name
)),
2396 JSON_BUILD_PAIR("types", JSON_BUILD_VARIANT(bm
))));
2399 case DNS_TYPE_NSEC3
: {
2400 _cleanup_(json_variant_unrefp
) JsonVariant
*bm
= NULL
;
2402 r
= type_bitmap_to_json(rr
->nsec3
.types
, &bm
);
2406 return json_build(ret
,
2408 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2409 JSON_BUILD_PAIR("algorithm", JSON_BUILD_UNSIGNED(rr
->nsec3
.algorithm
)),
2410 JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr
->nsec3
.flags
)),
2411 JSON_BUILD_PAIR("iterations", JSON_BUILD_UNSIGNED(rr
->nsec3
.iterations
)),
2412 JSON_BUILD_PAIR("salt", JSON_BUILD_HEX(rr
->nsec3
.salt
, rr
->nsec3
.salt_size
)),
2413 JSON_BUILD_PAIR("hash", JSON_BUILD_BASE32HEX(rr
->nsec3
.next_hashed_name
, rr
->nsec3
.next_hashed_name_size
)),
2414 JSON_BUILD_PAIR("types", JSON_BUILD_VARIANT(bm
))));
2418 return json_build(ret
,
2420 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2421 JSON_BUILD_PAIR("certUsage", JSON_BUILD_UNSIGNED(rr
->tlsa
.cert_usage
)),
2422 JSON_BUILD_PAIR("selector", JSON_BUILD_UNSIGNED(rr
->tlsa
.selector
)),
2423 JSON_BUILD_PAIR("matchingType", JSON_BUILD_UNSIGNED(rr
->tlsa
.matching_type
)),
2424 JSON_BUILD_PAIR("data", JSON_BUILD_HEX(rr
->tlsa
.data
, rr
->tlsa
.data_size
))));
2427 case DNS_TYPE_HTTPS
: {
2428 _cleanup_(json_variant_unrefp
) JsonVariant
*p
= NULL
;
2429 r
= svc_params_to_json(rr
->svcb
.params
, &p
);
2433 return json_build(ret
,
2435 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2436 JSON_BUILD_PAIR("priority", JSON_BUILD_UNSIGNED(rr
->svcb
.priority
)),
2437 JSON_BUILD_PAIR("target", JSON_BUILD_STRING(rr
->svcb
.target_name
)),
2438 JSON_BUILD_PAIR("params", JSON_BUILD_VARIANT(p
))));
2442 return json_build(ret
,
2444 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2445 JSON_BUILD_PAIR("flags", JSON_BUILD_UNSIGNED(rr
->caa
.flags
)),
2446 JSON_BUILD_PAIR("tag", JSON_BUILD_STRING(rr
->caa
.tag
)),
2447 JSON_BUILD_PAIR("value", JSON_BUILD_OCTESCAPE(rr
->caa
.value
, rr
->caa
.value_size
))));
2449 case DNS_TYPE_NAPTR
:
2450 return json_build(ret
,
2452 JSON_BUILD_PAIR("key", JSON_BUILD_VARIANT(k
)),
2453 JSON_BUILD_PAIR("order", JSON_BUILD_UNSIGNED(rr
->naptr
.order
)),
2454 JSON_BUILD_PAIR("preference", JSON_BUILD_UNSIGNED(rr
->naptr
.preference
)),
2455 /* NB: we name this flags field here naptrFlags, because there's already another "flags" field (for example in CAA) which has a different type */
2456 JSON_BUILD_PAIR("naptrFlags", JSON_BUILD_STRING(rr
->naptr
.flags
)),
2457 JSON_BUILD_PAIR("services", JSON_BUILD_STRING(rr
->naptr
.services
)),
2458 JSON_BUILD_PAIR("regexp", JSON_BUILD_STRING(rr
->naptr
.regexp
)),
2459 JSON_BUILD_PAIR("replacement", JSON_BUILD_STRING(rr
->naptr
.replacement
))));
2462 /* Can't provide broken-down format */
2468 static const char* const dnssec_algorithm_table
[_DNSSEC_ALGORITHM_MAX_DEFINED
] = {
2469 /* Mnemonics as listed on https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml */
2470 [DNSSEC_ALGORITHM_RSAMD5
] = "RSAMD5",
2471 [DNSSEC_ALGORITHM_DH
] = "DH",
2472 [DNSSEC_ALGORITHM_DSA
] = "DSA",
2473 [DNSSEC_ALGORITHM_ECC
] = "ECC",
2474 [DNSSEC_ALGORITHM_RSASHA1
] = "RSASHA1",
2475 [DNSSEC_ALGORITHM_DSA_NSEC3_SHA1
] = "DSA-NSEC3-SHA1",
2476 [DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1
] = "RSASHA1-NSEC3-SHA1",
2477 [DNSSEC_ALGORITHM_RSASHA256
] = "RSASHA256",
2478 [DNSSEC_ALGORITHM_RSASHA512
] = "RSASHA512",
2479 [DNSSEC_ALGORITHM_ECC_GOST
] = "ECC-GOST",
2480 [DNSSEC_ALGORITHM_ECDSAP256SHA256
] = "ECDSAP256SHA256",
2481 [DNSSEC_ALGORITHM_ECDSAP384SHA384
] = "ECDSAP384SHA384",
2482 [DNSSEC_ALGORITHM_ED25519
] = "ED25519",
2483 [DNSSEC_ALGORITHM_ED448
] = "ED448",
2484 [DNSSEC_ALGORITHM_INDIRECT
] = "INDIRECT",
2485 [DNSSEC_ALGORITHM_PRIVATEDNS
] = "PRIVATEDNS",
2486 [DNSSEC_ALGORITHM_PRIVATEOID
] = "PRIVATEOID",
2488 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_algorithm
, int, 255);
2490 static const char* const dnssec_digest_table
[_DNSSEC_DIGEST_MAX_DEFINED
] = {
2491 /* Names as listed on https://www.iana.org/assignments/ds-rr-types/ds-rr-types.xhtml */
2492 [DNSSEC_DIGEST_SHA1
] = "SHA-1",
2493 [DNSSEC_DIGEST_SHA256
] = "SHA-256",
2494 [DNSSEC_DIGEST_GOST_R_34_11_94
] = "GOST_R_34.11-94",
2495 [DNSSEC_DIGEST_SHA384
] = "SHA-384",
2497 DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_digest
, int, 255);