contrib/bind/lib/dns/rdatalist.c

   1 /*
   2  * Copyright (C) 2004, 2005, 2007, 2008, 2010  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and/or distribute this software for any
   6  * purpose with or without fee is hereby granted, provided that the above
   7  * copyright notice and this permission notice appear in all copies.
   8  *
   9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
  10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
  12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
  13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
  15  * PERFORMANCE OF THIS SOFTWARE.
  16  */
  17
  18 /* $Id: rdatalist.c,v 1.33.128.2.28.2 2010/02/25 10:56:01 tbox Exp $ */
  19
  20 /*! \file */
  21
  22 #include <config.h>
  23
  24 #include <stddef.h>
  25
  26 #include <isc/util.h>
  27
  28 #include <dns/name.h>
  29 #include <dns/rdata.h>
  30 #include <dns/rdatalist.h>
  31 #include <dns/rdataset.h>
  32
  33 #include "rdatalist_p.h"
  34
  35 static dns_rdatasetmethods_t methods = {
  36         isc__rdatalist_disassociate,
  37         isc__rdatalist_first,
  38         isc__rdatalist_next,
  39         isc__rdatalist_current,
  40         isc__rdatalist_clone,
  41         isc__rdatalist_count,
  42         isc__rdatalist_addnoqname,
  43         isc__rdatalist_getnoqname,
  44         NULL,
  45         NULL,
  46         NULL,
  47         NULL,
  48         NULL
  49 };
  50
  51 void
  52 dns_rdatalist_init(dns_rdatalist_t *rdatalist) {
  53
  54         /*
  55          * Initialize rdatalist.
  56          */
  57
  58         rdatalist->rdclass = 0;
  59         rdatalist->type = 0;
  60         rdatalist->covers = 0;
  61         rdatalist->ttl = 0;
  62         ISC_LIST_INIT(rdatalist->rdata);
  63         ISC_LINK_INIT(rdatalist, link);
  64 }
  65
  66 isc_result_t
  67 dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist,
  68                          dns_rdataset_t *rdataset) {
  69
  70         /*
  71          * Make 'rdataset' refer to the rdata in 'rdatalist'.
  72          */
  73
  74         REQUIRE(rdatalist != NULL);
  75         REQUIRE(DNS_RDATASET_VALID(rdataset));
  76         REQUIRE(! dns_rdataset_isassociated(rdataset));
  77
  78         rdataset->methods = &methods;
  79         rdataset->rdclass = rdatalist->rdclass;
  80         rdataset->type = rdatalist->type;
  81         rdataset->covers = rdatalist->covers;
  82         rdataset->ttl = rdatalist->ttl;
  83         rdataset->trust = 0;
  84         rdataset->private1 = rdatalist;
  85         rdataset->private2 = NULL;
  86         rdataset->private3 = NULL;
  87         rdataset->privateuint4 = 0;
  88         rdataset->private5 = NULL;
  89
  90         return (ISC_R_SUCCESS);
  91 }
  92
  93 isc_result_t
  94 dns_rdatalist_fromrdataset(dns_rdataset_t *rdataset,
  95                            dns_rdatalist_t **rdatalist)
  96 {
  97         REQUIRE(rdatalist != NULL && rdataset != NULL);
  98         *rdatalist = rdataset->private1;
  99
 100         return (ISC_R_SUCCESS);
 101 }
 102
 103 void
 104 isc__rdatalist_disassociate(dns_rdataset_t *rdataset) {
 105         UNUSED(rdataset);
 106 }
 107
 108 isc_result_t
 109 isc__rdatalist_first(dns_rdataset_t *rdataset) {
 110         dns_rdatalist_t *rdatalist;
 111
 112         rdatalist = rdataset->private1;
 113         rdataset->private2 = ISC_LIST_HEAD(rdatalist->rdata);
 114
 115         if (rdataset->private2 == NULL)
 116                 return (ISC_R_NOMORE);
 117
 118         return (ISC_R_SUCCESS);
 119 }
 120
 121 isc_result_t
 122 isc__rdatalist_next(dns_rdataset_t *rdataset) {
 123         dns_rdata_t *rdata;
 124
 125         rdata = rdataset->private2;
 126         if (rdata == NULL)
 127                 return (ISC_R_NOMORE);
 128
 129         rdataset->private2 = ISC_LIST_NEXT(rdata, link);
 130
 131         if (rdataset->private2 == NULL)
 132                 return (ISC_R_NOMORE);
 133
 134         return (ISC_R_SUCCESS);
 135 }
 136
 137 void
 138 isc__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 139         dns_rdata_t *list_rdata;
 140
 141         list_rdata = rdataset->private2;
 142         INSIST(list_rdata != NULL);
 143
 144         dns_rdata_clone(list_rdata, rdata);
 145 }
 146
 147 void
 148 isc__rdatalist_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 149         *target = *source;
 150
 151         /*
 152          * Reset iterator state.
 153          */
 154         target->private2 = NULL;
 155 }
 156
 157 unsigned int
 158 isc__rdatalist_count(dns_rdataset_t *rdataset) {
 159         dns_rdatalist_t *rdatalist;
 160         dns_rdata_t *rdata;
 161         unsigned int count;
 162
 163         rdatalist = rdataset->private1;
 164
 165         count = 0;
 166         for (rdata = ISC_LIST_HEAD(rdatalist->rdata);
 167              rdata != NULL;
 168              rdata = ISC_LIST_NEXT(rdata, link))
 169                 count++;
 170
 171         return (count);
 172 }
 173
 174 isc_result_t
 175 isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
 176         dns_rdataset_t *nsec = NULL;
 177         dns_rdataset_t *nsecsig = NULL;
 178         dns_rdataset_t *rdset;
 179         dns_ttl_t ttl;
 180
 181         for (rdset = ISC_LIST_HEAD(name->list);
 182              rdset != NULL;
 183              rdset = ISC_LIST_NEXT(rdset, link))
 184         {
 185                 if (rdset->rdclass != rdataset->rdclass)
 186                         continue;
 187                 if (rdset->type == dns_rdatatype_nsec)
 188                         nsec = rdset;
 189                 if (rdset->type == dns_rdatatype_rrsig &&
 190                     rdset->covers == dns_rdatatype_nsec)
 191                         nsecsig = rdset;
 192         }
 193
 194         if (nsec == NULL || nsecsig == NULL)
 195                 return (ISC_R_NOTFOUND);
 196         /*
 197          * Minimise ttl.
 198          */
 199         ttl = rdataset->ttl;
 200         if (nsec->ttl < ttl)
 201                 ttl = nsec->ttl;
 202         if (nsecsig->ttl < ttl)
 203                 ttl = nsecsig->ttl;
 204         rdataset->ttl = nsec->ttl = nsecsig->ttl = ttl;
 205         rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
 206         rdataset->private6 = name;
 207         return (ISC_R_SUCCESS);
 208 }
 209
 210 isc_result_t
 211 isc__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 212                          dns_rdataset_t *nsec, dns_rdataset_t *nsecsig)
 213 {
 214         dns_rdataclass_t rdclass = rdataset->rdclass;
 215         dns_rdataset_t *tnsec = NULL;
 216         dns_rdataset_t *tnsecsig = NULL;
 217         dns_name_t *noqname = rdataset->private6;
 218
 219         REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
 220         (void)dns_name_dynamic(noqname);        /* Sanity Check. */
 221
 222         for (rdataset = ISC_LIST_HEAD(noqname->list);
 223              rdataset != NULL;
 224              rdataset = ISC_LIST_NEXT(rdataset, link))
 225         {
 226                 if (rdataset->rdclass != rdclass)
 227                         continue;
 228                 if (rdataset->type == dns_rdatatype_nsec)
 229                         tnsec = rdataset;
 230                 if (rdataset->type == dns_rdatatype_rrsig &&
 231                     rdataset->covers == dns_rdatatype_nsec)
 232                         tnsecsig = rdataset;
 233         }
 234         if (tnsec == NULL || tnsecsig == NULL)
 235                 return (ISC_R_NOTFOUND);
 236
 237         dns_name_clone(noqname, name);
 238         dns_rdataset_clone(tnsec, nsec);
 239         dns_rdataset_clone(tnsecsig, nsecsig);
 240         return (ISC_R_SUCCESS);
 241 }