Return to ixfrcreate.c CVS log

Up to [local] / src / usr.sbin / nsd

update to nsd 4.8.0
OK sthen

/*
 * ixfrcreate.c -- generating IXFR differences from zone files.
 *
 * Copyright (c) 2021, NLnet Labs. All rights reserved.
 *
 * See LICENSE for the license.
 *
 */

#include "config.h"
#include <stdio.h>
#include <errno.h>
#include <unistd.h>
#include "ixfrcreate.h"
#include "namedb.h"
#include "ixfr.h"
#include "options.h"

/* spool a uint16_t to file */
static int spool_u16(FILE* out, uint16_t val)
{
	if(!fwrite(&val, sizeof(val), 1, out)) {
		return 0;
	}
	return 1;
}

/* spool a uint32_t to file */
static int spool_u32(FILE* out, uint32_t val)
{
	if(!fwrite(&val, sizeof(val), 1, out)) {
		return 0;
	}
	return 1;
}

/* spool dname to file */
static int spool_dname(FILE* out, dname_type* dname)
{
	uint16_t namelen = dname->name_size;
	if(!fwrite(&namelen, sizeof(namelen), 1, out)) {
		return 0;
	}
	if(!fwrite(dname_name(dname), namelen, 1, out)) {
		return 0;
	}
	return 1;
}

/* calculate the rdatalen of an RR */
static size_t rr_rdatalen_uncompressed(rr_type* rr)
{
	int i;
	size_t rdlen_uncompressed = 0;
	for(i=0; i<rr->rdata_count; i++) {
		if(rdata_atom_is_domain(rr->type, i)) {
			rdlen_uncompressed += domain_dname(rr->rdatas[i].domain)
				->name_size;
		} else {
			rdlen_uncompressed += rr->rdatas[i].data[0];
		}
	}
	return rdlen_uncompressed;
}

/* spool the data for one rr into the file */
static int spool_rr_data(FILE* out, rr_type* rr)
{
	int i;
	uint16_t rdlen;
	if(!spool_u32(out, rr->ttl))
		return 0;
	rdlen = rr_rdatalen_uncompressed(rr);
	if(!spool_u16(out, rdlen))
		return 0;
	for(i=0; i<rr->rdata_count; i++) {
		if(rdata_atom_is_domain(rr->type, i)) {
			if(!fwrite(dname_name(domain_dname(
				rr->rdatas[i].domain)), domain_dname(
				rr->rdatas[i].domain)->name_size, 1, out))
				return 0;
		} else {
			if(!fwrite(&rr->rdatas[i].data[1],
				rr->rdatas[i].data[0], 1, out))
				return 0;
		}
	}
	return 1;
}

/* spool one rrset to file */
static int spool_rrset(FILE* out, rrset_type* rrset)
{
	int i;
	if(rrset->rr_count == 0)
		return 1;
	if(!spool_u16(out, rrset->rrs[0].type))
		return 0;
	if(!spool_u16(out, rrset->rrs[0].klass))
		return 0;
	if(!spool_u16(out, rrset->rr_count))
		return 0;
	for(i=0; i<rrset->rr_count; i++) {
		if(!spool_rr_data(out, &rrset->rrs[i]))
			return 0;
	}
	return 1;
}

/* spool rrsets to file */
static int spool_rrsets(FILE* out, rrset_type* rrsets, struct zone* zone)
{
	rrset_type* s;
	for(s=rrsets; s; s=s->next) {
		if(s->zone != zone)
			continue;
		if(!spool_rrset(out, s)) {
			return 0;
		}
	}
	return 1;
}

/* count number of rrsets for a domain */
static size_t domain_count_rrsets(domain_type* domain, zone_type* zone)
{
	rrset_type* s;
	size_t count = 0;
	for(s=domain->rrsets; s; s=s->next) {
		if(s->zone == zone)
			count++;
	}
	return count;
}

/* spool the domain names to file, each one in turn. end with enddelimiter */
static int spool_domains(FILE* out, struct zone* zone)
{
	domain_type* domain;
	for(domain = zone->apex; domain && domain_is_subdomain(domain,
		zone->apex); domain = domain_next(domain)) {
		uint32_t count = domain_count_rrsets(domain, zone);
		if(count == 0)
			continue;
		/* write the name */
		if(!spool_dname(out, domain_dname(domain)))
			return 0;
		if(!spool_u32(out, count))
			return 0;
		/* write the rrsets */
		if(!spool_rrsets(out, domain->rrsets, zone))
			return 0;
	}
	/* the end delimiter is a 0 length. domain names are not zero length */
	if(!spool_u16(out, 0))
		return 0;
	return 1;
}

