/* $Id: zone.c,v 1.23 1999/10/15 01:39:31 halley Exp $ */

#include <config.h>

#include <string.h>

#include <isc/assertions.h>

#include <isc/error.h>

#include <../isc/util.h> /* XXX MPA */

#include <isc/timer.h>

#include <isc/print.h>

#include <isc/serial.h>

#include <isc/magic.h>

#include <dns/confparser.h>

#include <dns/db.h>

#include <dns/dbiterator.h>

#include <dns/dispatch.h>

#include <dns/journal.h>

#include <dns/master.h>

#include <dns/message.h>

#include <dns/rcode.h>

#include <dns/rdata.h>

#include <dns/rdatalist.h>

#include <dns/rdatasetiter.h>

#include <dns/rdatastruct.h>

#include <dns/resolver.h>

#include <dns/view.h>

#include <dns/zone.h>

#include <dns/zt.h>

#define dns_zone_uptodate(x) dns_zone_logerror(x, "dns_zone_uptodate")

#define referral(x) ISC_FALSE

#include <stdarg.h>

#define ZONE_MAGIC 0x5a4f4e45U

#define CHECKSERVERS_MAGIC 0x43484346U

#define DNS_ZONE_VALID(zone) \

ISC_MAGIC_VALID(zone, ZONE_MAGIC)

#define DNS_CHECKSERVERS_VALID(server) \

ISC_MAGIC_VALID(zone, CHECKSERVERS_MAGIC)

#ifndef DNS_GLOBAL_OPTION /* XXX MPA */

#define DNS_GLOBAL_OPTION(o) 0

#endif

#define DEFAULT_REFRESH 900 /*XXX*/

#define DEFAULT_RETRY 300 /*XXX*/

#define MAX_XFER_TIME 3600 /*XXX*/

typedef enum {

get_a6, get_aaaa, get_a, get_ns, get_soa

} dns_zone_state_t;

typedef struct dns_zone_checkservers {

isc_uint32_t magic;

isc_boolean_t name_known;

dns_name_t server;

isc_sockaddr_t address;

dns_zone_state_t state;

dns_zone_t *zone;

dns_resolver_t *res;

isc_mem_t *mctx;

dns_fetch_t *fetch;

ISC_LINK(struct dns_zone_checkservers) link;

} dns_zone_checkservers_t;

struct dns_zone {

/* Unlocked */

unsigned int magic;

isc_mutex_t lock;

isc_mem_t *mctx;

/* Locked */

dns_db_t *top;

isc_timermgr_t *timgr;

isc_timer_t *timer;

unsigned int references;

dns_name_t origin;

char *database;

char *ixfrlog; /*

char *updatelog;

isc_int32_t ixfrlogsize;

dns_rdataclass_t rdclass;

dns_zonetype_t type;

unsigned int flags;

unsigned int options;

unsigned int setoptions;

char * db_type;

unsigned int db_argc;

char ** db_argv;

isc_stdtime_t expiretime;

isc_stdtime_t refreshtime;

isc_stdtime_t dumptime;

isc_stdtime_t servertime;

isc_stdtime_t parenttime;

isc_stdtime_t childtime;

isc_uint32_t serial;

isc_uint32_t refresh;

isc_uint32_t retry;

isc_uint32_t expire;

isc_uint32_t minimum;

isc_sockaddr_t * masters;

unsigned int masterscnt;

in_port_t masterport;

unsigned int curmaster;

isc_sockaddr_t * notify;

unsigned int notifycnt;

isc_sockaddr_t notifyfrom;

isc_task_t * task;

isc_sockaddr_t xfrsource;

/* Access Control Lists */

dns_c_ipmatchlist_t *update_acl;

dns_c_ipmatchlist_t *query_acl;

dns_c_ipmatchlist_t *xfr_acl;

dns_c_severity_t check_names;

dns_c_pubkey_t *pubkey;

ISC_LIST(dns_zone_checkservers_t) checkservers;

dns_fetch_t *fetch;

dns_resolver_t *res;

isc_socketmgr_t *socketmgr;

isc_uint32_t xfrtime;

isc_boolean_t diff_on_reload;

};

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

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

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

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

#define DNS_ZONE_F_SERVERS 0x00000004U /* servers check in progress */

#define DNS_ZONE_F_PARENTS 0x00000008U /* parents check in progress */

#define DNS_ZONE_F_CHILDREN 0x00000010U /* child check in progress */

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

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

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

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

#define DNS_ZONE_F_UPTODATE 0x00000200U /* zone contents are

#define DNS_ZONE_OPTION(z,o) ((((z)->setoptions & (o)) != 0) ? \

(((z)->options & (o)) != 0) : \

DNS_GLOBAL_OPTION(o))

static void refresh_callback(isc_task_t *, isc_event_t *);

static void zone_shutdown(isc_task_t *, isc_event_t *);

static void soa_query(dns_zone_t *, isc_taskaction_t);

static dns_result_t zone_settimer(dns_zone_t *, isc_stdtime_t);

static void cancel_refresh(dns_zone_t *);

static dns_result_t dns_notify(dns_name_t *, isc_sockaddr_t *, dns_rdatatype_t,

dns_rdataclass_t, isc_sockaddr_t *, isc_mem_t *);

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

static void dns_zone_logerror(dns_zone_t *zone, const char *msg, ...);

static int message_count(dns_message_t *msg, dns_section_t section,

dns_rdatatype_t type);

#if 0

static void sockaddr_fromaddr(isc_sockaddr_t *sockaddr, dns_c_addr_t *a,

in_port_t port);

#endif

static void add_address_tocheck(dns_message_t *msg,

dns_zone_checkservers_t *checkservers,

dns_rdatatype_t type);

extern void dns_zone_transfer_in(dns_zone_t *zone);

static void record_serial(void);

static char * dns_zone_tostr(dns_zone_t *zone);

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

isc_result_t iresult;

dns_zone_t *zone;

isc_sockaddr_t sockaddr_any;

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

REQUIRE(mctx != NULL);

isc_sockaddr_fromin6(&sockaddr_any, &in6addr_any, 0);

zone = isc_mem_get(mctx, sizeof *zone);

if (zone == NULL)

return (DNS_R_NOMEMORY);

iresult = isc_mutex_init(&zone->lock);

if (iresult != ISC_R_SUCCESS) {

isc_mem_put(mctx, zone, sizeof *zone);

UNEXPECTED_ERROR(__FILE__, __LINE__,

"isc_mutex_init() failed: %s",

isc_result_totext(iresult));

return (DNS_R_UNEXPECTED);

}

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

zone->mctx = mctx;

zone->top = NULL;

zone->timgr = NULL;

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

dns_name_init(&zone->origin, NULL);

zone->database = NULL;

zone->ixfrlog = NULL;

zone->ixfrlogsize = -1;

zone->updatelog = NULL;

zone->rdclass = dns_rdataclass_none;

zone->type = dns_zone_none;

zone->flags = 0;

zone->options = 0;

zone->setoptions = 0;

zone->db_type = NULL;

zone->db_argc = 0;

zone->db_argv = NULL;

zone->expiretime = 0;

zone->refreshtime = 0;

zone->dumptime = 0;

zone->servertime = 0;

zone->parenttime = 0;

zone->childtime = 0;

zone->serial = 0;

zone->refresh = DEFAULT_REFRESH;

zone->retry = DEFAULT_RETRY;

zone->expire = 0;

zone->minimum = 0;

zone->masters = NULL;

zone->masterscnt = 0;

zone->masterport = 0;

zone->curmaster = 0;

zone->notify = NULL;

zone->notifycnt = 0;

zone->task = NULL;

zone->update_acl = NULL;

zone->query_acl = NULL;

zone->xfr_acl = NULL;

zone->check_names = dns_c_severity_ignore;

zone->pubkey = NULL;

zone->fetch = NULL;

zone->res = NULL;

zone->socketmgr = NULL;

zone->timer = NULL;

ISC_LIST_INIT(zone->checkservers);

zone->xfrsource = sockaddr_any;

zone->xfrtime = MAX_XFER_TIME;

zone->diff_on_reload = ISC_FALSE;

zone->magic = ZONE_MAGIC;

#if 0

printf("create: %p: %s: references = %d\n", zone, dns_zone_tostr(zone),

zone->references);

#endif

*zonep = zone;

return (DNS_R_SUCCESS);

}

static void

