/src/bind9/lib/dns/zoneproperties.c

Source
/*
 * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, you can obtain one at https://mozilla.org/MPL/2.0/.
 *
 * See the COPYRIGHT file distributed with this work for additional
 * information regarding copyright ownership.
 */

/*! \file */

#include <isc/async.h>  /* WMM: remove include */
#include <isc/random.h> /* WMM: remove include */

#include <dns/kasp.h>
#include <dns/peer.h>
#include <dns/request.h>
#include <dns/ssu.h>
#include <dns/stats.h>
#include <dns/view.h>
#include <dns/zone.h>
#include <dns/zoneproperties.h>

#include "zone_p.h"

static void
default_journal(dns_zone_t *zone);
static void
zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length);
static void
zone_name_tostr(dns_zone_t *zone, char *buf, size_t length);
static void
zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length);

static void
free_rad_rcu(struct rcu_head *rcu_head) {
  dns_rad_t *rad = caa_container_of(rcu_head, dns_rad_t, rcu_head);
  dns_fixedname_invalidate(&rad->fname);

  isc_mem_putanddetach(&rad->mctx, rad, sizeof(*rad));
}

/*
 *  Single shot.
 */
void
dns_zone_setclass(dns_zone_t *zone, dns_rdataclass_t rdclass) {
  char namebuf[1024];

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(rdclass != dns_rdataclass_none);

  /*
   * Test and set.
   */
  LOCK_ZONE(zone);
  INSIST(zone != zone->raw);
  REQUIRE(zone->rdclass == dns_rdataclass_none ||
    zone->rdclass == rdclass);
  zone->rdclass = rdclass;

  if (zone->strnamerd != NULL) {
    isc_mem_free(zone->mctx, zone->strnamerd);
  }
  if (zone->strrdclass != NULL) {
    isc_mem_free(zone->mctx, zone->strrdclass);
  }

  zone_namerd_tostr(zone, namebuf, sizeof namebuf);
  zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf);
  zone_rdclass_tostr(zone, namebuf, sizeof namebuf);
  zone->strrdclass = isc_mem_strdup(zone->mctx, namebuf);

  if (dns__zone_inline_secure(zone)) {
    dns_zone_setclass(zone->raw, rdclass);
  }
  UNLOCK_ZONE(zone);
}

dns_rdataclass_t
dns_zone_getclass(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->rdclass;
}

void
dns_zone_setnotifytype(dns_zone_t *zone, dns_rdatatype_t type,
           dns_notifytype_t notifytype) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  switch (type) {
  case dns_rdatatype_soa:
    zone->notifysoa.notifytype = notifytype;
    break;
  case dns_rdatatype_cds:
    INSIST(notifytype == dns_notifytype_no ||
           notifytype == dns_notifytype_yes);
    zone->notifycds.notifytype = notifytype;
    break;
  default:
    UNREACHABLE();
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setcheckdstype(dns_zone_t *zone, dns_checkdstype_t checkdstype) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->checkdstype = checkdstype;
  UNLOCK_ZONE(zone);
}

/*
 *  Single shot.
 */
void
dns_zone_settype(dns_zone_t *zone, dns_zonetype_t type) {
  char namebuf[1024];

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(type != dns_zone_none);

  /*
   * Test and set.
   */
  LOCK_ZONE(zone);
  REQUIRE(zone->type == dns_zone_none || zone->type == type);
  zone->type = type;

  if (zone->strnamerd != NULL) {
    isc_mem_free(zone->mctx, zone->strnamerd);
  }

  zone_namerd_tostr(zone, namebuf, sizeof namebuf);
  zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf);
  UNLOCK_ZONE(zone);
}

void
dns_zone_getdbtype(dns_zone_t *zone, char ***argv, isc_mem_t *mctx) {
  size_t size = 0;
  unsigned int i;
  void *mem;
  char **tmp, *tmp2, *base;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(argv != NULL && *argv == NULL);

  LOCK_ZONE(zone);
  size = ISC_CHECKED_MUL(zone->db_argc + 1, sizeof(char *));
  for (i = 0; i < zone->db_argc; i++) {
    size += strlen(zone->db_argv[i]) + 1;
  }
  mem = isc_mem_allocate(mctx, size);
  {
    tmp = mem;
    tmp2 = mem;
    base = mem;
    tmp2 += ISC_CHECKED_MUL(zone->db_argc + 1, sizeof(char *));
    for (i = 0; i < zone->db_argc; i++) {
      *tmp++ = tmp2;
      strlcpy(tmp2, zone->db_argv[i], size - (tmp2 - base));
      tmp2 += strlen(tmp2) + 1;
    }
    *tmp = NULL;
  }
  UNLOCK_ZONE(zone);
  *argv = mem;
}

void
dns_zone_setdbtype(dns_zone_t *zone, unsigned int dbargc,
       const char *const *dbargv) {
  char **argv = NULL;
  unsigned int i;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(dbargc >= 1);
  REQUIRE(dbargv != NULL);

  LOCK_ZONE(zone);

  /* Set up a new database argument list. */
  argv = isc_mem_cget(zone->mctx, dbargc, sizeof(*argv));
  for (i = 0; i < dbargc; i++) {
    argv[i] = NULL;
  }
  for (i = 0; i < dbargc; i++) {
    argv[i] = isc_mem_strdup(zone->mctx, dbargv[i]);
  }

  /* Free the old list. */
  dns__zone_freedbargs(zone);

  zone->db_argc = dbargc;
  zone->db_argv = argv;

  UNLOCK_ZONE(zone);
}

void
dns_zone_setview(dns_zone_t *zone, dns_view_t *view) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  dns__zone_setview_helper(zone, view);
  UNLOCK_ZONE(zone);
}

dns_view_t *
dns_zone_getview(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->view;
}

void
dns_zone_setorigin(dns_zone_t *zone, const dns_name_t *origin) {
  char namebuf[1024];

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(origin != NULL);

  LOCK_ZONE(zone);
  INSIST(zone != zone->raw);
  if (dns_name_dynamic(&zone->origin)) {
    dns_name_free(&zone->origin, zone->mctx);
    dns_name_init(&zone->origin);
  }
  dns_name_dup(origin, zone->mctx, &zone->origin);

  if (zone->strnamerd != NULL) {
    isc_mem_free(zone->mctx, zone->strnamerd);
  }
  if (zone->strname != NULL) {
    isc_mem_free(zone->mctx, zone->strname);
  }

  zone_namerd_tostr(zone, namebuf, sizeof namebuf);
  zone->strnamerd = isc_mem_strdup(zone->mctx, namebuf);
  zone_name_tostr(zone, namebuf, sizeof namebuf);
  zone->strname = isc_mem_strdup(zone->mctx, namebuf);

  if (dns__zone_inline_secure(zone)) {
    dns_zone_setorigin(zone->raw, origin);
  }
  UNLOCK_ZONE(zone);
}

