#include <config.h>

#include <isc/file.h>

#include <isc/print.h>

#include <isc/random.h>

#include <isc/ratelimiter.h>

#include <isc/serial.h>

#include <isc/string.h>

#include <isc/taskpool.h>

#include <isc/timer.h>

#include <isc/util.h>

#include <dns/acl.h>

#include <dns/adb.h>

#include <dns/callbacks.h>

#include <dns/db.h>

#include <dns/events.h>

#include <dns/journal.h>

#include <dns/log.h>

#include <dns/master.h>

#include <dns/masterdump.h>

#include <dns/message.h>

#include <dns/name.h>

#include <dns/peer.h>

#include <dns/rcode.h>

#include <dns/rdatalist.h>

#include <dns/rdataset.h>

#include <dns/rdatastruct.h>

#include <dns/request.h>

#include <dns/resolver.h>

#include <dns/result.h>

#include <dns/ssu.h>

#include <dns/tsig.h>

#include <dns/xfrin.h>

#include <dns/zone.h>

#define ZONE_MAGIC 0x5a4f4e45U /* ZONE */

#define NOTIFY_MAGIC 0x4e746679U /* Ntfy */

#define STUB_MAGIC 0x53747562U /* Stub */

#define ZONEMGR_MAGIC 0x5a6d6772U /* Zmgr */

#define LOAD_MAGIC ISC_MAGIC('L','o','a','d')

#define FORWARD_MAGIC ISC_MAGIC('F','o','r','w')

#define IO_MAGIC ISC_MAGIC('Z','m','I','O')

#define DNS_ZONE_VALID(zone) \

ISC_MAGIC_VALID(zone, ZONE_MAGIC)

#define DNS_NOTIFY_VALID(notify) \

ISC_MAGIC_VALID(notify, NOTIFY_MAGIC)

#define DNS_STUB_VALID(stub) \

ISC_MAGIC_VALID(stub, STUB_MAGIC)

#define DNS_ZONEMGR_VALID(stub) \

ISC_MAGIC_VALID(stub, ZONEMGR_MAGIC)

#define DNS_LOAD_VALID(load) \

ISC_MAGIC_VALID(load, LOAD_MAGIC)

#define DNS_FORWARD_VALID(load) \

ISC_MAGIC_VALID(load, FORWARD_MAGIC)

#define DNS_IO_VALID(load) \

ISC_MAGIC_VALID(load, IO_MAGIC)

#define RANGE(a, b, c) (((a) < (b)) ? (b) : ((a) < (c) ? (a) : (c)))

#define DNS_DEFAULT_IDLEIN 3600 /* 1 hour */

#define DNS_DEFAULT_IDLEOUT 3600 /* 1 hour */

#define MAX_XFER_TIME (2*3600) /* Documented default is 2 hours */

#ifndef DNS_MAX_EXPIRE

#define DNS_MAX_EXPIRE 14515200 /* 24 weeks */

#endif

#ifndef DNS_DUMP_DELAY

#define DNS_DUMP_DELAY 900 /* 15 minutes */

#endif

typedef struct dns_notify dns_notify_t;

typedef struct dns_stub dns_stub_t;

typedef struct dns_load dns_load_t;

typedef struct dns_forward dns_forward_t;

typedef struct dns_io dns_io_t;

typedef ISC_LIST(dns_io_t) dns_iolist_t;

