Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / zone.c
CommitLineData
b9b3af22
JL
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
13#include <strings.h>
14#include <limits.h>
15
16ldns_rr *
17ldns_zone_soa(const ldns_zone *z)
18{
19 return z->_soa;
20}
21
22size_t
23ldns_zone_rr_count(const ldns_zone *z)
24{
25 return ldns_rr_list_rr_count(z->_rrs);
26}
27
28void
29ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa)
30{
31 z->_soa = soa;
32}
33
34ldns_rr_list *
35ldns_zone_rrs(const ldns_zone *z)
36{
37 return z->_rrs;
38}
39
40void
41ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist)
42{
43 z->_rrs = rrlist;
44}
45
46bool
47ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list)
48{
49 return ldns_rr_list_cat(ldns_zone_rrs(z), list);
50
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/* return a clone of the given rr list, without the glue records
60 * rr list should be the complete zone
61 * if present, stripped records are added to the list *glue_records
62 */
63ldns_rr_list *
64ldns_zone_strip_glue_rrs(const ldns_rdf *zone_name, const ldns_rr_list *rrs, ldns_rr_list *glue_rrs)
65{
66 ldns_rr_list *new_list;
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 *r, *ns, *a;
84 ldns_rdf *dname_a, *dname_ns, *ns_owner;
85 uint16_t i,j;
86
87 new_list = NULL;
88 zone_cuts = NULL;
89 addr = NULL;
90
91 new_list = ldns_rr_list_new();
92 if (!new_list) goto memory_error;
93 zone_cuts = ldns_rr_list_new();
94 if (!zone_cuts) goto memory_error;
95 addr = ldns_rr_list_new();
96 if (!addr) goto memory_error;
97
98 for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) {
99 r = ldns_rr_list_rr(rrs, i);
100 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A ||
101 ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) {
102 /* possibly glue */
103 if (!ldns_rr_list_push_rr(addr, r)) goto memory_error;
104 continue;
105 }
106 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) {
107 /* multiple zones will end up here -
108 * for now; not a problem
109 */
110 /* don't add NS records for the current zone itself */
111 if (ldns_rdf_compare(ldns_rr_owner(r),
112 zone_name) != 0) {
113 if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error;
114 }
115 continue;
116 }
117 }
118
119 /* will sorting make it quicker ?? */
120 for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) {
121 ns = ldns_rr_list_rr(zone_cuts, i);
122 ns_owner = ldns_rr_owner(ns);
123 dname_ns = ldns_rr_ns_nsdname(ns);
124 for(j = 0; j < ldns_rr_list_rr_count(addr); j++) {
125 a = ldns_rr_list_rr(addr, j);
126 dname_a = ldns_rr_owner(a);
127
128 if (ldns_dname_is_subdomain(dname_a, ns_owner)) {
129 /* GLUE! */
130 if (glue_rrs) {
131 if (!ldns_rr_list_push_rr(glue_rrs, a)) goto memory_error;
132 }
133 break;
134 } else {
135 if (!ldns_rr_list_push_rr(new_list, a)) goto memory_error;
136 }
137 }
138 }
139
140 ldns_rr_list_free(addr);
141 ldns_rr_list_free(zone_cuts);
142
143 return new_list;
144
145memory_error:
146 if (new_list) {
147 ldns_rr_list_free(new_list);
148 }
149 if (zone_cuts) {
150 ldns_rr_list_free(zone_cuts);
151 }
152 if (addr) {
153 ldns_rr_list_free(addr);
154 }
155 return NULL;
156}
157
158/*
159 * Get the list of glue records in a zone
160 * XXX: there should be a way for this to return error, other than NULL,
161 * since NULL is a valid return
162 */
163ldns_rr_list *
164ldns_zone_glue_rr_list(const ldns_zone *z)
165{
166 /* when do we find glue? It means we find an IP address
167 * (AAAA/A) for a nameserver listed in the zone
168 *
169 * Alg used here:
170 * first find all the zonecuts (NS records)
171 * find all the AAAA or A records (can be done it the
172 * above loop).
173 *
174 * Check if the aaaa/a list are subdomains under the
175 * NS domains.
176 * If yes -> glue, if no -> not glue
177 */
178
179 ldns_rr_list *zone_cuts;
180 ldns_rr_list *addr;
181 ldns_rr_list *glue;
182 ldns_rr *r, *ns, *a;
183 ldns_rdf *dname_a, *dname_ns, *ns_owner;
184 size_t i,j;
185
186 zone_cuts = NULL;
187 addr = NULL;
188 glue = NULL;
189
190 /* we cannot determine glue in a 'zone' without a SOA */
191 if (!ldns_zone_soa(z)) {
192 return NULL;
193 }
194
195 zone_cuts = ldns_rr_list_new();
196 if (!zone_cuts) goto memory_error;
197 addr = ldns_rr_list_new();
198 if (!addr) goto memory_error;
199 glue = ldns_rr_list_new();
200 if (!glue) goto memory_error;
201
202 for(i = 0; i < ldns_zone_rr_count(z); i++) {
203 r = ldns_rr_list_rr(ldns_zone_rrs(z), i);
204 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A ||
205 ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) {
206 /* possibly glue */
207 if (!ldns_rr_list_push_rr(addr, r)) goto memory_error;
208 continue;
209 }
210 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) {
211 /* multiple zones will end up here -
212 * for now; not a problem
213 */
214 /* don't add NS records for the current zone itself */
215 if (ldns_rdf_compare(ldns_rr_owner(r),
216 ldns_rr_owner(ldns_zone_soa(z))) != 0) {
217 if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error;
218 }
219 continue;
220 }
221 }
222
223 /* will sorting make it quicker ?? */
224 for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) {
225 ns = ldns_rr_list_rr(zone_cuts, i);
226 ns_owner = ldns_rr_owner(ns);
227
228 dname_ns = ldns_rr_ns_nsdname(ns);
229 for(j = 0; j < ldns_rr_list_rr_count(addr); j++) {
230 a = ldns_rr_list_rr(addr, j);
231 dname_a = ldns_rr_owner(a);
232
233 if (ldns_dname_is_subdomain(dname_a, ns_owner)) {
234 /* GLUE! */
235 if (!ldns_rr_list_push_rr(glue, a)) goto memory_error;
236 }
237 }
238 }
239
240 ldns_rr_list_free(addr);
241 ldns_rr_list_free(zone_cuts);
242
243 if (ldns_rr_list_rr_count(glue) == 0) {
244 ldns_rr_list_free(glue);
245 return NULL;
246 } else {
247 return glue;
248 }
249
250memory_error:
251 if (zone_cuts) {
252 LDNS_FREE(zone_cuts);
253 }
254 if (addr) {
255 ldns_rr_list_free(addr);
256 }
257 if (glue) {
258 ldns_rr_list_free(glue);
259 }
260 return NULL;
261}
262
263ldns_zone *
264ldns_zone_new(void)
265{
266 ldns_zone *z;
267
268 z = LDNS_MALLOC(ldns_zone);
269 if (!z) {
270 return NULL;
271 }
272
273 z->_rrs = ldns_rr_list_new();
274 if (!z->_rrs) {
275 LDNS_FREE(z);
276 return NULL;
277 }
278 ldns_zone_set_soa(z, NULL);
279 return z;
280}
281
282/* we regocnize:
283 * $TTL, $ORIGIN
284 */
285ldns_status
286ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c)
287{
288 return ldns_zone_new_frm_fp_l(z, fp, origin, ttl, c, NULL);
289}
290
291/* XXX: class is never used */
292ldns_status
293ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c,
294 int *line_nr)
295{
296 ldns_zone *newzone;
297 ldns_rr *rr;
298 uint32_t my_ttl;
299 ldns_rr_class my_class;
300 ldns_rdf *my_origin;
301 ldns_rdf *my_prev;
302 bool soa_seen = false; /* 2 soa are an error */
303 ldns_status s;
304 ldns_status ret;
305
306 /* most cases of error are memory problems */
307 ret = LDNS_STATUS_MEM_ERR;
308
309 newzone = NULL;
310 my_origin = NULL;
311 my_prev = NULL;
312
313 my_ttl = ttl;
314 my_class = c;
315
316 if (origin) {
317 my_origin = ldns_rdf_clone(origin);
318 if (!my_origin) goto error;
319 /* also set the prev */
320 my_prev = ldns_rdf_clone(origin);
321 if (!my_prev) goto error;
322 }
323
324 newzone = ldns_zone_new();
325 if (!newzone) goto error;
326
327 while(!feof(fp)) {
328 s = ldns_rr_new_frm_fp_l(&rr, fp, &my_ttl, &my_origin, &my_prev, line_nr);
329 switch (s) {
330 case LDNS_STATUS_OK:
331 if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) {
332 if (soa_seen) {
333 /* second SOA
334 * just skip, maybe we want to say
335 * something??? */
336 ldns_rr_free(rr);
337 continue;
338 }
339 soa_seen = true;
340 ldns_zone_set_soa(newzone, rr);
341 /* set origin to soa if not specified */
342 if (!my_origin) {
343 my_origin = ldns_rdf_clone(ldns_rr_owner(rr));
344 }
345 continue;
346 }
347
348 /* a normal RR - as sofar the DNS is normal */
349 if (!ldns_zone_push_rr(newzone, rr)) goto error;
350
351 /*my_origin = ldns_rr_owner(rr);*/
352 my_ttl = ldns_rr_ttl(rr); /* XXX: this seems like an error */
353 my_class = ldns_rr_get_class(rr);
354 case LDNS_STATUS_SYNTAX_EMPTY:
355 /* empty line was seen */
356 case LDNS_STATUS_SYNTAX_TTL:
357 /* the function set the ttl */
358 break;
359 case LDNS_STATUS_SYNTAX_ORIGIN:
360 /* the function set the origin */
361 break;
362 default:
363 ret = s;
364 goto error;
365 }
366 }
367
368 if (my_origin) {
369 ldns_rdf_deep_free(my_origin);
370 }
371 if (my_prev) {
372 ldns_rdf_deep_free(my_prev);
373 }
374 if (z) {
375 *z = newzone;
376 } else {
377 ldns_zone_free(newzone);
378 }
379
380 return LDNS_STATUS_OK;
381
382error:
383 if (my_origin) {
384 ldns_rdf_deep_free(my_origin);
385 }
386 if (my_prev) {
387 ldns_rdf_deep_free(my_prev);
388 }
389 if (newzone) {
390 ldns_zone_free(newzone);
391 }
392 return ret;
393}
394
395void
396ldns_zone_sort(ldns_zone *zone)
397{
398 ldns_rr_list *zrr;
399 assert(zone != NULL);
400
401 zrr = ldns_zone_rrs(zone);
402 ldns_rr_list_sort(zrr);
403}
404
405#if 0
406/**
407 * ixfr function. Work on a ldns_zone and remove and add
408 * the rrs from the rrlist
409 * \param[in] z the zone to work on
410 * \param[in] del rr_list to remove from the zone
411 * \param[in] add rr_list to add to the zone
412 * \return Tja, wat zouden we eens returnen TODO
413 */
414void
415ldns_zone_ixfr_del_add(ldns_zone *z, ldns_rr_list *del, ldns_rr_list *add)
416{
417
418}
419#endif
420
421void
422ldns_zone_free(ldns_zone *zone)
423{
424 ldns_rr_list_free(zone->_rrs);
425 LDNS_FREE(zone);
426}
427
428void
429ldns_zone_deep_free(ldns_zone *zone)
430{
431 ldns_rr_free(zone->_soa);
432 ldns_rr_list_deep_free(zone->_rrs);
433 LDNS_FREE(zone);
434}