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