HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/shared/dns-rr.c

94,596 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 26d2e3934a0bb04bd375985dfea1ee4f397cf9a2

Lines 2001–2688 of 2,688

}
 
bool dns_resource_record_is_link_local_address(DnsResourceRecord *rr) {
        assert(rr);
 
        if (rr->key->class != DNS_CLASS_IN)
                return false;
 
        if (rr->key->type == DNS_TYPE_A)
                return in4_addr_is_link_local(&rr->a.in_addr);
 
        if (rr->key->type == DNS_TYPE_AAAA)
                return in6_addr_is_link_local(&rr->aaaa.in6_addr);
 
        return false;
}
 
int dns_resource_record_get_cname_target(DnsResourceKey *key, DnsResourceRecord *cname, char **ret) {
        _cleanup_free_ char *d = NULL;
        int r;
 
        assert(key);
        assert(cname);
        assert(ret);
 
        /* Checks if the RR `cname` is a CNAME/DNAME RR that matches the specified `key`. If so, returns the
         * target domain. If not, returns -EUNATCH */
 
        if (key->class != cname->key->class && key->class != DNS_CLASS_ANY)
                return -EUNATCH;
 
        if (!dns_type_may_redirect(key->type)) /* This key type is not subject to CNAME/DNAME redirection?
                                                * Then let's refuse right-away */
                return -EUNATCH;
 
        if (cname->key->type == DNS_TYPE_CNAME) {
                r = dns_name_equal(dns_resource_key_name(key),
                                   dns_resource_key_name(cname->key));
                if (r < 0)
                        return r;
                if (r == 0)
                        return -EUNATCH; /* CNAME RR key doesn't actually match the original key */
 
                d = strdup(cname->cname.name);
                if (!d)
                        return -ENOMEM;
 
        } else if (cname->key->type == DNS_TYPE_DNAME) {
 
                r = dns_name_change_suffix(
                                dns_resource_key_name(key),
                                dns_resource_key_name(cname->key),
                                cname->dname.name,
                                &d);
                if (r < 0)
                        return r;
                if (r == 0)
                        return -EUNATCH; /* DNAME RR key doesn't actually match the original key */
 
        } else
                return -EUNATCH; /* Not a CNAME/DNAME RR, hence doesn't match the proposition either */
 
        *ret = TAKE_PTR(d);
        return 0;
}
 
DnsTxtItem *dns_txt_item_free_all(DnsTxtItem *first) {
        LIST_FOREACH(items, i, first)
                free(i);
 
        return NULL;
}
 
DnsSvcParam *dns_svc_param_free_all(DnsSvcParam *first) {
        LIST_FOREACH(params, i, first)
                free(i);
 
        return NULL;
}
 
bool dns_txt_item_equal(DnsTxtItem *a, DnsTxtItem *b) {
        DnsTxtItem *bb = b;
 
        if (a == b)
                return true;
 
        LIST_FOREACH(items, aa, a) {
                if (!bb)
                        return false;
 
                if (memcmp_nn(aa->data, aa->length, bb->data, bb->length) != 0)
                        return false;
 
                bb = bb->items_next;
        }
 
        return !bb;
}
 
DnsTxtItem *dns_txt_item_copy(DnsTxtItem *first) {
        DnsTxtItem *copy = NULL, *end = NULL;
 
        LIST_FOREACH(items, i, first) {
                DnsTxtItem *j;
 
                j = memdup(i, offsetof(DnsTxtItem, data) + i->length + 1);
                if (!j)
                        return dns_txt_item_free_all(copy);
 
                LIST_INSERT_AFTER(items, copy, end, j);
                end = j;
        }
 
        return copy;
}
 
bool dns_svc_params_equal(DnsSvcParam *a, DnsSvcParam *b) {
        DnsSvcParam *bb = b;
 
        if (a == b)
                return true;
 
        LIST_FOREACH(params, aa, a) {
                if (!bb)
                        return false;
 
                if (aa->key != bb->key)
                        return false;
 
                if (memcmp_nn(aa->value, aa->length, bb->value, bb->length) != 0)
                        return false;
 
                bb = bb->params_next;
        }
 
        return !bb;
}
 
