2 * Copyright (C) 2004, 2005, 2007-2009 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2001, 2003 Internet Software Consortium.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10 * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11 * AND FITNESS. IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12 * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13 * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14 * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15 * PERFORMANCE OF THIS SOFTWARE.
18 /* $Id: db.c,v 1.88.50.2 2009/06/23 00:19:34 tbox Exp $ */
28 #include <isc/buffer.h>
31 #include <isc/rwlock.h>
32 #include <isc/string.h>
35 #include <dns/callbacks.h>
38 #include <dns/master.h>
39 #include <dns/rdata.h>
40 #include <dns/rdataset.h>
41 #include <dns/result.h>
47 struct dns_dbimplementation {
49 dns_dbcreatefunc_t create;
52 ISC_LINK(dns_dbimplementation_t) link;
56 *** Supported DB Implementations Registry
60 * Built in database implementations are registered here.
66 static ISC_LIST(dns_dbimplementation_t) implementations;
67 static isc_rwlock_t implock;
68 static isc_once_t once = ISC_ONCE_INIT;
70 static dns_dbimplementation_t rbtimp;
71 static dns_dbimplementation_t rbt64imp;
75 RUNTIME_CHECK(isc_rwlock_init(&implock, 0, 0) == ISC_R_SUCCESS);
78 rbtimp.create = dns_rbtdb_create;
80 rbtimp.driverarg = NULL;
81 ISC_LINK_INIT(&rbtimp, link);
83 rbt64imp.name = "rbt64";
84 rbt64imp.create = dns_rbtdb64_create;
86 rbt64imp.driverarg = NULL;
87 ISC_LINK_INIT(&rbt64imp, link);
89 ISC_LIST_INIT(implementations);
90 ISC_LIST_APPEND(implementations, &rbtimp, link);
91 ISC_LIST_APPEND(implementations, &rbt64imp, link);
94 static inline dns_dbimplementation_t *
95 impfind(const char *name) {
96 dns_dbimplementation_t *imp;
98 for (imp = ISC_LIST_HEAD(implementations);
100 imp = ISC_LIST_NEXT(imp, link))
101 if (strcasecmp(name, imp->name) == 0)
112 dns_db_create(isc_mem_t *mctx, const char *db_type, dns_name_t *origin,
113 dns_dbtype_t type, dns_rdataclass_t rdclass,
114 unsigned int argc, char *argv[], dns_db_t **dbp)
116 dns_dbimplementation_t *impinfo;
118 RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
121 * Create a new database using implementation 'db_type'.
124 REQUIRE(dbp != NULL && *dbp == NULL);
125 REQUIRE(dns_name_isabsolute(origin));
127 RWLOCK(&implock, isc_rwlocktype_read);
128 impinfo = impfind(db_type);
129 if (impinfo != NULL) {
131 result = ((impinfo->create)(mctx, origin, type,
133 impinfo->driverarg, dbp));
134 RWUNLOCK(&implock, isc_rwlocktype_read);
138 RWUNLOCK(&implock, isc_rwlocktype_read);
140 isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
141 DNS_LOGMODULE_DB, ISC_LOG_ERROR,
142 "unsupported database type '%s'", db_type);
144 return (ISC_R_NOTFOUND);
148 dns_db_attach(dns_db_t *source, dns_db_t **targetp) {
151 * Attach *targetp to source.
154 REQUIRE(DNS_DB_VALID(source));
155 REQUIRE(targetp != NULL && *targetp == NULL);
157 (source->methods->attach)(source, targetp);
159 ENSURE(*targetp == source);
163 dns_db_detach(dns_db_t **dbp) {
166 * Detach *dbp from its database.
169 REQUIRE(dbp != NULL);
170 REQUIRE(DNS_DB_VALID(*dbp));
172 ((*dbp)->methods->detach)(dbp);
174 ENSURE(*dbp == NULL);
178 dns_db_ondestroy(dns_db_t *db, isc_task_t *task, isc_event_t **eventp)
180 REQUIRE(DNS_DB_VALID(db));
182 return (isc_ondestroy_register(&db->ondest, task, eventp));
187 dns_db_iscache(dns_db_t *db) {
190 * Does 'db' have cache semantics?
193 REQUIRE(DNS_DB_VALID(db));
195 if ((db->attributes & DNS_DBATTR_CACHE) != 0)
202 dns_db_iszone(dns_db_t *db) {
205 * Does 'db' have zone semantics?
208 REQUIRE(DNS_DB_VALID(db));
210 if ((db->attributes & (DNS_DBATTR_CACHE|DNS_DBATTR_STUB)) == 0)
217 dns_db_isstub(dns_db_t *db) {
220 * Does 'db' have stub semantics?
223 REQUIRE(DNS_DB_VALID(db));
225 if ((db->attributes & DNS_DBATTR_STUB) != 0)
232 dns_db_isdnssec(dns_db_t *db) {
235 * Is 'db' secure or partially secure?
238 REQUIRE(DNS_DB_VALID(db));
239 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
241 if (db->methods->isdnssec != NULL)
242 return ((db->methods->isdnssec)(db));
243 return ((db->methods->issecure)(db));
247 dns_db_issecure(dns_db_t *db) {
253 REQUIRE(DNS_DB_VALID(db));
254 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
256 return ((db->methods->issecure)(db));
260 dns_db_ispersistent(dns_db_t *db) {
263 * Is 'db' persistent?
266 REQUIRE(DNS_DB_VALID(db));
268 return ((db->methods->ispersistent)(db));
272 dns_db_origin(dns_db_t *db) {
274 * The origin of the database.
277 REQUIRE(DNS_DB_VALID(db));
279 return (&db->origin);
283 dns_db_class(dns_db_t *db) {
285 * The class of the database.
288 REQUIRE(DNS_DB_VALID(db));
290 return (db->rdclass);
294 dns_db_beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp,
295 dns_dbload_t **dbloadp) {
297 * Begin loading 'db'.
300 REQUIRE(DNS_DB_VALID(db));
301 REQUIRE(addp != NULL && *addp == NULL);
302 REQUIRE(dbloadp != NULL && *dbloadp == NULL);
304 return ((db->methods->beginload)(db, addp, dbloadp));
308 dns_db_endload(dns_db_t *db, dns_dbload_t **dbloadp) {
310 * Finish loading 'db'.
313 REQUIRE(DNS_DB_VALID(db));
314 REQUIRE(dbloadp != NULL && *dbloadp != NULL);
316 return ((db->methods->endload)(db, dbloadp));
320 dns_db_load(dns_db_t *db, const char *filename) {
321 return (dns_db_load2(db, filename, dns_masterformat_text));
325 dns_db_load2(dns_db_t *db, const char *filename, dns_masterformat_t format) {
326 isc_result_t result, eresult;
327 dns_rdatacallbacks_t callbacks;
328 unsigned int options = 0;
331 * Load master file 'filename' into 'db'.
334 REQUIRE(DNS_DB_VALID(db));
336 if ((db->attributes & DNS_DBATTR_CACHE) != 0)
337 options |= DNS_MASTER_AGETTL;
339 dns_rdatacallbacks_init(&callbacks);
341 result = dns_db_beginload(db, &callbacks.add, &callbacks.add_private);
342 if (result != ISC_R_SUCCESS)
344 result = dns_master_loadfile2(filename, &db->origin, &db->origin,
345 db->rdclass, options,
346 &callbacks, db->mctx, format);
347 eresult = dns_db_endload(db, &callbacks.add_private);
349 * We always call dns_db_endload(), but we only want to return its
350 * result if dns_master_loadfile() succeeded. If dns_master_loadfile()
351 * failed, we want to return the result code it gave us.
353 if (eresult != ISC_R_SUCCESS &&
354 (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE))
361 dns_db_dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
362 return ((db->methods->dump)(db, version, filename,
363 dns_masterformat_text));
367 dns_db_dump2(dns_db_t *db, dns_dbversion_t *version, const char *filename,
368 dns_masterformat_t masterformat) {
370 * Dump 'db' into master file 'filename' in the 'masterformat' format.
371 * XXXJT: is it okay to modify the interface to the existing "dump"
375 REQUIRE(DNS_DB_VALID(db));
377 return ((db->methods->dump)(db, version, filename, masterformat));
385 dns_db_currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
388 * Open the current version for reading.
391 REQUIRE(DNS_DB_VALID(db));
392 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
393 REQUIRE(versionp != NULL && *versionp == NULL);
395 (db->methods->currentversion)(db, versionp);
399 dns_db_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
402 * Open a new version for reading and writing.
405 REQUIRE(DNS_DB_VALID(db));
406 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
407 REQUIRE(versionp != NULL && *versionp == NULL);
409 return ((db->methods->newversion)(db, versionp));
413 dns_db_attachversion(dns_db_t *db, dns_dbversion_t *source,
414 dns_dbversion_t **targetp)
417 * Attach '*targetp' to 'source'.
420 REQUIRE(DNS_DB_VALID(db));
421 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
422 REQUIRE(source != NULL);
423 REQUIRE(targetp != NULL && *targetp == NULL);
425 (db->methods->attachversion)(db, source, targetp);
427 ENSURE(*targetp != NULL);
431 dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
432 isc_boolean_t commit)
436 * Close version '*versionp'.
439 REQUIRE(DNS_DB_VALID(db));
440 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
441 REQUIRE(versionp != NULL && *versionp != NULL);
443 (db->methods->closeversion)(db, versionp, commit);
445 ENSURE(*versionp == NULL);
453 dns_db_findnode(dns_db_t *db, dns_name_t *name,
454 isc_boolean_t create, dns_dbnode_t **nodep)
458 * Find the node with name 'name'.
461 REQUIRE(DNS_DB_VALID(db));
462 REQUIRE(nodep != NULL && *nodep == NULL);
464 return ((db->methods->findnode)(db, name, create, nodep));
468 dns_db_findnsec3node(dns_db_t *db, dns_name_t *name,
469 isc_boolean_t create, dns_dbnode_t **nodep)
473 * Find the node with name 'name'.
476 REQUIRE(DNS_DB_VALID(db));
477 REQUIRE(nodep != NULL && *nodep == NULL);
479 return ((db->methods->findnsec3node)(db, name, create, nodep));
483 dns_db_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
484 dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
485 dns_dbnode_t **nodep, dns_name_t *foundname,
486 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
490 * Find the best match for 'name' and 'type' in version 'version'
494 REQUIRE(DNS_DB_VALID(db));
495 REQUIRE(type != dns_rdatatype_rrsig);
496 REQUIRE(nodep == NULL || (nodep != NULL && *nodep == NULL));
497 REQUIRE(dns_name_hasbuffer(foundname));
498 REQUIRE(rdataset == NULL ||
499 (DNS_RDATASET_VALID(rdataset) &&
500 ! dns_rdataset_isassociated(rdataset)));
501 REQUIRE(sigrdataset == NULL ||
502 (DNS_RDATASET_VALID(sigrdataset) &&
503 ! dns_rdataset_isassociated(sigrdataset)));
505 return ((db->methods->find)(db, name, version, type, options, now,
506 nodep, foundname, rdataset, sigrdataset));
510 dns_db_findzonecut(dns_db_t *db, dns_name_t *name,
511 unsigned int options, isc_stdtime_t now,
512 dns_dbnode_t **nodep, dns_name_t *foundname,
513 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
516 * Find the deepest known zonecut which encloses 'name' in 'db'.
519 REQUIRE(DNS_DB_VALID(db));
520 REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
521 REQUIRE(nodep == NULL || (nodep != NULL && *nodep == NULL));
522 REQUIRE(dns_name_hasbuffer(foundname));
523 REQUIRE(sigrdataset == NULL ||
524 (DNS_RDATASET_VALID(sigrdataset) &&
525 ! dns_rdataset_isassociated(sigrdataset)));
527 return ((db->methods->findzonecut)(db, name, options, now, nodep,
528 foundname, rdataset, sigrdataset));
532 dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
535 * Attach *targetp to source.
538 REQUIRE(DNS_DB_VALID(db));
539 REQUIRE(source != NULL);
540 REQUIRE(targetp != NULL && *targetp == NULL);
542 (db->methods->attachnode)(db, source, targetp);
546 dns_db_detachnode(dns_db_t *db, dns_dbnode_t **nodep) {
549 * Detach *nodep from its node.
552 REQUIRE(DNS_DB_VALID(db));
553 REQUIRE(nodep != NULL && *nodep != NULL);
555 (db->methods->detachnode)(db, nodep);
557 ENSURE(*nodep == NULL);
561 dns_db_transfernode(dns_db_t *db, dns_dbnode_t **sourcep,
562 dns_dbnode_t **targetp)
564 REQUIRE(DNS_DB_VALID(db));
565 REQUIRE(targetp != NULL && *targetp == NULL);
567 * This doesn't check the implementation magic. If we find that
568 * we need such checks in future then this will be done in the
571 REQUIRE(sourcep != NULL && *sourcep != NULL);
575 if (db->methods->transfernode == NULL) {
579 (db->methods->transfernode)(db, sourcep, targetp);
581 ENSURE(*sourcep == NULL);
585 dns_db_expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
588 * Mark as stale all records at 'node' which expire at or before 'now'.
591 REQUIRE(DNS_DB_VALID(db));
592 REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
593 REQUIRE(node != NULL);
595 return ((db->methods->expirenode)(db, node, now));
599 dns_db_printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
601 * Print a textual representation of the contents of the node to
605 REQUIRE(DNS_DB_VALID(db));
606 REQUIRE(node != NULL);
608 (db->methods->printnode)(db, node, out);
612 *** DB Iterator Creation
616 dns_db_createiterator(dns_db_t *db, unsigned int flags,
617 dns_dbiterator_t **iteratorp)
620 * Create an iterator for version 'version' of 'db'.
623 REQUIRE(DNS_DB_VALID(db));
624 REQUIRE(iteratorp != NULL && *iteratorp == NULL);
626 return (db->methods->createiterator(db, flags, iteratorp));
634 dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
635 dns_rdatatype_t type, dns_rdatatype_t covers,
636 isc_stdtime_t now, dns_rdataset_t *rdataset,
637 dns_rdataset_t *sigrdataset)
640 * Search for an rdataset of type 'type' at 'node' that are in version
641 * 'version' of 'db'. If found, make 'rdataset' refer to it.
644 REQUIRE(DNS_DB_VALID(db));
645 REQUIRE(node != NULL);
646 REQUIRE(DNS_RDATASET_VALID(rdataset));
647 REQUIRE(! dns_rdataset_isassociated(rdataset));
648 REQUIRE(covers == 0 || type == dns_rdatatype_rrsig);
649 REQUIRE(type != dns_rdatatype_any);
650 REQUIRE(sigrdataset == NULL ||
651 (DNS_RDATASET_VALID(sigrdataset) &&
652 ! dns_rdataset_isassociated(sigrdataset)));
654 return ((db->methods->findrdataset)(db, node, version, type, covers,
655 now, rdataset, sigrdataset));
659 dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
660 isc_stdtime_t now, dns_rdatasetiter_t **iteratorp)
663 * Make '*iteratorp' an rdataset iteratator for all rdatasets at
664 * 'node' in version 'version' of 'db'.
667 REQUIRE(DNS_DB_VALID(db));
668 REQUIRE(iteratorp != NULL && *iteratorp == NULL);
670 return ((db->methods->allrdatasets)(db, node, version, now,
675 dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
676 isc_stdtime_t now, dns_rdataset_t *rdataset,
677 unsigned int options, dns_rdataset_t *addedrdataset)
680 * Add 'rdataset' to 'node' in version 'version' of 'db'.
683 REQUIRE(DNS_DB_VALID(db));
684 REQUIRE(node != NULL);
685 REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL)||
686 ((db->attributes & DNS_DBATTR_CACHE) != 0 &&
687 version == NULL && (options & DNS_DBADD_MERGE) == 0));
688 REQUIRE((options & DNS_DBADD_EXACT) == 0 ||
689 (options & DNS_DBADD_MERGE) != 0);
690 REQUIRE(DNS_RDATASET_VALID(rdataset));
691 REQUIRE(dns_rdataset_isassociated(rdataset));
692 REQUIRE(rdataset->rdclass == db->rdclass);
693 REQUIRE(addedrdataset == NULL ||
694 (DNS_RDATASET_VALID(addedrdataset) &&
695 ! dns_rdataset_isassociated(addedrdataset)));
697 return ((db->methods->addrdataset)(db, node, version, now, rdataset,
698 options, addedrdataset));
702 dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
703 dns_dbversion_t *version, dns_rdataset_t *rdataset,
704 unsigned int options, dns_rdataset_t *newrdataset)
707 * Remove any rdata in 'rdataset' from 'node' in version 'version' of
711 REQUIRE(DNS_DB_VALID(db));
712 REQUIRE(node != NULL);
713 REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL);
714 REQUIRE(DNS_RDATASET_VALID(rdataset));
715 REQUIRE(dns_rdataset_isassociated(rdataset));
716 REQUIRE(rdataset->rdclass == db->rdclass);
717 REQUIRE(newrdataset == NULL ||
718 (DNS_RDATASET_VALID(newrdataset) &&
719 ! dns_rdataset_isassociated(newrdataset)));
721 return ((db->methods->subtractrdataset)(db, node, version, rdataset,
722 options, newrdataset));
726 dns_db_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
727 dns_dbversion_t *version, dns_rdatatype_t type,
728 dns_rdatatype_t covers)
731 * Make it so that no rdataset of type 'type' exists at 'node' in
732 * version version 'version' of 'db'.
735 REQUIRE(DNS_DB_VALID(db));
736 REQUIRE(node != NULL);
737 REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL)||
738 ((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL));
740 return ((db->methods->deleterdataset)(db, node, version,
745 dns_db_overmem(dns_db_t *db, isc_boolean_t overmem) {
747 REQUIRE(DNS_DB_VALID(db));
749 (db->methods->overmem)(db, overmem);
753 dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, isc_uint32_t *serialp)
756 dns_dbnode_t *node = NULL;
757 dns_rdataset_t rdataset;
758 dns_rdata_t rdata = DNS_RDATA_INIT;
761 REQUIRE(dns_db_iszone(db) || dns_db_isstub(db));
763 result = dns_db_findnode(db, dns_db_origin(db), ISC_FALSE, &node);
764 if (result != ISC_R_SUCCESS)
767 dns_rdataset_init(&rdataset);
768 result = dns_db_findrdataset(db, node, ver, dns_rdatatype_soa, 0,
769 (isc_stdtime_t)0, &rdataset, NULL);
770 if (result != ISC_R_SUCCESS)
773 result = dns_rdataset_first(&rdataset);
774 if (result != ISC_R_SUCCESS)
776 dns_rdataset_current(&rdataset, &rdata);
777 result = dns_rdataset_next(&rdataset);
778 INSIST(result == ISC_R_NOMORE);
780 INSIST(rdata.length > 20);
781 isc_buffer_init(&buffer, rdata.data, rdata.length);
782 isc_buffer_add(&buffer, rdata.length);
783 isc_buffer_forward(&buffer, rdata.length - 20);
784 *serialp = isc_buffer_getuint32(&buffer);
786 result = ISC_R_SUCCESS;
789 dns_rdataset_disassociate(&rdataset);
792 dns_db_detachnode(db, &node);
797 dns_db_nodecount(dns_db_t *db) {
798 REQUIRE(DNS_DB_VALID(db));
800 return ((db->methods->nodecount)(db));
804 dns_db_settask(dns_db_t *db, isc_task_t *task) {
805 REQUIRE(DNS_DB_VALID(db));
807 (db->methods->settask)(db, task);
811 dns_db_register(const char *name, dns_dbcreatefunc_t create, void *driverarg,
812 isc_mem_t *mctx, dns_dbimplementation_t **dbimp)
814 dns_dbimplementation_t *imp;
816 REQUIRE(name != NULL);
817 REQUIRE(dbimp != NULL && *dbimp == NULL);
819 RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
821 RWLOCK(&implock, isc_rwlocktype_write);
824 RWUNLOCK(&implock, isc_rwlocktype_write);
825 return (ISC_R_EXISTS);
828 imp = isc_mem_get(mctx, sizeof(dns_dbimplementation_t));
830 RWUNLOCK(&implock, isc_rwlocktype_write);
831 return (ISC_R_NOMEMORY);
834 imp->create = create;
836 imp->driverarg = driverarg;
837 isc_mem_attach(mctx, &imp->mctx);
838 ISC_LINK_INIT(imp, link);
839 ISC_LIST_APPEND(implementations, imp, link);
840 RWUNLOCK(&implock, isc_rwlocktype_write);
844 return (ISC_R_SUCCESS);
848 dns_db_unregister(dns_dbimplementation_t **dbimp) {
849 dns_dbimplementation_t *imp;
852 REQUIRE(dbimp != NULL && *dbimp != NULL);
854 RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
858 RWLOCK(&implock, isc_rwlocktype_write);
859 ISC_LIST_UNLINK(implementations, imp, link);
861 isc_mem_put(mctx, imp, sizeof(dns_dbimplementation_t));
862 isc_mem_detach(&mctx);
863 RWUNLOCK(&implock, isc_rwlocktype_write);
864 ENSURE(*dbimp == NULL);
868 dns_db_getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) {
869 REQUIRE(DNS_DB_VALID(db));
870 REQUIRE(dns_db_iszone(db) == ISC_TRUE);
871 REQUIRE(nodep != NULL && *nodep == NULL);
873 if (db->methods->getoriginnode != NULL)
874 return ((db->methods->getoriginnode)(db, nodep));
876 return (ISC_R_NOTFOUND);
880 dns_db_getrrsetstats(dns_db_t *db) {
881 REQUIRE(DNS_DB_VALID(db));
883 if (db->methods->getrrsetstats != NULL)
884 return ((db->methods->getrrsetstats)(db));
890 dns_db_getnsec3parameters(dns_db_t *db, dns_dbversion_t *version,
891 dns_hash_t *hash, isc_uint8_t *flags,
892 isc_uint16_t *iterations,
893 unsigned char *salt, size_t *salt_length)
895 REQUIRE(DNS_DB_VALID(db));
896 REQUIRE(dns_db_iszone(db) == ISC_TRUE);
898 if (db->methods->getnsec3parameters != NULL)
899 return ((db->methods->getnsec3parameters)(db, version, hash,
903 return (ISC_R_NOTFOUND);
907 dns_db_setsigningtime(dns_db_t *db, dns_rdataset_t *rdataset,
908 isc_stdtime_t resign)
910 if (db->methods->setsigningtime != NULL)
911 return ((db->methods->setsigningtime)(db, rdataset, resign));
912 return (ISC_R_NOTIMPLEMENTED);
916 dns_db_getsigningtime(dns_db_t *db, dns_rdataset_t *rdataset, dns_name_t *name)
918 if (db->methods->getsigningtime != NULL)
919 return ((db->methods->getsigningtime)(db, rdataset, name));
920 return (ISC_R_NOTFOUND);
924 dns_db_resigned(dns_db_t *db, dns_rdataset_t *rdataset, dns_dbversion_t *version)
926 if (db->methods->resigned != NULL)
927 (db->methods->resigned)(db, rdataset, version);