[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

/* With EDNS0 we can use larger packets, default to 4096, which is what is commonly used */
#define DNS_PACKET_UNICAST_SIZE_LARGE_MAX 4096

#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, bool edns0_do, 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
d74fb368 TG	68	/* With EDNS0 we can use larger packets, default to 4096, which is what is commonly used */
	69	#define DNS_PACKET_UNICAST_SIZE_LARGE_MAX 4096
	70
74b2466e LP	71	#define DNS_PACKET_SIZE_START 512
	72
	73	struct DnsPacket {
	74	int n_ref;
1716f6dc	75	DnsProtocol protocol;
74b2466e	76	size_t size, allocated, rindex;
faa133f3	77	void _data; / don't access directly, use DNS_PACKET_DATA()! */
74b2466e	78	Hashmap names; / For name compression */
faa133f3 LP	79
	80	/* Parsed data */
	81	DnsQuestion *question;
	82	DnsAnswer *answer;
1716f6dc	83
dc61b7e4	84	/* Packet reception metadata */
1716f6dc	85	int ifindex;
623a4c97	86	int family, ipproto;
1716f6dc	87	union in_addr_union sender, destination;
623a4c97	88	uint16_t sender_port, destination_port;
0dd25fb9	89	uint32_t ttl;
a4076574 LP	90
a4076574 LP	91	bool extracted;
f6a5fec6	92	bool refuse_compression;
74b2466e LP	93	};
	94
	95	static inline uint8_t* DNS_PACKET_DATA(DnsPacket *p) {
	96	if (_unlikely_(!p))
	97	return NULL;
	98
faa133f3 LP	99	if (p->_data)
faa133f3 LP	100	return p->_data;
74b2466e LP	101
	102	return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket));
	103	}
	104
	105	#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p))
3cb10d3a LP	106	#define DNS_PACKET_ID(p) DNS_PACKET_HEADER(p)->id
	107	#define DNS_PACKET_QR(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 15) & 1)
	108	#define DNS_PACKET_OPCODE(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 11) & 15)
8b757a38	109	#define DNS_PACKET_AA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 10) & 1)
ad867662	110	#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
8b757a38 DM	111	#define DNS_PACKET_RD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 8) & 1)
	112	#define DNS_PACKET_RA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 7) & 1)
	113	#define DNS_PACKET_AD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 5) & 1)
	114	#define DNS_PACKET_CD(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 4) & 1)
	115	#define DNS_PACKET_RCODE(p) (be16toh(DNS_PACKET_HEADER(p)->flags) & 15)
	116
	117	/* LLMNR defines some bits differently */
	118	#define DNS_PACKET_LLMNR_C(p) DNS_PACKET_AA(p)
	119	#define DNS_PACKET_LLMNR_T(p) DNS_PACKET_RD(p)
	120
3cb10d3a LP	121	#define DNS_PACKET_QDCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->qdcount)
	122	#define DNS_PACKET_ANCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->ancount)
	123	#define DNS_PACKET_NSCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->nscount)
	124	#define DNS_PACKET_ARCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->arcount)
	125
	126	#define DNS_PACKET_MAKE_FLAGS(qr, opcode, aa, tc, rd, ra, ad, cd, rcode) \
f0258e47 LP	127	(((uint16_t) !!(qr) << 15) \| \
	128	((uint16_t) ((opcode) & 15) << 11) \| \
	129	((uint16_t) !!(aa) << 10) \| /* on LLMNR: c */ \
	130	((uint16_t) !!(tc) << 9) \| \
	131	((uint16_t) !!(rd) << 8) \| /* on LLMNR: t */ \
	132	((uint16_t) !!(ra) << 7) \| \
	133	((uint16_t) !!(ad) << 5) \| \
	134	((uint16_t) !!(cd) << 4) \| \
	135	((uint16_t) ((rcode) & 15)))
3cb10d3a	136
322345fd LP	137	static inline unsigned DNS_PACKET_RRCOUNT(DnsPacket *p) {
	138	return
	139	(unsigned) DNS_PACKET_ANCOUNT(p) +
	140	(unsigned) DNS_PACKET_NSCOUNT(p) +
	141	(unsigned) DNS_PACKET_ARCOUNT(p);
	142	}
