[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/>.
 ***/

typedef struct DnsPacketHeader DnsPacketHeader;
typedef struct DnsPacket DnsPacket;

#include <inttypes.h>

#include "macro.h"
#include "sparse-endian.h"
#include "hashmap.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)

/* 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;
        Hashmap *names; /* For name compression */
        DnsResourceRecord **rrs;

        /* Packet reception meta data */
        int ifindex;
        int family;
        union in_addr_union sender, destination;
        uint32_t ttl;
};

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_RCODE(p) (be16toh(DNS_PACKET_HEADER(p)->flags) & 15)
#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
#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) | \
         ((uint16_t) !!tc << 9) | \
         ((uint16_t) !!rd << 8) | \
         ((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_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_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, size_t *start);
int dns_packet_append_key(DnsPacket *p, const DnsResourceKey *k, size_t *start);

int dns_packet_read(DnsPacket *p, size_t sz, const void **ret, 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, 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_rrs(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 } })
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
	24	typedef struct DnsPacketHeader DnsPacketHeader;
	25	typedef struct DnsPacket DnsPacket;
	26
	27	#include <inttypes.h>
	28
	29	#include "macro.h"
	30	#include "sparse-endian.h"
	31	#include "hashmap.h"
	32	#include "resolved-dns-rr.h"
	33
1716f6dc LP	34	typedef enum DnsProtocol {
	35	DNS_PROTOCOL_DNS,
	36	DNS_PROTOCOL_MDNS,
	37	DNS_PROTOCOL_LLMNR,
	38	_DNS_PROTOCOL_MAX,
	39	_DNS_PROTOCOL_INVALID = -1
	40	} DnsProtocol;
	41
74b2466e LP	42	struct DnsPacketHeader {
	43	uint16_t id;
	44	be16_t flags;
	45	be16_t qdcount;
	46	be16_t ancount;
	47	be16_t nscount;
	48	be16_t arcount;
	49	};
	50
	51	#define DNS_PACKET_HEADER_SIZE sizeof(DnsPacketHeader)
c73ce96b LP	52
	53	/* The various DNS protocols deviate in how large a packet can grow,
	54	but the TCP transport has a 16bit size field, hence that appears to
e1c95994	55	be the absolute maximum. */
c73ce96b	56	#define DNS_PACKET_SIZE_MAX 0xFFFF
e1c95994 LP	57
	58	/* RFC 1035 say 512 is the maximum, for classic unicast DNS */
	59	#define DNS_PACKET_UNICAST_SIZE_MAX 512
	60
74b2466e LP	61	#define DNS_PACKET_SIZE_START 512
	62
	63	struct DnsPacket {
	64	int n_ref;
1716f6dc	65	DnsProtocol protocol;
74b2466e	66	size_t size, allocated, rindex;
1716f6dc	67	void *data;
74b2466e	68	Hashmap names; / For name compression */
322345fd	69	DnsResourceRecord **rrs;
1716f6dc LP	70
	71	/* Packet reception meta data */
	72	int ifindex;
0dd25fb9	73	int family;
1716f6dc	74	union in_addr_union sender, destination;
0dd25fb9	75	uint32_t ttl;
74b2466e LP	76	};
	77
	78	static inline uint8_t* DNS_PACKET_DATA(DnsPacket *p) {
	79	if (_unlikely_(!p))
	80	return NULL;
	81
	82	if (p->data)
	83	return p->data;
	84
	85	return ((uint8_t*) p) + ALIGN(sizeof(DnsPacket));
	86	}
	87
	88	#define DNS_PACKET_HEADER(p) ((DnsPacketHeader*) DNS_PACKET_DATA(p))
3cb10d3a LP	89	#define DNS_PACKET_ID(p) DNS_PACKET_HEADER(p)->id
	90	#define DNS_PACKET_QR(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 15) & 1)
	91	#define DNS_PACKET_OPCODE(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 11) & 15)
	92	#define DNS_PACKET_RCODE(p) (be16toh(DNS_PACKET_HEADER(p)->flags) & 15)
ad867662	93	#define DNS_PACKET_TC(p) ((be16toh(DNS_PACKET_HEADER(p)->flags) >> 9) & 1)
3cb10d3a LP	94	#define DNS_PACKET_QDCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->qdcount)
	95	#define DNS_PACKET_ANCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->ancount)
	96	#define DNS_PACKET_NSCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->nscount)
	97	#define DNS_PACKET_ARCOUNT(p) be16toh(DNS_PACKET_HEADER(p)->arcount)
	98
	99	#define DNS_PACKET_MAKE_FLAGS(qr, opcode, aa, tc, rd, ra, ad, cd, rcode) \
	100	(((uint16_t) !!qr << 15) \| \
	101	((uint16_t) (opcode & 15) << 11) \| \
	102	((uint16_t) !!aa << 10) \| \
	103	((uint16_t) !!tc << 9) \| \
	104	((uint16_t) !!rd << 8) \| \
	105	((uint16_t) !!ra << 7) \| \
	106	((uint16_t) !!ad << 5) \| \
	107	((uint16_t) !!cd << 4) \| \
	108	((uint16_t) (rcode & 15)))
	109
