xref: /freebsd/contrib/ldns/resolver.c (revision 8df8b2d3e51d1b816201d8a1fe8bc29fe192e562)
1 /*
2  * resolver.c
3  *
4  * resolver implementation
5  *
6  * a Net::DNS like library for C
7  *
8  * (c) NLnet Labs, 2004-2006
9  *
10  * See the file LICENSE for the license
11  */
12 
13 #include <ldns/config.h>
14 
15 #include <ldns/ldns.h>
16 #include <strings.h>
17 
18 /* Access function for reading
19  * and setting the different Resolver
20  * options */
21 
22 /* read */
23 uint16_t
24 ldns_resolver_port(const ldns_resolver *r)
25 {
26 	return r->_port;
27 }
28 
29 ldns_rdf *
30 ldns_resolver_source(const ldns_resolver *r)
31 {
32 	return r->_source;
33 }
34 
35 uint16_t
36 ldns_resolver_edns_udp_size(const ldns_resolver *r)
37 {
38 	        return r->_edns_udp_size;
39 }
40 
41 uint8_t
42 ldns_resolver_retry(const ldns_resolver *r)
43 {
44 	return r->_retry;
45 }
46 
47 uint8_t
48 ldns_resolver_retrans(const ldns_resolver *r)
49 {
50 	return r->_retrans;
51 }
52 
53 bool
54 ldns_resolver_fallback(const ldns_resolver *r)
55 {
56 	return r->_fallback;
57 }
58 
59 uint8_t
60 ldns_resolver_ip6(const ldns_resolver *r)
61 {
62 	return r->_ip6;
63 }
64 
65 bool
66 ldns_resolver_recursive(const ldns_resolver *r)
67 {
68 	return r->_recursive;
69 }
70 
71 bool
72 ldns_resolver_debug(const ldns_resolver *r)
73 {
74 	return r->_debug;
75 }
76 
77 bool
78 ldns_resolver_dnsrch(const ldns_resolver *r)
79 {
80 	return r->_dnsrch;
81 }
82 
83 bool
84 ldns_resolver_fail(const ldns_resolver *r)
85 {
86 	return r->_fail;
87 }
88 
89 bool
90 ldns_resolver_defnames(const ldns_resolver *r)
91 {
92 	return r->_defnames;
93 }
94 
95 ldns_rdf *
96 ldns_resolver_domain(const ldns_resolver *r)
97 {
98 	return r->_domain;
99 }
100 
101 ldns_rdf **
102 ldns_resolver_searchlist(const ldns_resolver *r)
103 {
104 	return r->_searchlist;
105 }
106 
107 ldns_rdf **
108 ldns_resolver_nameservers(const ldns_resolver *r)
109 {
110 	return r->_nameservers;
111 }
112 
113 size_t
114 ldns_resolver_nameserver_count(const ldns_resolver *r)
115 {
116 	return r->_nameserver_count;
117 }
118 
119 bool
120 ldns_resolver_dnssec(const ldns_resolver *r)
121 {
122 	return r->_dnssec;
123 }
124 
125 bool
126 ldns_resolver_dnssec_cd(const ldns_resolver *r)
127 {
128 	return r->_dnssec_cd;
129 }
130 
131 ldns_rr_list *
132 ldns_resolver_dnssec_anchors(const ldns_resolver *r)
133 {
134     return r->_dnssec_anchors;
135 }
136 
137 bool
138 ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list * keys, ldns_rr_list * trusted_keys)
139 {
140   size_t i;
141   bool result = false;
142 
143   ldns_rr_list * trust_anchors;
144   ldns_rr * cur_rr;
145 
146   if (!r || !keys) { return false; }
147 
148   trust_anchors = ldns_resolver_dnssec_anchors(r);
149 
150   if (!trust_anchors) { return false; }
151 
152   for (i = 0; i < ldns_rr_list_rr_count(keys); i++) {
153 
154     cur_rr = ldns_rr_list_rr(keys, i);
155     if (ldns_rr_list_contains_rr(trust_anchors, cur_rr)) {
156       if (trusted_keys) { ldns_rr_list_push_rr(trusted_keys, cur_rr); }
157       result = true;
158     }
159   }
160 
161   return result;
162 }
163 
164 bool
165 ldns_resolver_igntc(const ldns_resolver *r)
166 {
167 	return r->_igntc;
168 }
169 
170 bool
171 ldns_resolver_usevc(const ldns_resolver *r)
172 {
173 	return r->_usevc;
174 }
175 
176 size_t *
177 ldns_resolver_rtt(const ldns_resolver *r)
178 {
179 	return r->_rtt;
180 }
181 
182 size_t
183 ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos)
184 {
185 	size_t *rtt;
186 
187 	assert(r != NULL);
188 
189 	rtt = ldns_resolver_rtt(r);
190 
191 	if (pos >= ldns_resolver_nameserver_count(r)) {
192 		/* error ?*/
193 		return 0;
194 	} else {
195 		return rtt[pos];
196 	}
197 
198 }
199 
200 struct timeval
201 ldns_resolver_timeout(const ldns_resolver *r)
202 {
203 	return r->_timeout;
204 }
205 
206 const char *
207 ldns_resolver_tsig_keyname(const ldns_resolver *r)
208 {
209 	return r->_tsig_keyname;
210 }
211 
212 const char *
213 ldns_resolver_tsig_algorithm(const ldns_resolver *r)
214 {
215 	return r->_tsig_algorithm;
216 }
217 
218 const char *
219 ldns_resolver_tsig_keydata(const ldns_resolver *r)
220 {
221 	return r->_tsig_keydata;
222 }
223 
224 bool
225 ldns_resolver_random(const ldns_resolver *r)
226 {
227 	return r->_random;
228 }
229 
230 size_t
231 ldns_resolver_searchlist_count(const ldns_resolver *r)
232 {
233 	return r->_searchlist_count;
234 }
235 
236 /* write */
237 void
238 ldns_resolver_set_port(ldns_resolver *r, uint16_t p)
239 {
240 	r->_port = p;
241 }
242 
243 void
244 ldns_resolver_set_source(ldns_resolver *r, ldns_rdf *s)
245 {
246 	r->_source = s;
247 }
248 
249 ldns_rdf *
250 ldns_resolver_pop_nameserver(ldns_resolver *r)
251 {
252 	ldns_rdf **nameservers;
253 	ldns_rdf *pop;
254 	size_t ns_count;
255 	size_t *rtt;
256 
257 	assert(r != NULL);
258 
259 	ns_count = ldns_resolver_nameserver_count(r);
260 	nameservers = ldns_resolver_nameservers(r);
261 	rtt = ldns_resolver_rtt(r);
262 	if (ns_count == 0 || !nameservers) {
263 		return NULL;
264 	}
265 
266 	pop = nameservers[ns_count - 1];
267 
268 	if (ns_count == 1) {
269 		LDNS_FREE(nameservers);
270 		LDNS_FREE(rtt);
271 
272 		ldns_resolver_set_nameservers(r, NULL);
273 		ldns_resolver_set_rtt(r, NULL);
274 	} else {
275 		nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *,
276 				(ns_count - 1));
277 		rtt = LDNS_XREALLOC(rtt, size_t, (ns_count - 1));
278 
279 	        ldns_resolver_set_nameservers(r, nameservers);
280 	        ldns_resolver_set_rtt(r, rtt);
281 	}
282 	/* decr the count */
283 	ldns_resolver_dec_nameserver_count(r);
284 	return pop;
285 }
286 
287 ldns_status
288 ldns_resolver_push_nameserver(ldns_resolver *r, const ldns_rdf *n)
289 {
290 	ldns_rdf **nameservers;
291 	size_t ns_count;
292 	size_t *rtt;
293 
294 	if (ldns_rdf_get_type(n) != LDNS_RDF_TYPE_A &&
295 			ldns_rdf_get_type(n) != LDNS_RDF_TYPE_AAAA) {
296 		return LDNS_STATUS_ERR;
297 	}
298 
299 	ns_count = ldns_resolver_nameserver_count(r);
300 	nameservers = ldns_resolver_nameservers(r);
301 	rtt = ldns_resolver_rtt(r);
302 
303 	/* make room for the next one */
304 	if (ns_count == 0) {
305 		nameservers = LDNS_XMALLOC(ldns_rdf *, 1);
306 	} else {
307 		nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count + 1));
308 	}
309         if(!nameservers)
310                 return LDNS_STATUS_MEM_ERR;
311 
312 	/* set the new value in the resolver */
313 	ldns_resolver_set_nameservers(r, nameservers);
314 
315 	/* don't forget the rtt */
316 	if (ns_count == 0) {
317 		rtt = LDNS_XMALLOC(size_t, 1);
318 	} else {
319 		rtt = LDNS_XREALLOC(rtt, size_t, (ns_count + 1));
320 	}
321         if(!rtt)
322                 return LDNS_STATUS_MEM_ERR;
323 
324 	/* slide n in its slot. */
325 	/* we clone it here, because then we can free the original
326 	 * rr's where it stood */
327 	nameservers[ns_count] = ldns_rdf_clone(n);
328 	rtt[ns_count] = LDNS_RESOLV_RTT_MIN;
329 	ldns_resolver_incr_nameserver_count(r);
330 	ldns_resolver_set_rtt(r, rtt);
331 	return LDNS_STATUS_OK;
332 }
333 
334 ldns_status
335 ldns_resolver_push_nameserver_rr(ldns_resolver *r, const ldns_rr *rr)
336 {
337 	ldns_rdf *address;
338 	if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_A &&
339 			ldns_rr_get_type(rr) != LDNS_RR_TYPE_AAAA)) {
340 		return LDNS_STATUS_ERR;
341 	}
342 	address = ldns_rr_rdf(rr, 0); /* extract the ip number */
343 	if (address) {
344 		return ldns_resolver_push_nameserver(r, address);
345 	} else {
346 		return LDNS_STATUS_ERR;
347 	}
348 }
349 
350 ldns_status
351 ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, const ldns_rr_list *rrlist)
352 {
353 	ldns_rr *rr;
354 	ldns_status stat;
355 	size_t i;
356 
357 	stat = LDNS_STATUS_OK;
358 	if (rrlist) {
359 		for(i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
360 			rr = ldns_rr_list_rr(rrlist, i);
361 			if (ldns_resolver_push_nameserver_rr(r, rr) != LDNS_STATUS_OK) {
362 				stat = LDNS_STATUS_ERR;
363 				break;
364 			}
365 		}
366 		return stat;
367 	} else {
368 		return LDNS_STATUS_ERR;
369 	}
370 }
371 
372 void
373 ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s)
374 {
375 	        r->_edns_udp_size = s;
376 }
377 
378 void
379 ldns_resolver_set_recursive(ldns_resolver *r, bool re)
380 {
381 	r->_recursive = re;
382 }
383 
384 void
385 ldns_resolver_set_dnssec(ldns_resolver *r, bool d)
386 {
387 	r->_dnssec = d;
388 }
389 
390 void
391 ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool d)
392 {
393 	r->_dnssec_cd = d;
394 }
395 
396 void
397 ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list * l)
398 {
399   r->_dnssec_anchors = l;
400 }
401 
402 ldns_status
403 ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr)
404 {
405   ldns_rr_list * trust_anchors;
406 
407   if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_DNSKEY &&
408                 ldns_rr_get_type(rr) != LDNS_RR_TYPE_DS)) {
409 
410     return LDNS_STATUS_ERR;
411   }
412 
413   if (!(trust_anchors = ldns_resolver_dnssec_anchors(r))) { /* Initialize */
414     trust_anchors = ldns_rr_list_new();
415     ldns_resolver_set_dnssec_anchors(r, trust_anchors);
416   }
417 
418   return (ldns_rr_list_push_rr(trust_anchors, ldns_rr_clone(rr))) ? LDNS_STATUS_OK : LDNS_STATUS_ERR;
419 }
420 
421 void
422 ldns_resolver_set_igntc(ldns_resolver *r, bool i)
423 {
424 	r->_igntc = i;
425 }
426 
427 void
428 ldns_resolver_set_usevc(ldns_resolver *r, bool vc)
429 {
430 	r->_usevc = vc;
431 }
432 
433 void
434 ldns_resolver_set_debug(ldns_resolver *r, bool d)
435 {
436 	r->_debug = d;
437 }
438 
439 void
440 ldns_resolver_set_ip6(ldns_resolver *r, uint8_t ip6)
441 {
442 	r->_ip6 = ip6;
443 }
444 
445 void
446 ldns_resolver_set_fail(ldns_resolver *r, bool f)
447 {
448 	r->_fail =f;
449 }
450 
451 static void
452 ldns_resolver_set_searchlist_count(ldns_resolver *r, size_t c)
453 {
454 	r->_searchlist_count = c;
455 }
456 
457 void
458 ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c)
459 {
460 	r->_nameserver_count = c;
461 }
462 
463 void
464 ldns_resolver_set_dnsrch(ldns_resolver *r, bool d)
465 {
466 	r->_dnsrch = d;
467 }
468 
469 void
470 ldns_resolver_set_retry(ldns_resolver *r, uint8_t retry)
471 {
472 	r->_retry = retry;
473 }
474 
475 void
476 ldns_resolver_set_retrans(ldns_resolver *r, uint8_t retrans)
477 {
478 	r->_retrans = retrans;
479 }
480 
481 void
482 ldns_resolver_set_fallback(ldns_resolver *r, bool fallback)
483 {
484 	r->_fallback = fallback;
485 }
486 
487 void
488 ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **n)
489 {
490 	r->_nameservers = n;
491 }
492 
493 void
494 ldns_resolver_set_defnames(ldns_resolver *r, bool d)
495 {
496 	r->_defnames = d;
497 }
498 
499 void
500 ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt)
501 {
502 	r->_rtt = rtt;
503 }
504 
505 void
506 ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value)
507 {
508 	size_t *rtt;
509 
510 	assert(r != NULL);
511 
512 	rtt = ldns_resolver_rtt(r);
513 
514 	if (pos >= ldns_resolver_nameserver_count(r)) {
515 		/* error ?*/
516 	} else {
517 		rtt[pos] = value;
518 	}
519 
520 }
521 
522 void
523 ldns_resolver_incr_nameserver_count(ldns_resolver *r)
524 {
525 	size_t c;
526 
527 	c = ldns_resolver_nameserver_count(r);
528 	ldns_resolver_set_nameserver_count(r, ++c);
529 }
530 
531 void
532 ldns_resolver_dec_nameserver_count(ldns_resolver *r)
533 {
534 	size_t c;
535 
536 	c = ldns_resolver_nameserver_count(r);
537 	if (c == 0) {
538 		return;
539 	} else {
540 		ldns_resolver_set_nameserver_count(r, --c);
541 	}
542 }
543 
544 void
545 ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *d)
546 {
547 	r->_domain = d;
548 }
549 
550 void
551 ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout)
552 {
553 	r->_timeout.tv_sec = timeout.tv_sec;
554 	r->_timeout.tv_usec = timeout.tv_usec;
555 }
556 
557 void
558 ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *d)
559 {
560 	ldns_rdf **searchlist;
561 	size_t list_count;
562 
563 	if (ldns_rdf_get_type(d) != LDNS_RDF_TYPE_DNAME) {
564 		return;
565 	}
566 
567 	list_count = ldns_resolver_searchlist_count(r);
568 	searchlist = ldns_resolver_searchlist(r);
569 
570 	searchlist = LDNS_XREALLOC(searchlist, ldns_rdf *, (list_count + 1));
571 	if (searchlist) {
572 		r->_searchlist = searchlist;
573 
574 		searchlist[list_count] = ldns_rdf_clone(d);
575 		ldns_resolver_set_searchlist_count(r, list_count + 1);
576 	} /* no way to report mem err */
577 }
578 
579 void
580 ldns_resolver_set_tsig_keyname(ldns_resolver *r, const char *tsig_keyname)
581 {
582 	LDNS_FREE(r->_tsig_keyname);
583 	r->_tsig_keyname = strdup(tsig_keyname);
584 }
585 
586 void
587 ldns_resolver_set_tsig_algorithm(ldns_resolver *r, const char *tsig_algorithm)
588 {
589 	LDNS_FREE(r->_tsig_algorithm);
590 	r->_tsig_algorithm = strdup(tsig_algorithm);
591 }
592 
593 void
594 ldns_resolver_set_tsig_keydata(ldns_resolver *r, const char *tsig_keydata)
595 {
596 	LDNS_FREE(r->_tsig_keydata);
597 	r->_tsig_keydata = strdup(tsig_keydata);
598 }
599 
600 void
601 ldns_resolver_set_random(ldns_resolver *r, bool b)
602 {
603 	r->_random = b;
604 }
605 
606 /* more sophisticated functions */
607 ldns_resolver *
608 ldns_resolver_new(void)
609 {
610 	ldns_resolver *r;
611 
612 	r = LDNS_MALLOC(ldns_resolver);
613 	if (!r) {
614 		return NULL;
615 	}
616 
617 	r->_searchlist = NULL;
618 	r->_nameservers = NULL;
619 	r->_rtt = NULL;
620 
621 	/* defaults are filled out */
622 	ldns_resolver_set_searchlist_count(r, 0);
623 	ldns_resolver_set_nameserver_count(r, 0);
624 	ldns_resolver_set_usevc(r, 0);
625 	ldns_resolver_set_port(r, LDNS_PORT);
626 	ldns_resolver_set_domain(r, NULL);
627 	ldns_resolver_set_defnames(r, false);
628 	ldns_resolver_set_retry(r, 3);
629 	ldns_resolver_set_retrans(r, 2);
630 	ldns_resolver_set_fallback(r, true);
631 	ldns_resolver_set_fail(r, false);
632 	ldns_resolver_set_edns_udp_size(r, 0);
633 	ldns_resolver_set_dnssec(r, false);
634 	ldns_resolver_set_dnssec_cd(r, false);
635 	ldns_resolver_set_dnssec_anchors(r, NULL);
636 	ldns_resolver_set_ip6(r, LDNS_RESOLV_INETANY);
637 	ldns_resolver_set_igntc(r, false);
638 	ldns_resolver_set_recursive(r, false);
639 	ldns_resolver_set_dnsrch(r, true);
640 	ldns_resolver_set_source(r, NULL);
641 	ldns_resolver_set_ixfr_serial(r, 0);
642 
643 	/* randomize the nameserver to be queried
644 	 * when there are multiple
645 	 */
646 	ldns_resolver_set_random(r, true);
647 
648 	ldns_resolver_set_debug(r, 0);
649 
650 	r->_timeout.tv_sec = LDNS_DEFAULT_TIMEOUT_SEC;
651 	r->_timeout.tv_usec = LDNS_DEFAULT_TIMEOUT_USEC;
652 
653 	r->_socket = -1;
654 	r->_axfr_soa_count = 0;
655 	r->_axfr_i = 0;
656 	r->_cur_axfr_pkt = NULL;
657 
658 	r->_tsig_keyname = NULL;
659 	r->_tsig_keydata = NULL;
660 	r->_tsig_algorithm = NULL;
661 	return r;
662 }
663 
664 ldns_resolver *
665 ldns_resolver_clone(ldns_resolver *src)
666 {
667 	ldns_resolver *dst;
668 	size_t i;
669 
670 	assert(src != NULL);
671 
672 	if (!(dst = LDNS_MALLOC(ldns_resolver))) return NULL;
673 	(void) memcpy(dst, src, sizeof(ldns_resolver));
674 
675 	if (dst->_searchlist_count == 0)
676 		dst->_searchlist = NULL;
677 	else {
678 		if (!(dst->_searchlist =
679 		    LDNS_XMALLOC(ldns_rdf *, dst->_searchlist_count)))
680 			goto error;
681 		for (i = 0; i < dst->_searchlist_count; i++)
682 			if (!(dst->_searchlist[i] =
683 			    ldns_rdf_clone(src->_searchlist[i]))) {
684 				dst->_searchlist_count = i;
685 				goto error_searchlist;
686 			}
687 	}
688 	if (dst->_nameserver_count == 0) {
689 		dst->_nameservers = NULL;
690 		dst->_rtt = NULL;
691 	} else {
692 		if (!(dst->_nameservers =
693 		    LDNS_XMALLOC(ldns_rdf *, dst->_nameserver_count)))
694 			goto error_searchlist;
695 		for (i = 0; i < dst->_nameserver_count; i++)
696 			if (!(dst->_nameservers[i] =
697 			    ldns_rdf_clone(src->_nameservers[i]))) {
698 				dst->_nameserver_count = i;
699 				goto error_nameservers;
700 			}
701 		if (!(dst->_rtt =
702 		    LDNS_XMALLOC(size_t, dst->_nameserver_count)))
703 			goto error_nameservers;
704 		(void) memcpy(dst->_rtt, src->_rtt,
705 		    sizeof(size_t) * dst->_nameserver_count);
706 	}
707 	if (dst->_domain && (!(dst->_domain = ldns_rdf_clone(src->_domain))))
708 		goto error_rtt;
709 
710 	if (dst->_tsig_keyname &&
711 	    (!(dst->_tsig_keyname = strdup(src->_tsig_keyname))))
712 		goto error_domain;
713 
714 	if (dst->_tsig_keydata &&
715 	    (!(dst->_tsig_keydata = strdup(src->_tsig_keydata))))
716 		goto error_tsig_keyname;
717 
718 	if (dst->_tsig_algorithm &&
719 	    (!(dst->_tsig_algorithm = strdup(src->_tsig_algorithm))))
720 		goto error_tsig_keydata;
721 
722 	if (dst->_cur_axfr_pkt &&
723 	    (!(dst->_cur_axfr_pkt = ldns_pkt_clone(src->_cur_axfr_pkt))))
724 		goto error_tsig_algorithm;
725 
726 	if (dst->_dnssec_anchors &&
727 	    (!(dst->_dnssec_anchors=ldns_rr_list_clone(src->_dnssec_anchors))))
728 		goto error_cur_axfr_pkt;
729 
730 	return dst;
731 
732 error_cur_axfr_pkt:
733 	ldns_pkt_free(dst->_cur_axfr_pkt);
734 error_tsig_algorithm:
735 	LDNS_FREE(dst->_tsig_algorithm);
736 error_tsig_keydata:
737 	LDNS_FREE(dst->_tsig_keydata);
738 error_tsig_keyname:
739 	LDNS_FREE(dst->_tsig_keyname);
740 error_domain:
741 	ldns_rdf_deep_free(dst->_domain);
742 error_rtt:
743 	LDNS_FREE(dst->_rtt);
744 error_nameservers:
745 	for (i = 0; i < dst->_nameserver_count; i++)
746 		ldns_rdf_deep_free(dst->_nameservers[i]);
747 	LDNS_FREE(dst->_nameservers);
748 error_searchlist:
749 	for (i = 0; i < dst->_searchlist_count; i++)
750 		ldns_rdf_deep_free(dst->_searchlist[i]);
751 	LDNS_FREE(dst->_searchlist);
752 error:
753 	LDNS_FREE(dst);
754 	return NULL;
755 }
756 
757 
758 ldns_status
759 ldns_resolver_new_frm_fp(ldns_resolver **res, FILE *fp)
760 {
761 	return ldns_resolver_new_frm_fp_l(res, fp, NULL);
762 }
763 
764 ldns_status
765 ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
766 {
767 	ldns_resolver *r;
768 	const char *keyword[LDNS_RESOLV_KEYWORDS];
769 	char word[LDNS_MAX_LINELEN + 1];
770 	int8_t expect;
771 	uint8_t i;
772 	ldns_rdf *tmp;
773 #ifdef HAVE_SSL
774 	ldns_rr *tmp_rr;
775 #endif
776 	ssize_t gtr, bgtr;
777 	ldns_buffer *b;
778         int lnr = 0, oldline;
779 	FILE* myfp = fp;
780         if(!line_nr) line_nr = &lnr;
781 
782 	if(!fp) {
783 		myfp = fopen("/etc/resolv.conf", "r");
784 		if(!myfp)
785 			return LDNS_STATUS_FILE_ERR;
786 	}
787 
788 	/* do this better
789 	 * expect =
790 	 * 0: keyword
791 	 * 1: default domain dname
792 	 * 2: NS aaaa or a record
793 	 */
794 
795 	/* recognized keywords */
796 	keyword[LDNS_RESOLV_NAMESERVER] = "nameserver";
797 	keyword[LDNS_RESOLV_DEFDOMAIN] = "domain";
798 	keyword[LDNS_RESOLV_SEARCH] = "search";
799 	/* these two are read but not used atm TODO */
800 	keyword[LDNS_RESOLV_SORTLIST] = "sortlist";
801 	keyword[LDNS_RESOLV_OPTIONS] = "options";
802 	keyword[LDNS_RESOLV_ANCHOR] = "anchor";
803 	expect = LDNS_RESOLV_KEYWORD;
804 
805 	r = ldns_resolver_new();
806 	if (!r) {
807 		if(!fp) fclose(myfp);
808 		return LDNS_STATUS_MEM_ERR;
809 	}
810 
811 	gtr = 1;
812 	word[0] = 0;
813         oldline = *line_nr;
814         expect = LDNS_RESOLV_KEYWORD;
815 	while (gtr > 0) {
816 		/* check comments */
817 		if (word[0] == '#') {
818                         word[0]='x';
819                         if(oldline == *line_nr) {
820                                 /* skip until end of line */
821                                 int c;
822                                 do {
823                                         c = fgetc(myfp);
824                                 } while(c != EOF && c != '\n');
825                                 if(c=='\n') (*line_nr)++;
826                         }
827 			/* and read next to prepare for further parsing */
828                         oldline = *line_nr;
829 			continue;
830 		}
831                 oldline = *line_nr;
832 		switch(expect) {
833 			case LDNS_RESOLV_KEYWORD:
834 				/* keyword */
835 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
836 				if (gtr != 0) {
837                                         if(word[0] == '#') continue;
838 					for(i = 0; i < LDNS_RESOLV_KEYWORDS; i++) {
839 						if (strcasecmp(keyword[i], word) == 0) {
840 							/* chosen the keyword and
841 							 * expect values carefully
842 	        					 */
843 							expect = i;
844 							break;
845 						}
846 					}
847 					/* no keyword recognized */
848 					if (expect == LDNS_RESOLV_KEYWORD) {
849 						/* skip line */
850 						/*
851 						ldns_resolver_deep_free(r);
852 						if(!fp) fclose(myfp);
853 						return LDNS_STATUS_SYNTAX_KEYWORD_ERR;
854 						*/
855 					}
856 				}
857 				break;
858 			case LDNS_RESOLV_DEFDOMAIN:
859 				/* default domain dname */
860 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
861 				if (gtr == 0) {
862 					if(!fp) fclose(myfp);
863 					return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
864 				}
865                                 if(word[0] == '#') {
866                                         expect = LDNS_RESOLV_KEYWORD;
867                                         continue;
868                                 }
869 				tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
870 				if (!tmp) {
871 					ldns_resolver_deep_free(r);
872 					if(!fp) fclose(myfp);
873 					return LDNS_STATUS_SYNTAX_DNAME_ERR;
874 				}
875 
876 				/* DOn't free, because we copy the pointer */
877 				ldns_resolver_set_domain(r, tmp);
878 				expect = LDNS_RESOLV_KEYWORD;
879 				break;
880 			case LDNS_RESOLV_NAMESERVER:
881 				/* NS aaaa or a record */
882 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
883 				if (gtr == 0) {
884 					if(!fp) fclose(myfp);
885 					return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
886 				}
887                                 if(word[0] == '#') {
888                                         expect = LDNS_RESOLV_KEYWORD;
889                                         continue;
890                                 }
891                                 if(strchr(word, '%')) {
892                                         /* snip off interface labels,
893                                          * fe80::222:19ff:fe31:4222%eth0 */
894                                         strchr(word, '%')[0]=0;
895                                 }
896 				tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, word);
897 				if (!tmp) {
898 					/* try ip4 */
899 					tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, word);
900 				}
901 				/* could not parse it, exit */
902 				if (!tmp) {
903 					ldns_resolver_deep_free(r);
904 					if(!fp) fclose(myfp);
905 					return LDNS_STATUS_SYNTAX_ERR;
906 				}
907 				(void)ldns_resolver_push_nameserver(r, tmp);
908 				ldns_rdf_deep_free(tmp);
909 				expect = LDNS_RESOLV_KEYWORD;
910 				break;
911 			case LDNS_RESOLV_SEARCH:
912 				/* search list domain dname */
913 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
914 				b = LDNS_MALLOC(ldns_buffer);
915 				if(!b) {
916 					ldns_resolver_deep_free(r);
917 					if(!fp) fclose(myfp);
918 					return LDNS_STATUS_MEM_ERR;
919 				}
920 
921 				ldns_buffer_new_frm_data(b, word, (size_t) gtr);
922 				if(ldns_buffer_status(b) != LDNS_STATUS_OK) {
923 					LDNS_FREE(b);
924 					ldns_resolver_deep_free(r);
925 					if(!fp) fclose(myfp);
926 					return LDNS_STATUS_MEM_ERR;
927 				}
928 				bgtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL, (size_t) gtr + 1);
929 				while (bgtr > 0) {
930 					gtr -= bgtr;
931                                         if(word[0] == '#') {
932                                                 expect = LDNS_RESOLV_KEYWORD;
933                                                 break;
934                                         }
935 					tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
936 					if (!tmp) {
937 						ldns_resolver_deep_free(r);
938 						ldns_buffer_free(b);
939 						if(!fp) fclose(myfp);
940 						return LDNS_STATUS_SYNTAX_DNAME_ERR;
941 					}
942 
943 					ldns_resolver_push_searchlist(r, tmp);
944 
945 					ldns_rdf_deep_free(tmp);
946 					bgtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL,
947 					    (size_t) gtr + 1);
948 				}
949 				ldns_buffer_free(b);
950 				if (expect != LDNS_RESOLV_KEYWORD) {
951 					gtr = 1;
952 					expect = LDNS_RESOLV_KEYWORD;
953 				}
954 				break;
955 			case LDNS_RESOLV_SORTLIST:
956 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
957 				/* sortlist not implemented atm */
958 				expect = LDNS_RESOLV_KEYWORD;
959 				break;
960 			case LDNS_RESOLV_OPTIONS:
961 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
962 				/* options not implemented atm */
963 				expect = LDNS_RESOLV_KEYWORD;
964 				break;
965 			case LDNS_RESOLV_ANCHOR:
966 				/* a file containing a DNSSEC trust anchor */
967 				gtr = ldns_fget_token_l(myfp, word, LDNS_PARSE_NORMAL, 0, line_nr);
968 				if (gtr == 0) {
969 					ldns_resolver_deep_free(r);
970 					if(!fp) fclose(myfp);
971 					return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
972 				}
973                                 if(word[0] == '#') {
974                                         expect = LDNS_RESOLV_KEYWORD;
975                                         continue;
976                                 }
977 
978 #ifdef HAVE_SSL
979 				tmp_rr = ldns_read_anchor_file(word);
980 				(void) ldns_resolver_push_dnssec_anchor(r, tmp_rr);
981 				ldns_rr_free(tmp_rr);
982 #endif
983 				expect = LDNS_RESOLV_KEYWORD;
984 				break;
985 		}
986 	}
987 
988 	if(!fp)
989 		fclose(myfp);
990 
991 	if (res) {
992 		*res = r;
993 		return LDNS_STATUS_OK;
994 	} else {
995 		ldns_resolver_deep_free(r);
996 		return LDNS_STATUS_NULL;
997 	}
998 }
999 
1000 ldns_status
1001 ldns_resolver_new_frm_file(ldns_resolver **res, const char *filename)
1002 {
1003 	ldns_resolver *r;
1004 	FILE *fp;
1005 	ldns_status s;
1006 
1007 	if (!filename) {
1008 		fp = fopen(LDNS_RESOLV_CONF, "r");
1009 
1010 	} else {
1011 		fp = fopen(filename, "r");
1012 	}
1013 	if (!fp) {
1014 		return LDNS_STATUS_FILE_ERR;
1015 	}
1016 
1017 	s = ldns_resolver_new_frm_fp(&r, fp);
1018 	fclose(fp);
1019 	if (s == LDNS_STATUS_OK) {
1020 		if (res) {
1021 			*res = r;
1022 			return LDNS_STATUS_OK;
1023 		} else  {
1024 			ldns_resolver_free(r);
1025 			return LDNS_STATUS_NULL;
1026 		}
1027 	}
1028 	return s;
1029 }
1030 
1031 void
1032 ldns_resolver_free(ldns_resolver *res)
1033 {
1034 	LDNS_FREE(res);
1035 }
1036 
1037 void
1038 ldns_resolver_deep_free(ldns_resolver *res)
1039 {
1040 	size_t i;
1041 
1042 	if (res) {
1043 		close_socket(res->_socket);
1044 
1045 		if (res->_searchlist) {
1046 			for (i = 0; i < ldns_resolver_searchlist_count(res); i++) {
1047 				ldns_rdf_deep_free(res->_searchlist[i]);
1048 			}
1049 			LDNS_FREE(res->_searchlist);
1050 		}
1051 		if (res->_nameservers) {
1052 			for (i = 0; i < res->_nameserver_count; i++) {
1053 				ldns_rdf_deep_free(res->_nameservers[i]);
1054 			}
1055 			LDNS_FREE(res->_nameservers);
1056 		}
1057 		if (ldns_resolver_domain(res)) {
1058 			ldns_rdf_deep_free(ldns_resolver_domain(res));
1059 		}
1060 		if (res->_tsig_keyname) {
1061 			LDNS_FREE(res->_tsig_keyname);
1062 		}
1063 		if (res->_tsig_keydata) {
1064 			LDNS_FREE(res->_tsig_keydata);
1065 		}
1066 		if (res->_tsig_algorithm) {
1067 			LDNS_FREE(res->_tsig_algorithm);
1068 		}
1069 
1070 		if (res->_cur_axfr_pkt) {
1071 			ldns_pkt_free(res->_cur_axfr_pkt);
1072 		}
1073 
1074 		if (res->_rtt) {
1075 			LDNS_FREE(res->_rtt);
1076 		}
1077 		if (res->_dnssec_anchors) {
1078 			ldns_rr_list_deep_free(res->_dnssec_anchors);
1079 		}
1080 		LDNS_FREE(res);
1081 	}
1082 }
1083 
1084 ldns_status
1085 ldns_resolver_search_status(ldns_pkt** pkt,
1086 		ldns_resolver *r, const  ldns_rdf *name,
1087 		ldns_rr_type t, ldns_rr_class c, uint16_t flags)
1088 {
1089 	ldns_rdf *new_name;
1090 	ldns_rdf **search_list;
1091 	size_t i;
1092 	ldns_status s = LDNS_STATUS_OK;
1093 	ldns_rdf root_dname = { 1, LDNS_RDF_TYPE_DNAME, (void *)"" };
1094 
1095 	if (ldns_dname_absolute(name)) {
1096 		/* query as-is */
1097 		return ldns_resolver_query_status(pkt, r, name, t, c, flags);
1098 	} else if (ldns_resolver_dnsrch(r)) {
1099 		search_list = ldns_resolver_searchlist(r);
1100 		for (i = 0; i <= ldns_resolver_searchlist_count(r); i++) {
1101 			if (i == ldns_resolver_searchlist_count(r)) {
1102 				new_name = ldns_dname_cat_clone(name,
1103 						&root_dname);
1104 			} else {
1105 				new_name = ldns_dname_cat_clone(name,
1106 						search_list[i]);
1107 			}
1108 
1109 			s = ldns_resolver_query_status(pkt, r,
1110 					new_name, t, c, flags);
1111 			ldns_rdf_free(new_name);
1112 			if (pkt && *pkt) {
1113 				if (s == LDNS_STATUS_OK &&
1114 						ldns_pkt_get_rcode(*pkt) ==
1115 						LDNS_RCODE_NOERROR) {
1116 
1117 					return LDNS_STATUS_OK;
1118 				}
1119 				ldns_pkt_free(*pkt);
1120 				*pkt = NULL;
1121 			}
1122 		}
1123 	}
1124 	return s;
1125 }
1126 
1127 ldns_pkt *
1128 ldns_resolver_search(const ldns_resolver *r,const  ldns_rdf *name,
1129 	ldns_rr_type t, ldns_rr_class c, uint16_t flags)
1130 {
1131 	ldns_pkt* pkt = NULL;
1132 	if (ldns_resolver_search_status(&pkt, (ldns_resolver *)r,
1133 				name, t, c, flags) != LDNS_STATUS_OK) {
1134 		ldns_pkt_free(pkt);
1135 	}
1136 	return pkt;
1137 }
1138 
1139 ldns_status
1140 ldns_resolver_query_status(ldns_pkt** pkt,
1141 		ldns_resolver *r, const ldns_rdf *name,
1142 		ldns_rr_type t, ldns_rr_class c, uint16_t flags)
1143 {
1144 	ldns_rdf *newname;
1145 	ldns_status status;
1146 
1147 	if (!ldns_resolver_defnames(r) || !ldns_resolver_domain(r)) {
1148 		return ldns_resolver_send(pkt, r, name, t, c, flags);
1149 	}
1150 
1151 	newname = ldns_dname_cat_clone(name, ldns_resolver_domain(r));
1152 	if (!newname) {
1153 		return LDNS_STATUS_MEM_ERR;
1154 	}
1155 	status = ldns_resolver_send(pkt, r, newname, t, c, flags);
1156 	ldns_rdf_free(newname);
1157 	return status;
1158 }
1159 
1160 ldns_pkt *
1161 ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name,
1162 	ldns_rr_type t, ldns_rr_class c, uint16_t flags)
1163 {
1164 	ldns_pkt* pkt = NULL;
1165 	if (ldns_resolver_query_status(&pkt, (ldns_resolver *)r,
1166 				name, t, c, flags) != LDNS_STATUS_OK) {
1167 		ldns_pkt_free(pkt);
1168 	}
1169 	return pkt;
1170 }
1171 
1172 static size_t *
1173 ldns_resolver_backup_rtt(ldns_resolver *r)
1174 {
1175 	size_t *new_rtt;
1176 	size_t *old_rtt = ldns_resolver_rtt(r);
1177 
1178 	if (old_rtt && ldns_resolver_nameserver_count(r)) {
1179 		new_rtt = LDNS_XMALLOC(size_t
1180 				, ldns_resolver_nameserver_count(r));
1181 		memcpy(new_rtt, old_rtt, sizeof(size_t)
1182 				* ldns_resolver_nameserver_count(r));
1183 		ldns_resolver_set_rtt(r, new_rtt);
1184 		return old_rtt;
1185 	}
1186 	return NULL;
1187 }
1188 
1189 static void
1190 ldns_resolver_restore_rtt(ldns_resolver *r, size_t *old_rtt)
1191 {
1192 	size_t *cur_rtt = ldns_resolver_rtt(r);
1193 
1194 	if (cur_rtt) {
1195 		LDNS_FREE(cur_rtt);
1196 	}
1197 	ldns_resolver_set_rtt(r, old_rtt);
1198 }
1199 
1200 ldns_status
1201 ldns_resolver_send_pkt(ldns_pkt **answer, ldns_resolver *r,
1202 				   ldns_pkt *query_pkt)
1203 {
1204 	ldns_pkt *answer_pkt = NULL;
1205 	ldns_status stat = LDNS_STATUS_OK;
1206 	size_t *rtt;
1207 
1208 	stat = ldns_send(&answer_pkt, (ldns_resolver *)r, query_pkt);
1209 	if (stat != LDNS_STATUS_OK) {
1210 		if(answer_pkt) {
1211 			ldns_pkt_free(answer_pkt);
1212 			answer_pkt = NULL;
1213 		}
1214 	} else {
1215 		/* if tc=1 fall back to EDNS and/or TCP */
1216 		/* check for tcp first (otherwise we don't care about tc=1) */
1217 		if (!ldns_resolver_usevc(r) && ldns_resolver_fallback(r)) {
1218 			if (ldns_pkt_tc(answer_pkt)) {
1219 				/* was EDNS0 set? */
1220 				if (ldns_pkt_edns_udp_size(query_pkt) == 0) {
1221 					ldns_pkt_set_edns_udp_size(query_pkt
1222 							, 4096);
1223 					ldns_pkt_free(answer_pkt);
1224 					answer_pkt = NULL;
1225 					/* Nameservers should not become
1226 					 * unreachable because fragments are
1227 					 * dropped (network error). We might
1228 					 * still have success with TCP.
1229 					 * Therefore maintain reachability
1230 					 * statuses of the nameservers by
1231 					 * backup and restore the rtt list.
1232 					 */
1233 					rtt = ldns_resolver_backup_rtt(r);
1234 					stat = ldns_send(&answer_pkt, r
1235 							, query_pkt);
1236 					ldns_resolver_restore_rtt(r, rtt);
1237 				}
1238 				/* either way, if it is still truncated, use TCP */
1239 				if (stat != LDNS_STATUS_OK ||
1240 				    ldns_pkt_tc(answer_pkt)) {
1241 					ldns_resolver_set_usevc(r, true);
1242 					ldns_pkt_free(answer_pkt);
1243 					stat = ldns_send(&answer_pkt, r, query_pkt);
1244 					ldns_resolver_set_usevc(r, false);
1245 				}
1246 			}
1247 		}
1248 	}
1249 
1250 	if (answer) {
1251 		*answer = answer_pkt;
1252 	}
1253 
1254 	return stat;
1255 }
1256 
1257 ldns_status
1258 ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r,
1259                                 const ldns_rdf *name, ldns_rr_type t,
1260                                 ldns_rr_class c, uint16_t flags)
1261 {
1262 	struct timeval now;
1263 	ldns_rr* soa = NULL;
1264 
1265 	/* prepare a question pkt from the parameters
1266 	 * and then send this */
1267 	if (t == LDNS_RR_TYPE_IXFR) {
1268 		ldns_rdf *owner_rdf;
1269 		ldns_rdf *mname_rdf;
1270 		ldns_rdf *rname_rdf;
1271 		ldns_rdf *serial_rdf;
1272 		ldns_rdf *refresh_rdf;
1273 		ldns_rdf *retry_rdf;
1274 		ldns_rdf *expire_rdf;
1275 		ldns_rdf *minimum_rdf;
1276 		soa = ldns_rr_new();
1277 
1278 		if (!soa) {
1279 			return LDNS_STATUS_ERR;
1280 		}
1281 		owner_rdf = ldns_rdf_clone(name);
1282 		if (!owner_rdf) {
1283 			ldns_rr_free(soa);
1284 			return LDNS_STATUS_ERR;
1285 		}
1286 		ldns_rr_set_owner(soa, owner_rdf);
1287 		ldns_rr_set_type(soa, LDNS_RR_TYPE_SOA);
1288 		ldns_rr_set_class(soa, c);
1289 		ldns_rr_set_question(soa, false);
1290 		if (ldns_str2rdf_dname(&mname_rdf, ".") != LDNS_STATUS_OK) {
1291 			ldns_rr_free(soa);
1292 			return LDNS_STATUS_ERR;
1293 		} else	ldns_rr_push_rdf(soa, mname_rdf);
1294 		if (ldns_str2rdf_dname(&rname_rdf, ".") != LDNS_STATUS_OK) {
1295 			ldns_rr_free(soa);
1296 			return LDNS_STATUS_ERR;
1297 		} else	ldns_rr_push_rdf(soa, rname_rdf);
1298 		serial_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, ldns_resolver_get_ixfr_serial(r));
1299 		if (!serial_rdf) {
1300 			ldns_rr_free(soa);
1301 			return LDNS_STATUS_ERR;
1302 		} else	ldns_rr_push_rdf(soa, serial_rdf);
1303 		refresh_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1304 		if (!refresh_rdf) {
1305 			ldns_rr_free(soa);
1306 			return LDNS_STATUS_ERR;
1307 		} else	ldns_rr_push_rdf(soa, refresh_rdf);
1308 		retry_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1309 		if (!retry_rdf) {
1310 			ldns_rr_free(soa);
1311 			return LDNS_STATUS_ERR;
1312 		} else	ldns_rr_push_rdf(soa, retry_rdf);
1313 		expire_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1314 		if (!expire_rdf) {
1315 			ldns_rr_free(soa);
1316 			return LDNS_STATUS_ERR;
1317 		} else	ldns_rr_push_rdf(soa, expire_rdf);
1318 		minimum_rdf = ldns_native2rdf_int32(LDNS_RDF_TYPE_INT32, 0);
1319 		if (!minimum_rdf) {
1320 			ldns_rr_free(soa);
1321 			return LDNS_STATUS_ERR;
1322 		} else	ldns_rr_push_rdf(soa, minimum_rdf);
1323 
1324 		*query_pkt = ldns_pkt_ixfr_request_new(ldns_rdf_clone(name),
1325 			c, flags, soa);
1326 	} else {
1327 		*query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), t, c, flags);
1328 	}
1329 	if (!*query_pkt) {
1330 		ldns_rr_free(soa);
1331 		return LDNS_STATUS_ERR;
1332 	}
1333 
1334 	/* set DO bit if necessary */
1335 	if (ldns_resolver_dnssec(r)) {
1336 		if (ldns_resolver_edns_udp_size(r) == 0) {
1337 			ldns_resolver_set_edns_udp_size(r, 4096);
1338 		}
1339 		ldns_pkt_set_edns_do(*query_pkt, true);
1340 		if (ldns_resolver_dnssec_cd(r) || (flags & LDNS_CD)) {
1341 			ldns_pkt_set_cd(*query_pkt, true);
1342 		}
1343 	}
1344 
1345 	/* transfer the udp_edns_size from the resolver to the packet */
1346 	if (ldns_resolver_edns_udp_size(r) != 0) {
1347 		ldns_pkt_set_edns_udp_size(*query_pkt, ldns_resolver_edns_udp_size(r));
1348 	}
1349 
1350 	/* set the timestamp */
1351 	now.tv_sec = time(NULL);
1352 	now.tv_usec = 0;
1353 	ldns_pkt_set_timestamp(*query_pkt, now);
1354 
1355 
1356 	if (ldns_resolver_debug(r)) {
1357 		ldns_pkt_print(stdout, *query_pkt);
1358 	}
1359 
1360 	/* only set the id if it is not set yet */
1361 	if (ldns_pkt_id(*query_pkt) == 0) {
1362 		ldns_pkt_set_random_id(*query_pkt);
1363 	}
1364 
1365 	return LDNS_STATUS_OK;
1366 }
1367 
1368 ldns_status
1369 ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name,
1370 		ldns_rr_type t, ldns_rr_class c, uint16_t flags)
1371 {
1372 	ldns_pkt *query_pkt;
1373 	ldns_pkt *answer_pkt;
1374 	ldns_status status;
1375 
1376 	assert(r != NULL);
1377 	assert(name != NULL);
1378 
1379 	answer_pkt = NULL;
1380 
1381 	/* do all the preprocessing here, then fire of an query to
1382 	 * the network */
1383 
1384 	if (0 == t) {
1385 		t= LDNS_RR_TYPE_A;
1386 	}
1387 	if (0 == c) {
1388 		c= LDNS_RR_CLASS_IN;
1389 	}
1390 	if (0 == ldns_resolver_nameserver_count(r)) {
1391 		return LDNS_STATUS_RES_NO_NS;
1392 	}
1393 	if (ldns_rdf_get_type(name) != LDNS_RDF_TYPE_DNAME) {
1394 		return LDNS_STATUS_RES_QUERY;
1395 	}
1396 
1397 	status = ldns_resolver_prepare_query_pkt(&query_pkt, r, name,
1398 	                                         t, c, flags);
1399 	if (status != LDNS_STATUS_OK) {
1400 		return status;
1401 	}
1402 
1403 	/* if tsig values are set, tsign it */
1404 	/* TODO: make last 3 arguments optional too? maybe make complete
1405 	         rr instead of separate values in resolver (and packet)
1406 	  Jelte
1407 	  should this go in pkt_prepare?
1408 	*/
1409 	if (ldns_resolver_tsig_keyname(r) && ldns_resolver_tsig_keydata(r)) {
1410 #ifdef HAVE_SSL
1411 		status = ldns_pkt_tsig_sign(query_pkt,
1412 		                            ldns_resolver_tsig_keyname(r),
1413 		                            ldns_resolver_tsig_keydata(r),
1414 		                            300, ldns_resolver_tsig_algorithm(r), NULL);
1415 		if (status != LDNS_STATUS_OK) {
1416 			ldns_pkt_free(query_pkt);
1417 			return LDNS_STATUS_CRYPTO_TSIG_ERR;
1418 		}
1419 #else
1420 		ldns_pkt_free(query_pkt);
1421 	        return LDNS_STATUS_CRYPTO_TSIG_ERR;
1422 #endif /* HAVE_SSL */
1423 	}
1424 
1425 	status = ldns_resolver_send_pkt(&answer_pkt, r, query_pkt);
1426 	ldns_pkt_free(query_pkt);
1427 
1428 	/* allows answer to be NULL when not interested in return value */
1429 	if (answer) {
1430 		*answer = answer_pkt;
1431 	}
1432 	return status;
1433 }
1434 
1435 ldns_rr *
1436 ldns_axfr_next(ldns_resolver *resolver)
1437 {
1438 	ldns_rr *cur_rr;
1439 	uint8_t *packet_wire;
1440 	size_t packet_wire_size;
1441 	ldns_status status;
1442 
1443 	/* check if start() has been called */
1444 	if (!resolver || resolver->_socket == -1) {
1445 		return NULL;
1446 	}
1447 
1448 	if (resolver->_cur_axfr_pkt) {
1449 		if (resolver->_axfr_i == ldns_pkt_ancount(resolver->_cur_axfr_pkt)) {
1450 			ldns_pkt_free(resolver->_cur_axfr_pkt);
1451 			resolver->_cur_axfr_pkt = NULL;
1452 			return ldns_axfr_next(resolver);
1453 		}
1454 		cur_rr = ldns_rr_clone(ldns_rr_list_rr(
1455 					ldns_pkt_answer(resolver->_cur_axfr_pkt),
1456 					resolver->_axfr_i));
1457 		resolver->_axfr_i++;
1458 		if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_SOA) {
1459 			resolver->_axfr_soa_count++;
1460 			if (resolver->_axfr_soa_count >= 2) {
1461 
1462 				close_socket(resolver->_socket);
1463 
1464 				ldns_pkt_free(resolver->_cur_axfr_pkt);
1465 				resolver->_cur_axfr_pkt = NULL;
1466 			}
1467 		}
1468 		return cur_rr;
1469 	} else {
1470                packet_wire = ldns_tcp_read_wire_timeout(resolver->_socket, &packet_wire_size, resolver->_timeout);
1471 		if(!packet_wire)
1472 			return NULL;
1473 
1474 		status = ldns_wire2pkt(&resolver->_cur_axfr_pkt, packet_wire,
1475 				     packet_wire_size);
1476 		LDNS_FREE(packet_wire);
1477 
1478 		resolver->_axfr_i = 0;
1479 		if (status != LDNS_STATUS_OK) {
1480 			/* TODO: make status return type of this function (...api change) */
1481 #ifdef STDERR_MSGS
1482 			fprintf(stderr, "Error parsing rr during AXFR: %s\n", ldns_get_errorstr_by_id(status));
1483 #endif
1484 
1485 			/* we must now also close the socket, otherwise subsequent uses of the
1486 			   same resolver structure will fail because the link is still open or
1487 			   in an undefined state */
1488 
1489 			close_socket(resolver->_socket);
1490 
1491 			return NULL;
1492 		} else if (ldns_pkt_get_rcode(resolver->_cur_axfr_pkt) != 0) {
1493 #ifdef STDERR_MSGS
1494 			ldns_lookup_table *rcode = ldns_lookup_by_id(
1495 				ldns_rcodes,(int) ldns_pkt_get_rcode(
1496 				resolver->_cur_axfr_pkt));
1497 			if (rcode) {
1498 				fprintf(stderr, "Error in AXFR: %s\n",
1499 						rcode->name);
1500 			} else {
1501 				fprintf(stderr, "Error in AXFR: %d\n",
1502 						(int) ldns_pkt_get_rcode(
1503 						resolver->_cur_axfr_pkt));
1504 			}
1505 #endif
1506 
1507 			/* we must now also close the socket, otherwise subsequent uses of the
1508 			   same resolver structure will fail because the link is still open or
1509 			   in an undefined state */
1510 
1511 			close_socket(resolver->_socket);
1512 
1513 			return NULL;
1514 		} else {
1515 			return ldns_axfr_next(resolver);
1516 		}
1517 
1518 	}
1519 
1520 }
1521 
1522 /* this function is needed to abort a transfer that is in progress;
1523  * without it an aborted transfer will lead to the AXFR code in the
1524  * library staying in an indetermined state because the socket for the
1525  * AXFR is never closed
1526  */
1527 void
1528 ldns_axfr_abort(ldns_resolver *resolver)
1529 {
1530 	/* Only abort if an actual AXFR is in progress */
1531 	if (resolver->_socket != 0)
1532 	{
1533 #ifndef USE_WINSOCK
1534 		close(resolver->_socket);
1535 #else
1536 		closesocket(resolver->_socket);
1537 #endif
1538 		resolver->_socket = 0;
1539 	}
1540 }
1541 
1542 bool
1543 ldns_axfr_complete(const ldns_resolver *res)
1544 {
1545 	/* complete when soa count is 2? */
1546 	return res->_axfr_soa_count == 2;
1547 }
1548 
1549 ldns_pkt *
1550 ldns_axfr_last_pkt(const ldns_resolver *res)
1551 {
1552 	return res->_cur_axfr_pkt;
1553 }
1554 
1555 void
1556 ldns_resolver_set_ixfr_serial(ldns_resolver *r, uint32_t serial)
1557 {
1558 	r->_serial = serial;
1559 }
1560 
1561 uint32_t
1562 ldns_resolver_get_ixfr_serial(const ldns_resolver *res)
1563 {
1564 	return res->_serial;
1565 }
1566 
1567 
1568 /* random isn't really that good */
1569 void
1570 ldns_resolver_nameservers_randomize(ldns_resolver *r)
1571 {
1572 	uint16_t i, j;
1573 	ldns_rdf **ns, *tmpns;
1574 	size_t *rtt, tmprtt;
1575 
1576 	/* should I check for ldns_resolver_random?? */
1577 	assert(r != NULL);
1578 
1579 	ns = ldns_resolver_nameservers(r);
1580 	rtt = ldns_resolver_rtt(r);
1581 	for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
1582 		j = ldns_get_random() % ldns_resolver_nameserver_count(r);
1583 		tmpns = ns[i];
1584 		ns[i] = ns[j];
1585 		ns[j] = tmpns;
1586 		tmprtt = rtt[i];
1587 		rtt[i] = rtt[j];
1588 		rtt[j] = tmprtt;
1589 	}
1590 	ldns_resolver_set_nameservers(r, ns);
1591 }
1592 
1593