/*
* For optimal compression IXFR response packets are limited in size
* to MAX_COMPRESSION_OFFSET.
*/
#define IXFR_MAX_MESSAGE_LEN MAX_COMPRESSION_OFFSET
/* draft-ietf-dnsop-rfc2845bis-06, section 5.3.1 says to sign every packet */
#define IXFR_TSIG_SIGN_EVERY_NTH 0 /* tsig sign every N packets. */
/* initial space in rrs data for storing records */
#define IXFR_STORE_INITIAL_SIZE 4096
/* store compression for one name */
struct rrcompress_entry {
/* rbtree node, key is this struct */
struct rbnode node;
/* the uncompressed domain name */
const uint8_t* dname;
/* the length of the dname, includes terminating 0 label */
uint16_t len;
/* the offset of the dname in the packet */
uint16_t offset;
};
/* structure to store compression data for the packet */
struct pktcompression {
/* rbtree of rrcompress_entry. sorted by dname */
struct rbtree tree;
/* allocation information, how many bytes allocated now */
size_t alloc_now;
/* allocation information, total size in block */
size_t alloc_max;
/* region to use if block full, this is NULL if unused */
struct region* region;
/* block of temp data for allocation */
uint8_t block[sizeof(struct rrcompress_entry)*1024];
};
/* compare two elements in the compression tree. Returns -1, 0, or 1. */
static int compression_cmp(const void* a, const void* b)
{
struct rrcompress_entry* rra = (struct rrcompress_entry*)a;
struct rrcompress_entry* rrb = (struct rrcompress_entry*)b;
if(rra->len != rrb->len) {
if(rra->len < rrb->len)
return -1;
return 1;
}
return memcmp(rra->dname, rrb->dname, rra->len);
}
/* init the pktcompression to a new packet */
static void pktcompression_init(struct pktcompression* pcomp)
{
pcomp->alloc_now = 0;
pcomp->alloc_max = sizeof(pcomp->block);
pcomp->region = NULL;
pcomp->tree.root = RBTREE_NULL;
pcomp->tree.count = 0;
pcomp->tree.region = NULL;
pcomp->tree.cmp = &compression_cmp;
}
/* alloc data in pktcompression */
static void* pktcompression_alloc(struct pktcompression* pcomp, size_t s)
{
/* first attempt to allocate in the fixed block,
* that is very fast and on the stack in the pcomp struct */
if(pcomp->alloc_now + s <= pcomp->alloc_max) {
void* ret = pcomp->block + pcomp->alloc_now;
pcomp->alloc_now += s;
return ret;
}
/* if that fails, create a region to allocate in,
* it is freed in the freeup */
if(!pcomp->region) {
pcomp->region = region_create(xalloc, free);
if(!pcomp->region)
return NULL;
}
return region_alloc(pcomp->region, s);
}
/* insert a new domain name into the compression tree.
* it fails silently, no need to compress then. */
static void pktcompression_insert(struct pktcompression* pcomp,
const uint8_t* dname, size_t len, uint16_t offset)
{
struct rrcompress_entry* entry;
if(len > 65535)
return;
if(offset > MAX_COMPRESSION_OFFSET)
return; /* too far for a compression pointer */
entry = pktcompression_alloc(pcomp, sizeof(*entry));
if(!entry)
return;
memset(&entry->node, 0, sizeof(entry->node));
entry->node.key = entry;
entry->dname = dname;
entry->len = len;
entry->offset = offset;
(void)rbtree_insert(&pcomp->tree, &entry->node);
}
/* insert all the labels of a domain name */
static void pktcompression_insert_with_labels(struct pktcompression* pcomp,
uint8_t* dname, size_t len, uint16_t offset)
{
if(!dname)
return;
if(offset > MAX_COMPRESSION_OFFSET)
return;
/* while we have not seen the end root label */
while(len > 0 && dname[0] != 0) {
size_t lablen;
pktcompression_insert(pcomp, dname, len, offset);
lablen = (size_t)(dname[0]);
if( (lablen&0xc0) )
return; /* the dname should be uncompressed */
if(lablen+1 > len)
return; /* len should be uncompressed wireformat len */
if(offset > MAX_COMPRESSION_OFFSET - lablen - 1)
return; /* offset moves too far for compression */
/* skip label */
len -= lablen+1;
dname += lablen+1;
offset += lablen+1;
}
}
/* calculate length of dname in uncompressed wireformat in buffer */
static size_t dname_length(const uint8_t* buf, size_t len)
{
size_t l = 0;
if(!buf || len == 0)
return l;
while(len > 0 && buf[0] != 0) {
size_t lablen = (size_t)(buf[0]);
if( (lablen&0xc0) )
return 0; /* the name should be uncompressed */
if(lablen+1 > len)
return 0; /* should fit in the buffer */
l += lablen+1;
len -= lablen+1;
buf += lablen+1;
}
if(len == 0)
return 0; /* end label should fit in buffer */
if(buf[0] != 0)
return 0; /* must end in root label */
l += 1; /* for the end root label */
return l;
}
/* write a compressed domain name into the packet,
* returns uncompressed wireformat length,
* 0 if it does not fit and -1 on failure, bad dname. */
static int pktcompression_write_dname(struct buffer* packet,
struct pktcompression* pcomp, const uint8_t* rr, size_t rrlen)
{
size_t wirelen = 0;
size_t dname_len = dname_length(rr, rrlen);
if(!rr || rrlen == 0 || dname_len == 0)
return 0;
while(rrlen > 0 && rr[0] != 0) {
size_t lablen = (size_t)(rr[0]);
uint16_t offset;
if( (lablen&0xc0) )
return -1; /* name should be uncompressed */
if(lablen+1 > rrlen)
return -1; /* name should fit */
/* see if the domain name has a compression pointer */
if((offset=pktcompression_find(pcomp, rr, dname_len))!=0) {
if(!buffer_available(packet, 2))
return 0;
buffer_write_u16(packet, (uint16_t)(0xc000 | offset));
wirelen += dname_len;
return wirelen;
} else {
if(!buffer_available(packet, lablen+1))
return 0;
/* insert the domain name at this position */
pktcompression_insert(pcomp, rr, dname_len,
buffer_position(packet));
/* write it */
buffer_write(packet, rr, lablen+1);
}
/* write an RR into the packet with compression for domain names,
* return 0 and resets position if it does not fit in the packet. */
static int ixfr_write_rr_pkt(struct query* query, struct buffer* packet,
struct pktcompression* pcomp, const uint8_t* rr, size_t rrlen,
uint16_t total_added)
{
size_t oldpos = buffer_position(packet);
size_t rdpos;
uint16_t tp;
int dname_len;
size_t rdlen;
size_t i;
rrtype_descriptor_type* descriptor;
if(total_added == 0) {
size_t oldmaxlen = query->maxlen;
/* RR > 16K can be first RR */
query->maxlen = (query->tcp?TCP_MAX_MESSAGE_LEN:UDP_MAX_MESSAGE_LEN);
if(query_overflow(query)) {
query->maxlen = oldmaxlen;
return 0;
}
query->maxlen = oldmaxlen;
} else {
if(buffer_position(packet) > MAX_COMPRESSION_OFFSET
|| query_overflow(query)) {
/* we are past the maximum length */
return 0;
}
}
switch(rdata_atom_wireformat_type(tp, i)) {
case RDATA_WF_COMPRESSED_DNAME:
dname_len = pktcompression_write_dname(packet, pcomp,
rr, rdlen);
if(dname_len == -1)
return 1; /* attempt to skip malformed rr */
if(dname_len == 0) {
buffer_set_position(packet, oldpos);
return 0;
}
rr += dname_len;
rdlen -= dname_len;
break;
case RDATA_WF_UNCOMPRESSED_DNAME:
case RDATA_WF_LITERAL_DNAME:
copy_len = rdlen;
break;
case RDATA_WF_BYTE:
copy_len = 1;
break;
case RDATA_WF_SHORT:
copy_len = 2;
break;
case RDATA_WF_LONG:
copy_len = 4;
break;
case RDATA_WF_TEXTS:
case RDATA_WF_LONG_TEXT:
copy_len = rdlen;
break;
case RDATA_WF_TEXT:
case RDATA_WF_BINARYWITHLENGTH:
copy_len = 1;
if(rdlen > copy_len)
copy_len += rr[0];
break;
case RDATA_WF_A:
copy_len = 4;
break;
case RDATA_WF_AAAA:
copy_len = 16;
break;
case RDATA_WF_ILNP64:
copy_len = 8;
break;
case RDATA_WF_EUI48:
copy_len = EUI48ADDRLEN;
break;
case RDATA_WF_EUI64:
copy_len = EUI64ADDRLEN;
break;
case RDATA_WF_BINARY:
copy_len = rdlen;
break;
case RDATA_WF_APL:
copy_len = (sizeof(uint16_t) /* address family */
+ sizeof(uint8_t) /* prefix */
+ sizeof(uint8_t)); /* length */
if(copy_len <= rdlen)
copy_len += (rr[copy_len-1]&APL_LENGTH_MASK);
break;
case RDATA_WF_IPSECGATEWAY:
copy_len = rdlen;
break;
case RDATA_WF_SVCPARAM:
copy_len = 4;
if(copy_len <= rdlen)
copy_len += read_uint16(rr+2);
break;
default:
copy_len = rdlen;
break;
}
if(copy_len) {
if(!buffer_available(packet, copy_len)) {
buffer_set_position(packet, oldpos);
return 0;
}
if(copy_len > rdlen)
return 1; /* assert of skip malformed */
buffer_write(packet, rr, copy_len);
rr += copy_len;
rdlen -= copy_len;
}
}
/* write compressed rdata length */
buffer_write_u16_at(packet, rdpos, buffer_position(packet)-rdpos-2);
if(total_added == 0) {
size_t oldmaxlen = query->maxlen;
query->maxlen = (query->tcp?TCP_MAX_MESSAGE_LEN:UDP_MAX_MESSAGE_LEN);
if(query_overflow(query)) {
query->maxlen = oldmaxlen;
buffer_set_position(packet, oldpos);
return 0;
}
query->maxlen = oldmaxlen;
} else {
if(query_overflow(query)) {
/* we are past the maximum length */
buffer_set_position(packet, oldpos);
return 0;
}
}
return 1;
}
/* parse the serial number from the IXFR query */
static int parse_qserial(struct buffer* packet, uint32_t* qserial,
size_t* snip_pos)
{
unsigned int i;
uint16_t type, rdlen;
/* we must have a SOA in the authority section */
if(NSCOUNT(packet) == 0)
return 0;
/* skip over the question section, we want only one */
buffer_set_position(packet, QHEADERSZ);
if(QDCOUNT(packet) != 1)
return 0;
if(!packet_skip_rr(packet, 1))
return 0;
/* set position to snip off the authority section */
*snip_pos = buffer_position(packet);
/* skip over the authority section RRs until we find the SOA */
for(i=0; i<NSCOUNT(packet); i++) {
/* is this the SOA record? */
if(!packet_skip_dname(packet))
return 0; /* malformed name */
if(!buffer_available(packet, 10))
return 0; /* no type,class,ttl,rdatalen */
type = buffer_read_u16(packet);
buffer_skip(packet, 6);
rdlen = buffer_read_u16(packet);
if(!buffer_available(packet, rdlen))
return 0;
if(type == TYPE_SOA) {
/* read serial from rdata, skip two dnames, then
* read the 32bit value */
if(!packet_skip_dname(packet))
return 0; /* malformed nsname */
if(!packet_skip_dname(packet))
return 0; /* malformed rname */
if(!buffer_available(packet, 4))
return 0;
*qserial = buffer_read_u32(packet);
return 1;
}
buffer_skip(packet, rdlen);
}
return 0;
}
/* get serial from SOA RR */
static uint32_t soa_rr_get_serial(struct rr* rr)
{
if(rr->rdata_count < 3)
return 0;
if(rr->rdatas[2].data[0] < 4)
return 0;
return read_uint32(&rr->rdatas[2].data[1]);
}
/* get the current serial from the zone */
uint32_t zone_get_current_serial(struct zone* zone)
{
if(!zone || !zone->soa_rrset)
return 0;
if(zone->soa_rrset->rr_count == 0)
return 0;
if(zone->soa_rrset->rrs[0].rdata_count < 3)
return 0;
if(zone->soa_rrset->rrs[0].rdatas[2].data[0] < 4)
return 0;
return read_uint32(&zone->soa_rrset->rrs[0].rdatas[2].data[1]);
}
/* iterator over ixfr data. find first element, eg. oldest zone version
* change.
* The iterator can be started with the ixfr_data_first, but also with
* ixfr_data_last, or with an existing ixfr_data element to start from.
* Continue by using ixfr_data_next or ixfr_data_prev to ask for more elements
* until that returns NULL. NULL because end of list or loop was detected.
* The ixfr_data_prev uses a counter, start it at 0, it returns NULL when
* a loop is detected.
*/
static struct ixfr_data* ixfr_data_first(struct zone_ixfr* ixfr)
{
struct ixfr_data* n;
if(!ixfr || !ixfr->data || ixfr->data->count==0)
return NULL;
n = (struct ixfr_data*)rbtree_search(ixfr->data, &ixfr->oldest_serial);
if(!n || n == (struct ixfr_data*)RBTREE_NULL)
return NULL;
return n;
}
/* iterator over ixfr data. find last element, eg. newest zone version
* change. */
static struct ixfr_data* ixfr_data_last(struct zone_ixfr* ixfr)
{
struct ixfr_data* n;
if(!ixfr || !ixfr->data || ixfr->data->count==0)
return NULL;
n = (struct ixfr_data*)rbtree_search(ixfr->data, &ixfr->newest_serial);
if(!n || n == (struct ixfr_data*)RBTREE_NULL)
return NULL;
return n;
}
/* iterator over ixfr data. fetch next item. If loop or nothing, NULL */
static struct ixfr_data* ixfr_data_next(struct zone_ixfr* ixfr,
struct ixfr_data* cur)
{
struct ixfr_data* n;
if(!cur || cur == (struct ixfr_data*)RBTREE_NULL)
return NULL;
if(cur->oldserial == ixfr->newest_serial)
return NULL; /* that was the last element */
n = (struct ixfr_data*)rbtree_next(&cur->node);
if(n && n != (struct ixfr_data*)RBTREE_NULL &&
cur->newserial == n->oldserial) {
/* the next rbtree item is the next ixfr data item */
return n;
}
/* If the next item is last of tree, and we have to loop around,
* the search performs the lookup for the next item we need.
* If the next item exists, but also is not connected, the search
* finds the correct connected ixfr in the sorted tree. */
/* try searching for the correct ixfr data item */
n = (struct ixfr_data*)rbtree_search(ixfr->data, &cur->newserial);
if(!n || n == (struct ixfr_data*)RBTREE_NULL)
return NULL;
return n;
}
/* iterator over ixfr data. fetch the previous item. If loop or nothing NULL.*/
static struct ixfr_data* ixfr_data_prev(struct zone_ixfr* ixfr,
struct ixfr_data* cur, size_t* prevcount)
{
struct ixfr_data* prev;
if(!cur || cur == (struct ixfr_data*)RBTREE_NULL)
return NULL;
if(cur->oldserial == ixfr->oldest_serial)
return NULL; /* this was the first element */
prev = (struct ixfr_data*)rbtree_previous(&cur->node);
if(!prev || prev == (struct ixfr_data*)RBTREE_NULL) {
/* We hit the first element in the tree, go again
* at the last one. Wrap around. */
prev = (struct ixfr_data*)rbtree_last(ixfr->data);
}
while(prev && prev != (struct ixfr_data*)RBTREE_NULL) {
if(prev->newserial == cur->oldserial) {
/* This is the correct matching previous ixfr data */
/* Increase the prevcounter every time the routine
* returns an item, and if that becomes too large, we
* are in a loop. in that case, stop. */
if(prevcount) {
(*prevcount)++;
if(*prevcount > ixfr->data->count + 12) {
/* Larger than the max number of items
* plus a small margin. The longest
* chain is all the ixfr elements in
* the tree. It loops. */
return NULL;
}
}
return prev;
}
prev = (struct ixfr_data*)rbtree_previous(&prev->node);
if(!prev || prev == (struct ixfr_data*)RBTREE_NULL) {
/* We hit the first element in the tree, go again
* at the last one. Wrap around. */
prev = (struct ixfr_data*)rbtree_last(ixfr->data);
}
}
/* no elements in list */
return NULL;
}
/* connect IXFRs, return true if connected, false if not. Return last serial */
static int connect_ixfrs(struct zone_ixfr* ixfr, struct ixfr_data* data,
uint32_t* end_serial)
{
struct ixfr_data* p = data;
while(p != NULL) {
struct ixfr_data* next = ixfr_data_next(ixfr, p);
if(next) {
if(p->newserial != next->oldserial) {
/* These ixfrs are not connected,
* during IXFR processing that could already
* have been deleted, but we check here
* in any case */
return 0;
}
} else {
/* the chain of IXFRs ends in this serial number */
*end_serial = p->newserial;
}
p = next;
}
return 1;
}
/* Count length of next record in data */
static size_t count_rr_length(const uint8_t* data, size_t data_len,
size_t current)
{
uint8_t label_size;
uint16_t rdlen;
size_t i = current;
if(current >= data_len)
return 0;
/* pass the owner dname */
while(1) {
if(i+1 > data_len)
return 0;
label_size = data[i++];
if(label_size == 0) {
break;
} else if((label_size &0xc0) != 0) {
return 0; /* uncompressed dnames in IXFR store */
} else if(i+label_size > data_len) {
return 0;
} else {
i += label_size;
}
}
/* after dname, we pass type, class, ttl, rdatalen */
if(i+10 > data_len)
return 0;
i += 8;
rdlen = read_uint16(data+i);
i += 2;
/* pass over the rdata */
if(i+((size_t)rdlen) > data_len)
return 0;
i += ((size_t)rdlen);
return i-current;
}
/* Copy RRs into packet until packet full, return number RRs added */
static uint16_t ixfr_copy_rrs_into_packet(struct query* query,
struct pktcompression* pcomp)
{
uint16_t total_added = 0;
/* Copy RRs into the packet until the answer is full,
* when an RR does not fit, we return and add no more. */
/* Add first SOA */
if(query->ixfr_count_newsoa < query->ixfr_end_data->newsoa_len) {
/* the new SOA is added from the end_data segment, it is
* the final SOA of the result of the IXFR */
if(ixfr_write_rr_pkt(query, query->packet, pcomp,
query->ixfr_end_data->newsoa,
query->ixfr_end_data->newsoa_len, total_added)) {
query->ixfr_count_newsoa = query->ixfr_end_data->newsoa_len;
total_added++;
query->ixfr_pos_of_newsoa = buffer_position(query->packet);
} else {
/* cannot add another RR, so return */
return total_added;
}
}
/* Add second SOA */
if(query->ixfr_count_oldsoa < query->ixfr_data->oldsoa_len) {
if(ixfr_write_rr_pkt(query, query->packet, pcomp,
query->ixfr_data->oldsoa,
query->ixfr_data->oldsoa_len, total_added)) {
query->ixfr_count_oldsoa = query->ixfr_data->oldsoa_len;
total_added++;
} else {
/* cannot add another RR, so return */
return total_added;
}
}
/* Add del data, with deleted RRs and a SOA */
while(query->ixfr_count_del < query->ixfr_data->del_len) {
size_t rrlen = count_rr_length(query->ixfr_data->del,
query->ixfr_data->del_len, query->ixfr_count_del);
if(rrlen && ixfr_write_rr_pkt(query, query->packet, pcomp,
query->ixfr_data->del + query->ixfr_count_del,
rrlen, total_added)) {
query->ixfr_count_del += rrlen;
total_added++;
} else {
/* the next record does not fit in the remaining
* space of the packet */
return total_added;
}
}
/* Add add data, with added RRs and a SOA */
while(query->ixfr_count_add < query->ixfr_data->add_len) {
size_t rrlen = count_rr_length(query->ixfr_data->add,
query->ixfr_data->add_len, query->ixfr_count_add);
if(rrlen && ixfr_write_rr_pkt(query, query->packet, pcomp,
query->ixfr_data->add + query->ixfr_count_add,
rrlen, total_added)) {
query->ixfr_count_add += rrlen;
total_added++;
} else {
/* the next record does not fit in the remaining
* space of the packet */
return total_added;
}
}
return total_added;
}
pktcompression_init(&pcomp);
if (query->maxlen > IXFR_MAX_MESSAGE_LEN)
query->maxlen = IXFR_MAX_MESSAGE_LEN;
assert(!query_overflow(query));
/* only keep running values for most packets */
query->tsig_prepare_it = 0;
query->tsig_update_it = 1;
if(query->tsig_sign_it) {
/* prepare for next updates */
query->tsig_prepare_it = 1;
query->tsig_sign_it = 0;
}
if (query->ixfr_data == NULL) {
/* This is the first packet, process the query further */
uint32_t qserial = 0, current_serial = 0, end_serial = 0;
struct zone* zone;
struct ixfr_data* ixfr_data;
size_t oldpos;
STATUP(nsd, rixfr);
/* parse the serial number from the IXFR request */
oldpos = QHEADERSZ;
if(!parse_qserial(query->packet, &qserial, &oldpos)) {
NSCOUNT_SET(query->packet, 0);
ARCOUNT_SET(query->packet, 0);
buffer_set_position(query->packet, oldpos);
RCODE_SET(query->packet, RCODE_FORMAT);
return QUERY_PROCESSED;
}
NSCOUNT_SET(query->packet, 0);
ARCOUNT_SET(query->packet, 0);
buffer_set_position(query->packet, oldpos);
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "ixfr query routine, %s IXFR=%u",
dname_to_string(query->qname, NULL), (unsigned)qserial));
/* do we have an IXFR with this serial number? If not, serve AXFR */
zone = namedb_find_zone(nsd->db, query->qname);
if(!zone) {
/* no zone is present */
RCODE_SET(query->packet, RCODE_NOTAUTH);
return QUERY_PROCESSED;
}
ZTATUP(nsd, zone, rixfr);
/* if the query is for same or newer serial than our current
* serial, then serve a single SOA with our current serial */
current_serial = zone_get_current_serial(zone);
if(compare_serial(qserial, current_serial) >= 0) {
if(!zone->soa_rrset || zone->soa_rrset->rr_count != 1){
RCODE_SET(query->packet, RCODE_SERVFAIL);
return QUERY_PROCESSED;
}
query_add_compression_domain(query, zone->apex,
QHEADERSZ);
if(packet_encode_rr(query, zone->apex,
&zone->soa_rrset->rrs[0],
zone->soa_rrset->rrs[0].ttl)) {
ANCOUNT_SET(query->packet, 1);
} else {
RCODE_SET(query->packet, RCODE_SERVFAIL);
}
AA_SET(query->packet);
query_clear_compression_tables(query);
if(query->tsig.status == TSIG_OK)
query->tsig_sign_it = 1;
return QUERY_PROCESSED;
}
if(!zone->ixfr) {
/* we have no ixfr information for the zone, make an AXFR */
if(query->tsig_prepare_it)
query->tsig_sign_it = 1;
VERBOSITY(2, (LOG_INFO, "ixfr fallback to axfr, no ixfr info for zone: %s",
dname_to_string(query->qname, NULL)));
return query_axfr(nsd, query, 0);
}
ixfr_data = zone_ixfr_find_serial(zone->ixfr, qserial);
if(!ixfr_data) {
/* the specific version is not available, make an AXFR */
if(query->tsig_prepare_it)
query->tsig_sign_it = 1;
VERBOSITY(2, (LOG_INFO, "ixfr fallback to axfr, no history for serial for zone: %s",
dname_to_string(query->qname, NULL)));
return query_axfr(nsd, query, 0);
}
/* see if the IXFRs connect to the next IXFR, and if it ends
* at the current served zone, if not, AXFR */
if(!connect_ixfrs(zone->ixfr, ixfr_data, &end_serial) ||
end_serial != current_serial) {
if(query->tsig_prepare_it)
query->tsig_sign_it = 1;
VERBOSITY(2, (LOG_INFO, "ixfr fallback to axfr, incomplete history from this serial for zone: %s",
dname_to_string(query->qname, NULL)));
return query_axfr(nsd, query, 0);
}
query->zone = zone;
query->ixfr_data = ixfr_data;
query->ixfr_is_done = 0;
/* set up to copy the last version's SOA as first SOA */
query->ixfr_end_data = ixfr_data_last(zone->ixfr);
query->ixfr_count_newsoa = 0;
query->ixfr_count_oldsoa = 0;
query->ixfr_count_del = 0;
query->ixfr_count_add = 0;
query->ixfr_pos_of_newsoa = 0;
/* the query name can be compressed to */
pktcompression_insert_with_labels(&pcomp,
buffer_at(query->packet, QHEADERSZ),
query->qname->name_size, QHEADERSZ);
if(query->tsig.status == TSIG_OK) {
query->tsig_sign_it = 1; /* sign first packet in stream */
}
} else {
/*
* Query name need not be repeated after the
* first response packet.
*/
buffer_set_limit(query->packet, QHEADERSZ);
QDCOUNT_SET(query->packet, 0);
query_prepare_response(query);
}
while(query->ixfr_count_add >= query->ixfr_data->add_len) {
struct ixfr_data* next = ixfr_data_next(query->zone->ixfr,
query->ixfr_data);
/* finished the ixfr_data */
if(next) {
/* move to the next IXFR */
query->ixfr_data = next;
/* we need to skip the SOA records, set len to done*/
/* the newsoa count is already done, at end_data len */
query->ixfr_count_oldsoa = next->oldsoa_len;
/* and then set up to copy the del and add sections */
query->ixfr_count_del = 0;
query->ixfr_count_add = 0;
total_added += ixfr_copy_rrs_into_packet(query, &pcomp);
} else {
/* we finished the IXFR */
/* sign the last packet */
query->tsig_sign_it = 1;
query->ixfr_is_done = 1;
break;
}
}
if(!query->tcp && !query->ixfr_is_done) {
TC_SET(query->packet);
if(query->ixfr_pos_of_newsoa) {
/* if we recorded the newsoa in the result, snip off
* the rest of the response, the RFC1995 response for
* when it does not fit is only the latest SOA */
buffer_set_position(query->packet, query->ixfr_pos_of_newsoa);
ANCOUNT_SET(query->packet, 1);
}
query->ixfr_is_done = 1;
}
/* put new serial SOA record after delrrs and addrrs */
ixfr_put_newsoa(ixfr_store, &ixfr_store->data->del,
&ixfr_store->data->del_len, &ixfr_store->del_capacity);
ixfr_put_newsoa(ixfr_store, &ixfr_store->data->add,
&ixfr_store->data->add_len, &ixfr_store->add_capacity);
/* trim the data in the store, the overhead from capacity is
* removed */
if(!ixfr_store->data)
return; /* data should be nonNULL, we are not cancelled */
ixfr_trim_capacity(&ixfr_store->data->del,
&ixfr_store->data->del_len, &ixfr_store->del_capacity);
ixfr_trim_capacity(&ixfr_store->data->add,
&ixfr_store->data->add_len, &ixfr_store->add_capacity);
}
/* store the data in the zone */
if(!ixfr_store->zone->ixfr)
ixfr_store->zone->ixfr = zone_ixfr_create(nsd);
zone_ixfr_make_space(ixfr_store->zone->ixfr, ixfr_store->zone,
ixfr_store->data, ixfr_store);
if(ixfr_store->cancelled) {
ixfr_store_free(ixfr_store);
return;
}
zone_ixfr_add(ixfr_store->zone->ixfr, ixfr_store->data, 1);
ixfr_store->data = NULL;
if(ixfr_store->cancelled)
return;
if(ixfr_store->data->oldsoa) {
free(ixfr_store->data->oldsoa);
ixfr_store->data->oldsoa = NULL;
ixfr_store->data->oldsoa_len = 0;
}
/* we have the old SOA and thus we are sure it is an IXFR, make space*/
zone_ixfr_make_space(ixfr_store->zone->ixfr, ixfr_store->zone,
ixfr_store->data, ixfr_store);
if(ixfr_store->cancelled)
return;
oldpos = buffer_position(packet);
/* The SOA data is stored with separate calls. And then appended
* during the finish operation. We do not have to store it here
* when called from difffile's IXFR processing with type SOA. */
if(type == TYPE_SOA)
return;
/* make space for these RRs we have now; basically once we
* grow beyond the current allowed amount an older IXFR is deleted. */
zone_ixfr_make_space(ixfr_store->zone->ixfr, ixfr_store->zone,
ixfr_store->data, ixfr_store);
if(ixfr_store->cancelled)
return;
/* Check the number of IXFRs allowed for this zone, if too many,
* shorten the number to make space for another one */
while(ixfr->data->count >= zone->opts->pattern->ixfr_number) {
zone_ixfr_remove_oldest(ixfr);
}
/* Check the size of the current added data element 'data', and
* see if that overflows the maximum storage size for IXFRs for
* this zone, and if so, delete the oldest IXFR to make space */
addsize = ixfr_data_size(data);
while(ixfr->data->count > 0 && ixfr->total_size + addsize >
zone->opts->pattern->ixfr_size) {
zone_ixfr_remove_oldest(ixfr);
}
/* if deleting the oldest elements does not work, then this
* IXFR is too big to store and we cancel it */
if(ixfr->data->count == 0 && ixfr->total_size + addsize >
zone->opts->pattern->ixfr_size) {
ixfr_store_cancel(ixfr_store);
return;
}
}
/* calculate the number of files we want */
static int ixfr_target_number_files(struct zone* zone)
{
int dest_num_files;
if(!zone->ixfr || !zone->ixfr->data)
return 0;
if(!zone_is_ixfr_enabled(zone))
return 0;
/* if we store ixfr, it is the configured number of files */
dest_num_files = (int)zone->opts->pattern->ixfr_number;
/* but if the number of available transfers is smaller, store less */
if(dest_num_files > (int)zone->ixfr->data->count)
dest_num_files = (int)zone->ixfr->data->count;
return dest_num_files;
}
/* create ixfrfile name in buffer for file_num. The num is 1 .. number. */
static void make_ixfr_name(char* buf, size_t len, const char* zfile,
int file_num)
{
if(file_num == 1)
snprintf(buf, len, "%s.ixfr", zfile);
else snprintf(buf, len, "%s.ixfr.%d", zfile, file_num);
}
/* create temp ixfrfile name in buffer for file_num. The num is 1 .. number. */
static void make_ixfr_name_temp(char* buf, size_t len, const char* zfile,
int file_num, int temp)
{
if(file_num == 1)
snprintf(buf, len, "%s.ixfr%s", zfile, (temp?".temp":""));
else snprintf(buf, len, "%s.ixfr.%d%s", zfile, file_num,
(temp?".temp":""));
}
/* see if ixfr file exists */
static int ixfr_file_exists_ctmp(const char* zfile, int file_num, int temp)
{
struct stat statbuf;
char ixfrfile[1024+24];
make_ixfr_name_temp(ixfrfile, sizeof(ixfrfile), zfile, file_num, temp);
memset(&statbuf, 0, sizeof(statbuf));
if(stat(ixfrfile, &statbuf) < 0) {
if(errno == ENOENT)
return 0;
/* file is not usable */
return 0;
}
return 1;
}
int ixfr_file_exists(const char* zfile, int file_num)
{
return ixfr_file_exists_ctmp(zfile, file_num, 0);
}
/* see if ixfr file exists */
static int ixfr_file_exists_temp(const char* zfile, int file_num)
{
return ixfr_file_exists_ctmp(zfile, file_num, 1);
}
/* unlink an ixfr file */
static int ixfr_unlink_it_ctmp(const char* zname, const char* zfile,
int file_num, int silent_enoent, int temp)
{
char ixfrfile[1024+24];
make_ixfr_name_temp(ixfrfile, sizeof(ixfrfile), zfile, file_num, temp);
VERBOSITY(3, (LOG_INFO, "delete zone %s IXFR data file %s",
zname, ixfrfile));
if(unlink(ixfrfile) < 0) {
if(silent_enoent && errno == ENOENT)
return 0;
log_msg(LOG_ERR, "error to delete file %s: %s", ixfrfile,
strerror(errno));
return 0;
}
return 1;
}
int ixfr_unlink_it(const char* zname, const char* zfile, int file_num,
int silent_enoent)
{
return ixfr_unlink_it_ctmp(zname, zfile, file_num, silent_enoent, 0);
}
/* unlink an ixfr file */
static int ixfr_unlink_it_temp(const char* zname, const char* zfile,
int file_num, int silent_enoent)
{
return ixfr_unlink_it_ctmp(zname, zfile, file_num, silent_enoent, 1);
}
/* delete rest ixfr files, that are after the current item */
static void ixfr_delete_rest_files(struct zone* zone, struct ixfr_data* from,
const char* zfile, int temp)
{
size_t prevcount = 0;
struct ixfr_data* data = from;
while(data) {
if(data->file_num != 0) {
(void)ixfr_unlink_it_ctmp(zone->opts->name, zfile,
data->file_num, 0, temp);
data->file_num = 0;
}
data = ixfr_data_prev(zone->ixfr, data, &prevcount);
}
}
void ixfr_delete_superfluous_files(struct zone* zone, const char* zfile,
int dest_num_files)
{
int i = dest_num_files + 1;
if(!ixfr_file_exists(zfile, i))
return;
while(ixfr_unlink_it(zone->opts->name, zfile, i, 1)) {
i++;
}
}
int ixfr_rename_it(const char* zname, const char* zfile, int oldnum,
int oldtemp, int newnum, int newtemp)
{
char ixfrfile_old[1024+24];
char ixfrfile_new[1024+24];
make_ixfr_name_temp(ixfrfile_old, sizeof(ixfrfile_old), zfile, oldnum,
oldtemp);
make_ixfr_name_temp(ixfrfile_new, sizeof(ixfrfile_new), zfile, newnum,
newtemp);
VERBOSITY(3, (LOG_INFO, "rename zone %s IXFR data file %s to %s",
zname, ixfrfile_old, ixfrfile_new));
if(rename(ixfrfile_old, ixfrfile_new) < 0) {
log_msg(LOG_ERR, "error to rename file %s: %s", ixfrfile_old,
strerror(errno));
return 0;
}
return 1;
}
/* delete if we have too many items in memory */
static void ixfr_delete_memory_items(struct zone* zone, int dest_num_files)
{
if(!zone->ixfr || !zone->ixfr->data)
return;
if(dest_num_files == (int)zone->ixfr->data->count)
return;
if(dest_num_files > (int)zone->ixfr->data->count) {
/* impossible, dest_num_files should be smaller */
return;
}
/* delete oldest ixfr, until we have dest_num_files entries */
while(dest_num_files < (int)zone->ixfr->data->count) {
zone_ixfr_remove_oldest(zone->ixfr);
}
}
/* rename the ixfr files that need to change name */
static int ixfr_rename_files(struct zone* zone, const char* zfile,
int dest_num_files)
{
struct ixfr_data* data, *startspot = NULL;
size_t prevcount = 0;
int destnum;
if(!zone->ixfr || !zone->ixfr->data)
return 1;
/* the oldest file is at the largest number */
data = ixfr_data_first(zone->ixfr);
destnum = dest_num_files;
if(!data)
return 1; /* nothing to do */
if(data->file_num == destnum)
return 1; /* nothing to do for rename */
/* rename the files to temporary files, because otherwise the
* items would overwrite each other when the list touches itself.
* On fail, the temporary files are removed and we end up with
* the newly written data plus the remaining files, in order.
* Thus, start the temporary rename at the oldest, then rename
* to the final names starting from the newest. */
while(data && data->file_num != 0) {
/* if existing file at temporary name, delete that */
if(ixfr_file_exists_temp(zfile, data->file_num)) {
(void)ixfr_unlink_it_temp(zone->opts->name, zfile,
data->file_num, 0);
}
/* rename to temporary name */
if(!ixfr_rename_it(zone->opts->name, zfile, data->file_num, 0,
data->file_num, 1)) {
/* failure, we cannot store files */
/* delete the renamed files */
ixfr_delete_rest_files(zone, data, zfile, 1);
return 0;
}
/* the next cycle should start at the newest file that
* has been renamed to a temporary name */
startspot = data;
data = ixfr_data_next(zone->ixfr, data);
destnum--;
}
/* rename the files to their final name position */
data = startspot;
while(data && data->file_num != 0) {
destnum++;
/* if there is an existing file, delete it */
if(ixfr_file_exists(zfile, destnum)) {
(void)ixfr_unlink_it(zone->opts->name, zfile,
destnum, 0);
}
if(!ixfr_rename_it(zone->opts->name, zfile, data->file_num, 1, destnum, 0)) {
/* failure, we cannot store files */
ixfr_delete_rest_files(zone, data, zfile, 1);
/* delete the previously renamed files, so in
* memory stays as is, on disk we have the current
* item (and newer transfers) okay. */
return 0;
}
data->file_num = destnum;
data = ixfr_data_prev(zone->ixfr, data, &prevcount);
}
return 1;
}
/* write the ixfr files that need to be stored on disk */
static void ixfr_write_files(struct zone* zone, const char* zfile)
{
size_t prevcount = 0;
int num;
struct ixfr_data* data;
if(!zone->ixfr || !zone->ixfr->data)
return; /* nothing to write */
/* write unwritten files to disk */
data = ixfr_data_last(zone->ixfr);
num=1;
while(data && data->file_num == 0) {
if(!ixfr_write_file(zone, data, zfile, num)) {
/* There could be more files that are sitting on the
* disk, remove them, they are not used without
* this ixfr file.
*
* Give this element a file num, so it can be
* deleted, it failed to write. It may be partial,
* and we do not want to read that back in.
* We are left with the newer transfers, that form
* a correct list of transfers, that are wholly
* written. */
data->file_num = num;
ixfr_delete_rest_files(zone, data, zfile, 0);
return;
}
num++;
data = ixfr_data_prev(zone->ixfr, data, &prevcount);
}
}
void ixfr_write_to_file(struct zone* zone, const char* zfile)
{
int dest_num_files = 0;
/* we just wrote the zonefile zfile, and it is time to write
* the IXFR contents to the disk too. */
/* find out what the target number of files is that we want on
* the disk */
dest_num_files = ixfr_target_number_files(zone);
/* delete if we have more than we need */
ixfr_delete_superfluous_files(zone, zfile, dest_num_files);
/* delete if we have too much in memory */
ixfr_delete_memory_items(zone, dest_num_files);
/* rename the transfers that we have that already have a file */
if(!ixfr_rename_files(zone, zfile, dest_num_files))
return;
/* write the transfers that are not written yet */
ixfr_write_files(zone, zfile);
}
/* can we delete temp domain */
static int can_del_temp_domain(struct domain* domain)
{
struct domain* n;
/* we want to keep the zone apex */
if(domain->is_apex)
return 0;
if(domain->rrsets)
return 0;
if(domain->usage)
return 0;
/* check if there are domains under it */
n = domain_next(domain);
if(n && domain_is_subdomain(n, domain))
return 0;
return 1;
}
/* delete temporary domain */
static void ixfr_temp_deldomain(struct domain_table* temptable,
struct domain* domain)
{
struct domain* p;
if(!can_del_temp_domain(domain))
return;
p = domain->parent;
/* see if this domain is someones wildcard-child-closest-match,
* which can only be the parent, and then it should use the
* one-smaller than this domain as closest-match. */
if(domain->parent &&
domain->parent->wildcard_child_closest_match == domain)
domain->parent->wildcard_child_closest_match =
domain_previous_existing_child(domain);
domain_table_delete(temptable, domain);
while(p) {
struct domain* up = p->parent;
if(!can_del_temp_domain(p))
break;
if(p->parent && p->parent->wildcard_child_closest_match == p)
p->parent->wildcard_child_closest_match =
domain_previous_existing_child(p);
domain_table_delete(temptable, p);
p = up;
}
}
/* clear out the just read RR from the temp table */
static void clear_temp_table_of_rr(struct domain_table* temptable,
struct zone* tempzone, struct rr* rr)
{
#if 0 /* clear out by removing everything, alternate for the cleanout code */
/* clear domains from the tempzone,
* the only domain left is the zone apex and its parents */
domain_type* domain;
#ifdef USE_RADIX_TREE
struct radnode* first = radix_first(temptable->nametree);
domain = first?(domain_type*)first->elem:NULL;
#else
domain = (domain_type*)rbtree_first(temptable->names_to_domains);
#endif
while(domain != (domain_type*)RBTREE_NULL && domain) {
domain_type* next = domain_next(domain);
if(domain != tempzone->apex &&
!domain_is_subdomain(tempzone->apex, domain)) {
domain_table_delete(temptable, domain);
} else {
if(!domain->parent /* is the root */ ||
domain == tempzone->apex)
domain->usage = 1;
else domain->usage = 0;
}
domain = next;
}
/* read ixfr data new SOA */
static int ixfr_data_readnewsoa(struct ixfr_data* data, struct zone* zone,
FILE* in, const char* ixfrfile, struct region* tempregion,
struct domain_table* temptable, struct zone* tempzone,
uint32_t dest_serial)
{
struct rr* rr;
size_t capacity = 0;
if(!ixfr_data_readrr(zone, in, ixfrfile, tempregion, temptable,
tempzone, &rr))
return 0;
if(rr->type != TYPE_SOA) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data does not start with SOA",
zone->opts->name, ixfrfile);
return 0;
}
if(rr->klass != CLASS_IN) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data is not class IN",
zone->opts->name, ixfrfile);
return 0;
}
if(!zone->apex) {
log_msg(LOG_ERR, "zone %s ixfr data %s: zone has no apex, no zone data",
zone->opts->name, ixfrfile);
return 0;
}
if(dname_compare(domain_dname(zone->apex), domain_dname(rr->owner)) != 0) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data wrong SOA for zone %s",
zone->opts->name, ixfrfile, domain_to_string(rr->owner));
return 0;
}
data->newserial = soa_rr_get_serial(rr);
if(data->newserial != dest_serial) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data contains the wrong version, serial %u but want destination serial %u",
zone->opts->name, ixfrfile, data->newserial,
dest_serial);
return 0;
}
if(!ixfr_putrr(domain_dname(rr->owner), rr->type, rr->klass, rr->ttl, rr->rdatas, rr->rdata_count, &data->newsoa, &data->newsoa_len, &capacity)) {
log_msg(LOG_ERR, "zone %s ixfr data %s: cannot allocate space",
zone->opts->name, ixfrfile);
return 0;
}
clear_temp_table_of_rr(temptable, tempzone, rr);
region_free_all(tempregion);
ixfr_trim_capacity(&data->newsoa, &data->newsoa_len, &capacity);
return 1;
}
/* read ixfr data old SOA */
static int ixfr_data_readoldsoa(struct ixfr_data* data, struct zone* zone,
FILE* in, const char* ixfrfile, struct region* tempregion,
struct domain_table* temptable, struct zone* tempzone,
uint32_t* dest_serial)
{
struct rr* rr;
size_t capacity = 0;
if(!ixfr_data_readrr(zone, in, ixfrfile, tempregion, temptable,
tempzone, &rr))
return 0;
if(rr->type != TYPE_SOA) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data 2nd RR is not SOA",
zone->opts->name, ixfrfile);
return 0;
}
if(rr->klass != CLASS_IN) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data 2ndSOA is not class IN",
zone->opts->name, ixfrfile);
return 0;
}
if(!zone->apex) {
log_msg(LOG_ERR, "zone %s ixfr data %s: zone has no apex, no zone data",
zone->opts->name, ixfrfile);
return 0;
}
if(dname_compare(domain_dname(zone->apex), domain_dname(rr->owner)) != 0) {
log_msg(LOG_ERR, "zone %s ixfr data %s: IXFR data wrong 2nd SOA for zone %s",
zone->opts->name, ixfrfile, domain_to_string(rr->owner));
return 0;
}
data->oldserial = soa_rr_get_serial(rr);
if(!ixfr_putrr(domain_dname(rr->owner), rr->type, rr->klass, rr->ttl, rr->rdatas, rr->rdata_count, &data->oldsoa, &data->oldsoa_len, &capacity)) {
log_msg(LOG_ERR, "zone %s ixfr data %s: cannot allocate space",
zone->opts->name, ixfrfile);
return 0;
}
clear_temp_table_of_rr(temptable, tempzone, rr);
region_free_all(tempregion);
ixfr_trim_capacity(&data->oldsoa, &data->oldsoa_len, &capacity);
*dest_serial = data->oldserial;
return 1;
}
/* read ixfr data del section */
static int ixfr_data_readdel(struct ixfr_data* data, struct zone* zone,
FILE* in, const char* ixfrfile, struct region* tempregion,
struct domain_table* temptable, struct zone* tempzone)
{
struct rr* rr;
size_t capacity = 0;
while(1) {
if(!ixfr_data_readrr(zone, in, ixfrfile, tempregion, temptable,
tempzone, &rr))
return 0;
if(!ixfr_putrr(domain_dname(rr->owner), rr->type, rr->klass, rr->ttl, rr->rdatas, rr->rdata_count, &data->del, &data->del_len, &capacity)) {
log_msg(LOG_ERR, "zone %s ixfr data %s: cannot allocate space",
zone->opts->name, ixfrfile);
return 0;
}
/* check SOA and also serial, because there could be other
* add and del sections from older versions collated, we can
* see this del section end when it has the serial */
if(rr->type == TYPE_SOA &&
soa_rr_get_serial(rr) == data->newserial) {
/* end of del section. */
clear_temp_table_of_rr(temptable, tempzone, rr);
region_free_all(tempregion);
break;
}
clear_temp_table_of_rr(temptable, tempzone, rr);
region_free_all(tempregion);
}
ixfr_trim_capacity(&data->del, &data->del_len, &capacity);
return 1;
}
/* read ixfr data from file */
static int ixfr_data_read(struct nsd* nsd, struct zone* zone, FILE* in,
const char* ixfrfile, uint32_t* dest_serial, int file_num)
{
struct ixfr_data* data = NULL;
struct region* tempregion, *stayregion;
struct domain_table* temptable;
struct zone* tempzone;
if(zone->ixfr &&
zone->ixfr->data->count == zone->opts->pattern->ixfr_number) {
VERBOSITY(3, (LOG_INFO, "zone %s skip %s IXFR data because only %d ixfr-number configured",
zone->opts->name, ixfrfile, (int)zone->opts->pattern->ixfr_number));
return 0;
}
/* the file has header comments, new soa, old soa, delsection,
* addsection. The delsection and addsection end in a SOA of oldver
* and newver respectively. */
data = xalloc_zero(sizeof(*data));
data->file_num = file_num;
/* the temp region is cleared after every RR */
tempregion = region_create(xalloc, free);
/* the stay region holds the temporary data that stays between RRs */
stayregion = region_create(xalloc, free);
temptable = domain_table_create(stayregion);
tempzone = region_alloc_zero(stayregion, sizeof(zone_type));
if(!zone->apex) {
ixfr_data_free(data);
region_destroy(tempregion);
region_destroy(stayregion);
return 0;
}
tempzone->apex = domain_table_insert(temptable,
domain_dname(zone->apex));
temptable->root->usage++;
tempzone->apex->usage++;
tempzone->opts = zone->opts;
/* switch to per RR region for new allocations in temp domain table */
temptable->region = tempregion;
if(!zone->ixfr)
zone->ixfr = zone_ixfr_create(nsd);
if(zone->opts->pattern->ixfr_size != 0 &&
zone->ixfr->total_size + ixfr_data_size(data) >
zone->opts->pattern->ixfr_size) {
VERBOSITY(3, (LOG_INFO, "zone %s skip %s IXFR data because only ixfr-size: %u configured, and it is %u size",
zone->opts->name, ixfrfile, (unsigned)zone->opts->pattern->ixfr_size, (unsigned)ixfr_data_size(data)));
ixfr_data_free(data);
return 0;
}
zone_ixfr_add(zone->ixfr, data, 0);
VERBOSITY(3, (LOG_INFO, "zone %s read %s IXFR data of %u bytes",
zone->opts->name, ixfrfile, (unsigned)ixfr_data_size(data)));
return 1;
}
/* try to read the next ixfr file. returns false if it fails or if it
* does not fit in the configured sizes */
static int ixfr_read_one_more_file(struct nsd* nsd, struct zone* zone,
const char* zfile, int num_files, uint32_t *dest_serial)
{
char ixfrfile[1024+24];
FILE* in;
int file_num = num_files+1;
make_ixfr_name(ixfrfile, sizeof(ixfrfile), zfile, file_num);
in = fopen(ixfrfile, "r");
if(!in) {
if(errno == ENOENT) {
/* the file does not exist, we reached the end
* of the list of IXFR files */
return 0;
}
log_msg(LOG_ERR, "could not read zone %s IXFR file %s: %s",
zone->opts->name, ixfrfile, strerror(errno));
return 0;
}
warn_if_directory("IXFR data", in, ixfrfile);
if(!ixfr_data_read(nsd, zone, in, ixfrfile, dest_serial, file_num)) {
fclose(in);
return 0;
}
fclose(in);
return 1;
}
void ixfr_read_from_file(struct nsd* nsd, struct zone* zone, const char* zfile)
{
uint32_t serial;
int num_files = 0;
/* delete the existing data, the zone data in memory has likely
* changed, eg. due to reading a new zonefile. So that needs new
* IXFRs */
zone_ixfr_clear(zone->ixfr);
/* track the serial number that we need to end up with, and check
* that the IXFRs match up and result in the required version */
serial = zone_get_current_serial(zone);
