1/* zone.c
2 *
3 * Functions for ldns_zone structure
4 * a Net::DNS like library for C
5 *
6 * (c) NLnet Labs, 2005-2006
7 * See the file LICENSE for the license
8 */
9#include <ldns/config.h>
10
11#include <ldns/ldns.h>
12#include <ldns/internal.h>
13
14#include <strings.h>
15#include <limits.h>
16
17ldns_rr *
18ldns_zone_soa(const ldns_zone *z)
19{
20        return z->_soa;
21}
22
23size_t
24ldns_zone_rr_count(const ldns_zone *z)
25{
26	return ldns_rr_list_rr_count(z->_rrs);
27}
28
29void
30ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa)
31{
32	z->_soa = soa;
33}
34
35ldns_rr_list *
36ldns_zone_rrs(const ldns_zone *z)
37{
38	return z->_rrs;
39}
40
41void
42ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist)
43{
44	z->_rrs = rrlist;
45}
46
47bool
48ldns_zone_push_rr_list(ldns_zone *z, const ldns_rr_list *list)
49{
50	return ldns_rr_list_cat(ldns_zone_rrs(z), list);
51}
52
53bool
54ldns_zone_push_rr(ldns_zone *z, ldns_rr *rr)
55{
56	return ldns_rr_list_push_rr(ldns_zone_rrs(z), rr);
57}
58
59
60/*
61 * Get the list of glue records in a zone
62 * XXX: there should be a way for this to return error, other than NULL,
63 *      since NULL is a valid return
64 */
65ldns_rr_list *
66ldns_zone_glue_rr_list(const ldns_zone *z)
67{
68	/* when do we find glue? It means we find an IP address
69	 * (AAAA/A) for a nameserver listed in the zone
70	 *
71	 * Alg used here:
72	 * first find all the zonecuts (NS records)
73	 * find all the AAAA or A records (can be done it the
74	 * above loop).
75	 *
76	 * Check if the aaaa/a list are subdomains under the
77	 * NS domains.
78	 * If yes -> glue, if no -> not glue
79	 */
80
81	ldns_rr_list *zone_cuts;
82	ldns_rr_list *addr;
83	ldns_rr_list *glue;
84	ldns_rr *r, *ns, *a;
85	ldns_rdf *dname_a, *ns_owner;
86	size_t i,j;
87
88	zone_cuts = NULL;
89	addr = NULL;
90	glue = NULL;
91
92	/* we cannot determine glue in a 'zone' without a SOA */
93	if (!ldns_zone_soa(z)) {
94		return NULL;
95	}
96
97	zone_cuts = ldns_rr_list_new();
98	if (!zone_cuts) goto memory_error;
99	addr = ldns_rr_list_new();
100	if (!addr) goto memory_error;
101	glue = ldns_rr_list_new();
102	if (!glue) goto memory_error;
103
104	for(i = 0; i < ldns_zone_rr_count(z); i++) {
105		r = ldns_rr_list_rr(ldns_zone_rrs(z), i);
106		if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A ||
107				ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) {
108			/* possibly glue */
109			if (!ldns_rr_list_push_rr(addr, r)) goto memory_error;
110			continue;
111		}
112		if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) {
113			/* multiple zones will end up here -
114			 * for now; not a problem
115			 */
116			/* don't add NS records for the current zone itself */
117			if (ldns_rdf_compare(ldns_rr_owner(r),
118						ldns_rr_owner(ldns_zone_soa(z))) != 0) {
119				if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error;
120			}
121			continue;
122		}
123	}
124
125	/* will sorting make it quicker ?? */
126	for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) {
127		ns = ldns_rr_list_rr(zone_cuts, i);
128		ns_owner = ldns_rr_owner(ns);
129
130		for(j = 0; j < ldns_rr_list_rr_count(addr); j++) {
131			a = ldns_rr_list_rr(addr, j);
132			dname_a = ldns_rr_owner(a);
133
134			if (ldns_dname_is_subdomain(dname_a, ns_owner) ||
135				ldns_dname_compare(dname_a, ns_owner) == 0) {
136				/* GLUE! */
137				if (!ldns_rr_list_push_rr(glue, a)) goto memory_error;
138			}
139		}
140	}
141
142	ldns_rr_list_free(addr);
143	ldns_rr_list_free(zone_cuts);
144
145	if (ldns_rr_list_rr_count(glue) == 0) {
146		ldns_rr_list_free(glue);
147		return NULL;
148	} else {
149		return glue;
150	}
151
152memory_error:
153	if (zone_cuts) {
154		LDNS_FREE(zone_cuts);
155	}
156	if (addr) {
157		ldns_rr_list_free(addr);
158	}
159	if (glue) {
160		ldns_rr_list_free(glue);
161	}
162	return NULL;
163}
164
165ldns_zone *
166ldns_zone_new(void)
167{
168	ldns_zone *z;
169
170	z = LDNS_MALLOC(ldns_zone);
171	if (!z) {
172		return NULL;
173	}
174
175	z->_rrs = ldns_rr_list_new();
176	if (!z->_rrs) {
177		LDNS_FREE(z);
178		return NULL;
179	}
180	ldns_zone_set_soa(z, NULL);
181	return z;
182}
183
184/* we recognize:
185 * $TTL, $ORIGIN
186 */
187ldns_status
188ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, const ldns_rdf *origin, uint32_t ttl, ldns_rr_class c)
189{
190	return ldns_zone_new_frm_fp_l(z, fp, origin, ttl, c, NULL);
191}
192
193/* XXX: class is never used */
194ldns_status
195ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, const ldns_rdf *origin,
196	uint32_t default_ttl, ldns_rr_class ATTR_UNUSED(c), int *line_nr)
197{
198	ldns_zone *newzone;
199	ldns_rr *rr, *prev_rr = NULL;
200	uint32_t my_ttl;
201	ldns_rdf *my_origin;
202	ldns_rdf *my_prev;
203	bool soa_seen = false; 	/* 2 soa are an error */
204	ldns_status s;
205	ldns_status ret;
206	/* RFC 1035 Section 5.1, says 'Omitted class and TTL values are default
207	 * to the last explicitly stated values.'
208	 */
209	bool ttl_from_TTL = false;
210	bool explicit_ttl = false;
211
212	/* most cases of error are memory problems */
213	ret = LDNS_STATUS_MEM_ERR;
214
215	newzone = NULL;
216	my_origin = NULL;
217	my_prev = NULL;
218
219	my_ttl    = default_ttl;
220
221	if (origin) {
222		my_origin = ldns_rdf_clone(origin);
223		if (!my_origin) goto error;
224		/* also set the prev */
225		my_prev   = ldns_rdf_clone(origin);
226		if (!my_prev) goto error;
227	}
228
229	newzone = ldns_zone_new();
230	if (!newzone) goto error;
231
232	while(!feof(fp)) {
233		/* If ttl came from $TTL line, then it should be the default.
234		 * (RFC 2308 Section 4)
235		 * Otherwise it "defaults to the last explicitly stated value"
236		 * (RFC 1035 Section 5.1)
237		 */
238		if (ttl_from_TTL)
239			my_ttl = default_ttl;
240		s = _ldns_rr_new_frm_fp_l_internal(&rr, fp, &my_ttl, &my_origin,
241				&my_prev, line_nr, &explicit_ttl);
242		switch (s) {
243		case LDNS_STATUS_OK:
244			if (explicit_ttl) {
245				if (!ttl_from_TTL) {
246					/* No $TTL, so ttl "defaults to the
247					 * last explicitly stated value"
248					 * (RFC 1035 Section 5.1)
249					 */
250					my_ttl = ldns_rr_ttl(rr);
251				}
252			/* When ttl is implicit, try to adhere to the rules as
253			 * much as possible. (also for compatibility with bind)
254			 * This was changed when fixing an issue with ZONEMD
255			 * which hashes the TTL too.
256			 */
257			} else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SIG
258			       ||  ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) {
259				if (ldns_rr_rd_count(rr) >= 4
260				&&  ldns_rdf_get_type(ldns_rr_rdf(rr, 3)) == LDNS_RDF_TYPE_INT32)
261
262					/* SIG without explicit ttl get ttl
263					 * from the original_ttl field
264					 * (RFC 2535 Section 7.2)
265					 *
266					 * Similarly for RRSIG, but stated less
267					 * specifically in the spec.
268					 * (RFC 4034 Section 3)
269					 */
270					ldns_rr_set_ttl(rr,
271					    ldns_rdf2native_int32(
272					        ldns_rr_rdf(rr, 3)));
273
274			} else if (prev_rr
275			       &&  ldns_rr_get_type(prev_rr) == ldns_rr_get_type(rr)
276			       &&  ldns_dname_compare( ldns_rr_owner(prev_rr)
277			                             , ldns_rr_owner(rr)) == 0)
278
279				/* "TTLs of all RRs in an RRSet must be the same"
280				 * (RFC 2881 Section 5.2)
281				 */
282				ldns_rr_set_ttl(rr, ldns_rr_ttl(prev_rr));
283
284			prev_rr = rr;
285			if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) {
286				if (soa_seen) {
287					/* second SOA
288					 * just skip, maybe we want to say
289					 * something??? */
290					ldns_rr_free(rr);
291					continue;
292				}
293				soa_seen = true;
294				ldns_zone_set_soa(newzone, rr);
295				/* set origin to soa if not specified */
296				if (!my_origin) {
297					my_origin = ldns_rdf_clone(ldns_rr_owner(rr));
298				}
299				continue;
300			}
301
302			/* a normal RR - as sofar the DNS is normal */
303			if (!ldns_zone_push_rr(newzone, rr)) {
304				ldns_rr_free(rr);
305				goto error;
306			}
307			break;
308
309		case LDNS_STATUS_SYNTAX_EMPTY:
310			/* empty line was seen */
311		case LDNS_STATUS_SYNTAX_TTL:
312			/* the function set the ttl */
313			default_ttl = my_ttl;
314			ttl_from_TTL = true;
315			break;
316		case LDNS_STATUS_SYNTAX_ORIGIN:
317			/* the function set the origin */
318			break;
319		case LDNS_STATUS_SYNTAX_INCLUDE:
320			ret = LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL;
321			goto error;
322		default:
323			ret = s;
324			goto error;
325		}
326	}
327
328	if (my_origin) {
329		ldns_rdf_deep_free(my_origin);
330	}
331	if (my_prev) {
332		ldns_rdf_deep_free(my_prev);
333	}
334	if (z) {
335		*z = newzone;
336	} else {
337		ldns_zone_free(newzone);
338	}
339
340	return LDNS_STATUS_OK;
341
342error:
343	if (my_origin) {
344		ldns_rdf_deep_free(my_origin);
345	}
346	if (my_prev) {
347		ldns_rdf_deep_free(my_prev);
348	}
349	if (newzone) {
350		ldns_zone_free(newzone);
351	}
352	return ret;
353}
354
355void
356ldns_zone_sort(ldns_zone *zone)
357{
358	ldns_rr_list *zrr;
359	assert(zone != NULL);
360
361	zrr = ldns_zone_rrs(zone);
362	ldns_rr_list_sort(zrr);
363}
364
365void
366ldns_zone_free(ldns_zone *zone)
367{
368	ldns_rr_list_free(zone->_rrs);
369	LDNS_FREE(zone);
370}
371
372void
373ldns_zone_deep_free(ldns_zone *zone)
374{
375	ldns_rr_free(zone->_soa);
376	ldns_rr_list_deep_free(zone->_rrs);
377	LDNS_FREE(zone);
378}
379