DnsSvcParam *dns_svc_params_copy(DnsSvcParam *first) {
        DnsSvcParam *copy = NULL, *end = NULL;
 
        LIST_FOREACH(params, i, first) {
                DnsSvcParam *j;
 
                j = memdup(i, offsetof(DnsSvcParam, value) + i->length);
                if (!j)
                        return dns_svc_param_free_all(copy);
 
                LIST_INSERT_AFTER(params, copy, end, j);
                end = j;
        }
 
        return copy;
}
 
int dns_txt_item_new_empty(DnsTxtItem **ret) {
        DnsTxtItem *i;
 
        assert(ret);
 
        /* RFC 6763, section 6.1 suggests to treat
         * empty TXT RRs as equivalent to a TXT record
         * with a single empty string. */
 
        i = malloc0(offsetof(DnsTxtItem, data) + 1); /* for safety reasons we add an extra NUL byte */
        if (!i)
                return -ENOMEM;
 
        *ret = i;
        return 0;
}
 
int dns_resource_record_new_from_raw(DnsResourceRecord **ret, const void *data, size_t size) {
        _cleanup_(dns_packet_unrefp) DnsPacket *p = NULL;
        int r;
 
        r = dns_packet_new(&p, DNS_PROTOCOL_DNS, 0, DNS_PACKET_SIZE_MAX);
        if (r < 0)
                return r;
 
        p->refuse_compression = true;
 
        r = dns_packet_append_blob(p, data, size, NULL);
        if (r < 0)
                return r;
 
        return dns_packet_read_rr(p, ret, NULL, NULL);
}
 
int dns_resource_key_to_json(DnsResourceKey *key, sd_json_variant **ret) {
        assert(key);
        assert(ret);
 
        return sd_json_buildo(
                        ret,
                        SD_JSON_BUILD_PAIR_INTEGER("class", key->class),
                        SD_JSON_BUILD_PAIR_INTEGER("type", key->type),
                        SD_JSON_BUILD_PAIR_STRING("name", dns_resource_key_name(key)));
}
 
int dns_resource_key_from_json(sd_json_variant *v, DnsResourceKey **ret) {
        struct params {
                uint16_t type;
                uint16_t class;
                const char *name;
        };
 
        static const sd_json_dispatch_field dispatch_table[] = {
                { "class", _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16,       offsetof(struct params, class), 0                 },
                { "type",  _SD_JSON_VARIANT_TYPE_INVALID, sd_json_dispatch_uint16,       offsetof(struct params, type),  SD_JSON_MANDATORY },
                { "name",  SD_JSON_VARIANT_STRING,        sd_json_dispatch_const_string, offsetof(struct params, name),  SD_JSON_MANDATORY },
                {}
        };
 
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        struct params p = {
                .class = DNS_CLASS_IN,
        };
        int r;
 
        assert(v);
        assert(ret);
 
        r = sd_json_dispatch(v, dispatch_table, 0, &p);
        if (r < 0)
                return r;
 
        r = dns_name_is_valid(p.name);
        if (r < 0)
                return r;
        if (r == 0)
                return -EBADMSG;
 
        key = dns_resource_key_new(p.class, p.type, p.name);
        if (!key)
                return -ENOMEM;
 
        *ret = TAKE_PTR(key);
        return 0;
}
 
static int type_bitmap_to_json(Bitmap *b, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
        unsigned t;
        int r;
 
        assert(ret);
 
        BITMAP_FOREACH(t, b) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
 
                r = sd_json_variant_new_unsigned(&v, t);
                if (r < 0)
                        return r;
 
                r = sd_json_variant_append_array(&l, v);
                if (r < 0)
                        return r;
        }
 
        if (!l)
                return sd_json_variant_new_array(ret, NULL, 0);
 
        *ret = TAKE_PTR(l);
        return 0;
}
 
static int txt_to_json(DnsTxtItem *items, sd_json_variant **ret) {
        sd_json_variant **elements = NULL;
        size_t n = 0;
        int r;
 
        assert(ret);
 
        LIST_FOREACH(items, i, items) {
                if (!GREEDY_REALLOC(elements, n + 1)) {
                        r = -ENOMEM;
                        goto finalize;
                }
 
                r = sd_json_variant_new_octescape(elements + n, i->data, i->length);
                if (r < 0)
                        goto finalize;
 
                n++;
        }
 
        r = sd_json_variant_new_array(ret, elements, n);
 
finalize:
        sd_json_variant_unref_many(elements, n);
        return r;
}
 