/* spool the namedb zone to the file. print error on failure. */
static int spool_zone_to_file(struct zone* zone, char* file_name,
	uint32_t serial)
{
	FILE* out;
	out = fopen(file_name, "w");
	if(!out) {
		log_msg(LOG_ERR, "could not open %s for writing: %s",
			file_name, strerror(errno));
		return 0;
	}
	if(!spool_dname(out, domain_dname(zone->apex))) {
		log_msg(LOG_ERR, "could not write %s: %s",
			file_name, strerror(errno));
		fclose(out);
		return 0;
	}
	if(!spool_u32(out, serial)) {
		log_msg(LOG_ERR, "could not write %s: %s",
			file_name, strerror(errno));
		fclose(out);
		return 0;
	}
	if(!spool_domains(out, zone)) {
		log_msg(LOG_ERR, "could not write %s: %s",
			file_name, strerror(errno));
		fclose(out);
		return 0;
	}
	fclose(out);
	return 1;
}

/* create ixfr spool file name */
static int create_ixfr_spool_name(struct ixfr_create* ixfrcr,
	const char* zfile)
{
	char buf[1024];
	snprintf(buf, sizeof(buf), "%s.spoolzone.%u", zfile,
		(unsigned)getpid());
	ixfrcr->file_name = strdup(buf);
	if(!ixfrcr->file_name)
		return 0;
	return 1;
}

/* start ixfr creation */
struct ixfr_create* ixfr_create_start(struct zone* zone, const char* zfile,
	uint64_t ixfr_size, int errorcmdline)
{
	struct ixfr_create* ixfrcr = (struct ixfr_create*)calloc(1,
		sizeof(*ixfrcr));
	if(!ixfrcr) {
		log_msg(LOG_ERR, "malloc failure");
		return NULL;
	}
	ixfrcr->zone_name_len = domain_dname(zone->apex)->name_size;
	ixfrcr->zone_name = (uint8_t*)malloc(ixfrcr->zone_name_len);
	if(!ixfrcr->zone_name) {
		free(ixfrcr);
		log_msg(LOG_ERR, "malloc failure");
		return NULL;
	}
	memmove(ixfrcr->zone_name, dname_name(domain_dname(zone->apex)),
		ixfrcr->zone_name_len);

	if(!create_ixfr_spool_name(ixfrcr, zfile)) {
		ixfr_create_free(ixfrcr);
		log_msg(LOG_ERR, "malloc failure");
		return NULL;
	}
	ixfrcr->old_serial = zone_get_current_serial(zone);
	if(!spool_zone_to_file(zone, ixfrcr->file_name, ixfrcr->old_serial)) {
		ixfr_create_free(ixfrcr);
		return NULL;
	}
	if(zone->opts && zone->opts->pattern)
		ixfrcr->max_size = (size_t)zone->opts->pattern->ixfr_size;
	else	ixfrcr->max_size = (size_t)ixfr_size;
	ixfrcr->errorcmdline = errorcmdline;
	return ixfrcr;
}

/* free ixfr create */
void ixfr_create_free(struct ixfr_create* ixfrcr)
{
	if(!ixfrcr)
		return;
	free(ixfrcr->file_name);
	free(ixfrcr->zone_name);
	free(ixfrcr);
}

/* read uint16_t from spool */
static int read_spool_u16(FILE* spool, uint16_t* val)
{
	if(fread(val, sizeof(*val), 1, spool) < 1)
		return 0;
	return 1;
}

/* read uint32_t from spool */
static int read_spool_u32(FILE* spool, uint32_t* val)
{
	if(fread(val, sizeof(*val), 1, spool) < 1)
		return 0;
	return 1;
}

/* read dname from spool */
static int read_spool_dname(FILE* spool, uint8_t* buf, size_t buflen,
	size_t* dname_len)
{
	uint16_t len;
	if(fread(&len, sizeof(len), 1, spool) < 1)
		return 0;
	if(len > buflen) {
		log_msg(LOG_ERR, "dname too long");
		return 0;
	}
	if(len > 0) {
		if(fread(buf, len, 1, spool) < 1)
			return 0;
	}
	*dname_len = len;
	return 1;
}

/* read and check the spool file header */
static int read_spool_header(FILE* spool, struct ixfr_create* ixfrcr)
{
	uint8_t dname[MAXDOMAINLEN+1];
	size_t dname_len;
	uint32_t serial;
	/* read apex */
	if(!read_spool_dname(spool, dname, sizeof(dname), &dname_len)) {
		log_msg(LOG_ERR, "error reading file %s: %s",
			ixfrcr->file_name, strerror(errno));
		return 0;
	}
	/* read serial */
	if(!read_spool_u32(spool, &serial)) {
		log_msg(LOG_ERR, "error reading file %s: %s",
			ixfrcr->file_name, strerror(errno));
		return 0;
	}

	/* check */
	if(ixfrcr->zone_name_len != dname_len ||
		memcmp(ixfrcr->zone_name, dname, ixfrcr->zone_name_len) != 0) {
		log_msg(LOG_ERR, "error file %s does not contain the correct zone apex",
			ixfrcr->file_name);
		return 0;
	}
	if(ixfrcr->old_serial != serial) {
		log_msg(LOG_ERR, "error file %s does not contain the correct zone serial",
			ixfrcr->file_name);
		return 0;
	}
	return 1;
}

