mirror of
https://github.com/isc-projects/bind9.git
synced 2026-06-10 01:21:00 -04:00
Remove dns_rdataslab_merge() and friends
After the split to dns_rdataslab and dns_rdatavec, the dns_rdataslab_merge() function was unused and it suffered from the same data race as fixed in the previous commit. Instead of fixing it, just remove the function and bunch of other unused functions from the dns_rdataslab unit.
This commit is contained in:
Ondřej Surý
parent
8085b1bc23
commit
3a4ad1fd12
2 changed files with 0 additions and 403 deletions
|
|
@ -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);
|
||||
/*%<
|
||||
|
|
|
|||
|
|
@ -13,7 +13,6 @@
|
|||
|
||||
/*! \file */
|
||||
|
||||
#include <ctype.h>
|
||||
#include <stdbool.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
|
|
@ -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;
|
||||
|
|
|
|||
Loading…
Reference in a new issue