zone_free(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

REQUIRE(zone->references == 0);

zone->flags |= DNS_ZONE_F_EXITING;

UNLOCK(&zone->lock);

/* managed objects */

/* order is important */

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_REFRESH))

cancel_refresh(zone);

if (zone->timer != NULL)

isc_timer_detach(&zone->timer);

if (zone->res != NULL)

dns_resolver_detach(&zone->res);

if (zone->fetch != NULL)

dns_resolver_destroyfetch(zone->res, &zone->fetch);

if (zone->timgr != NULL)

isc_timermgr_destroy(&zone->timgr);

if (zone->task != NULL)

isc_task_destroy(&zone->task);

if (zone->socketmgr != NULL)

isc_socketmgr_destroy(&zone->socketmgr);

/* unmanaged objects */

if (zone->database != NULL)

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

zone->database = NULL;

if (zone->ixfrlog != NULL)

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

zone->ixfrlog = NULL;

zone->ixfrlogsize = -1;

if (zone->updatelog != NULL)

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

zone->updatelog = NULL;

if (zone->db_type != NULL)

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

zone->db_type = NULL;

if (zone->top != NULL)

dns_db_detach(&zone->top);

dns_zone_cleardbargs(zone);

dns_zone_clearmasters(zone);

zone->masterport = 0;

dns_zone_clearnotify(zone);

zone->check_names = dns_c_severity_ignore;

zone->pubkey = NULL; /* XXX detach */

if (zone->update_acl != NULL)

dns_c_ipmatchlist_delete(NULL, &zone->update_acl);

if (zone->query_acl != NULL)

dns_c_ipmatchlist_delete(NULL, &zone->query_acl);

if (zone->xfr_acl != NULL)

dns_c_ipmatchlist_delete(NULL, &zone->xfr_acl);

if (dns_name_dynamic(&zone->origin))

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

/* last stuff */

isc_mutex_destroy(&zone->lock);

zone->magic = 0;

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

}

dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(rdclass != dns_rdataclass_none);

REQUIRE(zone->rdclass == dns_rdataclass_none ||

zone->rdclass == rdclass);

zone->rdclass = rdclass;

}

dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(type != dns_zone_none);

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

zone->type = type;

}

dns_zone_setdbtype(dns_zone_t *zone, char *db_type) {

dns_result_t result = DNS_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (zone->db_type != NULL)

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

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

if (zone->db_type == NULL)

result = DNS_R_NOMEMORY;

UNLOCK(&zone->lock);

return (result);

}

dns_zone_setorigin(dns_zone_t *zone, char *origin) {

isc_buffer_t buffer;

dns_fixedname_t fixed;

dns_result_t result;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(origin != NULL);

dns_fixedname_init(&fixed);

isc_buffer_init(&buffer, origin, strlen(origin), ISC_BUFFERTYPE_TEXT);

isc_buffer_add(&buffer, strlen(origin));

result = dns_name_fromtext(dns_fixedname_name(&fixed),

&buffer, dns_rootname, ISC_FALSE, NULL);

if (result != DNS_R_SUCCESS)

return (result);

LOCK(&zone->lock);

result = dns_name_dup(dns_fixedname_name(&fixed), zone->mctx,

&zone->origin);

UNLOCK(&zone->lock);

return (result);

}

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

dns_result_t result = DNS_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(database != NULL);

LOCK(&zone->lock);

if (zone->database != NULL)

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

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

if (zone->database == NULL)

result = DNS_R_NOMEMORY;

UNLOCK(&zone->lock);

return (result);

}

dns_zone_setupdatelog(dns_zone_t *zone, char *updatelog) {

dns_result_t result = DNS_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(updatelog != NULL);

LOCK(&zone->lock);

if (zone->updatelog != NULL)

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

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

if (zone->updatelog == NULL)

result = DNS_R_NOMEMORY;

UNLOCK(&zone->lock);

return (result);

}

dns_zone_setixfrlog(dns_zone_t *zone, const char *ixfrlog) {

dns_result_t result = DNS_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(ixfrlog != NULL);

LOCK(&zone->lock);

if (zone->ixfrlog != NULL)

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

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

if (zone->ixfrlog == NULL)

result = DNS_R_NOMEMORY;

UNLOCK(&zone->lock);

return (result);

}

dns_zone_validate(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(dns_name_countlabels(&zone->origin) != 0);

REQUIRE(zone->type != dns_zone_none);

switch (zone->rdclass) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

case dns_zone_hint:

REQUIRE(zone->database != NULL);

/*FALLTHROUGH*/

case dns_zone_forward:

REQUIRE(zone->rdclass != dns_rdataclass_none);

break;

case dns_zone_cache:

REQUIRE(zone->rdclass == dns_rdataclass_none);

REQUIRE(zone->database == NULL);

break;

}

REQUIRE(zone->db_type != NULL);

}

dns_zone_load(dns_zone_t *zone) {

int soacount = 0;

int nscount = 0;

dns_result_t result;

dns_dbnode_t *node = NULL;

dns_dbversion_t *version = NULL;

dns_rdataset_t rdataset;

isc_boolean_t cache = ISC_FALSE;

dns_rdata_soa_t soa;

dns_rdata_t rdata;

isc_stdtime_t now;

dns_db_t *db = NULL;

REQUIRE(DNS_ZONE_VALID(zone));

if (isc_stdtime_get(&now) != ISC_R_SUCCESS) {

/*XXX*/

return (DNS_R_UNEXPECTED);

}

switch (zone->type) {

case dns_zone_forward:

case dns_zone_none:

return (DNS_R_SUCCESS);

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

case dns_zone_hint:

cache = ISC_FALSE;

break;

case dns_zone_cache:

cache = ISC_TRUE;

break;

default:

INSIST("bad zone type" == NULL);

}

result = dns_db_create(zone->mctx, zone->db_type,

&zone->origin,

cache, zone->rdclass,

zone->db_argc, zone->db_argv, &db);

if (result != DNS_R_SUCCESS)

return (result);

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

/*

if (result != DNS_R_SUCCESS)

goto cleanup;

/*

if (zone->ixfrlog != NULL && zone->diff_on_reload == ISC_FALSE) {

result = dns_journal_rollforward(zone->mctx, db, zone->ixfrlog);

if (result != DNS_R_SUCCESS && result != DNS_R_NOTFOUND &&

result != DNS_R_UPTODATE)

goto cleanup;

if (result == DNS_R_SUCCESS)

zone->flags |= DNS_ZONE_F_NEEDDUMP;

}

/*

nscount = 0;

soacount = 0;

dns_db_currentversion(db, &version);

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

if (result == DNS_R_SUCCESS) {

dns_rdataset_init(&rdataset);

result = dns_db_findrdataset(db, node, version,

dns_rdatatype_ns,

dns_rdatatype_none, 0, &rdataset,

NULL);

if (result == DNS_R_SUCCESS) {

result = dns_rdataset_first(&rdataset);

while (result == DNS_R_SUCCESS) {

nscount++;

result = dns_rdataset_next(&rdataset);

}

dns_rdataset_disassociate(&rdataset);

}

result = dns_db_findrdataset(db, node, version,

dns_rdatatype_soa,

dns_rdatatype_none, 0, &rdataset,

NULL);

if (result == DNS_R_SUCCESS) {

result = dns_rdataset_first(&rdataset);

while (result == DNS_R_SUCCESS) {

dns_rdataset_current(&rdataset, &rdata);

if (soacount == 0)

dns_rdata_tostruct(&rdata, &soa,

zone->mctx);

soacount++;

result = dns_rdataset_next(&rdataset);

}

dns_rdataset_disassociate(&rdataset);

}

dns_rdataset_invalidate(&rdataset);

}

dns_db_detachnode(db, &node);

dns_db_closeversion(db, &version, ISC_FALSE);

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

if (soacount != 1 || nscount == 0) {

if (soacount != 0)

dns_rdata_freestruct(&soa);

return (DNS_R_BADZONE);

}

zone->serial = soa.serial;

zone->refresh = soa.refresh;

zone->retry = soa.retry;

zone->expire = soa.expire;

zone->minimum = soa.minimum;

if (zone->type == dns_zone_slave ||

zone->type == dns_zone_stub) {

zone->expiretime = now /*XXX*/ + zone->expire;

zone->refreshtime = now + zone->refresh /*XXX*/;

}

break;

case dns_zone_hint:

if (nscount == 0) {

if (soacount != 0)

dns_rdata_freestruct(&soa);

return (DNS_R_BADZONE);

}