/* store the old soa record when we encounter it on the spool */
static int process_store_oldsoa(struct ixfr_store* store, uint8_t* dname,
	size_t dname_len, uint16_t tp, uint16_t kl, uint32_t ttl, uint8_t* buf,
	uint16_t rdlen)
{
	if(store->data->oldsoa) {
		log_msg(LOG_ERR, "error spool contains multiple SOA records");
		return 0;
	}
	if(!ixfr_store_oldsoa_uncompressed(store, dname, dname_len, tp, kl,
		ttl, buf, rdlen)) {
		log_msg(LOG_ERR, "out of memory");
		return 0;
	}
	return 1;
}

/* see if rdata matches, true if equal */
static int rdata_match(struct rr* rr, uint8_t* rdata, uint16_t rdlen)
{
	size_t rdpos = 0;
	int i;
	for(i=0; i<rr->rdata_count; i++) {
		if(rdata_atom_is_domain(rr->type, i)) {
			if(rdpos + domain_dname(rr->rdatas[i].domain)->name_size
				> rdlen)
				return 0;
			if(memcmp(rdata+rdpos,
				dname_name(domain_dname(rr->rdatas[i].domain)),
				domain_dname(rr->rdatas[i].domain)->name_size)
				!= 0)
				return 0;
			rdpos += domain_dname(rr->rdatas[i].domain)->name_size;
		} else {
			if(rdpos + rr->rdatas[i].data[0] > rdlen)
				return 0;
			if(memcmp(rdata+rdpos, &rr->rdatas[i].data[1],
				rr->rdatas[i].data[0]) != 0)
				return 0;
			rdpos += rr->rdatas[i].data[0];
		}
	}
	if(rdpos != rdlen)
		return 0;
	return 1;
}

/* find an rdata in an rrset, true if found and sets index found */
static int rrset_find_rdata(struct rrset* rrset, uint32_t ttl, uint8_t* rdata,
	uint16_t rdlen, uint16_t* index)
{
	int i;
	for(i=0; i<rrset->rr_count; i++) {
		if(rrset->rrs[i].ttl != ttl)
			continue;
		if(rdata_match(&rrset->rrs[i], rdata, rdlen)) {
			*index = i;
			return 1;
		}
	}
	return 0;
}

/* sort comparison for uint16 elements */
static int sort_uint16(const void* x, const void* y)
{
	const uint16_t* ax = (const uint16_t*)x;
	const uint16_t* ay = (const uint16_t*)y;
	if(*ax < *ay)
		return -1;
	if(*ax > *ay)
		return 1;
	return 0;
}

/* spool read an rrset, it is a deleted RRset */
static int process_diff_rrset(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct domain* domain,
	uint16_t tp, uint16_t kl, uint16_t rrcount, struct rrset* rrset)
{
	/* read RRs from file and see if they are added, deleted or in both */
	uint8_t buf[MAX_RDLENGTH];
	uint16_t marked[65536];
	size_t marked_num = 0, atmarked;
	int i;
	for(i=0; i<rrcount; i++) {
		uint16_t rdlen, index;
		uint32_t ttl;
		if(!read_spool_u32(spool, &ttl) ||
		   !read_spool_u16(spool, &rdlen)) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		/* because rdlen is uint16_t always smaller than sizeof(buf)*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
		assert(rdlen <= sizeof(buf));
#pragma GCC diagnostic pop
		if(fread(buf, rdlen, 1, spool) < 1) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		if(tp == TYPE_SOA) {
			if(!process_store_oldsoa(store,
				(void*)dname_name(domain_dname(domain)),
				domain_dname(domain)->name_size, tp, kl, ttl,
				buf, rdlen))
				return 0;
		}
		/* see if the rr is in the RRset */
		if(rrset_find_rdata(rrset, ttl, buf, rdlen, &index)) {
			/* it is in both, mark it */
			marked[marked_num++] = index;
		} else {
			/* not in new rrset, but only on spool, it is
			 * a deleted RR */
			if(!ixfr_store_delrr_uncompressed(store,
				(void*)dname_name(domain_dname(domain)),
				domain_dname(domain)->name_size,
				tp, kl, ttl, buf, rdlen)) {
				log_msg(LOG_ERR, "out of memory");
				return 0;
			}
		}
	}
	/* now that we are done, see if RRs in the rrset are not marked,
	 * and thus are new rrs that are added */
	qsort(marked, marked_num, sizeof(marked[0]), &sort_uint16);
	atmarked = 0;
	for(i=0; i<rrset->rr_count; i++) {
		if(atmarked < marked_num && marked[atmarked] == i) {
			/* the item is in the marked list, skip it */
			atmarked++;
			continue;
		}
		/* not in the marked list, the RR is added */
		if(!ixfr_store_addrr_rdatas(store, domain_dname(domain),
			rrset->rrs[i].type, rrset->rrs[i].klass,
			rrset->rrs[i].ttl, rrset->rrs[i].rdatas,
			rrset->rrs[i].rdata_count)) {
			log_msg(LOG_ERR, "out of memory");
			return 0;
		}
	}
	return 1;
}

