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 #include <ldns/internal.h> 13 14 #include <strings.h> 15 #include <limits.h> 16 17 ldns_rr * 18 ldns_zone_soa(const ldns_zone *z) 19 { 20 return z->_soa; 21 } 22 23 size_t 24 ldns_zone_rr_count(const ldns_zone *z) 25 { 26 return ldns_rr_list_rr_count(z->_rrs); 27 } 28 29 void 30 ldns_zone_set_soa(ldns_zone *z, ldns_rr *soa) 31 { 32 z->_soa = soa; 33 } 34 35 ldns_rr_list * 36 ldns_zone_rrs(const ldns_zone *z) 37 { 38 return z->_rrs; 39 } 40 41 void 42 ldns_zone_set_rrs(ldns_zone *z, ldns_rr_list *rrlist) 43 { 44 z->_rrs = rrlist; 45 } 46 47 bool 48 ldns_zone_push_rr_list(ldns_zone *z, const ldns_rr_list *list) 49 { 50 return ldns_rr_list_cat(ldns_zone_rrs(z), list); 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 60 /* 61 * Get the list of glue records in a zone 62 * XXX: there should be a way for this to return error, other than NULL, 63 * since NULL is a valid return 64 */ 65 ldns_rr_list * 66 ldns_zone_glue_rr_list(const ldns_zone *z) 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_list *glue; 84 ldns_rr *r, *ns, *a; 85 ldns_rdf *dname_a, *ns_owner; 86 size_t i,j; 87 88 zone_cuts = NULL; 89 addr = NULL; 90 glue = NULL; 91 92 /* we cannot determine glue in a 'zone' without a SOA */ 93 if (!ldns_zone_soa(z)) { 94 return NULL; 95 } 96 97 zone_cuts = ldns_rr_list_new(); 98 if (!zone_cuts) goto memory_error; 99 addr = ldns_rr_list_new(); 100 if (!addr) goto memory_error; 101 glue = ldns_rr_list_new(); 102 if (!glue) goto memory_error; 103 104 for(i = 0; i < ldns_zone_rr_count(z); i++) { 105 r = ldns_rr_list_rr(ldns_zone_rrs(z), i); 106 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_A || 107 ldns_rr_get_type(r) == LDNS_RR_TYPE_AAAA) { 108 /* possibly glue */ 109 if (!ldns_rr_list_push_rr(addr, r)) goto memory_error; 110 continue; 111 } 112 if (ldns_rr_get_type(r) == LDNS_RR_TYPE_NS) { 113 /* multiple zones will end up here - 114 * for now; not a problem 115 */ 116 /* don't add NS records for the current zone itself */ 117 if (ldns_rdf_compare(ldns_rr_owner(r), 118 ldns_rr_owner(ldns_zone_soa(z))) != 0) { 119 if (!ldns_rr_list_push_rr(zone_cuts, r)) goto memory_error; 120 } 121 continue; 122 } 123 } 124 125 /* will sorting make it quicker ?? */ 126 for(i = 0; i < ldns_rr_list_rr_count(zone_cuts); i++) { 127 ns = ldns_rr_list_rr(zone_cuts, i); 128 ns_owner = ldns_rr_owner(ns); 129 130 for(j = 0; j < ldns_rr_list_rr_count(addr); j++) { 131 a = ldns_rr_list_rr(addr, j); 132 dname_a = ldns_rr_owner(a); 133 134 if (ldns_dname_is_subdomain(dname_a, ns_owner) || 135 ldns_dname_compare(dname_a, ns_owner) == 0) { 136 /* GLUE! */ 137 if (!ldns_rr_list_push_rr(glue, a)) goto memory_error; 138 } 139 } 140 } 141 142 ldns_rr_list_free(addr); 143 ldns_rr_list_free(zone_cuts); 144 145 if (ldns_rr_list_rr_count(glue) == 0) { 146 ldns_rr_list_free(glue); 147 return NULL; 148 } else { 149 return glue; 150 } 151 152 memory_error: 153 if (zone_cuts) { 154 LDNS_FREE(zone_cuts); 155 } 156 if (addr) { 157 ldns_rr_list_free(addr); 158 } 159 if (glue) { 160 ldns_rr_list_free(glue); 161 } 162 return NULL; 163 } 164 165 ldns_zone * 166 ldns_zone_new(void) 167 { 168 ldns_zone *z; 169 170 z = LDNS_MALLOC(ldns_zone); 171 if (!z) { 172 return NULL; 173 } 174 175 z->_rrs = ldns_rr_list_new(); 176 if (!z->_rrs) { 177 LDNS_FREE(z); 178 return NULL; 179 } 180 ldns_zone_set_soa(z, NULL); 181 return z; 182 } 183 184 /* we recognize: 185 * $TTL, $ORIGIN 186 */ 187 ldns_status 188 ldns_zone_new_frm_fp(ldns_zone **z, FILE *fp, const ldns_rdf *origin, uint32_t ttl, ldns_rr_class c) 189 { 190 return ldns_zone_new_frm_fp_l(z, fp, origin, ttl, c, NULL); 191 } 192 193 /* XXX: class is never used */ 194 ldns_status 195 ldns_zone_new_frm_fp_l(ldns_zone **z, FILE *fp, const ldns_rdf *origin, 196 uint32_t default_ttl, ldns_rr_class ATTR_UNUSED(c), int *line_nr) 197 { 198 ldns_zone *newzone; 199 ldns_rr *rr, *prev_rr = NULL; 200 uint32_t my_ttl; 201 ldns_rdf *my_origin; 202 ldns_rdf *my_prev; 203 bool soa_seen = false; /* 2 soa are an error */ 204 ldns_status s; 205 ldns_status ret; 206 /* RFC 1035 Section 5.1, says 'Omitted class and TTL values are default 207 * to the last explicitly stated values.' 208 */ 209 bool ttl_from_TTL = false; 210 bool explicit_ttl = false; 211 212 /* most cases of error are memory problems */ 213 ret = LDNS_STATUS_MEM_ERR; 214 215 newzone = NULL; 216 my_origin = NULL; 217 my_prev = NULL; 218 219 my_ttl = default_ttl; 220 221 if (origin) { 222 my_origin = ldns_rdf_clone(origin); 223 if (!my_origin) goto error; 224 /* also set the prev */ 225 my_prev = ldns_rdf_clone(origin); 226 if (!my_prev) goto error; 227 } 228 229 newzone = ldns_zone_new(); 230 if (!newzone) goto error; 231 232 while(!feof(fp)) { 233 /* If ttl came from $TTL line, then it should be the default. 234 * (RFC 2308 Section 4) 235 * Otherwise it "defaults to the last explicitly stated value" 236 * (RFC 1035 Section 5.1) 237 */ 238 if (ttl_from_TTL) 239 my_ttl = default_ttl; 240 s = _ldns_rr_new_frm_fp_l_internal(&rr, fp, &my_ttl, &my_origin, 241 &my_prev, line_nr, &explicit_ttl); 242 switch (s) { 243 case LDNS_STATUS_OK: 244 if (explicit_ttl) { 245 if (!ttl_from_TTL) { 246 /* No $TTL, so ttl "defaults to the 247 * last explicitly stated value" 248 * (RFC 1035 Section 5.1) 249 */ 250 my_ttl = ldns_rr_ttl(rr); 251 } 252 /* When ttl is implicit, try to adhere to the rules as 253 * much as possible. (also for compatibility with bind) 254 * This was changed when fixing an issue with ZONEMD 255 * which hashes the TTL too. 256 */ 257 } else if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SIG 258 || ldns_rr_get_type(rr) == LDNS_RR_TYPE_RRSIG) { 259 if (ldns_rr_rd_count(rr) >= 4 260 && ldns_rdf_get_type(ldns_rr_rdf(rr, 3)) == LDNS_RDF_TYPE_INT32) 261 262 /* SIG without explicit ttl get ttl 263 * from the original_ttl field 264 * (RFC 2535 Section 7.2) 265 * 266 * Similarly for RRSIG, but stated less 267 * specifically in the spec. 268 * (RFC 4034 Section 3) 269 */ 270 ldns_rr_set_ttl(rr, 271 ldns_rdf2native_int32( 272 ldns_rr_rdf(rr, 3))); 273 274 } else if (prev_rr 275 && ldns_rr_get_type(prev_rr) == ldns_rr_get_type(rr) 276 && ldns_dname_compare( ldns_rr_owner(prev_rr) 277 , ldns_rr_owner(rr)) == 0) 278 279 /* "TTLs of all RRs in an RRSet must be the same" 280 * (RFC 2881 Section 5.2) 281 */ 282 ldns_rr_set_ttl(rr, ldns_rr_ttl(prev_rr)); 283 284 prev_rr = rr; 285 if (ldns_rr_get_type(rr) == LDNS_RR_TYPE_SOA) { 286 if (soa_seen) { 287 /* second SOA 288 * just skip, maybe we want to say 289 * something??? */ 290 ldns_rr_free(rr); 291 continue; 292 } 293 soa_seen = true; 294 ldns_zone_set_soa(newzone, rr); 295 /* set origin to soa if not specified */ 296 if (!my_origin) { 297 my_origin = ldns_rdf_clone(ldns_rr_owner(rr)); 298 } 299 continue; 300 } 301 302 /* a normal RR - as sofar the DNS is normal */ 303 if (!ldns_zone_push_rr(newzone, rr)) { 304 ldns_rr_free(rr); 305 goto error; 306 } 307 break; 308 309 case LDNS_STATUS_SYNTAX_EMPTY: 310 /* empty line was seen */ 311 case LDNS_STATUS_SYNTAX_TTL: 312 /* the function set the ttl */ 313 default_ttl = my_ttl; 314 ttl_from_TTL = true; 315 break; 316 case LDNS_STATUS_SYNTAX_ORIGIN: 317 /* the function set the origin */ 318 break; 319 case LDNS_STATUS_SYNTAX_INCLUDE: 320 ret = LDNS_STATUS_SYNTAX_INCLUDE_ERR_NOTIMPL; 321 goto error; 322 default: 323 ret = s; 324 goto error; 325 } 326 } 327 328 if (my_origin) { 329 ldns_rdf_deep_free(my_origin); 330 } 331 if (my_prev) { 332 ldns_rdf_deep_free(my_prev); 333 } 334 if (z) { 335 *z = newzone; 336 } else { 337 ldns_zone_free(newzone); 338 } 339 340 return LDNS_STATUS_OK; 341 342 error: 343 if (my_origin) { 344 ldns_rdf_deep_free(my_origin); 345 } 346 if (my_prev) { 347 ldns_rdf_deep_free(my_prev); 348 } 349 if (newzone) { 350 ldns_zone_free(newzone); 351 } 352 return ret; 353 } 354 355 void 356 ldns_zone_sort(ldns_zone *zone) 357 { 358 ldns_rr_list *zrr; 359 assert(zone != NULL); 360 361 zrr = ldns_zone_rrs(zone); 362 ldns_rr_list_sort(zrr); 363 } 364 365 void 366 ldns_zone_free(ldns_zone *zone) 367 { 368 ldns_rr_list_free(zone->_rrs); 369 LDNS_FREE(zone); 370 } 371 372 void 373 ldns_zone_deep_free(ldns_zone *zone) 374 { 375 ldns_rr_free(zone->_soa); 376 ldns_rr_list_deep_free(zone->_rrs); 377 LDNS_FREE(zone); 378 } 379