[thirdparty/systemd.git] / src / resolve / resolved-dns-packet.h

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

#pragma once

/***
  This file is part of systemd.

  Copyright 2014 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
 ***/

#include <netinet/ip.h>
#include <netinet/udp.h>

#include "hashmap.h"
#include "in-addr-util.h"
#include "macro.h"
#include "sparse-endian.h"

typedef struct DnsPacketHeader DnsPacketHeader;
typedef struct DnsPacket DnsPacket;

#include "resolved-def.h"
#include "resolved-dns-answer.h"
#include "resolved-dns-question.h"
#include "resolved-dns-rr.h"

typedef enum DnsProtocol {
        DNS_PROTOCOL_DNS,
        DNS_PROTOCOL_MDNS,
        DNS_PROTOCOL_LLMNR,
        _DNS_PROTOCOL_MAX,
        _DNS_PROTOCOL_INVALID = -1
} DnsProtocol;

struct DnsPacketHeader {
        uint16_t id;
        be16_t flags;
        be16_t qdcount;
        be16_t ancount;
        be16_t nscount;
        be16_t arcount;
};

#define DNS_PACKET_HEADER_SIZE sizeof(DnsPacketHeader)
#define UDP_PACKET_HEADER_SIZE (sizeof(struct iphdr) + sizeof(struct udphdr))

/* The various DNS protocols deviate in how large a packet can grow,
   but the TCP transport has a 16bit size field, hence that appears to
   be the absolute maximum. */
#define DNS_PACKET_SIZE_MAX 0xFFFF

/* RFC 1035 say 512 is the maximum, for classic unicast DNS */
#define DNS_PACKET_UNICAST_SIZE_MAX 512

#define DNS_PACKET_SIZE_START 512

struct DnsPacket {
        int n_ref;
        DnsProtocol protocol;
        size_t size, allocated, rindex;
        void *_data; /* don't access directly, use DNS_PACKET_DATA()! */
        Hashmap *names; /* For name compression */

        /* Parsed data */
        DnsQuestion *question;
        DnsAnswer *answer;

        /* Packet reception metadata */
        int ifindex;
        int family, ipproto;
        union in_addr_union sender, destination;
        uint16_t sender_port, destination_port;
        uint32_t ttl;

        bool extracted;
        bool refuse_compression;
};

static inline uint8_t* DNS_PACKET_DATA(DnsPacket *p) {
        if (_unlikely_(!p))
                return NULL;

        if (p->_data)
                return p->_data;

        return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket));
}

#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p))
#define DNS_PACKET_ID(p) DNS_PACKET_HEADER(p)->id
#define DNS_PACKET_QR(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 15) & 1)
#define DNS_PACKET_OPCODE(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 11) & 15)
#define DNS_PACKET_AA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 10) & 1)
#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
#define DNS_PACKET_RD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 8) & 1)
#define DNS_PACKET_RA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 7) & 1)
#define DNS_PACKET_AD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 5) & 1)
#define DNS_PACKET_CD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 4) & 1)
#define DNS_PACKET_RCODE(p) (be16toh(DNS_PACKET_HEADER(p)->flags) & 15)

/* LLMNR defines some bits differently */
#define DNS_PACKET_LLMNR_C(p) DNS_PACKET_AA(p)
#define DNS_PACKET_LLMNR_T(p) DNS_PACKET_RD(p)

#define DNS_PACKET_QDCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->qdcount)
#define DNS_PACKET_ANCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->ancount)
#define DNS_PACKET_NSCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->nscount)
#define DNS_PACKET_ARCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->arcount)

#define DNS_PACKET_MAKE_FLAGS(qr, opcode, aa, tc, rd, ra, ad, cd, rcode) \
        (((uint16_t) !!(qr) << 15) |                                    \
         ((uint16_t) ((opcode) & 15) << 11) |                           \
         ((uint16_t) !!(aa) << 10) |                /* on LLMNR: c */   \
         ((uint16_t) !!(tc) << 9) |                                     \
         ((uint16_t) !!(rd) << 8) |                 /* on LLMNR: t */   \
         ((uint16_t) !!(ra) << 7) |                                     \
         ((uint16_t) !!(ad) << 5) |                                     \
         ((uint16_t) !!(cd) << 4) |                                     \
         ((uint16_t) ((rcode) & 15)))

