}
}
-/*
- * This method should never be called, because DB is "persistent".
- * See ispersistent() function. It means that database do not need to be
- * loaded in the usual sense.
- */
-static isc_result_t
-beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
-
- FATAL_ERROR("current implementation should never call beginload()");
-
- /* Not reached */
- return (ISC_R_SUCCESS);
-}
-
-/*
- * This method should never be called, because DB is "persistent".
- * See ispersistent() function. It means that database do not need to be
- * loaded in the usual sense.
- */
-static isc_result_t
-endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
-
- FATAL_ERROR("current implementation should never call endload()");
-
- /* Not reached */
- return (ISC_R_SUCCESS);
-}
-
-static isc_result_t
-dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
- dns_masterformat_t masterformat) {
- UNUSED(db);
- UNUSED(version);
- UNUSED(filename);
- UNUSED(masterformat);
-
- FATAL_ERROR("current implementation should never call dump()");
-
- /* Not reached */
- return (ISC_R_SUCCESS);
-}
-
static void
currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
sampledb_t *sampledb = (sampledb_t *)db;
return (dns_db_nodecount(sampledb->rbtdb, tree));
}
-/*
- * The database does not need to be loaded from disk or written to disk.
- * Always return true.
- */
-static bool
-ispersistent(dns_db_t *db) {
- UNUSED(db);
-
- return (true);
-}
-
static void
overmem(dns_db_t *db, bool over) {
sampledb_t *sampledb = (sampledb_t *)db;
printnode, createiterator, findrdataset,
allrdatasets, addrdataset, subtractrdataset,
deleterdataset, issecure, nodecount,
- ispersistent, overmem, setloop,
+ NULL, overmem, setloop,
getoriginnode, transfernode, getnsec3parameters,
findnsec3node, setsigningtime, getsigningtime,
resigned, isdnssec, getrrsetstats,
if (db->methods->isdnssec != NULL) {
return ((db->methods->isdnssec)(db));
}
- return ((db->methods->issecure)(db));
+ if (db->methods->issecure != NULL) {
+ return ((db->methods->issecure)(db));
+ }
+ return (false);
}
bool
REQUIRE(DNS_DB_VALID(db));
REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
- return ((db->methods->issecure)(db));
+ if (db->methods->issecure != NULL) {
+ return ((db->methods->issecure)(db));
+ }
+ return (false);
}
bool
REQUIRE(DNS_DB_VALID(db));
- return ((db->methods->ispersistent)(db));
+ if (db->methods->ispersistent != NULL) {
+ return ((db->methods->ispersistent)(db));
+ } else if (db->methods->beginload == NULL) {
+ /* If the database can't be loaded, assume it's persistent */
+ return (true);
+ }
+
+ return (false);
}
dns_name_t *
REQUIRE(DNS_DB_VALID(db));
REQUIRE(DNS_CALLBACK_VALID(callbacks));
- return ((db->methods->beginload)(db, callbacks));
+ if (db->methods->beginload != NULL) {
+ return ((db->methods->beginload)(db, callbacks));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
REQUIRE(DNS_CALLBACK_VALID(callbacks));
REQUIRE(callbacks->add_private != NULL);
+ /*
+ * When dns_db_endload() is called, we call the onupdate function
+ * for all registered listeners, regardless of whether the underlying
+ * database has an 'endload' implementation.
+ */
for (listener = ISC_LIST_HEAD(db->update_listeners); listener != NULL;
listener = ISC_LIST_NEXT(listener, link))
{
listener->onupdate(db, listener->onupdate_arg);
}
- return ((db->methods->endload)(db, callbacks));
+ if (db->methods->endload != NULL) {
+ return ((db->methods->endload)(db, callbacks));
+ }
+
+ return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
isc_result_t
dns_db_dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {
- return ((db->methods->dump)(db, version, filename,
- dns_masterformat_text));
+ if (db->methods->dump != NULL) {
+ return ((db->methods->dump)(db, version, filename,
+ dns_masterformat_text));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
/***
REQUIRE((db->attributes & DNS_DBATTR_CACHE) == 0);
REQUIRE(versionp != NULL && *versionp == NULL);
- return ((db->methods->newversion)(db, versionp));
+ if (db->methods->newversion != NULL) {
+ return ((db->methods->newversion)(db, versionp));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
void
(DNS_RDATASET_VALID(sigrdataset) &&
!dns_rdataset_isassociated(sigrdataset)));
- return ((db->methods->findzonecut)(db, name, options, now, nodep,
- foundname, dcname, rdataset,
- sigrdataset));
+ if (db->methods->findzonecut != NULL) {
+ return ((db->methods->findzonecut)(db, name, options, now,
+ nodep, foundname, dcname,
+ rdataset, sigrdataset));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
void
REQUIRE((db->attributes & DNS_DBATTR_CACHE) != 0);
REQUIRE(node != NULL);
- return ((db->methods->expirenode)(db, node, now));
+ if (db->methods->expirenode != NULL) {
+ return ((db->methods->expirenode)(db, node, now));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
void
REQUIRE(DNS_DB_VALID(db));
REQUIRE(node != NULL);
- (db->methods->printnode)(db, node, out);
+ if (db->methods->printnode != NULL) {
+ (db->methods->printnode)(db, node, out);
+ }
}
/***
(DNS_RDATASET_VALID(addedrdataset) &&
!dns_rdataset_isassociated(addedrdataset)));
- return ((db->methods->addrdataset)(db, node, version, now, rdataset,
- options, addedrdataset));
+ if (db->methods->addrdataset != NULL) {
+ return ((db->methods->addrdataset)(db, node, version, now,
+ rdataset, options,
+ addedrdataset));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
(DNS_RDATASET_VALID(newrdataset) &&
!dns_rdataset_isassociated(newrdataset)));
- return ((db->methods->subtractrdataset)(db, node, version, rdataset,
- options, newrdataset));
+ if (db->methods->subtractrdataset != NULL) {
+ return ((db->methods->subtractrdataset)(
+ db, node, version, rdataset, options, newrdataset));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
REQUIRE(((db->attributes & DNS_DBATTR_CACHE) == 0 && version != NULL) ||
((db->attributes & DNS_DBATTR_CACHE) != 0 && version == NULL));
- return ((db->methods->deleterdataset)(db, node, version, type, covers));
+ if (db->methods->deleterdataset != NULL) {
+ return ((db->methods->deleterdataset)(db, node, version, type,
+ covers));
+ }
+ return (ISC_R_NOTIMPLEMENTED);
}
void
dns_db_overmem(dns_db_t *db, bool overmem) {
REQUIRE(DNS_DB_VALID(db));
- (db->methods->overmem)(db, overmem);
+ if (db->methods->overmem != NULL) {
+ (db->methods->overmem)(db, overmem);
+ }
}
isc_result_t
dns_db_nodecount(dns_db_t *db, dns_dbtree_t tree) {
REQUIRE(DNS_DB_VALID(db));
- return ((db->methods->nodecount)(db, tree));
+ if (db->methods->nodecount != NULL) {
+ return ((db->methods->nodecount)(db, tree));
+ }
+ return (0);
}
size_t
dns_db_setloop(dns_db_t *db, isc_loop_t *loop) {
REQUIRE(DNS_DB_VALID(db));
- (db->methods->setloop)(db, loop);
+ if (db->methods->setloop != NULL) {
+ (db->methods->setloop)(db, loop);
+ }
}
isc_result_t
REQUIRE(node != NULL);
REQUIRE(name != NULL);
- if (db->methods->nodefullname == NULL) {
- return (ISC_R_NOTIMPLEMENTED);
+ if (db->methods->nodefullname != NULL) {
+ return ((db->methods->nodefullname)(db, node, name));
}
- return ((db->methods->nodefullname)(db, node, name));
+ return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
void
dns_db_setloop(dns_db_t *db, isc_loop_t *loop);
/*%<
- * If loop is set then the final detach maybe performed asynchronously.
+ * If loop is set then the final detach may be performed asynchronously.
*
* Requires:
* \li 'db' is a valid database.
* 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.
+ *
* Requires:
*
* \li 'db' is a valid database.
return (result);
}
-static isc_result_t
-zone_findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
- isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
- dns_name_t *dcname, dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset) {
- UNUSED(db);
- UNUSED(name);
- UNUSED(options);
- UNUSED(now);
- UNUSED(nodep);
- UNUSED(foundname);
- UNUSED(dcname);
- UNUSED(rdataset);
- UNUSED(sigrdataset);
-
- FATAL_ERROR("zone_findzonecut() called!");
-
- UNREACHABLE();
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static bool
check_stale_header(dns_rbtnode_t *node, rdatasetheader_t *header,
isc_rwlocktype_t *nlocktypep, nodelock_t *lock,
RBTDB_UNLOCK(&rbtdb->lock, isc_rwlocktype_write);
}
-static bool
-ispersistent(dns_db_t *db) {
- UNUSED(db);
- return (false);
-}
-
static isc_result_t
getoriginnode(dns_db_t *db, dns_dbnode_t **nodep) {
dns_rbtdb_t *rbtdb = (dns_rbtdb_t *)db;
closeversion,
findnode,
zone_find,
- zone_findzonecut,
+ NULL, /* findzonecut */
attachnode,
detachnode,
expirenode,
deleterdataset,
issecure,
nodecount,
- ispersistent,
+ NULL,
overmem,
setloop,
getoriginnode,
deleterdataset,
issecure,
nodecount,
- ispersistent,
+ NULL,
overmem,
setloop,
getoriginnode,
static int dummy;
static isc_result_t
-dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
- dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
- void *driverarg, dns_db_t **dbp);
+create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
+ dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
+ void *driverarg, dns_db_t **dbp);
static isc_result_t
findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
dns_sdb_register(const char *drivername, const dns_sdbmethods_t *methods,
void *driverdata, unsigned int flags, isc_mem_t *mctx,
dns_sdbimplementation_t **sdbimp) {
- dns_sdbimplementation_t *imp;
+ dns_sdbimplementation_t *imp = NULL;
isc_result_t result;
REQUIRE(drivername != NULL);
isc_mutex_init(&imp->driverlock);
imp->dbimp = NULL;
- result = dns_db_register(drivername, dns_sdb_create, imp, mctx,
- &imp->dbimp);
+ result = dns_db_register(drivername, create, imp, mctx, &imp->dbimp);
if (result != ISC_R_SUCCESS) {
goto cleanup_mutex;
}
void
dns_sdb_unregister(dns_sdbimplementation_t **sdbimp) {
- dns_sdbimplementation_t *imp;
+ dns_sdbimplementation_t *imp = NULL;
REQUIRE(sdbimp != NULL && *sdbimp != NULL);
dns_sdb_putrdata(dns_sdblookup_t *lookup, dns_rdatatype_t typeval,
dns_ttl_t ttl, const unsigned char *rdatap,
unsigned int rdlen) {
- dns_rdatalist_t *rdatalist;
- dns_rdata_t *rdata;
+ dns_rdatalist_t *rdatalist = NULL;
+ dns_rdata_t *rdata = NULL;
isc_buffer_t *rdatabuf = NULL;
- isc_mem_t *mctx;
+ isc_mem_t *mctx = NULL;
isc_region_t region;
mctx = lookup->sdb->common.mctx;
isc_result_t result;
unsigned char *p = NULL;
unsigned int size = 0; /* Init to suppress compiler warning */
- isc_mem_t *mctx;
- dns_sdbimplementation_t *imp;
- const dns_name_t *origin;
+ isc_mem_t *mctx = NULL;
+ dns_sdbimplementation_t *imp = NULL;
+ const dns_name_t *origin = NULL;
isc_buffer_t b;
isc_buffer_t rb;
static isc_result_t
getnode(dns_sdballnodes_t *allnodes, const char *name, dns_sdbnode_t **nodep) {
- dns_name_t *newname;
- const dns_name_t *origin;
+ dns_name_t *newname = NULL;
+ const dns_name_t *origin = NULL;
dns_fixedname_t fnewname;
dns_sdb_t *sdb = (dns_sdb_t *)allnodes->common.db;
dns_sdbimplementation_t *imp = sdb->implementation;
- dns_sdbnode_t *sdbnode;
+ dns_sdbnode_t *sdbnode = NULL;
isc_mem_t *mctx = sdb->common.mctx;
isc_buffer_t b;
isc_result_t result;
}
}
-static isc_result_t
-beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-static isc_result_t
-endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-static isc_result_t
-dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
- dns_masterformat_t masterformat) {
- UNUSED(db);
- UNUSED(version);
- UNUSED(filename);
- UNUSED(masterformat);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static void
currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
REQUIRE(versionp != NULL && *versionp == NULL);
return;
}
-static isc_result_t
-newversion(dns_db_t *db, dns_dbversion_t **versionp) {
- UNUSED(db);
- UNUSED(versionp);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static void
attachversion(dns_db_t *db, dns_dbversion_t *source,
dns_dbversion_t **targetp) {
static isc_result_t
createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep) {
- dns_sdbnode_t *node;
+ dns_sdbnode_t *node = NULL;
node = isc_mem_get(sdb->common.mctx, sizeof(dns_sdbnode_t));
static void
destroynode(dns_sdbnode_t *node) {
- dns_rdatalist_t *list;
- dns_rdata_t *rdata;
- isc_buffer_t *b;
- dns_sdb_t *sdb;
- isc_mem_t *mctx;
+ dns_rdatalist_t *list = NULL;
+ dns_rdata_t *rdata = NULL;
+ isc_buffer_t *b = NULL;
+ dns_sdb_t *sdb = NULL;
+ isc_mem_t *mctx = NULL;
sdb = node->sdb;
mctx = sdb->common.mctx;
isc_result_t result;
isc_buffer_t b;
char namestr[DNS_NAME_MAXTEXT + 1];
- dns_sdbimplementation_t *imp;
+ dns_sdbimplementation_t *imp = NULL;
dns_name_t relname;
- dns_name_t *name;
+ dns_name_t *name = NULL;
REQUIRE(VALID_SDB(sdb));
REQUIRE(nodep != NULL && *nodep == NULL);
isc_buffer_t b;
char namestr[DNS_NAME_MAXTEXT + 1];
bool isorigin;
- dns_sdbimplementation_t *imp;
+ dns_sdbimplementation_t *imp = NULL;
dns_name_t relname;
unsigned int labels;
dns_dbnode_t *node = NULL;
dns_fixedname_t fname;
dns_rdataset_t xrdataset;
- dns_name_t *xname;
+ dns_name_t *xname = NULL;
unsigned int nlabels, olabels;
isc_result_t result;
unsigned int i;
return (result);
}
-static isc_result_t
-findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
- isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
- dns_name_t *dcname, dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset) {
- UNUSED(db);
- UNUSED(name);
- UNUSED(options);
- UNUSED(now);
- UNUSED(nodep);
- UNUSED(foundname);
- UNUSED(dcname);
- UNUSED(rdataset);
- UNUSED(sigrdataset);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static void
attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
dns_sdb_t *sdb = (dns_sdb_t *)db;
static void
detachnode(dns_db_t *db, dns_dbnode_t **targetp) {
dns_sdb_t *sdb = (dns_sdb_t *)db;
- dns_sdbnode_t *node;
+ dns_sdbnode_t *node = NULL;
REQUIRE(VALID_SDB(sdb));
REQUIRE(targetp != NULL && *targetp != NULL);
}
}
-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) {
dns_sdb_t *sdb = (dns_sdb_t *)db;
REQUIRE(VALID_SDB(sdb));
- sdb_dbiterator_t *sdbiter;
+ sdb_dbiterator_t *sdbiter = NULL;
isc_result_t result;
dns_sdbimplementation_t *imp = sdb->implementation;
dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
REQUIRE(VALID_SDBNODE(node));
- dns_rdatalist_t *list;
+ dns_rdatalist_t *list = NULL;
dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)node;
UNUSED(db);
allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,
unsigned int options, isc_stdtime_t now,
dns_rdatasetiter_t **iteratorp) {
- sdb_rdatasetiter_t *iterator;
+ sdb_rdatasetiter_t *iterator = NULL;
REQUIRE(version == NULL || version == &dummy);
return (ISC_R_SUCCESS);
}
-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) {
- UNUSED(db);
- UNUSED(node);
- UNUSED(version);
- UNUSED(now);
- UNUSED(rdataset);
- UNUSED(options);
- UNUSED(addedrdataset);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-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) {
- UNUSED(db);
- UNUSED(node);
- UNUSED(version);
- UNUSED(rdataset);
- UNUSED(options);
- UNUSED(newrdataset);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-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) {
- UNUSED(db);
- UNUSED(node);
- UNUSED(version);
- UNUSED(type);
- UNUSED(covers);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-static bool
-issecure(dns_db_t *db) {
- UNUSED(db);
-
- return (false);
-}
-
-static unsigned int
-nodecount(dns_db_t *db, dns_dbtree_t tree) {
- UNUSED(db);
- UNUSED(tree);
-
- return (0);
-}
-
static bool
ispersistent(dns_db_t *db) {
UNUSED(db);
return (true);
}
-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);
- UNUSED(loop);
-}
-
static dns_dbmethods_t sdb_methods = {
- attach, detach,
- beginload, endload,
- dump, currentversion,
- newversion, attachversion,
- closeversion, NULL, /* findnode */
- NULL, /* find */
- findzonecut, attachnode,
- detachnode, expirenode,
- printnode, createiterator,
- findrdataset, allrdatasets,
- addrdataset, subtractrdataset,
- deleterdataset, issecure,
- nodecount, ispersistent,
- overmem, setloop,
- getoriginnode, /* getoriginnode */
- NULL, /* transfernode */
- NULL, /* getnsec3parameters */
- NULL, /* findnsec3node */
- NULL, /* setsigningtime */
- NULL, /* getsigningtime */
- NULL, /* resigned */
- NULL, /* isdnssec */
- NULL, /* getrrsetstats */
- findnodeext, findext,
- NULL, /* setcachestats */
- NULL, /* hashsize */
- NULL, /* nodefullname */
- NULL, /* getsize */
- NULL, /* setservestalettl */
- NULL, /* getservestalettl */
- NULL, /* setservestalerefresh */
- NULL, /* getservestalerefresh */
- NULL, /* setgluecachestats */
+ attach, detach, NULL, /* beginload */
+ NULL, /* endload */
+ NULL, /* dump */
+ currentversion, NULL, /* newversion */
+ attachversion, closeversion, NULL, /* findnode */
+ NULL, /* find */
+ NULL, /* findzonecut */
+ attachnode, detachnode, NULL, /* expirenode */
+ NULL, /* printnode */
+ createiterator, findrdataset, allrdatasets, NULL, /* addrdataset */
+ NULL, /* subtractrdataset */
+ NULL, /* deleterdataset */
+ NULL, /* issecure */
+ NULL, /* nodecount */
+ ispersistent, NULL, /* overmem */
+ NULL, /* setloop */
+ getoriginnode, /* getoriginnode */
+ NULL, /* transfernode */
+ NULL, /* getnsec3parameters */
+ NULL, /* findnsec3node */
+ NULL, /* setsigningtime */
+ NULL, /* getsigningtime */
+ NULL, /* resigned */
+ NULL, /* isdnssec */
+ NULL, /* getrrsetstats */
+ findnodeext, findext, NULL, /* setcachestats */
+ NULL, /* hashsize */
+ NULL, /* nodefullname */
+ NULL, /* getsize */
+ NULL, /* setservestalettl */
+ NULL, /* getservestalettl */
+ NULL, /* setservestalerefresh */
+ NULL, /* getservestalerefresh */
+ NULL, /* setgluecachestats */
};
static isc_result_t
-dns_sdb_create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
- dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
- void *driverarg, dns_db_t **dbp) {
- dns_sdb_t *sdb;
+create(isc_mem_t *mctx, const dns_name_t *origin, dns_dbtype_t type,
+ dns_rdataclass_t rdclass, unsigned int argc, char *argv[],
+ void *driverarg, dns_db_t **dbp) {
+ dns_sdb_t *sdb = NULL;
isc_result_t result;
char zonestr[DNS_NAME_MAXTEXT + 1];
isc_buffer_t b;
- dns_sdbimplementation_t *imp;
+ dns_sdbimplementation_t *imp = NULL;
REQUIRE(driverarg != NULL);
}
}
-static isc_result_t
-beginload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-static isc_result_t
-endload(dns_db_t *db, dns_rdatacallbacks_t *callbacks) {
- UNUSED(db);
- UNUSED(callbacks);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
-static isc_result_t
-dump(dns_db_t *db, dns_dbversion_t *version, const char *filename,
- dns_masterformat_t masterformat) {
- UNUSED(db);
- UNUSED(version);
- UNUSED(filename);
- UNUSED(masterformat);
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static void
currentversion(dns_db_t *db, dns_dbversion_t **versionp) {
dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
return (getnodedata(db, name, create, 0, NULL, NULL, nodep));
}
-static isc_result_t
-findzonecut(dns_db_t *db, const dns_name_t *name, unsigned int options,
- isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,
- dns_name_t *dcname, dns_rdataset_t *rdataset,
- dns_rdataset_t *sigrdataset) {
- UNUSED(db);
- UNUSED(name);
- UNUSED(options);
- UNUSED(now);
- UNUSED(nodep);
- UNUSED(foundname);
- UNUSED(dcname);
- UNUSED(rdataset);
- UNUSED(sigrdataset);
-
- return (ISC_R_NOTIMPLEMENTED);
-}
-
static void
attachnode(dns_db_t *db, dns_dbnode_t *source, dns_dbnode_t **targetp) {
dns_sdlz_db_t *sdlz = (dns_sdlz_db_t *)db;
return (0);
}
-static bool
-ispersistent(dns_db_t *db) {
- UNUSED(db);
- return (true);
-}
-
static void
overmem(dns_db_t *db, bool over) {
UNUSED(db);
}
static dns_dbmethods_t sdlzdb_methods = {
- attach, detach, beginload,
- endload, dump, currentversion,
- newversion, attachversion, closeversion,
- findnode, find, findzonecut,
+ attach, detach, NULL, /* beginload */
+ NULL, /* endload */
+ NULL, /* dump */
+ currentversion, newversion, attachversion,
+ closeversion, findnode, find,
+ NULL, /* findzonecut */
attachnode, detachnode, expirenode,
printnode, createiterator, findrdataset,
allrdatasets, addrdataset, subtractrdataset,
deleterdataset, issecure, nodecount,
- ispersistent, overmem, setloop,
+ NULL, overmem, setloop,
getoriginnode, NULL, /* transfernode */
NULL, /* getnsec3parameters */
NULL, /* findnsec3node */
projects / thirdparty / bind9.git / commitdiff
