contrib/bind-9.2.4rc7/lib/dns/db.c

   1 /*
   2  * Copyright (C) 2004  Internet Systems Consortium, Inc. ("ISC")
   3  * Copyright (C) 1999-2001, 2003  Internet Software Consortium.
   4  *
   5  * Permission to use, copy, modify, and 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.
   8  *
   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.
  16  */
  17
  18 /* $Id: db.c,v 1.69.2.5 2004/03/09 06:11:00 marka Exp $ */
  19
  20 /***
  21  *** Imports
  22  ***/
  23
  24 #include <config.h>
  25
  26 #include <isc/buffer.h>
  27 #include <isc/mem.h>
  28 #include <isc/once.h>
  29 #include <isc/rwlock.h>
  30 #include <isc/string.h>
  31 #include <isc/util.h>
  32
  33 #include <dns/callbacks.h>
  34 #include <dns/db.h>
  35 #include <dns/log.h>
  36 #include <dns/master.h>
  37 #include <dns/rdata.h>
  38 #include <dns/rdataset.h>
  39 #include <dns/result.h>
  40
  41 /***
  42  *** Private Types
  43  ***/
  44
  45 struct dns_dbimplementation {
  46         const char *                            name;
  47         dns_dbcreatefunc_t                      create;
  48         isc_mem_t *                             mctx;
  49         void *                                  driverarg;
  50         ISC_LINK(dns_dbimplementation_t)        link;
  51 };
  52
  53 /***
  54  *** Supported DB Implementations Registry
  55  ***/
  56
  57 /*
  58  * Built in database implementations are registered here.
  59  */
  60
  61 #include "rbtdb.h"
  62 #include "rbtdb64.h"
  63
  64 static ISC_LIST(dns_dbimplementation_t) implementations;
  65 static isc_rwlock_t implock;
  66 static isc_once_t once = ISC_ONCE_INIT;
  67
  68 static dns_dbimplementation_t rbtimp;
  69 static dns_dbimplementation_t rbt64imp;
  70
  71 static void
  72 initialize(void) {
  73         RUNTIME_CHECK(isc_rwlock_init(&implock, 0, 0) == ISC_R_SUCCESS);
  74
  75         rbtimp.name = "rbt";
  76         rbtimp.create = dns_rbtdb_create;
  77         rbtimp.mctx = NULL;
  78         rbtimp.driverarg = NULL;
  79         ISC_LINK_INIT(&rbtimp, link);
  80
  81         rbt64imp.name = "rbt64";
  82         rbt64imp.create = dns_rbtdb64_create;
  83         rbt64imp.mctx = NULL;
  84         rbt64imp.driverarg = NULL;
  85         ISC_LINK_INIT(&rbt64imp, link);
  86
  87         ISC_LIST_INIT(implementations);
  88         ISC_LIST_APPEND(implementations, &rbtimp, link);
  89         ISC_LIST_APPEND(implementations, &rbt64imp, link);
  90 }
  91
  92 static inline dns_dbimplementation_t *
  93 impfind(const char *name) {
  94         dns_dbimplementation_t *imp;
  95
  96         for (imp = ISC_LIST_HEAD(implementations);
  97              imp != NULL;
  98              imp = ISC_LIST_NEXT(imp, link))
  99                 if (strcasecmp(name, imp->name) == 0)
 100                         return (imp);
 101         return (NULL);
 102 }
 103
 104
 105 /***
 106  *** Basic DB Methods
 107  ***/
 108
 109 isc_result_t
 110 dns_db_create(isc_mem_t *mctx, const char *db_type, dns_name_t *origin,
 111               dns_dbtype_t type, dns_rdataclass_t rdclass,
 112               unsigned int argc, char *argv[], dns_db_t **dbp)
 113 {
 114         dns_dbimplementation_t *impinfo;
 115
 116         RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
 117
 118         /*
 119          * Create a new database using implementation 'db_type'.
 120          */
 121
 122         REQUIRE(dbp != NULL && *dbp == NULL);
 123         REQUIRE(dns_name_isabsolute(origin));
 124
 125         RWLOCK(&implock, isc_rwlocktype_read);
 126         impinfo = impfind(db_type);
 127         if (impinfo != NULL) {
 128                 isc_result_t result;
 129                 result = ((impinfo->create)(mctx, origin, type,
 130                                             rdclass, argc, argv,
 131                                             impinfo->driverarg, dbp));
 132                 RWUNLOCK(&implock, isc_rwlocktype_read);
 133                 return (result);
 134         }
 135
 136         RWUNLOCK(&implock, isc_rwlocktype_read);
 137
 138         isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE,
 139                       DNS_LOGMODULE_DB, ISC_LOG_ERROR,
 140                       "unsupported database type '%s'", db_type);
 141
 142         return (ISC_R_NOTFOUND);
 143 }
 144
 145 void
 146 dns_db_attach(dns_db_t *source, dns_db_t **targetp) {
 147
 148         /*
 149          * Attach *targetp to source.
 150          */
 151
 152         REQUIRE(DNS_DB_VALID(source));
 153         REQUIRE(targetp != NULL && *targetp == NULL);
 154
 155         (source->methods->attach)(source, targetp);
 156
 157         ENSURE(*targetp == source);
 158 }
 159
 160 void
 161 dns_db_detach(dns_db_t **dbp) {
 162
 163         /*
 164          * Detach *dbp from its database.
 165          */
 166
 167         REQUIRE(dbp != NULL);
 168         REQUIRE(DNS_DB_VALID(*dbp));
 169
 170         ((*dbp)->methods->detach)(dbp);
 171
 172         ENSURE(*dbp == NULL);
 173 }
 174
 175 isc_result_t
 176 dns_db_ondestroy(dns_db_t *db, isc_task_t *task, isc_event_t **eventp)
 177 {
 178         REQUIRE(DNS_DB_VALID(db));
 179
 180         return (isc_ondestroy_register(&db->ondest, task, eventp));
 181 }
 182
 183
 184 isc_boolean_t
 185 dns_db_iscache(dns_db_t *db) {
 186
 187         /*
 188          * Does 'db' have cache semantics?
 189          */
 190
 191         REQUIRE(DNS_DB_VALID(db));
 192
 193         if ((db->attributes & DNS_DBATTR_CACHE) != 0)
 194                 return (ISC_TRUE);
 195
 196         return (ISC_FALSE);
 197 }
 198
 199 isc_boolean_t
 200 dns_db_iszone(dns_db_t *db) {
 201
 202         /*
 203          * Does 'db' have zone semantics?
 204          */
 205
 206         REQUIRE(DNS_DB_VALID(db));
 207
 208         if ((db->attributes & (DNS_DBATTR_CACHE|DNS_DBATTR_STUB)) == 0)
 209                 return (ISC_TRUE);
 210
 211         return (ISC_FALSE);
 212 }
 213
 214 isc_boolean_t
 215 dns_db_isstub(dns_db_t *db) {
 216
 217         /*
 218          * Does 'db' have stub semantics?
 219          */
 220
 221         REQUIRE(DNS_DB_VALID(db));
 222
 223         if ((db->attributes & DNS_DBATTR_STUB) != 0)
 224                 return (ISC_TRUE);
 225
 226         return (ISC_FALSE);
 227 }
 228
 229 isc_boolean_t
 230 dns_db_issecure(dns_db_t *db) {
 231
 232         /*
 233          * Is 'db' secure?
 234          */
 235
 236         REQUIRE(DNS_DB_VALID(db));
 237         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
 238
 239         return ((db->methods->issecure)(db));
 240 }
 241
 242 isc_boolean_t
 243 dns_db_ispersistent(dns_db_t *db) {
 244
 245         /*
 246          * Is 'db' persistent?
 247          */
 248
 249         REQUIRE(DNS_DB_VALID(db));
 250
 251         return ((db->methods->ispersistent)(db));
 252 }
 253
 254 dns_name_t *
 255 dns_db_origin(dns_db_t *db) {
 256         /*
 257          * The origin of the database.
 258          */
 259
 260         REQUIRE(DNS_DB_VALID(db));
 261
 262         return (&db->origin);
 263 }
 264
 265 dns_rdataclass_t
 266 dns_db_class(dns_db_t *db) {
 267         /*
 268          * The class of the database.
 269          */
 270
 271         REQUIRE(DNS_DB_VALID(db));
 272
 273         return (db->rdclass);
 274 }
 275
 276 isc_result_t
 277 dns_db_beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp,
 278                  dns_dbload_t **dbloadp) {
 279         /*
 280          * Begin loading 'db'.
 281          */
 282
 283         REQUIRE(DNS_DB_VALID(db));
 284         REQUIRE(addp != NULL && *addp == NULL);
 285         REQUIRE(dbloadp != NULL && *dbloadp == NULL);
 286
 287         return ((db->methods->beginload)(db, addp, dbloadp));
 288 }
 289
 290 isc_result_t
 291 dns_db_endload(dns_db_t *db, dns_dbload_t **dbloadp) {
 292         /*
 293          * Finish loading 'db'.
 294          */
 295
 296         REQUIRE(DNS_DB_VALID(db));
 297         REQUIRE(dbloadp != NULL && *dbloadp != NULL);
 298
 299         return ((db->methods->endload)(db, dbloadp));
 300 }
 301
 302 isc_result_t
 303 dns_db_load(dns_db_t *db, const char *filename) {
 304         isc_result_t result, eresult;
 305         dns_rdatacallbacks_t callbacks;
 306         unsigned int options = 0;
 307
 308         /*
 309          * Load master file 'filename' into 'db'.
 310          */
 311
 312         REQUIRE(DNS_DB_VALID(db));
 313
 314         if ((db->attributes & DNS_DBATTR_CACHE) != 0)
 315                 options |= DNS_MASTER_AGETTL;
 316
 317         dns_rdatacallbacks_init(&callbacks);
 318
 319         result = dns_db_beginload(db, &callbacks.add, &callbacks.add_private);
 320         if (result != ISC_R_SUCCESS)
 321                 return (result);
 322         result = dns_master_loadfile(filename, &db->origin, &db->origin,
 323                                      db->rdclass, options,
 324                                      &callbacks, db->mctx);
 325         eresult = dns_db_endload(db, &callbacks.add_private);
 326         /*
 327          * We always call dns_db_endload(), but we only want to return its
 328          * result if dns_master_loadfile() succeeded.  If dns_master_loadfile()
 329          * failed, we want to return the result code it gave us.
 330          */
 331         if (eresult != ISC_R_SUCCESS &&
 332             (result == ISC_R_SUCCESS || result == DNS_R_SEENINCLUDE))
 333                 result = eresult;
 334
 335         return (result);
 336 }
 337
 338 isc_result_t
 339 dns_db_dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
 340         /*
 341          * Dump 'db' into master file 'filename'.
 342          */
 343
 344         REQUIRE(DNS_DB_VALID(db));
 345
 346         return ((db->methods->dump)(db, version, filename));
 347 }
 348
 349 /***
 350  *** Version Methods
 351  ***/
 352
 353 void
 354 dns_db_currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
 355
 356         /*
 357          * Open the current version for reading.
 358          */
 359
 360         REQUIRE(DNS_DB_VALID(db));
 361         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
 362         REQUIRE(versionp != NULL && *versionp == NULL);
 363
 364         (db->methods->currentversion)(db, versionp);
 365 }
 366
 367 isc_result_t
 368 dns_db_newversion(dns_db_t *db, dns_dbversion_t **versionp) {
 369
 370         /*
 371          * Open a new version for reading and writing.
 372          */
 373
 374         REQUIRE(DNS_DB_VALID(db));
 375         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
 376         REQUIRE(versionp != NULL && *versionp == NULL);
 377
 378         return ((db->methods->newversion)(db, versionp));
 379 }
 380
 381 void
 382 dns_db_attachversion(dns_db_t *db, dns_dbversion_t *source,
 383                      dns_dbversion_t **targetp)
 384 {
 385         /*
 386          * Attach '*targetp' to 'source'.
 387          */
 388
 389         REQUIRE(DNS_DB_VALID(db));
 390         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
 391         REQUIRE(source != NULL);
 392         REQUIRE(targetp != NULL && *targetp == NULL);
 393
 394         (db->methods->attachversion)(db, source, targetp);
 395
 396         ENSURE(*targetp != NULL);
 397 }
 398
 399 void
 400 dns_db_closeversion(dns_db_t *db, dns_dbversion_t **versionp,
 401                     isc_boolean_t commit)
 402 {
 403
 404         /*
 405          * Close version '*versionp'.
 406          */
 407
 408         REQUIRE(DNS_DB_VALID(db));
 409         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
 410         REQUIRE(versionp != NULL && *versionp != NULL);
 411
 412         (db->methods->closeversion)(db, versionp, commit);
 413
 414         ENSURE(*versionp == NULL);
 415 }
 416
 417 /***
 418  *** Node Methods
 419  ***/
 420
 421 isc_result_t
 422 dns_db_findnode(dns_db_t *db, dns_name_t *name,
 423                 isc_boolean_t create, dns_dbnode_t **nodep)
 424 {
 425
 426         /*
 427          * Find the node with name 'name'.
 428          */
 429
 430         REQUIRE(DNS_DB_VALID(db));
 431         REQUIRE(nodep != NULL && *nodep == NULL);
 432
 433         return ((db->methods->findnode)(db, name, create, nodep));
 434 }
 435
 436 isc_result_t
 437 dns_db_find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,
 438             dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,
 439             dns_dbnode_t **nodep, dns_name_t *foundname,
 440             dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
 441 {
 442
 443         /*
 444          * Find the best match for 'name' and 'type' in version 'version'
 445          * of 'db'.
 446          */
 447
 448         REQUIRE(DNS_DB_VALID(db));
 449         REQUIRE(type != dns_rdatatype_sig);
 450         REQUIRE(nodep == NULL || (nodep != NULL && *nodep == NULL));
 451         REQUIRE(dns_name_hasbuffer(foundname));
 452         REQUIRE(rdataset == NULL ||
 453                 (DNS_RDATASET_VALID(rdataset) &&
 454                  ! dns_rdataset_isassociated(rdataset)));
 455         REQUIRE(sigrdataset == NULL ||
 456                 (DNS_RDATASET_VALID(sigrdataset) &&
 457                  ! dns_rdataset_isassociated(sigrdataset)));
 458
 459         return ((db->methods->find)(db, name, version, type, options, now,
 460                                     nodep, foundname, rdataset, sigrdataset));
 461 }
 462
 463 isc_result_t
 464 dns_db_findzonecut(dns_db_t *db, dns_name_t *name,
 465                    unsigned int options, isc_stdtime_t now,
 466                    dns_dbnode_t **nodep, dns_name_t *foundname,
 467                    dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)
 468 {
 469         /*
 470          * Find the deepest known zonecut which encloses 'name' in 'db'.
 471          */
 472
 473         REQUIRE(DNS_DB_VALID(db));
 474         REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
 475         REQUIRE(nodep == NULL || (nodep != NULL && *nodep == NULL));
 476         REQUIRE(dns_name_hasbuffer(foundname));
 477         REQUIRE(sigrdataset == NULL ||
 478                 (DNS_RDATASET_VALID(sigrdataset) &&
 479                  ! dns_rdataset_isassociated(sigrdataset)));
 480
 481         return ((db->methods->findzonecut)(db, name, options, now, nodep,
 482                                            foundname, rdataset, sigrdataset));
 483 }
 484
 485 void
 486 dns_db_attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
 487
 488         /*
 489          * Attach *targetp to source.
 490          */
 491
 492         REQUIRE(DNS_DB_VALID(db));
 493         REQUIRE(source != NULL);
 494         REQUIRE(targetp != NULL && *targetp == NULL);
 495
 496         (db->methods->attachnode)(db, source, targetp);
 497 }
 498
 499 void
 500 dns_db_detachnode(dns_db_t *db, dns_dbnode_t **nodep) {
 501
 502         /*
 503          * Detach *nodep from its node.
 504          */
 505
 506         REQUIRE(DNS_DB_VALID(db));
 507         REQUIRE(nodep != NULL && *nodep != NULL);
 508
 509         (db->methods->detachnode)(db, nodep);
 510
 511         ENSURE(*nodep == NULL);
 512 }
 513
 514 isc_result_t
 515 dns_db_expirenode(dns_db_t *db, dns_dbnode_t *node, isc_stdtime_t now) {
 516
 517         /*
 518          * Mark as stale all records at 'node' which expire at or before 'now'.
 519          */
 520
 521         REQUIRE(DNS_DB_VALID(db));
 522         REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
 523         REQUIRE(node != NULL);
 524
 525         return ((db->methods->expirenode)(db, node, now));
 526 }
 527
 528 void
 529 dns_db_printnode(dns_db_t *db, dns_dbnode_t *node, FILE *out) {
 530         /*
 531          * Print a textual representation of the contents of the node to
 532          * 'out'.
 533          */
 534
 535         REQUIRE(DNS_DB_VALID(db));
 536         REQUIRE(node != NULL);
 537
 538         (db->methods->printnode)(db, node, out);
 539 }
 540
 541 /***
 542  *** DB Iterator Creation
 543  ***/
 544
 545 isc_result_t
 546 dns_db_createiterator(dns_db_t *db, isc_boolean_t relative_names,
 547                       dns_dbiterator_t **iteratorp)
 548 {
 549         /*
 550          * Create an iterator for version 'version' of 'db'.
 551          */
 552
 553         REQUIRE(DNS_DB_VALID(db));
 554         REQUIRE(iteratorp != NULL && *iteratorp == NULL);
 555
 556         return (db->methods->createiterator(db, relative_names, iteratorp));
 557 }
 558
 559 /***
 560  *** Rdataset Methods
 561  ***/
 562
 563 isc_result_t
 564 dns_db_findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 565                     dns_rdatatype_t type, dns_rdatatype_t covers,
 566                     isc_stdtime_t now, dns_rdataset_t *rdataset,
 567                     dns_rdataset_t *sigrdataset)
 568 {
 569         /*
 570          * Search for an rdataset of type 'type' at 'node' that are in version
 571          * 'version' of 'db'.  If found, make 'rdataset' refer to it.
 572          */
 573
 574         REQUIRE(DNS_DB_VALID(db));
 575         REQUIRE(node != NULL);
 576         REQUIRE(DNS_RDATASET_VALID(rdataset));
 577         REQUIRE(! dns_rdataset_isassociated(rdataset));
 578         REQUIRE(covers == 0 || type == dns_rdatatype_sig);
 579         REQUIRE(type != dns_rdatatype_any);
 580         REQUIRE(sigrdataset == NULL ||
 581                 (DNS_RDATASET_VALID(sigrdataset) &&
 582                  ! dns_rdataset_isassociated(sigrdataset)));
 583
 584         return ((db->methods->findrdataset)(db, node, version, type, covers,
 585                                             now, rdataset, sigrdataset));
 586 }
 587
 588 isc_result_t
 589 dns_db_allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 590                     isc_stdtime_t now, dns_rdatasetiter_t **iteratorp)
 591 {
 592         /*
 593          * Make '*iteratorp' an rdataset iteratator for all rdatasets at
 594          * 'node' in version 'version' of 'db'.
 595          */
 596
 597         REQUIRE(DNS_DB_VALID(db));
 598         REQUIRE(iteratorp != NULL && *iteratorp == NULL);
 599
 600         return ((db->methods->allrdatasets)(db, node, version, now,
 601                                             iteratorp));
 602 }
 603
 604 isc_result_t
 605 dns_db_addrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
 606                    isc_stdtime_t now, dns_rdataset_t *rdataset,
 607                    unsigned int options, dns_rdataset_t *addedrdataset)
 608 {
 609         /*
 610          * Add 'rdataset' to 'node' in version 'version' of 'db'.
 611          */
 612
 613         REQUIRE(DNS_DB_VALID(db));
 614         REQUIRE(node != NULL);
 615         REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL)||
 616                 ((db->attributes & DNS_DBATTR_CACHE) != 0 &&
 617                  version == NULL && (options & DNS_DBADD_MERGE) == 0));
 618         REQUIRE((options & DNS_DBADD_EXACT) == 0 ||
 619                 (options & DNS_DBADD_MERGE) != 0);
 620         REQUIRE(DNS_RDATASET_VALID(rdataset));
 621         REQUIRE(dns_rdataset_isassociated(rdataset));
 622         REQUIRE(rdataset->rdclass == db->rdclass);
 623         REQUIRE(addedrdataset == NULL ||
 624                 (DNS_RDATASET_VALID(addedrdataset) &&
 625                  ! dns_rdataset_isassociated(addedrdataset)));
 626
 627         return ((db->methods->addrdataset)(db, node, version, now, rdataset,
 628                                            options, addedrdataset));
 629 }
 630
 631 isc_result_t
 632 dns_db_subtractrdataset(dns_db_t *db, dns_dbnode_t *node,
 633                         dns_dbversion_t *version, dns_rdataset_t *rdataset,
 634                         unsigned int options, dns_rdataset_t *newrdataset)
 635 {
 636         /*
 637          * Remove any rdata in 'rdataset' from 'node' in version 'version' of
 638          * 'db'.
 639          */
 640
 641         REQUIRE(DNS_DB_VALID(db));
 642         REQUIRE(node != NULL);
 643         REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL);
 644         REQUIRE(DNS_RDATASET_VALID(rdataset));
 645         REQUIRE(dns_rdataset_isassociated(rdataset));
 646         REQUIRE(rdataset->rdclass == db->rdclass);
 647         REQUIRE(newrdataset == NULL ||
 648                 (DNS_RDATASET_VALID(newrdataset) &&
 649                  ! dns_rdataset_isassociated(newrdataset)));
 650
 651         return ((db->methods->subtractrdataset)(db, node, version, rdataset,
 652                                                 options, newrdataset));
 653 }
 654
 655 isc_result_t
 656 dns_db_deleterdataset(dns_db_t *db, dns_dbnode_t *node,
 657                       dns_dbversion_t *version, dns_rdatatype_t type,
 658                       dns_rdatatype_t covers)
 659 {
 660         /*
 661          * Make it so that no rdataset of type 'type' exists at 'node' in
 662          * version version 'version' of 'db'.
 663          */
 664
 665         REQUIRE(DNS_DB_VALID(db));
 666         REQUIRE(node != NULL);
 667         REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL)||
 668                 ((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL));
 669
 670         return ((db->methods->deleterdataset)(db, node, version,
 671                                               type, covers));
 672 }
 673
 674 void
 675 dns_db_overmem(dns_db_t *db, isc_boolean_t overmem) {
 676
 677         REQUIRE(DNS_DB_VALID(db));
 678
 679         (db->methods->overmem)(db, overmem);
 680 }
 681
 682 isc_result_t
 683 dns_db_getsoaserial(dns_db_t *db, dns_dbversion_t *ver, isc_uint32_t *serialp)
 684 {
 685         isc_result_t result;
 686         dns_dbnode_t *node = NULL;
 687         dns_rdataset_t rdataset;
 688         dns_rdata_t rdata = DNS_RDATA_INIT;
 689         isc_buffer_t buffer;
 690
 691         REQUIRE(dns_db_iszone(db) || dns_db_isstub(db));
 692
 693         result = dns_db_findnode(db, dns_db_origin(db), ISC_FALSE, &node);
 694         if (result != ISC_R_SUCCESS)
 695                 return (result);
 696
 697         dns_rdataset_init(&rdataset);
 698         result = dns_db_findrdataset(db, node, ver, dns_rdatatype_soa, 0,
 699                                      (isc_stdtime_t)0, &rdataset, NULL);
 700         if (result != ISC_R_SUCCESS)
 701                 goto freenode;
 702
 703         result = dns_rdataset_first(&rdataset);
 704         if (result != ISC_R_SUCCESS)
 705                 goto freerdataset;
 706         dns_rdataset_current(&rdataset, &rdata);
 707         result = dns_rdataset_next(&rdataset);
 708         INSIST(result == ISC_R_NOMORE);
 709
 710         INSIST(rdata.length > 20);
 711         isc_buffer_init(&buffer, rdata.data, rdata.length);
 712         isc_buffer_add(&buffer, rdata.length);
 713         isc_buffer_forward(&buffer, rdata.length - 20);
 714         *serialp = isc_buffer_getuint32(&buffer);
 715
 716         result = ISC_R_SUCCESS;
 717
 718  freerdataset:
 719         dns_rdataset_disassociate(&rdataset);
 720
 721  freenode:
 722         dns_db_detachnode(db, &node);
 723         return (result);
 724 }
 725
 726 unsigned int
 727 dns_db_nodecount(dns_db_t *db) {
 728         REQUIRE(DNS_DB_VALID(db));
 729
 730         return ((db->methods->nodecount)(db));
 731 }
 732
 733 void
 734 dns_db_settask(dns_db_t *db, isc_task_t *task) {
 735         REQUIRE(DNS_DB_VALID(db));
 736
 737         (db->methods->settask)(db, task);
 738 }
 739
 740 isc_result_t
 741 dns_db_register(const char *name, dns_dbcreatefunc_t create, void *driverarg,
 742                 isc_mem_t *mctx, dns_dbimplementation_t **dbimp)
 743 {
 744         dns_dbimplementation_t *imp;
 745
 746         REQUIRE(name != NULL);
 747         REQUIRE(dbimp != NULL && *dbimp == NULL);
 748
 749         RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
 750
 751         RWLOCK(&implock, isc_rwlocktype_write);
 752         imp = impfind(name);
 753         if (imp != NULL) {
 754                 RWUNLOCK(&implock, isc_rwlocktype_write);
 755                 return (ISC_R_EXISTS);
 756         }
 757
 758         imp = isc_mem_get(mctx, sizeof(dns_dbimplementation_t));
 759         if (imp == NULL) {
 760                 RWUNLOCK(&implock, isc_rwlocktype_write);
 761                 return (ISC_R_NOMEMORY);
 762         }
 763         imp->name = name;
 764         imp->create = create;
 765         imp->mctx = NULL;
 766         imp->driverarg = driverarg;
 767         isc_mem_attach(mctx, &imp->mctx);
 768         ISC_LINK_INIT(imp, link);
 769         ISC_LIST_APPEND(implementations, imp, link);
 770         RWUNLOCK(&implock, isc_rwlocktype_write);
 771
 772         *dbimp = imp;
 773
 774         return (ISC_R_SUCCESS);
 775 }
 776
 777 void
 778 dns_db_unregister(dns_dbimplementation_t **dbimp) {
 779         dns_dbimplementation_t *imp;
 780         isc_mem_t *mctx;
 781
 782         REQUIRE(dbimp != NULL && *dbimp != NULL);
 783
 784         RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
 785
 786         imp = *dbimp;
 787         RWLOCK(&implock, isc_rwlocktype_write);
 788         ISC_LIST_UNLINK(implementations, imp, link);
 789         mctx = imp->mctx;
 790         isc_mem_put(mctx, imp, sizeof(dns_dbimplementation_t));
 791         isc_mem_detach(&mctx);
 792         RWUNLOCK(&implock, isc_rwlocktype_write);
 793 }