static inline unsigned DNS_PACKET_RRCOUNT(DnsPacket *p) {
        return
                (unsigned) DNS_PACKET_ANCOUNT(p) +
                (unsigned) DNS_PACKET_NSCOUNT(p) +
                (unsigned) DNS_PACKET_ARCOUNT(p);
}

int dns_packet_new(DnsPacket **p, DnsProtocol protocol, size_t mtu);
int dns_packet_new_query(DnsPacket **p, DnsProtocol protocol, size_t mtu);

DnsPacket *dns_packet_ref(DnsPacket *p);
DnsPacket *dns_packet_unref(DnsPacket *p);

DEFINE_TRIVIAL_CLEANUP_FUNC(DnsPacket*, dns_packet_unref);

int dns_packet_validate(DnsPacket *p);
int dns_packet_validate_reply(DnsPacket *p);
int dns_packet_validate_query(DnsPacket *p);

int dns_packet_append_blob(DnsPacket *p, const void *d, size_t sz, size_t *start);
int dns_packet_append_uint8(DnsPacket *p, uint8_t v, size_t *start);
int dns_packet_append_uint16(DnsPacket *p, uint16_t v, size_t *start);
int dns_packet_append_uint32(DnsPacket *p, uint32_t v, size_t *start);
int dns_packet_append_string(DnsPacket *p, const char *s, size_t *start);
int dns_packet_append_raw_string(DnsPacket *p, const void *s, size_t size, size_t *start);
int dns_packet_append_label(DnsPacket *p, const char *s, size_t l, size_t *start);
int dns_packet_append_name(DnsPacket *p, const char *name, bool allow_compression, size_t *start);
int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *key, size_t *start);
int dns_packet_append_rr(DnsPacket *p, const DnsResourceRecord *rr, size_t *start);
int dns_packet_append_opt_rr(DnsPacket *p, uint16_t max_udp_size, size_t *start);

void dns_packet_truncate(DnsPacket *p, size_t sz);

int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, size_t *start);
int dns_packet_read_blob(DnsPacket *p, void *d, size_t sz, size_t *start);
int dns_packet_read_uint8(DnsPacket *p, uint8_t *ret, size_t *start);
int dns_packet_read_uint16(DnsPacket *p, uint16_t *ret, size_t *start);
int dns_packet_read_uint32(DnsPacket *p, uint32_t *ret, size_t *start);
int dns_packet_read_string(DnsPacket *p, char **ret, size_t *start);
int dns_packet_read_raw_string(DnsPacket *p, const void **ret, size_t *size, size_t *start);
int dns_packet_read_name(DnsPacket *p, char **ret, bool allow_compression, size_t *start);
int dns_packet_read_key(DnsPacket *p, DnsResourceKey **ret, size_t *start);
int dns_packet_read_rr(DnsPacket *p, DnsResourceRecord **ret, size_t *start);

void dns_packet_rewind(DnsPacket *p, size_t idx);

int dns_packet_skip_question(DnsPacket *p);
int dns_packet_extract(DnsPacket *p);

static inline bool DNS_PACKET_SHALL_CACHE(DnsPacket *p) {
        /* Never cache data originating from localhost, under the
         * assumption, that it's coming from a locally DNS forwarder
         * or server, that is caching on its own. */

        return in_addr_is_localhost(p->family, &p->sender) == 0;
}

enum {
        DNS_RCODE_SUCCESS = 0,
        DNS_RCODE_FORMERR = 1,
        DNS_RCODE_SERVFAIL = 2,
        DNS_RCODE_NXDOMAIN = 3,
        DNS_RCODE_NOTIMP = 4,
        DNS_RCODE_REFUSED = 5,
        DNS_RCODE_YXDOMAIN = 6,
        DNS_RCODE_YXRRSET = 7,
        DNS_RCODE_NXRRSET = 8,
        DNS_RCODE_NOTAUTH = 9,
        DNS_RCODE_NOTZONE = 10,
        DNS_RCODE_BADVERS = 16,
        DNS_RCODE_BADSIG = 16, /* duplicate value! */
        DNS_RCODE_BADKEY = 17,
        DNS_RCODE_BADTIME = 18,
        DNS_RCODE_BADMODE = 19,
        DNS_RCODE_BADNAME = 20,
        DNS_RCODE_BADALG = 21,
        DNS_RCODE_BADTRUNC = 22,
        _DNS_RCODE_MAX_DEFINED
};