static void
setstring(dns_zone_t *zone, char **field, const char *value) {
  char *copy;

  if (value != NULL) {
    copy = isc_mem_strdup(zone->mctx, value);
  } else {
    copy = NULL;
  }

  if (*field != NULL) {
    isc_mem_free(zone->mctx, *field);
  }

  *field = copy;
}

typedef struct foundtoken foundtoken_t;
typedef struct token_names token_names_t;
typedef isc_result_t (*tokenparse_t)(const token_names_t *names,
             const foundtoken_t *token,
             isc_buffer_t *b);

struct foundtoken {
  const char *pos;
  size_t len;
  tokenparse_t parse;
};

struct token_names {
  dns_name_t *zonename;
  const char *viewname;
  const char *typename;
};

static int
foundtoken_order(const void *a, const void *b) {
  /* sort char pointers in order of which occurs first in memory */
  return ((foundtoken_t *)a)->pos - ((foundtoken_t *)b)->pos;
}

static isc_result_t
putmem(isc_buffer_t *b, const char *base, size_t length) {
  size_t space = isc_buffer_availablelength(b) - 1;
  if (space < length) {
    isc_buffer_putmem(b, (const unsigned char *)base, space);
    return ISC_R_NOSPACE;
  }

  isc_buffer_putmem(b, (const unsigned char *)base, length);
  return ISC_R_SUCCESS;
}

static isc_result_t
tokenparse_type(const token_names_t *names, const foundtoken_t *token,
    isc_buffer_t *b) {
  UNUSED(token);

  return putmem(b, names->typename, strlen(names->typename));
}

static isc_result_t
tokenparse_name(const token_names_t *names,
    const foundtoken_t *token ISC_ATTR_UNUSED, isc_buffer_t *b) {
  char name[DNS_NAME_FORMATSIZE];

  dns_name_format(names->zonename, name, sizeof(name));
  return putmem(b, name, strlen(name));
}

static isc_result_t
tokenparse_view(const token_names_t *names, const foundtoken_t *token,
    isc_buffer_t *b) {
  UNUSED(token);

  return putmem(b, names->viewname, strlen(names->viewname));
}

static isc_result_t
tokenparse_char(const token_names_t *names, const foundtoken_t *token,
    isc_buffer_t *b) {
  char name[DNS_NAME_FORMATSIZE];
  size_t chartokidx;
  char c;

  dns_name_format(names->zonename, name, sizeof(name));

  chartokidx = token->pos[token->len - 1] - '1';
  INSIST(chartokidx <= 2);
  if (chartokidx < strlen(name)) {
    c = name[chartokidx];
  } else {
    c = '.';
  }
  return putmem(b, &c, 1);
}

static isc_result_t
tokenparse_label(const token_names_t *names, const foundtoken_t *token,
     isc_buffer_t *b) {
  isc_result_t result;
  char buf[DNS_NAME_FORMATSIZE];
  dns_fixedname_t ft;
  dns_name_t *target = dns_fixedname_initname(&ft);
  unsigned int labels;
  char labeltokidx;
  int ilabel = -1;

  dns_name_copy(dns_rootname, target);
  labels = dns_name_countlabels(names->zonename);

  labeltokidx = isc_ascii_tolower(token->pos[token->len - 1]);
  if (token->len == 2) {
    /*
     * %z, %y, %x pattern
     */
    INSIST(labeltokidx >= 'x' && labeltokidx <= 'z');
  } else {
    /*
     * $label1, $label2, $label3 pattern
     */
    INSIST(labeltokidx >= '1' && labeltokidx <= '3');
  }

  if (labeltokidx == '1' || labeltokidx == 'z') {
    ilabel = labels - 1;
  } else if (labeltokidx == '2' || labeltokidx == 'y') {
    ilabel = labels - 2;
  } else if (labeltokidx == '3' || labeltokidx == 'x') {
    ilabel = labels - 3;
  }

  if (ilabel >= 0) {
    dns_name_getlabelsequence(names->zonename, ilabel, 1, target);
  }
  dns_name_format(target, buf, sizeof(buf));
  result = putmem(b, buf, strlen(buf));

  return result;
}

typedef struct {
  const char *name;
  tokenparse_t parse;
} token_t;
static const token_t tokens[] = {
  { "$type", tokenparse_type },  { "$name", tokenparse_name },
  { "$view", tokenparse_view },  { "$char1", tokenparse_char },
  { "$char2", tokenparse_char },   { "$char3", tokenparse_char },
  { "$label1", tokenparse_label }, { "$label2", tokenparse_label },
  { "$label3", tokenparse_label }, { "%t", tokenparse_type },
  { "%s", tokenparse_name },   { "%v", tokenparse_view },
  { "%1", tokenparse_char },   { "%2", tokenparse_char },
  { "%3", tokenparse_char },   { "%z", tokenparse_label },
  { "%y", tokenparse_label },  { "%x", tokenparse_label }
};

/*
 * Set the masterfile field, expanding:
 *
 *    - $name or "%s" to the zone name
 *    - $type or "%t" to the zone type
 *    - $view or "%v" to the view name.
 *    - $char1 or "%1" to the first character of the zone name
 *    - $char2 or "%2" to the second character of the zone name (or a dot if
 *      there is no second character)
 *    - $char3 or "%3" to the third character of the zone name (or a dot if
 *      there is no third character)
 *    - $label1 or "%z" to the toplevel domain of the zone (or a dot if it is
 *      the TLD)
 *    - $label2 or "%y" to the next label under the toplevel domain (or a dot if
 *      there is no next label)
 *    - $label2 or "%x" to the next-next label under the toplevel domain (or a
 *      dot if there is no next-next label)
 *
 * Cap the length at PATH_MAX.
 */