break;

case dns_zone_cache:

break;

default:

UNEXPECTED_ERROR(__FILE__, __LINE__,

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

if (soacount != 0)

dns_rdata_freestruct(&soa);

return (DNS_R_UNEXPECTED);

}

if (zone->top != NULL)

result = dns_zone_replacedb(zone, db, ISC_FALSE);

else {

dns_db_attach(db, &zone->top);

zone->flags |= DNS_ZONE_F_LOADED;

}

cleanup:

if (soacount != 0)

dns_rdata_freestruct(&soa);

if (db != NULL)

dns_db_detach(&db);

return (result);

}

#ifdef notyet

dns_zone_checkservers(dns_zone_t *zone) {

dns_name_t *zonename;

unsigned int i;

dns_zone_checkservers_t *checkservers;

dns_rdataset_t rdataset;

dns_rdata_t rdata;

dns_dbnode_t *node = NULL;

dns_dbversion_t *version = NULL;

dns_result_t result;

dns_rdata_ns_t ns;

REQUIRE(DNS_ZONE_VALID(zone));

/* XXX MPA */

/*

zonename = &zone->origin;

dns_db_currentversion(zone->top, &version);

result = dns_db_findnode(zone->top, zonename, ISC_FALSE, &node);

if (result == DNS_R_SUCCESS) {

dns_rdataset_init(&rdataset);

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

dns_rdatatype_ns,

dns_rdatatype_none, 0, &rdataset,

NULL);

if (result == DNS_R_SUCCESS) {

result = dns_rdataset_first(&rdataset);

while (result == DNS_R_SUCCESS) {

dns_rdataset_current(&rdataset, &rdata);

result = dns_rdata_tostruct(&rdata, &ns, zone->mctx);

if (result != DNS_R_SUCCESS)

continue;

checkservers = isc_mem_get(zone->mctx,

sizeof *checkservers);

if (checkservers == NULL)

break;

dns_name_init(&checkservers->server, NULL);

dns_name_dup(&ns.name, zone->mctx,

&checkservers->server);

checkservers->name_known = ISC_TRUE;

checkservers->state = get_a; /* XXXMPA */

dns_zone_attach(zone, &checkservers->zone);

checkservers->mctx = zone->mctx;

dns_resolver_attach(zone->res, &checkservers->res);

checkservers->fetch = NULL;

ISC_LINK_INIT(checkservers, link);

checkservers->magic = CHECKSERVERS_MAGIC;

/* XXX lookup A/AAAA/A6 records */

result = dns_rdataset_next(&rdataset);

}

}

dns_rdataset_disassociate(&rdataset);

dns_rdataset_invalidate(&rdataset);

}

dns_db_detachnode(zone->top, &node);

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

/*

/*

LOCK(&zone->lock);

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

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

if (checkservers == NULL)

break;

dns_name_init(&checkservers->server, NULL);

checkservers->name_known = ISC_FALSE;

checkservers->state = get_ns;

checkservers->address = zone->notify[i];

dns_zone_attach(zone, &checkservers->zone);

checkservers->mctx = zone->mctx;

dns_resolver_attach(zone->res, &checkservers->res);

checkservers->fetch = NULL;

ISC_LINK_INIT(checkservers, link);

checkservers->magic = CHECKSERVERS_MAGIC;

ISC_LIST_APPEND(zone->checkservers, checkservers, link);

dns_resolver_createfetch(zone->res, zonename, dns_rdatatype_ns,

NULL, NULL, NULL,

DNS_FETCHOPT_UNSHARED,

zone->task, checkservers_callback,

checkservers, &checkservers->fetch);

}

UNLOCK(&zone->lock);

}

#endif

#ifdef notyet

static void

checkservers_callback(isc_task_t *task, isc_event_t *event) {

dns_fetchdoneevent_t *devent = (dns_fetchdoneevent_t *)event;

dns_zone_checkservers_t *checkservers = event->arg;

dns_zone_state_t state;

dns_zone_t *zone;

dns_name_t *name;

isc_mem_t *mctx;

isc_sockaddr_t *address;

dns_resolver_t *res;

dns_message_t *msg;

char *master;

REQUIRE(DNS_CHECKSERVERS_VALID(checkservers));

state = checkservers->state;

zone = checkservers->zone;

name = &checkservers->server;

address = &checkservers->address;

mctx = checkservers->mctx;

res = checkservers->res;

task = task; /* unused */

master = isc_sockaddr_totext(&zone->masters[zone->curmaster],

zone->mctx);

if (devent->result != DNS_R_SUCCESS) {

/* timeout */

switch (state) {

case get_a6:

case get_aaaa:

case get_a:

dns_zone_logerror(zone,

"unable to obtain address for (%s)");

break;

case get_ns:

case get_soa:

dns_zone_logerror(zone,

"unable to obtain %s RRset from %s"

);

}

goto cleanup;

}

msg = NULL;

dns_resolver_getanswer(event, &msg);

switch (state) {

case get_a6:

add_address_tocheck(msg, checkservers, dns_rdatatype_a6);

dns_resolver_createfetch(res, name, dns_rdatatype_aaaa,

NULL, NULL, NULL, 0, zone->task,

checkservers_callback,

checkservers, &checkservers->fetch);

checkservers->state = get_aaaa;

break;

case get_aaaa:

add_address_tocheck(msg, checkservers, dns_rdatatype_a6);

dns_resolver_createfetch(res, name, dns_rdatatype_a,

NULL, NULL, NULL, 0, zone->task,

checkservers_callback,

checkservers, &checkservers->fetch);

checkservers->state = get_a;

break;

case get_a:

add_address_tocheck(msg, checkservers, dns_rdatatype_a);

/* make NS query to address */

dns_resolver_createfetch(res, name, dns_rdatatype_ns,

NULL, NULL, NULL,

DNS_FETCHOPT_UNSHARED,

zone->task, checkservers_callback,

checkservers, &checkservers->fetch);

checkservers->state = get_ns;

break;

case get_ns:

case get_soa:

if (msg->rcode != dns_rcode_noerror) {

char rcode[128];

isc_buffer_t rb;

isc_buffer_init(&rb, rcode, sizeof rcode,

ISC_BUFFERTYPE_TEXT);

dns_rcode_totext(msg->rcode, &rb);

dns_zone_logerror(zone,

"server %s (%s) unexpected rcode = %.*s",

rb.used, rcode);

break;

}

if (msg->counts[DNS_SECTION_ANSWER] == 0) {

if (referral(msg))

dns_zone_logerror(zone,

"server %s (%s) referral response");

else

dns_zone_logerror(zone,

"server %s (%s) type = %s NODATA response");

}

if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0) {

dns_zone_logerror(zone,

"server %s (%s) not authorative");

}

if (state == get_ns) {

/* compare NS RR sets */

/* make soa query to address */

dns_resolver_createfetch(res, name, dns_rdatatype_soa,

NULL, NULL, NULL,

DNS_FETCHOPT_UNSHARED,

zone->task,

checkservers_callback,

checkservers,

&checkservers->fetch);

checkservers->state = get_soa;

break;

} else {

/* compare SOA RR sets */

goto cleanup;

}

break;

default:

UNEXPECTED_ERROR(__FILE__, __LINE__, "unexpected state");

break;

}

isc_event_free(&event);

return;

cleanup:

isc_event_free(&event);

ISC_LIST_UNLINK(zone->checkservers, checkservers, link);

checkservers->magic = 0;

dns_zone_detach(&checkservers->zone);

isc_mem_put(mctx, checkservers, sizeof *checkservers);

}

#endif

#if 0

static void

cmp_soa(dns_message_t *msg, dns_zone_t *zone, char *server) {

dns_rdata_soa_t msgsoa, zonesoa;

dns_result_t result;

dns_rdataset_t *rdataset = NULL;

dns_rdataset_t zonerdataset;

dns_rdata_t rdata;

dns_rdata_init(&rdata);

/*

result = dns_message_findname(msg, DNS_SECTION_ANSWER,

&zone->origin,

dns_rdatatype_soa,

dns_rdatatype_none, NULL, &rdataset);

if (result != DNS_R_SUCCESS) {

dns_zone_logerror(zone,

"Unable to extract SOA from answer: %s",

server);

return;

}

result = dns_rdataset_first(rdataset);

if (DNS_R_SUCCESS != result)

return;

dns_rdataset_current(rdataset, &rdata);

result = dns_rdata_tostruct(&rdata, &msgsoa, zone->mctx);

if (DNS_R_SUCCESS != result)

return;

result = dns_rdataset_next(rdataset);

if (DNS_R_NOMORE != result) {

dns_zone_logerror(zone,

"More that one SOA record returned: %s",

server);

goto cleanup_msgsoa;

}

/*

dns_rdataset_init(&zonerdataset);

LOCK(&zone->lock);

result = dns_db_find(zone->top, &zone->origin,

NULL, dns_rdatatype_soa, dns_rdatatype_none,

0, 0, NULL, NULL, &zonerdataset);

UNLOCK(&zone->lock);

if (result != DNS_R_SUCCESS) {

/* XXXMPA */

goto cleanup_msgsoa;

}