const char* dns_rcode_to_string(int i) _const_;
int dns_rcode_from_string(const char *s) _pure_;

const char* dns_protocol_to_string(DnsProtocol p) _const_;
DnsProtocol dns_protocol_from_string(const char *s) _pure_;

#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 | 252U) })
#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 } })

#define DNSKEY_FLAG_ZONE_KEY (1u << 8)
#define DNSKEY_FLAG_SEP      (1u << 0)

static inline uint16_t dnskey_to_flags(const DnsResourceRecord *rr) {
        return (rr->dnskey.zone_key_flag * DNSKEY_FLAG_ZONE_KEY |
                rr->dnskey.sep_flag * DNSKEY_FLAG_SEP);
}

/* http://tools.ietf.org/html/rfc4034#appendix-A.1 */
enum {
        DNSSEC_ALGORITHM_RSAMD5 = 1,
        DNSSEC_ALGORITHM_DH,
        DNSSEC_ALGORITHM_DSA,
        DNSSEC_ALGORITHM_ECC,
        DNSSEC_ALGORITHM_RSASHA1,
        DNSSEC_ALGORITHM_DSA_NSEC3_SHA1,
        DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1,
        DNSSEC_ALGORITHM_INDIRECT = 252,
        DNSSEC_ALGORITHM_PRIVATEDNS,
        DNSSEC_ALGORITHM_PRIVATEOID,
        _DNSSEC_ALGORITHM_MAX_DEFINED
};

const char* dnssec_algorithm_to_string(int i) _const_;
int dnssec_algorithm_from_string(const char *s) _pure_;

static inline uint64_t SD_RESOLVED_FLAGS_MAKE(DnsProtocol protocol, int family) {

        /* Converts a protocol + family into a flags field as used in queries */

        switch (protocol) {
        case DNS_PROTOCOL_DNS:
                return SD_RESOLVED_DNS;

        case DNS_PROTOCOL_LLMNR:
                return family == AF_INET6 ? SD_RESOLVED_LLMNR_IPV6 : SD_RESOLVED_LLMNR_IPV4;

        default:
                break;
        }

        return 0;
}
Commit	Line	Data
74b2466e LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	#pragma once
	4
	5	/***
	6	This file is part of systemd.
	7
	8	Copyright 2014 Lennart Poettering
	9
	10	systemd is free software; you can redistribute it and/or modify it
	11	under the terms of the GNU Lesser General Public License as published by
	12	the Free Software Foundation; either version 2.1 of the License, or
	13	(at your option) any later version.
	14
	15	systemd is distributed in the hope that it will be useful, but
	16	WITHOUT ANY WARRANTY; without even the implied warranty of
	17	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	18	Lesser General Public License for more details.
	19
	20	You should have received a copy of the GNU Lesser General Public License
	21	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	22	***/
	23
a0166609	24	#include <netinet/ip.h>
71d35b6b	25	#include <netinet/udp.h>
74b2466e	26
74b2466e	27	#include "hashmap.h"
7e8e0422	28	#include "in-addr-util.h"
71d35b6b TA	29	#include "macro.h"
71d35b6b TA	30	#include "sparse-endian.h"
7e8e0422 LP	31
	32	typedef struct DnsPacketHeader DnsPacketHeader;
	33	typedef struct DnsPacket DnsPacket;
	34
51323288	35	#include "resolved-def.h"
71d35b6b TA	36	#include "resolved-dns-answer.h"
	37	#include "resolved-dns-question.h"
	38	#include "resolved-dns-rr.h"
74b2466e	39
1716f6dc LP	40	typedef enum DnsProtocol {
	41	DNS_PROTOCOL_DNS,
	42	DNS_PROTOCOL_MDNS,
	43	DNS_PROTOCOL_LLMNR,
	44	_DNS_PROTOCOL_MAX,
	45	_DNS_PROTOCOL_INVALID = -1
	46	} DnsProtocol;
	47
