[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/udp.h>
#include <netinet/ip.h>

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

typedef struct DnsPacketHeader DnsPacketHeader;
typedef struct DnsPacket DnsPacket;

#include "resolved-dns-rr.h"
#include "resolved-dns-question.h"
#include "resolved-dns-answer.h"
#include "resolved-def.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_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_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_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);

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
5eef597e MP	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
7035cd9e MP	24	#include <netinet/udp.h>
7035cd9e MP	25	#include <netinet/ip.h>
5eef597e MP	26
	27	#include "macro.h"
	28	#include "sparse-endian.h"
	29	#include "hashmap.h"
	30	#include "in-addr-util.h"
	31
	32	typedef struct DnsPacketHeader DnsPacketHeader;
	33	typedef struct DnsPacket DnsPacket;
	34
	35	#include "resolved-dns-rr.h"
	36	#include "resolved-dns-question.h"
	37	#include "resolved-dns-answer.h"
	38	#include "resolved-def.h"
	39
	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
	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)
7035cd9e	58	#define UDP_PACKET_HEADER_SIZE (sizeof(struct iphdr) + sizeof(struct udphdr))
5eef597e MP	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
	62	be the absolute maximum. */
	63	#define DNS_PACKET_SIZE_MAX 0xFFFF
	64
	65	/* RFC 1035 say 512 is the maximum, for classic unicast DNS */
	66	#define DNS_PACKET_UNICAST_SIZE_MAX 512
	67
	68	#define DNS_PACKET_SIZE_START 512
	69
	70	struct DnsPacket {
	71	int n_ref;
	72	DnsProtocol protocol;
	73	size_t size, allocated, rindex;
	74	void _data; / don't access directly, use DNS_PACKET_DATA()! */
	75	Hashmap names; / For name compression */
	76
	77	/* Parsed data */
	78	DnsQuestion *question;
	79	DnsAnswer *answer;
	80
d9dfd233	81	/* Packet reception metadata */
5eef597e MP	82	int ifindex;
	83	int family, ipproto;
	84	union in_addr_union sender, destination;
	85	uint16_t sender_port, destination_port;
	86	uint32_t ttl;
	87
	88	bool extracted;
13d276d0	89	bool refuse_compression;
5eef597e MP	90	};
	91
	92	static inline uint8_t* DNS_PACKET_DATA(DnsPacket *p) {
	93	if (_unlikely_(!p))
	94	return NULL;
	95
	96	if (p->_data)
	97	return p->_data;
	98
	99	return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket));
	100	}
	101
	102	#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p))
	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)