struct dns_zone {

/* Unlocked */

unsigned int magic;

isc_mutex_t lock;

isc_mem_t *mctx;

/* Locked */

dns_db_t *db;

dns_zonemgr_t *zmgr;

ISC_LINK(dns_zone_t) link; /* Used by zmgr. */

isc_timer_t *timer;

unsigned int erefs;

unsigned int irefs;

dns_name_t origin;

char *dbname;

char *journal;

isc_int32_t journalsize;

dns_rdataclass_t rdclass;

dns_zonetype_t type;

unsigned int flags;

unsigned int options;

unsigned int db_argc;

char **db_argv;

isc_stdtime_t expiretime;

isc_stdtime_t refreshtime;

isc_stdtime_t dumptime;

isc_time_t loadtime;

isc_uint32_t serial;

isc_uint32_t refresh;

isc_uint32_t retry;

isc_uint32_t expire;

isc_uint32_t minimum;

isc_uint32_t maxrefresh;

isc_uint32_t minrefresh;

isc_uint32_t maxretry;

isc_uint32_t minretry;

#ifndef NOMINUM_PUBLIC

isc_uint32_t maxnames;

#endif /* NOMINUM_PUBLIC */

isc_sockaddr_t *masters;

#ifndef NOMINUM_PUBLIC

dns_name_t **masterkeynames;

#endif /* NOMINUM_PUBLIC */

unsigned int masterscnt;

unsigned int curmaster;

isc_sockaddr_t masteraddr;

dns_notifytype_t notifytype;

isc_sockaddr_t *notify;

unsigned int notifycnt;

isc_sockaddr_t notifyfrom;

isc_task_t *task;

isc_sockaddr_t xfrsource4;

isc_sockaddr_t xfrsource6;

dns_xfrin_ctx_t *xfr;

/* Access Control Lists */

dns_acl_t *update_acl;

#ifndef NOMINUM_PUBLIC

dns_acl_t *notify_acl;

#endif /* NOMINUM_PUBLIC */

dns_acl_t *query_acl;

dns_acl_t *xfr_acl;

dns_severity_t check_names;

ISC_LIST(dns_notify_t) notifies;

dns_request_t *request;

dns_io_t *readio;

isc_uint32_t maxxfrin;

isc_uint32_t maxxfrout;

isc_uint32_t idlein;

isc_uint32_t idleout;

isc_boolean_t diff_on_reload;

isc_event_t ctlevent;

dns_ssutable_t *ssutable;

isc_uint32_t sigvalidityinterval;

dns_view_t *view;

/*

ISC_LINK(dns_zone_t) statelink;

dns_zonelist_t *statelist;

};

#define DNS_ZONE_FLAG(z,f) (((z)->flags & (f)) != 0)

/* XXX MPA these may need to go back into zone.h */

#define DNS_ZONEFLG_REFRESH 0x00000001U /* refresh check in progress */

#define DNS_ZONEFLG_NEEDDUMP 0x00000002U /* zone need consolidation */

#define DNS_ZONEFLG_USEVC 0x00000004U /* use tcp for refresh query */

#define DNS_ZONEFLG_DUMPING 0x00000008U /* a dump is in progress */

/* #define DNS_ZONEFLG_UNUSED 0x00000010U */ /* unused */

#define DNS_ZONEFLG_LOADED 0x00000020U /* database has loaded */

#define DNS_ZONEFLG_EXITING 0x00000040U /* zone is being destroyed */

#define DNS_ZONEFLG_EXPIRED 0x00000080U /* zone has expired */

#define DNS_ZONEFLG_NEEDREFRESH 0x00000100U /* refresh check needed */

#define DNS_ZONEFLG_UPTODATE 0x00000200U /* zone contents are

#define DNS_ZONEFLG_NEEDNOTIFY 0x00000400U /* need to send out notify

#define DNS_ZONEFLG_DIFFONRELOAD 0x00000800U /* generate a journal diff on

#define DNS_ZONEFLG_NOMASTERS 0x00001000U /* an attempt to refresh a

#define DNS_ZONEFLG_LOADING 0x00002000U /* load from disk in progress */

#define DNS_ZONEFLG_HAVETIMERS 0x00004000U /* timer values have been set from

#define DNS_ZONE_OPTION(z,o) (((z)->options & (o)) != 0)

struct dns_zonemgr {

unsigned int magic;

isc_mem_t * mctx;

int refs; /* Locked by rwlock */

isc_taskmgr_t * taskmgr;

isc_timermgr_t * timermgr;

isc_socketmgr_t * socketmgr;

isc_taskpool_t * zonetasks;

isc_task_t * task;

isc_ratelimiter_t * rl;

isc_rwlock_t rwlock;

isc_rwlock_t conflock;

isc_mutex_t iolock;

/* Locked by rwlock. */

dns_zonelist_t zones;

dns_zonelist_t waiting_for_xfrin;

dns_zonelist_t xfrin_in_progress;

/* Locked by conflock. */

int transfersin;

int transfersperns;

/* Locked by iolock */

isc_uint32_t iolimit;

isc_uint32_t ioactive;

dns_iolist_t high;

dns_iolist_t low;

};

struct dns_notify {

isc_int32_t magic;

#ifndef NOMINUM_PUBLIC

unsigned int flags;

#endif /* NOMINUM_PUBLIC */

isc_mem_t *mctx;

dns_zone_t *zone;

dns_adbfind_t *find;

dns_request_t *request;

dns_name_t ns;

isc_sockaddr_t dst;

ISC_LINK(dns_notify_t) link;

};

#ifndef NOMINUM_PUBLIC

#define DNS_NOTIFY_NOSOA 0x0001U

#endif /* NOMINUM_PUBLIC */

struct dns_stub {

isc_int32_t magic;

isc_mem_t *mctx;

dns_zone_t *zone;

dns_db_t *db;

dns_dbversion_t *version;

};

struct dns_load {

isc_int32_t magic;

isc_mem_t *mctx;

dns_zone_t *zone;

dns_db_t *db;

isc_time_t loadtime;

dns_rdatacallbacks_t callbacks;

};

struct dns_forward {

isc_int32_t magic;

isc_mem_t *mctx;

dns_zone_t *zone;

isc_buffer_t *msgbuf;

dns_request_t *request;

isc_uint32_t which;

isc_sockaddr_t addr;

dns_updatecallback_t callback;

void *callback_arg;

};

struct dns_io {

isc_int32_t magic;

dns_zonemgr_t *zmgr;

isc_boolean_t high;

isc_task_t *task;

ISC_LINK(dns_io_t) link;

isc_event_t *event;

};

static isc_result_t zone_settimer(dns_zone_t *, isc_stdtime_t);

static void cancel_refresh(dns_zone_t *);

static void zone_log(dns_zone_t *zone, const char *, int, const char *msg,

...);

static void notify_log(dns_zone_t *zone, int level, const char *fmt, ...);

static void queue_xfrin(dns_zone_t *zone);

static void zone_unload(dns_zone_t *zone);

static void zone_expire(dns_zone_t *zone);

#ifndef NOMINUM_PUBLIC

static void zone_deletefile(dns_zone_t *zone);

#endif /* NOMINUM_PUBLIC */

static isc_result_t zone_replacedb(dns_zone_t *zone, dns_db_t *db,

isc_boolean_t dump);

static isc_result_t default_journal(dns_zone_t *zone);

static void zone_xfrdone(dns_zone_t *zone, isc_result_t result);

static isc_result_t zone_postload(dns_zone_t *zone, dns_db_t *db,

isc_time_t loadtime, isc_result_t result);

static void zone_needdump(dns_zone_t *zone, unsigned int delay);

static void zone_shutdown(isc_task_t *, isc_event_t *);

static void zone_loaddone(void *arg, isc_result_t result);

static isc_result_t zone_startload(dns_db_t *db, dns_zone_t *zone,

isc_time_t loadtime);

#if 0

static void dns_zonemgr_dbdestroyed(isc_task_t *task, isc_event_t *event);

#endif

static void refresh_callback(isc_task_t *, isc_event_t *);

static void stub_callback(isc_task_t *, isc_event_t *);

static void queue_soa_query(dns_zone_t *zone);

static void soa_query(isc_task_t *, isc_event_t *);

static void ns_query(dns_zone_t *zone, dns_rdataset_t *soardataset,

dns_stub_t *stub);

static int message_count(dns_message_t *msg, dns_section_t section,

dns_rdatatype_t type);

static void notify_cancel(dns_zone_t *zone);

static void notify_find_address(dns_notify_t *notify);

static void notify_send(dns_notify_t *notify);

#ifdef NOMINUM_PUBLIC

static isc_result_t notify_createmessage(dns_zone_t *zone,

dns_message_t **messagep);

#else /* NOMINUM_PUBLIC */

static isc_result_t notify_createmessage(dns_zone_t *zone,

unsigned int flags,

dns_message_t **messagep);

static void zone_notifyforward(dns_zone_t *zone);

#endif /* NOMINUM_PUBLIC */

static void notify_done(isc_task_t *task, isc_event_t *event);

static void notify_send_toaddr(isc_task_t *task, isc_event_t *event);

static isc_result_t zone_dump(dns_zone_t *);

static void got_transfer_quota(isc_task_t *task, isc_event_t *event);

static isc_result_t zmgr_start_xfrin_ifquota(dns_zonemgr_t *zmgr,

dns_zone_t *zone);

static void zmgr_resume_xfrs(dns_zonemgr_t *zmgr);

static void zonemgr_free(dns_zonemgr_t *zmgr);

static isc_result_t zonemgr_getio(dns_zonemgr_t *zmgr, isc_boolean_t high,

isc_task_t *task, isc_taskaction_t action,

void *arg, dns_io_t **iop);

static void zonemgr_putio(dns_io_t **iop);

static void zonemgr_cancelio(dns_io_t *io);

static isc_result_t

zone_get_from_db(dns_db_t *db, dns_name_t *origin, unsigned int *nscount,

unsigned int *soacount, isc_uint32_t *serial,

isc_uint32_t *refresh, isc_uint32_t *retry,

isc_uint32_t *expire, isc_uint32_t *minimum);

static void zone_freedbargs(dns_zone_t *zone);

static void forward_callback(isc_task_t *task, isc_event_t *event);

static void zone_saveunique(dns_zone_t *zone, const char *path,

const char *templat);

#define ZONE_LOG(x,y) zone_log(zone, me, ISC_LOG_DEBUG(x), y)

#define DNS_ENTER zone_log(zone, me, ISC_LOG_DEBUG(1), "enter")

#define DNS_LEAVE zone_log(zone, me, ISC_LOG_DEBUG(1), "leave")

const unsigned int dbargc_default = 1;

const char *dbargv_default[] = { "rbt" };

dns_zone_create(dns_zone_t **zonep, isc_mem_t *mctx) {

isc_result_t result;

dns_zone_t *zone;

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

REQUIRE(mctx != NULL);

zone = isc_mem_get(mctx, sizeof *zone);

if (zone == NULL)

return (ISC_R_NOMEMORY);

result = isc_mutex_init(&zone->lock);

if (result != ISC_R_SUCCESS) {

isc_mem_put(mctx, zone, sizeof *zone);

UNEXPECTED_ERROR(__FILE__, __LINE__,

"isc_mutex_init() failed: %s",

isc_result_totext(result));

return (ISC_R_UNEXPECTED);

}

/* XXX MPA check that all elements are initialised */

zone->mctx = NULL;

isc_mem_attach(mctx, &zone->mctx);

zone->db = NULL;

zone->zmgr = NULL;

ISC_LINK_INIT(zone, link);

zone->erefs = 1; /* Implicit attach. */

zone->irefs = 0;

dns_name_init(&zone->origin, NULL);

zone->dbname = NULL;

zone->journalsize = -1;

zone->journal = NULL;

zone->rdclass = dns_rdataclass_none;

zone->type = dns_zone_none;

zone->flags = 0;

zone->options = 0;

zone->db_argc = 0;

zone->db_argv = NULL;

zone->expiretime = 0;

zone->refreshtime = 0;

zone->dumptime = 0;

isc_time_settoepoch(&zone->loadtime);

zone->serial = 0;

zone->refresh = DNS_ZONE_DEFAULTREFRESH;

zone->retry = DNS_ZONE_DEFAULTRETRY;

zone->expire = 0;

zone->minimum = 0;

zone->maxrefresh = DNS_ZONE_MAXREFRESH;

zone->minrefresh = DNS_ZONE_MINREFRESH;

zone->maxretry = DNS_ZONE_MAXRETRY;

zone->minretry = DNS_ZONE_MINRETRY;

#ifndef NOMINUM_PUBLIC

zone->maxnames = 0;

#endif /* NOMINUM_PUBLIC */

zone->masters = NULL;

#ifndef NOMINUM_PUBLIC

zone->masterkeynames = NULL;

#endif /* NOMINUM_PUBLIC */

zone->masterscnt = 0;

zone->curmaster = 0;

zone->notify = NULL;

zone->notifytype = dns_notifytype_yes;

zone->notifycnt = 0;

zone->task = NULL;

zone->update_acl = NULL;

#ifndef NOMINUM_PUBLIC

zone->notify_acl = NULL;

#endif /* NOMINUM_PUBLIC */

zone->query_acl = NULL;

zone->xfr_acl = NULL;

zone->check_names = dns_severity_ignore;

zone->request = NULL;

zone->readio = NULL;

zone->timer = NULL;

zone->idlein = DNS_DEFAULT_IDLEIN;

zone->idleout = DNS_DEFAULT_IDLEOUT;

ISC_LIST_INIT(zone->notifies);

isc_sockaddr_any(&zone->xfrsource4);

isc_sockaddr_any6(&zone->xfrsource6);

zone->xfr = NULL;

zone->maxxfrin = MAX_XFER_TIME;

zone->maxxfrout = MAX_XFER_TIME;

zone->diff_on_reload = ISC_FALSE;

zone->ssutable = NULL;

zone->sigvalidityinterval = 30 * 24 * 3600;

zone->view = NULL;

ISC_LINK_INIT(zone, statelink);

zone->statelist = NULL;

zone->magic = ZONE_MAGIC;

/* Must be after magic is set. */

result = dns_zone_setdbtype(zone, dbargc_default, dbargv_default);

if (result != ISC_R_SUCCESS)

goto free_mutex;

ISC_EVENT_INIT(&zone->ctlevent, sizeof(zone->ctlevent), 0, NULL,

DNS_EVENT_ZONECONTROL, zone_shutdown, zone, zone,

NULL, NULL);

*zonep = zone;

return (ISC_R_SUCCESS);

free_mutex:

DESTROYLOCK(&zone->lock);

return (ISC_R_NOMEMORY);

}

static void

zone_free(dns_zone_t *zone) {

isc_mem_t *mctx = NULL;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(zone->erefs == 0);

REQUIRE(zone->irefs == 0);

/*

if (zone->timer != NULL)

isc_timer_detach(&zone->timer);

if (zone->request != NULL)

dns_request_destroy(&zone->request); /* XXXMPA */

INSIST(zone->readio == NULL);

INSIST(zone->statelist == NULL);

if (zone->task != NULL)

isc_task_detach(&zone->task);

if (zone->zmgr)

dns_zonemgr_releasezone(zone->zmgr, zone);

/* Unmanaged objects */

if (zone->dbname != NULL)

isc_mem_free(zone->mctx, zone->dbname);

zone->dbname = NULL;

zone->journalsize = -1;

if (zone->journal != NULL)

isc_mem_free(zone->mctx, zone->journal);

zone->journal = NULL;

if (zone->db != NULL)

dns_db_detach(&zone->db);

zone_freedbargs(zone);

#ifndef NOMINUM_PUBLIC

dns_zone_setmasterswithkeys(zone, NULL, NULL, 0);

#else /* NOMINUM_PUBLIC */

dns_zone_setmasters(zone, NULL, 0);

#endif /* NOMINUM_PUBLIC */

dns_zone_setalsonotify(zone, NULL, 0);

zone->check_names = dns_severity_ignore;

if (zone->update_acl != NULL)

dns_acl_detach(&zone->update_acl);

#ifndef NOMINUM_PUBLIC

if (zone->notify_acl != NULL)

dns_acl_detach(&zone->notify_acl);

#endif /* NOMINUM_PUBLIC */

if (zone->query_acl != NULL)

dns_acl_detach(&zone->query_acl);

if (zone->xfr_acl != NULL)

dns_acl_detach(&zone->xfr_acl);

if (dns_name_dynamic(&zone->origin))

dns_name_free(&zone->origin, zone->mctx);

if (zone->ssutable != NULL)

dns_ssutable_detach(&zone->ssutable);

/* last stuff */

DESTROYLOCK(&zone->lock);

zone->magic = 0;

mctx = zone->mctx;

isc_mem_put(mctx, zone, sizeof *zone);

isc_mem_detach(&mctx);

}

dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(rdclass != dns_rdataclass_none);

/*

LOCK(&zone->lock);

REQUIRE(zone->rdclass == dns_rdataclass_none ||

zone->rdclass == rdclass);

zone->rdclass = rdclass;

UNLOCK(&zone->lock);

}

dns_zone_getclass(dns_zone_t *zone){

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->rdclass);

}

dns_zone_setnotifytype(dns_zone_t *zone, dns_notifytype_t notifytype) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->notifytype = notifytype;

UNLOCK(&zone->lock);

}

dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(type != dns_zone_none);

/*

LOCK(&zone->lock);

REQUIRE(zone->type == dns_zone_none || zone->type == type);

zone->type = type;

UNLOCK(&zone->lock);

}

static void

zone_freedbargs(dns_zone_t *zone) {

unsigned int i;

/* Free the old database argument list. */

if (zone->db_argv != NULL) {

for (i = 0; i < zone->db_argc; i++)

isc_mem_free(zone->mctx, zone->db_argv[i]);

isc_mem_put(zone->mctx, zone->db_argv,

zone->db_argc * sizeof *zone->db_argv);

}

zone->db_argc = 0;

zone->db_argv = NULL;

}