74b2466e LP	48	struct DnsPacketHeader {
	49	uint16_t id;
	50	be16_t flags;
	51	be16_t qdcount;
	52	be16_t ancount;
	53	be16_t nscount;
	54	be16_t arcount;
	55	};
	56
	57	#define DNS_PACKET_HEADER_SIZE sizeof(DnsPacketHeader)
a0166609	58	#define UDP_PACKET_HEADER_SIZE (sizeof(struct iphdr) + sizeof(struct udphdr))
c73ce96b LP	59
	60	/* The various DNS protocols deviate in how large a packet can grow,
	61	but the TCP transport has a 16bit size field, hence that appears to
e1c95994	62	be the absolute maximum. */
c73ce96b	63	#define DNS_PACKET_SIZE_MAX 0xFFFF
e1c95994 LP	64
	65	/* RFC 1035 say 512 is the maximum, for classic unicast DNS */
	66	#define DNS_PACKET_UNICAST_SIZE_MAX 512
	67
74b2466e LP	68	#define DNS_PACKET_SIZE_START 512
	69
	70	struct DnsPacket {
	71	int n_ref;
1716f6dc	72	DnsProtocol protocol;
74b2466e	73	size_t size, allocated, rindex;
faa133f3	74	void _data; / don't access directly, use DNS_PACKET_DATA()! */
74b2466e	75	Hashmap names; / For name compression */
faa133f3 LP	76
	77	/* Parsed data */
	78	DnsQuestion *question;
	79	DnsAnswer *answer;
1716f6dc	80
dc61b7e4	81	/* Packet reception metadata */
1716f6dc	82	int ifindex;
623a4c97	83	int family, ipproto;
1716f6dc	84	union in_addr_union sender, destination;
623a4c97	85	uint16_t sender_port, destination_port;
0dd25fb9	86	uint32_t ttl;
a4076574 LP	87
a4076574 LP	88	bool extracted;
f6a5fec6	89	bool refuse_compression;
74b2466e LP	90	};
	91
	92	static inline uint8_t* DNS_PACKET_DATA(DnsPacket *p) {
	93	if (_unlikely_(!p))
	94	return NULL;
	95
faa133f3 LP	96	if (p->_data)
faa133f3 LP	97	return p->_data;
74b2466e LP	98
	99	return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket));
	100	}
	101
	102	#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p))
3cb10d3a LP	103	#define DNS_PACKET_ID(p) DNS_PACKET_HEADER(p)->id
	104	#define DNS_PACKET_QR(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 15) & 1)
	105	#define DNS_PACKET_OPCODE(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 11) & 15)
8b757a38	106	#define DNS_PACKET_AA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 10) & 1)
ad867662	107	#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
8b757a38 DM	108	#define DNS_PACKET_RD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 8) & 1)
	109	#define DNS_PACKET_RA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 7) & 1)
	110	#define DNS_PACKET_AD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 5) & 1)
	111	#define DNS_PACKET_CD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 4) & 1)
	112	#define DNS_PACKET_RCODE(p) (be16toh(DNS_PACKET_HEADER(p)->flags) & 15)
	113
	114	/* LLMNR defines some bits differently */
	115	#define DNS_PACKET_LLMNR_C(p) DNS_PACKET_AA(p)
	116	#define DNS_PACKET_LLMNR_T(p) DNS_PACKET_RD(p)
	117
3cb10d3a LP	118	#define DNS_PACKET_QDCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->qdcount)
	119	#define DNS_PACKET_ANCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->ancount)
	120	#define DNS_PACKET_NSCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->nscount)
	121	#define DNS_PACKET_ARCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->arcount)
	122
	123	#define DNS_PACKET_MAKE_FLAGS(qr, opcode, aa, tc, rd, ra, ad, cd, rcode) \
f0258e47 LP	124	(((uint16_t) !!(qr) << 15) \| \
	125	((uint16_t) ((opcode) & 15) << 11) \| \
	126	((uint16_t) !!(aa) << 10) \| /* on LLMNR: c */ \
	127	((uint16_t) !!(tc) << 9) \| \
	128	((uint16_t) !!(rd) << 8) \| /* on LLMNR: t */ \
	129	((uint16_t) !!(ra) << 7) \| \
	130	((uint16_t) !!(ad) << 5) \| \
	131	((uint16_t) !!(cd) << 4) \| \
	132	((uint16_t) ((rcode) & 15)))
