/src/bind9/lib/dns/notify.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/netmgr.h>
#include <isc/ratelimiter.h>
#include <isc/result.h>

#include <dns/adb.h>
#include <dns/notify.h>
#include <dns/peer.h>
#include <dns/rcode.h>
#include <dns/rdatalist.h>
#include <dns/request.h>
#include <dns/stats.h>
#include <dns/tsig.h>
#include <dns/zone.h>

#include "zone_p.h"

static void
notify_log(dns_notify_t *notify, int level, const char *fmt, ...) {
  va_list ap;

  va_start(ap, fmt);
  dns_zone_logv(notify->zone, DNS_LOGCATEGORY_NOTIFY, level, NULL, fmt,
          ap);
  va_end(ap);
}

void
dns_notifyctx_init(dns_notifyctx_t *nctx, dns_rdatatype_t type) {
  dns_notifyctx_t ctx = {
    .type = type,
    .notifytype = dns_notifytype_yes,
    .notifydelay = 5,
    .notifies = ISC_LIST_INITIALIZER,
  };
  isc_sockaddr_any(&ctx.notifysrc4);
  isc_sockaddr_any6(&ctx.notifysrc6);

  *nctx = ctx;
}

void
dns_notify_create(isc_mem_t *mctx, dns_rdatatype_t type, in_port_t port,
      unsigned int flags, dns_notify_t **notifyp) {
  dns_notify_t *notify;

  REQUIRE(notifyp != NULL && *notifyp == NULL);

  notify = isc_mem_get(mctx, sizeof(*notify));
  *notify = (dns_notify_t){
    .flags = flags,
    .port = port,
    .type = type,
  };

  isc_mem_attach(mctx, &notify->mctx);
  isc_sockaddr_any(&notify->src);
  isc_sockaddr_any(&notify->dst);
  dns_name_init(&notify->ns);
  ISC_LINK_INIT(notify, link);
  notify->magic = NOTIFY_MAGIC;
  *notifyp = notify;
}

void
dns_notify_destroy(dns_notify_t *notify, bool locked) {
  REQUIRE(DNS_NOTIFY_VALID(notify));

  isc_mem_t *mctx;
  dns_notifyctx_t *nctx;

  if (notify->zone != NULL) {
    if (!locked) {
      dns__zone_lock(notify->zone);
    }
    REQUIRE(dns__zone_locked(notify->zone));
    nctx = dns__zone_getnotifyctx(notify->zone, notify->type);
    if (ISC_LINK_LINKED(notify, link)) {
      ISC_LIST_UNLINK(nctx->notifies, notify, link);
    }
    if (!locked) {
      dns__zone_unlock(notify->zone);
    }
    if (locked) {
      dns__zone_idetach_locked(&notify->zone);
    } else {
      dns_zone_idetach(&notify->zone);
    }
  }
  if (notify->find != NULL) {
    dns_adb_destroyfind(&notify->find);
  }
  if (notify->request != NULL) {
    dns_request_destroy(&notify->request);
  }
  if (dns_name_dynamic(&notify->ns)) {
    dns_name_free(&notify->ns, notify->mctx);
  }
  if (notify->key != NULL) {
    dns_tsigkey_detach(&notify->key);
  }
  if (notify->transport != NULL) {
    dns_transport_detach(&notify->transport);
  }
  mctx = notify->mctx;
  isc_mem_put(notify->mctx, notify, sizeof(*notify));
  isc_mem_detach(&mctx);
}