dns_zone_setdbtype(dns_zone_t *zone,

unsigned int dbargc, const char * const *dbargv) {

isc_result_t result = ISC_R_SUCCESS;

char **new = NULL;

unsigned int i;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(dbargc >= 1);

REQUIRE(dbargv != NULL);

LOCK(&zone->lock);

/* Set up a new database argument list. */

new = isc_mem_get(zone->mctx, dbargc * sizeof *new);

if (new == NULL)

goto nomem;

for (i = 0; i < dbargc; i++)

new[i] = NULL;

for (i = 0; i < dbargc; i++) {

new[i] = isc_mem_strdup(zone->mctx, dbargv[i]);

if (new[i] == NULL)

goto nomem;

}

/* Free the old list. */

zone_freedbargs(zone);

zone->db_argc = dbargc;

zone->db_argv = new;

result = ISC_R_SUCCESS;

goto unlock;

nomem:

if (new != NULL) {

for (i = 0; i < dbargc; i++) {

if (zone->db_argv[i] != NULL)

isc_mem_free(zone->mctx, new[i]);

isc_mem_put(zone->mctx, new,

dbargc * sizeof *new);

}

}

result = ISC_R_NOMEMORY;

unlock:

UNLOCK(&zone->lock);

return (result);

}

dns_zone_setview(dns_zone_t *zone, dns_view_t *view) {

REQUIRE(DNS_ZONE_VALID(zone));

if (zone->view != NULL)

dns_view_weakdetach(&zone->view);

dns_view_weakattach(view, &zone->view);

}

dns_view_t *

dns_zone_getview(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->view);

}

dns_zone_setorigin(dns_zone_t *zone, dns_name_t *origin) {

isc_result_t result;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(origin != NULL);

LOCK(&zone->lock);

if (dns_name_dynamic(&zone->origin)) {

dns_name_free(&zone->origin, zone->mctx);

dns_name_init(&zone->origin, NULL);

}

result = dns_name_dup(origin, zone->mctx, &zone->origin);

UNLOCK(&zone->lock);

return (result);

}

dns_zone_setdatabase(dns_zone_t *zone, const char *dbname) {

isc_result_t result = ISC_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(dbname != NULL);

LOCK(&zone->lock);

if (zone->dbname != NULL)

isc_mem_free(zone->mctx, zone->dbname);

zone->dbname = isc_mem_strdup(zone->mctx, dbname);

if (zone->dbname == NULL)

result = ISC_R_NOMEMORY;

else

result = default_journal(zone);

UNLOCK(&zone->lock);

return (result);

}

static isc_result_t

default_journal(dns_zone_t *zone) {

int len;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(zone->dbname != NULL);

if (zone->journal != NULL)

isc_mem_free(zone->mctx, zone->journal);

len = strlen(zone->dbname) + sizeof ".jnl"; /* includes '\0' */

zone->journal = isc_mem_allocate(zone->mctx, len);

if (zone->journal == NULL)

return (ISC_R_NOMEMORY);

strcpy(zone->journal, zone->dbname);

strcat(zone->journal, ".jnl");

return (ISC_R_SUCCESS);

}

dns_zone_setjournal(dns_zone_t *zone, const char *journal) {

isc_result_t result = ISC_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(journal != NULL);

LOCK(&zone->lock);

if (zone->journal != NULL)

isc_mem_free(zone->mctx, zone->journal);

zone->journal = isc_mem_strdup(zone->mctx, journal);

if (zone->journal == NULL)

result = ISC_R_NOMEMORY;

UNLOCK(&zone->lock);

return (result);

}

char *

dns_zone_getjournal(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->journal);

}

