dns_name_t *namein, *nameout, *namecmp;
isc_buffer_t buf;
dns_qpkey_t key, cmp;
- uint8_t denial;
+ dns_namespace_t space;
namein = dns_fixedname_initname(&fixedin);
nameout = dns_fixedname_initname(&fixedout);
/* verify round-trip conversion of first name */
size_t keylen = dns_qpkey_fromname(key, namein, 0);
- dns_qpkey_toname(key, keylen, nameout, &denial);
+ dns_qpkey_toname(key, keylen, nameout, &space);
assert(dns_name_equal(namein, nameout));
- assert(denial == 0);
+ assert(space == 0);
/* is there a second name? */
CHECK(dns_name_fromwire(namecmp, &buf, DNS_DECOMPRESS_NEVER, NULL));
assert((namerel < 0) == (keyrel < 0));
assert((namerel == 0) == (keyrel == 0));
assert((namerel > 0) == (keyrel > 0));
- assert(denial == 0);
+ assert(space == 0);
return 0;
}
};
/*%
- * Used in composite databases such as RBTDB to indicate whether a node
- * exists in a specal tree for NSEC or NSEC3.
- */
-enum {
- DNS_DB_NSEC_NORMAL = 0, /* in main tree */
- DNS_DB_NSEC_NSEC = 2, /* in nsec tree */
- DNS_DB_NSEC_NSEC3 = 3 /* in nsec3 tree */
-};
+ * Used in QP keys to indicate whether a node is in a special namespace
+ * such as NSEC or NSEC3. These values will be mapped to characters at
+ * the beginning of the key, converting them to '0', '1', and '2'.
+ */
+typedef enum {
+ DNS_DB_NSEC_NORMAL = 0, /* regular namespace */
+ DNS_DB_NSEC_NSEC = 1, /* nsec namespace */
+ DNS_DB_NSEC_NSEC3 = 2, /* nsec3 namespace */
+} dns_namespace_t;
/*@{*/
/*%
#include <isc/attributes.h>
+#include <dns/db.h>
#include <dns/name.h>
#include <dns/types.h>
* common hostname character; otherwise unusual characters are escaped,
* using two bytes in the key. Because the maximum label length is 63
* characters, the actual max is (255 - 5) * 2 + 6 == 506. Then, we need
- * one more byte to prepend the denial of existence value.
+ * one more byte to prepend the namespace.
*
* Note: this gives us 5 bytes available space to store more data.
*/
*/
size_t
-dns_qpkey_fromname(dns_qpkey_t key, const dns_name_t *name, uint8_t denial);
+dns_qpkey_fromname(dns_qpkey_t key, const dns_name_t *name,
+ dns_namespace_t space);
/*%<
* Convert a DNS name into a trie lookup key.
*
- * If 'denial' is DNS_DB_NSEC_NORMAL (0), convert the name for a NSEC lookup.
- * If 'denial' is DNS_DB_NSEC_NSEC, convert the name for a NSEC lookup.
- * If 'denial' is DNS_DB_NSEC_NSEC3, convert the name for a NSEC3 lookup.
+ * If 'space' is DNS_DB_NSEC_NORMAL (0), convert the name for a normal lookup.
+ * If 'space' is DNS_DB_NSEC_NSEC, convert the name for a NSEC lookup.
+ * If 'space' is DNS_DB_NSEC_NSEC3, convert the name for a NSEC3 lookup.
*
* Requires:
* \li `name` is a pointer to a valid `dns_name_t`
void
dns_qpkey_toname(const dns_qpkey_t key, size_t keylen, dns_name_t *name,
- uint8_t *denial);
+ dns_namespace_t *space);
/*%<
* Convert a trie lookup key back into a DNS name.
*
- * 'denial' stores whether the key is for a normal name, or denial of existence.
+ * 'space' stores whether the key is for a normal name, or denial of existence.
*
* Requires:
* \li `name` is a pointer to a valid `dns_name_t`
*/
isc_result_t
-dns_qp_getname(dns_qpreadable_t qpr, const dns_name_t *name, uint8_t denial,
- void **pval_r, uint32_t *ival_r);
+dns_qp_getname(dns_qpreadable_t qpr, const dns_name_t *name,
+ dns_namespace_t space, void **pval_r, uint32_t *ival_r);
/*%<
- * Find a leaf in a qp-trie that matches the given DNS name, and denial value.
+ * Find a leaf in a qp-trie that matches the given DNS name, and namespace.
*
* The leaf values are assigned to whichever of `*pval_r` and `*ival_r`
* are not null, unless the return value is ISC_R_NOTFOUND.
*/
isc_result_t
-dns_qp_lookup2(dns_qpreadable_t qpr, const dns_name_t *name, uint8_t denial,
- dns_name_t *foundname, dns_qpiter_t *iter, dns_qpchain_t *chain,
- void **pval_r, uint32_t *ival_r);
+dns_qp_lookup2(dns_qpreadable_t qpr, const dns_name_t *name,
+ dns_namespace_t space, dns_name_t *foundname, dns_qpiter_t *iter,
+ dns_qpchain_t *chain, void **pval_r, uint32_t *ival_r);
/*%<
- * The same as 'dns_qp_lookup', but with the possibility to set a denial value,
+ * The same as 'dns_qp_lookup', but with the possibility to set a namespace,
* either DNS_DB_NSEC_NORMAL (or 0, which is the equivalent of 'dns_qp_lookup'),
* DNS_DB_NSEC_NSEC, OR DNS_DB_NSEC3.
*/
*/
isc_result_t
-dns_qp_deletename(dns_qp_t *qp, const dns_name_t *name, uint8_t denial,
+dns_qp_deletename(dns_qp_t *qp, const dns_name_t *name, dns_namespace_t space,
void **pval_r, uint32_t *ival_r);
/*%<
- * Delete a leaf from a qp-trie that matches the given DNS name, and denial
- * value.
+ * Delete a leaf from a qp-trie that matches the given DNS name, and namespace.
*
* The leaf values are assigned to whichever of `*pval_r` and `*ival_r`
* are not null, unless the return value is ISC_R_NOTFOUND.
#include <isc/urcu.h>
#include <isc/util.h>
-#include <dns/db.h>
#include <dns/fixedname.h>
#include <dns/name.h>
#include <dns/qp.h>
*/
/*
- * An offset for the denial value.
+ * Convert the namespace value. We map namespace values to numerical
+ * digits so they can be represented in a single byte in the QP key;
+ * thus namespace 0 becomes '0', etc.
*/
-#define DENIAL_OFFSET 48
+#define ENCODE_NAMESPACE(c) dns_qp_bits_for_byte[(c) + (uint8_t)'0']
+#define DECODE_NAMESPACE(c) dns_qp_byte_for_bit[(c)] - (uint8_t)'0'
+
+#define NAME_OFFSET 1
/*
* Number of distinct byte values, i.e. 256
* dot in a zone file).
*/
size_t
-dns_qpkey_fromname(dns_qpkey_t key, const dns_name_t *name, uint8_t denial) {
+dns_qpkey_fromname(dns_qpkey_t key, const dns_name_t *name,
+ dns_namespace_t space) {
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- REQUIRE(denial <= DNS_DB_NSEC_NSEC3);
dns_offsets_t offsets;
size_t labels = dns_name_offsets(name, offsets);
size_t len = 0;
- /* denial? */
- key[len++] = dns_qp_bits_for_byte[denial + DENIAL_OFFSET];
+ /* namespace */
+ key[len++] = ENCODE_NAMESPACE(space);
/* name */
if (labels == 0) {
key[len] = SHIFT_NOBYTE;
void
dns_qpkey_toname(const dns_qpkey_t key, size_t keylen, dns_name_t *name,
- uint8_t *denial) {
+ dns_namespace_t *space) {
size_t locs[DNS_NAME_MAXLABELS];
size_t loc = 0;
- size_t offset;
+ size_t offset = 0;
REQUIRE(ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
REQUIRE(name->buffer != NULL);
dns_name_reset(name);
- SET_IF_NOT_NULL(denial, dns_qp_byte_for_bit[key[0]] - DENIAL_OFFSET);
+ SET_IF_NOT_NULL(space, DECODE_NAMESPACE(key[offset++]));
- if (keylen == 1) {
+ if (keylen == NAME_OFFSET) {
return;
}
/* Scan the key looking for label boundaries */
- for (offset = 1; offset <= keylen; offset++) {
+ for (; offset <= keylen; offset++) {
INSIST(key[offset] >= SHIFT_NOBYTE &&
key[offset] < SHIFT_OFFSET);
INSIST(loc < DNS_NAME_MAXLABELS);
goto scanned;
}
locs[loc++] = offset + 1;
- } else if (offset == 1) {
+ } else if (offset == NAME_OFFSET) {
/* This happens for a relative name */
locs[loc++] = offset;
}
}
/* Add a root label for absolute names */
- if (key[1] == SHIFT_NOBYTE) {
+ if (key[NAME_OFFSET] == SHIFT_NOBYTE) {
name->attributes.absolute = true;
isc_buffer_putuint8(name->buffer, 0);
name->length++;
}
isc_result_t
-dns_qp_deletename(dns_qp_t *qp, const dns_name_t *name, uint8_t denial,
+dns_qp_deletename(dns_qp_t *qp, const dns_name_t *name, dns_namespace_t space,
void **pval_r, uint32_t *ival_r) {
dns_qpkey_t key;
- size_t keylen = dns_qpkey_fromname(key, name, denial);
+ size_t keylen = dns_qpkey_fromname(key, name, space);
return dns_qp_deletekey(qp, key, keylen, pval_r, ival_r);
}
}
isc_result_t
-dns_qp_getname(dns_qpreadable_t qpr, const dns_name_t *name, uint8_t denial,
- void **pval_r, uint32_t *ival_r) {
+dns_qp_getname(dns_qpreadable_t qpr, const dns_name_t *name,
+ dns_namespace_t space, void **pval_r, uint32_t *ival_r) {
dns_qpkey_t key;
- size_t keylen = dns_qpkey_fromname(key, name, denial);
+ size_t keylen = dns_qpkey_fromname(key, name, space);
return dns_qp_getkey(qpr, key, keylen, pval_r, ival_r);
}
}
isc_result_t
-dns_qp_lookup2(dns_qpreadable_t qpr, const dns_name_t *name, uint8_t denial,
- dns_name_t *foundname, dns_qpiter_t *iter, dns_qpchain_t *chain,
- void **pval_r, uint32_t *ival_r) {
+dns_qp_lookup2(dns_qpreadable_t qpr, const dns_name_t *name,
+ dns_namespace_t space, dns_name_t *foundname, dns_qpiter_t *iter,
+ dns_qpchain_t *chain, void **pval_r, uint32_t *ival_r) {
dns_qpreader_t *qp = dns_qpreader(qpr);
dns_qpkey_t search, found;
size_t searchlen, foundlen;
REQUIRE(QP_VALID(qp));
REQUIRE(foundname == NULL || ISC_MAGIC_VALID(name, DNS_NAME_MAGIC));
- searchlen = dns_qpkey_fromname(search, name, denial);
+ searchlen = dns_qpkey_fromname(search, name, space);
if (chain == NULL) {
chain = &oc;
uint8_t : 0;
unsigned int delegating : 1;
- unsigned int nsec : 2; /*%< range is 0..3 */
+ unsigned int nspace : 2; /*%< range is 0..3 */
unsigned int havensec : 1;
uint8_t : 0;
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
qpcnode_t *data = pval;
- return dns_qpkey_fromname(key, &data->name, data->nsec);
+ return dns_qpkey_fromname(key, &data->name, data->nspace);
}
static void
printname, node->locknum);
}
- switch (node->nsec) {
+ switch (node->nspace) {
case DNS_DB_NSEC_NORMAL:
if (node->havensec) {
/*
isc_result_totext(result));
}
}
- result = dns_qp_deletename(qpdb->tree, &node->name, node->nsec,
- NULL, NULL);
+ result = dns_qp_deletename(qpdb->tree, &node->name,
+ node->nspace, NULL, NULL);
break;
case DNS_DB_NSEC_NSEC:
- result = dns_qp_deletename(qpdb->nsec, &node->name, node->nsec,
- NULL, NULL);
+ result = dns_qp_deletename(qpdb->nsec, &node->name,
+ node->nspace, NULL, NULL);
break;
}
if (result != ISC_R_SUCCESS) {
qpcnode_t *node = NULL;
isc_result_t result;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- uint8_t dopt = DNS_DB_NSEC_NORMAL;
+ dns_namespace_t dopt = DNS_DB_NSEC_NORMAL;
TREE_RDLOCK(&qpdb->tree_lock, &tlocktype);
- result = dns_qp_getname(qpdb->tree, name, dopt, (void **)&node, NULL);
+ result = dns_qp_getname(qpdb->tree, name, nspace, (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
if (!create) {
goto unlock;
* Try to upgrade the lock and if that fails unlock then relock.
*/
TREE_FORCEUPGRADE(&qpdb->tree_lock, &tlocktype);
- result = dns_qp_getname(qpdb->tree, name, dopt, (void **)&node,
- NULL);
+ result = dns_qp_getname(qpdb->tree, name, nspace,
+ (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
node = new_qpcnode(qpdb, name);
- node->nsec = dopt;
+ node->nspace = dopt;
result = dns_qp_insert(qpdb->tree, node, 0);
INSIST(result == ISC_R_SUCCESS);
qpcnode_unref(node);
if (result != ISC_R_SUCCESS) {
INSIST(nsecnode == NULL);
nsecnode = new_qpcnode(qpdb, name);
- nsecnode->nsec = DNS_DB_NSEC_NSEC;
+ nsecnode->nspace = DNS_DB_NSEC_NSEC;
result = dns_qp_insert(qpdb->nsec, nsecnode, 0);
INSIST(result == ISC_R_SUCCESS);
qpcnode_detach(&nsecnode);
isc_refcount_t erefs;
uint16_t locknum;
- atomic_uint_fast8_t nsec;
+ _Atomic(dns_namespace_t) nspace;
atomic_bool havensec;
atomic_bool wild;
atomic_bool delegating;
* we simply remember the node data's address.
*/
qpdb->origin = new_qpznode(qpdb, &qpdb->common.origin);
- qpdb->origin->nsec = DNS_DB_NSEC_NORMAL;
+ qpdb->origin->nspace = DNS_DB_NSEC_NORMAL;
result = dns_qp_insert(qp, qpdb->origin, 0);
INSIST(result == ISC_R_SUCCESS);
* the NSEC nodes while iterating over the full tree.
*/
qpdb->nsec_origin = new_qpznode(qpdb, &qpdb->common.origin);
- qpdb->nsec_origin->nsec = DNS_DB_NSEC_NSEC;
+ qpdb->nsec_origin->nspace = DNS_DB_NSEC_NSEC;
result = dns_qp_insert(qp, qpdb->nsec_origin, 0);
INSIST(result == ISC_R_SUCCESS);
* record in the tree.
*/
qpdb->nsec3_origin = new_qpznode(qpdb, &qpdb->common.origin);
- qpdb->nsec3_origin->nsec = DNS_DB_NSEC_NSEC3;
+ qpdb->nsec3_origin->nspace = DNS_DB_NSEC_NSEC3;
result = dns_qp_insert(qp, qpdb->nsec3_origin, 0);
INSIST(result == ISC_R_SUCCESS);
*nodep = node;
} else {
node = new_qpznode(qpdb, name);
- node->nsec = DNS_DB_NSEC_NSEC3;
+ node->nspace = DNS_DB_NSEC_NSEC3;
result = dns_qp_insert(loadctx->tree, node, 0);
INSIST(result == ISC_R_SUCCESS);
*nodep = node;
} else {
INSIST(node == NULL);
node = new_qpznode(qpdb, name);
- node->nsec = DNS_DB_NSEC_NORMAL;
+ node->nspace = DNS_DB_NSEC_NORMAL;
result = dns_qp_insert(loadctx->tree, node, 0);
INSIST(result == ISC_R_SUCCESS);
qpznode_unref(node);
*/
node->havensec = true;
nsecnode = new_qpznode(qpdb, name);
- nsecnode->nsec = DNS_DB_NSEC_NSEC;
+ nsecnode->nspace = DNS_DB_NSEC_NSEC;
(void)dns_qp_insert(loadctx->tree, nsecnode, 0);
qpznode_detach(&nsecnode);
static void
wildcardmagic(qpzonedb_t *qpdb, dns_qp_t *qp, const dns_name_t *name,
- uint8_t denial) {
+ dns_namespace_t nspace) {
isc_result_t result;
dns_name_t foundname;
unsigned int n;
dns_name_getlabelsequence(name, 1, n, &foundname);
/* insert an empty node, if needed, to hold the wildcard bit */
- result = dns_qp_getname(qp, &foundname, denial, (void **)&node, NULL);
+ result = dns_qp_getname(qp, &foundname, nspace, (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
INSIST(node == NULL);
node = new_qpznode(qpdb, &foundname);
- node->nsec = denial;
+ node->nspace = nspace;
result = dns_qp_insert(qp, node, 0);
INSIST(result == ISC_R_SUCCESS);
qpznode_unref(node);
static void
addwildcards(qpzonedb_t *qpdb, dns_qp_t *qp, const dns_name_t *name,
- uint8_t denial) {
+ dns_namespace_t nspace) {
dns_name_t foundname;
unsigned int n, l, i;
while (i < n) {
dns_name_getlabelsequence(name, n - i, i, &foundname);
if (dns_name_iswildcard(&foundname)) {
- wildcardmagic(qpdb, qp, &foundname, denial);
+ wildcardmagic(qpdb, qp, &foundname, nspace);
}
i++;
bool nsec3, dns_dbnode_t **nodep DNS__DB_FLARG) {
isc_result_t result;
qpznode_t *node = NULL;
- uint8_t denial = nsec3 ? DNS_DB_NSEC_NSEC3 : DNS_DB_NSEC_NORMAL;
+ dns_namespace_t nspace = nsec3 ? DNS_DB_NSEC_NSEC3 : DNS_DB_NSEC_NORMAL;
dns_qpread_t qpr = { 0 };
dns_qp_t *qp = NULL;
qp = (dns_qp_t *)&qpr;
}
- result = dns_qp_getname(qp, name, denial, (void **)&node, NULL);
+ result = dns_qp_getname(qp, name, nspace, (void **)&node, NULL);
if (result != ISC_R_SUCCESS) {
if (!create) {
dns_qpread_destroy(qpdb->tree, &qpr);
}
node = new_qpznode(qpdb, name);
- node->nsec = denial;
+ node->nspace = nspace;
result = dns_qp_insert(qp, node, 0);
INSIST(result == ISC_R_SUCCESS);
qpznode_unref(node);
if (!nsec3) {
- addwildcards(qpdb, qp, name, denial);
+ addwildcards(qpdb, qp, name, nspace);
if (dns_name_iswildcard(name)) {
- wildcardmagic(qpdb, qp, name, denial);
+ wildcardmagic(qpdb, qp, name, nspace);
}
}
}
- INSIST(node->nsec == DNS_DB_NSEC_NSEC3 || !nsec3);
+ INSIST(node->nspace == DNS_DB_NSEC_NSEC3 || !nsec3);
qpznode_acquire(qpdb, node DNS__DB_FLARG_PASS);
static isc_result_t
find_wildcard(qpz_search_t *search, qpznode_t **nodep, const dns_name_t *qname,
- uint8_t denial) {
+ dns_namespace_t nspace) {
dns_slabheader_t *header = NULL;
isc_result_t result = ISC_R_NOTFOUND;
break;
}
- result = dns_qp_lookup2(&search->qpr, wname, denial,
+ result = dns_qp_lookup2(&search->qpr, wname, nspace,
NULL, &wit, NULL,
(void **)&wnode, NULL);
if (result == ISC_R_SUCCESS) {
close_version = true;
}
- uint8_t denial;
+ dns_namespace_t nspace;
qpz_search_t search;
qpz_search_init(&search, (qpzonedb_t *)db, (qpz_version_t *)version,
options);
if ((options & DNS_DBFIND_FORCENSEC3) != 0) {
nsec3 = true;
- denial = DNS_DB_NSEC_NSEC3;
+ nspace = DNS_DB_NSEC_NSEC3;
} else {
- denial = DNS_DB_NSEC_NORMAL;
+ nspace = DNS_DB_NSEC_NORMAL;
}
dns_qpmulti_query(qpdb->tree, &search.qpr);
/*
* Search down from the root of the tree.
*/
- result = dns_qp_lookup2(&search.qpr, name, denial, NULL, &search.iter,
+ result = dns_qp_lookup2(&search.qpr, name, nspace, NULL, &search.iter,
&search.chain, (void **)&node, NULL);
if (result != ISC_R_NOTFOUND) {
dns_name_copy(&node->name, foundname);
* we must see if there's a matching wildcard active
* in the current version.
*/
- result = find_wildcard(&search, &node, name, denial);
+ result = find_wildcard(&search, &node, name, nspace);
if (result == ISC_R_SUCCESS) {
dns_name_copy(name, foundname);
wild = true;
* If we immediately hit an NSEC/NSEC3 node,
* we don't have any non-nsec nodes.
*/
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NORMAL) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NORMAL) {
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
}
* If we hit an NSEC node, we need to start at the NSEC3 part of
* the tree.
*/
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC) {
break;
}
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NSEC);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NSEC);
/* FALLTHROUGH */
case nsec3only:
/* tree only has NSEC3 origin node. */
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
- } else if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC3) {
+ } else if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC3)
+ {
/* tree has no NSEC3 nodes at all. */
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
* If we hit an NSEC node, we need to seek the final normal node
* of the tree.
*/
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC) {
break;
}
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NSEC);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NSEC);
/* FALLTHROUGH */
case nonsec3:
(void **)&qpdbiter->node,
NULL);
INSIST(result == ISC_R_SUCCESS);
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NORMAL);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NORMAL);
}
break;
default:
/* we hit the NSEC3 origin node. */
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
- } else if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC3) {
+ } else if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC3)
+ {
/* we hit a non-NSEC3 node. */
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
* If we hit an NSEC node, we need to seek the final normal node
* of the tree.
*/
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC) {
break;
}
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NSEC);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NSEC);
result = dns_qp_lookup2(qpdbiter->snap, &qpdb->common.origin,
DNS_DB_NSEC_NSEC, NULL, &qpdbiter->iter,
NULL, (void **)&qpdbiter->node, NULL);
(void **)&qpdbiter->node,
NULL);
INSIST(result == ISC_R_SUCCESS);
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NORMAL);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NORMAL);
}
break;
case nonsec3:
case nonsec3:
if (result == ISC_R_SUCCESS) {
/* we hit an NSEC or NSEC3 node. */
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NORMAL) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NORMAL) {
qpdbiter->node = NULL;
result = ISC_R_NOMORE;
}
* If we hit an NSEC node, we need to start at the NSEC3 part of
* the tree.
*/
- if (qpdbiter->node->nsec != DNS_DB_NSEC_NSEC) {
+ if (qpdbiter->node->nspace != DNS_DB_NSEC_NSEC) {
break;
}
- INSIST(qpdbiter->node->nsec == DNS_DB_NSEC_NSEC);
+ INSIST(qpdbiter->node->nspace == DNS_DB_NSEC_NSEC);
result = dns_qp_lookup2(qpdbiter->snap, &qpdb->common.origin,
DNS_DB_NSEC_NSEC3, NULL,
return DNS_R_NOTZONETOP;
}
- REQUIRE((node->nsec == DNS_DB_NSEC_NSEC3 &&
+ REQUIRE((node->nspace == DNS_DB_NSEC_NSEC3 &&
(rdataset->type == dns_rdatatype_nsec3 ||
rdataset->covers == dns_rdatatype_nsec3)) ||
- (node->nsec != DNS_DB_NSEC_NSEC3 &&
+ (node->nspace != DNS_DB_NSEC_NSEC3 &&
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3));
* move on.
*/
qpznode_t *nsecnode = new_qpznode(qpdb, name);
- nsecnode->nsec = DNS_DB_NSEC_NSEC;
+ nsecnode->nspace = DNS_DB_NSEC_NSEC;
(void)dns_qp_insert(nsec, nsecnode, 0);
qpznode_detach(&nsecnode);
}
REQUIRE(VALID_QPZONE(qpdb));
REQUIRE(version != NULL && version->qpdb == qpdb);
- REQUIRE((node->nsec == DNS_DB_NSEC_NSEC3 &&
+ REQUIRE((node->nspace == DNS_DB_NSEC_NSEC3 &&
(rdataset->type == dns_rdatatype_nsec3 ||
rdataset->covers == dns_rdatatype_nsec3)) ||
- (node->nsec != DNS_DB_NSEC_NSEC3 &&
+ (node->nspace != DNS_DB_NSEC_NSEC3 &&
rdataset->type != dns_rdatatype_nsec3 &&
rdataset->covers != dns_rdatatype_nsec3));
qp_makekey(dns_qpkey_t key, void *uctx ISC_ATTR_UNUSED, void *pval,
uint32_t ival ISC_ATTR_UNUSED) {
qpznode_t *data = pval;
- return dns_qpkey_fromname(key, &data->name, data->nsec);
+ return dns_qpkey_fromname(key, &data->name, data->nspace);
}
static void
ISC_RUN_TEST_IMPL(qpkey_name) {
struct {
const char *namestr;
- uint8_t denial;
+ dns_namespace_t space;
uint8_t key[512];
size_t len;
} testcases[] = {
{
.namestr = "",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x02 },
.len = 1,
},
{
.namestr = ".",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x02, 0x02 },
.len = 2,
},
{
.namestr = "\\000",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x03, 0x03, 0x02 },
.len = 4,
},
{
.namestr = "\\000\\009",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x03, 0x03, 0x03, 0x0c, 0x02 },
.len = 6,
},
{
.namestr = "com",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x16, 0x22, 0x20, 0x02 },
.len = 5,
},
{
.namestr = "com.",
- .denial = DNS_DB_NSEC_NSEC,
- .key = { 0x09, 0x02, 0x16, 0x22, 0x20, 0x02 },
+ .space = DNS_DB_NSEC_NSEC,
+ .key = { 0x08, 0x02, 0x16, 0x22, 0x20, 0x02 },
.len = 6,
},
{
.namestr = "com.",
- .denial = DNS_DB_NSEC_NSEC3,
- .key = { 0x0a, 0x02, 0x16, 0x22, 0x20, 0x02 },
+ .space = DNS_DB_NSEC_NSEC3,
+ .key = { 0x09, 0x02, 0x16, 0x22, 0x20, 0x02 },
.len = 6,
},
{
.namestr = "com.",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x02, 0x16, 0x22, 0x20, 0x02 },
.len = 6,
},
{
.namestr = "example.com.",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x02, 0x16, 0x22, 0x20, 0x02, 0x18, 0x2b,
0x14, 0x20, 0x23, 0x1f, 0x18, 0x02 },
.len = 14,
},
{
.namestr = "example.com",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x16, 0x22, 0x20, 0x02, 0x18, 0x2b, 0x14,
0x20, 0x23, 0x1f, 0x18, 0x02 },
.len = 13,
},
{
.namestr = "EXAMPLE.COM",
- .denial = DNS_DB_NSEC_NORMAL,
+ .space = DNS_DB_NSEC_NORMAL,
.key = { 0x07, 0x16, 0x22, 0x20, 0x02, 0x18, 0x2b, 0x14,
0x20, 0x23, 0x1f, 0x18, 0x02 },
.len = 13,
dns_fixedname_t fn1, fn2;
dns_name_t *in = NULL, *out = NULL;
char namebuf[DNS_NAME_FORMATSIZE];
- uint8_t denial;
+ dns_namespace_t space;
in = dns_fixedname_initname(&fn1);
if (testcases[i].len > 1) {
dns_test_namefromstring(testcases[i].namestr, &fn1);
}
- len = dns_qpkey_fromname(key, in, testcases[i].denial);
+ len = dns_qpkey_fromname(key, in, testcases[i].space);
if (verbose) {
qp_test_printkey(key, len);
}
assert_memory_equal(testcases[i].key, key, len);
out = dns_fixedname_initname(&fn2);
- dns_qpkey_toname(key, len, out, &denial);
+ dns_qpkey_toname(key, len, out, &space);
assert_true(dns_name_equal(in, out));
- assert_int_equal(denial, testcases[i].denial);
+ assert_int_equal(space, testcases[i].space);
/* check that 'out' is properly reset by dns_qpkey_toname */
dns_qpkey_toname(key, len, out, NULL);
dns_name_format(out, namebuf, sizeof(namebuf));
const char *namestr;
dns_name_t *name;
dns_fixedname_t fixed;
- uint8_t denial;
+ dns_namespace_t space;
size_t len;
dns_qpkey_t key;
} testcases[] = {
- { .namestr = ".", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "\\000.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "\\000.\\000.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "\\000\\009.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "\\007.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "example.com.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "EXAMPLE.COM.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "www.example.com.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "exam.com.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "exams.com.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "exam\\000.com.", .denial = DNS_DB_NSEC_NORMAL },
- { .namestr = "exam.com.", .denial = DNS_DB_NSEC_NSEC },
- { .namestr = "exams.com.", .denial = DNS_DB_NSEC_NSEC },
- { .namestr = "exam.com.", .denial = DNS_DB_NSEC_NSEC3 },
- { .namestr = "exams.com.", .denial = DNS_DB_NSEC_NSEC3 },
+ { .namestr = ".", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "\\000.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "\\000.\\000.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "\\000\\009.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "\\007.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "example.com.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "EXAMPLE.COM.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "www.example.com.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "exam.com.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "exams.com.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "exam\\000.com.", .space = DNS_DB_NSEC_NORMAL },
+ { .namestr = "exam.com.", .space = DNS_DB_NSEC_NSEC },
+ { .namestr = "exams.com.", .space = DNS_DB_NSEC_NSEC },
+ { .namestr = "exam.com.", .space = DNS_DB_NSEC_NSEC3 },
+ { .namestr = "exams.com.", .space = DNS_DB_NSEC_NSEC3 },
};
for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
testcases[i].name = dns_fixedname_name(&testcases[i].fixed);
testcases[i].len = dns_qpkey_fromname(testcases[i].key,
testcases[i].name,
- testcases[i].denial);
+ testcases[i].space);
}
for (size_t i = 0; i < ARRAY_SIZE(testcases); i++) {
/* include extra terminating NOBYTE */
int keycmp = memcmp(testcases[i].key, testcases[j].key,
len + 1);
- if (testcases[i].denial == testcases[j].denial) {
+ if (testcases[i].space == testcases[j].space) {
assert_true((namecmp < 0) == (keycmp < 0));
assert_true((namecmp == 0) == (keycmp == 0));
assert_true((namecmp > 0) == (keycmp > 0));
} else {
- uint8_t di = testcases[i].denial;
- uint8_t dj = testcases[j].denial;
+ uint8_t di = testcases[i].space;
+ uint8_t dj = testcases[j].space;
assert_true((di < dj) == (keycmp < 0));
assert_true((di > dj) == (keycmp > 0));
}
static size_t
qpkey_fromstring(dns_qpkey_t key, void *uctx, void *pval, uint32_t ival) {
dns_fixedname_t fixed;
- uint8_t denial = ival;
+ dns_namespace_t space = ival;
UNUSED(uctx);
dns_test_namefromstring(pval, &fixed);
- return dns_qpkey_fromname(key, dns_fixedname_name(&fixed), denial);
+ return dns_qpkey_fromname(key, dns_fixedname_name(&fixed), space);
}
const dns_qpmethods_t string_methods = {
static void
check_partialmatch(dns_qp_t *qp, struct check_partialmatch check[],
- uint8_t denial) {
+ dns_namespace_t space) {
for (int i = 0; check[i].query != NULL; i++) {
isc_result_t result;
dns_fixedname_t fn1, fn2;
void *pval = NULL;
dns_test_namefromstring(check[i].query, &fn1);
- result = dns_qp_lookup2(qp, name, denial, foundname, NULL, NULL,
+ result = dns_qp_lookup2(qp, name, space, foundname, NULL, NULL,
&pval, NULL);
#if 0
fprintf(stderr, "%s%s %s (expected %s) "
"value \"%s\" (expected \"%s\")\n",
- denial == DNS_DB_NSEC_NSEC3 ? "NSEC3:" : (denial == DNS_DB_NSEC_NSEC ? "NSEC:" : ""),
+ space == DNS_DB_NSEC_NSEC3 ? "NSEC3:" : (space == DNS_DB_NSEC_NSEC ? "NSEC:" : ""),
check[i].query,
isc_result_totext(result),
isc_result_totext(check[i].result), (char *)pval,
}
static void
-insert_name(dns_qp_t *qp, const char *str, uint8_t denial) {
+insert_name(dns_qp_t *qp, const char *str, dns_namespace_t space) {
isc_result_t result;
uintptr_t pval = (uintptr_t)str;
- uint32_t ival = (uint32_t)denial;
+ uint32_t ival = (uint32_t)space;
INSIST((pval & 3) == 0);
result = dns_qp_insert(qp, (void *)pval, ival);
assert_int_equal(result, ISC_R_SUCCESS);
}
static void
-delete_rootkey(dns_qp_t *qp, uint8_t denial) {
- uint8_t d = dns_qp_bits_for_byte[denial + 48];
+delete_rootkey(dns_qp_t *qp, dns_namespace_t space) {
+ uint8_t d = dns_qp_bits_for_byte[space + 48];
dns_qpkey_t rootkey = { d, SHIFT_NOBYTE };
isc_result_t result = dns_qp_deletekey(qp, rootkey, 1, NULL, NULL);
assert_int_equal(result, ISC_R_SUCCESS);
struct check_qpchain {
const char *query;
- uint8_t denial;
+ dns_namespace_t space;
isc_result_t result;
unsigned int length;
const char *names[10];
dns_qpchain_init(qp, &chain);
dns_test_namefromstring(check[i].query, &fn1);
- result = dns_qp_lookup2(qp, name, check[i].denial, NULL, iter,
+ result = dns_qp_lookup2(qp, name, check[i].space, NULL, iter,
&chain, NULL, NULL);
#if 0
fprintf(stderr,
struct check_predecessors {
const char *query;
- uint8_t denial;
+ dns_namespace_t space;
const char *predecessor;
- uint8_t pdenial;
+ dns_namespace_t pspace;
isc_result_t result;
int remaining;
};
result = dns_name_tostring(expred, &predstr, mctx);
assert_int_equal(result, ISC_R_SUCCESS);
- result = dns_qp_lookup2(qp, name, check[i].denial, NULL, &it,
+ result = dns_qp_lookup2(qp, name, check[i].space, NULL, &it,
chain, NULL, NULL);
#if 0
fprintf(stderr, "%s %s: expected %s got %s\n", check[i].query,
- check[i].denial == DNS_DB_NSEC_NSEC3
+ check[i].space == DNS_DB_NSEC_NSEC3
? "NSEC3"
- : (check[i].denial == DNS_DB_NSEC_NSEC
+ : (check[i].space == DNS_DB_NSEC_NSEC
? "NSEC"
: "NORMAL"),
isc_result_totext(check[i].result),
result = dns_name_tostring(pred, &namestr, mctx);
#if 0
fprintf(stderr, "... expected predecessor %s %u got %s %u\n",
- predstr, check[i].pdenial, namestr, ival);
+ predstr, check[i].pspace, namestr, ival);
#endif
assert_int_equal(result, ISC_R_SUCCESS);
assert_string_equal(namestr, predstr);
- assert_int_equal(ival, check[i].pdenial);
+ assert_int_equal(ival, check[i].pspace);
#if 0
fprintf(stderr, "%d: remaining names after %s:\n", i, namestr);
struct inserting {
/* Fixed size strings [32] should ensure leaf-compatible alignment. */
const char name[32];
- uint8_t denial;
+ dns_namespace_t space;
/* Padding */
uint8_t pad1;
uint16_t pad2;
struct check_delete {
const char *name;
- uint8_t denial;
+ dns_namespace_t space;
isc_result_t result;
};
dns_qpchain_init(qp, &chain);
dns_test_namefromstring(check[i].name, &fn1);
- result = dns_qp_deletename(qp, name, check[i].denial, NULL,
+ result = dns_qp_deletename(qp, name, check[i].space, NULL,
NULL);
#if 0
fprintf(stderr, "%s %u %s (expected %s)\n", check[i].name,
- check[i].denial, isc_result_totext(result),
+ check[i].space, isc_result_totext(result),
isc_result_totext(check[i].result));
#endif
assert_int_equal(result, check[i].result);
dns_qp_create(mctx, &string_methods, NULL, &qp);
while (insert1[i].name[0] != '\0') {
- insert_name(qp, insert1[i].name, insert1[i].denial);
+ insert_name(qp, insert1[i].name, insert1[i].space);
i++;
}
qp_test_printkey(const dns_qpkey_t key, size_t keylen) {
dns_fixedname_t fn;
dns_name_t *n = dns_fixedname_initname(&fn);
- uint8_t d;
+ dns_namespace_t s;
char txt[DNS_NAME_FORMATSIZE];
- dns_qpkey_toname(key, keylen, n, &d);
+ dns_qpkey_toname(key, keylen, n, &s);
dns_name_format(n, txt, sizeof(txt));
printf("%s%s%s\n", txt,
- d == DNS_DB_NSEC_NSEC3 ? "NSEC3:"
- : (d == DNS_DB_NSEC_NSEC ? "NSEC" : ""),
+ s == DNS_DB_NSEC_NSEC3 ? "NSEC3:"
+ : (s == DNS_DB_NSEC_NSEC ? "NSEC" : ""),
dns_name_isabsolute(n) ? "." : "");
}
projects / thirdparty / bind9.git / commitdiff