74b2466e	143
1716f6dc LP	144	int dns_packet_new(DnsPacket **p, DnsProtocol protocol, size_t mtu);
1716f6dc LP	145	int dns_packet_new_query(DnsPacket **p, DnsProtocol protocol, size_t mtu);
74b2466e LP	146
	147	DnsPacket dns_packet_ref(DnsPacket p);
	148	DnsPacket dns_packet_unref(DnsPacket p);
	149
	150	DEFINE_TRIVIAL_CLEANUP_FUNC(DnsPacket*, dns_packet_unref);
	151
	152	int dns_packet_validate(DnsPacket *p);
	153	int dns_packet_validate_reply(DnsPacket *p);
623a4c97	154	int dns_packet_validate_query(DnsPacket *p);
74b2466e	155
623a4c97	156	int dns_packet_append_blob(DnsPacket p, const void d, size_t sz, size_t *start);
74b2466e LP	157	int dns_packet_append_uint8(DnsPacket p, uint8_t v, size_t start);
74b2466e LP	158	int dns_packet_append_uint16(DnsPacket p, uint16_t v, size_t start);
623a4c97	159	int dns_packet_append_uint32(DnsPacket p, uint32_t v, size_t start);
74b2466e	160	int dns_packet_append_string(DnsPacket p, const char s, size_t *start);
2001c805	161	int dns_packet_append_raw_string(DnsPacket p, const void s, size_t size, size_t *start);
74b2466e	162	int dns_packet_append_label(DnsPacket p, const char s, size_t l, size_t *start);
2001c805	163	int dns_packet_append_name(DnsPacket p, const char name, bool allow_compression, size_t *start);
623a4c97 LP	164	int dns_packet_append_key(DnsPacket p, const DnsResourceKey key, size_t *start);
623a4c97 LP	165	int dns_packet_append_rr(DnsPacket p, const DnsResourceRecord rr, size_t *start);
7586f4d1	166	int dns_packet_append_opt_rr(DnsPacket p, uint16_t max_udp_size, bool edns0_do, size_t start);
74b2466e	167
9c5e12a4 TG	168	void dns_packet_truncate(DnsPacket *p, size_t sz);
9c5e12a4 TG	169
74b2466e	170	int dns_packet_read(DnsPacket p, size_t sz, const void ret, size_t start);
623a4c97	171	int dns_packet_read_blob(DnsPacket p, void d, size_t sz, size_t *start);
74b2466e LP	172	int dns_packet_read_uint8(DnsPacket p, uint8_t ret, size_t *start);
	173	int dns_packet_read_uint16(DnsPacket p, uint16_t ret, size_t *start);
	174	int dns_packet_read_uint32(DnsPacket p, uint32_t ret, size_t *start);
	175	int dns_packet_read_string(DnsPacket p, char ret, size_t start);
2001c805 LP	176	int dns_packet_read_raw_string(DnsPacket p, const void ret, size_t size, size_t *start);
2001c805 LP	177	int dns_packet_read_name(DnsPacket p, char ret, bool allow_compression, size_t start);
faa133f3	178	int dns_packet_read_key(DnsPacket p, DnsResourceKey ret, size_t start);
74b2466e LP	179	int dns_packet_read_rr(DnsPacket p, DnsResourceRecord ret, size_t start);
74b2466e LP	180
8ba9fd9c LP	181	void dns_packet_rewind(DnsPacket *p, size_t idx);
8ba9fd9c LP	182
74b2466e	183	int dns_packet_skip_question(DnsPacket *p);
faa133f3	184	int dns_packet_extract(DnsPacket *p);
74b2466e	185
d830ebbd LP	186	static inline bool DNS_PACKET_SHALL_CACHE(DnsPacket *p) {
	187	/* Never cache data originating from localhost, under the
	188	* assumption, that it's coming from a locally DNS forwarder
	189	* or server, that is caching on its own. */
	190
	191	return in_addr_is_localhost(p->family, &p->sender) == 0;
	192	}
	193