dns_zone_load(dns_zone_t *zone) {

const char me[] = "dns_zone_load";

isc_result_t result;

isc_stdtime_t now;

isc_time_t loadtime, filetime;

dns_db_t *db = NULL;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

isc_stdtime_get(&now);

INSIST(zone->type != dns_zone_none);

if (zone->dbname == NULL) {

/*

result = ISC_R_SUCCESS;

goto cleanup;

}

zone_log(zone, me, ISC_LOG_DEBUG(1), "start");

/*

result = isc_file_getmodtime(zone->dbname, &filetime);

if (result == ISC_R_SUCCESS && ! isc_time_isepoch(&zone->loadtime) &&

isc_time_compare(&filetime, &zone->loadtime) < 0) {

zone_log(zone, me, ISC_LOG_DEBUG(1),

"skipping: database file older than last load");

result = ISC_R_SUCCESS;

goto cleanup;

}

/*

result = isc_time_now(&loadtime);

if (result != ISC_R_SUCCESS)

goto cleanup;

INSIST(zone->db_argc >= 1);

result = dns_db_create(zone->mctx, zone->db_argv[0],

&zone->origin, (zone->type == dns_zone_stub) ?

dns_dbtype_stub : dns_dbtype_zone,

zone->rdclass,

zone->db_argc - 1, zone->db_argv + 1,

&db);

if (result != ISC_R_SUCCESS)

goto cleanup;

if (!dns_db_ispersistent(db))

result = zone_startload(db, zone, loadtime);

if (result == DNS_R_CONTINUE) {

zone->flags |= DNS_ZONEFLG_LOADING;

result = ISC_R_SUCCESS;

goto cleanup;

}

result = zone_postload(zone, db, loadtime, result);

cleanup:

UNLOCK(&zone->lock);

if (db != NULL)

dns_db_detach(&db);

return (result);

}

static void

zone_gotreadhandle(isc_task_t *task, isc_event_t *event) {

dns_load_t *load = event->ev_arg;

isc_result_t result = ISC_R_SUCCESS;

REQUIRE(DNS_LOAD_VALID(load));

if ((event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0)

result = ISC_R_CANCELED;

isc_event_free(&event);

if (result == ISC_R_CANCELED)

goto fail;

result = dns_master_loadfileinc(load->zone->dbname,

dns_db_origin(load->db),

dns_db_origin(load->db),

load->zone->rdclass, ISC_FALSE,

&load->callbacks, task,

zone_loaddone, load, load->zone->mctx);

if (result != ISC_R_SUCCESS && result != DNS_R_CONTINUE)

goto fail;

return;

fail:

zone_loaddone(load, result);

}

static isc_result_t

zone_startload(dns_db_t *db, dns_zone_t *zone, isc_time_t loadtime) {

dns_load_t *load;

isc_result_t result;

isc_result_t tresult;

if (zone->zmgr != NULL && zone->db != NULL) {

load = isc_mem_get(zone->mctx, sizeof(*load));

if (load == NULL)

return (ISC_R_NOMEMORY);

load->mctx = NULL;

load->zone = NULL;

load->db = NULL;

load->loadtime = loadtime;

load->magic = LOAD_MAGIC;

isc_mem_attach(zone->mctx, &load->mctx);

dns_zone_iattach(zone, &load->zone);

dns_db_attach(db, &load->db);

dns_rdatacallbacks_init(&load->callbacks);

result = dns_db_beginload(db, &load->callbacks.add,

&load->callbacks.add_private);

if (result != ISC_R_SUCCESS)

goto cleanup;

result = zonemgr_getio(zone->zmgr, ISC_TRUE, zone->task,

zone_gotreadhandle, load,

&zone->readio);

if (result != ISC_R_SUCCESS) {

tresult = dns_db_endload(load->db,

&load->callbacks.add_private);

if (result == ISC_R_SUCCESS)

result = tresult;

goto cleanup;

} else

result = DNS_R_CONTINUE;

} else {

result = dns_db_load(db, zone->dbname);

}

return (result);

cleanup:

load->magic = 0;

dns_db_detach(&load->db);

dns_zone_idetach(&load->zone);

isc_mem_detach(&load->mctx);

isc_mem_put(zone->mctx, load, sizeof(*load));

return (result);

}

static isc_result_t

zone_postload(dns_zone_t *zone, dns_db_t *db, isc_time_t loadtime,

isc_result_t result)

{

const char me[] = "dns_zone_load";

unsigned int soacount = 0;

unsigned int nscount = 0;

isc_uint32_t serial, refresh, retry, expire, minimum;

isc_stdtime_t now;

isc_boolean_t needdump = ISC_FALSE;

isc_stdtime_get(&now);

/*

if (result != ISC_R_SUCCESS) {

if (zone->type == dns_zone_slave ||

zone->type == dns_zone_stub) {

if (result == ISC_R_FILENOTFOUND)

zone_log(zone, me, ISC_LOG_INFO,

"no database file");

else

zone_log(zone, me, ISC_LOG_ERROR,

"database %s: dns_db_load failed: %s",

zone->dbname,

dns_result_totext(result));

} else

zone_log(zone, me, ISC_LOG_ERROR,

"database %s: dns_db_load failed: %s",

zone->dbname, dns_result_totext(result));

goto cleanup;

}

zone_log(zone, me, ISC_LOG_DEBUG(2),

"number of nodes in database: %u",

dns_db_nodecount(db));

zone->loadtime = loadtime;

zone_log(zone, me, ISC_LOG_INFO, "loaded");

/*

if (zone->journal != NULL) {

result = dns_journal_rollforward(zone->mctx, db,

zone->journal);

if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND &&

result != DNS_R_UPTODATE && result != DNS_R_NOJOURNAL &&

result != ISC_R_RANGE) {

zone_log(zone, me, ISC_LOG_ERROR,

"dns_journal_rollforward returned: %s",

dns_result_totext(result));

goto cleanup;

}

if (result == ISC_R_NOTFOUND || result == ISC_R_RANGE) {

zone_log(zone, me, ISC_LOG_ERROR,

"journal out of sync with zone");

goto cleanup;

}

zone_log(zone, me, ISC_LOG_DEBUG(1),

"dns_journal_rollforward: %s",

dns_result_totext(result));

if (result == ISC_R_SUCCESS)

needdump = ISC_TRUE;

}

/*

nscount = 0;

soacount = 0;

INSIST(db != NULL);

result = zone_get_from_db(db, &zone->origin, &nscount,

&soacount, &serial, &refresh, &retry,

&expire, &minimum);

if (result != ISC_R_SUCCESS) {

zone_log(zone, me, ISC_LOG_ERROR,

"could not find NS and/or SOA records");

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

if (soacount != 1) {

zone_log(zone, me, ISC_LOG_ERROR,

"has %d SOA records", soacount);

result = DNS_R_BADZONE;

goto cleanup;

}

if (nscount == 0)

zone_log(zone, me, ISC_LOG_ERROR, "no NS records");

if (zone->db != NULL) {

if (!isc_serial_ge(serial, zone->serial)) {

zone_log(zone, me, ISC_LOG_ERROR,

"zone serial has gone backwards");

}

}

zone->serial = serial;

zone->refresh = RANGE(refresh,

zone->minrefresh, zone->maxrefresh);

zone->retry = RANGE(retry,

zone->minretry, zone->maxretry);

zone->expire = RANGE(expire, zone->refresh + zone->retry,

DNS_MAX_EXPIRE);

zone->minimum = minimum;

zone->flags |= DNS_ZONEFLG_HAVETIMERS;

if (zone->type == dns_zone_slave ||

zone->type == dns_zone_stub) {

isc_time_t t;

result = isc_file_getmodtime(zone->dbname, &t);

if (result == ISC_R_SUCCESS)

zone->expiretime = isc_time_seconds(&t) +

zone->expire;

else

zone->expiretime = now + zone->retry;

zone->refreshtime = now;

}

break;

default:

UNEXPECTED_ERROR(__FILE__, __LINE__,

"unexpected zone type %d", zone->type);

result = ISC_R_UNEXPECTED;

goto cleanup;

}

#if 0

/* destroy notification example. */

{

isc_event_t *e = isc_event_allocate(zone->mctx, NULL,

DNS_EVENT_DBDESTROYED,

dns_zonemgr_dbdestroyed,

zone,

sizeof(isc_event_t));

dns_db_ondestroy(db, zone->task, &e);

}

#endif

if (zone->db != NULL) {

result = zone_replacedb(zone, db, ISC_FALSE);

if (result != ISC_R_SUCCESS)

goto cleanup;

} else {

dns_db_attach(db, &zone->db);

zone->flags |= DNS_ZONEFLG_LOADED|DNS_ZONEFLG_NEEDNOTIFY;

}

result = ISC_R_SUCCESS;

if (needdump)

zone_needdump(zone, DNS_DUMP_DELAY);

if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))

