dns__db_detachnode(sampledb->rbtdb, targetp DNS__DB_FLARG_PASS);
}
-static isc_result_t
-expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- return (dns_db_expirenode(sampledb->rbtdb, node, now));
-}
-
-static void
-printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns_db_printnode(sampledb->rbtdb, node, out);
-}
-
static isc_result_t
createiterator(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp) {
return (dns_db_nodecount(sampledb->rbtdb, tree));
}
-static void
-overmem(dns_db_t *db, bool over) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns_db_overmem(sampledb->rbtdb, over);
-}
-
static void
setloop(dns_db_t *db, isc_loop_t *loop) {
sampledb_t *sampledb = (sampledb_t *)db;
nodep DNS__DB_FLARG_PASS));
}
-static void
-transfernode(dns_db_t *db, dns_dbnode_t **sourcep, dns_dbnode_t **targetp) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns_db_transfernode(sampledb->rbtdb, sourcep, targetp);
-}
-
static isc_result_t
getnsec3parameters(dns_db_t *db, dns_dbversion_t *version, dns_hash_t *hash,
uint8_t *flags, uint16_t *iterations, unsigned char *salt,
name DNS__DB_FLARG_PASS));
}
-static void
-resigned(dns_db_t *db, dns_rdataset_t *rdataset,
- dns_dbversion_t *version DNS__DB_FLARG) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- dns__db_resigned(sampledb->rbtdb, rdataset, version DNS__DB_FLARG_PASS);
-}
-
-static bool
-isdnssec(dns_db_t *db) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- return (dns_db_isdnssec(sampledb->rbtdb));
-}
-
static dns_stats_t *
getrrsetstats(dns_db_t *db) {
sampledb_t *sampledb = (sampledb_t *)db;
return (dns_db_setcachestats(sampledb->rbtdb, stats));
}
-static size_t
-hashsize(dns_db_t *db) {
- sampledb_t *sampledb = (sampledb_t *)db;
-
- REQUIRE(VALID_SAMPLEDB(sampledb));
-
- return (dns_db_hashsize(sampledb->rbtdb));
-}
-
/*
* DB interface definition. Database driver uses this structure to
* determine which implementation of dns_db_*() function to call.
.findzonecut = findzonecut,
.attachnode = attachnode,
.detachnode = detachnode,
- .expirenode = expirenode,
- .printnode = printnode,
.createiterator = createiterator,
.findrdataset = findrdataset,
.allrdatasets = allrdatasets,
.deleterdataset = deleterdataset,
.issecure = issecure,
.nodecount = nodecount,
- .overmem = overmem,
.setloop = setloop,
.getoriginnode = getoriginnode,
- .transfernode = transfernode,
.getnsec3parameters = getnsec3parameters,
.findnsec3node = findnsec3node,
.setsigningtime = setsigningtime,
.getsigningtime = getsigningtime,
- .resigned = resigned,
- .isdnssec = isdnssec,
.getrrsetstats = getrrsetstats,
.findnodeext = findnodeext,
.findext = findext,
.setcachestats = setcachestats,
- .hashsize = hashsize,
};
/* Auxiliary driver functions. */
dns_ttl_t serve_stale_ttl;
dns_ttl_t serve_stale_refresh;
isc_stats_t *stats;
- bool overmem;
};
/***
return (cache->name);
}
-static void
-water(void *arg, int mark) {
- dns_cache_t *cache = arg;
- bool overmem = (mark == ISC_MEM_HIWATER);
-
- REQUIRE(VALID_CACHE(cache));
-
- LOCK(&cache->lock);
- if (overmem != cache->overmem) {
- dns_db_overmem(cache->db, overmem);
- cache->overmem = overmem;
- isc_mem_waterack(cache->mctx, mark);
- }
- UNLOCK(&cache->lock);
-}
-
void
dns_cache_setcachesize(dns_cache_t *cache, size_t size) {
- size_t hiwater, lowater;
-
REQUIRE(VALID_CACHE(cache));
/*
LOCK(&cache->lock);
cache->size = size;
UNLOCK(&cache->lock);
-
- hiwater = size - (size >> 3); /* Approximately 7/8ths. */
- lowater = size - (size >> 2); /* Approximately 3/4ths. */
-
- /*
- * If the cache was overmem and cleaning, but now with the new limits
- * it is no longer in an overmem condition, then the next
- * isc_mem_put for cache memory will do the right thing and trigger
- * water().
- */
-
- if (size == 0U || hiwater == 0U || lowater == 0U) {
- /*
- * Disable cache memory limiting.
- */
- isc_mem_clearwater(cache->mctx);
- } else {
- /*
- * Establish new cache memory limits (either for the first
- * time, or replacing other limits).
- */
- isc_mem_setwater(cache->mctx, water, cache, hiwater, lowater);
- }
}
size_t
return (false);
}
-bool
-dns_db_isdnssec(dns_db_t *db) {
- /*
- * Is 'db' secure or partially secure?
- */
-
- REQUIRE(DNS_DB_VALID(db));
- REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
-
- if (db->methods->isdnssec != NULL) {
- return ((db->methods->isdnssec)(db));
- }
- if (db->methods->issecure != NULL) {
- return ((db->methods->issecure)(db));
- }
- return (false);
-}
-
bool
dns_db_issecure(dns_db_t *db) {
/*
REQUIRE(DNS_DB_VALID(db));
- if (db->methods->ispersistent != NULL) {
- return ((db->methods->ispersistent)(db));
- } else if (db->methods->beginload == NULL) {
+ if (db->methods->beginload == NULL) {
/* If the database can't be loaded, assume it's persistent */
return (true);
}
return (result);
}
-isc_result_t
-dns_db_dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
- if (db->methods->dump != NULL) {
- return ((db->methods->dump)(db, version, filename,
- dns_masterformat_text));
- }
- return (ISC_R_NOTIMPLEMENTED);
-}
-
/***
*** Version Methods
***/
dns_dbnode_t **targetp) {
REQUIRE(DNS_DB_VALID(db));
REQUIRE(targetp != NULL && *targetp == NULL);
- /*
- * This doesn't check the implementation magic. If we find that
- * we need such checks in future then this will be done in the
- * method.
- */
REQUIRE(sourcep != NULL && *sourcep != NULL);
- UNUSED(db);
-
- if (db->methods->transfernode == NULL) {
- *targetp = *sourcep;
- *sourcep = NULL;
- } else {
- (db->methods->transfernode)(db, sourcep, targetp);
- }
-
- ENSURE(*sourcep == NULL);
-}
-
-isc_result_t
-dns_db_expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
- /*
- * Mark as stale all records at 'node' which expire at or before 'now'.
- */
-
- REQUIRE(DNS_DB_VALID(db));
- REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
- REQUIRE(node != NULL);
-
- if (db->methods->expirenode != NULL) {
- return ((db->methods->expirenode)(db, node, now));
- }
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-void
-dns_db_printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
- /*
- * Print a textual representation of the contents of the node to
- * 'out'.
- */
-
- REQUIRE(DNS_DB_VALID(db));
- REQUIRE(node != NULL);
-
- if (db->methods->printnode != NULL) {
- (db->methods->printnode)(db, node, out);
- }
+ *targetp = *sourcep;
+ *sourcep = NULL;
}
/***
return (ISC_R_NOTIMPLEMENTED);
}
-void
-dns_db_overmem(dns_db_t *db, bool overmem) {
- REQUIRE(DNS_DB_VALID(db));
-
- if (db->methods->overmem != NULL) {
- (db->methods->overmem)(db, overmem);
- }
-}
-
isc_result_t
dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, uint32_t *serialp) {
isc_result_t result;
return (ISC_R_NOTFOUND);
}
-void
-dns__db_resigned(dns_db_t *db, dns_rdataset_t *rdataset,
- dns_dbversion_t *version DNS__DB_FLARG) {
- if (db->methods->resigned != NULL) {
- (db->methods->resigned)(db, rdataset,
- version DNS__DB_FLARG_PASS);
- }
-}
-
/*
* Attach a notify-on-update function the database
*/
return (ISC_R_NOTFOUND);
}
-isc_result_t
-dns_db_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name) {
- REQUIRE(db != NULL);
- REQUIRE(node != NULL);
- REQUIRE(name != NULL);
-
- if (db->methods->nodefullname != NULL) {
- return ((db->methods->nodefullname)(db, node, name));
- }
- return (ISC_R_NOTIMPLEMENTED);
-}
-
isc_result_t
dns_db_setservestalettl(dns_db_t *db, dns_ttl_t ttl) {
REQUIRE(DNS_DB_VALID(db));
isc_result_t (*beginload)(dns_db_t *db,
dns_rdatacallbacks_t *callbacks);
isc_result_t (*endload)(dns_db_t *db, dns_rdatacallbacks_t *callbacks);
- isc_result_t (*dump)(dns_db_t *db, dns_dbversion_t *version,
- const char *filename,
- dns_masterformat_t masterformat);
void (*currentversion)(dns_db_t *db, dns_dbversion_t **versionp);
isc_result_t (*newversion)(dns_db_t *db, dns_dbversion_t **versionp);
void (*attachversion)(dns_db_t *db, dns_dbversion_t *source,
void (*attachnode)(dns_db_t *db, dns_dbnode_t *source,
dns_dbnode_t **targetp DNS__DB_FLARG);
void (*detachnode)(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG);
- isc_result_t (*expirenode)(dns_db_t *db, dns_dbnode_t *node,
- isc_stdtime_t now);
- void (*printnode)(dns_db_t *db, dns_dbnode_t *node, FILE *out);
isc_result_t (*createiterator)(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp);
isc_result_t (*findrdataset)(dns_db_t *db, dns_dbnode_t *node,
dns_rdatatype_t covers DNS__DB_FLARG);
bool (*issecure)(dns_db_t *db);
unsigned int (*nodecount)(dns_db_t *db, dns_dbtree_t);
- bool (*ispersistent)(dns_db_t *db);
- void (*overmem)(dns_db_t *db, bool overmem);
void (*setloop)(dns_db_t *db, isc_loop_t *);
isc_result_t (*getoriginnode)(dns_db_t *db,
dns_dbnode_t **nodep DNS__DB_FLARG);
- void (*transfernode)(dns_db_t *db, dns_dbnode_t **sourcep,
- dns_dbnode_t **targetp);
isc_result_t (*getnsec3parameters)(dns_db_t *db,
dns_dbversion_t *version,
dns_hash_t *hash, uint8_t *flags,
isc_stdtime_t resign);
isc_result_t (*getsigningtime)(dns_db_t *db, dns_rdataset_t *rdataset,
dns_name_t *name DNS__DB_FLARG);
- void (*resigned)(dns_db_t *db, dns_rdataset_t *rdataset,
- dns_dbversion_t *version DNS__DB_FLARG);
- bool (*isdnssec)(dns_db_t *db);
dns_stats_t *(*getrrsetstats)(dns_db_t *db);
isc_result_t (*findnodeext)(dns_db_t *db, const dns_name_t *name,
bool create,
dns_rdataset_t *sigrdataset DNS__DB_FLARG);
isc_result_t (*setcachestats)(dns_db_t *db, isc_stats_t *stats);
size_t (*hashsize)(dns_db_t *db);
- isc_result_t (*nodefullname)(dns_db_t *db, dns_dbnode_t *node,
- dns_name_t *name);
isc_result_t (*getsize)(dns_db_t *db, dns_dbversion_t *version,
uint64_t *records, uint64_t *bytes);
isc_result_t (*setservestalettl)(dns_db_t *db, dns_ttl_t ttl);
uint16_t attributes;
dns_rdataclass_t rdclass;
dns_name_t origin;
+ dns_ttl_t serve_stale_ttl; /* for cache DB's only */
isc_mem_t *mctx;
isc_refcount_t references;
ISC_LIST(dns_dbonupdatelistener_t) update_listeners;
* \li '*sourcep' is NULL.
*/
-isc_result_t
-dns_db_expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now);
-/*%<
- * Mark as stale all records at 'node' which expire at or before 'now'.
- *
- * Note: if 'now' is zero, then the current time will be used.
- *
- * Requires:
- *
- * \li 'db' is a valid cache database.
- *
- * \li 'node' is a valid node.
- */
-
void
dns_db_printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out);
/*%<
* \li 'ver' is a valid version.
*/
-void
-dns_db_overmem(dns_db_t *db, bool overmem);
-/*%<
- * Enable / disable aggressive cache cleaning.
- */
-
unsigned int
dns_db_nodecount(dns_db_t *db, dns_dbtree_t tree);
/*%<
* Is 'db' persistent? A persistent database does not need to be loaded
* from disk or written to disk.
*
- * By default, return false if the database implementation has an
- * 'endload' function and true if it doesn't. This default can be overridden
- * by including an 'ispersistent function in the database implementation.
+ * By default, return false if the database implementation has a
+ * 'beginload' function and true if it doesn't.
*
* Requires:
*
* Requires:
* \li 'db' is a valid zone database.
* \li 'rdataset' is or is to be associated with 'db'.
- * \li 'rdataset' is not pending removed from the heap via an
- * uncommitted call to dns_db_resigned().
*
* Returns:
* \li #ISC_R_SUCCESS
* \li #ISC_R_NOTFOUND - No dataset exists.
*/
-#define dns_db_resigned(db, rdataset, version) \
- dns__db_resigned(db, rdataset, version DNS__DB_FILELINE)
-void
-dns__db_resigned(dns_db_t *db, dns_rdataset_t *rdataset,
- dns_dbversion_t *version DNS__DB_FLARG);
-/*%<
- * Mark 'rdataset' as not being available to be returned by
- * dns_db_getsigningtime(). If the changes associated with 'version'
- * are committed this will be permanent. If the version is not committed
- * this change will be rolled back when the version is closed. Until
- * 'version' is either committed or rolled back, 'rdataset' can no longer
- * be acted upon by dns_db_setsigningtime().
- *
- * Requires:
- * \li 'db' is a valid zone database.
- * \li 'rdataset' to be associated with 'db'.
- * \li 'version' to be open for writing.
- */
-
dns_stats_t *
dns_db_getrrsetstats(dns_db_t *db);
/*%<
*
*/
-isc_result_t
-dns_db_nodefullname(dns_db_t *db, dns_dbnode_t *node, dns_name_t *name);
-/*%<
- * Get the name associated with a database node.
- *
- * Requires:
- *
- * \li 'db' is a valid database
- * \li 'node' and 'name' are not NULL
- */
-
isc_result_t
dns_db_setservestalettl(dns_db_t *db, dns_ttl_t ttl);
/*%<
#define STATCOUNT(header) \
((atomic_load_acquire(&(header)->attributes) & \
DNS_SLABHEADERATTR_STATCOUNT) != 0)
-#define STALE_TTL(header, rbtdb) (NXDOMAIN(header) ? 0 : rbtdb->serve_stale_ttl)
+
+#define STALE_TTL(header, rbtdb) \
+ (NXDOMAIN(header) ? 0 : rbtdb->common.serve_stale_ttl)
#define HEADER_GETATTR(header, attribute) \
(atomic_load_acquire(&(header)->attributes) & attribute)
dns_dbnode_t *soanode;
dns_dbnode_t *nsnode;
- /*
- * Maximum length of time to keep using a stale answer past its
- * normal TTL expiry.
- */
- dns_ttl_t serve_stale_ttl;
-
/*
* The time after a failed lookup, where stale answers from cache
* may be used directly in a DNS response without attempting a
#define RBTDB_ATTR_LOADED 0x01
#define RBTDB_ATTR_LOADING 0x02
-#define KEEPSTALE(rbtdb) ((rbtdb)->serve_stale_ttl > 0)
+#define KEEPSTALE(rbtdb) ((rbtdb)->common.serve_stale_ttl > 0)
/*%
* Search Context
static void
free_rbtdb(dns_rbtdb_t *rbtdb, bool log);
static void
-overmem(dns_db_t *db, bool over);
-static void
setnsec3parameters(dns_db_t *db, dns_rbtdb_version_t *version);
static void
setownercase(dns_slabheader_t *header, const dns_name_t *name);
dns_rbt_t **treep = NULL;
isc_time_t start;
- if (IS_CACHE(rbtdb) && rbtdb->common.rdclass == dns_rdataclass_in) {
- overmem((dns_db_t *)rbtdb, (bool)-1);
- }
-
REQUIRE(rbtdb->current_version != NULL || EMPTY(rbtdb->open_versions));
REQUIRE(rbtdb->future_version == NULL);
}
static void
-destroy(dns_db_t *db) {
+dns__rbtdb_destroy(dns_db_t *db) {
maybe_free_rbtdb((dns_rbtdb_t *)db);
}
static void
-currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
+dns__rbtdb_currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtdb_version_t *version = NULL;
}
static isc_result_t
-newversion(dns_db_t *db, dns_dbversion_t **versionp) {
+dns__rbtdb_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtdb_version_t *version = NULL;
}
static void
-attachversion(dns_db_t *db, dns_dbversion_t *source,
- dns_dbversion_t **targetp) {
+dns__rbtdb_attachversion(dns_db_t *db, dns_dbversion_t *source,
+ dns_dbversion_t **targetp) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtdb_version_t *rbtversion = source;
}
static void
-closeversion(dns_db_t *db, dns_dbversion_t **versionp,
- bool commit DNS__DB_FLARG) {
+dns__rbtdb_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
+ bool commit DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtdb_version_t *version = NULL, *cleanup_version = NULL;
dns_rbtdb_version_t *least_greater = NULL;
}
static isc_result_t
-findnode(dns_db_t *db, const dns_name_t *name, bool create,
- dns_dbnode_t **nodep DNS__DB_FLARG) {
+dns__rbtdb_findnode(dns_db_t *db, const dns_name_t *name, bool create,
+ dns_dbnode_t **nodep DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
REQUIRE(VALID_RBTDB(rbtdb));
* version.
*/
if (version == NULL) {
- currentversion(db, &version);
+ dns__rbtdb_currentversion(db, &version);
close_version = true;
}
}
if (close_version) {
- closeversion(db, &version, false DNS__DB_FLARG_PASS);
+ dns__rbtdb_closeversion(db, &version, false DNS__DB_FLARG_PASS);
}
dns_rbtnodechain_reset(&search.chain);
}
static void
-attachnode(dns_db_t *db, dns_dbnode_t *source,
- dns_dbnode_t **targetp DNS__DB_FLARG) {
+dns__rbtdb_attachnode(dns_db_t *db, dns_dbnode_t *source,
+ dns_dbnode_t **targetp DNS__DB_FLARG) {
REQUIRE(VALID_RBTDB((dns_rbtdb_t *)db));
REQUIRE(targetp != NULL && *targetp == NULL);
}
static void
-detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
+dns__rbtdb_detachnode(dns_db_t *db, dns_dbnode_t **targetp DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *node = NULL;
bool want_free = false;
}
static isc_result_t
-expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtnode_t *rbtnode = node;
- dns_slabheader_t *header = NULL;
- bool force_expire = false;
- /*
- * These are the category and module used by the cache cleaner.
- */
- bool log = false;
- isc_logcategory_t *category = DNS_LOGCATEGORY_DATABASE;
- isc_logmodule_t *module = DNS_LOGMODULE_CACHE;
- int level = ISC_LOG_DEBUG(2);
- char printname[DNS_NAME_FORMATSIZE];
- isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
-
- REQUIRE(VALID_RBTDB(rbtdb));
-
- /*
- * Caller must hold a tree lock.
- */
-
- if (now == 0) {
- now = isc_stdtime_now();
- }
-
- if (isc_mem_isovermem(rbtdb->common.mctx)) {
- /*
- * Force expire with 25% probability.
- * XXXDCL Could stand to have a better policy, like LRU.
- */
- force_expire = (rbtnode->down == NULL &&
- (isc_random32() % 4) == 0);
-
- /*
- * Note that 'log' can be true IFF overmem is also true.
- * overmem can currently only be true for cache
- * databases -- hence all of the "overmem cache" log strings.
- */
- log = isc_log_wouldlog(dns_lctx, level);
- if (log) {
- isc_log_write(
- dns_lctx, category, module, level,
- "overmem cache: %s %s",
- force_expire ? "FORCE" : "check",
- dns_rbt_formatnodename(rbtnode, printname,
- sizeof(printname)));
- }
- }
-
- /*
- * We may not need write access, but this code path is not performance
- * sensitive, so it should be okay to always lock as a writer.
- */
- NODE_WRLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
-
- for (header = rbtnode->data; header != NULL; header = header->next) {
- if (header->rdh_ttl + STALE_TTL(header, rbtdb) <=
- now - RBTDB_VIRTUAL)
- {
- /*
- * We don't check if refcurrent(rbtnode) == 0 and try
- * to free like we do in cache_find(), because
- * refcurrent(rbtnode) must be non-zero. This is so
- * because 'node' is an argument to the function.
- */
- mark_header_ancient(rbtdb, header);
- if (log) {
- isc_log_write(dns_lctx, category, module, level,
- "overmem cache: ancient %s",
- printname);
- }
- } else if (force_expire) {
- set_ttl(rbtdb, header, 0);
- mark_header_ancient(rbtdb, header);
- } else if (isc_mem_isovermem(rbtdb->common.mctx) && log) {
- isc_log_write(dns_lctx, category, module, level,
- "overmem cache: saved %s", printname);
- }
- }
-
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
-
- return (ISC_R_SUCCESS);
-}
-
-static void
-overmem(dns_db_t *db, bool over) {
- /* This is an empty callback. See adb.c:water() */
-
- UNUSED(db);
- UNUSED(over);
-
- return;
-}
-
-static void
-printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtnode_t *rbtnode = node;
- bool first;
- uint32_t refs;
- isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
-
- REQUIRE(VALID_RBTDB(rbtdb));
-
- NODE_RDLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
-
- refs = isc_refcount_current(&rbtnode->references);
- fprintf(out, "node %p, %" PRIu32 " references, locknum = %u\n", rbtnode,
- refs, rbtnode->locknum);
- if (rbtnode->data != NULL) {
- dns_slabheader_t *current = NULL, *top_next = NULL;
-
- for (current = rbtnode->data; current != NULL;
- current = top_next)
- {
- top_next = current->next;
- first = true;
- fprintf(out, "\ttype %u", current->type);
- do {
- uint_least16_t attributes = atomic_load_acquire(
- ¤t->attributes);
- if (!first) {
- fprintf(out, "\t");
- }
- first = false;
- fprintf(out,
- "\tserial = %lu, ttl = %u, "
- "trust = %u, attributes = %" PRIuLEAST16
- ", "
- "resign = %u\n",
- (unsigned long)current->serial,
- current->rdh_ttl, current->trust,
- attributes,
- (current->resign << 1) |
- current->resign_lsb);
- current = current->down;
- } while (current != NULL);
- }
- } else {
- fprintf(out, "(empty)\n");
- }
-
- NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
-}
-
-static isc_result_t
-createiterator(dns_db_t *db, unsigned int options,
- dns_dbiterator_t **iteratorp) {
+dns__rbtdb_createiterator(dns_db_t *db, unsigned int options,
+ dns_dbiterator_t **iteratorp) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
rbtdb_dbiterator_t *rbtdbiter = NULL;
INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
if (rbtversion == NULL) {
- currentversion(db, (dns_dbversion_t **)(void *)(&rbtversion));
+ dns__rbtdb_currentversion(
+ db, (dns_dbversion_t **)(void *)(&rbtversion));
close_version = true;
}
serial = rbtversion->serial;
NODE_UNLOCK(&rbtdb->node_locks[rbtnode->locknum].lock, &nlocktype);
if (close_version) {
- closeversion(db, (dns_dbversion_t **)(void *)(&rbtversion),
- false DNS__DB_FLARG_PASS);
+ dns__rbtdb_closeversion(
+ db, (dns_dbversion_t **)(void *)(&rbtversion),
+ false DNS__DB_FLARG_PASS);
}
if (found == NULL) {
}
static isc_result_t
-allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- unsigned int options, isc_stdtime_t now,
- dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
+dns__rbtdb_allrdatasets(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, unsigned int options,
+ isc_stdtime_t now,
+ dns_rdatasetiter_t **iteratorp DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_rbtdb_version_t *rbtversion = version;
if ((db->attributes & DNS_DBATTR_CACHE) == 0) {
now = 0;
if (rbtversion == NULL) {
- currentversion(
+ dns__rbtdb_currentversion(
db, (dns_dbversion_t **)(void *)(&rbtversion));
} else {
INSIST(rbtversion->rbtdb == rbtdb);
}
static isc_result_t
-addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- isc_stdtime_t now, dns_rdataset_t *rdataset, unsigned int options,
- dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
+dns__rbtdb_addrdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, isc_stdtime_t now,
+ dns_rdataset_t *rdataset, unsigned int options,
+ dns_rdataset_t *addedrdataset DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_rbtdb_version_t *rbtversion = version;
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until closeversion() is called.
+ * this is deferred until dns__rbtdb_closeversion() is called.
*/
if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
iszonesecure(db, version, rbtdb->origin_node);
}
static isc_result_t
-subtractrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- dns_rdataset_t *rdataset, unsigned int options,
- dns_rdataset_t *newrdataset DNS__DB_FLARG) {
+dns__rbtdb_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, dns_rdataset_t *rdataset,
+ unsigned int options,
+ dns_rdataset_t *newrdataset DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_rbtdb_version_t *rbtversion = version;
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until closeversion() is called.
+ * this is deferred until dns__rbtdb_closeversion() is called.
*/
if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
}
static isc_result_t
-deleterdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- dns_rdatatype_t type, dns_rdatatype_t covers DNS__DB_FLARG) {
+dns__rbtdb_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
+ dns_dbversion_t *version, dns_rdatatype_t type,
+ dns_rdatatype_t covers DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *rbtnode = (dns_rbtnode_t *)node;
dns_rbtdb_version_t *rbtversion = version;
/*
* Update the zone's secure status. If version is non-NULL
- * this is deferred until closeversion() is called.
+ * this is deferred until dns__rbtdb_closeversion() is called.
*/
if (result == ISC_R_SUCCESS && version == NULL && !IS_CACHE(rbtdb)) {
RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
return (ISC_R_SUCCESS);
}
-static isc_result_t
-dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
- dns_masterformat_t masterformat) {
- dns_rbtdb_t *rbtdb = NULL;
- dns_rbtdb_version_t *rbtversion = version;
-
- rbtdb = (dns_rbtdb_t *)db;
-
- REQUIRE(VALID_RBTDB(rbtdb));
- INSIST(rbtversion == NULL || rbtversion->rbtdb == rbtdb);
-
- return (dns_master_dump(rbtdb->common.mctx, db, version,
- &dns_master_style_default, filename,
- masterformat, NULL));
-}
-
static void
delete_callback(void *data, void *arg) {
dns_rbtdb_t *rbtdb = arg;
return (secure);
}
-static bool
-isdnssec(dns_db_t *db) {
- dns_rbtdb_t *rbtdb = NULL;
- bool dnssec;
-
- rbtdb = (dns_rbtdb_t *)db;
-
- REQUIRE(VALID_RBTDB(rbtdb));
-
- RBTDB_LOCK(&rbtdb->lock, isc_rwlocktype_read);
- dnssec = rbtdb->current_version->secure;
- RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_read);
-
- return (dnssec);
-}
-
static unsigned int
-nodecount(dns_db_t *db, dns_dbtree_t tree) {
+dns__rbtdb_nodecount(dns_db_t *db, dns_dbtree_t tree) {
dns_rbtdb_t *rbtdb = NULL;
unsigned int count;
isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
}
static void
-setloop(dns_db_t *db, isc_loop_t *loop) {
+dns__rbtdb_setloop(dns_db_t *db, isc_loop_t *loop) {
dns_rbtdb_t *rbtdb = NULL;
rbtdb = (dns_rbtdb_t *)db;
}
static isc_result_t
-getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
+dns__rbtdb_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep DNS__DB_FLARG) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
dns_rbtnode_t *onode = NULL;
isc_result_t result = ISC_R_SUCCESS;
return (result);
}
-static void
-resigned(dns_db_t *db, dns_rdataset_t *rdataset,
- dns_dbversion_t *version DNS__DB_FLARG) {
- dns_rbtdb_version_t *rbtversion = (dns_rbtdb_version_t *)version;
- dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
- dns_rbtnode_t *node = NULL;
- dns_slabheader_t *header = NULL;
- isc_rwlocktype_t tlocktype = isc_rwlocktype_none;
- isc_rwlocktype_t nlocktype = isc_rwlocktype_none;
-
- REQUIRE(VALID_RBTDB(rbtdb));
- REQUIRE(rdataset != NULL);
- REQUIRE(rdataset->methods == &rdataset_methods);
- REQUIRE(rbtdb->future_version == rbtversion);
- REQUIRE(rbtversion != NULL);
- REQUIRE(rbtversion->writer);
- REQUIRE(rbtversion->rbtdb == rbtdb);
-
- INSIST(rdataset->slab.node != NULL);
- INSIST(rdataset->slab.raw != NULL);
-
- node = (dns_rbtnode_t *)rdataset->slab.node;
- header = dns_slabheader_fromrdataset(rdataset);
-
- if (header->heap_index == 0) {
- return;
- }
-
- TREE_WRLOCK(&rbtdb->tree_lock, &tlocktype);
- NODE_WRLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
- /*
- * Delete from heap and save to re-signed list so that it can
- * be restored if we backout of this change.
- */
- resign_delete(rbtdb, rbtversion, header DNS__DB_FLARG_PASS);
- NODE_UNLOCK(&rbtdb->node_locks[node->locknum].lock, &nlocktype);
- TREE_UNLOCK(&rbtdb->tree_lock, &tlocktype);
-}
-
static isc_result_t
setcachestats(dns_db_t *db, isc_stats_t *stats) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
REQUIRE(IS_CACHE(rbtdb));
/* currently no bounds checking. 0 means disable. */
- rbtdb->serve_stale_ttl = ttl;
+ rbtdb->common.serve_stale_ttl = ttl;
return (ISC_R_SUCCESS);
}
REQUIRE(VALID_RBTDB(rbtdb));
REQUIRE(IS_CACHE(rbtdb));
- *ttl = rbtdb->serve_stale_ttl;
+ *ttl = rbtdb->common.serve_stale_ttl;
return (ISC_R_SUCCESS);
}
}
static dns_dbmethods_t zone_methods = {
- .destroy = destroy,
+ .destroy = dns__rbtdb_destroy,
.beginload = beginload,
.endload = endload,
- .dump = dump,
- .currentversion = currentversion,
- .newversion = newversion,
- .attachversion = attachversion,
- .closeversion = closeversion,
- .findnode = findnode,
+ .currentversion = dns__rbtdb_currentversion,
+ .newversion = dns__rbtdb_newversion,
+ .attachversion = dns__rbtdb_attachversion,
+ .closeversion = dns__rbtdb_closeversion,
+ .findnode = dns__rbtdb_findnode,
.find = zone_find,
- .attachnode = attachnode,
- .detachnode = detachnode,
- .expirenode = expirenode,
- .printnode = printnode,
- .createiterator = createiterator,
+ .attachnode = dns__rbtdb_attachnode,
+ .detachnode = dns__rbtdb_detachnode,
+ .createiterator = dns__rbtdb_createiterator,
.findrdataset = zone_findrdataset,
- .allrdatasets = allrdatasets,
- .addrdataset = addrdataset,
- .subtractrdataset = subtractrdataset,
- .deleterdataset = deleterdataset,
+ .allrdatasets = dns__rbtdb_allrdatasets,
+ .addrdataset = dns__rbtdb_addrdataset,
+ .subtractrdataset = dns__rbtdb_subtractrdataset,
+ .deleterdataset = dns__rbtdb_deleterdataset,
.issecure = issecure,
- .nodecount = nodecount,
- .overmem = overmem,
- .setloop = setloop,
- .getoriginnode = getoriginnode,
+ .nodecount = dns__rbtdb_nodecount,
+ .setloop = dns__rbtdb_setloop,
+ .getoriginnode = dns__rbtdb_getoriginnode,
.getnsec3parameters = getnsec3parameters,
.findnsec3node = findnsec3node,
.setsigningtime = setsigningtime,
.getsigningtime = getsigningtime,
- .resigned = resigned,
- .isdnssec = isdnssec,
- .hashsize = hashsize,
- .nodefullname = nodefullname,
.getsize = getsize,
.setgluecachestats = setgluecachestats
};
static dns_dbmethods_t cache_methods = {
- .destroy = destroy,
- .beginload = beginload,
- .endload = endload,
- .dump = dump,
- .currentversion = currentversion,
- .newversion = newversion,
- .attachversion = attachversion,
- .closeversion = closeversion,
- .findnode = findnode,
+ .destroy = dns__rbtdb_destroy,
+ .currentversion = dns__rbtdb_currentversion,
+ .newversion = dns__rbtdb_newversion,
+ .attachversion = dns__rbtdb_attachversion,
+ .closeversion = dns__rbtdb_closeversion,
+ .findnode = dns__rbtdb_findnode,
.find = cache_find,
.findzonecut = cache_findzonecut,
- .attachnode = attachnode,
- .detachnode = detachnode,
- .expirenode = expirenode,
- .printnode = printnode,
- .createiterator = createiterator,
+ .attachnode = dns__rbtdb_attachnode,
+ .detachnode = dns__rbtdb_detachnode,
+ .createiterator = dns__rbtdb_createiterator,
.findrdataset = cache_findrdataset,
- .allrdatasets = allrdatasets,
- .addrdataset = addrdataset,
- .subtractrdataset = subtractrdataset,
- .deleterdataset = deleterdataset,
- .issecure = issecure,
- .nodecount = nodecount,
- .overmem = overmem,
- .setloop = setloop,
- .getoriginnode = getoriginnode,
- .isdnssec = isdnssec,
+ .allrdatasets = dns__rbtdb_allrdatasets,
+ .addrdataset = dns__rbtdb_addrdataset,
+ .subtractrdataset = dns__rbtdb_subtractrdataset,
+ .deleterdataset = dns__rbtdb_deleterdataset,
+ .nodecount = dns__rbtdb_nodecount,
+ .setloop = dns__rbtdb_setloop,
+ .getoriginnode = dns__rbtdb_getoriginnode,
.getrrsetstats = getrrsetstats,
.setcachestats = setcachestats,
.hashsize = hashsize,
- .nodefullname = nodefullname,
.setservestalettl = setservestalettl,
.getservestalettl = getservestalettl,
.setservestalerefresh = setservestalerefresh,
* we need to know if the node has the origin name of the zone.
* In loading_addrdataset() we could simply compare the new name
* to the origin name, but this is expensive. Also, we don't know the
- * node name in addrdataset(), so we need another way of knowing the
- * zone's top.
+ * node name in dns__rbtdb_addrdataset(), so we need another way of
+ * knowing the zone's top.
*
* We now explicitly create a node for the zone's origin, and then
* we simply remember the node's address. This is safe, because
rbtiterator = (rbtdb_rdatasetiter_t *)(*iteratorp);
if (rbtiterator->common.version != NULL) {
- closeversion(rbtiterator->common.db,
- &rbtiterator->common.version,
- false DNS__DB_FLARG_PASS);
+ dns__rbtdb_closeversion(rbtiterator->common.db,
+ &rbtiterator->common.version,
+ false DNS__DB_FLARG_PASS);
}
dns__db_detachnode(rbtiterator->common.db,
&rbtiterator->common.node DNS__DB_FLARG_PASS);
}
}
-static isc_result_t
-expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
- UNUSED(db);
- UNUSED(node);
- UNUSED(now);
- UNREACHABLE();
-}
-
-static void
-printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
- UNUSED(db);
- UNUSED(node);
- UNUSED(out);
- return;
-}
-
static isc_result_t
createiterator(dns_db_t *db, unsigned int options,
dns_dbiterator_t **iteratorp) {
return (0);
}
-static void
-overmem(dns_db_t *db, bool over) {
- UNUSED(db);
- UNUSED(over);
-}
-
static void
setloop(dns_db_t *db, isc_loop_t *loop) {
UNUSED(db);
.find = find,
.attachnode = attachnode,
.detachnode = detachnode,
- .expirenode = expirenode,
- .printnode = printnode,
.createiterator = createiterator,
.findrdataset = findrdataset,
.allrdatasets = allrdatasets,
.deleterdataset = deleterdataset,
.issecure = issecure,
.nodecount = nodecount,
- .overmem = overmem,
.setloop = setloop,
.getoriginnode = getoriginnode,
.findnodeext = findnodeext,
static isc_result_t
checkandaddsoa(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
- dns_rdataset_t *rdataset, uint32_t oldserial) {
+ dns_name_t *name, dns_rdataset_t *rdataset, uint32_t oldserial) {
dns_rdata_soa_t soa;
dns_rdata_t rdata = DNS_RDATA_INIT;
dns_rdatalist_t temprdatalist;
isc_buffer_t b;
isc_result_t result;
unsigned char buf[DNS_SOA_BUFFERSIZE];
- dns_fixedname_t fixed;
- dns_name_t *name;
result = dns_rdataset_first(rdataset);
RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdataset_init(&temprdataset);
dns_rdatalist_tordataset(&temprdatalist, &temprdataset);
- name = dns_fixedname_initname(&fixed);
- result = dns_db_nodefullname(db, node, name);
- RUNTIME_CHECK(result == ISC_R_SUCCESS);
dns_rdataset_getownercase(rdataset, name);
dns_rdataset_setownercase(&temprdataset, name);
return (dns_db_addrdataset(db, node, version, 0, &temprdataset, 0,
continue;
}
if (rdataset.type == dns_rdatatype_soa && oldserial != NULL) {
- result = checkandaddsoa(db, node, version, &rdataset,
- *oldserial);
+ result = checkandaddsoa(db, node, version, name,
+ &rdataset, *oldserial);
} else {
result = dns_db_addrdataset(db, node, version, 0,
&rdataset, 0, NULL);
#define isc__rwlock_unlock(rwl, type) \
{ \
int _ret = pthread_rwlock_unlock(rwl); \
+ UNUSED(type); \
PTHREADS_RUNTIME_CHECK(pthread_rwlock_rwlock, _ret); \
}
dns_db_detach(&db);
/* DB has cache semantics */
- result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_cache,
+ result = dns_db_create(mctx, "rbt", dns_rootname, dns_dbtype_zone,
dns_rdataclass_in, 0, NULL, &db);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_load(db, TESTS_DIR "/testdata/db/data.db",
dns_masterformat_text, 0);
assert_int_equal(result, ISC_R_SUCCESS);
- assert_true(dns_db_iscache(db));
- assert_false(dns_db_iszone(db));
+ assert_false(dns_db_iscache(db));
+ assert_true(dns_db_iszone(db));
dns_db_detach(&db);
}
dns_db_t *db = NULL;
dns_dbiterator_t *iter = NULL;
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
name = dns_fixedname_initname(&f);
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
ISC_RUN_TEST_IMPL(walk) {
UNUSED(state);
- test_walk(TESTS_DIR "/testdata/dbiterator/zone1.data", 12);
+ test_walk(TESTS_DIR "/testdata/dbiterator/zone1.data", 13);
}
ISC_RUN_TEST_IMPL(walk_nsec3) {
name = dns_fixedname_initname(&f);
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
name = dns_fixedname_initname(&f1);
seekname = dns_fixedname_initname(&f2);
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
ISC_RUN_TEST_IMPL(seek_node) {
UNUSED(state);
- test_seek_node(TESTS_DIR "/testdata/dbiterator/zone1.data", 9);
+ test_seek_node(TESTS_DIR "/testdata/dbiterator/zone1.data", 10);
}
ISC_RUN_TEST_IMPL(seek_node_nsec3) {
seekname = dns_fixedname_initname(&f1);
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
seekname = dns_fixedname_initname(&f1);
- result = dns_test_loaddb(&db, dns_dbtype_cache, TEST_ORIGIN, filename);
+ result = dns_test_loaddb(&db, dns_dbtype_zone, TEST_ORIGIN, filename);
assert_int_equal(result, ISC_R_SUCCESS);
result = dns_db_createiterator(db, 0, &iter);
assert_null(node);
}
-/*
- * Check dns_db_dump() passes with matching db and version, and
- * asserts with mis-matching db and version.
- */
-ISC_RUN_TEST_IMPL(dump) {
- isc_result_t res;
- FILE *f = NULL;
-
- UNUSED(state);
-
- res = isc_file_openunique(tempname, &f);
- fclose(f);
- assert_int_equal(res, ISC_R_SUCCESS);
-
- res = dns_db_dump(db1, v1, tempname);
- assert_int_equal(res, ISC_R_SUCCESS);
-
- check_assertion(dns_db_dump(db1, v2, tempname));
-}
-
/*
* Check dns_db_addrdataset() passes with matching db and version, and
* asserts with mis-matching db and version.
db1, v2, &hash, &flags, &iterations, salt, &salt_length));
}
-/*
- * Check dns_db_resigned() passes with matching db and version, and
- * asserts with mis-matching db and version.
- */
-ISC_RUN_TEST_IMPL(resigned) {
- isc_result_t res;
- dns_rdataset_t rdataset, added;
- dns_dbnode_t *node = NULL;
- dns_rdatalist_t rdatalist;
- dns_rdata_rrsig_t rrsig;
- dns_rdata_t rdata = DNS_RDATA_INIT;
- isc_buffer_t b;
- unsigned char buf[1024];
-
- UNUSED(state);
-
- /*
- * Create a dummy RRSIG record and set a resigning time.
- */
- dns_rdataset_init(&added);
- dns_rdataset_init(&rdataset);
- dns_rdatalist_init(&rdatalist);
- isc_buffer_init(&b, buf, sizeof(buf));
-
- DNS_RDATACOMMON_INIT(&rrsig, dns_rdatatype_rrsig, dns_rdataclass_in);
- rrsig.covered = dns_rdatatype_a;
- rrsig.algorithm = 100;
- rrsig.labels = 0;
- rrsig.originalttl = 0;
- rrsig.timeexpire = 3600;
- rrsig.timesigned = 0;
- rrsig.keyid = 0;
- dns_name_init(&rrsig.signer, NULL);
- dns_name_clone(dns_rootname, &rrsig.signer);
- rrsig.siglen = 0;
- rrsig.signature = NULL;
-
- res = dns_rdata_fromstruct(&rdata, dns_rdataclass_in,
- dns_rdatatype_rrsig, &rrsig, &b);
- assert_int_equal(res, ISC_R_SUCCESS);
-
- rdatalist.rdclass = dns_rdataclass_in;
- rdatalist.type = dns_rdatatype_rrsig;
- ISC_LIST_APPEND(rdatalist.rdata, &rdata, link);
-
- dns_rdatalist_tordataset(&rdatalist, &rdataset);
-
- rdataset.attributes |= DNS_RDATASETATTR_RESIGN;
- rdataset.resign = 7200;
-
- res = dns_db_findnode(db1, dns_rootname, false, &node);
- assert_int_equal(res, ISC_R_SUCCESS);
-
- res = dns_db_addrdataset(db1, node, v1, 0, &rdataset, 0, &added);
- assert_int_equal(res, ISC_R_SUCCESS);
-
- dns_db_detachnode(db1, &node);
- assert_null(node);
-
- check_assertion(dns_db_resigned(db1, &added, v2));
-
- dns_db_resigned(db1, &added, v1);
-
- dns_rdataset_disassociate(&added);
-}
-
ISC_TEST_LIST_START
-ISC_TEST_ENTRY_CUSTOM(dump, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(find, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(allrdatasets, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(findrdataset, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(subtract, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(addrdataset, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(getnsec3parameters, setup_test, teardown_test)
-ISC_TEST_ENTRY_CUSTOM(resigned, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(attachversion, setup_test, teardown_test)
ISC_TEST_ENTRY_CUSTOM(closeversion, setup_test, teardown_test)
ISC_TEST_LIST_END
projects / thirdparty / bind9.git / commitdiff