3cb10d3a	133
322345fd LP	134	static inline unsigned DNS_PACKET_RRCOUNT(DnsPacket *p) {
	135	return
	136	(unsigned) DNS_PACKET_ANCOUNT(p) +
	137	(unsigned) DNS_PACKET_NSCOUNT(p) +
	138	(unsigned) DNS_PACKET_ARCOUNT(p);
	139	}
74b2466e	140
1716f6dc LP	141	int dns_packet_new(DnsPacket **p, DnsProtocol protocol, size_t mtu);
1716f6dc LP	142	int dns_packet_new_query(DnsPacket **p, DnsProtocol protocol, size_t mtu);
74b2466e LP	143
	144	DnsPacket dns_packet_ref(DnsPacket p);
	145	DnsPacket dns_packet_unref(DnsPacket p);
	146
	147	DEFINE_TRIVIAL_CLEANUP_FUNC(DnsPacket*, dns_packet_unref);
	148
	149	int dns_packet_validate(DnsPacket *p);
	150	int dns_packet_validate_reply(DnsPacket *p);
623a4c97	151	int dns_packet_validate_query(DnsPacket *p);
74b2466e	152
623a4c97	153	int dns_packet_append_blob(DnsPacket p, const void d, size_t sz, size_t *start);
74b2466e LP	154	int dns_packet_append_uint8(DnsPacket p, uint8_t v, size_t start);
74b2466e LP	155	int dns_packet_append_uint16(DnsPacket p, uint16_t v, size_t start);
623a4c97	156	int dns_packet_append_uint32(DnsPacket p, uint32_t v, size_t start);
74b2466e	157	int dns_packet_append_string(DnsPacket p, const char s, size_t *start);
2001c805	158	int dns_packet_append_raw_string(DnsPacket p, const void s, size_t size, size_t *start);
74b2466e	159	int dns_packet_append_label(DnsPacket p, const char s, size_t l, size_t *start);
2001c805	160	int dns_packet_append_name(DnsPacket p, const char name, bool allow_compression, size_t *start);
623a4c97 LP	161	int dns_packet_append_key(DnsPacket p, const DnsResourceKey key, size_t *start);
623a4c97 LP	162	int dns_packet_append_rr(DnsPacket p, const DnsResourceRecord rr, size_t *start);
dc913c9a	163	int dns_packet_append_opt_rr(DnsPacket p, uint16_t max_udp_size, size_t start);
74b2466e	164
9c5e12a4 TG	165	void dns_packet_truncate(DnsPacket *p, size_t sz);
9c5e12a4 TG	166
74b2466e	167	int dns_packet_read(DnsPacket p, size_t sz, const void ret, size_t start);
623a4c97	168	int dns_packet_read_blob(DnsPacket p, void d, size_t sz, size_t *start);
74b2466e LP	169	int dns_packet_read_uint8(DnsPacket p, uint8_t ret, size_t *start);
	170	int dns_packet_read_uint16(DnsPacket p, uint16_t ret, size_t *start);
	171	int dns_packet_read_uint32(DnsPacket p, uint32_t ret, size_t *start);
	172	int dns_packet_read_string(DnsPacket p, char ret, size_t start);
2001c805 LP	173	int dns_packet_read_raw_string(DnsPacket p, const void ret, size_t size, size_t *start);
2001c805 LP	174	int dns_packet_read_name(DnsPacket p, char ret, bool allow_compression, size_t start);
faa133f3	175	int dns_packet_read_key(DnsPacket p, DnsResourceKey ret, size_t start);
74b2466e LP	176	int dns_packet_read_rr(DnsPacket p, DnsResourceRecord ret, size_t start);
74b2466e LP	177
8ba9fd9c LP	178	void dns_packet_rewind(DnsPacket *p, size_t idx);
8ba9fd9c LP	179
74b2466e	180	int dns_packet_skip_question(DnsPacket *p);
faa133f3	181	int dns_packet_extract(DnsPacket *p);
74b2466e	182
d830ebbd LP	183	static inline bool DNS_PACKET_SHALL_CACHE(DnsPacket *p) {
	184	/* Never cache data originating from localhost, under the
	185	* assumption, that it's coming from a locally DNS forwarder
	186	* or server, that is caching on its own. */
	187
	188	return in_addr_is_localhost(p->family, &p->sender) == 0;
	189	}
	190