(void) zone_settimer(zone, now);

return (result);

cleanup:

if (zone->type == dns_zone_slave ||

zone->type == dns_zone_stub) {

if (zone->journal != NULL)

zone_saveunique(zone, zone->journal, "jn-XXXXXXXX");

if (zone->dbname != NULL)

zone_saveunique(zone, zone->dbname, "db-XXXXXXXX");

/* Mark the zone for immediate refresh. */

zone->refreshtime = now;

result = ISC_R_SUCCESS;

}

return (result);

}

static void

exit_check(dns_zone_t *zone) {

if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING) &&

zone->irefs == 0)

{

/*

INSIST(zone->erefs == 0);

zone_free(zone);

}

}

static isc_result_t

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

unsigned int *nscount)

{

isc_result_t result;

unsigned int count;

dns_rdataset_t rdataset;

REQUIRE(nscount != NULL);

dns_rdataset_init(&rdataset);

result = dns_db_findrdataset(db, node, version, dns_rdatatype_ns,

dns_rdatatype_none, 0, &rdataset, NULL);

if (result == ISC_R_NOTFOUND) {

*nscount = 0;

result = ISC_R_SUCCESS;

goto invalidate_rdataset;

}

else if (result != ISC_R_SUCCESS)

goto invalidate_rdataset;

count = 0;

result = dns_rdataset_first(&rdataset);

while (result == ISC_R_SUCCESS) {

count++;

result = dns_rdataset_next(&rdataset);

}

dns_rdataset_disassociate(&rdataset);

*nscount = count;

result = ISC_R_SUCCESS;

invalidate_rdataset:

dns_rdataset_invalidate(&rdataset);

return (result);

}

static isc_result_t

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

unsigned int *soacount,

isc_uint32_t *serial, isc_uint32_t *refresh,

isc_uint32_t *retry, isc_uint32_t *expire,

isc_uint32_t *minimum)

{

isc_result_t result;

unsigned int count;

dns_rdataset_t rdataset;

dns_rdata_t rdata;

dns_rdata_soa_t soa;

dns_rdataset_init(&rdataset);

result = dns_db_findrdataset(db, node, version, dns_rdatatype_soa,

dns_rdatatype_none, 0, &rdataset, NULL);

if (result != ISC_R_SUCCESS)

goto invalidate_rdataset;

count = 0;

result = dns_rdataset_first(&rdataset);

while (result == ISC_R_SUCCESS) {

dns_rdataset_current(&rdataset, &rdata);

count++;

if (count == 1)

dns_rdata_tostruct(&rdata, &soa, NULL);

result = dns_rdataset_next(&rdataset);

}

dns_rdataset_disassociate(&rdataset);

if (soacount != NULL)

*soacount = count;

if (count > 0) {

if (serial != NULL)

*serial = soa.serial;

if (refresh != NULL)

*refresh = soa.refresh;

if (retry != NULL)

*retry = soa.retry;

if (expire != NULL)

*expire = soa.expire;

if (minimum != NULL)

*minimum = soa.minimum;

}

result = ISC_R_SUCCESS;

invalidate_rdataset:

dns_rdataset_invalidate(&rdataset);

return (result);

}

static isc_result_t

zone_get_from_db(dns_db_t *db, dns_name_t *origin, unsigned int *nscount,

unsigned int *soacount, isc_uint32_t *serial,

isc_uint32_t *refresh, isc_uint32_t *retry,

isc_uint32_t *expire, isc_uint32_t *minimum)

{

dns_dbversion_t *version;

isc_result_t result;

isc_result_t answer = ISC_R_SUCCESS;

dns_dbnode_t *node;

REQUIRE(db != NULL);

REQUIRE(origin != NULL);

version = NULL;

dns_db_currentversion(db, &version);

node = NULL;

result = dns_db_findnode(db, origin, ISC_FALSE, &node);

if (result != ISC_R_SUCCESS) {

answer = result;

goto closeversion;

}

if (nscount != NULL) {

result = zone_count_ns_rr(db, node, version, nscount);

if (result != ISC_R_SUCCESS)

answer = result;

}

if (soacount != NULL || serial != NULL || refresh != NULL

|| retry != NULL || expire != NULL || minimum != NULL) {

result = zone_load_soa_rr(db, node, version, soacount,

serial, refresh, retry, expire,

minimum);

if (result != ISC_R_SUCCESS)

answer = result;

}

dns_db_detachnode(db, &node);

closeversion:

dns_db_closeversion(db, &version, ISC_FALSE);

return (answer);

}

dns_zone_attach(dns_zone_t *source, dns_zone_t **target) {

REQUIRE(DNS_ZONE_VALID(source));

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

LOCK(&source->lock);

REQUIRE(source->erefs > 0);

source->erefs++;

INSIST(source->erefs != 0);

zone_log(source, "dns_zone_attach", ISC_LOG_DEBUG(10),

"eref = %d, irefs = %d", source->erefs, source->irefs);

UNLOCK(&source->lock);

*target = source;

}

dns_zone_detach(dns_zone_t **zonep) {

dns_zone_t *zone;

isc_boolean_t free_now = ISC_FALSE;

REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));

zone = *zonep;

LOCK(&zone->lock);

REQUIRE(zone->erefs > 0);

zone->erefs--;

if (zone->erefs == 0) {

/*

if (zone->task != NULL) {

/*

isc_event_t *ev = &zone->ctlevent;

isc_task_send(zone->task, &ev);

} else {

/*

/*

INSIST(zone->view == NULL);

free_now = ISC_TRUE;

}

}

zone_log(zone, "dns_zone_detach", ISC_LOG_DEBUG(10),

"eref = %d, irefs = %d", zone->erefs, zone->irefs);

UNLOCK(&zone->lock);

*zonep = NULL;

if (free_now)

zone_free(zone);

}

dns_zone_iattach(dns_zone_t *source, dns_zone_t **target) {

REQUIRE(DNS_ZONE_VALID(source));

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

source->irefs++;

INSIST(source->irefs != 0);

*target = source;

zone_log(source, "dns_zone_iattach", ISC_LOG_DEBUG(10),

"eref = %d, irefs = %d", source->erefs, source->irefs);

}

dns_zone_idetach(dns_zone_t **zonep) {

dns_zone_t *zone;

REQUIRE(zonep != NULL && DNS_ZONE_VALID(*zonep));

zone = *zonep;

REQUIRE(zone->irefs > 0);

zone->irefs--;

*zonep = NULL;

zone_log(zone, "dns_zone_idetach", ISC_LOG_DEBUG(10),

"eref = %d, irefs = %d", zone->erefs, zone->irefs);

exit_check(zone);

}

isc_mem_t *

dns_zone_getmctx(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->mctx);

}

dns_zonemgr_t *

dns_zone_getmgr(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->zmgr);

}

dns_zone_setflag(dns_zone_t *zone, unsigned int flags, isc_boolean_t value) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (value)

zone->flags |= flags;

else

zone->flags &= ~flags;

UNLOCK(&zone->lock);

}

dns_zone_setoption(dns_zone_t *zone, unsigned int option, isc_boolean_t value)

{

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (value)

zone->options |= option;

else

zone->options &= ~option;

UNLOCK(&zone->lock);

}

unsigned int

dns_zone_getoptions(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->options);

}

dns_zone_setxfrsource4(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->xfrsource4 = *xfrsource;

UNLOCK(&zone->lock);

return (ISC_R_SUCCESS);

}

isc_sockaddr_t *

dns_zone_getxfrsource4(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (&zone->xfrsource4);

}

dns_zone_setxfrsource6(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->xfrsource6 = *xfrsource;

UNLOCK(&zone->lock);

return (ISC_R_SUCCESS);

}

isc_sockaddr_t *

dns_zone_getxfrsource6(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (&zone->xfrsource6);

}

dns_zone_setalsonotify(dns_zone_t *zone, isc_sockaddr_t *notify,

isc_uint32_t count)

{

isc_sockaddr_t *new;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE((notify == NULL && count == 0) ||

(notify != NULL && count != 0));

LOCK(&zone->lock);

if (zone->notify != NULL) {

isc_mem_put(zone->mctx, zone->notify,

zone->notifycnt * sizeof *new);

zone->notify = NULL;

zone->notifycnt = 0;

}

if (notify == NULL)

goto unlock;

new = isc_mem_get(zone->mctx, count * sizeof *new);

if (new == NULL) {

UNLOCK(&zone->lock);

return (ISC_R_NOMEMORY);

}

memcpy(new, notify, count * sizeof *new);

zone->notify = new;

zone->notifycnt = count;

unlock:

UNLOCK(&zone->lock);

return (ISC_R_SUCCESS);

}

#ifndef NOMINUM_PUBLIC

dns_zone_setmasters(dns_zone_t *zone, isc_sockaddr_t *masters,

isc_uint32_t count)

{

isc_result_t result;

result = dns_zone_setmasterswithkeys(zone, masters, NULL, count);

return (result);

}

dns_zone_setmasterswithkeys(dns_zone_t *zone, isc_sockaddr_t *masters,

dns_name_t **keynames, isc_uint32_t count)

#else /* NOMINUM_PUBLIC */

dns_zone_setmasters(dns_zone_t *zone, isc_sockaddr_t *masters,

isc_uint32_t count)

#endif /* NOMINUM_PUBLIC */

{

isc_sockaddr_t *new;

isc_result_t result = ISC_R_SUCCESS;

#ifndef NOMINUM_PUBLIC

dns_name_t **newname;

unsigned int i;

#endif /* NOMINUM_PUBLIC */

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(count == 0 || masters != NULL);

#ifndef NOMINUM_PUBLIC

if (keynames != NULL) {

REQUIRE(count != 0);

}

#endif /* NOMINUM_PUBLIC */

LOCK(&zone->lock);

if (zone->masters != NULL) {

isc_mem_put(zone->mctx, zone->masters,

zone->masterscnt * sizeof *new);

zone->masters = NULL;

}

#ifndef NOMINUM_PUBLIC

if (zone->masterkeynames != NULL) {

for (i = 0; i < zone->masterscnt; i++) {

if (zone->masterkeynames[i] != NULL) {

dns_name_free(zone->masterkeynames[i],

zone->mctx);

isc_mem_put(zone->mctx,

zone->masterkeynames[i],

sizeof(dns_name_t));

zone->masterkeynames[i] = NULL;

}

}

isc_mem_put(zone->mctx, zone->masterkeynames,

zone->masterscnt * sizeof(dns_name_t *));

zone->masterkeynames = NULL;

}

#endif /* NOMINUM_PUBLIC */

zone->masterscnt = 0;

/*

if (count == 0)

goto unlock;

/*

new = isc_mem_get(zone->mctx,

count * sizeof(isc_sockaddr_t));

if (new == NULL) {

result = ISC_R_NOMEMORY;

goto unlock;

}

memcpy(new, masters, count * sizeof *new);

zone->masters = new;

zone->masterscnt = count;

zone->flags &= ~DNS_ZONEFLG_NOMASTERS;

#ifndef NOMINUM_PUBLIC

/*

if (keynames != NULL) {

newname = isc_mem_get(zone->mctx,

count * sizeof(dns_name_t *));

if (newname == NULL) {

result = ISC_R_NOMEMORY;

isc_mem_put(zone->mctx, zone->masters,

count * sizeof *new);

goto unlock;

}

for (i = 0; i < count; i++)

newname[i] = NULL;

for (i = 0; i < count; i++) {

if (keynames[i] != NULL) {

newname[i] = isc_mem_get(zone->mctx,

sizeof(dns_name_t));

if (newname[i] == NULL)

goto allocfail;

dns_name_init(newname[i], NULL);

result = dns_name_dup(keynames[i], zone->mctx,

newname[i]);

if (result != ISC_R_SUCCESS) {

allocfail:

for (i = 0; i < count; i++)

if (newname[i] != NULL)

dns_name_free(

newname[i],

zone->mctx);

isc_mem_put(zone->mctx, zone->masters,

count * sizeof *new);

isc_mem_put(zone->mctx, newname,

count * sizeof *newname);

goto unlock;

}

}

}

zone->masterkeynames = newname;

}

#endif /* NOMINUM_PUBLIC */

unlock:

UNLOCK(&zone->lock);

return (result);

}

dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) {

isc_result_t result = ISC_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (zone->db == NULL)

result = DNS_R_NOTLOADED;

else

dns_db_attach(zone->db, dpb);

UNLOCK(&zone->lock);

return (result);

}