7035cd9e	106	#define DNS_PACKET_AA(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 10) & 1)
5eef597e	107	#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
7035cd9e MP	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
5eef597e MP	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) \
13d276d0 MP	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)))
5eef597e MP	133
	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	}
	140
	141	int dns_packet_new(DnsPacket **p, DnsProtocol protocol, size_t mtu);
	142	int dns_packet_new_query(DnsPacket **p, DnsProtocol protocol, size_t mtu);
	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);
	151	int dns_packet_validate_query(DnsPacket *p);
	152
	153	int dns_packet_append_blob(DnsPacket p, const void d, size_t sz, size_t *start);
	154	int dns_packet_append_uint8(DnsPacket p, uint8_t v, size_t start);
	155	int dns_packet_append_uint16(DnsPacket p, uint16_t v, size_t start);
	156	int dns_packet_append_uint32(DnsPacket p, uint32_t v, size_t start);
	157	int dns_packet_append_string(DnsPacket p, const char s, size_t *start);
	158	int dns_packet_append_label(DnsPacket p, const char s, size_t l, size_t *start);
	159	int dns_packet_append_name(DnsPacket p, const char name,
	160	bool allow_compression, size_t *start);
	161	int dns_packet_append_key(DnsPacket p, const DnsResourceKey key, size_t *start);
	162	int dns_packet_append_rr(DnsPacket p, const DnsResourceRecord rr, size_t *start);
	163
	164	int dns_packet_read(DnsPacket p, size_t sz, const void ret, size_t start);
	165	int dns_packet_read_blob(DnsPacket p, void d, size_t sz, size_t *start);
	166	int dns_packet_read_uint8(DnsPacket p, uint8_t ret, size_t *start);
	167	int dns_packet_read_uint16(DnsPacket p, uint16_t ret, size_t *start);
	168	int dns_packet_read_uint32(DnsPacket p, uint32_t ret, size_t *start);
	169	int dns_packet_read_string(DnsPacket p, char ret, size_t start);
	170	int dns_packet_read_name(DnsPacket p, char *ret,
	171	bool allow_compression, size_t *start);
	172	int dns_packet_read_key(DnsPacket p, DnsResourceKey ret, size_t start);
	173	int dns_packet_read_rr(DnsPacket p, DnsResourceRecord ret, size_t start);
	174
	175	void dns_packet_rewind(DnsPacket *p, size_t idx);
	176
	177	int dns_packet_skip_question(DnsPacket *p);
	178	int dns_packet_extract(DnsPacket *p);
	179
	180	enum {
	181	DNS_RCODE_SUCCESS = 0,
	182	DNS_RCODE_FORMERR = 1,
	183	DNS_RCODE_SERVFAIL = 2,
	184	DNS_RCODE_NXDOMAIN = 3,
	185	DNS_RCODE_NOTIMP = 4,
	186	DNS_RCODE_REFUSED = 5,
	187	DNS_RCODE_YXDOMAIN = 6,
	188	DNS_RCODE_YXRRSET = 7,
	189	DNS_RCODE_NXRRSET = 8,
	190	DNS_RCODE_NOTAUTH = 9,
	191	DNS_RCODE_NOTZONE = 10,
	192	DNS_RCODE_BADVERS = 16,
	193	DNS_RCODE_BADSIG = 16, /* duplicate value! */
	194	DNS_RCODE_BADKEY = 17,
	195	DNS_RCODE_BADTIME = 18,
	196	DNS_RCODE_BADMODE = 19,
197	DNS_RCODE_BADNAME = 20,
198	DNS_RCODE_BADALG = 21,
199	DNS_RCODE_BADTRUNC = 22,
200	_DNS_RCODE_MAX_DEFINED
201	};
202
203	const char* dns_rcode_to_string(int i) _const_;
204	int dns_rcode_from_string(const char *s) _pure_;
205
206	const char* dns_protocol_to_string(DnsProtocol p) _const_;
207	DnsProtocol dns_protocol_from_string(const char *s) _pure_;
208
209	#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 \| 252U) })
210	#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 } })
211
212	#define DNSKEY_FLAG_ZONE_KEY (1u << 8)
213	#define DNSKEY_FLAG_SEP (1u << 0)
214
215	static inline uint16_t dnskey_to_flags(const DnsResourceRecord *rr) {
216	return (rr->dnskey.zone_key_flag * DNSKEY_FLAG_ZONE_KEY \|
217	rr->dnskey.sep_flag * DNSKEY_FLAG_SEP);
218	}
219
220	/* http://tools.ietf.org/html/rfc4034#appendix-A.1 */
221	enum {
222	DNSSEC_ALGORITHM_RSAMD5 = 1,
223	DNSSEC_ALGORITHM_DH,
224	DNSSEC_ALGORITHM_DSA,
225	DNSSEC_ALGORITHM_ECC,
226	DNSSEC_ALGORITHM_RSASHA1,
7035cd9e MP	227	DNSSEC_ALGORITHM_DSA_NSEC3_SHA1,
7035cd9e MP	228	DNSSEC_ALGORITHM_RSASHA1_NSEC3_SHA1,
5eef597e MP	229	DNSSEC_ALGORITHM_INDIRECT = 252,
	230	DNSSEC_ALGORITHM_PRIVATEDNS,
	231	DNSSEC_ALGORITHM_PRIVATEOID,
	232	_DNSSEC_ALGORITHM_MAX_DEFINED
	233	};
	234
	235	const char* dnssec_algorithm_to_string(int i) _const_;
	236	int dnssec_algorithm_from_string(const char *s) _pure_;
	237
	238	static inline uint64_t SD_RESOLVED_FLAGS_MAKE(DnsProtocol protocol, int family) {
	239
	240	/* Converts a protocol + family into a flags field as used in queries */
	241
13d276d0 MP	242	switch (protocol) {
13d276d0 MP	243	case DNS_PROTOCOL_DNS:
5eef597e MP	244	return SD_RESOLVED_DNS;
5eef597e MP	245
13d276d0	246	case DNS_PROTOCOL_LLMNR:
5eef597e MP	247	return family == AF_INET6 ? SD_RESOLVED_LLMNR_IPV6 : SD_RESOLVED_LLMNR_IPV4;
5eef597e MP	248
13d276d0 MP	249	default:
	250	break;
	251	}
	252
5eef597e MP	253	return 0;
5eef597e MP	254	}