1 /* zone.c 2 * 3 * Functions for ldns_zone structure 4 * a Net::DNS like library for C 5 * 6 * (c) NLnet Labs, 2005-2006 7 * See the file LICENSE for the license 8 */ 9 #include <ldns/config.h> 10 11 #include <ldns/ldns.h> 12 13 #include <strings.h> 14 #include <limits.h> 15 16 ldns_rr * 17 ldns_zone_soa(const ldns_zone *z) 18 { 19 return z->_soa; 20 } 21 22 size_t 23 ldns_zone_rr_count(const ldns_zone *z) 24 { 25 return ldns_rr_list_rr_count(z->_rrs); 26 } 27 28 void 29 ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa) 30 { 31 z->_soa = soa; 32 } 33 34 ldns_rr_list * 35 ldns_zone_rrs(const ldns_zone *z) 36 { 37 return z->_rrs; 38 } 39 40 void 41 ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist) 42 { 43 z->_rrs = rrlist; 44 } 45 46 bool 47 ldns_zone_push_rr_list(ldns_zone *z, ldns_rr_list *list) 48 { 49 return ldns_rr_list_cat(ldns_zone_rrs(z), list); 50 51 } 52 53 bool 54 ldns_zone_push_rr(ldns_zone *z, ldns_rr *rr) 55 { 56 return ldns_rr_list_push_rr( ldns_zone_rrs(z), rr); 57 } 58 59 /* return a clone of the given rr list, without the glue records 60 * rr list should be the complete zone 61 * if present, stripped records are added to the list *glue_records 62 */ 63 ldns_rr_list * 64 ldns_zone_strip_glue_rrs(const ldns_rdf *zone_name, const ldns_rr_list *rrs, ldns_rr_list *glue_rrs) 65 { 66 ldns_rr_list *new_list; 67 68 /* when do we find glue? It means we find an IP address 69 * (AAAA/A) for a nameserver listed in the zone 70 * 71 * Alg used here: 72 * first find all the zonecuts (NS records) 73 * find all the AAAA or A records (can be done it the 74 * above loop). 75 * 76 * Check if the aaaa/a list are subdomains under the 77 * NS domains. 78 * If yes -> glue, if no -> not glue 79 */ 80 81 ldns_rr_list *zone_cuts; 82 ldns_rr_list *addr; 83 ldns_rr *r, *ns, *a; 84 ldns_rdf *dname_a, *dname_ns, *ns_owner; 85 uint16_t i,j; 86 87 new_list = NULL; 88 zone_cuts = NULL; 89 addr = NULL; 90 91 new_list = ldns_rr_list_new(); 92 if (!new_list) goto memory_error; 93 zone_cuts = ldns_rr_list_new(); 94 if (!zone_cuts) goto memory_error; 95 addr = ldns_rr_list_new(); 96 if (!addr) goto memory_error; 97 98 for(i = 0; i < ldns_rr_list_rr_count(rrs); i++) { 99 r = ldns_rr_list_rr(rrs, i); 100 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A || 101 ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) { 102 /* possibly glue */ 103 if (!ldns_rr_list_push_rr(addr, r)) goto memory_error; 104 continue; 105 } 106 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) { 107 /* multiple zones will end up here - 108 * for now; not a problem 109 */ 110 /* don't add NS records for the current zone itself */ 111 if (ldns_rdf_compare(ldns_rr_owner(r), 112 zone_name) != 0) { 113 if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error; 114 } 115 continue; 116 } 117 } 118 119 /* will sorting make it quicker ?? */ 120 for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) { 121 ns = ldns_rr_list_rr(zone_cuts, i); 122 ns_owner = ldns_rr_owner(ns); 123 dname_ns = ldns_rr_ns_nsdname(ns); 124 for(j = 0; j < ldns_rr_list_rr_count(addr); j++) { 125 a = ldns_rr_list_rr(addr, j); 126 dname_a = ldns_rr_owner(a); 127 128 if (ldns_dname_is_subdomain(dname_a, ns_owner)) { 129 /* GLUE! */ 130 if (glue_rrs) { 131 if (!ldns_rr_list_push_rr(glue_rrs, a)) goto memory_error; 132 } 133 break; 134 } else { 135 if (!ldns_rr_list_push_rr(new_list, a)) goto memory_error; 136 } 137 } 138 } 139 140 ldns_rr_list_free(addr); 141 ldns_rr_list_free(zone_cuts); 142 143 return new_list; 144 145 memory_error: 146 if (new_list) { 147 ldns_rr_list_free(new_list); 148 } 149 if (zone_cuts) { 150 ldns_rr_list_free(zone_cuts); 151 } 152 if (addr) { 153 ldns_rr_list_free(addr); 154 } 155 return NULL; 156 } 157 158 /* 159 * Get the list of glue records in a zone 160 * XXX: there should be a way for this to return error, other than NULL, 161 * since NULL is a valid return 162 */ 163 ldns_rr_list * 164 ldns_zone_glue_rr_list(const ldns_zone *z) 165 { 166 /* when do we find glue? It means we find an IP address 167 * (AAAA/A) for a nameserver listed in the zone 168 * 169 * Alg used here: 170 * first find all the zonecuts (NS records) 171 * find all the AAAA or A records (can be done it the 172 * above loop). 173 * 174 * Check if the aaaa/a list are subdomains under the 175 * NS domains. 176 * If yes -> glue, if no -> not glue 177 */ 178 179 ldns_rr_list *zone_cuts; 180 ldns_rr_list *addr; 181 ldns_rr_list *glue; 182 ldns_rr *r, *ns, *a; 183 ldns_rdf *dname_a, *dname_ns, *ns_owner; 184 size_t i,j; 185 186 zone_cuts = NULL; 187 addr = NULL; 188 glue = NULL; 189 190 /* we cannot determine glue in a 'zone' without a SOA */ 191 if (!ldns_zone_soa(z)) { 192 return NULL; 193 } 194 195 zone_cuts = ldns_rr_list_new(); 196 if (!zone_cuts) goto memory_error; 197 addr = ldns_rr_list_new(); 198 if (!addr) goto memory_error; 199 glue = ldns_rr_list_new(); 200 if (!glue) goto memory_error; 201 202 for(i = 0; i < ldns_zone_rr_count(z); i++) { 203 r = ldns_rr_list_rr(ldns_zone_rrs(z), i); 204 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A || 205 ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) { 206 /* possibly glue */ 207 if (!ldns_rr_list_push_rr(addr, r)) goto memory_error; 208 continue; 209 } 210 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) { 211 /* multiple zones will end up here - 212 * for now; not a problem 213 */ 214 /* don't add NS records for the current zone itself */ 215 if (ldns_rdf_compare(ldns_rr_owner(r), 216 ldns_rr_owner(ldns_zone_soa(z))) != 0) { 217 if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error; 218 } 219 continue; 220 } 221 } 222 223 /* will sorting make it quicker ?? */ 224 for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) { 225 ns = ldns_rr_list_rr(zone_cuts, i); 226 ns_owner = ldns_rr_owner(ns); 227 228 dname_ns = ldns_rr_ns_nsdname(ns); 229 for(j = 0; j < ldns_rr_list_rr_count(addr); j++) { 230 a = ldns_rr_list_rr(addr, j); 231 dname_a = ldns_rr_owner(a); 232 233 if (ldns_dname_is_subdomain(dname_a, ns_owner)) { 234 /* GLUE! */ 235 if (!ldns_rr_list_push_rr(glue, a)) goto memory_error; 236 } 237 } 238 } 239 240 ldns_rr_list_free(addr); 241 ldns_rr_list_free(zone_cuts); 242 243 if (ldns_rr_list_rr_count(glue) == 0) { 244 ldns_rr_list_free(glue); 245 return NULL; 246 } else { 247 return glue; 248 } 249 250 memory_error: 251 if (zone_cuts) { 252 LDNS_FREE(zone_cuts); 253 } 254 if (addr) { 255 ldns_rr_list_free(addr); 256 } 257 if (glue) { 258 ldns_rr_list_free(glue); 259 } 260 return NULL; 261 } 262 263 ldns_zone * 264 ldns_zone_new(void) 265 { 266 ldns_zone *z; 267 268 z = LDNS_MALLOC(ldns_zone); 269 if (!z) { 270 return NULL; 271 } 272 273 z->_rrs = ldns_rr_list_new(); 274 if (!z->_rrs) { 275 LDNS_FREE(z); 276 return NULL; 277 } 278 ldns_zone_set_soa(z, NULL); 279 return z; 280 } 281 282 /* we regocnize: 283 * $TTL, $ORIGIN 284 */ 285 ldns_status 286 ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c) 287 { 288 return ldns_zone_new_frm_fp_l(z, fp, origin, ttl, c, NULL); 289 } 290 291 /* XXX: class is never used */ 292 ldns_status 293 ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, ldns_rdf *origin, uint32_t ttl, ldns_rr_class c, 294 int *line_nr) 295 { 296 ldns_zone *newzone; 297 ldns_rr *rr; 298 uint32_t my_ttl; 299 ldns_rr_class my_class; 300 ldns_rdf *my_origin; 301 ldns_rdf *my_prev; 302 bool soa_seen = false; /* 2 soa are an error */ 303 ldns_status s; 304 ldns_status ret; 305 306 /* most cases of error are memory problems */ 307 ret = LDNS_STATUS_MEM_ERR; 308 309 newzone = NULL; 310 my_origin = NULL; 311 my_prev = NULL; 312 313 my_ttl = ttl; 314 my_class = c; 315 316 if (origin) { 317 my_origin = ldns_rdf_clone(origin); 318 if (!my_origin) goto error; 319 /* also set the prev */ 320 my_prev = ldns_rdf_clone(origin); 321 if (!my_prev) goto error; 322 } 323 324 newzone = ldns_zone_new(); 325 if (!newzone) goto error; 326 327 while(!feof(fp)) { 328 s = ldns_rr_new_frm_fp_l(&rr, fp, &my_ttl, &my_origin, &my_prev, line_nr); 329 switch (s) { 330 case LDNS_STATUS_OK: 331 if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) { 332 if (soa_seen) { 333 /* second SOA 334 * just skip, maybe we want to say 335 * something??? */ 336 ldns_rr_free(rr); 337 continue; 338 } 339 soa_seen = true; 340 ldns_zone_set_soa(newzone, rr); 341 /* set origin to soa if not specified */ 342 if (!my_origin) { 343 my_origin = ldns_rdf_clone(ldns_rr_owner(rr)); 344 } 345 continue; 346 } 347 348 /* a normal RR - as sofar the DNS is normal */ 349 if (!ldns_zone_push_rr(newzone, rr)) goto error; 350 351 /*my_origin = ldns_rr_owner(rr);*/ 352 my_ttl = ldns_rr_ttl(rr); /* XXX: this seems like an error */ 353 my_class = ldns_rr_get_class(rr); 354 case LDNS_STATUS_SYNTAX_EMPTY: 355 /* empty line was seen */ 356 case LDNS_STATUS_SYNTAX_TTL: 357 /* the function set the ttl */ 358 break; 359 case LDNS_STATUS_SYNTAX_ORIGIN: 360 /* the function set the origin */ 361 break; 362 default: 363 ret = s; 364 goto error; 365 } 366 } 367 368 if (my_origin) { 369 ldns_rdf_deep_free(my_origin); 370 } 371 if (my_prev) { 372 ldns_rdf_deep_free(my_prev); 373 } 374 if (z) { 375 *z = newzone; 376 } else { 377 ldns_zone_free(newzone); 378 } 379 380 return LDNS_STATUS_OK; 381 382 error: 383 if (my_origin) { 384 ldns_rdf_deep_free(my_origin); 385 } 386 if (my_prev) { 387 ldns_rdf_deep_free(my_prev); 388 } 389 if (newzone) { 390 ldns_zone_free(newzone); 391 } 392 return ret; 393 } 394 395 void 396 ldns_zone_sort(ldns_zone *zone) 397 { 398 ldns_rr_list *zrr; 399 assert(zone != NULL); 400 401 zrr = ldns_zone_rrs(zone); 402 ldns_rr_list_sort(zrr); 403 } 404 405 #if 0 406 /** 407 * ixfr function. Work on a ldns_zone and remove and add 408 * the rrs from the rrlist 409 * \param[in] z the zone to work on 410 * \param[in] del rr_list to remove from the zone 411 * \param[in] add rr_list to add to the zone 412 * \return Tja, wat zouden we eens returnen TODO 413 */ 414 void 415 ldns_zone_ixfr_del_add(ldns_zone *z, ldns_rr_list *del, ldns_rr_list *add) 416 { 417 418 } 419 #endif 420 421 void 422 ldns_zone_free(ldns_zone *zone) 423 { 424 ldns_rr_list_free(zone->_rrs); 425 LDNS_FREE(zone); 426 } 427 428 void 429 ldns_zone_deep_free(ldns_zone *zone) 430 { 431 ldns_rr_free(zone->_soa); 432 ldns_rr_list_deep_free(zone->_rrs); 433 LDNS_FREE(zone); 434 } 435