void
dns_zone_expandzonefile(isc_buffer_t *b, const char *filename,
      const dns_name_t *zonename, const char *viewname,
      const char *typename) {
  isc_result_t result;
  foundtoken_t founds[ARRAY_SIZE(tokens)];
  dns_fixedname_t fz;
  size_t tags = 0;
  token_names_t names = { .zonename = dns_fixedname_initname(&fz),
        .viewname = viewname,
        .typename = typename };

  REQUIRE(zonename != NULL);
  REQUIRE(filename != NULL);
  REQUIRE(typename != NULL);

  if (viewname == NULL) {
    names.viewname = "";
  }

  /* Normalize the name by converting to lower case */
  result = dns_name_downcase(zonename, names.zonename);
  INSIST(result == ISC_R_SUCCESS);

  for (size_t i = 0; i < ARRAY_SIZE(tokens); i++) {
    const token_t *token = &tokens[i];
    const char *p = strcasestr(filename, token->name);

    if (p != NULL) {
      founds[tags++] =
        (foundtoken_t){ .pos = p,
            .len = strlen(token->name),
            .parse = token->parse };
    }
  }

  if (tags == 0) {
    putmem(b, filename, strlen(filename));
    goto cleanup;
  }

  /* sort the tag offsets in order of occurrence */
  qsort(founds, tags, sizeof(foundtoken_t), foundtoken_order);

  const char *p = filename;
  for (size_t i = 0; i < tags; i++) {
    foundtoken_t *token = &founds[i];

    CHECK(putmem(b, p, token->pos - p));

    p = token->pos;
    INSIST(p != NULL);
    CHECK(token->parse(&names, token, b));

    /* Advance the input pointer past the token */
    p += founds[i].len;
  }

  const char *end = filename + strlen(filename);
  putmem(b, p, end - p);

cleanup:
  isc_buffer_putuint8(b, 0);
}

static void
setfilename(dns_zone_t *zone, char **field, const char *value) {
  char filename[PATH_MAX];
  isc_buffer_t b;

  if (value == NULL) {
    *field = NULL;
    return;
  }

  isc_buffer_init(&b, filename, sizeof(filename));
  dns_zone_expandzonefile(&b, value, &zone->origin,
        zone->view != NULL ? zone->view->name : NULL,
        dns_zonetype_name(zone->type));
  setstring(zone, field, filename);
}

void
dns_zone_setfile(dns_zone_t *zone, const char *file, const char *initial_file,
     dns_masterformat_t format, const dns_master_style_t *style) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(zone->stream == NULL);

  LOCK_ZONE(zone);
  setfilename(zone, &zone->masterfile, file);
  setstring(zone, &zone->initfile, initial_file);
  zone->masterformat = format;
  if (format == dns_masterformat_text) {
    zone->masterstyle = style;
  }
  default_journal(zone);
  UNLOCK_ZONE(zone);
}

const char *
dns_zone_getfile(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->masterfile;
}

void
dns_zone_setstream(dns_zone_t *zone, const FILE *stream,
       dns_masterformat_t format, const dns_master_style_t *style) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(stream != NULL);
  REQUIRE(zone->masterfile == NULL);

  LOCK_ZONE(zone);
  zone->stream = stream;
  zone->masterformat = format;
  if (format == dns_masterformat_text) {
    zone->masterstyle = style;
  }
  default_journal(zone);
  UNLOCK_ZONE(zone);
}

dns_ttl_t
dns_zone_getmaxttl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->maxttl;
}

void
dns_zone_setmaxttl(dns_zone_t *zone, dns_ttl_t maxttl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (maxttl != 0) {
    DNS_ZONE_SETOPTION(zone, DNS_ZONEOPT_CHECKTTL);
  } else {
    DNS_ZONE_CLROPTION(zone, DNS_ZONEOPT_CHECKTTL);
  }
  zone->maxttl = maxttl;
  UNLOCK_ZONE(zone);

  return;
}

static void
default_journal(dns_zone_t *zone) {
  char *journal;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(LOCKED_ZONE(zone));

  if (zone->masterfile != NULL) {
    /* Calculate string length including '\0'. */
    int len = strlen(zone->masterfile) + sizeof(".jnl");
    journal = isc_mem_allocate(zone->mctx, len);
    strlcpy(journal, zone->masterfile, len);
    strlcat(journal, ".jnl", len);
  } else {
    journal = NULL;
  }
  setstring(zone, &zone->journal, journal);
  if (journal != NULL) {
    isc_mem_free(zone->mctx, journal);
  }
}

void
dns_zone_setjournal(dns_zone_t *zone, const char *myjournal) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  setstring(zone, &zone->journal, myjournal);
  UNLOCK_ZONE(zone);
}

char *
dns_zone_getjournal(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->journal;
}

isc_mem_t *
dns_zone_getmctx(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->mctx;
}

dns_zonemgr_t *
dns_zone_getmgr(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->zmgr;
}

void
dns_zone_setkasp(dns_zone_t *zone, dns_kasp_t *kasp) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->kasp != NULL) {
    dns_kasp_detach(&zone->kasp);
  }
  if (kasp != NULL) {
    dns_kasp_attach(kasp, &zone->kasp);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setdefaultkasp(dns_zone_t *zone, dns_kasp_t *kasp) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->defaultkasp != NULL) {
    dns_kasp_detach(&zone->defaultkasp);
  }
  if (kasp != NULL) {
    dns_kasp_attach(kasp, &zone->defaultkasp);
  }
  UNLOCK_ZONE(zone);
}

dns_kasp_t *
dns_zone_getkasp(dns_zone_t *zone) {
  dns_kasp_t *kasp = NULL;

  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (dns__zone_inline_raw(zone) && zone->secure != NULL) {
    kasp = zone->secure->kasp;
  } else {
    kasp = zone->kasp;
  }
  UNLOCK_ZONE(zone);

  return kasp;
}

void
dns_zone_setxfrsource4(dns_zone_t *zone, const isc_sockaddr_t *xfrsource) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(xfrsource != NULL);

  LOCK_ZONE(zone);
  zone->xfrsource4 = *xfrsource;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getxfrsource4(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(xfrsource != NULL);

  LOCK_ZONE(zone);
  *xfrsource = zone->xfrsource4;
  UNLOCK_ZONE(zone);
}

void
dns_zone_setxfrsource6(dns_zone_t *zone, const isc_sockaddr_t *xfrsource) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(xfrsource != NULL);

  LOCK_ZONE(zone);
  zone->xfrsource6 = *xfrsource;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getxfrsource6(dns_zone_t *zone, isc_sockaddr_t *xfrsource) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(xfrsource != NULL);

  LOCK_ZONE(zone);
  *xfrsource = zone->xfrsource6;
  UNLOCK_ZONE(zone);
}

