1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
25 #include "unaligned.h"
26 #include "resolved-dns-domain.h"
27 #include "resolved-dns-packet.h"
29 int dns_packet_new(DnsPacket **ret, DnsProtocol protocol, size_t mtu) {
36 a = DNS_PACKET_SIZE_START;
40 if (a < DNS_PACKET_HEADER_SIZE)
41 a = DNS_PACKET_HEADER_SIZE;
43 /* round up to next page size */
44 a = PAGE_ALIGN(ALIGN(sizeof(DnsPacket)) + a) - ALIGN(sizeof(DnsPacket));
46 /* make sure we never allocate more than useful */
47 if (a > DNS_PACKET_SIZE_MAX)
48 a = DNS_PACKET_SIZE_MAX;
50 p = malloc0(ALIGN(sizeof(DnsPacket)) + a);
54 p->size = p->rindex = DNS_PACKET_HEADER_SIZE;
56 p->protocol = protocol;
64 int dns_packet_new_query(DnsPacket **ret, DnsProtocol protocol, size_t mtu) {
71 r = dns_packet_new(&p, protocol, mtu);
75 h = DNS_PACKET_HEADER(p);
77 if (protocol == DNS_PROTOCOL_LLMNR)
78 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
88 h->flags = htobe16(DNS_PACKET_MAKE_FLAGS(0 /* qr */,
92 1 /* rd (ask for recursion) */,
102 DnsPacket *dns_packet_ref(DnsPacket *p) {
107 assert(p->n_ref > 0);
112 static void dns_packet_free(DnsPacket *p) {
117 dns_question_unref(p->question);
118 dns_answer_unref(p->answer);
120 while ((s = hashmap_steal_first_key(p->names)))
122 hashmap_free(p->names);
128 DnsPacket *dns_packet_unref(DnsPacket *p) {
132 assert(p->n_ref > 0);
142 int dns_packet_validate(DnsPacket *p) {
145 if (p->size < DNS_PACKET_HEADER_SIZE)
148 if (p->size > DNS_PACKET_SIZE_MAX)
154 int dns_packet_validate_reply(DnsPacket *p) {
159 r = dns_packet_validate(p);
163 if (DNS_PACKET_QR(p) != 1)
166 if (DNS_PACKET_OPCODE(p) != 0)
169 /* RFC 4795, Section 2.1.1. says to discard all replies with QDCOUNT != 1 */
170 if (p->protocol == DNS_PROTOCOL_LLMNR &&
171 DNS_PACKET_QDCOUNT(p) != 1)
177 int dns_packet_validate_query(DnsPacket *p) {
182 r = dns_packet_validate(p);
186 if (DNS_PACKET_QR(p) != 0)
189 if (DNS_PACKET_OPCODE(p) != 0)
192 if (DNS_PACKET_TC(p))
195 /* RFC 4795, Section 2.1.1. says to discard all queries with QDCOUNT != 1 */
196 if (p->protocol == DNS_PROTOCOL_LLMNR &&
197 DNS_PACKET_QDCOUNT(p) != 1)
200 /* RFC 4795, Section 2.1.1. says to discard all queries with ANCOUNT != 0 */
201 if (DNS_PACKET_ANCOUNT(p) > 0)
204 /* RFC 4795, Section 2.1.1. says to discard all queries with NSCOUNT != 0 */
205 if (DNS_PACKET_NSCOUNT(p) > 0)
211 static int dns_packet_extend(DnsPacket *p, size_t add, void **ret, size_t *start) {
214 if (p->size + add > p->allocated) {
217 a = PAGE_ALIGN((p->size + add) * 2);
218 if (a > DNS_PACKET_SIZE_MAX)
219 a = DNS_PACKET_SIZE_MAX;
221 if (p->size + add > a)
227 d = realloc(p->_data, a);
233 p->_data = malloc(a);
237 memcpy(p->_data, (uint8_t*) p + ALIGN(sizeof(DnsPacket)), p->size);
238 memzero((uint8_t*) p->_data + p->size, a - p->size);
248 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->size;
254 static void dns_packet_truncate(DnsPacket *p, size_t sz) {
264 HASHMAP_FOREACH_KEY(s, n, p->names, i) {
266 if (PTR_TO_SIZE(n) < sz)
269 hashmap_remove(p->names, s);
276 int dns_packet_append_blob(DnsPacket *p, const void *d, size_t l, size_t *start) {
282 r = dns_packet_extend(p, l, &q, start);
290 int dns_packet_append_uint8(DnsPacket *p, uint8_t v, size_t *start) {
296 r = dns_packet_extend(p, sizeof(uint8_t), &d, start);
300 ((uint8_t*) d)[0] = v;
305 int dns_packet_append_uint16(DnsPacket *p, uint16_t v, size_t *start) {
311 r = dns_packet_extend(p, sizeof(uint16_t), &d, start);
315 unaligned_write_be16(d, v);
320 int dns_packet_append_uint32(DnsPacket *p, uint32_t v, size_t *start) {
326 r = dns_packet_extend(p, sizeof(uint32_t), &d, start);
330 unaligned_write_be32(d, v);
335 int dns_packet_append_string(DnsPacket *p, const char *s, size_t *start) {
347 r = dns_packet_extend(p, 1 + l, &d, start);
351 ((uint8_t*) d)[0] = (uint8_t) l;
352 memcpy(((uint8_t*) d) + 1, s, l);
357 int dns_packet_append_label(DnsPacket *p, const char *d, size_t l, size_t *start) {
364 if (l > DNS_LABEL_MAX)
367 r = dns_packet_extend(p, 1 + l, &w, start);
371 ((uint8_t*) w)[0] = (uint8_t) l;
372 memcpy(((uint8_t*) w) + 1, d, l);
377 int dns_packet_append_name(DnsPacket *p, const char *name,
378 bool allow_compression, size_t *start) {
385 saved_size = p->size;
388 _cleanup_free_ char *s = NULL;
389 char label[DNS_LABEL_MAX];
393 if (allow_compression)
394 n = PTR_TO_SIZE(hashmap_get(p->names, name));
399 r = dns_packet_append_uint16(p, 0xC000 | n, NULL);
413 r = dns_label_unescape(&name, label, sizeof(label));
417 if (p->protocol == DNS_PROTOCOL_DNS)
418 k = dns_label_apply_idna(label, r, label, sizeof(label));
420 k = dns_label_undo_idna(label, r, label, sizeof(label));
428 r = dns_packet_append_label(p, label, r, &n);
432 if (allow_compression) {
433 r = hashmap_ensure_allocated(&p->names, &dns_name_hash_ops);
437 r = hashmap_put(p->names, s, SIZE_TO_PTR(n));
445 r = dns_packet_append_uint8(p, 0, NULL);
456 dns_packet_truncate(p, saved_size);
460 int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *k, size_t *start) {
467 saved_size = p->size;
469 r = dns_packet_append_name(p, DNS_RESOURCE_KEY_NAME(k), true, NULL);
473 r = dns_packet_append_uint16(p, k->type, NULL);
477 r = dns_packet_append_uint16(p, k->class, NULL);
487 dns_packet_truncate(p, saved_size);
491 int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, size_t *start) {
492 size_t saved_size, rdlength_offset, end, rdlength;
498 saved_size = p->size;
500 r = dns_packet_append_key(p, rr->key, NULL);
504 r = dns_packet_append_uint32(p, rr->ttl, NULL);
508 /* Initially we write 0 here */
509 r = dns_packet_append_uint16(p, 0, &rdlength_offset);
513 switch (rr->unparseable ? _DNS_TYPE_INVALID : rr->key->type) {
516 r = dns_packet_append_uint16(p, rr->srv.priority, NULL);
520 r = dns_packet_append_uint16(p, rr->srv.weight, NULL);
524 r = dns_packet_append_uint16(p, rr->srv.port, NULL);
528 r = dns_packet_append_name(p, rr->srv.name, true, NULL);
535 r = dns_packet_append_name(p, rr->ptr.name, true, NULL);
539 r = dns_packet_append_string(p, rr->hinfo.cpu, NULL);
543 r = dns_packet_append_string(p, rr->hinfo.os, NULL);
546 case DNS_TYPE_SPF: /* exactly the same as TXT */
550 STRV_FOREACH(s, rr->txt.strings) {
551 r = dns_packet_append_string(p, *s, NULL);
561 r = dns_packet_append_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
565 r = dns_packet_append_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
569 r = dns_packet_append_name(p, rr->soa.mname, true, NULL);
573 r = dns_packet_append_name(p, rr->soa.rname, true, NULL);
577 r = dns_packet_append_uint32(p, rr->soa.serial, NULL);
581 r = dns_packet_append_uint32(p, rr->soa.refresh, NULL);
585 r = dns_packet_append_uint32(p, rr->soa.retry, NULL);
589 r = dns_packet_append_uint32(p, rr->soa.expire, NULL);
593 r = dns_packet_append_uint32(p, rr->soa.minimum, NULL);
597 r = dns_packet_append_uint16(p, rr->mx.priority, NULL);
601 r = dns_packet_append_name(p, rr->mx.exchange, true, NULL);
605 r = dns_packet_append_uint8(p, rr->loc.version, NULL);
609 r = dns_packet_append_uint8(p, rr->loc.size, NULL);
613 r = dns_packet_append_uint8(p, rr->loc.horiz_pre, NULL);
617 r = dns_packet_append_uint8(p, rr->loc.vert_pre, NULL);
621 r = dns_packet_append_uint32(p, rr->loc.latitude, NULL);
625 r = dns_packet_append_uint32(p, rr->loc.longitude, NULL);
629 r = dns_packet_append_uint32(p, rr->loc.altitude, NULL);
633 r = dns_packet_append_uint8(p, rr->sshfp.algorithm, NULL);
637 r = dns_packet_append_uint8(p, rr->sshfp.fptype, NULL);
641 r = dns_packet_append_blob(p, rr->sshfp.key, rr->sshfp.key_size, NULL);
644 case DNS_TYPE_DNSKEY:
645 r = dns_packet_append_uint16(p, dnskey_to_flags(rr), NULL);
649 r = dns_packet_append_uint8(p, 3u, NULL);
653 r = dns_packet_append_uint8(p, rr->dnskey.algorithm, NULL);
657 r = dns_packet_append_blob(p, rr->dnskey.key, rr->dnskey.key_size, NULL);
661 r = dns_packet_append_uint16(p, rr->rrsig.type_covered, NULL);
665 r = dns_packet_append_uint8(p, rr->rrsig.algorithm, NULL);
669 r = dns_packet_append_uint8(p, rr->rrsig.labels, NULL);
673 r = dns_packet_append_uint32(p, rr->rrsig.original_ttl, NULL);
677 r = dns_packet_append_uint32(p, rr->rrsig.expiration, NULL);
681 r = dns_packet_append_uint32(p, rr->rrsig.inception, NULL);
685 r = dns_packet_append_uint8(p, rr->rrsig.key_tag, NULL);
689 r = dns_packet_append_name(p, rr->rrsig.signer, false, NULL);
693 r = dns_packet_append_blob(p, rr->rrsig.signature, rr->rrsig.signature_size, NULL);
696 case _DNS_TYPE_INVALID: /* unparseable */
699 r = dns_packet_append_blob(p, rr->generic.data, rr->generic.size, NULL);
705 /* Let's calculate the actual data size and update the field */
706 rdlength = p->size - rdlength_offset - sizeof(uint16_t);
707 if (rdlength > 0xFFFF) {
713 p->size = rdlength_offset;
714 r = dns_packet_append_uint16(p, rdlength, NULL);
725 dns_packet_truncate(p, saved_size);
730 int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start) {
733 if (p->rindex + sz > p->size)
737 *ret = (uint8_t*) DNS_PACKET_DATA(p) + p->rindex;
746 void dns_packet_rewind(DnsPacket *p, size_t idx) {
748 assert(idx <= p->size);
749 assert(idx >= DNS_PACKET_HEADER_SIZE);
754 int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start) {
761 r = dns_packet_read(p, sz, &q, start);
769 int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start) {
775 r = dns_packet_read(p, sizeof(uint8_t), &d, start);
779 *ret = ((uint8_t*) d)[0];
783 int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start) {
789 r = dns_packet_read(p, sizeof(uint16_t), &d, start);
793 *ret = unaligned_read_be16(d);
798 int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start) {
804 r = dns_packet_read(p, sizeof(uint32_t), &d, start);
808 *ret = unaligned_read_be32(d);
813 int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start) {
822 saved_rindex = p->rindex;
824 r = dns_packet_read_uint8(p, &c, NULL);
828 r = dns_packet_read(p, c, &d, NULL);
832 if (memchr(d, 0, c)) {
843 if (!utf8_is_valid(t)) {
852 *start = saved_rindex;
857 dns_packet_rewind(p, saved_rindex);
861 int dns_packet_read_name(DnsPacket *p, char **_ret,
862 bool allow_compression, size_t *start) {
863 size_t saved_rindex, after_rindex = 0, jump_barrier;
864 _cleanup_free_ char *ret = NULL;
865 size_t n = 0, allocated = 0;
872 saved_rindex = p->rindex;
873 jump_barrier = p->rindex;
878 r = dns_packet_read_uint8(p, &c, NULL);
886 _cleanup_free_ char *t = NULL;
890 r = dns_packet_read(p, c, (const void**) &label, NULL);
894 r = dns_label_escape(label, c, &t);
898 if (!GREEDY_REALLOC(ret, allocated, n + !first + strlen(t) + 1)) {
908 memcpy(ret + n, t, r);
911 } else if (allow_compression && (c & 0xc0) == 0xc0) {
915 r = dns_packet_read_uint8(p, &d, NULL);
919 ptr = (uint16_t) (c & ~0xc0) << 8 | (uint16_t) d;
920 if (ptr < DNS_PACKET_HEADER_SIZE || ptr >= jump_barrier) {
925 if (after_rindex == 0)
926 after_rindex = p->rindex;
928 /* Jumps are limited to a "prior occurence" (RFC-1035 4.1.4) */
937 if (!GREEDY_REALLOC(ret, allocated, n + 1)) {
944 if (after_rindex != 0)
945 p->rindex= after_rindex;
951 *start = saved_rindex;
956 dns_packet_rewind(p, saved_rindex);
960 int dns_packet_read_key(DnsPacket *p, DnsResourceKey **ret, size_t *start) {
961 _cleanup_free_ char *name = NULL;
962 uint16_t class, type;
970 saved_rindex = p->rindex;
972 r = dns_packet_read_name(p, &name, true, NULL);
976 r = dns_packet_read_uint16(p, &type, NULL);
980 r = dns_packet_read_uint16(p, &class, NULL);
984 key = dns_resource_key_new_consume(class, type, name);
994 *start = saved_rindex;
998 dns_packet_rewind(p, saved_rindex);
1002 static int dns_packet_read_public_key(DnsPacket *p, size_t length,
1003 void **dp, size_t *lengthp,
1009 r = dns_packet_read(p, length, &d, NULL);
1013 d2 = memdup(d, length);
1022 static bool loc_size_ok(uint8_t size) {
1023 uint8_t m = size >> 4, e = size & 0xF;
1025 return m <= 9 && e <= 9 && (m > 0 || e == 0);
1028 static int dnskey_parse_flags(DnsResourceRecord *rr, uint16_t flags) {
1031 if (flags & ~(DNSKEY_FLAG_SEP | DNSKEY_FLAG_ZONE_KEY))
1034 rr->dnskey.zone_key_flag = flags & DNSKEY_FLAG_ZONE_KEY;
1035 rr->dnskey.sep_flag = flags & DNSKEY_FLAG_SEP;
1039 int dns_packet_read_rr(DnsPacket *p, DnsResourceRecord **ret, size_t *start) {
1040 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1041 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1042 size_t saved_rindex, offset;
1050 saved_rindex = p->rindex;
1052 r = dns_packet_read_key(p, &key, NULL);
1056 if (key->class == DNS_CLASS_ANY ||
1057 key->type == DNS_TYPE_ANY) {
1062 rr = dns_resource_record_new(key);
1068 r = dns_packet_read_uint32(p, &rr->ttl, NULL);
1072 r = dns_packet_read_uint16(p, &rdlength, NULL);
1076 if (p->rindex + rdlength > p->size) {
1083 switch (rr->key->type) {
1086 r = dns_packet_read_uint16(p, &rr->srv.priority, NULL);
1089 r = dns_packet_read_uint16(p, &rr->srv.weight, NULL);
1092 r = dns_packet_read_uint16(p, &rr->srv.port, NULL);
1095 r = dns_packet_read_name(p, &rr->srv.name, true, NULL);
1100 case DNS_TYPE_CNAME:
1101 case DNS_TYPE_DNAME:
1102 r = dns_packet_read_name(p, &rr->ptr.name, true, NULL);
1105 case DNS_TYPE_HINFO:
1106 r = dns_packet_read_string(p, &rr->hinfo.cpu, NULL);
1110 r = dns_packet_read_string(p, &rr->hinfo.os, NULL);
1113 case DNS_TYPE_SPF: /* exactly the same as TXT */
1114 case DNS_TYPE_TXT: {
1117 while (p->rindex < offset + rdlength) {
1118 r = dns_packet_read_string(p, &s, NULL);
1122 r = strv_consume(&rr->txt.strings, s);
1132 r = dns_packet_read_blob(p, &rr->a.in_addr, sizeof(struct in_addr), NULL);
1136 r = dns_packet_read_blob(p, &rr->aaaa.in6_addr, sizeof(struct in6_addr), NULL);
1140 r = dns_packet_read_name(p, &rr->soa.mname, true, NULL);
1144 r = dns_packet_read_name(p, &rr->soa.rname, true, NULL);
1148 r = dns_packet_read_uint32(p, &rr->soa.serial, NULL);
1152 r = dns_packet_read_uint32(p, &rr->soa.refresh, NULL);
1156 r = dns_packet_read_uint32(p, &rr->soa.retry, NULL);
1160 r = dns_packet_read_uint32(p, &rr->soa.expire, NULL);
1164 r = dns_packet_read_uint32(p, &rr->soa.minimum, NULL);
1168 r = dns_packet_read_uint16(p, &rr->mx.priority, NULL);
1172 r = dns_packet_read_name(p, &rr->mx.exchange, true, NULL);
1175 case DNS_TYPE_LOC: {
1179 r = dns_packet_read_uint8(p, &t, &pos);
1184 rr->loc.version = t;
1186 r = dns_packet_read_uint8(p, &rr->loc.size, NULL);
1190 if (!loc_size_ok(rr->loc.size)) {
1195 r = dns_packet_read_uint8(p, &rr->loc.horiz_pre, NULL);
1199 if (!loc_size_ok(rr->loc.horiz_pre)) {
1204 r = dns_packet_read_uint8(p, &rr->loc.vert_pre, NULL);
1208 if (!loc_size_ok(rr->loc.vert_pre)) {
1213 r = dns_packet_read_uint32(p, &rr->loc.latitude, NULL);
1217 r = dns_packet_read_uint32(p, &rr->loc.longitude, NULL);
1221 r = dns_packet_read_uint32(p, &rr->loc.altitude, NULL);
1227 dns_packet_rewind(p, pos);
1228 rr->unparseable = true;
1233 case DNS_TYPE_SSHFP:
1234 r = dns_packet_read_uint8(p, &rr->sshfp.algorithm, NULL);
1238 r = dns_packet_read_uint8(p, &rr->sshfp.fptype, NULL);
1242 r = dns_packet_read_public_key(p, rdlength - 2,
1243 &rr->sshfp.key, &rr->sshfp.key_size,
1247 case DNS_TYPE_DNSKEY: {
1251 r = dns_packet_read_uint16(p, &flags, NULL);
1255 r = dnskey_parse_flags(rr, flags);
1259 r = dns_packet_read_uint8(p, &proto, NULL);
1263 /* protocol is required to be always 3 */
1269 r = dns_packet_read_uint8(p, &rr->dnskey.algorithm, NULL);
1273 r = dns_packet_read_public_key(p, rdlength - 4,
1274 &rr->dnskey.key, &rr->dnskey.key_size,
1279 case DNS_TYPE_RRSIG:
1280 r = dns_packet_read_uint16(p, &rr->rrsig.type_covered, NULL);
1284 r = dns_packet_read_uint8(p, &rr->rrsig.algorithm, NULL);
1288 r = dns_packet_read_uint8(p, &rr->rrsig.labels, NULL);
1292 r = dns_packet_read_uint32(p, &rr->rrsig.original_ttl, NULL);
1296 r = dns_packet_read_uint32(p, &rr->rrsig.expiration, NULL);
1300 r = dns_packet_read_uint32(p, &rr->rrsig.inception, NULL);
1304 r = dns_packet_read_uint16(p, &rr->rrsig.key_tag, NULL);
1308 r = dns_packet_read_name(p, &rr->rrsig.signer, false, NULL);
1312 r = dns_packet_read_public_key(p, offset + rdlength - p->rindex,
1313 &rr->rrsig.signature, &rr->rrsig.signature_size,
1319 r = dns_packet_read(p, rdlength, &d, NULL);
1323 rr->generic.data = memdup(d, rdlength);
1324 if (!rr->generic.data) {
1329 rr->generic.size = rdlength;
1334 if (p->rindex != offset + rdlength) {
1343 *start = saved_rindex;
1347 dns_packet_rewind(p, saved_rindex);
1351 int dns_packet_extract(DnsPacket *p) {
1352 _cleanup_(dns_question_unrefp) DnsQuestion *question = NULL;
1353 _cleanup_(dns_answer_unrefp) DnsAnswer *answer = NULL;
1354 size_t saved_rindex;
1361 saved_rindex = p->rindex;
1362 dns_packet_rewind(p, DNS_PACKET_HEADER_SIZE);
1364 n = DNS_PACKET_QDCOUNT(p);
1366 question = dns_question_new(n);
1372 for (i = 0; i < n; i++) {
1373 _cleanup_(dns_resource_key_unrefp) DnsResourceKey *key = NULL;
1375 r = dns_packet_read_key(p, &key, NULL);
1379 r = dns_question_add(question, key);
1385 n = DNS_PACKET_RRCOUNT(p);
1387 answer = dns_answer_new(n);
1393 for (i = 0; i < n; i++) {
1394 _cleanup_(dns_resource_record_unrefp) DnsResourceRecord *rr = NULL;
1396 r = dns_packet_read_rr(p, &rr, NULL);
1400 r = dns_answer_add(answer, rr);
1406 p->question = question;
1412 p->extracted = true;
1417 p->rindex = saved_rindex;
1421 static const char* const dns_rcode_table[_DNS_RCODE_MAX_DEFINED] = {
1422 [DNS_RCODE_SUCCESS] = "SUCCESS",
1423 [DNS_RCODE_FORMERR] = "FORMERR",
1424 [DNS_RCODE_SERVFAIL] = "SERVFAIL",
1425 [DNS_RCODE_NXDOMAIN] = "NXDOMAIN",
1426 [DNS_RCODE_NOTIMP] = "NOTIMP",
1427 [DNS_RCODE_REFUSED] = "REFUSED",
1428 [DNS_RCODE_YXDOMAIN] = "YXDOMAIN",
1429 [DNS_RCODE_YXRRSET] = "YRRSET",
1430 [DNS_RCODE_NXRRSET] = "NXRRSET",
1431 [DNS_RCODE_NOTAUTH] = "NOTAUTH",
1432 [DNS_RCODE_NOTZONE] = "NOTZONE",
1433 [DNS_RCODE_BADVERS] = "BADVERS",
1434 [DNS_RCODE_BADKEY] = "BADKEY",
1435 [DNS_RCODE_BADTIME] = "BADTIME",
1436 [DNS_RCODE_BADMODE] = "BADMODE",
1437 [DNS_RCODE_BADNAME] = "BADNAME",
1438 [DNS_RCODE_BADALG] = "BADALG",
1439 [DNS_RCODE_BADTRUNC] = "BADTRUNC",
1441 DEFINE_STRING_TABLE_LOOKUP(dns_rcode, int);
1443 static const char* const dns_protocol_table[_DNS_PROTOCOL_MAX] = {
1444 [DNS_PROTOCOL_DNS] = "dns",
1445 [DNS_PROTOCOL_MDNS] = "mdns",
1446 [DNS_PROTOCOL_LLMNR] = "llmnr",
1448 DEFINE_STRING_TABLE_LOOKUP(dns_protocol, DnsProtocol);
1450 static const char* const dnssec_algorithm_table[_DNSSEC_ALGORITHM_MAX_DEFINED] = {
1451 [DNSSEC_ALGORITHM_RSAMD5] = "RSAMD5",
1452 [DNSSEC_ALGORITHM_DH] = "DH",
1453 [DNSSEC_ALGORITHM_DSA] = "DSA",
1454 [DNSSEC_ALGORITHM_ECC] = "ECC",
1455 [DNSSEC_ALGORITHM_RSASHA1] = "RSASHA1",
1456 [DNSSEC_ALGORITHM_INDIRECT] = "INDIRECT",
1457 [DNSSEC_ALGORITHM_PRIVATEDNS] = "PRIVATEDNS",
1458 [DNSSEC_ALGORITHM_PRIVATEOID] = "PRIVATEOID",
1460 DEFINE_STRING_TABLE_LOOKUP(dnssec_algorithm, int);