3b922eeb6294d579edfd720ac162287e6736e07aTinderbox User

3b922eeb6294d579edfd720ac162287e6736e07aTinderbox User /* $Id: zone.c,v 1.24 1999/10/15 19:47:31 gson Exp $ */

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <config.h>

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <string.h>

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <isc/assertions.h>

87a40683bf81a4a18291c093b7da67ca46760607Mark Andrews#include <isc/error.h>

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

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <isc/timer.h>

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <isc/print.h>

af9dbf1ccdd53933aaae9300d13ce0965d39b067Evan Hunt#include <isc/serial.h>

87a40683bf81a4a18291c093b7da67ca46760607Mark Andrews#include <isc/magic.h>

87a40683bf81a4a18291c093b7da67ca46760607Mark Andrews

#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 != 1)

fprintf(stderr, "zone has %d SOA records\n",

soacount);

if (nscount == 0)

fprintf(stderr, "zone has no NS records\n");

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

if (result != ISC_R_SUCCESS)

goto cleanup;

} else {

dns_db_attach(db, &zone->top);

zone->flags |= DNS_ZONE_F_LOADED;

}

result = ISC_R_SUCCESS;

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

}