/* spool read an rrset, it is a deleted RRset */
static int process_spool_delrrset(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, uint8_t* dname, size_t dname_len,
	uint16_t tp, uint16_t kl, uint16_t rrcount)
{
	/* read the RRs from file and add to del list. */
	uint8_t buf[MAX_RDLENGTH];
	int i;
	for(i=0; i<rrcount; i++) {
		uint16_t rdlen;
		uint32_t ttl;
		if(!read_spool_u32(spool, &ttl) ||
		   !read_spool_u16(spool, &rdlen)) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		/* because rdlen is uint16_t always smaller than sizeof(buf)*/
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wtype-limits"
		assert(rdlen <= sizeof(buf));
#pragma GCC diagnostic pop
		if(fread(buf, rdlen, 1, spool) < 1) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		if(tp == TYPE_SOA) {
			if(!process_store_oldsoa(store, dname, dname_len,
				tp, kl, ttl, buf, rdlen))
				return 0;
		}
		if(!ixfr_store_delrr_uncompressed(store, dname, dname_len, tp,
			kl, ttl, buf, rdlen)) {
			log_msg(LOG_ERR, "out of memory");
			return 0;
		}
	}
	return 1;
}

/* add the rrset to the added list */
static int process_add_rrset(struct ixfr_store* ixfr_store,
	struct domain* domain, struct rrset* rrset)
{
	int i;
	for(i=0; i<rrset->rr_count; i++) {
		if(!ixfr_store_addrr_rdatas(ixfr_store, domain_dname(domain),
			rrset->rrs[i].type, rrset->rrs[i].klass,
			rrset->rrs[i].ttl, rrset->rrs[i].rdatas,
			rrset->rrs[i].rdata_count)) {
			log_msg(LOG_ERR, "out of memory");
			return 0;
		}
	}
	return 1;
}

/* add the RR types that are not in the marktypes list from the new zone */
static int process_marktypes(struct ixfr_store* store, struct zone* zone,
	struct domain* domain, uint16_t* marktypes, size_t marktypes_used)
{
	/* walk through the rrsets in the zone, if it is not in the
	 * marktypes list, then it is new and an added RRset */
	rrset_type* s;
	qsort(marktypes, marktypes_used, sizeof(marktypes[0]), &sort_uint16);
	for(s=domain->rrsets; s; s=s->next) {
		uint16_t tp;
		if(s->zone != zone)
			continue;
		tp = rrset_rrtype(s);
		if(bsearch(&tp, marktypes, marktypes_used, sizeof(marktypes[0]), &sort_uint16)) {
			/* the item is in the marked list, skip it */
			continue;
		}
		if(!process_add_rrset(store, domain, s))
			return 0;
	}
	return 1;
}

/* check the difference between the domain and RRs from spool */
static int process_diff_domain(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct zone* zone, struct domain* domain)
{
	/* Read the RR types from spool. Mark off the ones seen,
	 * later, the notseen ones from the new zone are added RRsets.
	 * For the ones not in the new zone, they are deleted RRsets.
	 * If they exist in old and new, check for RR differences. */
	uint32_t spool_type_count, i; 
	uint16_t marktypes[65536];
	size_t marktypes_used = 0;
	if(!read_spool_u32(spool, &spool_type_count)) {
		log_msg(LOG_ERR, "error reading file %s: %s",
			ixfrcr->file_name, strerror(errno));
		return 0;
	}
	if(spool_type_count > sizeof(marktypes)) {
		log_msg(LOG_ERR, "error reading file %s: spool type count "
			"too large", ixfrcr->file_name);
		return 0;
	}
	for(i=0; i<spool_type_count; i++) {
		uint16_t tp, kl, rrcount;
		struct rrset* rrset;
		if(!read_spool_u16(spool, &tp) ||
		   !read_spool_u16(spool, &kl) ||
		   !read_spool_u16(spool, &rrcount)) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		/* The rrcount is within limits of sizeof(marktypes), because
		 * the uint16_t < 65536 */
		rrset = domain_find_rrset(domain, zone, tp);
		if(!rrset) {
			/* rrset in spool but not in new zone, deleted RRset */
			if(!process_spool_delrrset(spool, ixfrcr, store,
				(void*)dname_name(domain_dname(domain)),
				domain_dname(domain)->name_size, tp, kl,
				rrcount))
				return 0;
		} else {
			/* add to the marked types, this one is present in
			 * spool */
			marktypes[marktypes_used++] = tp;
			/* rrset in old and in new zone, diff the RRset */
			if(!process_diff_rrset(spool, ixfrcr, store, domain,
				tp, kl, rrcount, rrset))
				return 0;
		}
	}
	/* process markoff to see if new zone has RRsets not in spool,
	 * those are added RRsets. */
	if(!process_marktypes(store, zone, domain, marktypes, marktypes_used))
		return 0;
	return 1;
}