dns_zone_maintenance(dns_zone_t *zone) {

const char me[] = "dns_zone_maintenance";

isc_stdtime_t now;

isc_result_t result;

REQUIRE(DNS_ZONE_VALID(zone));

DNS_ENTER;

/*

if (zone->view == NULL || zone->view->adb == NULL)

return;

isc_stdtime_get(&now);

/*

switch (zone->type) {

case dns_zone_slave:

case dns_zone_stub:

LOCK(&zone->lock);

if (now >= zone->expiretime &&

DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED)) {

zone_expire(zone);

zone->refreshtime = now;

}

UNLOCK(&zone->lock);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_slave:

case dns_zone_stub:

if (now >= zone->refreshtime)

dns_zone_refresh(zone);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

LOCK(&zone->lock);

if (zone->dbname != NULL &&

now >= zone->dumptime &&

DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) &&

DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP)) {

result = zone_dump(zone);

if (result != ISC_R_SUCCESS)

zone_log(zone, "zone_dump", ISC_LOG_WARNING,

"failed: %s",

dns_result_totext(result));

}

UNLOCK(&zone->lock);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDNOTIFY))

dns_zone_notify(zone);

break;

default:

break;

}

if (!DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))

(void) zone_settimer(zone, now);

}

dns_zone_markdirty(dns_zone_t *zone) {

LOCK(&zone->lock);

zone_needdump(zone, DNS_DUMP_DELAY);

UNLOCK(&zone->lock);

}

dns_zone_expire(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone_expire(zone);

UNLOCK(&zone->lock);

}

static void

zone_expire(dns_zone_t *zone) {

isc_result_t result;

/*

REQUIRE(ISLOCKED(&zone->lock));

zone_log(zone, "zone_expire", ISC_LOG_WARNING, "expired");

if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP)) {

result = zone_dump(zone);

if (result != ISC_R_SUCCESS)

zone_log(zone, "zone_dump", ISC_LOG_WARNING,

"failure: %s", dns_result_totext(result));

}

zone->flags |= DNS_ZONEFLG_EXPIRED;

zone->refresh = DNS_ZONE_DEFAULTREFRESH;

zone->retry = DNS_ZONE_DEFAULTRETRY;

zone->flags &= ~DNS_ZONEFLG_HAVETIMERS;

zone_unload(zone);

}

dns_zone_refresh(dns_zone_t *zone) {

isc_stdtime_t now;

isc_uint32_t oldflags;

REQUIRE(DNS_ZONE_VALID(zone));

if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_EXITING))

return;

isc_stdtime_get(&now);

/*

LOCK(&zone->lock);

oldflags = zone->flags;

if (zone->masterscnt == 0) {

zone->flags |= DNS_ZONEFLG_NOMASTERS;

if ((oldflags & DNS_ZONEFLG_NOMASTERS) == 0)

zone_log(zone, "dns_zone_refresh", ISC_LOG_ERROR,

"no masters");

UNLOCK(&zone->lock);

return;

}

zone->flags |= DNS_ZONEFLG_REFRESH;

UNLOCK(&zone->lock);

if ((oldflags & (DNS_ZONEFLG_REFRESH|DNS_ZONEFLG_LOADING)) != 0)

return;

/*

zone->refreshtime = now +

isc_random_jitter(zone->retry, zone->retry / 4);

zone_log(zone, "dns_zone_refresh", ISC_LOG_DEBUG(20),

"refresh time (%u/%u), now %u",

zone->refreshtime, zone->refresh, now);

/*

if (! DNS_ZONE_FLAG(zone, DNS_ZONEFLG_HAVETIMERS))

zone->retry = ISC_MIN(zone->retry * 2, 6 * 3600);

zone->curmaster = 0;

/* initiate soa query */

queue_soa_query(zone);

}

dns_zone_flush(dns_zone_t *zone) {

isc_result_t result = ISC_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_NEEDDUMP))

result = zone_dump(zone);

UNLOCK(&zone->lock);

return (result);

}

dns_zone_dump(dns_zone_t *zone) {

isc_result_t result;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

result = zone_dump(zone);

UNLOCK(&zone->lock);

return (result);

}

static void

zone_needdump(dns_zone_t *zone, unsigned int delay) {

isc_stdtime_t now;

REQUIRE(DNS_ZONE_VALID(zone));

/*

if (zone->dbname == NULL ||

DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED) == 0)

return;

isc_stdtime_get(&now);

/* add some noise */

delay = isc_random_jitter(delay, delay/4);

zone->flags |= DNS_ZONEFLG_NEEDDUMP;

if (zone->dumptime == 0 ||

zone->dumptime > now + delay)

zone->dumptime = now + delay;

zone_settimer(zone, now);

}

