contrib/bind9/lib/dns/rdatalist.c

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