static void
notify_done(void *arg) {
  dns_request_t *request = (dns_request_t *)arg;
  dns_notify_t *notify = dns_request_getarg(request);
  isc_result_t result;
  dns_message_t *message = NULL;
  isc_buffer_t buf;
  char rcode[128];
  char addrbuf[ISC_SOCKADDR_FORMATSIZE];
  char typebuf[DNS_RDATATYPE_FORMATSIZE];

  REQUIRE(DNS_NOTIFY_VALID(notify));

  isc_buffer_init(&buf, rcode, sizeof(rcode));
  isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));

  dns_rdatatype_format(notify->type, typebuf, sizeof(typebuf));

  /* WMM: This is changing the mctx from zone to notify. */
  dns_message_create(notify->mctx, NULL, NULL, DNS_MESSAGE_INTENTPARSE,
         &message);

  result = dns_request_getresult(request);
  if (result != ISC_R_SUCCESS) {
    goto fail;
  }

  result = dns_request_getresponse(request, message,
           DNS_MESSAGEPARSE_PRESERVEORDER);
  if (result != ISC_R_SUCCESS) {
    goto fail;
  }

  result = dns_rcode_totext(message->rcode, &buf);
  if (result == ISC_R_SUCCESS) {
    notify_log(notify, ISC_LOG_DEBUG(3),
         "notify(%s) response from %s: %.*s", typebuf,
         addrbuf, (int)buf.used, rcode);
  }
fail:
  dns_message_detach(&message);

  if (result == ISC_R_SUCCESS) {
    notify_log(notify, ISC_LOG_DEBUG(1),
         "notify(%s) to %s successful", typebuf, addrbuf);
  } else if (result == ISC_R_SHUTTINGDOWN || result == ISC_R_CANCELED) {
    /* just destroy the notify */
  } else if ((notify->flags & DNS_NOTIFY_TCP) == 0) {
    notify_log(notify, ISC_LOG_NOTICE,
         "notify(%s) to %s failed: %s: retrying over TCP",
         typebuf, addrbuf, isc_result_totext(result));
    notify->flags |= DNS_NOTIFY_TCP;
    dns_request_destroy(&notify->request);
    dns_notify_queue(notify, notify->flags & DNS_NOTIFY_STARTUP);
    return;
  } else if (result == ISC_R_TIMEDOUT) {
    notify_log(notify, ISC_LOG_WARNING,
         "notify(%s) to %s failed: %s: retries exceeded",
         typebuf, addrbuf, isc_result_totext(result));
  } else {
    notify_log(notify, ISC_LOG_WARNING,
         "notify(%s) to %s failed: %s", typebuf, addrbuf,
         isc_result_totext(result));
  }
  dns_notify_destroy(notify, false);
}