322345fd LP	110	static inline unsigned DNS_PACKET_RRCOUNT(DnsPacket *p) {
	111	return
	112	(unsigned) DNS_PACKET_ANCOUNT(p) +
	113	(unsigned) DNS_PACKET_NSCOUNT(p) +
	114	(unsigned) DNS_PACKET_ARCOUNT(p);
	115	}
74b2466e	116
1716f6dc LP	117	int dns_packet_new(DnsPacket **p, DnsProtocol protocol, size_t mtu);
1716f6dc LP	118	int dns_packet_new_query(DnsPacket **p, DnsProtocol protocol, size_t mtu);
74b2466e LP	119
	120	DnsPacket dns_packet_ref(DnsPacket p);
	121	DnsPacket dns_packet_unref(DnsPacket p);
	122
	123	DEFINE_TRIVIAL_CLEANUP_FUNC(DnsPacket*, dns_packet_unref);
	124
	125	int dns_packet_validate(DnsPacket *p);
	126	int dns_packet_validate_reply(DnsPacket *p);
	127
	128	int dns_packet_append_uint8(DnsPacket p, uint8_t v, size_t start);
	129	int dns_packet_append_uint16(DnsPacket p, uint16_t v, size_t start);
	130	int dns_packet_append_string(DnsPacket p, const char s, size_t *start);
	131	int dns_packet_append_label(DnsPacket p, const char s, size_t l, size_t *start);
	132	int dns_packet_append_name(DnsPacket p, const char name, size_t *start);
	133	int dns_packet_append_key(DnsPacket p, const DnsResourceKey k, size_t *start);
	134
	135	int dns_packet_read(DnsPacket p, size_t sz, const void ret, size_t start);
	136	int dns_packet_read_uint8(DnsPacket p, uint8_t ret, size_t *start);
	137	int dns_packet_read_uint16(DnsPacket p, uint16_t ret, size_t *start);
	138	int dns_packet_read_uint32(DnsPacket p, uint32_t ret, size_t *start);
	139	int dns_packet_read_string(DnsPacket p, char ret, size_t start);
	140	int dns_packet_read_name(DnsPacket p, char ret, size_t start);
	141	int dns_packet_read_key(DnsPacket p, DnsResourceKey ret, size_t *start);
	142	int dns_packet_read_rr(DnsPacket p, DnsResourceRecord ret, size_t start);
	143
8ba9fd9c LP	144	void dns_packet_rewind(DnsPacket *p, size_t idx);
8ba9fd9c LP	145
74b2466e	146	int dns_packet_skip_question(DnsPacket *p);
322345fd	147	int dns_packet_extract_rrs(DnsPacket *p);
74b2466e	148
74b2466e LP	149	enum {
	150	DNS_RCODE_SUCCESS = 0,
	151	DNS_RCODE_FORMERR = 1,
	152	DNS_RCODE_SERVFAIL = 2,
	153	DNS_RCODE_NXDOMAIN = 3,
	154	DNS_RCODE_NOTIMP = 4,
	155	DNS_RCODE_REFUSED = 5,
	156	DNS_RCODE_YXDOMAIN = 6,
	157	DNS_RCODE_YXRRSET = 7,
	158	DNS_RCODE_NXRRSET = 8,
	159	DNS_RCODE_NOTAUTH = 9,
	160	DNS_RCODE_NOTZONE = 10,
	161	DNS_RCODE_BADVERS = 16,
	162	DNS_RCODE_BADSIG = 16, /* duplicate value! */
	163	DNS_RCODE_BADKEY = 17,
	164	DNS_RCODE_BADTIME = 18,
	165	DNS_RCODE_BADMODE = 19,
	166	DNS_RCODE_BADNAME = 20,
	167	DNS_RCODE_BADALG = 21,
	168	DNS_RCODE_BADTRUNC = 22,
	169	_DNS_RCODE_MAX_DEFINED
	170	};
	171
	172	const char* dns_rcode_to_string(int i) _const_;
	173	int dns_rcode_from_string(const char *s) _pure_;
1716f6dc LP	174
	175	const char* dns_protocol_to_string(DnsProtocol p) _const_;
	176	DnsProtocol dns_protocol_from_string(const char *s) _pure_;
	177
	178	#define LLMNR_MULTICAST_IPV4_ADDRESS ((struct in_addr) { .s_addr = htobe32(224U << 24 \| 252U) })
	179	#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 } })