void
dns_zone_setparentalsrc4(dns_zone_t *zone, const isc_sockaddr_t *parentalsrc) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(parentalsrc != NULL);

  LOCK_ZONE(zone);
  zone->parentalsrc4 = *parentalsrc;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getparentalsrc4(dns_zone_t *zone, isc_sockaddr_t *parentalsrc) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(parentalsrc != NULL);

  LOCK_ZONE(zone);
  *parentalsrc = zone->parentalsrc4;
  UNLOCK_ZONE(zone);
}

void
dns_zone_setparentalsrc6(dns_zone_t *zone, const isc_sockaddr_t *parentalsrc) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->parentalsrc6 = *parentalsrc;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getparentalsrc6(dns_zone_t *zone, isc_sockaddr_t *parentalsrc) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(parentalsrc != NULL);

  LOCK_ZONE(zone);
  *parentalsrc = zone->parentalsrc6;
  UNLOCK_ZONE(zone);
}

void
dns_zone_setnotifysrc4(dns_zone_t *zone, dns_rdatatype_t type,
           const isc_sockaddr_t *notifysrc) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(notifysrc != NULL);

  LOCK_ZONE(zone);
  switch (type) {
  case dns_rdatatype_soa:
    zone->notifysoa.notifysrc4 = *notifysrc;
    break;
  case dns_rdatatype_cds:
    zone->notifycds.notifysrc4 = *notifysrc;
    break;
  default:
    UNREACHABLE();
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setnotifysrc6(dns_zone_t *zone, dns_rdatatype_t type,
           const isc_sockaddr_t *notifysrc) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(notifysrc != NULL);

  LOCK_ZONE(zone);
  switch (type) {
  case dns_rdatatype_soa:
    zone->notifysoa.notifysrc6 = *notifysrc;
    break;
  case dns_rdatatype_cds:
    zone->notifycds.notifysrc6 = *notifysrc;
    break;
  default:
    UNREACHABLE();
  }
  UNLOCK_ZONE(zone);
}

static bool
has_pf(isc_sockaddr_t *addresses, size_t count, int pf) {
  for (size_t i = 0; i < count; i++) {
    if (isc_sockaddr_pf(&addresses[i]) == pf) {
      return true;
    }
  }
  return false;
}

static void
report_no_active_addresses(dns_zone_t *zone, isc_sockaddr_t *addresses,
         size_t count, const char *what) {
  if (isc_net_probeipv4() == ISC_R_DISABLED) {
    if (!has_pf(addresses, count, AF_INET6)) {
      dns_zone_log(zone, ISC_LOG_NOTICE,
             "IPv4 disabled and no IPv6 %s", what);
    }
  } else if (isc_net_probeipv6() == ISC_R_DISABLED) {
    if (!has_pf(addresses, count, AF_INET)) {
      dns_zone_log(zone, ISC_LOG_NOTICE,
             "IPv6 disabled and no IPv4 %s", what);
    }
  }
}

static void
setremote(dns_zone_t *zone, dns_remote_t *remote, const char *remotestr,
    isc_sockaddr_t *addresses, isc_sockaddr_t *sources,
    dns_name_t **keynames, dns_name_t **tlsnames, bool refresh,
    bool report, uint32_t count) {
  dns_remote_t newremote;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(DNS_REMOTE_VALID(remote));

  newremote.magic = DNS_REMOTE_MAGIC;
  newremote.addresses = addresses;
  newremote.sources = sources;
  newremote.keynames = keynames;
  newremote.tlsnames = tlsnames;
  newremote.addrcnt = count;

  if (dns_remote_equal(remote, &newremote)) {
    return;
  }

  /*
   * The refresh code assumes that 'servers' wouldn't change under it.
   * If it will change then kill off any current refresh in progress
   * and update the primaries info.  If it won't change then we can just
   * unlock and exit.
   */
  if (zone->request != NULL && refresh) {
    dns_request_cancel(zone->request);
  }

  dns_remote_clear(remote);

  /*
   * If count == 0, don't allocate any space for servers.
   */
  if (count == 0) {
    return;
  }

  /*
   * Now set up the address and key lists.
   */
  if (report) {
    report_no_active_addresses(zone, addresses, count, remotestr);
  }

  dns_remote_init(remote, count, addresses, sources, keynames, tlsnames,
      true, zone->mctx);
}

void
dns_zone_setalsonotify(dns_zone_t *zone, isc_sockaddr_t *addresses,
           isc_sockaddr_t *sources, dns_name_t **keynames,
           dns_name_t **tlsnames, uint32_t count) {
  bool refresh = false;
  bool report = false;

  LOCK_ZONE(zone);
  setremote(zone, &zone->alsonotify, "also-notify", addresses, sources,
      keynames, tlsnames, refresh, report, count);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setprimaries(dns_zone_t *zone, isc_sockaddr_t *addresses,
          isc_sockaddr_t *sources, dns_name_t **keynames,
          dns_name_t **tlsnames, uint32_t count) {
  bool refresh = true;
  bool report = true;

  LOCK_ZONE(zone);
  setremote(zone, &zone->primaries, "primaries", addresses, sources,
      keynames, tlsnames, refresh, report, count);
  DNS_ZONE_CLRFLAG(zone, DNS_ZONEFLG_NOPRIMARIES);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setparentals(dns_zone_t *zone, isc_sockaddr_t *addresses,
          isc_sockaddr_t *sources, dns_name_t **keynames,
          dns_name_t **tlsnames, uint32_t count) {
  bool refresh = false;
  bool report = true;

  LOCK_ZONE(zone);
  setremote(zone, &zone->parentals, "parental-agents", addresses, sources,
      keynames, tlsnames, refresh, report, count);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setcdsendpoints(dns_zone_t *zone, isc_sockaddr_t *addresses,
       isc_sockaddr_t *sources, dns_name_t **keynames,
       dns_name_t **tlsnames, uint32_t count) {
  bool refresh = false;
  bool report = false;

  LOCK_ZONE(zone);
  setremote(zone, &zone->cds_endpoints, "cds-endpoints", addresses,
      sources, keynames, tlsnames, refresh, report, count);
  UNLOCK_ZONE(zone);
}

isc_result_t
dns_zone_getdb(dns_zone_t *zone, dns_db_t **dpb) {
  isc_result_t result = ISC_R_SUCCESS;

  REQUIRE(DNS_ZONE_VALID(zone));

  ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_read);
  if (zone->db == NULL) {
    result = DNS_R_NOTLOADED;
  } else {
    dns_db_attach(zone->db, dpb);
  }
  ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_read);

  return result;
}

void
dns_zone_setdb(dns_zone_t *zone, dns_db_t *db) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(zone->type == dns_zone_staticstub);

  ZONEDB_LOCK(&zone->dblock, isc_rwlocktype_write);
  REQUIRE(zone->db == NULL);
  dns_db_attach(db, &zone->db);
  ZONEDB_UNLOCK(&zone->dblock, isc_rwlocktype_write);
}