static isc_result_t

zone_dump(dns_zone_t *zone) {

isc_result_t result;

dns_dbversion_t *version = NULL;

/*

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(ISLOCKED(&zone->lock));

dns_db_currentversion(zone->db, &version);

result = dns_master_dump(zone->mctx, zone->db, version,

&dns_master_style_default,

zone->dbname);

dns_db_closeversion(zone->db, &version, ISC_FALSE);

zone->dumptime = 0;

if (result != ISC_R_SUCCESS) {

/*

zone_needdump(zone, DNS_DUMP_DELAY);

return (result);

}

zone->flags &= ~DNS_ZONEFLG_NEEDDUMP;

return (ISC_R_SUCCESS);

}

dns_zone_dumptostream(dns_zone_t *zone, FILE *fd) {

isc_result_t result;

dns_dbversion_t *version = NULL;

dns_db_t *db = NULL;

REQUIRE(DNS_ZONE_VALID(zone));

dns_db_attach(zone->db, &db);

dns_db_currentversion(db, &version);

result = dns_master_dumptostream(zone->mctx, db, version,

&dns_master_style_default, fd);

dns_db_closeversion(db, &version, ISC_FALSE);

dns_db_detach(&db);

return (result);

}

dns_zone_unload(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone_unload(zone);

UNLOCK(&zone->lock);

}

static void

notify_cancel(dns_zone_t *zone) {

dns_notify_t *notify;

/*

for (notify = ISC_LIST_HEAD(zone->notifies);

notify != NULL;

notify = ISC_LIST_NEXT(notify, link)) {

if (notify->find != NULL)

dns_adb_cancelfind(notify->find);

if (notify->request != NULL)

dns_request_cancel(notify->request);

}

}

static void

zone_unload(dns_zone_t *zone) {

/*

REQUIRE(ISLOCKED(&zone->lock));

dns_db_detach(&zone->db);

zone->flags &= ~DNS_ZONEFLG_LOADED;

}

#ifndef NOMINUM_PUBLIC

static void

zone_deletefile(dns_zone_t *zone) {

const char me[] = "zone_deletefile";

isc_result_t result;

/*

REQUIRE(ISLOCKED(&zone->lock));

if (zone->dbname == NULL)

return;

result = isc_file_remove(zone->dbname);

if (result != ISC_R_SUCCESS) {

zone_log(zone, me, ISC_LOG_WARNING,

"failed to delete '%s': %s",

zone->dbname, dns_result_totext(result));

}

if (zone->journal != NULL)

(void)isc_file_remove(zone->journal);

}

#endif /* NOMINUM_PUBLIC */

dns_zone_setminrefreshtime(dns_zone_t *zone, isc_uint32_t val) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(val > 0);

zone->minrefresh = val;

}

dns_zone_setmaxrefreshtime(dns_zone_t *zone, isc_uint32_t val) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(val > 0);

zone->maxrefresh = val;

}

dns_zone_setminretrytime(dns_zone_t *zone, isc_uint32_t val) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(val > 0);

zone->minretry = val;

}

dns_zone_setmaxretrytime(dns_zone_t *zone, isc_uint32_t val) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(val > 0);

zone->maxretry = val;

}

#ifndef NOMINUM_PUBLIC

dns_zone_setmaxnames(dns_zone_t *zone, isc_uint32_t val) {

REQUIRE(DNS_ZONE_VALID(zone));

zone->maxnames = val;

}

isc_uint32_t dns_zone_getmaxnames(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (zone->maxnames);

}

#endif /* NOMINUM_PUBLIC */

static isc_boolean_t

notify_isqueued(dns_zone_t *zone, dns_name_t *name, isc_sockaddr_t *addr) {

dns_notify_t *notify;

for (notify = ISC_LIST_HEAD(zone->notifies);

notify != NULL;

notify = ISC_LIST_NEXT(notify, link)) {

if (notify->request != NULL)

continue;

if (name != NULL && dns_name_dynamic(&notify->ns) &&

dns_name_equal(name, &notify->ns))

return (ISC_TRUE);

if (addr != NULL && isc_sockaddr_equal(addr, &notify->dst))

return (ISC_TRUE);

}

return (ISC_FALSE);

}

static void

notify_destroy(dns_notify_t *notify, isc_boolean_t locked) {

isc_mem_t *mctx;

/*

REQUIRE(DNS_NOTIFY_VALID(notify));

if (notify->zone != NULL) {

if (!locked)

LOCK(&notify->zone->lock);

if (ISC_LINK_LINKED(notify, link))

ISC_LIST_UNLINK(notify->zone->notifies, notify, link);

if (!locked)

UNLOCK(&notify->zone->lock);

dns_zone_idetach(&notify->zone);

}

if (notify->find != NULL)

dns_adb_destroyfind(&notify->find);

if (notify->request != NULL)

dns_request_destroy(&notify->request);

if (dns_name_dynamic(&notify->ns))

dns_name_free(&notify->ns, notify->mctx);

mctx = notify->mctx;

isc_mem_put(notify->mctx, notify, sizeof *notify);

isc_mem_detach(&mctx);

}

static isc_result_t

notify_create(isc_mem_t *mctx, dns_notify_t **notifyp) {

dns_notify_t *notify;

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

notify = isc_mem_get(mctx, sizeof *notify);

if (notify == NULL)

return (ISC_R_NOMEMORY);

notify->mctx = NULL;

isc_mem_attach(mctx, &notify->mctx);

#ifndef NOMINUM_PUBLIC

notify->flags = 0;

#endif /* NOMINUM_PUBLIC */

notify->zone = NULL;

notify->find = NULL;

notify->request = NULL;

isc_sockaddr_any(&notify->dst);

dns_name_init(&notify->ns, NULL);

ISC_LINK_INIT(notify, link);

notify->magic = NOTIFY_MAGIC;

*notifyp = notify;

return (ISC_R_SUCCESS);

}

static void

process_adb_event(isc_task_t *task, isc_event_t *ev) {

dns_notify_t *notify;

isc_eventtype_t result;

UNUSED(task);

notify = ev->ev_arg;

REQUIRE(DNS_NOTIFY_VALID(notify));

INSIST(task == notify->zone->task);

result = ev->ev_type;

isc_event_free(&ev);

if (result == DNS_EVENT_ADBMOREADDRESSES) {

dns_adb_destroyfind(&notify->find);

notify_find_address(notify);

return;

}

if (result == DNS_EVENT_ADBNOMOREADDRESSES) {

LOCK(&notify->zone->lock);

notify_send(notify);

UNLOCK(&notify->zone->lock);

}

notify_destroy(notify, ISC_FALSE);

}

static void

notify_find_address(dns_notify_t *notify) {

isc_result_t result;

unsigned int options;

REQUIRE(DNS_NOTIFY_VALID(notify));

options = DNS_ADBFIND_WANTEVENT | DNS_ADBFIND_INET |

DNS_ADBFIND_INET6 | DNS_ADBFIND_RETURNLAME;

if (notify->zone->view->adb == NULL)

goto destroy;

result = dns_adb_createfind(notify->zone->view->adb,

notify->zone->task,

process_adb_event, notify,

&notify->ns, dns_rootname,

options, 0, NULL,

notify->zone->view->dstport,

&notify->find);

/* Something failed? */

if (result != ISC_R_SUCCESS)

goto destroy;

/* More addresses pending? */

if ((notify->find->options & DNS_ADBFIND_WANTEVENT) != 0)

return;

/* We have as many addresses as we can get. */

LOCK(&notify->zone->lock);

notify_send(notify);

UNLOCK(&notify->zone->lock);

destroy:

notify_destroy(notify, ISC_FALSE);

}

static isc_result_t

notify_send_queue(dns_notify_t *notify) {

isc_event_t *e;

isc_result_t result;

e = isc_event_allocate(notify->mctx, NULL,

DNS_EVENT_NOTIFYSENDTOADDR,

notify_send_toaddr,

notify, sizeof(isc_event_t));

if (e == NULL)

return (ISC_R_NOMEMORY);

e->ev_arg = notify;

e->ev_sender = NULL;

result = isc_ratelimiter_enqueue(notify->zone->zmgr->rl,

notify->zone->task, &e);

if (result != ISC_R_SUCCESS)

isc_event_free(&e);

return (result);

}