74b2466e LP	194	enum {
	195	DNS_RCODE_SUCCESS = 0,
	196	DNS_RCODE_FORMERR = 1,
	197	DNS_RCODE_SERVFAIL = 2,
	198	DNS_RCODE_NXDOMAIN = 3,
	199	DNS_RCODE_NOTIMP = 4,
	200	DNS_RCODE_REFUSED = 5,
	201	DNS_RCODE_YXDOMAIN = 6,
	202	DNS_RCODE_YXRRSET = 7,
	203	DNS_RCODE_NXRRSET = 8,
	204	DNS_RCODE_NOTAUTH = 9,
	205	DNS_RCODE_NOTZONE = 10,
	206	DNS_RCODE_BADVERS = 16,
	207	DNS_RCODE_BADSIG = 16, /* duplicate value! */
	208	DNS_RCODE_BADKEY = 17,
	209	DNS_RCODE_BADTIME = 18,
	210	DNS_RCODE_BADMODE = 19,
	211	DNS_RCODE_BADNAME = 20,
	212	DNS_RCODE_BADALG = 21,
	213	DNS_RCODE_BADTRUNC = 22,
	214	_DNS_RCODE_MAX_DEFINED
	215	};
	216
	217	const char* dns_rcode_to_string(int i) _const_;
	218	int dns_rcode_from_string(const char *s) _pure_;
1716f6dc LP	219
	220	const char* dns_protocol_to_string(DnsProtocol p) _const_;
	221	DnsProtocol dns_protocol_from_string(const char *s) _pure_;
	222
	223	#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 \| 252U) })
	224	#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	225
	226	#define DNSKEY_FLAG_ZONE_KEY (1u << 8)
	227	#define DNSKEY_FLAG_SEP (1u << 0)
	228
	229	static inline uint16_t dnskey_to_flags(const DnsResourceRecord *rr) {
	230	return (rr->dnskey.zone_key_flag * DNSKEY_FLAG_ZONE_KEY \|
	231	rr->dnskey.sep_flag * DNSKEY_FLAG_SEP);
	232	}
ff3d6560 ZJS	233
	234	/* http://tools.ietf.org/html/rfc4034#appendix-A.1 */
	235	enum {
	236	DNSSEC_ALGORITHM_RSAMD5 = 1,
	237	DNSSEC_ALGORITHM_DH,
	238	DNSSEC_ALGORITHM_DSA,
	239	DNSSEC_ALGORITHM_ECC,
	240	DNSSEC_ALGORITHM_RSASHA1,
5d45a880 TG	241	DNSSEC_ALGORITHM_DSA_NSEC3_SHA1,
5d45a880 TG	242	DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1,
ff3d6560 ZJS	243	DNSSEC_ALGORITHM_INDIRECT = 252,
	244	DNSSEC_ALGORITHM_PRIVATEDNS,
	245	DNSSEC_ALGORITHM_PRIVATEOID,
	246	_DNSSEC_ALGORITHM_MAX_DEFINED
	247	};
	248
	249	const char* dnssec_algorithm_to_string(int i) _const_;
	250	int dnssec_algorithm_from_string(const char *s) _pure_;
51323288 LP	251
	252	static inline uint64_t SD_RESOLVED_FLAGS_MAKE(DnsProtocol protocol, int family) {
	253
	254	/* Converts a protocol + family into a flags field as used in queries */
	255
106784eb DM	256	switch (protocol) {
106784eb DM	257	case DNS_PROTOCOL_DNS:
51323288 LP	258	return SD_RESOLVED_DNS;
51323288 LP	259
106784eb	260	case DNS_PROTOCOL_LLMNR:
51323288 LP	261	return family == AF_INET6 ? SD_RESOLVED_LLMNR_IPV6 : SD_RESOLVED_LLMNR_IPV4;
51323288 LP	262
106784eb DM	263	default:
	264	break;
	265	}
	266
51323288 LP	267	return 0;
51323288 LP	268	}