[thirdparty/systemd.git] / src / resolve / resolved-dns-rr.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/in.h>

#include "bitmap.h"
#include "dns-type.h"
#include "hashmap.h"
#include "in-addr-util.h"
#include "list.h"

typedef struct DnsResourceKey DnsResourceKey;
typedef struct DnsResourceRecord DnsResourceRecord;
typedef struct DnsTxtItem DnsTxtItem;

/* DNS record classes, see RFC 1035 */
enum {
        DNS_CLASS_IN   = 0x01,
        DNS_CLASS_ANY  = 0xFF,
        _DNS_CLASS_MAX,
        _DNS_CLASS_INVALID = -1
};

struct DnsResourceKey {
        unsigned n_ref;
        uint16_t class, type;
        char *_name; /* don't access directy, use DNS_RESOURCE_KEY_NAME()! */
};

struct DnsTxtItem {
        size_t length;
        LIST_FIELDS(DnsTxtItem, items);
        uint8_t data[];
};

struct DnsResourceRecord {
        unsigned n_ref;
        DnsResourceKey *key;
        uint32_t ttl;
        bool unparseable:1;
        bool wire_format_canonical:1;
        void *wire_format;
        size_t wire_format_size;
        size_t wire_format_rdata_offset;
        union {
                struct {
                        void *data;
                        size_t size;
                } generic;

                struct {
                        uint16_t priority;
                        uint16_t weight;
                        uint16_t port;
                        char *name;
                } srv;

                struct {
                        char *name;
                } ptr, ns, cname, dname;

                struct {
                        char *cpu;
                        char *os;
                } hinfo;

                struct {
                        DnsTxtItem *items;
                } txt, spf;

                struct {
                        struct in_addr in_addr;
                } a;

                struct {
                        struct in6_addr in6_addr;
                } aaaa;

                struct {
                        char *mname;
                        char *rname;
                        uint32_t serial;
                        uint32_t refresh;
                        uint32_t retry;
                        uint32_t expire;
                        uint32_t minimum;
                } soa;

                struct {
                        uint16_t priority;
                        char *exchange;
                } mx;

                struct {
                        uint8_t version;
                        uint8_t size;
                        uint8_t horiz_pre;
                        uint8_t vert_pre;
                        uint32_t latitude;
                        uint32_t longitude;
                        uint32_t altitude;
                } loc;

                struct {
                        uint16_t key_tag;
                        uint8_t algorithm;
                        uint8_t digest_type;
                        void *digest;
                        size_t digest_size;
                } ds;

                /* https://tools.ietf.org/html/rfc4255#section-3.1 */
                struct {
                        uint8_t algorithm;
                        uint8_t fptype;
                        void *fingerprint;
                        size_t fingerprint_size;
                } sshfp;

                /* http://tools.ietf.org/html/rfc4034#section-2.1 */
                struct {
                        uint16_t flags;
                        uint8_t protocol;
                        uint8_t algorithm;
                        void* key;
                        size_t key_size;
                } dnskey;

                /* http://tools.ietf.org/html/rfc4034#section-3.1 */
                struct {
                        uint16_t type_covered;
                        uint8_t algorithm;
                        uint8_t labels;
                        uint32_t original_ttl;
                        uint32_t expiration;
                        uint32_t inception;
                        uint16_t key_tag;
                        char *signer;
                        void *signature;
                        size_t signature_size;
                } rrsig;

                /* https://tools.ietf.org/html/rfc4034#section-4.1 */
                struct {
                        char *next_domain_name;
                        Bitmap *types;
                } nsec;

                struct {
                        uint8_t algorithm;
                        uint8_t flags;
                        uint16_t iterations;
                        void *salt;
                        size_t salt_size;
                        void *next_hashed_name;
                        size_t next_hashed_name_size;
                        Bitmap *types;
                } nsec3;
        };
};

static inline const char* DNS_RESOURCE_KEY_NAME(const DnsResourceKey *key) {
        if (_unlikely_(!key))
                return NULL;

        if (key->_name)
                return key->_name;

        return (char*) key + sizeof(DnsResourceKey);
}

DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name);
DnsResourceKey* dns_resource_key_new_cname(const DnsResourceKey *key);
DnsResourceKey* dns_resource_key_new_dname(const DnsResourceKey *key);
DnsResourceKey* dns_resource_key_new_redirect(const DnsResourceKey *key, const DnsResourceRecord *cname);
int dns_resource_key_new_append_suffix(DnsResourceKey **ret, DnsResourceKey *key, char *name);
DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name);
DnsResourceKey* dns_resource_key_ref(DnsResourceKey *key);
DnsResourceKey* dns_resource_key_unref(DnsResourceKey *key);
int dns_resource_key_equal(const DnsResourceKey *a, const DnsResourceKey *b);
int dns_resource_key_match_rr(const DnsResourceKey *key, const DnsResourceRecord *rr, const char *search_domain);
int dns_resource_key_match_cname(const DnsResourceKey *key, const DnsResourceRecord *rr, const char *search_domain);
int dns_resource_key_to_string(const DnsResourceKey *key, char **ret);
DEFINE_TRIVIAL_CLEANUP_FUNC(DnsResourceKey*, dns_resource_key_unref);

DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key);
DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name);
DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr);
DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr);
int dns_resource_record_new_reverse(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *name);
int dns_resource_record_new_address(DnsResourceRecord **ret, int family, const union in_addr_union *address, const char *name);
int dns_resource_record_equal(const DnsResourceRecord *a, const DnsResourceRecord *b);
int dns_resource_record_to_string(const DnsResourceRecord *rr, char **ret);
DEFINE_TRIVIAL_CLEANUP_FUNC(DnsResourceRecord*, dns_resource_record_unref);

int dns_resource_record_to_wire_format(DnsResourceRecord *rr, bool canonical);

DnsTxtItem *dns_txt_item_free_all(DnsTxtItem *i);
bool dns_txt_item_equal(DnsTxtItem *a, DnsTxtItem *b);

const char *dns_class_to_string(uint16_t type);
int dns_class_from_string(const char *name, uint16_t *class);

extern const struct hash_ops dns_resource_key_hash_ops;
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
74b2466e LP	24	#include <netinet/in.h>
74b2466e LP	25
50f1e641	26	#include "bitmap.h"
71d35b6b	27	#include "dns-type.h"
322345fd	28	#include "hashmap.h"
623a4c97	29	#include "in-addr-util.h"
2001c805	30	#include "list.h"
74b2466e LP	31
	32	typedef struct DnsResourceKey DnsResourceKey;
	33	typedef struct DnsResourceRecord DnsResourceRecord;
2001c805	34	typedef struct DnsTxtItem DnsTxtItem;
74b2466e LP	35
	36	/* DNS record classes, see RFC 1035 */
	37	enum {
	38	DNS_CLASS_IN = 0x01,
322345fd	39	DNS_CLASS_ANY = 0xFF,
b93312f5 ZJS	40	_DNS_CLASS_MAX,
b93312f5 ZJS	41	_DNS_CLASS_INVALID = -1
74b2466e LP	42	};
74b2466e LP	43
74b2466e	44	struct DnsResourceKey {
faa133f3 LP	45	unsigned n_ref;
	46	uint16_t class, type;
	47	char _name; / don't access directy, use DNS_RESOURCE_KEY_NAME()! */
74b2466e LP	48	};
74b2466e LP	49
2001c805 LP	50	struct DnsTxtItem {
	51	size_t length;
	52	LIST_FIELDS(DnsTxtItem, items);
	53	uint8_t data[];
	54	};
	55
74b2466e LP	56	struct DnsResourceRecord {
74b2466e LP	57	unsigned n_ref;
faa133f3	58	DnsResourceKey *key;
74b2466e	59	uint32_t ttl;
a8812dd7 LP	60	bool unparseable:1;
	61	bool wire_format_canonical:1;
	62	void *wire_format;
	63	size_t wire_format_size;
	64	size_t wire_format_rdata_offset;
74b2466e LP	65	union {
	66	struct {
	67	void *data;
f5430a3e	68	size_t size;
74b2466e LP	69	} generic;
74b2466e LP	70
9c92ce6d LP	71	struct {
	72	uint16_t priority;
	73	uint16_t weight;
	74	uint16_t port;
	75	char *name;
	76	} srv;
74b2466e LP	77
	78	struct {
	79	char *name;
8ac4e9e1	80	} ptr, ns, cname, dname;
74b2466e LP	81
	82	struct {
	83	char *cpu;
	84	char *os;
	85	} hinfo;
	86
2e276efc	87	struct {
2001c805	88	DnsTxtItem *items;
c0eb11cf	89	} txt, spf;
74b2466e LP	90
	91	struct {
	92	struct in_addr in_addr;
	93	} a;
	94
	95	struct {
	96	struct in6_addr in6_addr;
	97	} aaaa;
7e8e0422 LP	98
	99	struct {
	100	char *mname;
	101	char *rname;
	102	uint32_t serial;
	103	uint32_t refresh;
	104	uint32_t retry;
	105	uint32_t expire;
	106	uint32_t minimum;
	107	} soa;
946c7094 ZJS	108
	109	struct {
	110	uint16_t priority;
	111	char *exchange;
	112	} mx;
0dae31d4 ZJS	113
	114	struct {
	115	uint8_t version;
	116	uint8_t size;
	117	uint8_t horiz_pre;
	118	uint8_t vert_pre;
	119	uint32_t latitude;
	120	uint32_t longitude;
	121	uint32_t altitude;
	122	} loc;
42cc2eeb	123
abf126a3 TG	124	struct {
	125	uint16_t key_tag;
	126	uint8_t algorithm;
	127	uint8_t digest_type;
	128	void *digest;
	129	size_t digest_size;
	130	} ds;
	131
549c1a25	132	/* https://tools.ietf.org/html/rfc4255#section-3.1 */
42cc2eeb LP	133	struct {
	134	uint8_t algorithm;
	135	uint8_t fptype;
549c1a25 TG	136	void *fingerprint;
549c1a25 TG	137	size_t fingerprint_size;
42cc2eeb	138	} sshfp;
8db0d2f5 ZJS	139
	140	/* http://tools.ietf.org/html/rfc4034#section-2.1 */
	141	struct {
f91dc240 LP	142	uint16_t flags;
f91dc240 LP	143	uint8_t protocol;
8db0d2f5 ZJS	144	uint8_t algorithm;
	145	void* key;
	146	size_t key_size;
	147	} dnskey;
151226ab ZJS	148
	149	/* http://tools.ietf.org/html/rfc4034#section-3.1 */
	150	struct {
	151	uint16_t type_covered;
	152	uint8_t algorithm;
	153	uint8_t labels;
	154	uint32_t original_ttl;
	155	uint32_t expiration;
	156	uint32_t inception;
	157	uint16_t key_tag;
	158	char *signer;
	159	void *signature;
	160	size_t signature_size;
	161	} rrsig;
50f1e641	162
9ead3519	163	/* https://tools.ietf.org/html/rfc4034#section-4.1 */
50f1e641 TG	164	struct {
	165	char *next_domain_name;
	166	Bitmap *types;
	167	} nsec;
5d45a880 TG	168
	169	struct {
	170	uint8_t algorithm;
	171	uint8_t flags;
	172	uint16_t iterations;
	173	void *salt;
	174	size_t salt_size;
	175	void *next_hashed_name;
	176	size_t next_hashed_name_size;
	177	Bitmap *types;
	178	} nsec3;
74b2466e LP	179	};
	180	};
	181
