| 1 |
/* SPDX-License-Identifier: LGPL-2.1-or-later */ |
| 2 |
#pragma once |
| 3 |
|
| 4 |
#include <netinet/ip.h> |
| 5 |
#include <netinet/ip6.h> |
| 6 |
#include <netinet/udp.h> |
| 7 |
|
| 8 |
#include "in-addr-util.h" |
| 9 |
#include "memory-util.h" |
| 10 |
#include "resolved-def.h" |
| 11 |
#include "shared-forward.h" |
| 12 |
#include "sparse-endian.h" |
| 13 |
|
| 14 |
typedef enum DnsProtocol { |
| 15 |
DNS_PROTOCOL_DNS, |
| 16 |
DNS_PROTOCOL_MDNS, |
| 17 |
DNS_PROTOCOL_LLMNR, |
| 18 |
_DNS_PROTOCOL_MAX, |
| 19 |
_DNS_PROTOCOL_INVALID = -EINVAL, |
| 20 |
} DnsProtocol; |
| 21 |
|
| 22 |
typedef struct DnsPacketHeader { |
| 23 |
uint16_t id; |
| 24 |
be16_t flags; |
| 25 |
be16_t qdcount; |
| 26 |
be16_t ancount; |
| 27 |
be16_t nscount; |
| 28 |
be16_t arcount; |
| 29 |
} _packed_ DnsPacketHeader; |
| 30 |
|
| 31 |
#define DNS_PACKET_HEADER_SIZE sizeof(DnsPacketHeader) |
| 32 |
#define UDP4_PACKET_HEADER_SIZE (sizeof(struct iphdr) + sizeof(struct udphdr)) |
| 33 |
#define UDP6_PACKET_HEADER_SIZE (sizeof(struct ip6_hdr) + sizeof(struct udphdr)) |
| 34 |
|
| 35 |
assert_cc(sizeof(struct ip6_hdr) == 40); |
| 36 |
assert_cc(sizeof(struct iphdr) == 20); |
| 37 |
assert_cc(sizeof(struct udphdr) == 8); |
| 38 |
assert_cc(sizeof(DnsPacketHeader) == 12); |
| 39 |
|
| 40 |
/* The various DNS protocols deviate in how large a packet can grow, but the TCP transport has a 16-bit size |
| 41 |
* field, hence that appears to be the absolute maximum. */ |
| 42 |
#define DNS_PACKET_SIZE_MAX 0xFFFFu |
| 43 |
|
| 44 |
/* The default size to use for allocation when we don't know how large |
| 45 |
* the packet will turn out to be. */ |
| 46 |
#define DNS_PACKET_SIZE_START 512u |
| 47 |
|
| 48 |
/* RFC 1035 say 512 is the maximum, for classic unicast DNS */ |
| 49 |
#define DNS_PACKET_UNICAST_SIZE_MAX 512u |
| 50 |
|
| 51 |
/* With EDNS0 we can use larger packets, default to 1232, which is what is commonly used */ |
| 52 |
#define DNS_PACKET_UNICAST_SIZE_LARGE_MAX 1232u |
| 53 |
|
| 54 |
typedef struct DnsPacket { |
| 55 |
unsigned n_ref; |
| 56 |
DnsProtocol protocol; |
| 57 |
size_t size, allocated, rindex, max_size, fragsize; |
| 58 |
void *_data; /* don't access directly, use DNS_PACKET_DATA()! */ |
| 59 |
Hashmap *names; /* For name compression */ |
| 60 |
size_t opt_start, opt_size; |
| 61 |
|
| 62 |
/* Parsed data */ |
| 63 |
DnsQuestion *question; |
| 64 |
DnsAnswer *answer; |
| 65 |
DnsResourceRecord *opt; |
| 66 |
|
| 67 |
/* For support of truncated packets */ |
| 68 |
DnsPacket *more; |
| 69 |
|
| 70 |
/* Packet reception metadata */ |
| 71 |
usec_t timestamp; /* CLOCK_BOOTTIME (or CLOCK_MONOTONIC if the former doesn't exist) */ |
| 72 |
int ifindex; |
| 73 |
int family, ipproto; |
| 74 |
union in_addr_union sender, destination; |
| 75 |
uint16_t sender_port, destination_port; |
| 76 |
uint32_t ttl; |
| 77 |
|
| 78 |
bool on_stack; |
| 79 |
bool extracted; |
| 80 |
bool refuse_compression; |
| 81 |
bool canonical_form; |
| 82 |
|
| 83 |
/* Note: fields should be ordered to minimize alignment gaps. Use pahole! */ |
| 84 |
} DnsPacket; |
| 85 |
|
| 86 |
static inline uint8_t* DNS_PACKET_DATA(const DnsPacket *p) { |
| 87 |
if (_unlikely_(!p)) |
| 88 |
return NULL; |
| 89 |
|
| 90 |
if (p->_data) |
| 91 |
return p->_data; |
| 92 |
|
| 93 |
return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket)); |
| 94 |
} |
| 95 |
|
| 96 |
#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p)) |
| 97 |
#define DNS_PACKET_ID(p) DNS_PACKET_HEADER(p)->id |
| 98 |
#define DNS_PACKET_QR(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 15) & 1) |
| 99 |
#define DNS_PACKET_OPCODE(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 11) & 15) |
| 100 |
#define DNS_PACKET_AA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 10) & 1) |
| 101 |
#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1) |
| 102 |
#define DNS_PACKET_RD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 8) & 1) |
| 103 |
#define DNS_PACKET_RA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 7) & 1) |
| 104 |
#define DNS_PACKET_AD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 5) & 1) |
| 105 |
#define DNS_PACKET_CD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 4) & 1) |
| 106 |
|
| 107 |
#define DNS_PACKET_FLAG_CD (UINT16_C(1) << 4) |
| 108 |
#define DNS_PACKET_FLAG_AD (UINT16_C(1) << 5) |
| 109 |
#define DNS_PACKET_FLAG_TC (UINT16_C(1) << 9) |
| 110 |
|
| 111 |
uint16_t dns_packet_rcode(DnsPacket *p); |
| 112 |
uint16_t dns_packet_payload_size_max(DnsPacket *p); |
| 113 |
bool dns_packet_do(DnsPacket *p); |
| 114 |
bool dns_packet_version_supported(DnsPacket *p); |
| 115 |
|
| 116 |
static inline bool DNS_PACKET_IS_FRAGMENTED(DnsPacket *p) { |
| 117 |
assert(p); |
| 118 |
|
| 119 |
/* For ingress packets: was this packet fragmented according to our knowledge? */ |
| 120 |
|
| 121 |
return p->fragsize != 0; |
| 122 |
} |
| 123 |
|
| 124 |
/* LLMNR defines some bits differently */ |
| 125 |
#define DNS_PACKET_LLMNR_C(p) DNS_PACKET_AA(p) |
| 126 |
#define DNS_PACKET_LLMNR_T(p) DNS_PACKET_RD(p) |
| 127 |
|
| 128 |
#define DNS_PACKET_QDCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->qdcount) |
| 129 |
#define DNS_PACKET_ANCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->ancount) |
| 130 |
#define DNS_PACKET_NSCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->nscount) |
| 131 |
#define DNS_PACKET_ARCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->arcount) |
| 132 |
|
| 133 |
#define DNS_PACKET_MAKE_FLAGS(qr, opcode, aa, tc, rd, ra, ad, cd, rcode) \ |
| 134 |
(((uint16_t) !!(qr) << 15) | \ |
| 135 |
((uint16_t) ((opcode) & 15) << 11) | \ |
| 136 |
((uint16_t) !!(aa) << 10) | /* on LLMNR: c */ \ |
| 137 |
((uint16_t) !!(tc) << 9) | \ |
| 138 |
((uint16_t) !!(rd) << 8) | /* on LLMNR: t */ \ |
| 139 |
((uint16_t) !!(ra) << 7) | \ |
| 140 |
((uint16_t) !!(ad) << 5) | \ |
| 141 |
((uint16_t) !!(cd) << 4) | \ |
| 142 |
((uint16_t) ((rcode) & 15))) |
| 143 |
|
| 144 |
static inline unsigned DNS_PACKET_RRCOUNT(DnsPacket *p) { |
| 145 |
return |
| 146 |
(unsigned) DNS_PACKET_ANCOUNT(p) + |
| 147 |
(unsigned) DNS_PACKET_NSCOUNT(p) + |
| 148 |
(unsigned) DNS_PACKET_ARCOUNT(p); |
| 149 |
} |
| 150 |
|
| 151 |
int dns_packet_new(DnsPacket **ret, DnsProtocol protocol, size_t min_alloc_dsize, size_t max_size); |
| 152 |
int dns_packet_new_query(DnsPacket **ret, DnsProtocol protocol, size_t min_alloc_dsize, bool dnssec_checking_disabled); |
| 153 |
|
| 154 |
int dns_packet_dup(DnsPacket **ret, DnsPacket *p); |
| 155 |
|
| 156 |
void dns_packet_set_flags(DnsPacket *p, bool dnssec_checking_disabled, bool truncated); |
| 157 |
|
| 158 |
DnsPacket *dns_packet_ref(DnsPacket *p); |
| 159 |
DnsPacket *dns_packet_unref(DnsPacket *p); |
| 160 |
|
| 161 |
DEFINE_TRIVIAL_CLEANUP_FUNC(DnsPacket*, dns_packet_unref); |
| 162 |
|
| 163 |
#define DNS_PACKET_REPLACE(a, b) \ |
| 164 |
do { \ |
| 165 |
typeof(a)* _a = &(a); \ |
| 166 |
typeof(b) _b = (b); \ |
| 167 |
dns_packet_unref(*_a); \ |
| 168 |
*_a = _b; \ |
| 169 |
} while(0) |
| 170 |
|
| 171 |
int dns_packet_validate(DnsPacket *p); |
| 172 |
int dns_packet_validate_reply(DnsPacket *p); |
| 173 |
int dns_packet_validate_query(DnsPacket *p); |
| 174 |
|
| 175 |
int dns_packet_is_reply_for(DnsPacket *p, const DnsResourceKey *key); |
| 176 |
|
| 177 |
int dns_packet_append_blob(DnsPacket *p, const void *d, size_t l, size_t *start); |
| 178 |
int dns_packet_append_uint8(DnsPacket *p, uint8_t v, size_t *start); |
| 179 |
int dns_packet_append_uint16(DnsPacket *p, uint16_t v, size_t *start); |
| 180 |
int dns_packet_append_uint32(DnsPacket *p, uint32_t v, size_t *start); |
| 181 |
int dns_packet_append_string(DnsPacket *p, const char *s, size_t *start); |
| 182 |
int dns_packet_append_raw_string(DnsPacket *p, const void *s, size_t size, size_t *start); |
| 183 |
int dns_packet_append_label(DnsPacket *p, const char *d, size_t l, bool canonical_candidate, size_t *start); |
| 184 |
int dns_packet_append_name(DnsPacket *p, const char *name, bool allow_compression, bool canonical_candidate, size_t *start); |
| 185 |
int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *key, DnsAnswerFlags flags, size_t *start); |
| 186 |
int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, DnsAnswerFlags flags, size_t *start, size_t *rdata_start); |
| 187 |
int dns_packet_append_opt(DnsPacket *p, uint16_t max_udp_size, bool edns0_do, bool include_rfc6975, const char *nsid, int rcode, size_t *ret_start); |
| 188 |
int dns_packet_append_question(DnsPacket *p, DnsQuestion *q); |
| 189 |
int dns_packet_append_answer(DnsPacket *p, DnsAnswer *a, unsigned *completed); |
| 190 |
|
| 191 |
int dns_packet_patch_max_udp_size(DnsPacket *p, uint16_t max_udp_size); |
| 192 |
int dns_packet_patch_ttls(DnsPacket *p, usec_t timestamp); |
| 193 |
|
| 194 |
void dns_packet_truncate(DnsPacket *p, size_t sz); |
| 195 |
int dns_packet_truncate_opt(DnsPacket *p); |
| 196 |
|
| 197 |
int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start); |
| 198 |
int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start); |
| 199 |
int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start); |
| 200 |
int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start); |
| 201 |
int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start); |
| 202 |
int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start); |
| 203 |
int dns_packet_read_raw_string(DnsPacket *p, const void **ret, size_t *size, size_t *start); |
| 204 |
int dns_packet_read_name(DnsPacket *p, char **ret, bool allow_compression, size_t *start); |
| 205 |
int dns_packet_read_key(DnsPacket *p, DnsResourceKey **ret, bool *ret_cache_flush_or_qu, size_t *start); |
| 206 |
int dns_packet_read_rr(DnsPacket *p, DnsResourceRecord **ret, bool *ret_cache_flush, size_t *start); |
| 207 |
|
| 208 |
void dns_packet_rewind(DnsPacket *p, size_t idx); |
| 209 |
|
| 210 |
int dns_packet_skip_question(DnsPacket *p); |
| 211 |
int dns_packet_extract(DnsPacket *p); |
| 212 |
|
| 213 |
bool dns_packet_equal(const DnsPacket *a, const DnsPacket *b); |
| 214 |
|
| 215 |
int dns_packet_ede_rcode(DnsPacket *p, int *ret_ede_rcode, char **ret_ede_msg); |
| 216 |
bool dns_ede_rcode_is_dnssec(int ede_rcode); |
| 217 |
int dns_packet_has_nsid_request(DnsPacket *p); |
| 218 |
|
| 219 |
/* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6 */ |
| 220 |
enum { |
| 221 |
DNS_RCODE_SUCCESS = 0, |
| 222 |
DNS_RCODE_FORMERR = 1, |
| 223 |
DNS_RCODE_SERVFAIL = 2, |
| 224 |
DNS_RCODE_NXDOMAIN = 3, |
| 225 |
DNS_RCODE_NOTIMP = 4, |
| 226 |
DNS_RCODE_REFUSED = 5, |
| 227 |
DNS_RCODE_YXDOMAIN = 6, |
| 228 |
DNS_RCODE_YXRRSET = 7, |
| 229 |
DNS_RCODE_NXRRSET = 8, |
| 230 |
DNS_RCODE_NOTAUTH = 9, |
| 231 |
DNS_RCODE_NOTZONE = 10, |
| 232 |
DNS_RCODE_DSOTYPENI = 11, |
| 233 |
/* 12-15 are unassigned. */ |
| 234 |
DNS_RCODE_BADVERS = 16, |
| 235 |
DNS_RCODE_BADSIG = 16, /* duplicate value! */ |
| 236 |
DNS_RCODE_BADKEY = 17, |
| 237 |
DNS_RCODE_BADTIME = 18, |
| 238 |
DNS_RCODE_BADMODE = 19, |
| 239 |
DNS_RCODE_BADNAME = 20, |
| 240 |
DNS_RCODE_BADALG = 21, |
| 241 |
DNS_RCODE_BADTRUNC = 22, |
| 242 |
DNS_RCODE_BADCOOKIE = 23, |
| 243 |
/* 24-3840 are unassigned. */ |
| 244 |
/* 3841-4095 are for private use. */ |
| 245 |
/* 4096-65534 are unassigned. */ |
| 246 |
_DNS_RCODE_MAX_DEFINED, |
| 247 |
_DNS_RCODE_MAX = 65535, /* reserved */ |
| 248 |
_DNS_RCODE_INVALID = -EINVAL, |
| 249 |
}; |
| 250 |
|
| 251 |
/* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-11 */ |
| 252 |
enum { |
| 253 |
DNS_EDNS_OPT_RESERVED = 0, /* RFC 6891 */ |
| 254 |
DNS_EDNS_OPT_LLQ = 1, /* RFC 8764 */ |
| 255 |
DNS_EDNS_OPT_UL = 2, |
| 256 |
DNS_EDNS_OPT_NSID = 3, /* RFC 5001 */ |
| 257 |
/* DNS_EDNS_OPT_RESERVED = 4 */ |
| 258 |
DNS_EDNS_OPT_DAU = 5, /* RFC 6975 */ |
| 259 |
DNS_EDNS_OPT_DHU = 6, /* RFC 6975 */ |
| 260 |
DNS_EDNS_OPT_N3U = 7, /* RFC 6975 */ |
| 261 |
DNS_EDNS_OPT_CLIENT_SUBNET = 8, /* RFC 7871 */ |
| 262 |
DNS_EDNS_OPT_EXPIRE = 9, /* RFC 7314 */ |
| 263 |
DNS_EDNS_OPT_COOKIE = 10, /* RFC 7873 */ |
| 264 |
DNS_EDNS_OPT_TCP_KEEPALIVE = 11, /* RFC 7828 */ |
| 265 |
DNS_EDNS_OPT_PADDING = 12, /* RFC 7830 */ |
| 266 |
DNS_EDNS_OPT_CHAIN = 13, /* RFC 7901 */ |
| 267 |
DNS_EDNS_OPT_KEY_TAG = 14, /* RFC 8145 */ |
| 268 |
DNS_EDNS_OPT_EXT_ERROR = 15, /* RFC 8914 */ |
| 269 |
DNS_EDNS_OPT_CLIENT_TAG = 16, |
| 270 |
DNS_EDNS_OPT_SERVER_TAG = 17, |
| 271 |
_DNS_EDNS_OPT_MAX_DEFINED, |
| 272 |
_DNS_EDNS_OPT_INVALID = -EINVAL, |
| 273 |
}; |
| 274 |
|
| 275 |
/* https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#extended-dns-error-codes */ |
| 276 |
enum { |
| 277 |
DNS_EDE_RCODE_OTHER = 0, /* RFC 8914, Section 4.1 */ |
| 278 |
DNS_EDE_RCODE_UNSUPPORTED_DNSKEY_ALG = 1, /* RFC 8914, Section 4.2 */ |
| 279 |
DNS_EDE_RCODE_UNSUPPORTED_DS_DIGEST = 2, /* RFC 8914, Section 4.3 */ |
| 280 |
DNS_EDE_RCODE_STALE_ANSWER = 3, /* RFC 8914, Section 4.4 */ |
| 281 |
DNS_EDE_RCODE_FORGED_ANSWER = 4, /* RFC 8914, Section 4.5 */ |
| 282 |
DNS_EDE_RCODE_DNSSEC_INDETERMINATE = 5, /* RFC 8914, Section 4.6 */ |
| 283 |
DNS_EDE_RCODE_DNSSEC_BOGUS = 6, /* RFC 8914, Section 4.7 */ |
| 284 |
DNS_EDE_RCODE_SIG_EXPIRED = 7, /* RFC 8914, Section 4.8 */ |
| 285 |
DNS_EDE_RCODE_SIG_NOT_YET_VALID = 8, /* RFC 8914, Section 4.9 */ |
| 286 |
DNS_EDE_RCODE_DNSKEY_MISSING = 9, /* RFC 8914, Section 4.10 */ |
| 287 |
DNS_EDE_RCODE_RRSIG_MISSING = 10, /* RFC 8914, Section 4.11 */ |
| 288 |
DNS_EDE_RCODE_NO_ZONE_KEY_BIT = 11, /* RFC 8914, Section 4.12 */ |
| 289 |
DNS_EDE_RCODE_NSEC_MISSING = 12, /* RFC 8914, Section 4.13 */ |
| 290 |
DNS_EDE_RCODE_CACHED_ERROR = 13, /* RFC 8914, Section 4.14 */ |
| 291 |
DNS_EDE_RCODE_NOT_READY = 14, /* RFC 8914, Section 4.15 */ |
| 292 |
DNS_EDE_RCODE_BLOCKED = 15, /* RFC 8914, Section 4.16 */ |
| 293 |
DNS_EDE_RCODE_CENSORED = 16, /* RFC 8914, Section 4.17 */ |
| 294 |
DNS_EDE_RCODE_FILTERED = 17, /* RFC 8914, Section 4.18 */ |
| 295 |
DNS_EDE_RCODE_PROHIBITED = 18, /* RFC 8914, Section 4.19 */ |
| 296 |
DNS_EDE_RCODE_STALE_NXDOMAIN_ANSWER = 19, /* RFC 8914, Section 4.20 */ |
| 297 |
DNS_EDE_RCODE_NOT_AUTHORITATIVE = 20, /* RFC 8914, Section 4.21 */ |
| 298 |
DNS_EDE_RCODE_NOT_SUPPORTED = 21, /* RFC 8914, Section 4.22 */ |
| 299 |
DNS_EDE_RCODE_UNREACH_AUTHORITY = 22, /* RFC 8914, Section 4.23 */ |
| 300 |
DNS_EDE_RCODE_NET_ERROR = 23, /* RFC 8914, Section 4.24 */ |
| 301 |
DNS_EDE_RCODE_INVALID_DATA = 24, /* RFC 8914, Section 4.25 */ |
| 302 |
DNS_EDE_RCODE_SIG_NEVER = 25, |
| 303 |
DNS_EDE_RCODE_TOO_EARLY = 26, /* RFC 9250 */ |
| 304 |
DNS_EDE_RCODE_UNSUPPORTED_NSEC3_ITER = 27, /* RFC 9276 */ |
| 305 |
DNS_EDE_RCODE_TRANSPORT_POLICY = 28, |
| 306 |
DNS_EDE_RCODE_SYNTHESIZED = 29, |
| 307 |
_DNS_EDE_RCODE_MAX_DEFINED, |
| 308 |
_DNS_EDE_RCODE_INVALID = -EINVAL, |
| 309 |
}; |
| 310 |
|
| 311 |
DECLARE_STRING_TABLE_LOOKUP(dns_rcode, int); |
| 312 |
const char* format_dns_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]); |
| 313 |
#define FORMAT_DNS_RCODE(i) format_dns_rcode(i, (char [DECIMAL_STR_MAX(int)]) {}) |
| 314 |
|
| 315 |
DECLARE_STRING_TABLE_LOOKUP_TO_STRING(dns_ede_rcode, int); |
| 316 |
const char* format_dns_ede_rcode(int i, char buf[static DECIMAL_STR_MAX(int)]); |
| 317 |
#define FORMAT_DNS_EDE_RCODE(i) format_dns_ede_rcode(i, (char [DECIMAL_STR_MAX(int)]) {}) |
| 318 |
|
| 319 |
DECLARE_STRING_TABLE_LOOKUP(dns_protocol, DnsProtocol); |
| 320 |
|
| 321 |
#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 | 252U) }) |
| 322 |
#define LLMNR_MULTICAST_IPV6_ADDRESS ((struct in6_addr) { .s6_addr = { 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x03 } }) |
| 323 |
|
| 324 |
#define MDNS_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 | 251U) }) |
| 325 |
#define MDNS_MULTICAST_IPV6_ADDRESS ((struct in6_addr) { .s6_addr = { 0xFF, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xfb } }) |
| 326 |
|
| 327 |
extern const struct hash_ops dns_packet_hash_ops; |
| 328 |
|
| 329 |
/* https://www.iana.org/assignments/dns-svcb/dns-svcb.xhtml#dns-svcparamkeys */ |
| 330 |
enum { |
| 331 |
DNS_SVC_PARAM_KEY_MANDATORY = 0, /* RFC 9460 § 8 */ |
| 332 |
DNS_SVC_PARAM_KEY_ALPN = 1, /* RFC 9460 § 7.1 */ |
| 333 |
DNS_SVC_PARAM_KEY_NO_DEFAULT_ALPN = 2, /* RFC 9460 § 7.1 */ |
| 334 |
DNS_SVC_PARAM_KEY_PORT = 3, /* RFC 9460 § 7.2 */ |
| 335 |
DNS_SVC_PARAM_KEY_IPV4HINT = 4, /* RFC 9460 § 7.3 */ |
| 336 |
DNS_SVC_PARAM_KEY_ECH = 5, /* RFC 9460 */ |
| 337 |
DNS_SVC_PARAM_KEY_IPV6HINT = 6, /* RFC 9460 § 7.3 */ |
| 338 |
DNS_SVC_PARAM_KEY_DOHPATH = 7, /* RFC 9461 */ |
| 339 |
DNS_SVC_PARAM_KEY_OHTTP = 8, |
| 340 |
_DNS_SVC_PARAM_KEY_MAX_DEFINED, |
| 341 |
DNS_SVC_PARAM_KEY_INVALID = 65535 /* RFC 9460 */ |
| 342 |
}; |
| 343 |
|
| 344 |
DECLARE_STRING_TABLE_LOOKUP_TO_STRING(dns_svc_param_key, int); |
| 345 |
const char* format_dns_svc_param_key(uint16_t i, char buf[static DECIMAL_STR_MAX(uint16_t)+3]); |
| 346 |
#define FORMAT_DNS_SVC_PARAM_KEY(i) format_dns_svc_param_key(i, (char [DECIMAL_STR_MAX(uint16_t)+3]) {}) |
| 347 |
|
| 348 |
static inline uint64_t SD_RESOLVED_FLAGS_MAKE( |
| 349 |
DnsProtocol protocol, |
| 350 |
int family, |
| 351 |
bool authenticated, |
| 352 |
bool confidential) { |
| 353 |
uint64_t f; |
| 354 |
|
| 355 |
/* Converts a protocol + family into a flags field as used in queries and responses */ |
| 356 |
|
| 357 |
f = (authenticated ? SD_RESOLVED_AUTHENTICATED : 0) | |
| 358 |
(confidential ? SD_RESOLVED_CONFIDENTIAL : 0); |
| 359 |
|
| 360 |
switch (protocol) { |
| 361 |
case DNS_PROTOCOL_DNS: |
| 362 |
return f|SD_RESOLVED_DNS; |
| 363 |
|
| 364 |
case DNS_PROTOCOL_LLMNR: |
| 365 |
return f|(family == AF_INET6 ? SD_RESOLVED_LLMNR_IPV6 : SD_RESOLVED_LLMNR_IPV4); |
| 366 |
|
| 367 |
case DNS_PROTOCOL_MDNS: |
| 368 |
return f|(family == AF_INET6 ? SD_RESOLVED_MDNS_IPV6 : SD_RESOLVED_MDNS_IPV4); |
| 369 |
|
| 370 |
default: |
| 371 |
return f; |
| 372 |
} |
| 373 |
} |
| 374 |
|
| 375 |
static inline size_t dns_packet_size_max(DnsPacket *p) { |
| 376 |
assert(p); |
| 377 |
|
| 378 |
/* Why not insist on a fully initialized max_size during DnsPacket construction? Well, this way it's easy to |
| 379 |
* allocate a transient, throw-away DnsPacket on the stack by simple zero initialization, without having to |
| 380 |
* deal with explicit field initialization. */ |
| 381 |
|
| 382 |
return p->max_size != 0 ? p->max_size : DNS_PACKET_SIZE_MAX; |
| 383 |
} |
| 384 |
|
| 385 |
static inline size_t udp_header_size(int af) { |
| 386 |
|
| 387 |
switch (af) { |
| 388 |
case AF_INET: |
| 389 |
return UDP4_PACKET_HEADER_SIZE; |
| 390 |
case AF_INET6: |
| 391 |
return UDP6_PACKET_HEADER_SIZE; |
| 392 |
default: |
| 393 |
assert_not_reached(); |
| 394 |
} |
| 395 |
} |
| 396 |
|
| 397 |
size_t dns_packet_size_unfragmented(DnsPacket *p); |