diff --git a/lib/dns/include/dns/rdataslab.h b/lib/dns/include/dns/rdataslab.h index 421c7df8aa..a2e33ad998 100644 --- a/lib/dns/include/dns/rdataslab.h +++ b/lib/dns/include/dns/rdataslab.h @@ -237,29 +237,6 @@ dns_rdataslab_count(dns_slabheader_t *header); *\li The number of records in the slab. */ -isc_result_t -dns_rdataslab_merge(dns_slabheader_t *oheader, dns_slabheader_t *nheader, - isc_mem_t *mctx, dns_rdataclass_t rdclass, - dns_rdatatype_t type, unsigned int flags, - uint32_t maxrrperset, dns_slabheader_t **theaderp); -/*%< - * Merge the slabs following 'oheader' and 'nheader'. - */ - -isc_result_t -dns_rdataslab_subtract(dns_slabheader_t *mheader, dns_slabheader_t *sheader, - isc_mem_t *mctx, dns_rdataclass_t rdclass, - dns_rdatatype_t type, unsigned int flags, - dns_slabheader_t **theaderp); -/*%< - * Subtract the slab following 'sheader' from the one following 'mheader'. - * If 'exact' is true then all elements from the 'sheader' slab must exist - * in the 'mheader' slab. - * - * XXX - * valid flags are DNS_RDATASLAB_EXACT - */ - bool dns_rdataslab_equal(dns_slabheader_t *header1, dns_slabheader_t *header2); /*%< @@ -285,18 +262,6 @@ dns_rdataslab_equalx(dns_slabheader_t *header1, dns_slabheader_t *header2, *\li true if the slabs are equal, #false otherwise. */ -void -dns_slabheader_setownercase(dns_slabheader_t *header, const dns_name_t *name); -/*%< - * Store the casing of 'name', into a bitfield in 'header'. - */ - -void -dns_slabheader_copycase(dns_slabheader_t *dest, dns_slabheader_t *src); -/*%< - * Copy the casing of 'src', into 'dest'. - */ - void dns_slabheader_reset(dns_slabheader_t *h, dns_dbnode_t *node); /*%< diff --git a/lib/dns/rdataslab.c b/lib/dns/rdataslab.c index ba56690669..6850fd1fb7 100644 --- a/lib/dns/rdataslab.c +++ b/lib/dns/rdataslab.c @@ -13,7 +13,6 @@ /*! \file */ -#include #include #include @@ -399,336 +398,6 @@ rdata_from_slabitem(unsigned char **current, dns_rdataclass_t rdclass, *current = tcurrent; } -static void -rdata_to_slabitem(unsigned char **current, dns_rdatatype_t type, - dns_rdata_t *rdata) { - unsigned int length = rdata->length; - unsigned char *data = rdata->data; - unsigned char *p = *current; - - if (type == dns_rdatatype_rrsig) { - length++; - data--; - } - - put_uint16(p, length); - memmove(p, data, length); - p += length; - - *current = p; -} - -typedef struct slabinfo { - unsigned char *pos; - dns_rdata_t rdata; - bool dup; -} slabinfo_t; - -isc_result_t -dns_rdataslab_merge(dns_slabheader_t *oheader, dns_slabheader_t *nheader, - isc_mem_t *mctx, dns_rdataclass_t rdclass, - dns_rdatatype_t type, unsigned int flags, - uint32_t maxrrperset, dns_slabheader_t **theaderp) { - isc_result_t result = ISC_R_SUCCESS; - unsigned char *ocurrent = NULL, *ncurrent = NULL, *tcurrent = NULL; - unsigned int ocount, ncount, tlength, tcount = 0; - slabinfo_t *oinfo = NULL, *ninfo = NULL; - size_t o = 0, n = 0; - - REQUIRE(theaderp != NULL && *theaderp == NULL); - REQUIRE(oheader != NULL && nheader != NULL); - - ocurrent = (unsigned char *)oheader + sizeof(dns_slabheader_t); - ocount = get_uint16(ocurrent); - - ncurrent = (unsigned char *)nheader + sizeof(dns_slabheader_t); - ncount = get_uint16(ncurrent); - - INSIST(ocount > 0 && ncount > 0); - - if (maxrrperset > 0 && ocount + ncount > maxrrperset) { - return DNS_R_TOOMANYRECORDS; - } - - /* - * Figure out the target length. Start with the header, - * plus 2 octets for the count. - */ - tlength = sizeof(dns_slabheader_t) + 2; - - /* - * Gather the rdatas in the old slab and add their lengths to - * the larget length. - */ - oinfo = isc_mem_cget(mctx, ocount, sizeof(struct slabinfo)); - for (size_t i = 0; i < ocount; i++) { - oinfo[i].pos = ocurrent; - dns_rdata_init(&oinfo[i].rdata); - rdata_from_slabitem(&ocurrent, rdclass, type, &oinfo[i].rdata); - tlength += ocurrent - oinfo[i].pos; - } - - /* - * Then add the length of rdatas in the new slab that aren't - * duplicated in the old slab. - */ - ninfo = isc_mem_cget(mctx, ncount, sizeof(struct slabinfo)); - for (size_t i = 0; i < ncount; i++) { - ninfo[i].pos = ncurrent; - dns_rdata_init(&ninfo[i].rdata); - rdata_from_slabitem(&ncurrent, rdclass, type, &ninfo[i].rdata); - - for (size_t j = 0; j < ocount; j++) { - if (oinfo[j].dup) { - /* - * This was already found to be - * duplicated; no need to compare - * it again. - */ - continue; - } - - if (dns_rdata_compare(&oinfo[j].rdata, - &ninfo[i].rdata) == 0) - { - /* - * Found a dup. Mark the old copy as a - * duplicate so we don't check it again; - * mark the new copy as a duplicate so we - * don't copy it to the target. - */ - oinfo[j].dup = ninfo[i].dup = true; - break; - } - } - - if (ninfo[i].dup) { - continue; - } - - /* - * We will be copying this item to the target, so - * add its length to tlength and increment tcount. - */ - tlength += ncurrent - ninfo[i].pos; - tcount++; - } - - /* - * If the EXACT flag is set, there can't be any rdata in - * the new slab that was also in the old. If tcount is less - * than ncount, then we found such a duplicate. - */ - if (((flags & DNS_RDATASLAB_EXACT) != 0) && (tcount < ncount)) { - CLEANUP(DNS_R_NOTEXACT); - } - - /* - * If nothing's being copied in from the new slab, and the - * FORCE flag isn't set, we're done. - */ - if (tcount == 0 && (flags & DNS_RDATASLAB_FORCE) == 0) { - CLEANUP(DNS_R_UNCHANGED); - } - - /* Add to tcount the total number of items from the old slab. */ - tcount += ocount; - - /* Resposition ncurrent at the first item. */ - ncurrent = (unsigned char *)nheader + sizeof(dns_slabheader_t) + 2; - - /* Single types can't have more than one RR. */ - if (tcount > 1 && dns_rdatatype_issingleton(type)) { - CLEANUP(DNS_R_SINGLETON); - } - - if (tcount > 0xffff) { - CLEANUP(ISC_R_NOSPACE); - } - - /* Allocate the target buffer and copy the new slab's header */ - unsigned char *tstart = isc_mem_get(mctx, tlength); - - memmove(tstart, nheader, sizeof(dns_slabheader_t)); - tcurrent = tstart + sizeof(dns_slabheader_t); - - /* Write the new count, then start merging the slabs. */ - put_uint16(tcurrent, tcount); - - /* - * Now walk the sets together, adding each item in DNSSEC order, - * and skipping over any more dups in the new slab. - */ - while (o < ocount || n < ncount) { - bool fromold; - - /* Skip to the next non-duplicate in the new slab. */ - for (; n < ncount && ninfo[n].dup; n++) - ; - - if (o == ocount) { - fromold = false; - } else if (n == ncount) { - fromold = true; - } else { - fromold = dns_rdata_compare(&oinfo[o].rdata, - &ninfo[n].rdata) < 0; - } - - if (fromold) { - rdata_to_slabitem(&tcurrent, type, &oinfo[o].rdata); - if (++o < ocount) { - /* Skip to the next rdata in the old slab */ - continue; - } - } else { - rdata_to_slabitem(&tcurrent, type, &ninfo[n++].rdata); - } - } - - INSIST(tcurrent == tstart + tlength); - - *theaderp = (dns_slabheader_t *)tstart; - -cleanup: - isc_mem_cput(mctx, oinfo, ocount, sizeof(struct slabinfo)); - isc_mem_cput(mctx, ninfo, ncount, sizeof(struct slabinfo)); - - return result; -} - -isc_result_t -dns_rdataslab_subtract(dns_slabheader_t *oheader, dns_slabheader_t *sheader, - isc_mem_t *mctx, dns_rdataclass_t rdclass, - dns_rdatatype_t type, unsigned int flags, - dns_slabheader_t **theaderp) { - isc_result_t result = ISC_R_SUCCESS; - unsigned char *ocurrent = NULL, *scurrent = NULL; - unsigned char *tstart = NULL, *tcurrent = NULL; - unsigned int ocount, scount, tlength; - unsigned int tcount = 0, rcount = 0; - slabinfo_t *oinfo = NULL, *sinfo = NULL; - - REQUIRE(theaderp != NULL && *theaderp == NULL); - REQUIRE(oheader != NULL && sheader != NULL); - - ocurrent = (unsigned char *)oheader + sizeof(dns_slabheader_t); - ocount = get_uint16(ocurrent); - - scurrent = (unsigned char *)sheader + sizeof(dns_slabheader_t); - scount = get_uint16(scurrent); - - INSIST(ocount > 0 && scount > 0); - - /* Get info about the rdatas being subtracted */ - sinfo = isc_mem_cget(mctx, scount, sizeof(struct slabinfo)); - for (size_t i = 0; i < scount; i++) { - sinfo[i].pos = scurrent; - dns_rdata_init(&sinfo[i].rdata); - rdata_from_slabitem(&scurrent, rdclass, type, &sinfo[i].rdata); - } - - /* - * Figure out the target length. Start with the header, - * plus 2 octets for the count. - */ - tlength = sizeof(dns_slabheader_t) + 2; - - /* - * Add the length of the rdatas in the old slab that - * aren't being subtracted. - */ - oinfo = isc_mem_cget(mctx, ocount, sizeof(struct slabinfo)); - for (size_t i = 0; i < ocount; i++) { - bool matched = false; - - oinfo[i].pos = ocurrent; - dns_rdata_init(&oinfo[i].rdata); - rdata_from_slabitem(&ocurrent, rdclass, type, &oinfo[i].rdata); - - for (size_t j = 0; j < scount; j++) { - if (sinfo[j].dup) { - continue; - } else if (dns_rdata_compare(&oinfo[i].rdata, - &sinfo[j].rdata) == 0) - { - matched = true; - oinfo[i].dup = sinfo[j].dup = true; - break; - } - } - - if (matched) { - /* This item will be subtracted. */ - rcount++; - } else { - /* - * This rdata wasn't in the slab to be subtracted, - * so copy it to the target. Add its length to - * tlength and increment tcount. - */ - tlength += ocurrent - oinfo[i].pos; - tcount++; - } - } - - /* - * If the EXACT flag wasn't set, check that all the records that - * were to be subtracted actually did exist in the original slab. - * (The numeric check works here because rdataslabs do not contain - * duplicates.) - */ - if ((flags & DNS_RDATASLAB_EXACT) != 0 && rcount != scount) { - CLEANUP(DNS_R_NOTEXACT); - } - - /* - * If the resulting rdataslab would be empty, don't bother to - * create a new buffer, just return. - */ - if (tcount == 0) { - CLEANUP(DNS_R_NXRRSET); - } - - /* - * If nothing is going to change, stop. - */ - if (rcount == 0) { - CLEANUP(DNS_R_UNCHANGED); - } - - /* - * Allocate the target buffer and copy the old slab's header. - */ - tstart = isc_mem_get(mctx, tlength); - memmove(tstart, oheader, sizeof(dns_slabheader_t)); - tcurrent = tstart + sizeof(dns_slabheader_t); - - /* - * Write the new count. - */ - put_uint16(tcurrent, tcount); - - /* - * Copy the parts of the old slab that didn't have duplicates. - */ - for (size_t i = 0; i < ocount; i++) { - if (!oinfo[i].dup) { - rdata_to_slabitem(&tcurrent, type, &oinfo[i].rdata); - } - } - - INSIST(tcurrent == tstart + tlength); - - *theaderp = (dns_slabheader_t *)tstart; - -cleanup: - isc_mem_cput(mctx, oinfo, ocount, sizeof(struct slabinfo)); - isc_mem_cput(mctx, sinfo, scount, sizeof(struct slabinfo)); - - return result; -} - bool dns_rdataslab_equal(dns_slabheader_t *slab1, dns_slabheader_t *slab2) { unsigned char *current1 = NULL, *current2 = NULL; @@ -793,43 +462,6 @@ dns_rdataslab_equalx(dns_slabheader_t *slab1, dns_slabheader_t *slab2, return true; } -void -dns_slabheader_setownercase(dns_slabheader_t *header, const dns_name_t *name) { - REQUIRE(!CASESET(header)); - - bool casefullylower = true; - - /* - * We do not need to worry about label lengths as they are all - * less than or equal to 63. - */ - memset(header->upper, 0, sizeof(header->upper)); - for (size_t i = 0; i < name->length; i++) { - if (isupper(name->ndata[i])) { - header->upper[i / 8] |= 1 << (i % 8); - casefullylower = false; - } - } - if (casefullylower) { - DNS_SLABHEADER_SETATTR(header, - DNS_SLABHEADERATTR_CASEFULLYLOWER); - } - DNS_SLABHEADER_SETATTR(header, DNS_SLABHEADERATTR_CASESET); -} - -void -dns_slabheader_copycase(dns_slabheader_t *dest, dns_slabheader_t *src) { - REQUIRE(!CASESET(dest)); - if (CASESET(src)) { - memmove(dest->upper, src->upper, sizeof(src->upper)); - if (CASEFULLYLOWER(src)) { - DNS_SLABHEADER_SETATTR( - dest, DNS_SLABHEADERATTR_CASEFULLYLOWER); - } - DNS_SLABHEADER_SETATTR(dest, DNS_SLABHEADERATTR_CASESET); - } -} - void dns_slabheader_reset(dns_slabheader_t *h, dns_dbnode_t *node) { h->heap_index = 0;