74b2466e LP	191	enum {
	192	DNS_RCODE_SUCCESS = 0,
	193	DNS_RCODE_FORMERR = 1,
	194	DNS_RCODE_SERVFAIL = 2,
	195	DNS_RCODE_NXDOMAIN = 3,
	196	DNS_RCODE_NOTIMP = 4,
	197	DNS_RCODE_REFUSED = 5,
	198	DNS_RCODE_YXDOMAIN = 6,
	199	DNS_RCODE_YXRRSET = 7,
	200	DNS_RCODE_NXRRSET = 8,
	201	DNS_RCODE_NOTAUTH = 9,
	202	DNS_RCODE_NOTZONE = 10,
	203	DNS_RCODE_BADVERS = 16,
	204	DNS_RCODE_BADSIG = 16, /* duplicate value! */
	205	DNS_RCODE_BADKEY = 17,
	206	DNS_RCODE_BADTIME = 18,
	207	DNS_RCODE_BADMODE = 19,
	208	DNS_RCODE_BADNAME = 20,
	209	DNS_RCODE_BADALG = 21,
	210	DNS_RCODE_BADTRUNC = 22,
	211	_DNS_RCODE_MAX_DEFINED
	212	};
	213
	214	const char* dns_rcode_to_string(int i) _const_;
	215	int dns_rcode_from_string(const char *s) _pure_;
1716f6dc LP	216
	217	const char* dns_protocol_to_string(DnsProtocol p) _const_;
	218	DnsProtocol dns_protocol_from_string(const char *s) _pure_;
	219
	220	#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 \| 252U) })
	221	#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 } })
8db0d2f5 ZJS	222
	223	#define DNSKEY_FLAG_ZONE_KEY (1u << 8)
	224	#define DNSKEY_FLAG_SEP (1u << 0)
	225
	226	static inline uint16_t dnskey_to_flags(const DnsResourceRecord *rr) {
	227	return (rr->dnskey.zone_key_flag * DNSKEY_FLAG_ZONE_KEY \|
	228	rr->dnskey.sep_flag * DNSKEY_FLAG_SEP);
	229	}
ff3d6560 ZJS	230
	231	/* http://tools.ietf.org/html/rfc4034#appendix-A.1 */
	232	enum {
	233	DNSSEC_ALGORITHM_RSAMD5 = 1,
	234	DNSSEC_ALGORITHM_DH,
	235	DNSSEC_ALGORITHM_DSA,
	236	DNSSEC_ALGORITHM_ECC,
	237	DNSSEC_ALGORITHM_RSASHA1,
5d45a880 TG	238	DNSSEC_ALGORITHM_DSA_NSEC3_SHA1,
5d45a880 TG	239	DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1,
ff3d6560 ZJS	240	DNSSEC_ALGORITHM_INDIRECT = 252,
	241	DNSSEC_ALGORITHM_PRIVATEDNS,
	242	DNSSEC_ALGORITHM_PRIVATEOID,
	243	_DNSSEC_ALGORITHM_MAX_DEFINED
	244	};
	245
	246	const char* dnssec_algorithm_to_string(int i) _const_;
	247	int dnssec_algorithm_from_string(const char *s) _pure_;
51323288 LP	248
	249	static inline uint64_t SD_RESOLVED_FLAGS_MAKE(DnsProtocol protocol, int family) {
	250
	251	/* Converts a protocol + family into a flags field as used in queries */
	252
106784eb DM	253	switch (protocol) {
106784eb DM	254	case DNS_PROTOCOL_DNS:
51323288 LP	255	return SD_RESOLVED_DNS;
51323288 LP	256
106784eb	257	case DNS_PROTOCOL_LLMNR:
51323288 LP	258	return family == AF_INET6 ? SD_RESOLVED_LLMNR_IPV6 : SD_RESOLVED_LLMNR_IPV4;
51323288 LP	259
106784eb DM	260	default:
	261	break;
	262	}
	263
51323288 LP	264	return 0;
51323288 LP	265	}