14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <config.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <string.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/buffer.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/lex.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/log.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/magic.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/mem.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/once.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/print.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/region.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <isc/util.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

704e6c8876907aac0bf7380effca8bca400d4acdMark Andrews#include <dns/callbacks.h>

704e6c8876907aac0bf7380effca8bca400d4acdMark Andrews#include <dns/db.h>

704e6c8876907aac0bf7380effca8bca400d4acdMark Andrews#include <dns/dbiterator.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <dns/fixedname.h>

f5d30e2864e048a42c4dc1134993ae7efdb5d6c3Mark Andrews#include <dns/log.h>

c1a883f2e04d94e99c433b1f6cfd0c0338f4ed85Mark Andrews#include <dns/rdata.h>

f052a01ff268cdbbf3e6f600b06d02ed8573badfAutomatic Updater#include <dns/rdatalist.h>

d60212e03fbef1d3dd7f7eb05c0545cc373cb9fcAutomatic Updater#include <dns/rdataset.h>

938440694b33cd752e9e4b71a526368b4811c177Tinderbox User#include <dns/rdatasetiter.h>

19c7b1a0293498a3e36692c59646ed6e15ffc8d0Tinderbox User#include <dns/rdatatype.h>

21635968f7663163ce914f238fd99e40fdff07a1Tinderbox User#include <dns/result.h>