static isc_result_t
notify_createmessage(dns_notify_t *notify, dns_message_t **messagep) {
  dns_db_t *zonedb = NULL;
  dns_dbnode_t *node = NULL;
  dns_dbversion_t *version = NULL;
  dns_message_t *message = NULL;
  dns_rdataset_t rdataset;
  dns_rdata_t rdata = DNS_RDATA_INIT;

  dns_name_t *tempname = NULL;
  dns_rdata_t *temprdata = NULL;
  dns_rdatalist_t *temprdatalist = NULL;
  dns_rdataset_t *temprdataset = NULL;

  isc_result_t result;
  isc_region_t r;
  isc_buffer_t *b = NULL;

  REQUIRE(DNS_NOTIFY_VALID(notify));
  REQUIRE(messagep != NULL && *messagep == NULL);

  /* WMM: This is changing the mctx from zone to notify. */
  dns_message_create(notify->mctx, NULL, NULL, DNS_MESSAGE_INTENTRENDER,
         &message);

  message->opcode = dns_opcode_notify;
  message->flags |= DNS_MESSAGEFLAG_AA;
  message->rdclass = dns_zone_getrdclass(notify->zone);

  dns_message_gettempname(message, &tempname);
  dns_message_gettemprdataset(message, &temprdataset);

  /*
   * Make question.
   */
  dns_name_clone(dns_zone_getorigin(notify->zone), tempname);
  dns_rdataset_makequestion(temprdataset,
          dns_zone_getrdclass(notify->zone),
          dns_rdatatype_soa);
  ISC_LIST_APPEND(tempname->list, temprdataset, link);
  dns_message_addname(message, tempname, DNS_SECTION_QUESTION);
  tempname = NULL;
  temprdataset = NULL;

  if ((notify->flags & DNS_NOTIFY_NOSOA) != 0) {
    goto done;
  }

  dns_message_gettempname(message, &tempname);
  dns_message_gettemprdata(message, &temprdata);
  dns_message_gettemprdataset(message, &temprdataset);
  dns_message_gettemprdatalist(message, &temprdatalist);

  result = dns_zone_getdb(notify->zone, &zonedb);
  INSIST(result == ISC_R_SUCCESS);
  INSIST(zonedb != NULL); /* XXXJT: is this assumption correct? */

  dns_name_clone(dns_zone_getorigin(notify->zone), tempname);
  dns_db_currentversion(zonedb, &version);
  result = dns_db_findnode(zonedb, tempname, false, &node);
  if (result != ISC_R_SUCCESS) {
    goto soa_cleanup;
  }

  dns_rdataset_init(&rdataset);
  result = dns_db_findrdataset(zonedb, node, version, dns_rdatatype_soa,
             dns_rdatatype_none, 0, &rdataset, NULL);
  if (result != ISC_R_SUCCESS) {
    goto soa_cleanup;
  }
  result = dns_rdataset_first(&rdataset);
  if (result != ISC_R_SUCCESS) {
    goto soa_cleanup;
  }
  dns_rdataset_current(&rdataset, &rdata);
  dns_rdata_toregion(&rdata, &r);
  /* WMM: This is changing the mctx from zone to notify. */
  isc_buffer_allocate(notify->mctx, &b, r.length);
  isc_buffer_putmem(b, r.base, r.length);
  isc_buffer_usedregion(b, &r);
  dns_rdata_fromregion(temprdata, rdata.rdclass, rdata.type, &r);
  dns_message_takebuffer(message, &b);
  result = dns_rdataset_next(&rdataset);
  dns_rdataset_disassociate(&rdataset);
  if (result != ISC_R_NOMORE) {
    goto soa_cleanup;
  }
  temprdatalist->rdclass = rdata.rdclass;
  temprdatalist->type = rdata.type;
  temprdatalist->ttl = rdataset.ttl;
  ISC_LIST_APPEND(temprdatalist->rdata, temprdata, link);

  dns_rdatalist_tordataset(temprdatalist, temprdataset);

  ISC_LIST_APPEND(tempname->list, temprdataset, link);
  dns_message_addname(message, tempname, DNS_SECTION_ANSWER);
  temprdatalist = NULL;
  temprdataset = NULL;
  temprdata = NULL;
  tempname = NULL;

soa_cleanup:
  if (node != NULL) {
    dns_db_detachnode(&node);
  }
  if (version != NULL) {
    dns_db_closeversion(zonedb, &version, false);
  }
  if (zonedb != NULL) {
    dns_db_detach(&zonedb);
  }
  if (tempname != NULL) {
    dns_message_puttempname(message, &tempname);
  }
  if (temprdata != NULL) {
    dns_message_puttemprdata(message, &temprdata);
  }
  if (temprdataset != NULL) {
    dns_message_puttemprdataset(message, &temprdataset);
  }
  if (temprdatalist != NULL) {
    dns_message_puttemprdatalist(message, &temprdatalist);
  }

done:
  *messagep = message;
  return ISC_R_SUCCESS;
}