void
dns_zone_setminrefreshtime(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(val > 0);

  zone->minrefresh = val;
}

void
dns_zone_setmaxrefreshtime(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(val > 0);

  zone->maxrefresh = val;
}

void
dns_zone_setminretrytime(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(val > 0);

  zone->minretry = val;
}

void
dns_zone_setmaxretrytime(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(val > 0);

  zone->maxretry = val;
}

uint32_t
dns_zone_getmaxrecords(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->maxrecords;
}

void
dns_zone_setmaxrecords(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->maxrecords = val;
}

void
dns_zone_setmaxrrperset(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->maxrrperset = val;
  if (zone->db != NULL) {
    dns_db_setmaxrrperset(zone->db, val);
  }
}

void
dns_zone_setmaxtypepername(dns_zone_t *zone, uint32_t val) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->maxtypepername = val;
  if (zone->db != NULL) {
    dns_db_setmaxtypepername(zone->db, val);
  }
}

void
dns_zone_setnotifyacl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearnotifyacl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->notifysoa.notify_acl);
  dns_acl_attach(acl, &zone->notifycds.notify_acl);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setqueryacl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearqueryacl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->query_acl);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setqueryonacl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearqueryonacl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->queryon_acl);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setupdateacl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearupdateacl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->update_acl);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setforwardacl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearforwardacl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->forward_acl);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setxfracl(dns_zone_t *zone, dns_acl_t *acl) {
  REQUIRE(DNS_ZONE_VALID(zone));

  dns_zone_clearxfracl(zone);

  LOCK_ZONE(zone);
  dns_acl_attach(acl, &zone->xfr_acl);
  UNLOCK_ZONE(zone);
}

dns_acl_t *
dns_zone_getqueryacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->query_acl;
}

dns_acl_t *
dns_zone_getqueryonacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->queryon_acl;
}

dns_acl_t *
dns_zone_getupdateacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->update_acl;
}

dns_acl_t *
dns_zone_getforwardacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->forward_acl;
}

dns_acl_t *
dns_zone_getxfracl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->xfr_acl;
}

void
dns_zone_clearupdateacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->update_acl != NULL) {
    dns_acl_detach(&zone->update_acl);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_clearforwardacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->forward_acl != NULL) {
    dns_acl_detach(&zone->forward_acl);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_clearnotifyacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->notifysoa.notify_acl != NULL) {
    dns_acl_detach(&zone->notifysoa.notify_acl);
  }
  if (zone->notifycds.notify_acl != NULL) {
    dns_acl_detach(&zone->notifycds.notify_acl);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_clearqueryacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->query_acl != NULL) {
    dns_acl_detach(&zone->query_acl);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_clearqueryonacl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->queryon_acl != NULL) {
    dns_acl_detach(&zone->queryon_acl);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_clearxfracl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->xfr_acl != NULL) {
    dns_acl_detach(&zone->xfr_acl);
  }
  UNLOCK_ZONE(zone);
}

bool
dns_zone_getupdatedisabled(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->update_disabled;
}

void
dns_zone_setupdatedisabled(dns_zone_t *zone, bool state) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->update_disabled = state;
}

bool
dns_zone_getzeronosoattl(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->zero_no_soa_ttl;
}

void
dns_zone_setzeronosoattl(dns_zone_t *zone, bool state) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->zero_no_soa_ttl = state;
}

void
dns_zone_setchecknames(dns_zone_t *zone, dns_severity_t severity) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->check_names = severity;
}

dns_severity_t
dns_zone_getchecknames(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->check_names;
}

void
dns_zone_setjournalsize(dns_zone_t *zone, int32_t size) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->journalsize = size;
}

int32_t
dns_zone_getjournalsize(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->journalsize;
}

static void
zone_namerd_tostr(dns_zone_t *zone, char *buf, size_t length) {
  isc_result_t result = ISC_R_FAILURE;
  isc_buffer_t buffer;

  REQUIRE(buf != NULL);
  REQUIRE(length > 1U);

  /*
   * Leave space for terminating '\0'.
   */
  isc_buffer_init(&buffer, buf, (unsigned int)length - 1);
  if (zone->type != dns_zone_redirect && zone->type != dns_zone_key) {
    if (dns_name_dynamic(&zone->origin)) {
      result = dns_name_totext(
        &zone->origin, DNS_NAME_OMITFINALDOT, &buffer);
    }
    if (result != ISC_R_SUCCESS &&
        isc_buffer_availablelength(&buffer) >=
          (sizeof("<UNKNOWN>") - 1))
    {
      isc_buffer_putstr(&buffer, "<UNKNOWN>");
    }

    if (isc_buffer_availablelength(&buffer) > 0) {
      isc_buffer_putstr(&buffer, "/");
    }
    (void)dns_rdataclass_totext(zone->rdclass, &buffer);
  }

  if (zone->view != NULL && strcmp(zone->view->name, "_bind") != 0 &&
      strcmp(zone->view->name, "_default") != 0 &&
      strlen(zone->view->name) < isc_buffer_availablelength(&buffer))
  {
    isc_buffer_putstr(&buffer, "/");
    isc_buffer_putstr(&buffer, zone->view->name);
  }
  if (dns__zone_inline_secure(zone) &&
      9U < isc_buffer_availablelength(&buffer))
  {
    isc_buffer_putstr(&buffer, " (signed)");
  }
  if (dns__zone_inline_raw(zone) &&
      11U < isc_buffer_availablelength(&buffer))
  {
    isc_buffer_putstr(&buffer, " (unsigned)");
  }

  buf[isc_buffer_usedlength(&buffer)] = '\0';
}