/* add the RRs for the domain in new zone */
static int process_domain_add_RRs(struct ixfr_store* store, struct zone* zone,
	struct domain* domain)
{
	rrset_type* s;
	for(s=domain->rrsets; s; s=s->next) {
		if(s->zone != zone)
			continue;
		if(!process_add_rrset(store, domain, s))
			return 0;
	}
	return 1;
}

/* del the RRs for the domain from the spool */
static int process_domain_del_RRs(struct ixfr_create* ixfrcr,
	struct ixfr_store* store, FILE* spool, uint8_t* dname,
	size_t dname_len)
{
	uint32_t spool_type_count, i;
	if(!read_spool_u32(spool, &spool_type_count)) {
		log_msg(LOG_ERR, "error reading file %s: %s",
			ixfrcr->file_name, strerror(errno));
		return 0;
	}
	if(spool_type_count > 65536) {
		log_msg(LOG_ERR, "error reading file %s: del RR spool type "
			"count too large", ixfrcr->file_name);
		return 0;
	}
	for(i=0; i<spool_type_count; i++) {
		uint16_t tp, kl, rrcount;
		if(!read_spool_u16(spool, &tp) ||
		   !read_spool_u16(spool, &kl) ||
		   !read_spool_u16(spool, &rrcount)) {
			log_msg(LOG_ERR, "error reading file %s: %s",
				ixfrcr->file_name, strerror(errno));
			return 0;
		}
		/* The rrcount is within reasonable limits, because
		 * the uint16_t < 65536 */
		if(!process_spool_delrrset(spool, ixfrcr, store, dname,
			dname_len, tp, kl, rrcount))
			return 0;
	}
	return 1;
}

/* init the spool dname iterator */
static void spool_dname_iter_init(struct spool_dname_iterator* iter,
	FILE* spool, char* file_name)
{
	memset(iter, 0, sizeof(*iter));
	iter->spool = spool;
	iter->file_name = file_name;
}

/* read the dname element into the buffer for the spool dname iterator */
static int spool_dname_iter_read(struct spool_dname_iterator* iter)
{
	if(!read_spool_dname(iter->spool, iter->dname, sizeof(iter->dname),
		&iter->dname_len)) {
		log_msg(LOG_ERR, "error reading file %s: %s",
			iter->file_name, strerror(errno));
		return 0;
	}
	return 1;
}

/* get the next name to operate on, that is not processed yet, 0 on failure
 * returns okay on endoffile, check with eof for that.
 * when done with an element, set iter->is_processed on the element. */
static int spool_dname_iter_next(struct spool_dname_iterator* iter)
{
	if(iter->eof)
		return 1;
	if(!iter->read_first) {
		/* read the first one */
		if(!spool_dname_iter_read(iter))
			return 0;
		if(iter->dname_len == 0)
			iter->eof = 1;
		iter->read_first = 1;
		iter->is_processed = 0;
	}
	if(!iter->is_processed) {
		/* the current one needs processing */
		return 1;
	}
	/* read the next one */
	if(!spool_dname_iter_read(iter))
		return 0;
	if(iter->dname_len == 0)
		iter->eof = 1;
	iter->is_processed = 0;
	return 1;
}

/* check if the ixfr is too large */
static int ixfr_create_too_large(struct ixfr_create* ixfrcr,
	struct ixfr_store* store)
{
	if(store->cancelled)
		return 1;
	if(ixfrcr->max_size != 0 &&
		ixfr_data_size(store->data) > ixfrcr->max_size) {
		if(ixfrcr->errorcmdline) {
			log_msg(LOG_ERR, "the ixfr for %s exceeds size %u, it is not created",
				wiredname2str(ixfrcr->zone_name),
				(unsigned)ixfrcr->max_size);
		} else {
			VERBOSITY(2, (LOG_INFO, "the ixfr for %s exceeds size %u, it is not created",
				wiredname2str(ixfrcr->zone_name),
				(unsigned)ixfrcr->max_size));
		}
		ixfr_store_cancel(store);
		return 1;
	}
	return 0;
}