static int svc_params_to_json(DnsSvcParam *params, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *w = NULL;
        int r;
 
        assert(ret);
 
        LIST_FOREACH(params, i, params) {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *v = NULL;
                r = sd_json_variant_new_base64(&v, i->value, i->length);
                if (r < 0)
                        return r;
 
                r = sd_json_variant_set_field(&w, FORMAT_DNS_SVC_PARAM_KEY(i->key), v);
                if (r < 0)
                        return r;
        }
 
        *ret = TAKE_PTR(w);
        return 0;
}
 
int dns_resource_record_to_json(DnsResourceRecord *rr, sd_json_variant **ret) {
        _cleanup_(sd_json_variant_unrefp) sd_json_variant *k = NULL;
        int r;
 
        assert(rr);
 
        r = dns_resource_key_to_json(rr->key, &k);
        if (r < 0)
                return r;
 
        switch (rr->unparsable ? _DNS_TYPE_INVALID : rr->key->type) {
 
        case DNS_TYPE_SRV:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->srv.priority),
                                SD_JSON_BUILD_PAIR_UNSIGNED("weight", rr->srv.weight),
                                SD_JSON_BUILD_PAIR_UNSIGNED("port", rr->srv.port),
                                SD_JSON_BUILD_PAIR_STRING("name", rr->srv.name));
 
        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
        case DNS_TYPE_DNAME:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_STRING("name", rr->ptr.name));
 
        case DNS_TYPE_HINFO:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_STRING("cpu", rr->hinfo.cpu),
                                SD_JSON_BUILD_PAIR_STRING("os", rr->hinfo.os));
 
        case DNS_TYPE_SPF:
        case DNS_TYPE_TXT: {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *l = NULL;
 
                r = txt_to_json(rr->txt.items, &l);
                if (r < 0)
                        return r;
 
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_VARIANT("items", l));
        }
 
        case DNS_TYPE_A:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN4_ADDR(&rr->a.in_addr)));
 
        case DNS_TYPE_AAAA:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR("address", JSON_BUILD_IN6_ADDR(&rr->aaaa.in6_addr)));
 
        case DNS_TYPE_SOA:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_STRING("mname", rr->soa.mname),
                                SD_JSON_BUILD_PAIR_STRING("rname", rr->soa.rname),
                                SD_JSON_BUILD_PAIR_UNSIGNED("serial", rr->soa.serial),
                                SD_JSON_BUILD_PAIR_UNSIGNED("refresh", rr->soa.refresh),
                                SD_JSON_BUILD_PAIR_UNSIGNED("retry", rr->soa.retry),
                                SD_JSON_BUILD_PAIR_UNSIGNED("expire", rr->soa.expire),
                                SD_JSON_BUILD_PAIR_UNSIGNED("minimum", rr->soa.minimum));
 
        case DNS_TYPE_MX:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->mx.priority),
                                SD_JSON_BUILD_PAIR_STRING("exchange", rr->mx.exchange));
        case DNS_TYPE_LOC:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("version", rr->loc.version),
                                SD_JSON_BUILD_PAIR_UNSIGNED("size", rr->loc.size),
                                SD_JSON_BUILD_PAIR_UNSIGNED("horiz_pre", rr->loc.horiz_pre),
                                SD_JSON_BUILD_PAIR_UNSIGNED("vert_pre", rr->loc.vert_pre),
                                SD_JSON_BUILD_PAIR_UNSIGNED("latitude", rr->loc.latitude),
                                SD_JSON_BUILD_PAIR_UNSIGNED("longitude", rr->loc.longitude),
                                SD_JSON_BUILD_PAIR_UNSIGNED("altitude", rr->loc.altitude));
 
        case DNS_TYPE_DS:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->ds.key_tag),
                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->ds.algorithm),
                                SD_JSON_BUILD_PAIR_UNSIGNED("digestType", rr->ds.digest_type),
                                SD_JSON_BUILD_PAIR_HEX("digest", rr->ds.digest, rr->ds.digest_size));
 
        case DNS_TYPE_SSHFP:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->sshfp.algorithm),
                                SD_JSON_BUILD_PAIR_UNSIGNED("fptype", rr->sshfp.fptype),
                                SD_JSON_BUILD_PAIR_HEX("fingerprint", rr->sshfp.fingerprint, rr->sshfp.fingerprint_size));
 
        case DNS_TYPE_DNSKEY:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->dnskey.flags),
                                SD_JSON_BUILD_PAIR_UNSIGNED("protocol", rr->dnskey.protocol),
                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->dnskey.algorithm),
                                SD_JSON_BUILD_PAIR_BASE64("dnskey", rr->dnskey.key, rr->dnskey.key_size));
 
        case DNS_TYPE_RRSIG:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_STRING("signer", rr->rrsig.signer),
                                SD_JSON_BUILD_PAIR_UNSIGNED("typeCovered", rr->rrsig.type_covered),
                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->rrsig.algorithm),
                                SD_JSON_BUILD_PAIR_UNSIGNED("labels", rr->rrsig.labels),
                                SD_JSON_BUILD_PAIR_UNSIGNED("originalTtl", rr->rrsig.original_ttl),
                                SD_JSON_BUILD_PAIR_UNSIGNED("expiration", rr->rrsig.expiration),
                                SD_JSON_BUILD_PAIR_UNSIGNED("inception", rr->rrsig.inception),
                                SD_JSON_BUILD_PAIR_UNSIGNED("keyTag", rr->rrsig.key_tag),
                                SD_JSON_BUILD_PAIR_BASE64("signature", rr->rrsig.signature, rr->rrsig.signature_size));
 
        case DNS_TYPE_NSEC: {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
 
                r = type_bitmap_to_json(rr->nsec.types, &bm);
                if (r < 0)
                        return r;
 
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_STRING("nextDomain", rr->nsec.next_domain_name),
                                SD_JSON_BUILD_PAIR_VARIANT("types", bm));
        }
 
        case DNS_TYPE_NSEC3: {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *bm = NULL;
 
                r = type_bitmap_to_json(rr->nsec3.types, &bm);
                if (r < 0)
                        return r;
 
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("algorithm", rr->nsec3.algorithm),
                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->nsec3.flags),
                                SD_JSON_BUILD_PAIR_UNSIGNED("iterations", rr->nsec3.iterations),
                                SD_JSON_BUILD_PAIR_HEX("salt", rr->nsec3.salt, rr->nsec3.salt_size),
                                SD_JSON_BUILD_PAIR_BASE32HEX("hash", rr->nsec3.next_hashed_name, rr->nsec3.next_hashed_name_size),
                                SD_JSON_BUILD_PAIR_VARIANT("types", bm));
        }
 
        case DNS_TYPE_TLSA:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("certUsage", rr->tlsa.cert_usage),
                                SD_JSON_BUILD_PAIR_UNSIGNED("selector", rr->tlsa.selector),
                                SD_JSON_BUILD_PAIR_UNSIGNED("matchingType", rr->tlsa.matching_type),
                                SD_JSON_BUILD_PAIR_HEX("data", rr->tlsa.data, rr->tlsa.data_size));
 
        case DNS_TYPE_OPENPGPKEY:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_BASE64("data", rr->generic.data, rr->generic.data_size));
 
        case DNS_TYPE_SVCB:
        case DNS_TYPE_HTTPS: {
                _cleanup_(sd_json_variant_unrefp) sd_json_variant *p = NULL;
                r = svc_params_to_json(rr->svcb.params, &p);
                if (r < 0)
                        return r;
 
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("priority", rr->svcb.priority),
                                SD_JSON_BUILD_PAIR_STRING("target", rr->svcb.target_name),
                                SD_JSON_BUILD_PAIR_VARIANT("svcparams", p));
        }
 
        case DNS_TYPE_CAA:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("flags", rr->caa.flags),
                                SD_JSON_BUILD_PAIR_STRING("tag", rr->caa.tag),
                                SD_JSON_BUILD_PAIR_OCTESCAPE("value", rr->caa.value, rr->caa.value_size));
 
        case DNS_TYPE_NAPTR:
                return sd_json_buildo(
                                ret,
                                SD_JSON_BUILD_PAIR_VARIANT("key", k),
                                SD_JSON_BUILD_PAIR_UNSIGNED("order", rr->naptr.order),
                                SD_JSON_BUILD_PAIR_UNSIGNED("preference", rr->naptr.preference),
                                /* NB: we name this flags field here naptrFlags, because there's already another "flags" field (for example in CAA) which has a different type */
                                SD_JSON_BUILD_PAIR_STRING("naptrFlags", rr->naptr.flags),
                                SD_JSON_BUILD_PAIR_STRING("services", rr->naptr.services),
                                SD_JSON_BUILD_PAIR_STRING("regexp", rr->naptr.regexp),
                                SD_JSON_BUILD_PAIR_STRING("replacement", rr->naptr.replacement));
 
        default:
                /* Can't provide broken-down format */
                if (ret)
                        *ret = NULL;
                return 0;
        }
}
 
