contrib/ldns/zone.c

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