00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013 #include <ldns/config.h>
00014
00015 #include <ldns/ldns.h>
00016 #include <strings.h>
00017
00018
00019
00020
00021
00022
00023 uint16_t
00024 ldns_resolver_port(const ldns_resolver *r)
00025 {
00026 return r->_port;
00027 }
00028
00029 uint16_t
00030 ldns_resolver_edns_udp_size(const ldns_resolver *r)
00031 {
00032 return r->_edns_udp_size;
00033 }
00034
00035 uint8_t
00036 ldns_resolver_retry(const ldns_resolver *r)
00037 {
00038 return r->_retry;
00039 }
00040
00041 uint8_t
00042 ldns_resolver_retrans(const ldns_resolver *r)
00043 {
00044 return r->_retrans;
00045 }
00046
00047 uint8_t
00048 ldns_resolver_ip6(const ldns_resolver *r)
00049 {
00050 return r->_ip6;
00051 }
00052
00053 bool
00054 ldns_resolver_recursive(const ldns_resolver *r)
00055 {
00056 return r->_recursive;
00057 }
00058
00059 bool
00060 ldns_resolver_debug(const ldns_resolver *r)
00061 {
00062 return r->_debug;
00063 }
00064
00065 bool
00066 ldns_resolver_dnsrch(const ldns_resolver *r)
00067 {
00068 return r->_dnsrch;
00069 }
00070
00071 bool
00072 ldns_resolver_fail(const ldns_resolver *r)
00073 {
00074 return r->_fail;
00075 }
00076
00077 bool
00078 ldns_resolver_defnames(const ldns_resolver *r)
00079 {
00080 return r->_defnames;
00081 }
00082
00083 ldns_rdf *
00084 ldns_resolver_domain(const ldns_resolver *r)
00085 {
00086 return r->_domain;
00087 }
00088
00089 ldns_rdf **
00090 ldns_resolver_searchlist(const ldns_resolver *r)
00091 {
00092 return r->_searchlist;
00093 }
00094
00095 ldns_rdf **
00096 ldns_resolver_nameservers(const ldns_resolver *r)
00097 {
00098 return r->_nameservers;
00099 }
00100
00101 size_t
00102 ldns_resolver_nameserver_count(const ldns_resolver *r)
00103 {
00104 return r->_nameserver_count;
00105 }
00106
00107 bool
00108 ldns_resolver_dnssec(const ldns_resolver *r)
00109 {
00110 return r->_dnssec;
00111 }
00112
00113 bool
00114 ldns_resolver_dnssec_cd(const ldns_resolver *r)
00115 {
00116 return r->_dnssec_cd;
00117 }
00118
00119 ldns_rr_list *
00120 ldns_resolver_dnssec_anchors(const ldns_resolver *r)
00121 {
00122 return r->_dnssec_anchors;
00123 }
00124
00125 bool
00126 ldns_resolver_trusted_key(const ldns_resolver *r, ldns_rr_list * keys, ldns_rr_list * trusted_keys)
00127 {
00128 size_t i;
00129 bool result = false;
00130
00131 ldns_rr_list * trust_anchors;
00132 ldns_rr * cur_rr;
00133
00134 if (!r || !keys) { return false; }
00135
00136 trust_anchors = ldns_resolver_dnssec_anchors(r);
00137
00138 if (!trust_anchors) { return false; }
00139
00140 for (i = 0; i < ldns_rr_list_rr_count(keys); i++) {
00141
00142 cur_rr = ldns_rr_list_rr(keys, i);
00143 if (ldns_rr_list_contains_rr(trust_anchors, cur_rr)) {
00144 if (trusted_keys) { ldns_rr_list_push_rr(trusted_keys, cur_rr); }
00145 result = true;
00146 }
00147 }
00148
00149 return result;
00150 }
00151
00152 bool
00153 ldns_resolver_igntc(const ldns_resolver *r)
00154 {
00155 return r->_igntc;
00156 }
00157
00158 bool
00159 ldns_resolver_usevc(const ldns_resolver *r)
00160 {
00161 return r->_usevc;
00162 }
00163
00164 size_t *
00165 ldns_resolver_rtt(const ldns_resolver *r)
00166 {
00167 return r->_rtt;
00168 }
00169
00170 size_t
00171 ldns_resolver_nameserver_rtt(const ldns_resolver *r, size_t pos)
00172 {
00173 size_t *rtt;
00174
00175 assert(r != NULL);
00176
00177 rtt = ldns_resolver_rtt(r);
00178
00179 if (pos >= ldns_resolver_nameserver_count(r)) {
00180
00181 return 0;
00182 } else {
00183 return rtt[pos];
00184 }
00185
00186 }
00187
00188 struct timeval
00189 ldns_resolver_timeout(const ldns_resolver *r)
00190 {
00191 return r->_timeout;
00192 }
00193
00194 char *
00195 ldns_resolver_tsig_keyname(const ldns_resolver *r)
00196 {
00197 return r->_tsig_keyname;
00198 }
00199
00200 char *
00201 ldns_resolver_tsig_algorithm(const ldns_resolver *r)
00202 {
00203 return r->_tsig_algorithm;
00204 }
00205
00206 char *
00207 ldns_resolver_tsig_keydata(const ldns_resolver *r)
00208 {
00209 return r->_tsig_keydata;
00210 }
00211
00212 bool
00213 ldns_resolver_random(const ldns_resolver *r)
00214 {
00215 return r->_random;
00216 }
00217
00218 size_t
00219 ldns_resolver_searchlist_count(const ldns_resolver *r)
00220 {
00221 return r->_searchlist_count;
00222 }
00223
00224
00225 void
00226 ldns_resolver_set_port(ldns_resolver *r, uint16_t p)
00227 {
00228 r->_port = p;
00229 }
00230
00231 ldns_rdf *
00232 ldns_resolver_pop_nameserver(ldns_resolver *r)
00233 {
00234 ldns_rdf **nameservers;
00235 ldns_rdf *pop;
00236 size_t ns_count;
00237 size_t *rtt;
00238
00239 assert(r != NULL);
00240
00241 ns_count = ldns_resolver_nameserver_count(r);
00242 nameservers = ldns_resolver_nameservers(r);
00243 rtt = ldns_resolver_rtt(r);
00244 if (ns_count == 0 || !nameservers) {
00245 return NULL;
00246 }
00247
00248 pop = nameservers[ns_count - 1];
00249
00250 nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count - 1));
00251 rtt = LDNS_XREALLOC(rtt, size_t, (ns_count - 1));
00252
00253 ldns_resolver_set_nameservers(r, nameservers);
00254 ldns_resolver_set_rtt(r, rtt);
00255
00256 ldns_resolver_dec_nameserver_count(r);
00257 return pop;
00258 }
00259
00260 ldns_status
00261 ldns_resolver_push_nameserver(ldns_resolver *r, ldns_rdf *n)
00262 {
00263 ldns_rdf **nameservers;
00264 size_t ns_count;
00265 size_t *rtt;
00266
00267 if (ldns_rdf_get_type(n) != LDNS_RDF_TYPE_A &&
00268 ldns_rdf_get_type(n) != LDNS_RDF_TYPE_AAAA) {
00269 return LDNS_STATUS_ERR;
00270 }
00271
00272 ns_count = ldns_resolver_nameserver_count(r);
00273 nameservers = ldns_resolver_nameservers(r);
00274 rtt = ldns_resolver_rtt(r);
00275
00276
00277 nameservers = LDNS_XREALLOC(nameservers, ldns_rdf *, (ns_count + 1));
00278
00279 rtt = LDNS_XREALLOC(rtt, size_t, (ns_count + 1));
00280
00281
00282 ldns_resolver_set_nameservers(r, nameservers);
00283
00284
00285
00286
00287 nameservers[ns_count] = ldns_rdf_clone(n);
00288 rtt[ns_count] = LDNS_RESOLV_RTT_MIN;
00289 ldns_resolver_incr_nameserver_count(r);
00290 ldns_resolver_set_rtt(r, rtt);
00291 return LDNS_STATUS_OK;
00292 }
00293
00294 ldns_status
00295 ldns_resolver_push_nameserver_rr(ldns_resolver *r, ldns_rr *rr)
00296 {
00297 ldns_rdf *address;
00298 if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_A &&
00299 ldns_rr_get_type(rr) != LDNS_RR_TYPE_AAAA)) {
00300 return LDNS_STATUS_ERR;
00301 }
00302 address = ldns_rr_rdf(rr, 0);
00303 if (address) {
00304 return ldns_resolver_push_nameserver(r, address);
00305 } else {
00306 return LDNS_STATUS_ERR;
00307 }
00308 }
00309
00310 ldns_status
00311 ldns_resolver_push_nameserver_rr_list(ldns_resolver *r, ldns_rr_list *rrlist)
00312 {
00313 ldns_rr *rr;
00314 ldns_status stat;
00315 size_t i;
00316
00317 stat = LDNS_STATUS_OK;
00318 if (rrlist) {
00319 for(i = 0; i < ldns_rr_list_rr_count(rrlist); i++) {
00320 rr = ldns_rr_list_rr(rrlist, i);
00321 if (ldns_resolver_push_nameserver_rr(r, rr) != LDNS_STATUS_OK) {
00322 stat = LDNS_STATUS_ERR;
00323 }
00324 }
00325 return stat;
00326 } else {
00327 return LDNS_STATUS_ERR;
00328 }
00329 }
00330
00331 void
00332 ldns_resolver_set_edns_udp_size(ldns_resolver *r, uint16_t s)
00333 {
00334 r->_edns_udp_size = s;
00335 }
00336
00337 void
00338 ldns_resolver_set_recursive(ldns_resolver *r, bool re)
00339 {
00340 r->_recursive = re;
00341 }
00342
00343 void
00344 ldns_resolver_set_dnssec(ldns_resolver *r, bool d)
00345 {
00346 r->_dnssec = d;
00347 }
00348
00349 void
00350 ldns_resolver_set_dnssec_cd(ldns_resolver *r, bool d)
00351 {
00352 r->_dnssec_cd = d;
00353 }
00354
00355 void
00356 ldns_resolver_set_dnssec_anchors(ldns_resolver *r, ldns_rr_list * l)
00357 {
00358 r->_dnssec_anchors = l;
00359 }
00360
00361 ldns_status
00362 ldns_resolver_push_dnssec_anchor(ldns_resolver *r, ldns_rr *rr)
00363 {
00364 ldns_rr_list * trust_anchors;
00365
00366 if ((!rr) || (ldns_rr_get_type(rr) != LDNS_RR_TYPE_DNSKEY)) {
00367 return LDNS_STATUS_ERR;
00368 }
00369
00370 if (!(trust_anchors = ldns_resolver_dnssec_anchors(r))) {
00371 trust_anchors = ldns_rr_list_new();
00372 ldns_resolver_set_dnssec_anchors(r, trust_anchors);
00373 }
00374
00375 return (ldns_rr_list_push_rr(trust_anchors, ldns_rr_clone(rr))) ? LDNS_STATUS_OK : LDNS_STATUS_ERR;
00376 }
00377
00378 void
00379 ldns_resolver_set_igntc(ldns_resolver *r, bool i)
00380 {
00381 r->_igntc = i;
00382 }
00383
00384 void
00385 ldns_resolver_set_usevc(ldns_resolver *r, bool vc)
00386 {
00387 r->_usevc = vc;
00388 }
00389
00390 void
00391 ldns_resolver_set_debug(ldns_resolver *r, bool d)
00392 {
00393 r->_debug = d;
00394 }
00395
00396 void
00397 ldns_resolver_set_ip6(ldns_resolver *r, uint8_t ip6)
00398 {
00399 r->_ip6 = ip6;
00400 }
00401
00402 void
00403 ldns_resolver_set_fail(ldns_resolver *r, bool f)
00404 {
00405 r->_fail =f;
00406 }
00407
00408 void
00409 ldns_resolver_set_searchlist_count(ldns_resolver *r, size_t c)
00410 {
00411 r->_searchlist_count = c;
00412 }
00413
00414 void
00415 ldns_resolver_set_nameserver_count(ldns_resolver *r, size_t c)
00416 {
00417 r->_nameserver_count = c;
00418 }
00419
00420 void
00421 ldns_resolver_set_dnsrch(ldns_resolver *r, bool d)
00422 {
00423 r->_dnsrch = d;
00424 }
00425
00426 void
00427 ldns_resolver_set_retry(ldns_resolver *r, uint8_t retry)
00428 {
00429 r->_retry = retry;
00430 }
00431
00432 void
00433 ldns_resolver_set_retrans(ldns_resolver *r, uint8_t retrans)
00434 {
00435 r->_retrans = retrans;
00436 }
00437
00438 void
00439 ldns_resolver_set_nameservers(ldns_resolver *r, ldns_rdf **n)
00440 {
00441 r->_nameservers = n;
00442 }
00443
00444 void
00445 ldns_resolver_set_defnames(ldns_resolver *r, bool d)
00446 {
00447 r->_defnames = d;
00448 }
00449
00450 void
00451 ldns_resolver_set_rtt(ldns_resolver *r, size_t *rtt)
00452 {
00453 r->_rtt = rtt;
00454 }
00455
00456 void
00457 ldns_resolver_set_nameserver_rtt(ldns_resolver *r, size_t pos, size_t value)
00458 {
00459 size_t *rtt;
00460
00461 assert(r != NULL);
00462
00463 rtt = ldns_resolver_rtt(r);
00464
00465 if (pos >= ldns_resolver_nameserver_count(r)) {
00466
00467 } else {
00468 rtt[pos] = value;
00469 }
00470
00471 }
00472
00473 void
00474 ldns_resolver_incr_nameserver_count(ldns_resolver *r)
00475 {
00476 size_t c;
00477
00478 c = ldns_resolver_nameserver_count(r);
00479 ldns_resolver_set_nameserver_count(r, ++c);
00480 }
00481
00482 void
00483 ldns_resolver_dec_nameserver_count(ldns_resolver *r)
00484 {
00485 size_t c;
00486
00487 c = ldns_resolver_nameserver_count(r);
00488 if (c == 0) {
00489 return;
00490 } else {
00491 ldns_resolver_set_nameserver_count(r, --c);
00492 }
00493 }
00494
00495 void
00496 ldns_resolver_set_domain(ldns_resolver *r, ldns_rdf *d)
00497 {
00498 r->_domain = d;
00499 }
00500
00501 void
00502 ldns_resolver_set_timeout(ldns_resolver *r, struct timeval timeout)
00503 {
00504 r->_timeout.tv_sec = timeout.tv_sec;
00505 r->_timeout.tv_usec = timeout.tv_usec;
00506 }
00507
00508 void
00509 ldns_resolver_push_searchlist(ldns_resolver *r, ldns_rdf *d)
00510 {
00511 ldns_rdf **searchlist;
00512 size_t list_count;
00513
00514 if (ldns_rdf_get_type(d) != LDNS_RDF_TYPE_DNAME) {
00515 return;
00516 }
00517
00518 list_count = ldns_resolver_searchlist_count(r);
00519 searchlist = ldns_resolver_searchlist(r);
00520
00521 searchlist = LDNS_XREALLOC(searchlist, ldns_rdf *, (list_count + 1));
00522 if (searchlist) {
00523 r->_searchlist = searchlist;
00524
00525 searchlist[list_count] = ldns_rdf_clone(d);
00526 ldns_resolver_set_searchlist_count(r, list_count + 1);
00527 }
00528 }
00529
00530 void
00531 ldns_resolver_set_tsig_keyname(ldns_resolver *r, char *tsig_keyname)
00532 {
00533 r->_tsig_keyname = tsig_keyname;
00534 }
00535
00536 void
00537 ldns_resolver_set_tsig_algorithm(ldns_resolver *r, char *tsig_algorithm)
00538 {
00539 r->_tsig_algorithm = tsig_algorithm;
00540 }
00541
00542 void
00543 ldns_resolver_set_tsig_keydata(ldns_resolver *r, char *tsig_keydata)
00544 {
00545 r->_tsig_keydata = tsig_keydata;
00546 }
00547
00548 void
00549 ldns_resolver_set_random(ldns_resolver *r, bool b)
00550 {
00551 r->_random = b;
00552 }
00553
00554
00555 ldns_resolver *
00556 ldns_resolver_new(void)
00557 {
00558 ldns_resolver *r;
00559
00560 r = LDNS_MALLOC(ldns_resolver);
00561 if (!r) {
00562 return NULL;
00563 }
00564
00565 r->_searchlist = NULL;
00566 r->_nameservers = NULL;
00567 r->_rtt = NULL;
00568
00569
00570 ldns_resolver_set_searchlist_count(r, 0);
00571 ldns_resolver_set_nameserver_count(r, 0);
00572 ldns_resolver_set_usevc(r, 0);
00573 ldns_resolver_set_port(r, LDNS_PORT);
00574 ldns_resolver_set_domain(r, NULL);
00575 ldns_resolver_set_defnames(r, false);
00576 ldns_resolver_set_retry(r, 3);
00577 ldns_resolver_set_retrans(r, 2);
00578 ldns_resolver_set_fail(r, false);
00579 ldns_resolver_set_edns_udp_size(r, 0);
00580 ldns_resolver_set_dnssec(r, false);
00581 ldns_resolver_set_dnssec_cd(r, false);
00582 ldns_resolver_set_dnssec_anchors(r, NULL);
00583 ldns_resolver_set_ip6(r, LDNS_RESOLV_INETANY);
00584
00585
00586
00587
00588 ldns_resolver_set_random(r, true);
00589
00590 ldns_resolver_set_debug(r, 0);
00591
00592 r->_timeout.tv_sec = LDNS_DEFAULT_TIMEOUT_SEC;
00593 r->_timeout.tv_usec = LDNS_DEFAULT_TIMEOUT_USEC;
00594
00595 r->_socket = 0;
00596 r->_axfr_soa_count = 0;
00597 r->_axfr_i = 0;
00598 r->_cur_axfr_pkt = NULL;
00599
00600 r->_tsig_keyname = NULL;
00601 r->_tsig_keydata = NULL;
00602 r->_tsig_algorithm = NULL;
00603 return r;
00604 }
00605
00606 ldns_status
00607 ldns_resolver_new_frm_fp(ldns_resolver **res, FILE *fp)
00608 {
00609 return ldns_resolver_new_frm_fp_l(res, fp, NULL);
00610 }
00611
00612 ldns_status
00613 ldns_resolver_new_frm_fp_l(ldns_resolver **res, FILE *fp, int *line_nr)
00614 {
00615 ldns_resolver *r;
00616 const char *keyword[LDNS_RESOLV_KEYWORDS];
00617 char word[LDNS_MAX_LINELEN + 1];
00618 int8_t expect;
00619 uint8_t i;
00620 ldns_rdf *tmp;
00621 #ifdef HAVE_SSL
00622 ldns_rr *tmp_rr;
00623 #endif
00624 ssize_t gtr;
00625 ldns_buffer *b;
00626
00627
00628
00629
00630
00631
00632
00633
00634
00635 keyword[LDNS_RESOLV_NAMESERVER] = "nameserver";
00636 keyword[LDNS_RESOLV_DEFDOMAIN] = "domain";
00637 keyword[LDNS_RESOLV_SEARCH] = "search";
00638
00639 keyword[LDNS_RESOLV_SORTLIST] = "sortlist";
00640 keyword[LDNS_RESOLV_OPTIONS] = "options";
00641 keyword[LDNS_RESOLV_ANCHOR] = "anchor";
00642 expect = LDNS_RESOLV_KEYWORD;
00643
00644 r = ldns_resolver_new();
00645 if (!r) {
00646 return LDNS_STATUS_MEM_ERR;
00647 }
00648
00649 gtr = 1;
00650 word[0] = 0;
00651 while (gtr > 0) {
00652
00653 if (word[0] == '#') {
00654
00655 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00656
00657 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00658 continue;
00659 }
00660 switch(expect) {
00661 case LDNS_RESOLV_KEYWORD:
00662
00663 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00664 if (gtr != 0) {
00665 for(i = 0; i < LDNS_RESOLV_KEYWORDS; i++) {
00666 if (strcasecmp(keyword[i], word) == 0) {
00667
00668
00669
00670 expect = i;
00671 break;
00672 }
00673 }
00674 if (word[0] == '#') {
00675
00676 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
00677 continue;
00678 }
00679
00680 if (expect == LDNS_RESOLV_KEYWORD) {
00681
00682
00683
00684
00685
00686 }
00687 }
00688 break;
00689 case LDNS_RESOLV_DEFDOMAIN:
00690
00691 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00692 if (gtr == 0) {
00693 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
00694 }
00695 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
00696 if (!tmp) {
00697 ldns_resolver_deep_free(r);
00698 return LDNS_STATUS_SYNTAX_DNAME_ERR;
00699 }
00700
00701
00702 ldns_resolver_set_domain(r, tmp);
00703 expect = LDNS_RESOLV_KEYWORD;
00704 break;
00705 case LDNS_RESOLV_NAMESERVER:
00706
00707 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00708 if (gtr == 0) {
00709 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
00710 }
00711 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_AAAA, word);
00712 if (!tmp) {
00713
00714 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_A, word);
00715 }
00716
00717 if (!tmp) {
00718 ldns_resolver_deep_free(r);
00719 return LDNS_STATUS_SYNTAX_ERR;
00720 }
00721 (void)ldns_resolver_push_nameserver(r, tmp);
00722 ldns_rdf_deep_free(tmp);
00723 expect = LDNS_RESOLV_KEYWORD;
00724 break;
00725 case LDNS_RESOLV_SEARCH:
00726
00727 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
00728 b = LDNS_MALLOC(ldns_buffer);
00729 ldns_buffer_new_frm_data(b, word, (size_t) gtr);
00730
00731 gtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL, (size_t) gtr);
00732 while (gtr > 0) {
00733 tmp = ldns_rdf_new_frm_str(LDNS_RDF_TYPE_DNAME, word);
00734 if (!tmp) {
00735 ldns_resolver_deep_free(r);
00736 return LDNS_STATUS_SYNTAX_DNAME_ERR;
00737 }
00738
00739 ldns_resolver_push_searchlist(r, tmp);
00740
00741 ldns_rdf_deep_free(tmp);
00742 gtr = ldns_bget_token(b, word, LDNS_PARSE_NORMAL, (size_t) gtr);
00743 }
00744 ldns_buffer_free(b);
00745 gtr = 1;
00746 expect = LDNS_RESOLV_KEYWORD;
00747 break;
00748 case LDNS_RESOLV_SORTLIST:
00749 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
00750
00751 expect = LDNS_RESOLV_KEYWORD;
00752 break;
00753 case LDNS_RESOLV_OPTIONS:
00754 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_SKIP_SPACE, 0, line_nr);
00755
00756 expect = LDNS_RESOLV_KEYWORD;
00757 break;
00758 case LDNS_RESOLV_ANCHOR:
00759
00760 gtr = ldns_fget_token_l(fp, word, LDNS_PARSE_NORMAL, 0, line_nr);
00761 if (gtr == 0) {
00762 return LDNS_STATUS_SYNTAX_MISSING_VALUE_ERR;
00763 }
00764
00765 #ifdef HAVE_SSL
00766 tmp_rr = ldns_read_anchor_file(word);
00767 (void) ldns_resolver_push_dnssec_anchor(r, tmp_rr);
00768 ldns_rr_free(tmp_rr);
00769 #endif
00770 expect = LDNS_RESOLV_KEYWORD;
00771 break;
00772 }
00773 }
00774
00775 if (res) {
00776 *res = r;
00777 return LDNS_STATUS_OK;
00778 } else {
00779 return LDNS_STATUS_NULL;
00780 }
00781 }
00782
00783 ldns_status
00784 ldns_resolver_new_frm_file(ldns_resolver **res, const char *filename)
00785 {
00786 ldns_resolver *r;
00787 FILE *fp;
00788 ldns_status s;
00789
00790 if (!filename) {
00791 fp = fopen(LDNS_RESOLV_CONF, "r");
00792
00793 } else {
00794 fp = fopen(filename, "r");
00795 }
00796 if (!fp) {
00797 return LDNS_STATUS_FILE_ERR;
00798 }
00799
00800 s = ldns_resolver_new_frm_fp(&r, fp);
00801 fclose(fp);
00802 if (s == LDNS_STATUS_OK) {
00803 if (res) {
00804 *res = r;
00805 return LDNS_STATUS_OK;
00806 } else {
00807 return LDNS_STATUS_NULL;
00808 }
00809 }
00810 return s;
00811 }
00812
00813 void
00814 ldns_resolver_free(ldns_resolver *res)
00815 {
00816 LDNS_FREE(res);
00817 }
00818
00819 void
00820 ldns_resolver_deep_free(ldns_resolver *res)
00821 {
00822 size_t i;
00823
00824 if (res) {
00825 if (res->_searchlist) {
00826 for (i = 0; i < ldns_resolver_searchlist_count(res); i++) {
00827 ldns_rdf_deep_free(res->_searchlist[i]);
00828 }
00829 LDNS_FREE(res->_searchlist);
00830 }
00831 if (res->_nameservers) {
00832 for (i = 0; i < res->_nameserver_count; i++) {
00833 ldns_rdf_deep_free(res->_nameservers[i]);
00834 }
00835 LDNS_FREE(res->_nameservers);
00836 }
00837 if (ldns_resolver_domain(res)) {
00838 ldns_rdf_deep_free(ldns_resolver_domain(res));
00839 }
00840 if (ldns_resolver_tsig_keyname(res)) {
00841 LDNS_FREE(res->_tsig_keyname);
00842 }
00843
00844 if (res->_cur_axfr_pkt) {
00845 ldns_pkt_free(res->_cur_axfr_pkt);
00846 }
00847
00848 if (res->_rtt) {
00849 LDNS_FREE(res->_rtt);
00850 }
00851 if (res->_dnssec_anchors) {
00852 ldns_rr_list_deep_free(res->_dnssec_anchors);
00853 }
00854 LDNS_FREE(res);
00855 }
00856 }
00857
00858 ldns_pkt *
00859 ldns_resolver_search(const ldns_resolver *r,const ldns_rdf *name, ldns_rr_type type,
00860 ldns_rr_class class, uint16_t flags)
00861 {
00862
00863 char *str_dname;
00864 ldns_rdf *new_name;
00865 ldns_rdf **search_list;
00866 size_t i;
00867 ldns_pkt *p;
00868
00869 str_dname = ldns_rdf2str(name);
00870
00871 if (ldns_dname_str_absolute(str_dname)) {
00872
00873 return ldns_resolver_query(r, name, type, class, flags);
00874 } else {
00875 search_list = ldns_resolver_searchlist(r);
00876 for (i = 0; i < ldns_resolver_searchlist_count(r); i++) {
00877 new_name = ldns_dname_cat_clone(name, search_list[i]);
00878
00879 p = ldns_resolver_query(r, new_name, type, class, flags);
00880 ldns_rdf_free(new_name);
00881 if (p) {
00882 return p;
00883 }
00884 }
00885 }
00886 return NULL;
00887 }
00888
00889 ldns_pkt *
00890 ldns_resolver_query(const ldns_resolver *r, const ldns_rdf *name, ldns_rr_type type,
00891 ldns_rr_class class, uint16_t flags)
00892 {
00893 ldns_rdf *newname;
00894 ldns_pkt *pkt;
00895 ldns_status status;
00896
00897 pkt = NULL;
00898
00899 if (!ldns_resolver_defnames(r)) {
00900 status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, type, class,
00901 flags);
00902 if (status == LDNS_STATUS_OK) {
00903 return pkt;
00904 } else {
00905 if (pkt) {
00906 ldns_pkt_free(pkt);
00907 }
00908 fprintf(stderr, "error: %s\n", ldns_get_errorstr_by_id(status));
00909 return NULL;
00910 }
00911 }
00912
00913 if (!ldns_resolver_domain(r)) {
00914
00915 status = ldns_resolver_send(&pkt, (ldns_resolver *)r, name, type, class,
00916 flags);
00917 if (status == LDNS_STATUS_OK) {
00918 return pkt;
00919 } else {
00920 if (pkt) {
00921 ldns_pkt_free(pkt);
00922 }
00923 return NULL;
00924 }
00925 }
00926
00927 newname = ldns_dname_cat_clone((const ldns_rdf*)name, ldns_resolver_domain(r));
00928 if (!newname) {
00929 if (pkt) {
00930 ldns_pkt_free(pkt);
00931 }
00932 return NULL;
00933 }
00934 status = ldns_resolver_send(&pkt, (ldns_resolver *)r, newname, type, class,
00935 flags);
00936 ldns_rdf_free(newname);
00937 return pkt;
00938 }
00939
00940 ldns_status
00941 ldns_resolver_send_pkt(ldns_pkt **answer,const ldns_resolver *r,
00942 const ldns_pkt *query_pkt)
00943 {
00944 ldns_pkt *answer_pkt = NULL;
00945 ldns_status stat = LDNS_STATUS_OK;
00946
00947 stat = ldns_send(&answer_pkt, (ldns_resolver *)r, query_pkt);
00948 if (stat != LDNS_STATUS_OK) {
00949 if(answer_pkt) {
00950 ldns_pkt_free(answer_pkt);
00951 answer_pkt = NULL;
00952 }
00953 }
00954
00955 if (answer) {
00956 *answer = answer_pkt;
00957 }
00958
00959 return stat;
00960 }
00961
00962 ldns_status
00963 ldns_resolver_prepare_query_pkt(ldns_pkt **query_pkt, ldns_resolver *r,
00964 const ldns_rdf *name, ldns_rr_type type,
00965 ldns_rr_class class, uint16_t flags)
00966 {
00967
00968
00969 *query_pkt = ldns_pkt_query_new(ldns_rdf_clone(name), type, class, flags);
00970 if (!*query_pkt) {
00971 return LDNS_STATUS_ERR;
00972 }
00973
00974
00975 if (ldns_resolver_dnssec(r)) {
00976 if (ldns_resolver_edns_udp_size(r) == 0) {
00977 ldns_resolver_set_edns_udp_size(r, 4096);
00978 }
00979 ldns_pkt_set_edns_do(*query_pkt, true);
00980 if (ldns_resolver_dnssec_cd(r) || (flags & LDNS_CD)) {
00981 ldns_pkt_set_cd(*query_pkt, true);
00982 }
00983 }
00984
00985
00986 if (ldns_resolver_edns_udp_size(r) != 0) {
00987 ldns_pkt_set_edns_udp_size(*query_pkt, ldns_resolver_edns_udp_size(r));
00988 }
00989
00990 if (ldns_resolver_debug(r)) {
00991 ldns_pkt_print(stdout, *query_pkt);
00992 }
00993
00994
00995 if (ldns_pkt_id(*query_pkt) == 0) {
00996 ldns_pkt_set_random_id(*query_pkt);
00997 }
00998
00999 return LDNS_STATUS_OK;
01000 }
01001
01002
01003 ldns_status
01004 ldns_resolver_send(ldns_pkt **answer, ldns_resolver *r, const ldns_rdf *name,
01005 ldns_rr_type type, ldns_rr_class class, uint16_t flags)
01006 {
01007 ldns_pkt *query_pkt;
01008 ldns_pkt *answer_pkt;
01009 ldns_status status;
01010
01011 assert(r != NULL);
01012 assert(name != NULL);
01013
01014 answer_pkt = NULL;
01015
01016
01017
01018
01019 if (0 == type) {
01020 type = LDNS_RR_TYPE_A;
01021 }
01022 if (0 == class) {
01023 class = LDNS_RR_CLASS_IN;
01024 }
01025 if (0 == ldns_resolver_nameserver_count(r)) {
01026 return LDNS_STATUS_RES_NO_NS;
01027 }
01028 if (ldns_rdf_get_type(name) != LDNS_RDF_TYPE_DNAME) {
01029 return LDNS_STATUS_RES_QUERY;
01030 }
01031
01032 status = ldns_resolver_prepare_query_pkt(&query_pkt,
01033 r,
01034 name,
01035 type,
01036 class,
01037 flags);
01038 if (status != LDNS_STATUS_OK) {
01039 return status;
01040 }
01041
01042
01043
01044
01045
01046
01047
01048 #ifdef HAVE_SSL
01049 if (ldns_resolver_tsig_keyname(r) && ldns_resolver_tsig_keydata(r)) {
01050 status = ldns_pkt_tsig_sign(query_pkt,
01051 ldns_resolver_tsig_keyname(r),
01052 ldns_resolver_tsig_keydata(r),
01053 300, ldns_resolver_tsig_algorithm(r), NULL);
01054 if (status != LDNS_STATUS_OK) {
01055 return LDNS_STATUS_CRYPTO_TSIG_ERR;
01056 }
01057 }
01058 #endif
01059 status = ldns_resolver_send_pkt(&answer_pkt, r, query_pkt);
01060 ldns_pkt_free(query_pkt);
01061
01062
01063 if (answer) {
01064 *answer = answer_pkt;
01065 }
01066 return status;
01067 }
01068
01069 ldns_rr *
01070 ldns_axfr_next(ldns_resolver *resolver)
01071 {
01072 ldns_rr *cur_rr;
01073 uint8_t *packet_wire;
01074 size_t packet_wire_size;
01075 ldns_lookup_table *rcode;
01076 ldns_status status;
01077
01078
01079 if (!resolver || resolver->_socket == 0) {
01080 return NULL;
01081 }
01082
01083 if (resolver->_cur_axfr_pkt) {
01084 if (resolver->_axfr_i == ldns_pkt_ancount(resolver->_cur_axfr_pkt)) {
01085 ldns_pkt_free(resolver->_cur_axfr_pkt);
01086 resolver->_cur_axfr_pkt = NULL;
01087 return ldns_axfr_next(resolver);
01088 }
01089 cur_rr = ldns_rr_clone(ldns_rr_list_rr(
01090 ldns_pkt_answer(resolver->_cur_axfr_pkt),
01091 resolver->_axfr_i));
01092 resolver->_axfr_i++;
01093 if (ldns_rr_get_type(cur_rr) == LDNS_RR_TYPE_SOA) {
01094 resolver->_axfr_soa_count++;
01095 if (resolver->_axfr_soa_count >= 2) {
01096 close(resolver->_socket);
01097 resolver->_socket = 0;
01098 ldns_pkt_free(resolver->_cur_axfr_pkt);
01099 resolver->_cur_axfr_pkt = NULL;
01100 }
01101 }
01102 return cur_rr;
01103 } else {
01104 packet_wire = ldns_tcp_read_wire(resolver->_socket, &packet_wire_size);
01105 if(!packet_wire)
01106 return NULL;
01107
01108 status = ldns_wire2pkt(&resolver->_cur_axfr_pkt, packet_wire,
01109 packet_wire_size);
01110 free(packet_wire);
01111
01112 resolver->_axfr_i = 0;
01113 if (status != LDNS_STATUS_OK) {
01114
01115 fprintf(stderr, "Error parsing rr during AXFR: %s\n", ldns_get_errorstr_by_id(status));
01116 return NULL;
01117 } else if (ldns_pkt_get_rcode(resolver->_cur_axfr_pkt) != 0) {
01118 rcode = ldns_lookup_by_id(ldns_rcodes, (int) ldns_pkt_get_rcode(resolver->_cur_axfr_pkt));
01119 fprintf(stderr, "Error in AXFR: %s\n", rcode->name);
01120 return NULL;
01121 } else {
01122 return ldns_axfr_next(resolver);
01123 }
01124
01125 }
01126
01127 }
01128
01129 bool
01130 ldns_axfr_complete(const ldns_resolver *res)
01131 {
01132
01133 return res->_axfr_soa_count == 2;
01134 }
01135
01136 ldns_pkt *
01137 ldns_axfr_last_pkt(const ldns_resolver *res)
01138 {
01139 return res->_cur_axfr_pkt;
01140 }
01141
01142
01143 void
01144 ldns_resolver_nameservers_randomize(ldns_resolver *r)
01145 {
01146 uint8_t i, j;
01147 ldns_rdf **ns, *tmp;
01148
01149
01150 assert(r != NULL);
01151
01152 ns = ldns_resolver_nameservers(r);
01153
01154 for (i = 0; i < ldns_resolver_nameserver_count(r); i++) {
01155 j = random() % ldns_resolver_nameserver_count(r);
01156 tmp = ns[i];
01157 ns[i] = ns[j];
01158 ns[j] = tmp;
01159 }
01160 ldns_resolver_set_nameservers(r, ns);
01161 }
01162