/* process the spool input before the domain */
static int process_spool_before_domain(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct domain* domain,
	struct spool_dname_iterator* iter, struct region* tmp_region)
{
	const dname_type* dname;
	if(ixfr_create_too_large(ixfrcr, store))
		return 0;
	/* read the domains and rrsets before the domain and those are from
	 * the old zone. If the domain is equal, return to have that processed
	 * if we bypass, that means the domain does not exist, do that */
	while(!iter->eof) {
		if(!spool_dname_iter_next(iter))
			return 0;
		if(iter->eof)
			break;
		/* see if we are at, before or after the domain */
		dname = dname_make(tmp_region, iter->dname, 1);
		if(!dname) {
			log_msg(LOG_ERR, "error in dname in %s",
				iter->file_name);
			return 0;
		}
		if(dname_compare(dname, domain_dname(domain)) < 0) {
			/* the dname is smaller than the one from the zone.
			 * it must be deleted, process it */
			if(!process_domain_del_RRs(ixfrcr, store, spool,
				iter->dname, iter->dname_len))
				return 0;
			iter->is_processed = 1;
		} else {
			/* we are at or after the domain we are looking for,
			 * done here */
			return 1;
		}
		if(ixfr_create_too_large(ixfrcr, store))
			return 0;
	}
	/* no more domains on spool, done here */
	return 1;
}

/* process the spool input for the domain */
static int process_spool_for_domain(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct zone* zone, struct domain* domain,
	struct spool_dname_iterator* iter, struct region* tmp_region)
{
	/* process all the spool that is not the domain, that is before the
	 * domain in the new zone */
	if(!process_spool_before_domain(spool, ixfrcr, store, domain, iter,
		tmp_region))
		return 0;
	
	if(ixfr_create_too_large(ixfrcr, store))
		return 0;
	/* are we at the correct domain now? */
	if(iter->eof || iter->dname_len != domain_dname(domain)->name_size ||
		memcmp(iter->dname, dname_name(domain_dname(domain)),
			iter->dname_len) != 0) {
		/* the domain from the new zone is not present in the old zone,
		 * the content is in the added RRs set */
		if(!process_domain_add_RRs(store, zone, domain))
			return 0;
		return 1;
	}

	/* process the domain */
	/* the domain exists both in the old and new zone,
	 * check for RR differences */
	if(!process_diff_domain(spool, ixfrcr, store, zone, domain))
		return 0;
	iter->is_processed = 1;

	return 1;
}

/* process remaining spool items */
static int process_spool_remaining(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct spool_dname_iterator* iter)
{
	/* the remaining domain names in the spool file, that is after
	 * the last domain in the new zone. */
	if(ixfr_create_too_large(ixfrcr, store))
		return 0;
	while(!iter->eof) {
		if(!spool_dname_iter_next(iter))
			return 0;
		if(iter->eof)
			break;
		/* the domain only exists in the spool, the old zone,
		 * and not in the new zone. That would be domains
		 * after the new zone domains, or there are no new
		 * zone domains */
		if(!process_domain_del_RRs(ixfrcr, store, spool, iter->dname,
			iter->dname_len))
			return 0;
		iter->is_processed = 1;
		if(ixfr_create_too_large(ixfrcr, store))
			return 0;
	}
	return 1;
}

/* walk through the zone and find the differences */
static int ixfr_create_walk_zone(FILE* spool, struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct zone* zone)
{
	struct domain* domain;
	struct spool_dname_iterator iter;
	struct region* tmp_region;
	spool_dname_iter_init(&iter, spool, ixfrcr->file_name);
	tmp_region = region_create(xalloc, free);
	for(domain = zone->apex; domain && domain_is_subdomain(domain,
		zone->apex); domain = domain_next(domain)) {
		uint32_t count = domain_count_rrsets(domain, zone);
		if(count == 0)
			continue;

		/* the domain is a domain in the new zone */
		if(!process_spool_for_domain(spool, ixfrcr, store, zone,
			domain, &iter, tmp_region)) {
			region_destroy(tmp_region);
			return 0;
		}
		region_free_all(tmp_region);
		if(ixfr_create_too_large(ixfrcr, store))
			return 0;
	}
	if(!process_spool_remaining(spool, ixfrcr, store, &iter)) {
		region_destroy(tmp_region);
		return 0;
	}
	region_destroy(tmp_region);
	return 1;
}

/* see if the ixfr has already been created by reading the file header
 * of the to-be-created file, if that file already exists */
static int ixfr_create_already_done_serial(struct zone* zone,
	const char* zfile, int checknew, uint32_t old_serial,
	uint32_t new_serial)
{
	uint32_t file_oldserial = 0, file_newserial = 0;
	size_t data_size = 0;
	if(!ixfr_read_file_header(zone->opts->name, zfile, 1, &file_oldserial,
		&file_newserial, &data_size, 0)) {
		/* could not read, so it was not done */
		return 0;
	}
	if(file_oldserial == old_serial &&
		(!checknew || file_newserial == new_serial)) {
		log_msg(LOG_INFO, "IXFR already exists in file %s.ixfr, nothing to do",
			zfile);
		return 1;
	}
	return 0;
}