static void
zone_name_tostr(dns_zone_t *zone, char *buf, size_t length) {
  isc_result_t result = ISC_R_FAILURE;
  isc_buffer_t buffer;

  REQUIRE(buf != NULL);
  REQUIRE(length > 1U);

  /*
   * Leave space for terminating '\0'.
   */
  isc_buffer_init(&buffer, buf, (unsigned int)length - 1);
  if (dns_name_dynamic(&zone->origin)) {
    result = dns_name_totext(&zone->origin, DNS_NAME_OMITFINALDOT,
           &buffer);
  }
  if (result != ISC_R_SUCCESS &&
      isc_buffer_availablelength(&buffer) >= (sizeof("<UNKNOWN>") - 1))
  {
    isc_buffer_putstr(&buffer, "<UNKNOWN>");
  }

  buf[isc_buffer_usedlength(&buffer)] = '\0';
}

static void
zone_rdclass_tostr(dns_zone_t *zone, char *buf, size_t length) {
  isc_buffer_t buffer;

  REQUIRE(buf != NULL);
  REQUIRE(length > 1U);

  /*
   * Leave space for terminating '\0'.
   */
  isc_buffer_init(&buffer, buf, (unsigned int)length - 1);
  (void)dns_rdataclass_totext(zone->rdclass, &buffer);

  buf[isc_buffer_usedlength(&buffer)] = '\0';
}

void
dns_zone_name(dns_zone_t *zone, char *buf, size_t length) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(buf != NULL);

  LOCK_ZONE(zone);
  zone_namerd_tostr(zone, buf, length);
  UNLOCK_ZONE(zone);
}

void
dns_zone_nameonly(dns_zone_t *zone, char *buf, size_t length) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(buf != NULL);
  zone_name_tostr(zone, buf, length);
}

void
dns_zone_setminxfrratein(dns_zone_t *zone, uint32_t bytes, uint32_t seconds) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->minxfrratebytesin = bytes;
  zone->minxfrratesecondsin = seconds;
}

uint32_t
dns_zone_getminxfrratebytesin(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->minxfrratebytesin;
}

uint32_t
dns_zone_getminxfrratesecondsin(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->minxfrratesecondsin;
}

void
dns_zone_setmaxxfrin(dns_zone_t *zone, uint32_t maxxfrin) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->maxxfrin = maxxfrin;
}

uint32_t
dns_zone_getmaxxfrin(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->maxxfrin;
}

void
dns_zone_setmaxxfrout(dns_zone_t *zone, uint32_t maxxfrout) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->maxxfrout = maxxfrout;
}

uint32_t
dns_zone_getmaxxfrout(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->maxxfrout;
}

dns_zonetype_t
dns_zone_gettype(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->type;
}

dns_name_t *
dns_zone_getorigin(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return &zone->origin;
}

void
dns_zone_setidlein(dns_zone_t *zone, uint32_t idlein) {
  REQUIRE(DNS_ZONE_VALID(zone));

  if (idlein == 0) {
    idlein = DNS_DEFAULT_IDLEIN;
  }
  zone->idlein = idlein;
}

uint32_t
dns_zone_getidlein(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->idlein;
}

void
dns_zone_setidleout(dns_zone_t *zone, uint32_t idleout) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->idleout = idleout;
}

uint32_t
dns_zone_getidleout(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->idleout;
}

void
dns_zone_getssutable(dns_zone_t *zone, dns_ssutable_t **table) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(table != NULL);
  REQUIRE(*table == NULL);

  LOCK_ZONE(zone);
  if (zone->ssutable != NULL) {
    dns_ssutable_attach(zone->ssutable, table);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setssutable(dns_zone_t *zone, dns_ssutable_t *table) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->ssutable != NULL) {
    dns_ssutable_detach(&zone->ssutable);
  }
  if (table != NULL) {
    dns_ssutable_attach(table, &zone->ssutable);
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setsigvalidityinterval(dns_zone_t *zone, uint32_t interval) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->sigvalidityinterval = interval;
}

uint32_t
dns_zone_getsigvalidityinterval(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->sigvalidityinterval;
}

void
dns_zone_setkeyvalidityinterval(dns_zone_t *zone, uint32_t interval) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->keyvalidityinterval = interval;
}

uint32_t
dns_zone_getkeyvalidityinterval(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->keyvalidityinterval;
}

void
dns_zone_setsigresigninginterval(dns_zone_t *zone, uint32_t interval) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->sigresigninginterval = interval;
  dns__zone_set_resigntime(zone);
  if (zone->loop != NULL) {
    dns__zone_settimer(zone, isc_time_now());
  }
  UNLOCK_ZONE(zone);
}

uint32_t
dns_zone_getsigresigninginterval(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->sigresigninginterval;
}

void
dns_zone_getsourceaddr(dns_zone_t *zone, isc_sockaddr_t *sourceaddr) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(sourceaddr != NULL);

  LOCK_ZONE(zone);
  INSIST(dns_remote_count(&zone->primaries) > 0);
  *sourceaddr = zone->sourceaddr;
  UNLOCK_ZONE(zone);
}

isc_result_t
dns_zone_getprimaryaddr(dns_zone_t *zone, isc_sockaddr_t *primaryaddr) {
  isc_result_t result = ISC_R_NOMORE;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(primaryaddr != NULL);

  LOCK_ZONE(zone);
  INSIST(dns_remote_count(&zone->primaries) > 0);
  if (!dns_remote_done(&zone->primaries)) {
    *primaryaddr = dns_remote_curraddr(&zone->primaries);
    result = ISC_R_SUCCESS;
  }
  UNLOCK_ZONE(zone);

  return result;
}

isc_time_t
dns_zone_getxfrintime(dns_zone_t *zone) {
  isc_time_t xfrintime;

  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  xfrintime = zone->xfrintime;
  UNLOCK_ZONE(zone);

  return xfrintime;
}

void
dns_zone_setstats(dns_zone_t *zone, isc_stats_t *stats) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(zone->stats == NULL);

  LOCK_ZONE(zone);
  zone->stats = NULL;
  isc_stats_attach(stats, &zone->stats);
  UNLOCK_ZONE(zone);
}