result = dns_rdataset_first(&zonerdataset);

if (DNS_R_SUCCESS != result)

return;

dns_rdataset_current(&zonerdataset, &rdata);

result = dns_rdata_tostruct(&rdata, &msgsoa, zone->mctx);

if (DNS_R_SUCCESS != result)

return;

result = dns_rdataset_next(&zonerdataset);

if (DNS_R_NOMORE != result) {

dns_zone_logerror(zone, "More that one SOA in zone");

goto cleanup_msgsoa;

}

dns_rdataset_disassociate(&zonerdataset);

/*

if (msgsoa.serial != zonesoa.serial) {

if (!isc_serial_lt(msgsoa.serial, zonesoa.serial)) {

dns_zone_logerror(zone,

"slave serial not less than or equal to zone serial: %s",

server);

goto cleanup_zonesoa;

}

record_serial();

goto cleanup_zonesoa;

}

if (msgsoa.refresh != zonesoa.refresh ||

msgsoa.retry != zonesoa.retry ||

msgsoa.expire != zonesoa.expire ||

msgsoa.minimum != zonesoa.minimum ||

dns_name_compare(&msgsoa.origin, &zonesoa.origin) != 0 ||

dns_name_compare(&msgsoa.mname, &zonesoa.mname) != 0) {

dns_zone_logerror(zone, "SOA contents differ: %s",

server);

}

cleanup_zonesoa:

dns_rdata_freestruct(&zonesoa);

cleanup_msgsoa:

dns_rdata_freestruct(&msgsoa);

}

#endif

static void

add_address_tocheck(dns_message_t *msg, dns_zone_checkservers_t *checkservers,

dns_rdatatype_t type)

{

dns_rdataset_t *rdataset = NULL;

dns_result_t result;

isc_sockaddr_t sockaddr;

dns_rdata_in_a_t a;

dns_rdata_in_a6_t a6;

dns_rdata_t rdata;

if (msg->rcode != dns_rcode_noerror)

return;

if (msg->counts[DNS_SECTION_QUESTION] != 0 ||

dns_message_findname(msg, DNS_SECTION_QUESTION,

&checkservers->server,

type, dns_rdatatype_none,

NULL, &rdataset) != DNS_R_SUCCESS)

return;

result = dns_rdataset_first(rdataset);

while (DNS_R_SUCCESS == result) {

dns_rdataset_current(rdataset, &rdata);

switch (type) {

case dns_rdatatype_a:

result = dns_rdata_tostruct(&rdata, &a,

checkservers->mctx);

isc_sockaddr_fromin(&sockaddr, &a.in_addr, 0);

dns_rdata_freestruct(&a);

break;

case dns_rdatatype_a6:

result = dns_rdata_tostruct(&rdata, &a6,

checkservers->mctx);

isc_sockaddr_fromin6(&sockaddr, &a6.in6_addr, 0);

dns_rdata_freestruct(&a6);

break;

default:

INSIST(0);

}

result = dns_rdataset_next(rdataset);

}

}

dns_zone_checkparents(dns_zone_t *zone) {

/* XXX MPA */

REQUIRE(DNS_ZONE_VALID(zone));

/*

/*

}

dns_zone_checkchildren(dns_zone_t *zone) {

/* XXX MPA */

REQUIRE(DNS_ZONE_VALID(zone));

/*

}

dns_zone_checkglue(dns_zone_t *zone) {

/* XXX MPA */

REQUIRE(DNS_ZONE_VALID(zone));

/*

}

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->references > 0);

source->references++;

#if 0

printf("%p: %s: references = %d\n", source, dns_zone_tostr(source),

source->references);

#endif

INSIST(source->references != 0xffffffffU);

UNLOCK(&source->lock);

*target = source;

}

dns_zone_print(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

printf("\t%p: %s: references = %d\n", zone, dns_zone_tostr(zone),

zone->references);

}

static char *

dns_zone_tostr(dns_zone_t *zone) {

isc_buffer_t tbuf;

static char outbuf[1024];

dns_result_t result;

/*

isc_buffer_init(&tbuf, outbuf, sizeof(outbuf) - 1,

ISC_BUFFERTYPE_TEXT);

if (dns_name_countlabels(&zone->origin) > 0) {

result = dns_name_totext(&zone->origin, ISC_FALSE, &tbuf);

if (result == DNS_R_SUCCESS)

outbuf[tbuf.used] = '\0';

else

strncpy(outbuf, "<name conversion failed>",

sizeof outbuf);

}else

strncpy(outbuf, "<unnamed zone>", sizeof outbuf);

return (outbuf);

}

dns_zone_detach(dns_zone_t **zonep) {

dns_zone_t *zone;

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

zone = *zonep;

LOCK(&zone->lock);

REQUIRE(zone->references > 0);

zone->references--;

#if 0

printf("%p: %s: references = %d\n", zone, dns_zone_tostr(zone),

zone->references);

#endif

UNLOCK(&zone->lock);

if (zone->references == 0)

zone_free(zone);

*zonep = NULL;

}

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;

zone->setoptions |= option;

UNLOCK(&zone->lock);

}

dns_zone_clearoption(dns_zone_t *zone, unsigned int option) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->setoptions &= ~option;

UNLOCK(&zone->lock);

}

dns_zone_getoptions(dns_zone_t *zone, unsigned int *options,

unsigned int *optionsmask)

{

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(options != NULL);

REQUIRE(optionsmask != NULL);

LOCK(&zone->lock);

*options = zone->options;

*optionsmask = zone->setoptions;

UNLOCK(&zone->lock);

}

dns_zone_adddbarg(dns_zone_t *zone, char *arg) {

char **new = NULL;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(arg != NULL);

/*

LOCK(&zone->lock);

new = isc_mem_get(zone->mctx, (zone->db_argc + 1) * sizeof *new);

if (new == NULL)

goto cleanup;

new[zone->db_argc] = isc_mem_strdup(zone->mctx, arg);

if (new[zone->db_argc] == NULL)

goto cleanup;

/*

if (zone->db_argc != 0) {

memcpy(new, zone->db_argv, zone->db_argc * sizeof *new);

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

zone->db_argc * sizeof *new);

}

zone->db_argv = new;

zone->db_argc++;

UNLOCK(&zone->lock);

return (DNS_R_SUCCESS);

cleanup:

if (new != NULL)

isc_mem_put(zone->mctx, new,

(zone->db_argc + 1) * sizeof *new);

UNLOCK(&zone->lock);

return (DNS_R_NOMEMORY);

}

dns_zone_cleardbargs(dns_zone_t *zone) {

unsigned int i;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (zone->db_argc) {

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;

}

UNLOCK(&zone->lock);

}

dns_zone_setxfrsource(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

zone->xfrsource = *xfrsource;

UNLOCK(&zone->lock);

return (DNS_R_SUCCESS);

}

isc_sockaddr_t *

dns_zone_getxfrsource(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

return (&zone->xfrsource);

}

dns_zone_addnotify(dns_zone_t *zone, isc_sockaddr_t *notify) {

isc_sockaddr_t *new;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

new = isc_mem_get(zone->mctx, (zone->notifycnt + 1) * sizeof *new);

if (new == NULL)

goto cleanup;

new[zone->notifycnt] = *notify;

if (zone->notifycnt > 0) {

memcpy(new, zone->notify, zone->notifycnt * sizeof *new);

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

zone->notifycnt * sizeof *new);

}

zone->notify = new;

zone->notifycnt++;

UNLOCK(&zone->lock);

return (DNS_R_SUCCESS);

cleanup:

UNLOCK(&zone->lock);

return (DNS_R_NOMEMORY);

}

dns_zone_clearnotify(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (zone->notify != NULL) {

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

zone->notifycnt * sizeof *zone->notify);

zone->notify = NULL;

zone->notifycnt = 0;

}

UNLOCK(&zone->lock);

}

dns_zone_addmaster(dns_zone_t *zone, isc_sockaddr_t *master) {

isc_sockaddr_t *new;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

new = isc_mem_get(zone->mctx, (zone->masterscnt + 1) * sizeof *new);

if (new == NULL) {

UNLOCK(&zone->lock);

return (DNS_R_NOMEMORY);

}

new[zone->masterscnt] = *master;

if (zone->masterscnt > 0) {

memcpy(new, zone->masters, zone->masterscnt * sizeof *new);

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

zone->masterscnt * sizeof *new);

}

zone->masters = new;

zone->masterscnt++;

UNLOCK(&zone->lock);

return (DNS_R_SUCCESS);

}

dns_zone_clearmasters(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

while (DNS_ZONE_FLAG(zone, DNS_ZONE_F_REFRESH)) {

UNLOCK(&zone->lock);

cancel_refresh(zone);

LOCK(&zone->lock);

}

if (zone->masters != NULL) {

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

zone->masterscnt * sizeof *zone->masters);

zone->masters = NULL;

zone->masterscnt = 0;

zone->curmaster = 0;

}

UNLOCK(&zone->lock);

}

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

dns_result_t result = DNS_R_SUCCESS;

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

if (zone->top == NULL)

result = DNS_R_NOTLOADED;

else

dns_db_attach(zone->top, dpb);

UNLOCK(&zone->lock);

return (result);

}

dns_zone_maintenance(dns_zone_t *zone) {

isc_stdtime_t now;

REQUIRE(DNS_ZONE_VALID(zone));

fprintf(stderr, "dns_zone_maintenance\n");

if (isc_stdtime_get(&now) != ISC_R_SUCCESS)

return;

/*

switch (zone->type) {

case dns_zone_slave:

case dns_zone_stub:

LOCK(&zone->lock);

if (now >= zone->expiretime &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED)) {

dns_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_FLAG(zone, DNS_ZONE_F_REFRESH))

dns_zone_refresh(zone);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

LOCK(&zone->lock);

if (now >= zone->dumptime &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_NEEDDUMP)) {

dns_zone_dump(zone, stdout);

}

UNLOCK(&zone->lock);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

#ifdef notyet

if (now >= zone->servertime &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) &&

DNS_ZONE_OPTION(zone, DNS_ZONE_O_SERVERS) &&

!DNS_ZONE_FLAG(zone, DNS_ZONE_F_SERVERS))

dns_zone_checkservers(zone);

#endif

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

if (now >= zone->parenttime &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) &&

DNS_ZONE_OPTION(zone, DNS_ZONE_O_PARENTS) &&

!DNS_ZONE_FLAG(zone, DNS_ZONE_F_PARENTS))

dns_zone_checkparents(zone);

break;

default:

break;

}

/*

switch (zone->type) {

case dns_zone_master:

case dns_zone_slave:

case dns_zone_stub:

if (now >= zone->childtime &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) &&

DNS_ZONE_OPTION(zone, DNS_ZONE_O_CHILDREN) &&

!DNS_ZONE_FLAG(zone, DNS_ZONE_F_CHILDREN))

dns_zone_checkchildren(zone);

break;

default:

break;

}

(void) zone_settimer(zone, now); /*XXX*/

}