static void

notify_send_toaddr(isc_task_t *task, isc_event_t *event) {

dns_notify_t *notify;

isc_result_t result;

dns_message_t *message = NULL;

isc_netaddr_t dstip;

dns_tsigkey_t *key = NULL;

char addrbuf[ISC_SOCKADDR_FORMATSIZE];

notify = event->ev_arg;

REQUIRE(DNS_NOTIFY_VALID(notify));

UNUSED(task);

LOCK(&notify->zone->lock);

if (DNS_ZONE_FLAG(notify->zone, DNS_ZONEFLG_LOADED) == 0) {

result = ISC_R_CANCELED;

goto cleanup;

}

if ((event->ev_attributes & ISC_EVENTATTR_CANCELED) != 0 ||

DNS_ZONE_FLAG(notify->zone, DNS_ZONEFLG_EXITING) ||

notify->zone->view->requestmgr == NULL ||

notify->zone->db == NULL) {

result = ISC_R_CANCELED;

goto cleanup;

}

#ifdef NOMINUM_PUBLIC

result = notify_createmessage(notify->zone, &message);

#else /* NOMINUM_PUBLIC */

result = notify_createmessage(notify->zone, notify->flags, &message);

#endif /* NOMINUM_PUBLIC */

if (result != ISC_R_SUCCESS)

goto cleanup;

isc_netaddr_fromsockaddr(&dstip, &notify->dst);

(void)dns_view_getpeertsig(notify->zone->view, &dstip, &key);

isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));

notify_log(notify->zone, ISC_LOG_INFO, "sending NOTIFY to %s",

addrbuf);

result = dns_request_create(notify->zone->view->requestmgr, message,

&notify->dst, 0, key, 15,

notify->zone->task,

notify_done, notify,

&notify->request);

if (key != NULL)

dns_tsigkey_detach(&key);

dns_message_destroy(&message);

cleanup:

UNLOCK(&notify->zone->lock);

if (result != ISC_R_SUCCESS)

notify_destroy(notify, ISC_FALSE);

isc_event_free(&event);

}

static void

notify_send(dns_notify_t *notify) {

dns_adbaddrinfo_t *ai;

isc_sockaddr_t dst;

isc_result_t result;

dns_notify_t *new = NULL;

/*

REQUIRE(DNS_NOTIFY_VALID(notify));

REQUIRE(ISLOCKED(&notify->zone->lock));

for (ai = ISC_LIST_HEAD(notify->find->list);

ai != NULL;

ai = ISC_LIST_NEXT(ai, publink)) {

dst = ai->sockaddr;

if (notify_isqueued(notify->zone, NULL, &dst))

continue;

new = NULL;

result = notify_create(notify->mctx, &new);

if (result != ISC_R_SUCCESS)

goto cleanup;

dns_zone_iattach(notify->zone, &new->zone);

ISC_LIST_APPEND(new->zone->notifies, new, link);

new->dst = dst;

result = notify_send_queue(new);

if (result != ISC_R_SUCCESS)

goto cleanup;

new = NULL;

}

cleanup:

if (new != NULL)

notify_destroy(new, ISC_TRUE);

}

#ifndef NOMINUM_PUBLIC

static void

zone_notifyforward(dns_zone_t *zone) {

isc_result_t result;

const char me[] = "zone_notifyforward";

dns_notify_t *notify = NULL;

unsigned int i;

isc_sockaddr_t dst;

/*

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(ISLOCKED(&zone->lock));

DNS_ENTER;

/*

for (i = 0; i < zone->masterscnt; i++) {

dst = zone->masters[i];

if (notify_isqueued(zone, NULL, &dst))

continue;

result = notify_create(zone->mctx, &notify);

if (result != ISC_R_SUCCESS) {

return;

}

dns_zone_iattach(zone, &notify->zone);

notify->dst = dst;

notify->flags |= DNS_NOTIFY_NOSOA;

ISC_LIST_APPEND(zone->notifies, notify, link);

result = notify_send_queue(notify);

if (result != ISC_R_SUCCESS) {

notify_destroy(notify, ISC_TRUE);

return;

}

notify = NULL;

}

}

#endif /* NOMINUM_PUBLIC */

dns_zone_notify(dns_zone_t *zone) {

dns_dbnode_t *node = NULL;

dns_dbversion_t *version = NULL;

dns_name_t *origin = NULL;

dns_name_t master;

dns_rdata_ns_t ns;

dns_rdata_soa_t soa;

dns_rdata_t rdata;

dns_rdataset_t nsrdset;

dns_rdataset_t soardset;

isc_result_t result;

dns_notify_t *notify = NULL;

unsigned int i;

isc_sockaddr_t dst;

isc_boolean_t isqueued;

dns_notifytype_t notifytype;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->flags &= ~DNS_ZONEFLG_NEEDNOTIFY;

notifytype = zone->notifytype;

UNLOCK(&zone->lock);

if (! DNS_ZONE_FLAG(zone, DNS_ZONEFLG_LOADED))

return;

if (notifytype == dns_notifytype_no)

return;

notify_log(zone, ISC_LOG_INFO, "queuing notifies");

origin = &zone->origin;

/*

LOCK(&zone->lock);

for (i = 0; i < zone->notifycnt; i++) {

dst = zone->notify[i];

if (notify_isqueued(zone, NULL, &dst))

continue;

result = notify_create(zone->mctx, &notify);

if (result != ISC_R_SUCCESS) {

UNLOCK(&zone->lock);

return;

}

dns_zone_iattach(zone, &notify->zone);

notify->dst = dst;

ISC_LIST_APPEND(zone->notifies, notify, link);

result = notify_send_queue(notify);

if (result != ISC_R_SUCCESS) {

notify_destroy(notify, ISC_TRUE);

UNLOCK(&zone->lock);

return;

}

notify = NULL;

}

UNLOCK(&zone->lock);

if (notifytype == dns_notifytype_explicit)

return;

/*

dns_db_currentversion(zone->db, &version);

result = dns_db_findnode(zone->db, origin, ISC_FALSE, &node);

if (result != ISC_R_SUCCESS)

goto cleanup1;

dns_rdataset_init(&soardset);

result = dns_db_findrdataset(zone->db, node, version,

dns_rdatatype_soa,

dns_rdatatype_none, 0, &soardset, NULL);

if (result != ISC_R_SUCCESS)

goto cleanup2;

/*

dns_name_init(&master, NULL);

result = dns_rdataset_first(&soardset);

while (result == ISC_R_SUCCESS) {

dns_rdataset_current(&soardset, &rdata);

result = dns_rdata_tostruct(&rdata, &soa, NULL);

if (result != ISC_R_SUCCESS)

continue;

result = dns_name_dup(&soa.origin, zone->mctx, &master);

if (result != ISC_R_SUCCESS)

continue;

result = dns_rdataset_next(&soardset);

if (result != ISC_R_NOMORE)

break;

}

dns_rdataset_disassociate(&soardset);

if (result != ISC_R_NOMORE)

goto cleanup3;

dns_rdataset_init(&nsrdset);

result = dns_db_findrdataset(zone->db, node, version,

dns_rdatatype_ns,

dns_rdatatype_none, 0, &nsrdset, NULL);

if (result != ISC_R_SUCCESS)

goto cleanup3;

result = dns_rdataset_first(&nsrdset);

while (result == ISC_R_SUCCESS) {

dns_rdataset_current(&nsrdset, &rdata);

result = dns_rdata_tostruct(&rdata, &ns, NULL);

if (result != ISC_R_SUCCESS)

continue;

/*

if (dns_name_compare(&master, &ns.name) == 0) {

result = dns_rdataset_next(&nsrdset);

continue;

}

LOCK(&zone->lock);

isqueued = notify_isqueued(zone, &ns.name, NULL);

UNLOCK(&zone->lock);

if (isqueued) {

result = dns_rdataset_next(&nsrdset);

continue;

}

result = notify_create(zone->mctx, &notify);

if (result != ISC_R_SUCCESS)

continue;

dns_zone_iattach(zone, &notify->zone);

result = dns_name_dup(&ns.name, zone->mctx, &notify->ns);

if (result != ISC_R_SUCCESS) {

LOCK(&zone->lock);

notify_destroy(notify, ISC_TRUE);

UNLOCK(&zone->lock);

continue;

}

LOCK(&zone->lock);

ISC_LIST_APPEND(zone->notifies, notify, link);

UNLOCK(&zone->lock);

notify_find_address(notify);