void
dns_zone_setrequeststats(dns_zone_t *zone, isc_stats_t *stats) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->requeststats_on && stats == NULL) {
    zone->requeststats_on = false;
  } else if (!zone->requeststats_on && stats != NULL) {
    if (zone->requeststats == NULL) {
      isc_stats_attach(stats, &zone->requeststats);
    }
    zone->requeststats_on = true;
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setrcvquerystats(dns_zone_t *zone, isc_statsmulti_t *stats) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (zone->requeststats_on && stats != NULL) {
    if (zone->rcvquerystats == NULL) {
      isc_statsmulti_attach(stats, &zone->rcvquerystats);
      zone->requeststats_on = true;
    }
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setdnssecsignstats(dns_zone_t *zone, dns_stats_t *stats) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  if (stats != NULL && zone->dnssecsignstats == NULL) {
    dns_stats_attach(stats, &zone->dnssecsignstats);
  }
  UNLOCK_ZONE(zone);
}

dns_stats_t *
dns_zone_getdnssecsignstats(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->dnssecsignstats;
}

isc_stats_t *
dns_zone_getrequeststats(dns_zone_t *zone) {
  /*
   * We don't lock zone for efficiency reason.  This is not catastrophic
   * because requeststats must always be valid when requeststats_on is
   * true.
   * Some counters may be incremented while requeststats_on is becoming
   * false, or some cannot be incremented just after the statistics are
   * installed, but it shouldn't matter much in practice.
   */
  if (zone->requeststats_on) {
    return zone->requeststats;
  } else {
    return NULL;
  }
}

/*
 * Return the received query stats bucket
 * see note from dns_zone_getrequeststats()
 */
isc_statsmulti_t *
dns_zone_getrcvquerystats(dns_zone_t *zone) {
  if (zone->requeststats_on) {
    return zone->rcvquerystats;
  } else {
    return NULL;
  }
}

void
dns_zone_setkeydirectory(dns_zone_t *zone, const char *directory) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  setstring(zone, &zone->keydirectory, directory);
  UNLOCK_ZONE(zone);
}

const char *
dns_zone_getkeydirectory(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->keydirectory;
}

void
dns_zone_setcheckmx(dns_zone_t *zone, dns_checkmxfunc_t checkmx) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->checkmx = checkmx;
}

void
dns_zone_setchecksrv(dns_zone_t *zone, dns_checksrvfunc_t checksrv) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->checksrv = checksrv;
}

void
dns_zone_setcheckns(dns_zone_t *zone, dns_checknsfunc_t checkns) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->checkns = checkns;
}

void
dns_zone_setcheckisservedby(dns_zone_t *zone,
          dns_checkisservedbyfunc_t checkisservedby) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->checkisservedby = checkisservedby;
}

void
dns_zone_setisself(dns_zone_t *zone, dns_isselffunc_t isself, void *arg) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->isself = isself;
  zone->isselfarg = arg;
  UNLOCK_ZONE(zone);
}

void
dns__zone_getisself(dns_zone_t *zone, dns_isselffunc_t *isself, void **arg) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(isself != NULL);
  REQUIRE(arg != NULL && *arg == NULL);

  *isself = zone->isself;
  *arg = zone->isselfarg;
}

void
dns_zone_setnotifydefer(dns_zone_t *zone, dns_rdatatype_t type,
      uint32_t defer) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  switch (type) {
  case dns_rdatatype_soa:
    zone->notifysoa.notifydefer = defer;
    break;
  case dns_rdatatype_cds:
    /* not applicable to NOTIFY(CDS), unused */
    zone->notifycds.notifydefer = defer;
    break;
  default:
    UNREACHABLE();
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setnotifydelay(dns_zone_t *zone, dns_rdatatype_t type,
      uint32_t delay) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  switch (type) {
  case dns_rdatatype_soa:
    zone->notifysoa.notifydelay = delay;
    break;
  case dns_rdatatype_cds:
    /* not applicable to NOTIFY(CDS), unused */
    zone->notifycds.notifydelay = delay;
    break;
  default:
    UNREACHABLE();
  }
  UNLOCK_ZONE(zone);
}

void
dns_zone_setnodes(dns_zone_t *zone, uint32_t nodes) {
  REQUIRE(DNS_ZONE_VALID(zone));

  if (nodes == 0) {
    nodes = 1;
  }
  zone->nodes = nodes;
}

void
dns_zone_setsignatures(dns_zone_t *zone, uint32_t signatures) {
  REQUIRE(DNS_ZONE_VALID(zone));

  /*
   * We treat signatures as a signed value so explicitly
   * limit its range here.
   */
  if (signatures > INT32_MAX) {
    signatures = INT32_MAX;
  } else if (signatures == 0) {
    signatures = 1;
  }
  zone->signatures = signatures;
}

uint32_t
dns_zone_getsignatures(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->signatures;
}

void
dns_zone_setprivatetype(dns_zone_t *zone, dns_rdatatype_t type) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->privatetype = type;
}

dns_rdatatype_t
dns_zone_getprivatetype(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->privatetype;
}

void
dns_zone_setautomatic(dns_zone_t *zone, bool automatic) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->automatic = automatic;
  UNLOCK_ZONE(zone);
}

bool
dns_zone_getautomatic(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->automatic;
}

void
dns_zone_setadded(dns_zone_t *zone, bool added) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->added = added;
  UNLOCK_ZONE(zone);
}

bool
dns_zone_getadded(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->added;
}

void
dns_zone_setmodded(dns_zone_t *zone, bool modded) {
  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  zone->modded = modded;
  UNLOCK_ZONE(zone);
}

bool
dns_zone_getmodded(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->modded;
}

isc_result_t
dns_zone_setrefreshkeyinterval(dns_zone_t *zone, uint32_t interval) {
  REQUIRE(DNS_ZONE_VALID(zone));
  if (interval == 0) {
    return ISC_R_RANGE;
  }
  /* Maximum value: 24 hours (3600 minutes) */
  if (interval > (24 * 60)) {
    interval = (24 * 60);
  }
  /* Multiply by 60 for seconds */
  zone->refreshkeyinterval = interval * 60;
  return ISC_R_SUCCESS;
}

void
dns_zone_setrequestixfr(dns_zone_t *zone, bool flag) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->requestixfr = flag;
}

bool
dns_zone_getrequestixfr(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->requestixfr;
}

void
dns_zone_setrequestixfrmaxdiffs(dns_zone_t *zone, uint32_t maxdiffs) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->requestixfr_maxdiffs = maxdiffs;
}

bool
dns_zone_getrequestixfrmaxdiffs(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->requestixfr_maxdiffs;
}

void
dns_zone_setixfrratio(dns_zone_t *zone, uint32_t ratio) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->ixfr_ratio = ratio;
}

uint32_t
dns_zone_getixfrratio(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->ixfr_ratio;
}