dns_zone_expire(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_NEEDDUMP))

dns_zone_dump(zone, stdout); /* XXX */

zone->flags |= DNS_ZONE_F_EXPIRED;

dns_zone_setrefresh(zone, DEFAULT_REFRESH, DEFAULT_RETRY);

dns_zone_unload(zone);

}

dns_zone_refresh(dns_zone_t *zone) {

isc_stdtime_t now;

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(zone->masterscnt > 0);

if (isc_stdtime_get(&now) != ISC_R_SUCCESS)

return;

/*

LOCK(&zone->lock);

zone->flags |= DNS_ZONE_F_REFRESH;

UNLOCK(&zone->lock);

/*

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

zone->curmaster = 0;

/* initiate soa query */

#ifdef notyet

soa_query(zone, refresh_callback);

#endif

}

dns_zone_dump(dns_zone_t *zone, FILE *fd) {

dns_dbiterator_t *dbiterator = NULL;

dns_dbversion_t *version = NULL;

dns_result_t result;

dns_fixedname_t fname;

dns_name_t *name;

dns_rdatasetiter_t *rdsiter = NULL;

dns_dbnode_t *node = NULL;

isc_buffer_t text;

isc_region_t region;

char *buf = NULL;

unsigned int buflen = 1024;

dns_rdataset_t rdataset;

REQUIRE(DNS_ZONE_VALID(zone));

dns_fixedname_init(&fname);

name = dns_fixedname_name(&fname);

dns_db_currentversion(zone->top, &version);

result = dns_db_createiterator(zone->top, ISC_FALSE, &dbiterator);

if (result == DNS_R_SUCCESS)

result = dns_dbiterator_first(dbiterator);

while (result == DNS_R_SUCCESS) {

result = dns_dbiterator_current(dbiterator, &node, name);

if (result != DNS_R_SUCCESS && result != DNS_R_NEWORIGIN)

break;

result = dns_db_allrdatasets(zone->top, node, version, 0,

&rdsiter);

if (result != DNS_R_SUCCESS) {

dns_db_detachnode(zone->top, &node);

break;

}

dns_rdataset_init(&rdataset);

result = dns_rdatasetiter_first(rdsiter);

while (result == DNS_R_SUCCESS) {

dns_rdatasetiter_current(rdsiter, &rdataset);

retry:

if (buf == NULL)

buf = isc_mem_get(zone->mctx, buflen);

if (buf == NULL)

result = DNS_R_NOMEMORY;

isc_buffer_init(&text, buf, buflen,

ISC_BUFFERTYPE_TEXT);

if (result == DNS_R_SUCCESS)

result = dns_rdataset_totext(&rdataset, name,

ISC_FALSE,

ISC_FALSE, &text);

if (result == DNS_R_NOSPACE) {

isc_mem_put(zone->mctx, buf, buflen);

buf = NULL;

buflen += 1024;

goto retry;

}

isc_buffer_used(&text, &region);

if (result == DNS_R_SUCCESS)

fprintf(fd, "%.*s", (int)region.length,

(char *)region.base);

dns_rdataset_disassociate(&rdataset);

if (result == DNS_R_SUCCESS)

result = dns_rdatasetiter_next(rdsiter);

}

dns_rdatasetiter_destroy(&rdsiter);

dns_db_detachnode(zone->top, &node);

if (result == DNS_R_NOMORE)

result = dns_dbiterator_next(dbiterator);

}

if (buf != NULL)

isc_mem_put(zone->mctx, buf, buflen);

dns_dbiterator_destroy(&dbiterator);

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

return (result);

}

dns_zone_unload(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

LOCK(&zone->lock);

dns_db_detach(&zone->top);

zone->flags &= ~DNS_ZONE_F_LOADED;

UNLOCK(&zone->lock);

}

dns_zone_unmount(dns_zone_t *zone) {

REQUIRE(DNS_ZONE_VALID(zone));

/*XXX MPA*/

}

dns_zone_manage(dns_zone_t *zone, isc_taskmgr_t *tmgr) {

#if 1

(void)zone;

(void)tmgr;

return (DNS_R_NOTIMPLEMENTED);

#else

isc_result_t iresult;

dns_result_t result;

/*

REQUIRE(DNS_ZONE_VALID(zone));

REQUIRE(zone->task == NULL);

REQUIRE(zone->timgr == NULL);

iresult = isc_task_create(tmgr, zone->mctx, 0, &zone->task);

if (iresult != ISC_R_SUCCESS) {

/* XXX */

return (DNS_R_UNEXPECTED);

}

iresult = isc_task_onshutdown(zone->task, zone_shutdown, zone);

if (iresult != ISC_R_SUCCESS) {

/* XXX */

return (DNS_R_UNEXPECTED);

}

iresult = isc_timermgr_create(zone->mctx, &zone->timgr);

if (iresult != ISC_R_SUCCESS) {

/* XXX */

return (DNS_R_UNEXPECTED);

}