int dns_resource_record_from_json(sd_json_variant *v, DnsResourceRecord **ret) {
        int r;
 
        assert(v);
 
        sd_json_variant *k = sd_json_variant_by_key(v, "key");
        if (!k)
                return log_debug_errno(SYNTHETIC_ERRNO(EBADMSG), "Resource record entry lacks key field, refusing.");
 
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
        r = dns_resource_key_from_json(k, &key);
        if (r < 0)
                return r;
 
        _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
        rr = dns_resource_record_new(key);
        if (!rr)
                return log_oom_debug();
 
        /* Note, for now we only support the most common subset of RRs for decoding here. Please send patches for more. */
        switch (key->type) {
 
        case DNS_TYPE_PTR:
        case DNS_TYPE_NS:
        case DNS_TYPE_CNAME:
        case DNS_TYPE_DNAME: {
                _cleanup_free_ char *name = NULL;
 
                static const struct sd_json_dispatch_field table[] = {
                        { "name", SD_JSON_VARIANT_STRING, sd_json_dispatch_string, 0, SD_JSON_MANDATORY },
                        { "key",  SD_JSON_VARIANT_OBJECT, NULL,                    0, SD_JSON_MANDATORY },
                        {}
                };
 
                r = sd_json_dispatch(v, table, /* flags= */ 0, &name);
                if (r < 0)
                        return r;
 
                r = dns_name_is_valid(name);
                if (r < 0)
                        return r;
                if (r == 0)
                        return -EBADMSG;
 
                rr->ptr.name = TAKE_PTR(name);
                break;
        }
 
        case DNS_TYPE_A: {
                struct in_addr addr = {};
 
                static const struct sd_json_dispatch_field table[] = {
                        { "address", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in_addr, 0, SD_JSON_MANDATORY },
                        { "key",     SD_JSON_VARIANT_OBJECT,        NULL,                  0, SD_JSON_MANDATORY },
                        {}
                };
 
                r = sd_json_dispatch(v, table, /* flags= */ 0, &addr);
                if (r < 0)
                        return r;
 
                rr->a.in_addr = addr;
                break;
        }
 
        case DNS_TYPE_AAAA: {
                struct in6_addr addr = {};
 
                static const struct sd_json_dispatch_field table[] = {
                        { "address", _SD_JSON_VARIANT_TYPE_INVALID, json_dispatch_in6_addr, 0, SD_JSON_MANDATORY },
                        { "key",     SD_JSON_VARIANT_OBJECT,        NULL,                   0, SD_JSON_MANDATORY },
                        {}
                };
 
                r = sd_json_dispatch(v, table, /* flags= */ 0, &addr);
                if (r < 0)
                        return r;
 
                rr->aaaa.in6_addr = addr;
                break;
        }
 
        default:
                return log_debug_errno(SYNTHETIC_ERRNO(EOPNOTSUPP), "Decoding DNS type %s is currently not supported.", dns_type_to_string(key->type));
        }
 
        if (ret)
                *ret = TAKE_PTR(rr);
        return 0;
}
 