d63ae51ba337165172a9b50fd5d84805ffe50044Tinderbox User#include <dns/sdb.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include <dns/types.h>

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#include "rdatalist_p.h"

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeinstruct dns_sdbimplementation {

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt const dns_sdbmethods_t *methods;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein void *driverdata;

3001a1b4e6298466882a4147307b4c28a3b08f91Mark Andrews unsigned int flags;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt isc_mem_t *mctx;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt dns_dbimplementation_t *dbimp;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt};

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Huntstruct dns_sdb {

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt /* Unlocked */

b7a823a402eb5c4e99f283e58d778a903d2e72f5Michał Kępień dns_db_t common;

b7a823a402eb5c4e99f283e58d778a903d2e72f5Michał Kępień char *zone;

b7a823a402eb5c4e99f283e58d778a903d2e72f5Michał Kępień dns_sdbimplementation_t *implementation;

b7a823a402eb5c4e99f283e58d778a903d2e72f5Michał Kępień void *dbdata;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt isc_mutex_t lock;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt /* Locked */

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt unsigned int references;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein};

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeinstruct dns_sdblookup {

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt /* Unlocked */

30eec077db2bdcb6f2a0dc388a3cdde2ede75ec1Mark Andrews unsigned int magic;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_sdb_t *sdb;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein ISC_LIST(dns_rdatalist_t) lists;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein ISC_LIST(isc_buffer_t) buffers;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_name_t *name;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein ISC_LINK(dns_sdblookup_t) link;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein isc_mutex_t lock;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_rdatacallbacks_t callbacks;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein /* Locked */

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein unsigned int references;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein};

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeintypedef struct dns_sdblookup dns_sdbnode_t;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeinstruct dns_sdballnodes {

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_dbiterator_t common;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein ISC_LIST(dns_sdbnode_t) nodelist;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_sdbnode_t *current;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_sdbnode_t *origin;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein};

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeintypedef dns_sdballnodes_t sdb_dbiterator_t;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewstypedef struct sdb_rdatasetiter {

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_rdatasetiter_t common;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdatalist_t *current;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein} sdb_rdatasetiter_t;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#define SDB_MAGIC 0x5344422d /* SDB- */

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define VALID_SDB(sdb) ((sdb) != NULL && \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews (sdb)->common.impmagic == SDB_MAGIC)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define SDBLOOKUP_MAGIC ISC_MAGIC('S','D','B','L')

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define VALID_SDBLOOKUP(sdbl) ISC_MAGIC_VALID(sdbl, SDBLOOKUP_MAGIC)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define VALID_SDBNODE(sdbn) VALID_SDBLOOKUP(sdbn)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define SDB_DEFAULT_REFRESH (60 * 60 * 8)

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein#define SDB_DEFAULT_RETRY (60 * 60 * 2)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define SDB_DEFAULT_EXPIRE (60 * 60 * 24 * 7)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define SDB_DEFAULT_MINIMUM (60 * 60 * 24)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define SDB_DEFAULT_TTL (60 * 60 * 24)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define MAYBE_LOCK(sdb) \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews do { \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews unsigned int flags = sdb->implementation->flags; \

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein if ((flags & DNS_SDBFLAG_THREADSAFE) == 0) \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews LOCK(&sdb->lock); \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews } while (0)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews#define MAYBE_UNLOCK(sdb) \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews do { \

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews unsigned int flags = sdb->implementation->flags; \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if ((flags & DNS_SDBFLAG_THREADSAFE) == 0) \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews UNLOCK(&sdb->lock); \

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews } while (0)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic int dummy;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dns_sdb_create(isc_mem_t *mctx, dns_name_t *origin,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_dbtype_t type, dns_rdataclass_t rdclass,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews unsigned int argc, char *argv[],

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews void *driverarg, dns_db_t **dbp);

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrewsstatic isc_result_t findrdataset(dns_db_t *db, dns_dbnode_t *node,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_dbversion_t *version,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdatatype_t type, dns_rdatatype_t covers,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_stdtime_t now, dns_rdataset_t *rdataset,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdataset_t *sigrdataset);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic void destroynode(dns_sdbnode_t *node);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic void detachnode(dns_db_t *db, dns_dbnode_t **targetp);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic void list_tordataset(dns_rdatalist_t *rdatalist,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_db_t *db, dns_dbnode_t *node,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdataset_t *rdataset);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic void dbiterator_destroy(dns_dbiterator_t **iteratorp);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeinstatic isc_result_t dbiterator_first(dns_dbiterator_t *iterator);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_last(dns_dbiterator_t *iterator);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_seek(dns_dbiterator_t *iterator,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_name_t *name);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_prev(dns_dbiterator_t *iterator);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_next(dns_dbiterator_t *iterator);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_current(dns_dbiterator_t *iterator,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_dbnode_t **nodep,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_name_t *name);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t dbiterator_pause(dns_dbiterator_t *iterator);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austeinstatic isc_result_t dbiterator_origin(dns_dbiterator_t *iterator,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_name_t *name);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic dns_dbiteratormethods_t dbiterator_methods = {

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_destroy,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_first,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_last,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_seek,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_prev,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_next,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_current,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dbiterator_pause,

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dbiterator_origin

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews};

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic void rdatasetiter_destroy(dns_rdatasetiter_t **iteratorp);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t rdatasetiter_first(dns_rdatasetiter_t *iterator);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic isc_result_t rdatasetiter_next(dns_rdatasetiter_t *iterator);

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrewsstatic void rdatasetiter_current(dns_rdatasetiter_t *iterator,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdataset_t *rdataset);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsstatic dns_rdatasetitermethods_t rdatasetiter_methods = {

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatasetiter_destroy,

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews rdatasetiter_first,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatasetiter_next,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatasetiter_current

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews};

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsdns_sdb_register(const char *drivername, const dns_sdbmethods_t *methods,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews void *driverdata, unsigned int flags, isc_mem_t *mctx,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_sdbimplementation_t **sdbimp)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews{

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_sdbimplementation_t *imp;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_result_t result;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(drivername != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(methods != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(methods->lookup != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(mctx != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(sdbimp != NULL && *sdbimp == NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE((flags & ~(DNS_SDBFLAG_RELATIVEOWNER |

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein DNS_SDBFLAG_RELATIVERDATA |

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews DNS_SDBFLAG_THREADSAFE)) == 0);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews imp = isc_mem_get(mctx, sizeof(dns_sdbimplementation_t));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (imp == NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (ISC_R_NOMEMORY);

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews imp->methods = methods;

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews imp->driverdata = driverdata;

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews imp->flags = flags;

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews imp->mctx = NULL;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_attach(mctx, &imp->mctx);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews imp->dbimp = NULL;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = dns_db_register(drivername, dns_sdb_create, imp, mctx,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews &imp->dbimp);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS) {

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_sdb_unregister(&imp);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (result);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews }

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein *sdbimp = imp;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (ISC_R_SUCCESS);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews}

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsdns_sdb_unregister(dns_sdbimplementation_t **sdbimp) {

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_sdbimplementation_t *imp;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_t *mctx;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(sdbimp != NULL && *sdbimp != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews imp = *sdbimp;

3d711f2f75cb9a9ddcbf1fca9b2de192e75340e6Mark Andrews dns_db_unregister(&imp->dbimp);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews mctx = imp->mctx;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_put(mctx, imp, sizeof(dns_sdbimplementation_t));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_detach(&mctx);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews *sdbimp = NULL;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews}

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsdns_sdb_putrr(dns_sdblookup_t *lookup, const char *type, dns_ttl_t ttl,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews const char *data)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews{

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdatalist_t *rdatalist;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdata_t *rdata;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdatatype_t typeval;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_consttextregion_t r;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_buffer_t b;

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews isc_buffer_t *rdatabuf;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_lex_t *lex;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_result_t result;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews unsigned int size;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_t *mctx;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_sdbimplementation_t *imp;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_name_t *origin;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(VALID_SDBLOOKUP(lookup));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(type != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews REQUIRE(data != NULL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews mctx = lookup->sdb->common.mctx;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews r.base = type;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews r.length = strlen(type);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = dns_rdatatype_fromtext(&typeval, (isc_textregion_t *)&r);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews return (result);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatalist = ISC_LIST_HEAD(lookup->lists);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews while (rdatalist != NULL) {

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdatalist->type == typeval)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews break;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatalist = ISC_LIST_NEXT(rdatalist, link);

3001a1b4e6298466882a4147307b4c28a3b08f91Mark Andrews }

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdatalist == NULL) {

3001a1b4e6298466882a4147307b4c28a3b08f91Mark Andrews rdatalist = isc_mem_get(mctx, sizeof(dns_rdatalist_t));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdatalist == NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (ISC_R_NOMEMORY);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatalist->rdclass = lookup->sdb->common.rdclass;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatalist->type = typeval;

3001a1b4e6298466882a4147307b4c28a3b08f91Mark Andrews rdatalist->covers = 0;

3001a1b4e6298466882a4147307b4c28a3b08f91Mark Andrews rdatalist->ttl = ttl;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews ISC_LIST_INIT(rdatalist->rdata);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews ISC_LINK_INIT(rdatalist, link);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews ISC_LIST_APPEND(lookup->lists, rdatalist, link);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews } else

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdatalist->ttl != ttl)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (DNS_R_BADTTL);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdata = isc_mem_get(mctx, sizeof(dns_rdata_t));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdata == NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (ISC_R_NOMEMORY);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews dns_rdata_init(rdata);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews imp = lookup->sdb->implementation;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if ((imp->flags & DNS_SDBFLAG_RELATIVERDATA) != 0)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews origin = &lookup->sdb->common.origin;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews else

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews origin = dns_rootname;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews lex = NULL;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = isc_lex_create(mctx, 64, &lex);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews goto failure;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews size = 64;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews do {

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews isc_buffer_init(&b, data, strlen(data));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_buffer_add(&b, strlen(data));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = isc_lex_openbuffer(lex, &b);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews goto failure;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatabuf = NULL;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = isc_buffer_allocate(mctx, &rdatabuf, size);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews goto failure;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews result = dns_rdata_fromtext(rdata, rdatalist->rdclass,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews rdatalist->type, lex,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews origin, ISC_FALSE,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews mctx, rdatabuf,

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews &lookup->callbacks);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews isc_buffer_free(&rdatabuf);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews size *= 2;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews } while (result == ISC_R_NOSPACE);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (result != ISC_R_SUCCESS)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews goto failure;

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews ISC_LIST_APPEND(rdatalist->rdata, rdata, link);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews ISC_LIST_APPEND(lookup->buffers, rdatabuf, link);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

28784b996be9f5f8939883a77a8fa4daccd873c3Mark Andrews if (lex != NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_lex_destroy(&lex);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (ISC_R_SUCCESS);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews failure:

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (rdatabuf != NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_buffer_free(&rdatabuf);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews if (lex != NULL)

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_lex_destroy(&lex);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews return (result);

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews}

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrews

cf69e3d8b23f473dce7d07a926a3284d614f363bMark Andrewsdns_sdb_putnamedrr(dns_sdballnodes_t *allnodes, const char *name,

67d01dcacb2051a03377c8ec5c0e36604c17aea5Evan Hunt const char *type, dns_ttl_t ttl, const char *data)

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt{

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_name_t *newname, *origin;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt dns_fixedname_t fnewname;

30eec077db2bdcb6f2a0dc388a3cdde2ede75ec1Mark Andrews dns_sdb_t *sdb = (dns_sdb_t *)allnodes->common.db;

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews dns_sdbimplementation_t *imp = sdb->implementation;

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews dns_sdbnode_t *sdbnode;

30eec077db2bdcb6f2a0dc388a3cdde2ede75ec1Mark Andrews isc_mem_t *mctx = sdb->common.mctx;

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews isc_buffer_t b;

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews isc_result_t result;

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews dns_fixedname_init(&fnewname);

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews newname = dns_fixedname_name(&fnewname);

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews if ((imp->flags & DNS_SDBFLAG_RELATIVERDATA) != 0)

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews origin = &sdb->common.origin;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt else

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt origin = dns_rootname;

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt isc_buffer_init(&b, name, strlen(name));

6cf369f528c4acd8182eada41ad83b8d97623db8Mark Andrews isc_buffer_add(&b, strlen(name));

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein result = dns_name_fromtext(newname, &b, origin, ISC_FALSE, NULL);

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt if (result != ISC_R_SUCCESS)

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt return (result);

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein if (allnodes->common.relative_names) {

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein /* All names are relative to the root */

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein unsigned int nlabels = dns_name_countlabels(newname);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein dns_name_getlabelsequence(newname, 0, nlabels - 1, newname);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein }

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein sdbnode = ISC_LIST_HEAD(allnodes->nodelist);

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein if (sdbnode == NULL || !dns_name_equal(sdbnode->name, newname)) {

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt sdbnode = NULL;

268a4475065fe6a8cd7cc707820982cf5e98f430Rob Austein result = createnode(sdb, &sdbnode);

14a656f94b1fd0ababd84a772228dfa52276ba15Evan Hunt if (result != ISC_R_SUCCESS)

return (result);

sdbnode->name = isc_mem_get(mctx, sizeof(dns_name_t));

if (sdbnode->name == NULL) {

destroynode(sdbnode);

return (ISC_R_NOMEMORY);

}

dns_name_init(sdbnode->name, NULL);

result = dns_name_dup(newname, mctx, sdbnode->name);

if (result != ISC_R_SUCCESS) {

isc_mem_put(mctx, sdbnode->name, sizeof(dns_name_t));

destroynode(sdbnode);

return (result);

}

ISC_LIST_PREPEND(allnodes->nodelist, sdbnode, link);

if (allnodes->origin == NULL &&

dns_name_equal(newname, &sdb->common.origin))

allnodes->origin = sdbnode;

}

return (dns_sdb_putrr(sdbnode, type, ttl, data));

}

dns_sdb_putsoa(dns_sdblookup_t *lookup, const char *mname, const char *rname,

isc_uint32_t serial)

{

char str[2 * DNS_NAME_MAXTEXT + 5 * (sizeof("2147483647")) + 7];

int n;

REQUIRE(mname != NULL);

REQUIRE(rname != NULL);

n = snprintf(str, sizeof str, "%s %s %u %u %u %u %u",

mname, rname, serial,

SDB_DEFAULT_REFRESH, SDB_DEFAULT_RETRY,

SDB_DEFAULT_EXPIRE, SDB_DEFAULT_MINIMUM);

if (n >= (int)sizeof(str) || n < 0)

return (ISC_R_NOSPACE);

return (dns_sdb_putrr(lookup, "SOA", SDB_DEFAULT_TTL, str));

}

static void

attach(dns_db_t *source, dns_db_t **targetp) {

dns_sdb_t *sdb = (dns_sdb_t *) source;

REQUIRE(VALID_SDB(sdb));

LOCK(&sdb->lock);

REQUIRE(sdb->references > 0);

sdb->references++;

UNLOCK(&sdb->lock);

*targetp = source;

}

static void

destroy(dns_sdb_t *sdb) {

isc_mem_t *mctx;

dns_sdbimplementation_t *imp = sdb->implementation;

mctx = sdb->common.mctx;

if (imp->methods->destroy != NULL)

imp->methods->destroy(sdb->zone, imp->driverdata,

&sdb->dbdata);

isc_mem_free(mctx, sdb->zone);

DESTROYLOCK(&sdb->lock);

sdb->common.magic = 0;

sdb->common.impmagic = 0;

dns_name_free(&sdb->common.origin, mctx);

isc_mem_put(mctx, sdb, sizeof(dns_sdb_t));

isc_mem_detach(&mctx);

}

static void

detach(dns_db_t **dbp) {

dns_sdb_t *sdb = (dns_sdb_t *)(*dbp);

isc_boolean_t need_destroy = ISC_FALSE;

REQUIRE(VALID_SDB(sdb));

LOCK(&sdb->lock);

REQUIRE(sdb->references > 0);

sdb->references--;

if (sdb->references == 0)

need_destroy = ISC_TRUE;

UNLOCK(&sdb->lock);

if (need_destroy)

destroy(sdb);

*dbp = NULL;

}

static isc_result_t

beginload(dns_db_t *db, dns_addrdatasetfunc_t *addp, dns_dbload_t **dbloadp) {

UNUSED(db);

UNUSED(addp);

UNUSED(dbloadp);

return (ISC_R_NOTIMPLEMENTED);

}

static isc_result_t

endload(dns_db_t *db, dns_dbload_t **dbloadp) {

UNUSED(db);

UNUSED(dbloadp);

return (ISC_R_NOTIMPLEMENTED);

}

static isc_result_t

dump(dns_db_t *db, dns_dbversion_t *version, const char *filename) {

UNUSED(db);

UNUSED(version);

UNUSED(filename);

return (ISC_R_NOTIMPLEMENTED);

}

static void

currentversion(dns_db_t *db, dns_dbversion_t **versionp) {

REQUIRE(versionp != NULL && *versionp == NULL);

UNUSED(db);

*versionp = (void *) &dummy;

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)

{

REQUIRE(source != NULL && source == (void *) &dummy);

UNUSED(db);

UNUSED(source);

UNUSED(targetp);

return;

}

static void

closeversion(dns_db_t *db, dns_dbversion_t **versionp, isc_boolean_t commit) {

REQUIRE(versionp != NULL && *versionp == (void *) &dummy);

REQUIRE(commit == ISC_FALSE);

UNUSED(db);

UNUSED(commit);

*versionp = NULL;

}

static isc_result_t

createnode(dns_sdb_t *sdb, dns_sdbnode_t **nodep) {

dns_sdbnode_t *node;

isc_result_t result;

node = isc_mem_get(sdb->common.mctx, sizeof(dns_sdbnode_t));

if (node == NULL)

return (ISC_R_NOMEMORY);

node->sdb = NULL;

attach((dns_db_t *)sdb, (dns_db_t **)&node->sdb);

ISC_LIST_INIT(node->lists);

ISC_LIST_INIT(node->buffers);

ISC_LINK_INIT(node, link);

node->name = NULL;

result = isc_mutex_init(&node->lock);

if (result != ISC_R_SUCCESS) {

isc_mem_put(sdb->common.mctx, sdb, sizeof(dns_sdb_t));

UNEXPECTED_ERROR(__FILE__, __LINE__,

"isc_mutex_init() failed: %s",

isc_result_totext(result));

isc_mem_put(sdb->common.mctx, node, sizeof(dns_sdbnode_t));

return (ISC_R_UNEXPECTED);

}

dns_rdatacallbacks_init(&node->callbacks);

node->references = 1;

node->magic = SDBLOOKUP_MAGIC;

*nodep = node;

return (ISC_R_SUCCESS);

}

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;

sdb = node->sdb;

mctx = sdb->common.mctx;

while (!ISC_LIST_EMPTY(node->lists)) {

list = ISC_LIST_HEAD(node->lists);

while (!ISC_LIST_EMPTY(list->rdata)) {

rdata = ISC_LIST_HEAD(list->rdata);

ISC_LIST_UNLINK(list->rdata, rdata, link);

isc_mem_put(mctx, rdata, sizeof(dns_rdata_t));

}

ISC_LIST_UNLINK(node->lists, list, link);

isc_mem_put(mctx, list, sizeof(dns_rdatalist_t));

}

while (!ISC_LIST_EMPTY(node->buffers)) {

b = ISC_LIST_HEAD(node->buffers);

ISC_LIST_UNLINK(node->buffers, b, link);

isc_buffer_free(&b);

}

if (node->name != NULL) {

dns_name_free(node->name, mctx);

isc_mem_put(mctx, node->name, sizeof(dns_name_t));

}

DESTROYLOCK(&node->lock);

node->magic = 0;

isc_mem_put(mctx, node, sizeof(dns_sdbnode_t));

detach((dns_db_t **)&sdb);

}

static isc_result_t

findnode(dns_db_t *db, dns_name_t *name, isc_boolean_t create,

dns_dbnode_t **nodep)

{

dns_sdb_t *sdb = (dns_sdb_t *)db;

dns_sdbnode_t *node = NULL;

isc_result_t result;

isc_buffer_t b;

char namestr[DNS_NAME_MAXTEXT + 1];

isc_boolean_t isorigin;

dns_sdbimplementation_t *imp;

REQUIRE(VALID_SDB(sdb));

REQUIRE(create == ISC_FALSE);

REQUIRE(nodep != NULL && *nodep == NULL);

UNUSED(name);

UNUSED(create);

imp = sdb->implementation;

isc_buffer_init(&b, namestr, sizeof(namestr));

if ((imp->flags & DNS_SDBFLAG_RELATIVEOWNER) != 0) {

dns_name_t relname;

unsigned int labels;

labels = dns_name_countlabels(name) -

dns_name_countlabels(&db->origin);

dns_name_init(&relname, NULL);

dns_name_getlabelsequence(name, 0, labels, &relname);

result = dns_name_totext(&relname, ISC_TRUE, &b);

if (result != ISC_R_SUCCESS)

return (result);

} else {

result = dns_name_totext(name, ISC_TRUE, &b);

if (result != ISC_R_SUCCESS)

return (result);

}

isc_buffer_putuint8(&b, 0);

result = createnode(sdb, &node);

if (result != ISC_R_SUCCESS)

return (result);

isorigin = dns_name_equal(name, &sdb->common.origin);

MAYBE_LOCK(sdb);

result = imp->methods->lookup(sdb->zone, namestr, sdb->dbdata, node);

MAYBE_UNLOCK(sdb);

if (result != ISC_R_SUCCESS && !isorigin) {

destroynode(node);

return (result);

}

if (isorigin && imp->methods->authority != NULL) {

MAYBE_LOCK(sdb);

result = imp->methods->authority(sdb->zone, sdb->dbdata, node);

MAYBE_UNLOCK(sdb);

if (result != ISC_R_SUCCESS) {

destroynode(node);

return (result);

}

}

*nodep = node;

return (ISC_R_SUCCESS);

}

static isc_result_t

find(dns_db_t *db, dns_name_t *name, dns_dbversion_t *version,

dns_rdatatype_t type, unsigned int options, isc_stdtime_t now,

dns_dbnode_t **nodep, dns_name_t *foundname,

dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)

{

dns_sdb_t *sdb = (dns_sdb_t *)db;

dns_dbnode_t *node = NULL;

dns_fixedname_t fname;

dns_rdataset_t xrdataset;

dns_name_t *xname;

unsigned int nlabels, olabels;

isc_result_t result;

unsigned int i;

REQUIRE(VALID_SDB(sdb));

REQUIRE(nodep == NULL || *nodep == NULL);

REQUIRE(version == NULL || version == (void *) &dummy);

UNUSED(options);

UNUSED(sigrdataset);

UNUSED(sdb);

if (!dns_name_issubdomain(name, &db->origin))

return (DNS_R_NXDOMAIN);

olabels = dns_name_countlabels(&db->origin);

nlabels = dns_name_countlabels(name);

dns_fixedname_init(&fname);

xname = dns_fixedname_name(&fname);

if (rdataset == NULL)

rdataset = &xrdataset;

result = DNS_R_NXDOMAIN;

for (i = olabels; i <= nlabels; i++) {

/*

if (i == olabels && i != nlabels)

continue;

/*

dns_name_getlabelsequence(name, nlabels - i, i, xname);

result = findnode(db, xname, ISC_FALSE, &node);

if (result != ISC_R_SUCCESS) {

result = DNS_R_NXDOMAIN;

continue;

}

/*

if (i < nlabels) {

result = findrdataset(db, node, version,

dns_rdatatype_dname,

0, now, rdataset, sigrdataset);

if (result == ISC_R_SUCCESS) {

if (type != dns_rdatatype_dname)

result = DNS_R_DNAME;

break;

}

}

/*

if (i != olabels && (options & DNS_DBFIND_GLUEOK) == 0) {

result = findrdataset(db, node, version,

dns_rdatatype_ns,

0, now, rdataset, sigrdataset);

if (result == ISC_R_SUCCESS) {

if (type != dns_rdatatype_ns)

result = DNS_R_DELEGATION;

break;

}

}

/*

if (i < nlabels) {

destroynode(node);

node = NULL;

continue;

}

/*

if (type == dns_rdatatype_any) {

result = ISC_R_SUCCESS;

break;

}

/*

result = findrdataset(db, node, version, type,

0, now, rdataset, sigrdataset);

if (result == ISC_R_SUCCESS)

break;

/*

if (type != dns_rdatatype_cname) {

result = findrdataset(db, node, version,

dns_rdatatype_cname,

0, now, rdataset, sigrdataset);

if (result == ISC_R_SUCCESS) {

result = DNS_R_CNAME;

break;

}

}

result = DNS_R_NXRRSET;

break;

}

if (rdataset == &xrdataset && dns_rdataset_isassociated(rdataset))

dns_rdataset_disassociate(rdataset);

if (foundname != NULL) {

isc_result_t xresult;

xresult = dns_name_concatenate(xname, NULL, foundname, NULL);

if (xresult != ISC_R_SUCCESS) {

destroynode(node);

if (dns_rdataset_isassociated(rdataset))

dns_rdataset_disassociate(rdataset);

return (DNS_R_BADDB);

}

}

if (nodep != NULL)

*nodep = node;

else if (node != NULL)

detachnode(db, &node);

return (result);

}

static isc_result_t

findzonecut(dns_db_t *db, dns_name_t *name, unsigned int options,

isc_stdtime_t now, dns_dbnode_t **nodep, dns_name_t *foundname,

dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset)

{

UNUSED(db);

UNUSED(name);

UNUSED(options);

UNUSED(now);

UNUSED(nodep);

UNUSED(foundname);

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;

dns_sdbnode_t *node = (dns_sdbnode_t *)source;

REQUIRE(VALID_SDB(sdb));

UNUSED(sdb);

LOCK(&node->lock);

INSIST(node->references > 0);

node->references++;

INSIST(node->references != 0); /* Catch overflow. */

UNLOCK(&node->lock);

*targetp = source;

}

static void

detachnode(dns_db_t *db, dns_dbnode_t **targetp) {

dns_sdb_t *sdb = (dns_sdb_t *)db;

dns_sdbnode_t *node;

isc_boolean_t need_destroy = ISC_FALSE;

REQUIRE(VALID_SDB(sdb));

REQUIRE(targetp != NULL && *targetp != NULL);

UNUSED(sdb);

node = (dns_sdbnode_t *)(*targetp);

LOCK(&node->lock);

INSIST(node->references > 0);

node->references--;

if (node->references == 0)

need_destroy = ISC_TRUE;

UNLOCK(&node->lock);

if (need_destroy)

destroynode(node);

*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);

INSIST(0);

return (ISC_R_UNEXPECTED);

}

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, isc_boolean_t relative_names,

dns_dbiterator_t **iteratorp)

{

dns_sdb_t *sdb = (dns_sdb_t *)db;

sdb_dbiterator_t *sdbiter;

dns_sdbimplementation_t *imp = sdb->implementation;

isc_result_t result;

REQUIRE(VALID_SDB(sdb));

if (imp->methods->allnodes == NULL)

return (ISC_R_NOTIMPLEMENTED);

sdbiter = isc_mem_get(sdb->common.mctx, sizeof(sdb_dbiterator_t));

if (sdbiter == NULL)

return (ISC_R_NOMEMORY);

sdbiter->common.methods = &dbiterator_methods;

sdbiter->common.db = NULL;

dns_db_attach(db, &sdbiter->common.db);

sdbiter->common.relative_names = relative_names;

sdbiter->common.magic = DNS_DBITERATOR_MAGIC;

ISC_LIST_INIT(sdbiter->nodelist);

sdbiter->current = NULL;

sdbiter->origin = NULL;

MAYBE_LOCK(sdb);

result = imp->methods->allnodes(sdb->zone, sdb->dbdata, sdbiter);

MAYBE_UNLOCK(sdb);

if (result != ISC_R_SUCCESS) {

dbiterator_destroy((dns_dbiterator_t **)&sdbiter);

return (result);

}

if (sdbiter->origin != NULL) {

ISC_LIST_UNLINK(sdbiter->nodelist, sdbiter->origin, link);

ISC_LIST_PREPEND(sdbiter->nodelist, sdbiter->origin, link);

}

*iteratorp = (dns_dbiterator_t *)sdbiter;

return (ISC_R_SUCCESS);

}

static isc_result_t

findrdataset(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,

dns_rdatatype_t type, dns_rdatatype_t covers,

isc_stdtime_t now, dns_rdataset_t *rdataset,

dns_rdataset_t *sigrdataset)

{

dns_rdatalist_t *list;

dns_sdbnode_t *sdbnode = (dns_sdbnode_t *)node;

REQUIRE(VALID_SDBNODE(node));

UNUSED(db);

UNUSED(version);

UNUSED(covers);

UNUSED(now);

UNUSED(sigrdataset);

if (type == dns_rdatatype_sig)

return (ISC_R_NOTIMPLEMENTED);

list = ISC_LIST_HEAD(sdbnode->lists);

while (list != NULL) {

if (list->type == type)

break;

list = ISC_LIST_NEXT(list, link);

}

if (list == NULL)

return (ISC_R_NOTFOUND);

list_tordataset(list, db, node, rdataset);

return (ISC_R_SUCCESS);

}

static isc_result_t

allrdatasets(dns_db_t *db, dns_dbnode_t *node, dns_dbversion_t *version,

isc_stdtime_t now, dns_rdatasetiter_t **iteratorp)

{

sdb_rdatasetiter_t *iterator;

REQUIRE(version == NULL || version == &dummy);

UNUSED(version);

UNUSED(now);

iterator = isc_mem_get(db->mctx, sizeof(sdb_rdatasetiter_t));

if (iterator == NULL)

return (ISC_R_NOMEMORY);

iterator->common.magic = DNS_RDATASETITER_MAGIC;

iterator->common.methods = &rdatasetiter_methods;

iterator->common.db = db;

iterator->common.node = NULL;

attachnode(db, node, &iterator->common.node);

iterator->common.version = version;

iterator->common.now = now;

*iteratorp = (dns_rdatasetiter_t *)iterator;

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 isc_boolean_t

issecure(dns_db_t *db) {

UNUSED(db);

return (ISC_FALSE);

}

static unsigned int

nodecount(dns_db_t *db) {

UNUSED(db);

return (0);

}

static isc_boolean_t

ispersistent(dns_db_t *db) {

UNUSED(db);

return (ISC_TRUE);

}

static void

overmem(dns_db_t *db, isc_boolean_t overmem) {

UNUSED(db);

UNUSED(overmem);

}

static dns_dbmethods_t sdb_methods = {

attach,

detach,

beginload,

endload,

dump,

currentversion,

newversion,

attachversion,

closeversion,

findnode,

find,

findzonecut,

attachnode,

detachnode,

expirenode,

printnode,

createiterator,

findrdataset,

allrdatasets,

addrdataset,

subtractrdataset,

deleterdataset,

issecure,

nodecount,

ispersistent,

overmem

};

static isc_result_t

dns_sdb_create(isc_mem_t *mctx, 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;

isc_result_t result;

char zonestr[DNS_NAME_MAXTEXT + 1];

isc_buffer_t b;

dns_sdbimplementation_t *imp;

REQUIRE(driverarg != NULL);

imp = driverarg;

if (type != dns_dbtype_zone)

return (ISC_R_NOTIMPLEMENTED);

sdb = isc_mem_get(mctx, sizeof(dns_sdb_t));

if (sdb == NULL)

return (ISC_R_NOMEMORY);

memset(sdb, 0, sizeof(dns_sdb_t));

dns_name_init(&sdb->common.origin, NULL);

sdb->common.attributes = 0;

sdb->common.methods = &sdb_methods;

sdb->common.rdclass = rdclass;

sdb->common.mctx = NULL;

sdb->implementation = imp;

isc_mem_attach(mctx, &sdb->common.mctx);

result = isc_mutex_init(&sdb->lock);

if (result != ISC_R_SUCCESS) {

isc_mem_put(mctx, sdb, sizeof(dns_sdb_t));

UNEXPECTED_ERROR(__FILE__, __LINE__,

"isc_mutex_init() failed: %s",

isc_result_totext(result));

isc_mem_detach(&sdb->common.mctx);

return (ISC_R_UNEXPECTED);

}

result = dns_name_dupwithoffsets(origin, mctx, &sdb->common.origin);

if (result != ISC_R_SUCCESS) {

destroy(sdb);

return (result);

}

isc_buffer_init(&b, zonestr, sizeof(zonestr));

result = dns_name_totext(origin, ISC_TRUE, &b);

if (result != ISC_R_SUCCESS) {

destroy(sdb);

return (result);

}

isc_buffer_putuint8(&b, 0);

sdb->zone = isc_mem_strdup(mctx, zonestr);

if (sdb->zone == NULL) {

destroy(sdb);

return (ISC_R_NOMEMORY);

}

sdb->dbdata = NULL;

if (imp->methods->create != NULL) {

result = imp->methods->create(sdb->zone, argc, argv,

imp->driverdata, &sdb->dbdata);

if (result != ISC_R_SUCCESS) {

destroy(sdb);

return (result);

}

}

sdb->references = 1;

sdb->common.magic = DNS_DB_MAGIC;

sdb->common.impmagic = SDB_MAGIC;

*dbp = (dns_db_t *)sdb;

return (ISC_R_SUCCESS);

}

static void

disassociate(dns_rdataset_t *rdataset) {

dns_dbnode_t *node = rdataset->private5;

dns_sdbnode_t *sdbnode = (dns_sdbnode_t *) node;

dns_db_t *db = (dns_db_t *) sdbnode->sdb;

detachnode(db, &node);

isc__rdatalist_disassociate(rdataset);

}

static dns_rdatasetmethods_t methods = {

disassociate,

isc__rdatalist_first,

isc__rdatalist_next,

isc__rdatalist_current,

isc__rdatalist_clone,

isc__rdatalist_count

};

static void

list_tordataset(dns_rdatalist_t *rdatalist,

dns_db_t *db, dns_dbnode_t *node,

dns_rdataset_t *rdataset)

{

/* This should never fail. */

RUNTIME_CHECK(dns_rdatalist_tordataset(rdatalist, rdataset) ==

ISC_R_SUCCESS);

rdataset->methods = &methods;

dns_db_attachnode(db, node, &rdataset->private5);

}

static void

dbiterator_destroy(dns_dbiterator_t **iteratorp) {

sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)(*iteratorp);

dns_sdb_t *sdb = (dns_sdb_t *)sdbiter->common.db;

while (!ISC_LIST_EMPTY(sdbiter->nodelist)) {

dns_sdbnode_t *node;

node = ISC_LIST_HEAD(sdbiter->nodelist);

ISC_LIST_UNLINK(sdbiter->nodelist, node, link);

destroynode(node);

}

dns_db_detach(&sdbiter->common.db);

isc_mem_put(sdb->common.mctx, sdbiter, sizeof(sdb_dbiterator_t));

*iteratorp = NULL;

}

static isc_result_t

dbiterator_first(dns_dbiterator_t *iterator) {

sdb_dbiterator_t *sdbiter = (sdb_dbiterator_t *)iterator;

sdbiter->current = ISC_LIST_HEAD(sdbiter->nodelist);

if (sdbiter->current == NULL)

return (ISC_R_NOMORE);

else

return (ISC_R_SUCCESS);

}