1 /* 2 * iterator/iter_hints.c - iterative resolver module stub and root hints. 3 * 4 * Copyright (c) 2007, NLnet Labs. All rights reserved. 5 * 6 * This software is open source. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 12 * Redistributions of source code must retain the above copyright notice, 13 * this list of conditions and the following disclaimer. 14 * 15 * Redistributions in binary form must reproduce the above copyright notice, 16 * this list of conditions and the following disclaimer in the documentation 17 * and/or other materials provided with the distribution. 18 * 19 * Neither the name of the NLNET LABS nor the names of its contributors may 20 * be used to endorse or promote products derived from this software without 21 * specific prior written permission. 22 * 23 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 24 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 25 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 26 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE 27 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 28 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 29 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 30 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 31 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 32 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 33 * POSSIBILITY OF SUCH DAMAGE. 34 */ 35 36 /** 37 * \file 38 * 39 * This file contains functions to assist the iterator module. 40 * Keep track of stub and root hints, and read those from config. 41 */ 42 #include "config.h" 43 #include <ldns/dname.h> 44 #include <ldns/rr.h> 45 #include "iterator/iter_hints.h" 46 #include "iterator/iter_delegpt.h" 47 #include "util/log.h" 48 #include "util/config_file.h" 49 #include "util/net_help.h" 50 #include "util/data/dname.h" 51 52 struct iter_hints* 53 hints_create(void) 54 { 55 struct iter_hints* hints = (struct iter_hints*)calloc(1, 56 sizeof(struct iter_hints)); 57 if(!hints) 58 return NULL; 59 return hints; 60 } 61 62 static void hints_stub_free(struct iter_hints_stub* s) 63 { 64 if(!s) return; 65 delegpt_free_mlc(s->dp); 66 free(s); 67 } 68 69 static void delhintnode(rbnode_t* n, void* ATTR_UNUSED(arg)) 70 { 71 struct iter_hints_stub* node = (struct iter_hints_stub*)n; 72 hints_stub_free(node); 73 } 74 75 static void hints_del_tree(struct iter_hints* hints) 76 { 77 traverse_postorder(&hints->tree, &delhintnode, NULL); 78 } 79 80 void 81 hints_delete(struct iter_hints* hints) 82 { 83 if(!hints) 84 return; 85 hints_del_tree(hints); 86 free(hints); 87 } 88 89 /** add hint to delegation hints */ 90 static int 91 ah(struct delegpt* dp, const char* sv, const char* ip) 92 { 93 struct sockaddr_storage addr; 94 socklen_t addrlen; 95 ldns_rdf* rdf = ldns_dname_new_frm_str(sv); 96 if(!rdf) { 97 log_err("could not parse %s", sv); 98 return 0; 99 } 100 if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0) || 101 !extstrtoaddr(ip, &addr, &addrlen) || 102 !delegpt_add_target_mlc(dp, ldns_rdf_data(rdf), ldns_rdf_size(rdf), 103 &addr, addrlen, 0, 0)) { 104 ldns_rdf_deep_free(rdf); 105 return 0; 106 } 107 ldns_rdf_deep_free(rdf); 108 return 1; 109 } 110 111 /** obtain compiletime provided root hints */ 112 static struct delegpt* 113 compile_time_root_prime(int do_ip4, int do_ip6) 114 { 115 /* from: 116 ; This file is made available by InterNIC 117 ; under anonymous FTP as 118 ; file /domain/named.cache 119 ; on server FTP.INTERNIC.NET 120 ; -OR- RS.INTERNIC.NET 121 ; 122 ; related version of root zone: changes-on-20120103 123 */ 124 struct delegpt* dp = delegpt_create_mlc((uint8_t*)"\000"); 125 if(!dp) 126 return NULL; 127 dp->has_parent_side_NS = 1; 128 if(do_ip4) { 129 if(!ah(dp, "A.ROOT-SERVERS.NET.", "198.41.0.4")) goto failed; 130 if(!ah(dp, "B.ROOT-SERVERS.NET.", "192.228.79.201")) goto failed; 131 if(!ah(dp, "C.ROOT-SERVERS.NET.", "192.33.4.12")) goto failed; 132 if(!ah(dp, "D.ROOT-SERVERS.NET.", "199.7.91.13")) goto failed; 133 if(!ah(dp, "E.ROOT-SERVERS.NET.", "192.203.230.10")) goto failed; 134 if(!ah(dp, "F.ROOT-SERVERS.NET.", "192.5.5.241")) goto failed; 135 if(!ah(dp, "G.ROOT-SERVERS.NET.", "192.112.36.4")) goto failed; 136 if(!ah(dp, "H.ROOT-SERVERS.NET.", "128.63.2.53")) goto failed; 137 if(!ah(dp, "I.ROOT-SERVERS.NET.", "192.36.148.17")) goto failed; 138 if(!ah(dp, "J.ROOT-SERVERS.NET.", "192.58.128.30")) goto failed; 139 if(!ah(dp, "K.ROOT-SERVERS.NET.", "193.0.14.129")) goto failed; 140 if(!ah(dp, "L.ROOT-SERVERS.NET.", "199.7.83.42")) goto failed; 141 if(!ah(dp, "M.ROOT-SERVERS.NET.", "202.12.27.33")) goto failed; 142 } 143 if(do_ip6) { 144 if(!ah(dp, "A.ROOT-SERVERS.NET.", "2001:503:ba3e::2:30")) goto failed; 145 if(!ah(dp, "D.ROOT-SERVERS.NET.", "2001:500:2d::d")) goto failed; 146 if(!ah(dp, "F.ROOT-SERVERS.NET.", "2001:500:2f::f")) goto failed; 147 if(!ah(dp, "H.ROOT-SERVERS.NET.", "2001:500:1::803f:235")) goto failed; 148 if(!ah(dp, "I.ROOT-SERVERS.NET.", "2001:7fe::53")) goto failed; 149 if(!ah(dp, "J.ROOT-SERVERS.NET.", "2001:503:c27::2:30")) goto failed; 150 if(!ah(dp, "K.ROOT-SERVERS.NET.", "2001:7fd::1")) goto failed; 151 if(!ah(dp, "L.ROOT-SERVERS.NET.", "2001:500:3::42")) goto failed; 152 if(!ah(dp, "M.ROOT-SERVERS.NET.", "2001:dc3::35")) goto failed; 153 } 154 return dp; 155 failed: 156 delegpt_free_mlc(dp); 157 return 0; 158 } 159 160 /** insert new hint info into hint structure */ 161 static int 162 hints_insert(struct iter_hints* hints, uint16_t c, struct delegpt* dp, 163 int noprime) 164 { 165 struct iter_hints_stub* node = (struct iter_hints_stub*)malloc( 166 sizeof(struct iter_hints_stub)); 167 if(!node) { 168 delegpt_free_mlc(dp); 169 return 0; 170 } 171 node->dp = dp; 172 node->noprime = (uint8_t)noprime; 173 if(!name_tree_insert(&hints->tree, &node->node, dp->name, dp->namelen, 174 dp->namelabs, c)) { 175 char buf[257]; 176 dname_str(dp->name, buf); 177 log_err("second hints for zone %s ignored.", buf); 178 delegpt_free_mlc(dp); 179 free(node); 180 } 181 return 1; 182 } 183 184 /** set stub name */ 185 static struct delegpt* 186 read_stubs_name(struct config_stub* s) 187 { 188 struct delegpt* dp; 189 ldns_rdf* rdf; 190 if(!s->name) { 191 log_err("stub zone without a name"); 192 return NULL; 193 } 194 rdf = ldns_dname_new_frm_str(s->name); 195 if(!rdf) { 196 log_err("cannot parse stub zone name %s", s->name); 197 return NULL; 198 } 199 if(!(dp=delegpt_create_mlc(ldns_rdf_data(rdf)))) { 200 ldns_rdf_deep_free(rdf); 201 log_err("out of memory"); 202 return NULL; 203 } 204 ldns_rdf_deep_free(rdf); 205 return dp; 206 } 207 208 /** set stub host names */ 209 static int 210 read_stubs_host(struct config_stub* s, struct delegpt* dp) 211 { 212 struct config_strlist* p; 213 ldns_rdf* rdf; 214 for(p = s->hosts; p; p = p->next) { 215 log_assert(p->str); 216 rdf = ldns_dname_new_frm_str(p->str); 217 if(!rdf) { 218 log_err("cannot parse stub %s nameserver name: '%s'", 219 s->name, p->str); 220 return 0; 221 } 222 if(!delegpt_add_ns_mlc(dp, ldns_rdf_data(rdf), 0)) { 223 ldns_rdf_deep_free(rdf); 224 log_err("out of memory"); 225 return 0; 226 } 227 ldns_rdf_deep_free(rdf); 228 } 229 return 1; 230 } 231 232 /** set stub server addresses */ 233 static int 234 read_stubs_addr(struct config_stub* s, struct delegpt* dp) 235 { 236 struct config_strlist* p; 237 struct sockaddr_storage addr; 238 socklen_t addrlen; 239 for(p = s->addrs; p; p = p->next) { 240 log_assert(p->str); 241 if(!extstrtoaddr(p->str, &addr, &addrlen)) { 242 log_err("cannot parse stub %s ip address: '%s'", 243 s->name, p->str); 244 return 0; 245 } 246 if(!delegpt_add_addr_mlc(dp, &addr, addrlen, 0, 0)) { 247 log_err("out of memory"); 248 return 0; 249 } 250 } 251 return 1; 252 } 253 254 /** read stubs config */ 255 static int 256 read_stubs(struct iter_hints* hints, struct config_file* cfg) 257 { 258 struct config_stub* s; 259 struct delegpt* dp; 260 for(s = cfg->stubs; s; s = s->next) { 261 if(!(dp=read_stubs_name(s))) 262 return 0; 263 if(!read_stubs_host(s, dp) || !read_stubs_addr(s, dp)) { 264 delegpt_free_mlc(dp); 265 return 0; 266 } 267 /* the flag is turned off for 'stub-first' so that the 268 * last resort will ask for parent-side NS record and thus 269 * fallback to the internet name servers on a failure */ 270 dp->has_parent_side_NS = (uint8_t)!s->isfirst; 271 delegpt_log(VERB_QUERY, dp); 272 if(!hints_insert(hints, LDNS_RR_CLASS_IN, dp, !s->isprime)) 273 return 0; 274 } 275 return 1; 276 } 277 278 /** read root hints from file */ 279 static int 280 read_root_hints(struct iter_hints* hints, char* fname) 281 { 282 int lineno = 0; 283 uint32_t default_ttl = 0; 284 ldns_rdf* origin = NULL; 285 ldns_rdf* prev_rr = NULL; 286 struct delegpt* dp; 287 ldns_rr* rr = NULL; 288 ldns_status status; 289 uint16_t c = LDNS_RR_CLASS_IN; 290 FILE* f = fopen(fname, "r"); 291 if(!f) { 292 log_err("could not read root hints %s: %s", 293 fname, strerror(errno)); 294 return 0; 295 } 296 dp = delegpt_create_mlc(NULL); 297 if(!dp) { 298 log_err("out of memory reading root hints"); 299 fclose(f); 300 return 0; 301 } 302 verbose(VERB_QUERY, "Reading root hints from %s", fname); 303 dp->has_parent_side_NS = 1; 304 while(!feof(f)) { 305 status = ldns_rr_new_frm_fp_l(&rr, f, 306 &default_ttl, &origin, &prev_rr, &lineno); 307 if(status == LDNS_STATUS_SYNTAX_EMPTY || 308 status == LDNS_STATUS_SYNTAX_TTL || 309 status == LDNS_STATUS_SYNTAX_ORIGIN) 310 continue; 311 if(status != LDNS_STATUS_OK) { 312 log_err("reading root hints %s %d: %s", fname, 313 lineno, ldns_get_errorstr_by_id(status)); 314 goto stop_read; 315 } 316 if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_NS) { 317 if(!delegpt_add_ns_mlc(dp, 318 ldns_rdf_data(ldns_rr_rdf(rr, 0)), 0)) { 319 log_err("out of memory reading root hints"); 320 goto stop_read; 321 } 322 c = ldns_rr_get_class(rr); 323 if(!dp->name) { 324 if(!delegpt_set_name_mlc(dp, 325 ldns_rdf_data(ldns_rr_owner(rr)))){ 326 log_err("out of memory."); 327 goto stop_read; 328 } 329 } 330 } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_A) { 331 struct sockaddr_in sa; 332 socklen_t len = (socklen_t)sizeof(sa); 333 memset(&sa, 0, len); 334 sa.sin_family = AF_INET; 335 sa.sin_port = (in_port_t)htons(UNBOUND_DNS_PORT); 336 memmove(&sa.sin_addr, 337 ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET_SIZE); 338 if(!delegpt_add_target_mlc(dp, 339 ldns_rdf_data(ldns_rr_owner(rr)), 340 ldns_rdf_size(ldns_rr_owner(rr)), 341 (struct sockaddr_storage*)&sa, len, 342 0, 0)) { 343 log_err("out of memory reading root hints"); 344 goto stop_read; 345 } 346 } else if(ldns_rr_get_type(rr) == LDNS_RR_TYPE_AAAA) { 347 struct sockaddr_in6 sa; 348 socklen_t len = (socklen_t)sizeof(sa); 349 memset(&sa, 0, len); 350 sa.sin6_family = AF_INET6; 351 sa.sin6_port = (in_port_t)htons(UNBOUND_DNS_PORT); 352 memmove(&sa.sin6_addr, 353 ldns_rdf_data(ldns_rr_rdf(rr, 0)), INET6_SIZE); 354 if(!delegpt_add_target_mlc(dp, 355 ldns_rdf_data(ldns_rr_owner(rr)), 356 ldns_rdf_size(ldns_rr_owner(rr)), 357 (struct sockaddr_storage*)&sa, len, 358 0, 0)) { 359 log_err("out of memory reading root hints"); 360 goto stop_read; 361 } 362 } else { 363 log_warn("root hints %s:%d skipping type %d", 364 fname, lineno, ldns_rr_get_type(rr)); 365 } 366 367 ldns_rr_free(rr); 368 } 369 370 if (origin) 371 ldns_rdf_deep_free(origin); 372 if (prev_rr) 373 ldns_rdf_deep_free(prev_rr); 374 fclose(f); 375 if(!dp->name) { 376 log_warn("root hints %s: no NS content", fname); 377 delegpt_free_mlc(dp); 378 return 1; 379 } 380 if(!hints_insert(hints, c, dp, 0)) { 381 return 0; 382 } 383 delegpt_log(VERB_QUERY, dp); 384 return 1; 385 386 stop_read: 387 if (origin) 388 ldns_rdf_deep_free(origin); 389 if (prev_rr) 390 ldns_rdf_deep_free(prev_rr); 391 delegpt_free_mlc(dp); 392 fclose(f); 393 return 0; 394 } 395 396 /** read root hints list */ 397 static int 398 read_root_hints_list(struct iter_hints* hints, struct config_file* cfg) 399 { 400 struct config_strlist* p; 401 for(p = cfg->root_hints; p; p = p->next) { 402 log_assert(p->str); 403 if(p->str && p->str[0]) { 404 char* f = p->str; 405 if(cfg->chrootdir && cfg->chrootdir[0] && 406 strncmp(p->str, cfg->chrootdir, 407 strlen(cfg->chrootdir)) == 0) 408 f += strlen(cfg->chrootdir); 409 if(!read_root_hints(hints, f)) 410 return 0; 411 } 412 } 413 return 1; 414 } 415 416 int 417 hints_apply_cfg(struct iter_hints* hints, struct config_file* cfg) 418 { 419 hints_del_tree(hints); 420 name_tree_init(&hints->tree); 421 422 /* read root hints */ 423 if(!read_root_hints_list(hints, cfg)) 424 return 0; 425 426 /* read stub hints */ 427 if(!read_stubs(hints, cfg)) 428 return 0; 429 430 /* use fallback compiletime root hints */ 431 if(!hints_lookup_root(hints, LDNS_RR_CLASS_IN)) { 432 struct delegpt* dp = compile_time_root_prime(cfg->do_ip4, 433 cfg->do_ip6); 434 verbose(VERB_ALGO, "no config, using builtin root hints."); 435 if(!dp) 436 return 0; 437 if(!hints_insert(hints, LDNS_RR_CLASS_IN, dp, 0)) 438 return 0; 439 } 440 441 name_tree_init_parents(&hints->tree); 442 return 1; 443 } 444 445 struct delegpt* 446 hints_lookup_root(struct iter_hints* hints, uint16_t qclass) 447 { 448 uint8_t rootlab = 0; 449 struct iter_hints_stub *stub; 450 stub = (struct iter_hints_stub*)name_tree_find(&hints->tree, 451 &rootlab, 1, 1, qclass); 452 if(!stub) 453 return NULL; 454 return stub->dp; 455 } 456 457 struct iter_hints_stub* 458 hints_lookup_stub(struct iter_hints* hints, uint8_t* qname, 459 uint16_t qclass, struct delegpt* cache_dp) 460 { 461 size_t len; 462 int labs; 463 struct iter_hints_stub *r; 464 465 /* first lookup the stub */ 466 labs = dname_count_size_labels(qname, &len); 467 r = (struct iter_hints_stub*)name_tree_lookup(&hints->tree, qname, 468 len, labs, qclass); 469 if(!r) return NULL; 470 471 /* If there is no cache (root prime situation) */ 472 if(cache_dp == NULL) { 473 if(r->dp->namelabs != 1) 474 return r; /* no cache dp, use any non-root stub */ 475 return NULL; 476 } 477 478 /* 479 * If the stub is same as the delegation we got 480 * And has noprime set, we need to 'prime' to use this stub instead. 481 */ 482 if(r->noprime && query_dname_compare(cache_dp->name, r->dp->name)==0) 483 return r; /* use this stub instead of cached dp */ 484 485 /* 486 * If our cached delegation point is above the hint, we need to prime. 487 */ 488 if(dname_strict_subdomain(r->dp->name, r->dp->namelabs, 489 cache_dp->name, cache_dp->namelabs)) 490 return r; /* need to prime this stub */ 491 return NULL; 492 } 493 494 int hints_next_root(struct iter_hints* hints, uint16_t* qclass) 495 { 496 return name_tree_next_root(&hints->tree, qclass); 497 } 498 499 size_t 500 hints_get_mem(struct iter_hints* hints) 501 { 502 size_t s; 503 struct iter_hints_stub* p; 504 if(!hints) return 0; 505 s = sizeof(*hints); 506 RBTREE_FOR(p, struct iter_hints_stub*, &hints->tree) { 507 s += sizeof(*p) + delegpt_get_mem(p->dp); 508 } 509 return s; 510 } 511 512 int 513 hints_add_stub(struct iter_hints* hints, uint16_t c, struct delegpt* dp, 514 int noprime) 515 { 516 struct iter_hints_stub *z; 517 if((z=(struct iter_hints_stub*)name_tree_find(&hints->tree, 518 dp->name, dp->namelen, dp->namelabs, c)) != NULL) { 519 (void)rbtree_delete(&hints->tree, &z->node); 520 hints_stub_free(z); 521 } 522 if(!hints_insert(hints, c, dp, noprime)) 523 return 0; 524 name_tree_init_parents(&hints->tree); 525 return 1; 526 } 527 528 void 529 hints_delete_stub(struct iter_hints* hints, uint16_t c, uint8_t* nm) 530 { 531 struct iter_hints_stub *z; 532 size_t len; 533 int labs = dname_count_size_labels(nm, &len); 534 if(!(z=(struct iter_hints_stub*)name_tree_find(&hints->tree, 535 nm, len, labs, c))) 536 return; /* nothing to do */ 537 (void)rbtree_delete(&hints->tree, &z->node); 538 hints_stub_free(z); 539 name_tree_init_parents(&hints->tree); 540 } 541 542