static const char* const dnssec_algorithm_table[_DNSSEC_ALGORITHM_MAX_DEFINED] = {
        /* Mnemonics as listed on https://www.iana.org/assignments/dns-sec-alg-numbers/dns-sec-alg-numbers.xhtml */
        [DNSSEC_ALGORITHM_RSAMD5]             = "RSAMD5",
        [DNSSEC_ALGORITHM_DH]                 = "DH",
        [DNSSEC_ALGORITHM_DSA]                = "DSA",
        [DNSSEC_ALGORITHM_ECC]                = "ECC",
        [DNSSEC_ALGORITHM_RSASHA1]            = "RSASHA1",
        [DNSSEC_ALGORITHM_DSA_NSEC3_SHA1]     = "DSA-NSEC3-SHA1",
        [DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1] = "RSASHA1-NSEC3-SHA1",
        [DNSSEC_ALGORITHM_RSASHA256]          = "RSASHA256",
        [DNSSEC_ALGORITHM_RSASHA512]          = "RSASHA512",
        [DNSSEC_ALGORITHM_ECC_GOST]           = "ECC-GOST",
        [DNSSEC_ALGORITHM_ECDSAP256SHA256]    = "ECDSAP256SHA256",
        [DNSSEC_ALGORITHM_ECDSAP384SHA384]    = "ECDSAP384SHA384",
        [DNSSEC_ALGORITHM_ED25519]            = "ED25519",
        [DNSSEC_ALGORITHM_ED448]              = "ED448",
        [DNSSEC_ALGORITHM_INDIRECT]           = "INDIRECT",
        [DNSSEC_ALGORITHM_PRIVATEDNS]         = "PRIVATEDNS",
        [DNSSEC_ALGORITHM_PRIVATEOID]         = "PRIVATEOID",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_algorithm, int, 255);
 