if (zone->res == NULL) {

isc_socket_t *s;

dns_dispatch_t *dispatch;

RUNTIME_CHECK(isc_socketmgr_create(zone->mctx, &zone->socketmgr)

== ISC_R_SUCCESS);

s = NULL;

RUNTIME_CHECK(isc_socket_create(zone->socketmgr, PF_INET,

isc_sockettype_udp, &s) == ISC_R_SUCCESS);

dispatch = NULL;

RUNTIME_CHECK(dns_dispatch_create(zone->mctx, s, zone->task,

4096, 1000, 1000, 4, &dispatch) == DNS_R_SUCCESS);

result = dns_resolver_create(zone->mctx, tmgr, 10, zone->timgr,

zone->rdclass, dispatch,

&zone->res);

if (result != DNS_R_SUCCESS)

return (result);

dns_dispatch_detach(&dispatch);

isc_socket_detach(&s);

}

dns_zone_maintenance(zone);

return (DNS_R_SUCCESS);

#endif

}

dns_zone_setrefresh(dns_zone_t *zone, isc_uint32_t refresh,

isc_uint32_t retry)

{

REQUIRE(DNS_ZONE_VALID(zone));

zone->refresh = refresh;

zone->retry = retry;

}

dns_zone_notify(dns_zone_t *zone) {

unsigned int i;

dns_name_t *origin = NULL;

isc_sockaddr_t addr;

dns_rdataset_t nsrdset;

dns_rdataset_t ardset;

dns_dbversion_t *version = NULL;

dns_result_t result;

dns_dbnode_t *node = NULL;

dns_rdata_ns_t ns;

dns_rdata_in_a_t a;

dns_rdata_t rdata;

REQUIRE(DNS_ZONE_VALID(zone));

if (!DNS_ZONE_OPTION(zone, DNS_ZONE_O_NOTIFY))

return;

origin = &zone->origin;

/*

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

(void)dns_notify(origin, &zone->notify[i], dns_rdatatype_soa,

zone->rdclass, &zone->xfrsource, zone->mctx);

}

dns_db_currentversion(zone->top, &version);

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

if (result != DNS_R_SUCCESS)

goto cleanup1;

dns_rdataset_init(&nsrdset);

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

dns_rdatatype_ns,

dns_rdatatype_none, 0, &nsrdset, NULL);

if (result != DNS_R_SUCCESS)

goto cleanup2;

result = dns_rdataset_first(&nsrdset);

while (result == DNS_R_SUCCESS) {

dns_rdataset_current(&nsrdset, &rdata);

result = dns_rdata_tostruct(&rdata, &ns, zone->mctx);

if (result != DNS_R_SUCCESS)

continue;

/*

/* XXX MPA */

if (result == DNS_R_NOTFOUND) {

/*

/* XXX MPA*/

result = dns_rdataset_next(&nsrdset);

continue;

} else if (result != DNS_R_SUCCESS) {

result = dns_rdataset_next(&nsrdset);

continue;

}

result = dns_rdataset_first(&ardset);

while (result == DNS_R_SUCCESS) {

dns_rdataset_current(&ardset, &rdata);

result = dns_rdata_tostruct(&rdata, &a, zone->mctx);

if (result != DNS_R_SUCCESS)

continue;

/*

isc_sockaddr_fromin(&addr, &a.in_addr, 0);

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

if (isc_sockaddr_equal(&zone->notify[i], &addr))

break;

}

if (i == zone->notifycnt) {

(void)dns_notify(origin, &addr,

dns_rdatatype_soa,

zone->rdclass,

&zone->xfrsource, zone->mctx);

}

result = dns_rdataset_next(&ardset);

}

result = dns_rdataset_next(&nsrdset);

}

dns_rdataset_disassociate(&nsrdset);

cleanup2:

dns_db_detachnode(zone->top, &node);

cleanup1:

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

}

static void

refresh_callback(isc_task_t *task, isc_event_t *event) {

#if 1

(void)task;

(void)event;

#else

dns_fetchevent_t *devent = (dns_fetchevent_t *)event;

dns_zone_t *zone;

dns_message_t *msg = NULL;

isc_uint32_t soacnt, cnamecnt, soacount, nscount;

isc_stdtime_t now;

char *master;

char *unknown = "<UNKNOWN>";

dns_rdataset_t *rdataset;

dns_rdata_t rdata;

dns_rdata_soa_t soa;

dns_result_t result;

isc_uint32_t serial;

zone = devent->arg;

INSIST(DNS_ZONE_VALID(zone));

/*

master = isc_sockaddr_totext(&zone->masters[zone->curmaster],

zone->mctx);

if (master == NULL)

master = unknown;

if (devent->result != DNS_R_SUCCESS) {

dns_zone_logerror(zone, "refresh: failure for %s: %s",

master, dns_result_totext(devent->result));

goto next_master;

}

dns_resolver_getanswer(event, &msg);

/*

if (msg->rcode != dns_rcode_noerror) {

char rcode[128];

isc_buffer_t rb;

isc_buffer_init(&rb, rcode, sizeof rcode, ISC_BUFFERTYPE_TEXT);

dns_rcode_totext(msg->rcode, &rb);

dns_zone_logerror(zone,

"refresh: unexpected rcode (%.*s) from %s\n",

rb.used, rcode, master);

goto next_master;

}

/*

if ((msg->flags & DNS_MESSAGEFLAG_AA) == 0) {

dns_zone_logerror(zone,

"refresh: non-authorative answer from %s", master);

goto next_master;

}

/*

cnamecnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_cname);

soacnt = message_count(msg, DNS_SECTION_ANSWER, dns_rdatatype_soa);

if (cnamecnt != 0) {

dns_zone_logerror(zone,

"refresh: CNAME discovered: master %s", master);

goto next_master;

}

if (soacnt != 1) {

dns_zone_logerror(zone,

"refresh: SOA count (%d) != 1: master %s",

soacnt, master);

goto next_master;

}

nscount = message_count(msg, DNS_SECTION_AUTHORITY, dns_rdatatype_ns);

soacount = message_count(msg, DNS_SECTION_AUTHORITY, dns_rdatatype_soa);

/*

if (soacnt == 0 && soacount == 0 && nscount != 0) {

dns_zone_logerror(zone,

"refresh: referral: master %s", master);

goto next_master;

}

/*

if (soacnt == 0 && nscount == 0) {

dns_zone_logerror(zone, "refresh: NODATA: master %s", master);

goto next_master;

}

/*

rdataset = NULL;

result = dns_message_findname(msg, DNS_SECTION_ANSWER, &zone->origin,

dns_rdatatype_soa, dns_rdatatype_none,

NULL, &rdataset);

if (result != DNS_R_SUCCESS) {

dns_zone_logerror(zone, "refresh: unable to get soa record");

goto next_master;

}

result = dns_rdataset_first(rdataset);

if (result != DNS_R_SUCCESS) {

dns_zone_logerror(zone, "refresh: dns_rdataset_first failed");

goto next_master;

}

dns_rdataset_current(rdataset, &rdata);

result = dns_rdata_tostruct(&rdata, &soa, zone->mctx);

if (result != DNS_R_SUCCESS) {

dns_zone_logerror(zone, "refresh: dns_rdata_tostruct failed");

goto next_master;

}

serial = soa.serial;

dns_rdata_freestruct(&soa);

if (!DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) ||

isc_serial_gt(serial, zone->serial)) {

dns_zone_transfer_in(zone);

isc_event_free(&event);

dns_resolver_destroyfetch(zone->res, &zone->fetch);

} else if (isc_serial_eq(soa.serial, zone->serial)) {

dns_zone_uptodate(zone);

goto next_master;

} else {

goto next_master;

}

if (master != unknown)

isc_mem_put(zone->mctx, master, strlen(master) + 1);

return;

next_master:

LOCK(&zone->lock);

if (master != unknown)

isc_mem_put(zone->mctx, master, strlen(master) + 1);

isc_event_free(&event);

dns_resolver_destroyfetch(zone->res, &zone->fetch);

zone->curmaster++;

if (zone->curmaster >= zone->masterscnt) {

zone->flags &= ~DNS_ZONE_F_REFRESH;

if (isc_stdtime_get(&now) != ISC_R_SUCCESS)

return;

zone_settimer(zone, now);

UNLOCK(&zone->lock);

return;

}

UNLOCK(&zone->lock);

soa_query(zone, refresh_callback);

return;

#endif

}

#ifdef notyet

static void

soa_query(dns_zone_t *zone, isc_taskaction_t callback) {

dns_name_t *zonename;

dns_result_t result;

zonename = &zone->origin;

LOCK(&zone->lock);

result = dns_resolver_createfetch(zone->res, zonename,

dns_rdatatype_soa,

NULL, NULL, NULL,

DNS_FETCHOPT_UNSHARED,

zone->task, callback, zone,

&zone->fetch);

UNLOCK(&zone->lock);

if (result != DNS_R_SUCCESS)

cancel_refresh(zone);

}

#endif

static void

zone_shutdown(isc_task_t *task, isc_event_t *event) {

dns_zone_t *zone = (dns_zone_t *)event->arg;

isc_event_free(&event);

task = task; /* XXX */

zone = zone; /* XXX */

}

static void

zone_timer(isc_task_t *task, isc_event_t *event) {

dns_zone_t *zone = (dns_zone_t *)event->arg;

fprintf(stderr, "zone_timer\n");

dns_zone_maintenance(zone);

isc_event_free(&event);

task = task; /* XXX */

}

static dns_result_t

zone_settimer(dns_zone_t *zone, isc_stdtime_t now) {

isc_stdtime_t next = 0;

isc_time_t expires;

isc_interval_t interval;

isc_result_t iresult;

REQUIRE(DNS_ZONE_VALID(zone));

switch (zone->type) {

case dns_zone_master:

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_NEEDDUMP))

next = zone->dumptime;

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED)) {

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_SERVERS) &&