faa133f3 LP	182	static inline const char* DNS_RESOURCE_KEY_NAME(const DnsResourceKey *key) {
	183	if (_unlikely_(!key))
	184	return NULL;
	185
	186	if (key->_name)
	187	return key->_name;
	188
	189	return (char*) key + sizeof(DnsResourceKey);
	190	}
74b2466e	191
faa133f3	192	DnsResourceKey* dns_resource_key_new(uint16_t class, uint16_t type, const char *name);
7c1ff6ac	193	DnsResourceKey* dns_resource_key_new_cname(const DnsResourceKey *key);
58db254a	194	DnsResourceKey* dns_resource_key_new_dname(const DnsResourceKey *key);
36d9205d	195	DnsResourceKey* dns_resource_key_new_redirect(const DnsResourceKey key, const DnsResourceRecord cname);
801ad6a6	196	int dns_resource_key_new_append_suffix(DnsResourceKey *ret, DnsResourceKey key, char *name);
faa133f3 LP	197	DnsResourceKey* dns_resource_key_new_consume(uint16_t class, uint16_t type, char *name);
	198	DnsResourceKey* dns_resource_key_ref(DnsResourceKey *key);
	199	DnsResourceKey* dns_resource_key_unref(DnsResourceKey *key);
	200	int dns_resource_key_equal(const DnsResourceKey a, const DnsResourceKey b);
801ad6a6 LP	201	int dns_resource_key_match_rr(const DnsResourceKey key, const DnsResourceRecord rr, const char *search_domain);
801ad6a6 LP	202	int dns_resource_key_match_cname(const DnsResourceKey key, const DnsResourceRecord rr, const char *search_domain);
2d4c5cbc	203	int dns_resource_key_to_string(const DnsResourceKey key, char *ret);
faa133f3	204	DEFINE_TRIVIAL_CLEANUP_FUNC(DnsResourceKey*, dns_resource_key_unref);
322345fd	205
faa133f3	206	DnsResourceRecord* dns_resource_record_new(DnsResourceKey *key);
8bf52d3d	207	DnsResourceRecord* dns_resource_record_new_full(uint16_t class, uint16_t type, const char *name);
74b2466e LP	208	DnsResourceRecord* dns_resource_record_ref(DnsResourceRecord *rr);
74b2466e LP	209	DnsResourceRecord* dns_resource_record_unref(DnsResourceRecord *rr);
623a4c97	210	int dns_resource_record_new_reverse(DnsResourceRecord *ret, int family, const union in_addr_union address, const char *name);
78c6a153	211	int dns_resource_record_new_address(DnsResourceRecord *ret, int family, const union in_addr_union address, const char *name);
322345fd	212	int dns_resource_record_equal(const DnsResourceRecord a, const DnsResourceRecord b);
2d4c5cbc	213	int dns_resource_record_to_string(const DnsResourceRecord rr, char *ret);
faa133f3	214	DEFINE_TRIVIAL_CLEANUP_FUNC(DnsResourceRecord*, dns_resource_record_unref);
322345fd	215
a8812dd7 LP	216	int dns_resource_record_to_wire_format(DnsResourceRecord *rr, bool canonical);
a8812dd7 LP	217
2001c805 LP	218	DnsTxtItem dns_txt_item_free_all(DnsTxtItem i);
	219	bool dns_txt_item_equal(DnsTxtItem a, DnsTxtItem b);
	220
322345fd	221	const char *dns_class_to_string(uint16_t type);
2d4c5cbc	222	int dns_class_from_string(const char name, uint16_t class);
d5099efc MS	223
d5099efc MS	224	extern const struct hash_ops dns_resource_key_hash_ops;