/* See the data size of the ixfr by reading the file header of the ixfr file */
static int ixfr_read_header_data_size(const char* zname,
	const char* zfile, int file_num, size_t* data_size)
{
	uint32_t file_oldserial = 0, file_newserial = 0;
	if(!ixfr_read_file_header(zname, zfile, file_num, &file_oldserial,
		&file_newserial, data_size, 0)) {
		/* could not read */
		return 0;
	}
	return 1;
}

/* see if the ixfr has already been created by reading the file header
 * of the to-be-created file, if that file already exists */
static int ixfr_create_already_done(struct ixfr_create* ixfrcr,
	struct zone* zone, const char* zfile, int checknew)
{
	return ixfr_create_already_done_serial(zone, zfile, checknew,
		ixfrcr->old_serial, ixfrcr->new_serial);
}

/* store the new soa record for the ixfr */
static int ixfr_create_store_newsoa(struct ixfr_store* store,
	struct zone* zone)
{
	if(!zone || !zone->soa_rrset) {
		log_msg(LOG_ERR, "error no SOA rrset");
		return 0;
	}
	if(zone->soa_rrset->rr_count == 0) {
		log_msg(LOG_ERR, "error empty SOA rrset");
		return 0;
	}
	if(!ixfr_store_add_newsoa_rdatas(store, domain_dname(zone->apex),
		zone->soa_rrset->rrs[0].type, zone->soa_rrset->rrs[0].klass,
		zone->soa_rrset->rrs[0].ttl, zone->soa_rrset->rrs[0].rdatas,
		zone->soa_rrset->rrs[0].rdata_count)) {
		log_msg(LOG_ERR, "out of memory");
		return 0;
	}
	return 1;
}

/* initialise ixfr_create perform, open spool, read header, get serial */
static int ixfr_perform_init(struct ixfr_create* ixfrcr, struct zone* zone,
	struct ixfr_store* store_mem, struct ixfr_store** store, FILE** spool)
{
	*spool = fopen(ixfrcr->file_name, "r");
	if(!*spool) {
		log_msg(LOG_ERR, "could not open %s for reading: %s",
			ixfrcr->file_name, strerror(errno));
		return 0;
	}
	if(!read_spool_header(*spool, ixfrcr)) {
		fclose(*spool);
		return 0;
	}
	ixfrcr->new_serial = zone_get_current_serial(zone);
	*store = ixfr_store_start(zone, store_mem);
	if(!ixfr_create_store_newsoa(*store, zone)) {
		fclose(*spool);
		ixfr_store_free(*store);
		return 0;
	}
	return 1;
}

/* rename the other ixfr files */
static int ixfr_create_rename_and_delete_files(const char* zname,
	const char* zoptsname, const char* zfile, uint32_t ixfr_number,
	size_t ixfr_size, size_t cur_data_size)
{
	size_t size_in_use = cur_data_size;
	int dest_nr_files = (int)ixfr_number, maxsizehit = 0;
	int num = 1;
	while(ixfr_file_exists(zfile, num)) {
		size_t fsize = 0;
		if(!maxsizehit) {
			if(!ixfr_read_header_data_size(zoptsname, zfile, num,
				&fsize) || size_in_use + fsize > ixfr_size) {
				/* no more than this because of storage size */
				dest_nr_files = num;
				maxsizehit = 1;
			}
			size_in_use += fsize;
		}
		num++;
	}
	num--;
	/* num is now the number of ixfr files that exist */
	while(num > 0) {
		if(num+1 > dest_nr_files) {
			(void)ixfr_unlink_it(zname, zfile, num, 0);
		} else {
			if(!ixfr_rename_it(zname, zfile, num, 0, num+1, 0))
				return 0;
		}
		num--;
	}
	return 1;
}

/* finish up ixfr create processing */
static void ixfr_create_finishup(struct ixfr_create* ixfrcr,
	struct ixfr_store* store, struct zone* zone, int append_mem,
	struct nsd* nsd, const char* zfile, uint32_t ixfr_number)
{
	char log_buf[1024], nowstr[128];
	/* create the log message */
	time_t now = time(NULL);
	if(store->cancelled || ixfr_create_too_large(ixfrcr, store)) {
		/* remove unneeded files.
		 * since this ixfr cannot be created the others are useless. */
		ixfr_delete_superfluous_files(zone, zfile, 0);
		return;
	}
	snprintf(nowstr, sizeof(nowstr), "%s", ctime(&now));
	if(strchr(nowstr, '\n'))
		*strchr(nowstr, '\n') = 0;
	snprintf(log_buf, sizeof(log_buf),
		"IXFR created by NSD %s for %s %u to %u of %u bytes at time %s",
		PACKAGE_VERSION, wiredname2str(ixfrcr->zone_name),
		(unsigned)ixfrcr->old_serial, (unsigned)ixfrcr->new_serial,
		(unsigned)ixfr_data_size(store->data), nowstr);
	store->data->log_str = strdup(log_buf);
	if(!store->data->log_str) {
		log_msg(LOG_ERR, "out of memory");
		ixfr_store_free(store);
		return;
	}
	if(!ixfr_create_rename_and_delete_files(
		wiredname2str(ixfrcr->zone_name), zone->opts->name, zfile,
		ixfr_number, ixfrcr->max_size, ixfr_data_size(store->data))) {
		log_msg(LOG_ERR, "could not rename other ixfr files");
		ixfr_store_free(store);
		return;
	}
	if(!ixfr_write_file(zone, store->data, zfile, 1)) {
		log_msg(LOG_ERR, "could not write to file");
		ixfr_store_free(store);
		return;
	}
	if(append_mem) {
		ixfr_store_finish(store, nsd, log_buf);
	}
}

