* ixfrcreate.c -- generating IXFR differences from zone files.

/*
* 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;
}