void
dns_zone_setrequestexpire(dns_zone_t *zone, bool flag) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->requestexpire = flag;
}

bool
dns_zone_getrequestexpire(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->requestexpire;
}

void
dns_zone_setserialupdatemethod(dns_zone_t *zone, dns_updatemethod_t method) {
  REQUIRE(DNS_ZONE_VALID(zone));
  zone->updatemethod = method;
}

dns_updatemethod_t
dns_zone_getserialupdatemethod(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->updatemethod;
}

void
dns_zone_getloadtime(dns_zone_t *zone, isc_time_t *loadtime) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(loadtime != NULL);

  LOCK_ZONE(zone);
  *loadtime = zone->loadtime;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getexpiretime(dns_zone_t *zone, isc_time_t *expiretime) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(expiretime != NULL);

  LOCK_ZONE(zone);
  *expiretime = zone->expiretime;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getrefreshtime(dns_zone_t *zone, isc_time_t *refreshtime) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(refreshtime != NULL);

  LOCK_ZONE(zone);
  *refreshtime = zone->refreshtime;
  UNLOCK_ZONE(zone);
}

void
dns_zone_getrefreshkeytime(dns_zone_t *zone, isc_time_t *refreshkeytime) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(refreshkeytime != NULL);

  LOCK_ZONE(zone);
  *refreshkeytime = zone->refreshkeytime;
  UNLOCK_ZONE(zone);
}

void
dns_zone_setstatlevel(dns_zone_t *zone, dns_zonestat_level_t level) {
  REQUIRE(DNS_ZONE_VALID(zone));

  zone->statlevel = level;
}

dns_zonestat_level_t
dns_zone_getstatlevel(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->statlevel;
}

unsigned int
dns_zone_gettid(dns_zone_t *zone) {
  return zone->tid;
}

isc_loop_t *
dns_zone_getloop(dns_zone_t *zone) {
  return zone->loop;
}

isc_result_t
dns_zone_getrad(dns_zone_t *zone, dns_name_t *name) {
  isc_result_t result = ISC_R_NOTFOUND;

  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(DNS_NAME_VALID(name));

  rcu_read_lock();
  dns_rad_t *rad = rcu_dereference(zone->rad);
  if (rad != NULL) {
    dns_name_t *inner = dns_fixedname_name(&rad->fname);
    dns_name_copy(inner, name);
    result = ISC_R_SUCCESS;
  }
  rcu_read_unlock();

  return result;
}

void
dns_zone_setrad(dns_zone_t *zone, dns_name_t *name) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(name == NULL || DNS_NAME_VALID(name));

  rcu_read_lock();
  dns_rad_t *new_rad = NULL;
  if (name != NULL) {
    new_rad = isc_mem_get(zone->mctx, sizeof(*new_rad));
    *new_rad = (dns_rad_t){};
    dns_fixedname_init(&new_rad->fname);

    isc_mem_attach(zone->mctx, &new_rad->mctx);
    dns_name_copy(name, dns_fixedname_name(&new_rad->fname));
  }
  dns_rad_t *xchg_rad = rcu_xchg_pointer(&zone->rad, new_rad);

  if (xchg_rad != NULL) {
    call_rcu(&xchg_rad->rcu_head, free_rad_rcu);
  }
  rcu_read_unlock();
}

void *
dns_zone_gethooktable(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));
  return zone->hooktable;
}

void
dns_zone_sethooktable(dns_zone_t *zone, void *hooktable,
          void (*hooktable_free)(isc_mem_t *, void **)) {
  REQUIRE(DNS_ZONE_VALID(zone));
  REQUIRE(zone->hooktable == NULL);
  REQUIRE(zone->hooktable_free == NULL);

  zone->hooktable = hooktable;
  zone->hooktable_free = hooktable_free;
}

void
dns_zone_setcfg(dns_zone_t *zone, const char *cfg) {
  REQUIRE(DNS_ZONE_VALID(zone));

  if (zone->cfg != NULL) {
    isc_mem_free(zone->mctx, zone->cfg);
  }
  if (cfg != NULL) {
    zone->cfg = isc_mem_strdup(zone->mctx, cfg);
  }
}

const char *
dns_zone_getcfg(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->cfg;
}

/*
 * Get the transport type used for the SOA query to the current primary server
 * before an ongoing incoming zone transfer.
 *
 * Requires:
 *      The zone is locked by the caller.
 */
static dns_transport_type_t
get_request_transport_type(dns_zone_t *zone) {
  dns_transport_type_t transport_type = DNS_TRANSPORT_NONE;

  if (zone->transport != NULL) {
    transport_type = dns_transport_get_type(zone->transport);
  } else {
    transport_type = (DNS_ZONE_FLAG(zone, DNS_ZONEFLG_USEVC))
           ? DNS_TRANSPORT_TCP
           : DNS_TRANSPORT_UDP;

    /* Check if the peer is forced to always use TCP. */
    if (transport_type != DNS_TRANSPORT_TCP &&
        !dns_remote_done(&zone->primaries))
    {
      isc_result_t result;
      isc_sockaddr_t primaryaddr;
      isc_netaddr_t primaryip;
      dns_peer_t *peer = NULL;

      primaryaddr = dns_remote_curraddr(&zone->primaries);
      isc_netaddr_fromsockaddr(&primaryip, &primaryaddr);
      result = dns_peerlist_peerbyaddr(zone->view->peers,
               &primaryip, &peer);
      if (result == ISC_R_SUCCESS && peer != NULL) {
        bool usetcp;
        result = dns_peer_getforcetcp(peer, &usetcp);
        if (result == ISC_R_SUCCESS && usetcp) {
          transport_type = DNS_TRANSPORT_TCP;
        }
      }
    }
  }

  return transport_type;
}

dns_transport_type_t
dns_zone_getrequesttransporttype(dns_zone_t *zone) {
  dns_transport_type_t transport_type;

  REQUIRE(DNS_ZONE_VALID(zone));

  LOCK_ZONE(zone);
  transport_type = get_request_transport_type(zone);
  UNLOCK_ZONE(zone);

  return transport_type;
}

dns_keystorelist_t *
dns_zone_getkeystores(dns_zone_t *zone) {
  return zone->zmgr->keystores;
}

isc_stats_t *
dns_zone_getgluecachestats(dns_zone_t *zone) {
  REQUIRE(DNS_ZONE_VALID(zone));

  return zone->gluecachestats;
}

Coverage Report

Created: 2026-07-16 07:04