static void
notify_send_toaddr(void *arg) {
  dns_notify_t *notify = (dns_notify_t *)arg;
  dns_notifyctx_t *notifyctx = NULL;
  isc_result_t result;
  dns_db_t *zonedb = NULL;
  dns_view_t *view = NULL;
  isc_loop_t *loop = NULL;
  dns_zonemgr_t *zmgr = NULL;
  dns_message_t *message = NULL;
  isc_netaddr_t dstip;
  dns_tsigkey_t *key = NULL;
  char addrbuf[ISC_SOCKADDR_FORMATSIZE];
  char typebuf[DNS_RDATATYPE_FORMATSIZE];
  isc_sockaddr_t src;
  unsigned int options;
  bool have_notifysource = false;
  isc_tlsctx_cache_t *zmgr_tlsctx_cache = NULL;

  REQUIRE(DNS_NOTIFY_VALID(notify));

  dns__zone_lock(notify->zone);

  notifyctx = dns__zone_getnotifyctx(notify->zone, notify->type);
  zmgr = dns_zone_getmgr(notify->zone);
  view = dns_zone_getview(notify->zone);
  loop = dns_zone_getloop(notify->zone);
  result = dns_zone_getdb(notify->zone, &zonedb);

  isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));

  dns_rdatatype_format(notify->type, typebuf, sizeof(typebuf));

  if (!dns__zone_loaded(notify->zone) || notify->rlevent->canceled ||
      dns__zone_exiting(notify->zone) || zmgr == NULL || view == NULL ||
      view->requestmgr == NULL || loop == NULL || zonedb == NULL ||
      result != ISC_R_SUCCESS)
  {
    result = ISC_R_CANCELED;
    goto cleanup;
  }

  /*
   * The raw IPv4 address should also exist.  Don't send to the
   * mapped form.
   */
  if (isc_sockaddr_pf(&notify->dst) == PF_INET6 &&
      IN6_IS_ADDR_V4MAPPED(&notify->dst.type.sin6.sin6_addr))
  {
    notify_log(notify, ISC_LOG_DEBUG(3),
         "notify(%s): ignoring IPv6 mapped IPV4 address: %s",
         typebuf, addrbuf);
    result = ISC_R_CANCELED;
    goto cleanup;
  }

  CHECK(notify_createmessage(notify, &message));

  if (notify->key != NULL) {
    /* Transfer ownership of key */
    key = notify->key;
    notify->key = NULL;
  } else {
    isc_netaddr_fromsockaddr(&dstip, &notify->dst);
    result = dns_view_getpeertsig(view, &dstip, &key);
    if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
      notify_log(notify, ISC_LOG_ERROR,
           "NOTIFY(%s) to %s not sent. "
           "Peer TSIG key lookup failure.",
           typebuf, addrbuf);
      goto cleanup_message;
    }
  }

  if (key != NULL) {
    char namebuf[DNS_NAME_FORMATSIZE];

    dns_name_format(key->name, namebuf, sizeof(namebuf));
    notify_log(notify, ISC_LOG_INFO,
         "sending notify(%s) to %s : TSIG (%s)", typebuf,
         addrbuf, namebuf);
  } else {
    notify_log(notify, ISC_LOG_INFO, "sending notify(%s) to %s",
         typebuf, addrbuf);
  }
  options = 0;
  if (view->peers != NULL) {
    dns_peer_t *peer = NULL;
    bool usetcp = false;
    result = dns_peerlist_peerbyaddr(view->peers, &dstip, &peer);
    if (result == ISC_R_SUCCESS) {
      result = dns_peer_getnotifysource(peer, &src);
      if (result == ISC_R_SUCCESS) {
        have_notifysource = true;
      }
      result = dns_peer_getforcetcp(peer, &usetcp);
      if (result == ISC_R_SUCCESS && usetcp) {
        options |= DNS_FETCHOPT_TCP;
      }
    }
  }
  switch (isc_sockaddr_pf(&notify->dst)) {
  case PF_INET:
    if (!have_notifysource) {
      isc_sockaddr_t any;
      isc_sockaddr_any(&any);

      src = notify->src;
      if (isc_sockaddr_equal(&src, &any)) {
        src = notifyctx->notifysrc4;
      }
    }
    break;
  case PF_INET6:
    if (!have_notifysource) {
      isc_sockaddr_t any;
      isc_sockaddr_any6(&any);

      src = notify->src;
      if (isc_sockaddr_equal(&src, &any)) {
        src = notifyctx->notifysrc6;
      }
    }
    break;
  default:
    result = ISC_R_NOTIMPLEMENTED;
    goto cleanup_key;
  }

