Initial vendor import of ldns-1.6.4 into contrib.
[dragonfly.git] / contrib / ldns / zone.c
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
16 ldns_rr *
17 ldns_zone_soa(const ldns_zone *z)
18 {
19         return z->_soa;
20 }
21
22 size_t
23 ldns_zone_rr_count(const ldns_zone *z)
24 {
25         return ldns_rr_list_rr_count(z->_rrs);
26 }
27
28 void
29 ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa)
30 {
31         z->_soa = soa;
32 }
33
34 ldns_rr_list *
35 ldns_zone_rrs(const ldns_zone *z)
36 {
37         return z->_rrs;
38 }
39
40 void
41 ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist)
42 {
43         z->_rrs = rrlist;
44 }
45
46 bool
47 ldns_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
53 bool
54 ldns_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  */
63 ldns_rr_list *
64 ldns_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
145 memory_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  */
163 ldns_rr_list *
164 ldns_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
250 memory_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
263 ldns_zone *
264 ldns_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  */
285 ldns_status
286 ldns_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 */
292 ldns_status
293 ldns_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
382 error:
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
395 void
396 ldns_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  */
414 void
415 ldns_zone_ixfr_del_add(ldns_zone *z, ldns_rr_list *del, ldns_rr_list *add)
416 {
417         
418 }
419 #endif
420
421 void
422 ldns_zone_free(ldns_zone *zone) 
423 {
424         ldns_rr_list_free(zone->_rrs);
425         LDNS_FREE(zone);
426 }
427
428 void
429 ldns_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 }