HALF ECHO LEARN / REFERENCE COLLECTION
v262.2src/shared/dns-rr.c
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;
}