again:
  if ((notify->flags & DNS_NOTIFY_TCP) != 0) {
    options |= DNS_REQUESTOPT_TCP;
  }

  dns__zonemgr_tlsctx_attach(zmgr, &zmgr_tlsctx_cache);

  const unsigned int connect_timeout = isc_nm_getinitialtimeout() /
               MS_PER_SEC;
  result = dns_request_create(
    view->requestmgr, message, &src, &notify->dst,
    notify->transport, zmgr_tlsctx_cache, options, key,
    connect_timeout, TCP_REQUEST_TIMEOUT, UDP_REQUEST_TIMEOUT,
    UDP_REQUEST_RETRIES, loop, notify_done, notify,
    &notify->request);

  isc_tlsctx_cache_detach(&zmgr_tlsctx_cache);

  switch (result) {
  case ISC_R_SUCCESS:
    if (isc_sockaddr_pf(&notify->dst) == AF_INET) {
      dns__zone_stats_increment(
        notify->zone, dns_zonestatscounter_notifyoutv4);
    } else {
      dns__zone_stats_increment(
        notify->zone, dns_zonestatscounter_notifyoutv6);
    }
    break;
  case ISC_R_SHUTTINGDOWN:
  case ISC_R_CANCELED:
  case ISC_R_ADDRNOTAVAIL:
  case DNS_R_BLACKHOLED:
  case ISC_R_FAMILYNOSUPPORT:
    notify_log(notify, ISC_LOG_NOTICE,
         "notify(%s) to %s failed: %s", typebuf, addrbuf,
         isc_result_totext(result));
    break;
  default:
    if ((notify->flags & DNS_NOTIFY_TCP) == 0) {
      notify_log(notify, ISC_LOG_NOTICE,
           "notify(%s) to %s failed: %s: retrying over "
           "TCP",
           typebuf, addrbuf, isc_result_totext(result));
      notify->flags |= DNS_NOTIFY_TCP;
      goto again;
    }
  }

cleanup_key:
  if (key != NULL) {
    dns_tsigkey_detach(&key);
  }
cleanup_message:
  dns_message_detach(&message);
cleanup:
  dns__zone_unlock(notify->zone);

  if (zonedb != NULL) {
    dns_db_detach(&zonedb);
  }

  if (notify->rlevent != NULL) {
    isc_rlevent_free(&notify->rlevent);
  }

  if (result != ISC_R_SUCCESS) {
    isc_sockaddr_format(&notify->dst, addrbuf, sizeof(addrbuf));
    notify_log(notify, ISC_LOG_WARNING,
         "notify(%s) to %s failed: %s", typebuf, addrbuf,
         isc_result_totext(result));
    dns_notify_destroy(notify, false);
  }
}

static isc_result_t
notify_queue(dns_notify_t *notify, bool startup, bool dequeue) {
  REQUIRE(DNS_NOTIFY_VALID(notify));

  isc_loop_t *loop = dns_zone_getloop(notify->zone);
  dns_zonemgr_t *zmgr = dns_zone_getmgr(notify->zone);
  isc_ratelimiter_t *notifyrl = NULL;
  isc_ratelimiter_t *startupnotifyrl = NULL;

  INSIST(loop != NULL);
  INSIST(zmgr != NULL);

  dns__zonemgr_getnotifyrl(zmgr, &notifyrl);
  dns__zonemgr_getstartupnotifyrl(zmgr, &startupnotifyrl);

  if (dequeue) {
    return isc_ratelimiter_dequeue(
      startup ? startupnotifyrl : notifyrl, &notify->rlevent);
  }

  return isc_ratelimiter_enqueue(startup ? startupnotifyrl : notifyrl,
               loop, notify_send_toaddr, notify,
               &notify->rlevent);
}

isc_result_t
dns_notify_queue(dns_notify_t *notify, bool startup) {
  return notify_queue(notify, startup, false);
}