(zone->servertime < next || next == 0))

next = zone->servertime;

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_PARENTS) &&

(zone->parenttime < next || next == 0))

next = zone->parenttime;

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_CHILDREN) &&

(zone->childtime < next || next == 0))

next = zone->childtime;

}

break;

case dns_zone_slave:

case dns_zone_stub:

if (!DNS_ZONE_FLAG(zone, DNS_ZONE_F_REFRESH))

next = zone->refreshtime;

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED)) {

if (zone->expiretime < next || next == 0)

next = zone->expiretime;

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_SERVERS) &&

(zone->servertime < next || next == 0))

next = zone->servertime;

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_PARENTS) &&

(zone->parenttime < next || next == 0))

next = zone->parenttime;

if (DNS_ZONE_OPTION(zone, DNS_ZONE_O_CHILDREN) &&

(zone->childtime < next || next == 0))

next = zone->childtime;

}

break;

default:

break;

}

fprintf(stdout, "settimer %d %d = %d seconds\n",

next, now, next - now);

if (next == 0) {

if (zone->timer != NULL)

isc_timer_detach(&zone->timer);

} else {

isc_time_settoepoch(&expires);

if (next <= now)

isc_interval_set(&interval, 0, 1);

else

isc_interval_set(&interval, next - now, 0);

if (zone->timer != NULL) {

iresult = isc_timer_reset(zone->timer,

isc_timertype_once,

&expires, &interval,

ISC_TRUE);

} else {

iresult = isc_timer_create(zone->timgr,

isc_timertype_once,

&expires, &interval,

zone->task, zone_timer,

zone, &zone->timer);

}

if (iresult != ISC_R_SUCCESS) {

/* XXX */

return (DNS_R_UNEXPECTED);

}

}

return (DNS_R_SUCCESS);

}

cancel_refresh(dns_zone_t *zone) {

isc_stdtime_t now;

REQUIRE(DNS_ZONE_VALID(zone));

/* XXX MPA*/

LOCK(&zone->lock);

zone->flags &= ~DNS_ZONE_F_REFRESH;

UNLOCK(&zone->lock);

if (isc_stdtime_get(&now) != ISC_R_SUCCESS)

return;

if (!DNS_ZONE_FLAG(zone, DNS_ZONE_F_EXITING))

zone_settimer(zone, now);

}

static dns_result_t

dns_notify(dns_name_t *name, isc_sockaddr_t *addr, dns_rdatatype_t type,

dns_rdataclass_t rdclass, isc_sockaddr_t *source, isc_mem_t *mctx)

{

dns_message_t *msg = NULL;

dns_result_t result;

isc_buffer_t target;

/* dns_rdatalist_t *rdatalist = NULL; */

dns_rdatalist_t rdatalist;

dns_rdataset_t *rdataset = NULL;

char buf[512];

result = dns_message_create(mctx, DNS_MESSAGE_INTENTRENDER, &msg);

if (result != DNS_R_SUCCESS)

return (result);

msg->opcode = dns_opcode_notify;

msg->rdclass = rdclass;

msg->id = htons(3456); /* XXX */

/* result = dns_message_gettemprdatalist(msg, &rdatalist); */

ISC_LIST_INIT(rdatalist.rdata);

ISC_LINK_INIT(&rdatalist, link);

rdatalist.type = type;

rdatalist.rdclass = rdclass;

rdatalist.ttl = 0;

result = dns_message_gettemprdataset(msg, &rdataset);

if (result != DNS_R_SUCCESS)

goto cleanup;

dns_rdataset_init(rdataset);

dns_rdatalist_tordataset(&rdatalist, rdataset);

ISC_LIST_APPEND(name->list, rdataset, link);

dns_message_addname(msg, name, DNS_SECTION_QUESTION);

isc_buffer_init(&target, buf, sizeof buf, ISC_BUFFERTYPE_BINARY);

result = dns_message_renderbegin(msg, &target);

if (result != DNS_R_SUCCESS)

goto cleanup;

result = dns_message_rendersection(msg, DNS_SECTION_QUESTION, 0, 0);

if (result != DNS_R_SUCCESS)

goto cleanup;

result = dns_message_rendersection(msg, DNS_SECTION_ANSWER, 0, 0);

if (result != DNS_R_SUCCESS)

goto cleanup;

result = dns_message_rendersection(msg, DNS_SECTION_AUTHORITY, 0, 0);

if (result != DNS_R_SUCCESS)

goto cleanup;

result = dns_message_rendersection(msg, DNS_SECTION_ADDITIONAL, 0, 0);

if (result != DNS_R_SUCCESS)

goto cleanup;

/* XXX TSIG here */

result = dns_message_renderend(msg);

if (result != DNS_R_SUCCESS)

goto cleanup;

/* XXX Queue for sending */

addr = addr; /* XXX */

source = source; /* XXX */

cleanup:

dns_message_destroy(&msg);

return (result);

}

dns_zone_notifyreceive(dns_zone_t *zone, isc_sockaddr_t *from,

dns_message_t *msg)

