contrib/bind-9.3/lib/dns/rdatalist.c

   1 /*
   2  * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and 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.25.2.2.2.2 2004/03/08 02:07:56 marka Exp $ */
  19
  20 #include <config.h>
  21
  22 #include <stddef.h>
  23
  24 #include <isc/util.h>
  25
  26 #include <dns/name.h>
  27 #include <dns/rdata.h>
  28 #include <dns/rdatalist.h>
  29 #include <dns/rdataset.h>
  30
  31 #include "rdatalist_p.h"
  32
  33 static dns_rdatasetmethods_t methods = {
  34         isc__rdatalist_disassociate,
  35         isc__rdatalist_first,
  36         isc__rdatalist_next,
  37         isc__rdatalist_current,
  38         isc__rdatalist_clone,
  39         isc__rdatalist_count,
  40         isc__rdatalist_addnoqname,
  41         isc__rdatalist_getnoqname
  42 };
  43
  44 void
  45 dns_rdatalist_init(dns_rdatalist_t *rdatalist) {
  46
  47         /*
  48          * Initialize rdatalist.
  49          */
  50
  51         rdatalist->rdclass = 0;
  52         rdatalist->type = 0;
  53         rdatalist->covers = 0;
  54         rdatalist->ttl = 0;
  55         ISC_LIST_INIT(rdatalist->rdata);
  56         ISC_LINK_INIT(rdatalist, link);
  57 }
  58
  59 isc_result_t
  60 dns_rdatalist_tordataset(dns_rdatalist_t *rdatalist,
  61                          dns_rdataset_t *rdataset) {
  62
  63         /*
  64          * Make 'rdataset' refer to the rdata in 'rdatalist'.
  65          */
  66
  67         REQUIRE(rdatalist != NULL);
  68         REQUIRE(DNS_RDATASET_VALID(rdataset));
  69         REQUIRE(! dns_rdataset_isassociated(rdataset));
  70
  71         rdataset->methods = &methods;
  72         rdataset->rdclass = rdatalist->rdclass;
  73         rdataset->type = rdatalist->type;
  74         rdataset->covers = rdatalist->covers;
  75         rdataset->ttl = rdatalist->ttl;
  76         rdataset->trust = 0;
  77         rdataset->private1 = rdatalist;
  78         rdataset->private2 = NULL;
  79         rdataset->private3 = NULL;
  80         rdataset->privateuint4 = 0;
  81         rdataset->private5 = NULL;
  82
  83         return (ISC_R_SUCCESS);
  84 }
  85
  86 void
  87 isc__rdatalist_disassociate(dns_rdataset_t *rdataset) {
  88         UNUSED(rdataset);
  89 }
  90
  91 isc_result_t
  92 isc__rdatalist_first(dns_rdataset_t *rdataset) {
  93         dns_rdatalist_t *rdatalist;
  94
  95         rdatalist = rdataset->private1;
  96         rdataset->private2 = ISC_LIST_HEAD(rdatalist->rdata);
  97
  98         if (rdataset->private2 == NULL)
  99                 return (ISC_R_NOMORE);
 100
 101         return (ISC_R_SUCCESS);
 102 }
 103
 104 isc_result_t
 105 isc__rdatalist_next(dns_rdataset_t *rdataset) {
 106         dns_rdata_t *rdata;
 107
 108         rdata = rdataset->private2;
 109         if (rdata == NULL)
 110                 return (ISC_R_NOMORE);
 111
 112         rdataset->private2 = ISC_LIST_NEXT(rdata, link);
 113
 114         if (rdataset->private2 == NULL)
 115                 return (ISC_R_NOMORE);
 116
 117         return (ISC_R_SUCCESS);
 118 }
 119
 120 void
 121 isc__rdatalist_current(dns_rdataset_t *rdataset, dns_rdata_t *rdata) {
 122         dns_rdata_t *list_rdata;
 123
 124         list_rdata = rdataset->private2;
 125         INSIST(list_rdata != NULL);
 126
 127         dns_rdata_clone(list_rdata, rdata);
 128 }
 129
 130 void
 131 isc__rdatalist_clone(dns_rdataset_t *source, dns_rdataset_t *target) {
 132         *target = *source;
 133
 134         /*
 135          * Reset iterator state.
 136          */
 137         target->private2 = NULL;
 138 }
 139
 140 unsigned int
 141 isc__rdatalist_count(dns_rdataset_t *rdataset) {
 142         dns_rdatalist_t *rdatalist;
 143         dns_rdata_t *rdata;
 144         unsigned int count;
 145
 146         rdatalist = rdataset->private1;
 147
 148         count = 0;
 149         for (rdata = ISC_LIST_HEAD(rdatalist->rdata);
 150              rdata != NULL;
 151              rdata = ISC_LIST_NEXT(rdata, link))
 152                 count++;
 153
 154         return (count);
 155 }
 156
 157 isc_result_t
 158 isc__rdatalist_addnoqname(dns_rdataset_t *rdataset, dns_name_t *name) {
 159         dns_rdataset_t *nsec = NULL;
 160         dns_rdataset_t *nsecsig = NULL;
 161         dns_rdataset_t *rdset;
 162         dns_ttl_t ttl;
 163
 164         for (rdset = ISC_LIST_HEAD(name->list);
 165              rdset != NULL;
 166              rdset = ISC_LIST_NEXT(rdset, link))
 167         {
 168                 if (rdset->rdclass != rdataset->rdclass)
 169                         continue;
 170                 if (rdset->type == dns_rdatatype_nsec)
 171                         nsec = rdset;
 172                 if (rdset->type == dns_rdatatype_rrsig &&
 173                     rdset->covers == dns_rdatatype_nsec)
 174                         nsecsig = rdset;
 175         }
 176
 177         if (nsec == NULL || nsecsig == NULL)
 178                 return (ISC_R_NOTFOUND);
 179         /*
 180          * Minimise ttl.
 181          */
 182         ttl = rdataset->ttl;
 183         if (nsec->ttl < ttl)
 184                 ttl = nsec->ttl;
 185         if (nsecsig->ttl < ttl)
 186                 ttl = nsecsig->ttl;
 187         rdataset->ttl = nsec->ttl = nsecsig->ttl = ttl;
 188         rdataset->attributes |= DNS_RDATASETATTR_NOQNAME;
 189         rdataset->private6 = name;
 190         return (ISC_R_SUCCESS);
 191 }
 192
 193 isc_result_t
 194 isc__rdatalist_getnoqname(dns_rdataset_t *rdataset, dns_name_t *name,
 195                          dns_rdataset_t *nsec, dns_rdataset_t *nsecsig)
 196 {
 197         dns_rdataclass_t rdclass = rdataset->rdclass;
 198         dns_rdataset_t *tnsec = NULL;
 199         dns_rdataset_t *tnsecsig = NULL;
 200         dns_name_t *noqname = rdataset->private6;
 201
 202         REQUIRE((rdataset->attributes & DNS_RDATASETATTR_NOQNAME) != 0);
 203         (void)dns_name_dynamic(noqname);        /* Sanity Check. */
 204
 205         for (rdataset = ISC_LIST_HEAD(noqname->list);
 206              rdataset != NULL;
 207              rdataset = ISC_LIST_NEXT(rdataset, link))
 208         {
 209                 if (rdataset->rdclass != rdclass)
 210                         continue;
 211                 if (rdataset->type == dns_rdatatype_nsec)
 212                         tnsec = rdataset;
 213                 if (rdataset->type == dns_rdatatype_rrsig &&
 214                     rdataset->covers == dns_rdatatype_nsec)
 215                         tnsecsig = rdataset;
 216         }
 217         if (tnsec == NULL || tnsecsig == NULL)
 218                 return (ISC_R_NOTFOUND);
 219
 220         dns_name_clone(noqname, name);
 221         dns_rdataset_clone(tnsec, nsec);
 222         dns_rdataset_clone(tnsecsig, nsecsig);
 223         return (ISC_R_SUCCESS);
 224 }