void ixfr_readup_exist(struct zone* zone, struct nsd* nsd,
	const char* zfile)
{
	/* the .ixfr file already exists with the correct serial numbers
	 * on the disk. Read up the ixfr files from the drive and put them
	 * in memory. To match the zone that has just been read.
	 * We can skip ixfr creation, and read up the files from the drive.
	 * If the files on the drive are consistent, we end up with exactly
	 * those ixfrs and that zone in memory.
	 * Presumably, the user has used nsd-checkzone to create an IXFR
	 * file and has put a new zone file, so we read up the data that
	 * we should have now.
	 * This also takes into account the config on number and size. */
	ixfr_read_from_file(nsd, zone, zfile);
}

int ixfr_create_perform(struct ixfr_create* ixfrcr, struct zone* zone,
	int append_mem, struct nsd* nsd, const char* zfile,
	uint32_t ixfr_number)
{
	struct ixfr_store store_mem, *store;
	FILE* spool;
	if(!ixfr_perform_init(ixfrcr, zone, &store_mem, &store, &spool)) {
		(void)unlink(ixfrcr->file_name);
		return 0;
	}
	if(ixfrcr->new_serial == ixfrcr->old_serial ||
		compare_serial(ixfrcr->new_serial, ixfrcr->old_serial)<0) {
		log_msg(LOG_ERR, "zone %s ixfr could not be created because the serial is the same or moves backwards, from %u to %u",
			wiredname2str(ixfrcr->zone_name),
			(unsigned)ixfrcr->old_serial,
			(unsigned)ixfrcr->new_serial);
		ixfr_store_cancel(store);
		fclose(spool);
		ixfr_store_free(store);
		(void)unlink(ixfrcr->file_name);
		ixfr_delete_superfluous_files(zone, zfile, 0);
		if(append_mem)
			ixfr_store_delixfrs(zone);
		return 0;
	}
	if(ixfr_create_already_done(ixfrcr, zone, zfile, 1)) {
		ixfr_store_cancel(store);
		fclose(spool);
		ixfr_store_free(store);
		(void)unlink(ixfrcr->file_name);
		if(append_mem) {
			ixfr_readup_exist(zone, nsd, zfile);
		}
		return 0;
	}

	if(!ixfr_create_walk_zone(spool, ixfrcr, store, zone)) {
		fclose(spool);
		ixfr_store_free(store);
		(void)unlink(ixfrcr->file_name);
		ixfr_delete_superfluous_files(zone, zfile, 0);
		return 0;
	}
	if(store->data && !store->data->oldsoa) {
		log_msg(LOG_ERR, "error spool file did not contain a SOA record");
		fclose(spool);
		ixfr_store_free(store);
		(void)unlink(ixfrcr->file_name);
		return 0;
	}
	if(!store->cancelled)
		ixfr_store_finish_data(store);
	fclose(spool);
	(void)unlink(ixfrcr->file_name);

	ixfr_create_finishup(ixfrcr, store, zone, append_mem, nsd, zfile,
		ixfr_number);
	return 1;
}

void ixfr_create_cancel(struct ixfr_create* ixfrcr)
{
	if(!ixfrcr)
		return;
	(void)unlink(ixfrcr->file_name);
	ixfr_create_free(ixfrcr);
}

int ixfr_create_from_difference(struct zone* zone, const char* zfile,
	int* ixfr_create_already_done_flag)
{
	uint32_t old_serial;
	*ixfr_create_already_done_flag = 0;
	/* only if the zone is ixfr enabled */
	if(!zone_is_ixfr_enabled(zone))
		return 0;
	/* only if ixfr create is enabled */
	if(!zone->opts->pattern->create_ixfr)
		return 0;
	/* only if there is a zone in memory to compare with */
	if(!zone->soa_rrset || !zone->apex)
		return 0;

	old_serial = zone_get_current_serial(zone);
	if(ixfr_create_already_done_serial(zone, zfile, 0, old_serial, 0)) {
		*ixfr_create_already_done_flag = 1;
		return 0;
	}

	return 1;
}