{

unsigned int i;

dns_rdata_soa_t soa;

dns_rdataset_t *rdataset = NULL;

dns_rdata_t rdata;

dns_result_t result;

REQUIRE(DNS_ZONE_VALID(zone));

/*

/*

LOCK(&zone->lock);

if (msg->counts[DNS_SECTION_QUESTION] != 0 ||

dns_message_findname(msg, DNS_SECTION_QUESTION, &zone->origin,

dns_rdatatype_soa, dns_rdatatype_none,

NULL, NULL) != DNS_R_SUCCESS) {

UNLOCK(&zone->lock);

return (DNS_R_REFUSED);

}

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

if (isc_sockaddr_equal(from, &zone->masters[i]))

break;

if (i >= zone->masterscnt) {

UNLOCK(&zone->lock);

return (DNS_R_REFUSED);

}

/*

if (msg->counts[DNS_SECTION_ANSWER] > 0 &&

DNS_ZONE_FLAG(zone, DNS_ZONE_F_LOADED) &&

!DNS_ZONE_OPTION(zone, DNS_ZONE_O_DIALUP)) {

result = dns_message_findname(msg, DNS_SECTION_ANSWER,

&zone->origin,

dns_rdatatype_soa,

dns_rdatatype_none, NULL,

&rdataset);

if (result == DNS_R_SUCCESS)

result = dns_rdataset_first(rdataset);

if (result == DNS_R_SUCCESS) {

isc_uint32_t serial = 0;

dns_rdataset_current(rdataset, &rdata);

result = dns_rdata_tostruct(&rdata, &soa, zone->mctx);

if (result == DNS_R_SUCCESS) {

serial = soa.serial;

dns_rdata_freestruct(&soa);

if (isc_serial_le(serial, zone->serial))

return (DNS_R_SUCCESS);

}

}

}

/*

if (DNS_ZONE_FLAG(zone, DNS_ZONE_F_REFRESH)) {

zone->flags |= DNS_ZONE_F_NEEDREFRESH;

zone->notifyfrom = *from;

UNLOCK(&zone->lock);

return (DNS_R_SUCCESS);

}

UNLOCK(&zone->lock);

dns_zone_refresh(zone);

return (DNS_R_SUCCESS);

}

dns_zone_copy(dns_c_ctx_t *ctx, dns_c_zone_t *czone, dns_zone_t *zone) {

isc_result_t iresult;

dns_result_t result;

isc_boolean_t boolean;

const char *filename = NULL;

const char *ixfr = NULL;

dns_c_ipmatchlist_t *acl = 0;

dns_c_severity_t severity;

dns_c_iplist_t *iplist = NULL;

dns_c_pubkey_t *pubkey = NULL;

isc_uint32_t i;

isc_sockaddr_t sockaddr;

isc_int32_t size;

isc_int32_t xfrtime;

in_port_t port;

const char *origin;

char *o;

ctx = ctx; /* unused */

dns_zone_setclass(zone, czone->zclass);

origin = NULL;

result = dns_c_zone_getname(NULL, czone, &origin);

if (result != DNS_R_SUCCESS)

return (result);

o = isc_mem_strdup(zone->mctx, origin);

if (o == NULL)

return (DNS_R_NOMEMORY);

result = dns_zone_setorigin(zone, o);

isc_mem_free(zone->mctx, o);

if (result != DNS_R_SUCCESS)

return (result);

/* XXX needs to be an zone option */

result = dns_zone_setdbtype(zone, "rbt");

if (result != DNS_R_SUCCESS)

return (result);

switch (czone->ztype) {

case dns_c_zone_master:

dns_zone_settype(zone, dns_zone_master);

iresult = dns_c_zone_getfile(NULL /* isc_log_t */,

czone, &filename);

if (iresult != ISC_R_SUCCESS)

return (iresult);

result = dns_zone_setdatabase(zone, filename);

if (result != DNS_R_SUCCESS)

return (iresult);

iresult = dns_c_zone_getchecknames(NULL /* isc_log_t */,

czone, &severity);

if (iresult == ISC_R_SUCCESS)

dns_zone_setchecknames(zone, severity);

else

dns_zone_setchecknames(zone, dns_c_severity_fail);

iresult = dns_c_zone_getallowupd(NULL /* isc_log_t */,

czone, &acl);

if (iresult == ISC_R_SUCCESS) {

dns_zone_setupdateacl(zone, acl);

dns_c_ipmatchlist_delete(NULL, &acl);

} else

dns_zone_clearupdateacl(zone);

iresult = dns_c_zone_getallowquery(NULL /* isc_log_t */,

czone, &acl);

if (iresult == ISC_R_SUCCESS) {

dns_zone_setqueryacl(zone, acl);

dns_c_ipmatchlist_delete(NULL, &acl);

} else

dns_zone_clearqueryacl(zone);

iresult = dns_c_zone_getallowtransfer(NULL /* isc_log_t */,

czone, &acl);

if (iresult == ISC_R_SUCCESS) {

dns_zone_setxfracl(zone, acl);

dns_c_ipmatchlist_delete(NULL, &acl);

} else

dns_zone_clearxfracl(zone);

iresult = dns_c_zone_getdialup(NULL /* isc_log_t */,

czone, &boolean);

if (iresult == ISC_R_SUCCESS)

dns_zone_setoption(zone, DNS_ZONE_O_DIALUP, boolean);

else

dns_zone_clearoption(zone, DNS_ZONE_O_DIALUP);

iresult = dns_c_zone_getnotify(NULL /* isc_log_t */,

czone, &boolean);

if (iresult == ISC_R_SUCCESS)

dns_zone_setoption(zone, DNS_ZONE_O_NOTIFY, boolean);

else

dns_zone_clearoption(zone, DNS_ZONE_O_NOTIFY);

iresult = dns_c_zone_getalsonotify(NULL /* isc_log_t */,

czone, &iplist);

if (iresult == ISC_R_SUCCESS) {

for (i = 0; i < iplist->nextidx; i++) {

result = dns_zone_addnotify(zone,

&iplist->ips[i]);

if (result != DNS_R_SUCCESS)

return (result);

}

} else

dns_zone_clearnotify(zone);

iresult = dns_c_zone_getixfrbase(NULL /* isc_log_t */,

czone, &ixfr);

if (iresult == ISC_R_SUCCESS) {

result = dns_zone_setixfrlog(zone, ixfr);

if (result != DNS_R_SUCCESS)

return (result);

zone->diff_on_reload = ISC_TRUE;

} else

zone->diff_on_reload = ISC_FALSE;

czone->u.mzone.ixfr_tmp; /*XXX*/

iresult = dns_c_zone_getmaxixfrlog(NULL /* isc_log_t */,

czone, &size);

if (iresult == ISC_R_SUCCESS)

dns_zone_setixfrlogsize(zone, size);

czone->u.mzone.maint_ixfr_base; /*XXX*/

iresult = dns_c_zone_getpubkey(NULL /* isc_log_t */,

czone, &pubkey);

if (iresult == ISC_R_SUCCESS)

dns_zone_setpubkey(zone, pubkey);

else

dns_zone_setpubkey(zone, NULL);

break;

case dns_c_zone_forward:

#ifdef notyet

/*

czone->u.fzone.check_names; /* XXX unused in BIND 8 */

czone->u.fzone.forward; /* XXX*/

czone->u.fzone.forwarders; /* XXX*/

#endif

break;

case dns_c_zone_slave:

dns_zone_settype(zone, dns_zone_slave);

iresult = dns_c_zone_getfile(NULL /* isc_log_t */,

czone, &filename);

if (iresult != ISC_R_SUCCESS)

return (iresult);

result = dns_zone_setdatabase(zone, filename);

if (result != DNS_R_SUCCESS)

return (iresult);

iresult = dns_c_zone_getchecknames(NULL /* isc_log_t */,

czone, &severity);

if (iresult == ISC_R_SUCCESS)

dns_zone_setchecknames(zone, severity);

else

dns_zone_setchecknames(zone, dns_c_severity_warn);

iresult = dns_c_zone_getallowquery(NULL /* isc_log_t */,

czone, &acl);

if (iresult == ISC_R_SUCCESS) {

dns_zone_setqueryacl(zone, acl);

dns_c_ipmatchlist_delete(NULL, &acl);

} else

dns_zone_clearqueryacl(zone);

iresult = dns_c_zone_getpubkey(NULL /* isc_log_t */,

czone, &pubkey);

if (iresult == ISC_R_SUCCESS)

dns_zone_setpubkey(zone, pubkey);

else

dns_zone_setpubkey(zone, NULL);

iresult = dns_c_zone_getmasterport(NULL /* isc_log_t */,

czone, &port);

if (iresult != ISC_R_SUCCESS)

port = 53;

dns_zone_setmasterport(zone, port);

iresult = dns_c_zone_getmasterips(NULL /* isc_log_t */,

czone, &iplist);

if (iresult == ISC_R_SUCCESS) {

for (i = 0; i < iplist->nextidx; i++) {

result = dns_zone_addmaster(zone,

&iplist->ips[i]);

if (result != DNS_R_SUCCESS)

return (result);

}

} else

dns_zone_clearmasters(zone);

break;

case dns_c_zone_stub:

dns_zone_settype(zone, dns_zone_stub);

iresult = dns_c_zone_getfile(NULL /* isc_log_t */,

czone, &filename);

if (iresult != ISC_R_SUCCESS)

return (iresult);

result = dns_zone_setdatabase(zone, filename);

if (result != DNS_R_SUCCESS)

return (iresult);

iresult = dns_c_zone_getchecknames(NULL /* isc_log_t */,

czone, &severity);

if (iresult == ISC_R_SUCCESS)

dns_zone_setchecknames(zone, severity);

else

dns_zone_setchecknames(zone, dns_c_severity_warn);

iresult = dns_c_zone_getallowquery(NULL /* isc_log_t */,

czone, &acl);

if (iresult == ISC_R_SUCCESS) {

dns_zone_setqueryacl(zone, acl);

dns_c_ipmatchlist_delete(NULL, &acl);

} else

dns_zone_clearqueryacl(zone);

iresult = dns_c_zone_getpubkey(NULL /* isc_log_t */,

czone, &pubkey);

if (iresult == ISC_R_SUCCESS)

dns_zone_setpubkey(zone, pubkey);

else

dns_zone_setpubkey(zone, NULL);

iresult = dns_c_zone_getmasterport(NULL /* isc_log_t */,

czone, &port);

if (iresult != ISC_R_SUCCESS)

port = 53;

dns_zone_setmasterport(zone, port);