bool
dns_notify_isqueued(dns_notifyctx_t *nctx, dns_rdatatype_t type, in_port_t port,
        unsigned int flags, dns_name_t *name, isc_sockaddr_t *addr,
        dns_tsigkey_t *key, dns_transport_t *transport) {
  dns_notify_t *notify = NULL;
  isc_result_t result;

  REQUIRE(nctx != NULL);

  ISC_LIST_FOREACH(nctx->notifies, n, link) {
    if (n->request != NULL) {
      continue;
    }
    if (n->type != type) {
      continue;
    }
    if ((name != NULL && dns_name_dynamic(&n->ns) &&
         dns_name_equal(name, &n->ns)) ||
        (addr != NULL && isc_sockaddr_equal(addr, &n->dst) &&
         n->port == port && n->key == key &&
         n->transport == transport))
    {
      notify = n;
      goto requeue;
    }
  }
  return false;
requeue:
  /*
   * If we are enqueued on the startup ratelimiter and this is
   * not a startup notify, re-enqueue on the normal notify
   * ratelimiter.
   */
  if (notify->rlevent != NULL && (flags & DNS_NOTIFY_STARTUP) == 0 &&
      (notify->flags & DNS_NOTIFY_STARTUP) != 0)
  {
    result = notify_queue(notify, true, true);
    if (result != ISC_R_SUCCESS) {
      return true;
    }

    notify->flags &= ~DNS_NOTIFY_STARTUP;
    result = notify_queue(notify, false, false);
    if (result != ISC_R_SUCCESS) {
      return false;
    }
  }

  return true;
}

static bool
notify_isself(dns_notify_t *notify, isc_sockaddr_t *dst) {
  dns_tsigkey_t *key = NULL;
  isc_sockaddr_t src;
  isc_sockaddr_t any;
  bool isself;
  isc_netaddr_t dstaddr;
  isc_result_t result;
  dns_notifyctx_t *notifyctx = NULL;
  dns_view_t *view = NULL;
  dns_isselffunc_t isselffunc;
  void *isselfarg = NULL;

  notifyctx = dns__zone_getnotifyctx(notify->zone, notify->type);
  view = dns_zone_getview(notify->zone);
  dns__zone_getisself(notify->zone, &isselffunc, &isselfarg);
  if (view == NULL || isselffunc == NULL) {
    return false;
  }

  switch (isc_sockaddr_pf(dst)) {
  case PF_INET:
    src = notifyctx->notifysrc4;
    isc_sockaddr_any(&any);
    break;
  case PF_INET6:
    src = notifyctx->notifysrc6;
    isc_sockaddr_any6(&any);
    break;
  default:
    return false;
  }

  /*
   * When sending from any the kernel will assign a source address
   * that matches the destination address.
   */
  if (isc_sockaddr_eqaddr(&any, &src)) {
    src = *dst;
  }

  isc_netaddr_fromsockaddr(&dstaddr, dst);
  result = dns_view_getpeertsig(view, &dstaddr, &key);
  if (result != ISC_R_SUCCESS && result != ISC_R_NOTFOUND) {
    return false;
  }
  isself = (isselffunc)(view, key, &src, dst,
            dns_zone_getrdclass(notify->zone), isselfarg);
  if (key != NULL) {
    dns_tsigkey_detach(&key);
  }
  return isself;
}