static const char* const dnssec_digest_table[_DNSSEC_DIGEST_MAX_DEFINED] = {
        /* Names as listed on https://www.iana.org/assignments/ds-rr-types/ds-rr-types.xhtml */
        [DNSSEC_DIGEST_SHA1]            = "SHA-1",
        [DNSSEC_DIGEST_SHA256]          = "SHA-256",
        [DNSSEC_DIGEST_GOST_R_34_11_94] = "GOST_R_34.11-94",
        [DNSSEC_DIGEST_SHA384]          = "SHA-384",
};
DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(dnssec_digest, int, 255);
 
static const char* const sshfp_algorithm_table[_SSHFP_ALGORITHM_MAX_DEFINED] = {
        [SSHFP_ALGORITHM_RSA]     = "RSA",     /* RFC 4255 */
        [SSHFP_ALGORITHM_DSA]     = "DSA",     /* RFC 4255 */
        [SSHFP_ALGORITHM_ECDSA]   = "ECDSA",   /* RFC 6594 */
        [SSHFP_ALGORITHM_ED25519] = "Ed25519", /* RFC 7479 */
        [SSHFP_ALGORITHM_ED448]   = "Ed448",   /* RFC 8709 */
};
DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sshfp_algorithm, int, 255);
 
static const char* const sshfp_key_type_table[_SSHFP_KEY_TYPE_MAX_DEFINED] = {
        [SSHFP_KEY_TYPE_SHA1]     = "SHA-1",     /* RFC 4255 */
        [SSHFP_KEY_TYPE_SHA256]   = "SHA-256",   /* RFC 4255 */
};
DEFINE_STRING_TABLE_LOOKUP_WITH_FALLBACK(sshfp_key_type, int, 255);
 
int dns_json_dispatch_resource_key(const char *name, sd_json_variant *variant, sd_json_dispatch_flags_t flags, void *userdata) {
        DnsResourceKey **k = ASSERT_PTR(userdata);
        int r;
 
        _cleanup_(dns_resource_key_unrefp) DnsResourceKey *nk = NULL;
        r = dns_resource_key_from_json(variant, &nk);
        if (r < 0)
                return json_log(variant, flags, SYNTHETIC_ERRNO(EINVAL), "JSON field '%s' is not a valid resource record key.", strna(name));
 
        DNS_RESOURCE_KEY_REPLACE(*k, TAKE_PTR(nk));
        return 0;
}