static void
notify_send(dns_notify_t *notify) {
  isc_sockaddr_t dst;
  isc_result_t result;
  dns_notify_t *newnotify = NULL;
  dns_notifyctx_t *notifyctx = NULL;
  unsigned int flags;
  bool startup;

  /*
   * Zone lock held by caller.
   */
  REQUIRE(DNS_NOTIFY_VALID(notify));
  REQUIRE(dns__zone_locked(notify->zone));
  if (dns__zone_exiting(notify->zone)) {
    return;
  }
  notifyctx = dns__zone_getnotifyctx(notify->zone, notify->type);

  ISC_LIST_FOREACH(notify->find->list, ai, publink) {
    dst = ai->sockaddr;
    if (dns_notify_isqueued(notifyctx, notify->type, notify->port,
          notify->flags, NULL, &dst, NULL, NULL))
    {
      continue;
    }
    if (notify_isself(notify, &dst)) {
      continue;
    }
    newnotify = NULL;
    flags = notify->flags & DNS_NOTIFY_NOSOA;
    dns_notify_create(notify->mctx, notify->type, notify->port,
          flags, &newnotify);
    dns__zone_iattach_locked(notify->zone, &newnotify->zone);
    ISC_LIST_APPEND(notifyctx->notifies, newnotify, link);
    newnotify->dst = dst;
    if (isc_sockaddr_pf(&dst) == AF_INET6) {
      isc_sockaddr_any6(&newnotify->src);
    }
    startup = ((notify->flags & DNS_NOTIFY_STARTUP) != 0);
    CHECK(dns_notify_queue(newnotify, startup));
    newnotify = NULL;
  }

cleanup:
  if (newnotify != NULL) {
    dns_notify_destroy(newnotify, true);
  }
}

/*
 * XXXAG should check for DNS_ZONEFLG_EXITING
 */
static void
process_notify_adb_event(void *arg) {
  dns_adbfind_t *find = (dns_adbfind_t *)arg;
  dns_notify_t *notify = (dns_notify_t *)find->cbarg;
  dns_adbstatus_t astat = find->status;

  REQUIRE(DNS_NOTIFY_VALID(notify));
  REQUIRE(find == notify->find);

  switch (astat) {
  case DNS_ADB_MOREADDRESSES:
    dns_adb_destroyfind(&notify->find);
    dns_notify_find_address(notify);
    return;

  case DNS_ADB_NOMOREADDRESSES:
    dns__zone_lock(notify->zone);
    notify_send(notify);
    dns__zone_unlock(notify->zone);
    break;

  default:
    break;
  }

  dns_notify_destroy(notify, false);
}

void
dns_notify_find_address(dns_notify_t *notify) {
  isc_result_t result;
  unsigned int options;
  dns_adb_t *adb = NULL;
  dns_view_t *view = NULL;
  isc_loop_t *loop = NULL;

  REQUIRE(DNS_NOTIFY_VALID(notify));

  options = DNS_ADBFIND_WANTEVENT;
  if (isc_net_probeipv4() != ISC_R_DISABLED) {
    options |= DNS_ADBFIND_INET;
  }
  if (isc_net_probeipv6() != ISC_R_DISABLED) {
    options |= DNS_ADBFIND_INET6;
  }

  loop = dns_zone_getloop(notify->zone);
  view = dns_zone_getview(notify->zone);
  dns_view_getadb(view, &adb);
  if (loop == NULL || view == NULL || adb == NULL) {
    goto destroy;
  }

  result = dns_adb_createfind(adb, loop, process_notify_adb_event, notify,
            &notify->ns, options, 0, notify->port, 0,
            NULL, NULL, NULL, &notify->find);
  dns_adb_detach(&adb);

  /* Something failed? */
  if (result != ISC_R_SUCCESS) {
    goto destroy;
  }

  /* More addresses pending? */
  if ((notify->find->options & DNS_ADBFIND_WANTEVENT) != 0) {
    return;
  }

  /* We have as many addresses as we can get. */
  dns__zone_lock(notify->zone);
  notify_send(notify);
  dns__zone_unlock(notify->zone);
destroy:
  dns_notify_destroy(notify, false);
}

void
dns_notify_cancel(dns_notifyctx_t *nctx) {
  ISC_LIST_FOREACH(nctx->notifies, notify, link) {
    INSIST(dns__zone_locked(notify->zone));
    if (notify->find != NULL) {
      dns_adb_cancelfind(notify->find);
    }
    if (notify->request != NULL) {
      dns_request_cancel(notify->request);
    }
  }
}

Coverage Report

Created: 2026-02-26 06:45