Lines Matching defs:adb
1 /* $NetBSD: adb.c,v 1.16 2026/01/29 18:37:48 christos Exp $ */
38 #include <dns/adb.h>
77 * The period in seconds after which an ADB name entry is regarded as stale
94 /*% dns adb structure */
131 * up via the adb->names hash table. It holds references to fetches
139 dns_adb_t *adb;
205 * up via the adb->entries hash table. Also, each dns_adbnamehook and
215 dns_adb_t *adb;
273 new_adbname(dns_adb_t *adb, const dns_name_t *, unsigned int type);
281 new_adbnamehook(dns_adb_t *adb);
283 free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehookp);
285 new_adbentry(dns_adb_t *adb, const isc_sockaddr_t *addr, isc_stdtime_t now);
301 purge_stale_names(dns_adb_t *adb, isc_stdtime_t now);
303 purge_names_overmem(dns_adb_t *adb, size_t requested);
308 purge_stale_entries(dns_adb_t *adb, isc_stdtime_t now);
310 purge_entries_overmem(dns_adb_t *adb, size_t requested);
312 get_attached_and_locked_entry(dns_adb_t *adb, isc_stdtime_t now,
317 print_namehook_list(FILE *, const char *legend, dns_adb_t *adb,
495 inc_resstats(dns_adb_t *adb, isc_statscounter_t counter) {
496 if (adb->res != NULL) {
497 dns_resolver_incstats(adb->res, counter);
502 * Set adb-related statistics counters.
505 set_adbstat(dns_adb_t *adb, uint64_t val, isc_statscounter_t counter) {
506 if (adb->stats != NULL) {
507 isc_stats_set(adb->stats, val, counter);
512 dec_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
513 if (adb->stats != NULL) {
514 isc_stats_decrement(adb->stats, counter);
519 inc_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
520 if (adb->stats != NULL) {
521 isc_stats_increment(adb->stats, counter);
546 dns_adb_t *adb = NULL;
551 adb = adbname->adb;
553 REQUIRE(DNS_ADB_VALID(adb));
601 entry = get_attached_and_locked_entry(adb, now, &sockaddr);
613 nh = new_adbnamehook(adb);
660 dns_adb_t *adb = adbname->adb;
662 REQUIRE(DNS_ADB_VALID(adb));
672 clean_namehooks(adb, &adbname->v4);
673 clean_namehooks(adb, &adbname->v6);
674 clean_target(adb, &adbname->target);
689 result = isc_hashmap_delete(adb->names, hash_adbname(adbname),
693 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
704 REQUIRE(DNS_ADB_VALID(adbname->adb));
706 dns_adb_t *adb = adbname->adb;
714 clean_namehooks(adb, &adbname->v4);
727 clean_namehooks(adb, &adbname->v6);
738 clean_target(adb, &adbname->target);
744 shutdown_names(dns_adb_t *adb) {
747 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
748 for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
764 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
768 shutdown_entries(dns_adb_t *adb) {
770 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
771 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
777 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
784 clean_namehooks(dns_adb_t *adb, dns_adbnamehooklist_t *namehooks) {
805 free_adbnamehook(adb, &namehook);
812 clean_target(dns_adb_t *adb, dns_name_t *target) {
814 dns_name_free(target, adb->mctx);
820 set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
842 dns_name_dup(&cname.cname, adb->mctx, target);
881 dns_name_dup(new_target, adb->mctx, target);
959 new_adbname(dns_adb_t *adb, const dns_name_t *dnsname, unsigned int type) {
962 name = isc_mem_get(adb->mctx, sizeof(*name));
964 .adb = dns_adb_ref(adb),
990 inc_adbstats(adb, dns_adbstats_namescnt);
1004 dns_adb_t *adb = name->adb;
1016 isc_mem_put(adb->mctx, name, sizeof(*name));
1018 dec_adbstats(adb, dns_adbstats_namescnt);
1019 dns_adb_detach(&adb);
1023 new_adbnamehook(dns_adb_t *adb) {
1024 dns_adbnamehook_t *nh = isc_mem_get(adb->mctx, sizeof(*nh));
1035 free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
1049 isc_mem_put(adb->mctx, nh, sizeof(*nh));
1053 new_adbentry(dns_adb_t *adb, const isc_sockaddr_t *addr, isc_stdtime_t now) {
1056 entry = isc_mem_get(adb->mctx, sizeof(*entry));
1061 .quota = adb->quota,
1063 .adb = dns_adb_ref(adb),
1074 inc_adbstats(adb, dns_adbstats_entriescnt);
1083 dns_adb_t *adb = entry->adb;
1096 isc_mem_put(adb->mctx, entry->cookie, entry->cookielen);
1100 isc_mem_put(adb->mctx, entry, sizeof(*entry));
1102 dec_adbstats(adb, dns_adbstats_entriescnt);
1104 dns_adb_detach(&adb);
1114 new_adbfind(dns_adb_t *adb, in_port_t port) {
1117 find = isc_mem_get(adb->hmctx, sizeof(*find));
1127 dns_adb_attach(adb, &find->adb);
1137 dns_adb_t *adb = NULL;
1145 adb = find->adb;
1156 isc_mem_put(adb->hmctx, find, sizeof(*find));
1157 dns_adb_detach(&adb);
1161 new_adbfetch(dns_adb_t *adb) {
1164 fetch = isc_mem_get(adb->hmctx, sizeof(*fetch));
1174 free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetchp) {
1188 isc_mem_put(adb->hmctx, fetch, sizeof(*fetch));
1196 new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry, in_port_t port) {
1199 ai = isc_mem_get(adb->hmctx, sizeof(*ai));
1215 free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
1232 isc_mem_put(adb->hmctx, ai, sizeof(*ai));
1262 get_attached_and_locked_name(dns_adb_t *adb, const dns_name_t *name,
1274 bool overmem = isc_mem_isovermem(adb->mctx);
1278 RWLOCK(&adb->names_lock, locktype);
1279 last_update = adb->names_last_update;
1283 UPGRADELOCK(&adb->names_lock, locktype);
1285 purge_names_overmem(adb, 2 * sizeof(*adbname));
1287 purge_stale_names(adb, now);
1289 adb->names_last_update = last_update;
1292 result = isc_hashmap_find(adb->names, hashval, match_adbname,
1296 UPGRADELOCK(&adb->names_lock, locktype);
1299 adbname = new_adbname(adb, name, key.type);
1302 result = isc_hashmap_add(adb->names, hashval, match_adbname,
1308 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1315 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1329 ISC_LIST_PREPEND(adb->names_lru, adbname, link);
1337 RWUNLOCK(&adb->names_lock, locktype);
1350 * Find the entry in the adb->entries hashtable.
1353 get_attached_and_locked_entry(dns_adb_t *adb, isc_stdtime_t now,
1361 bool overmem = isc_mem_isovermem(adb->mctx);
1365 RWLOCK(&adb->entries_lock, locktype);
1366 last_update = adb->entries_last_update;
1371 UPGRADELOCK(&adb->entries_lock, locktype);
1373 purge_entries_overmem(adb, 2 * sizeof(*adbentry));
1375 purge_stale_entries(adb, now);
1377 adb->entries_last_update = now;
1380 result = isc_hashmap_find(adb->entries, hashval, match_adbentry,
1384 UPGRADELOCK(&adb->entries_lock, locktype);
1390 adbentry = new_adbentry(adb, addr, now);
1393 result = isc_hashmap_add(adb->entries, hashval, match_adbentry,
1396 ISC_LIST_PREPEND(adb->entries_lru, adbentry, link);
1407 * the ADB entry, so it is not destroyed under the lock.
1419 UPGRADELOCK(&adb->entries_lock, locktype);
1437 ISC_LIST_UNLINK(adb->entries_lru, adbentry, link);
1438 ISC_LIST_PREPEND(adb->entries_lru, adbentry, link);
1442 RWUNLOCK(&adb->entries_lock, locktype);
1463 "adb: quota %s (%" PRIuFAST32 "/%" PRIuFAST32 "): %s",
1469 copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_adbname_t *name) {
1486 addrinfo = new_adbaddrinfo(adb, entry, find->port);
1510 addrinfo = new_adbaddrinfo(adb, entry, find->port);
1523 * The name must be locked and write lock on adb->names_lock must be held.
1553 dns_adb_t *adb = adbentry->adb;
1559 adb->entries,
1563 ISC_LIST_UNLINK(adb->entries_lru, adbentry, link);
1596 * (unused for some period); if so, the name entry will be freed. If the ADB
1602 * adb->names_lock MUST be write locked
1605 purge_stale_names(dns_adb_t *adb, isc_stdtime_t now) {
1606 dns_adbname_t *adbname = ISC_LIST_TAIL(adb->names_lru);
1626 purge_names_overmem(dns_adb_t *adb, size_t requested) {
1630 for (dns_adbname_t *adbname = ISC_LIST_TAIL(adb->names_lru);
1651 cleanup_names(dns_adb_t *adb, isc_stdtime_t now) {
1654 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
1655 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
1673 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
1678 * (unused for some period); if so, the name entry will be freed. If the ADB
1684 * adb->entries_lock MUST be write locked
1687 purge_stale_entries(dns_adb_t *adb, isc_stdtime_t now) {
1688 dns_adbentry_t *adbentry = ISC_LIST_TAIL(adb->entries_lru);
1707 purge_entries_overmem(dns_adb_t *adb, size_t requested) {
1718 for (dns_adbentry_t *adbentry = ISC_LIST_TAIL(adb->entries_lru);
1735 cleanup_entries(dns_adb_t *adb, isc_stdtime_t now) {
1738 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
1739 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
1750 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
1754 destroy(dns_adb_t *adb) {
1755 DP(DEF_LEVEL, "destroying ADB %p", adb);
1757 adb->magic = 0;
1759 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
1760 INSIST(isc_hashmap_count(adb->names) == 0);
1761 isc_hashmap_destroy(&adb->names);
1762 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
1763 isc_rwlock_destroy(&adb->names_lock);
1765 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
1767 INSIST(isc_hashmap_count(adb->entries) == 0);
1768 isc_hashmap_destroy(&adb->entries);
1769 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
1770 isc_rwlock_destroy(&adb->entries_lock);
1772 isc_mem_detach(&adb->hmctx);
1774 isc_mutex_destroy(&adb->lock);
1776 isc_stats_detach(&adb->stats);
1777 dns_resolver_detach(&adb->res);
1778 dns_view_weakdetach(&adb->view);
1779 isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
1794 dns_adb_t *adb = NULL;
1800 adb = isc_mem_get(mem, sizeof(dns_adb_t));
1801 *adb = (dns_adb_t){
1812 __FILE__, __LINE__ + 1, adb);
1814 isc_refcount_init(&adb->references, 1);
1815 dns_view_weakattach(view, &adb->view);
1816 dns_resolver_attach(view->resolver, &adb->res);
1817 isc_mem_attach(mem, &adb->mctx);
1819 isc_mem_create(&adb->hmctx);
1820 isc_mem_setname(adb->hmctx, "ADB_dynamic");
1822 isc_hashmap_create(adb->hmctx, ADB_HASH_BITS, &adb->names);
1823 isc_rwlock_init(&adb->names_lock);
1825 isc_hashmap_create(adb->hmctx, ADB_HASH_BITS, &adb->entries);
1826 isc_rwlock_init(&adb->entries_lock);
1828 isc_mutex_init(&adb->lock);
1830 isc_stats_create(adb->mctx, &adb->stats, dns_adbstats_max);
1832 set_adbstat(adb, 0, dns_adbstats_nnames);
1833 set_adbstat(adb, 0, dns_adbstats_nentries);
1838 adb->magic = DNS_ADB_MAGIC;
1839 *newadb = adb;
1843 dns_adb_shutdown(dns_adb_t *adb) {
1844 if (!atomic_compare_exchange_strong(&adb->exiting, &(bool){ false },
1850 DP(DEF_LEVEL, "shutting down ADB %p", adb);
1852 isc_mem_clearwater(adb->mctx);
1854 shutdown_names(adb);
1855 shutdown_entries(adb);
1876 dns_adb_createfind(dns_adb_t *adb, isc_loop_t *loop, isc_job_cb cb, void *cbarg,
1894 REQUIRE(DNS_ADB_VALID(adb));
1905 if (atomic_load(&adb->exiting)) {
1926 find = new_adbfind(adb, port);
1940 adb, name, ADBNAME_TYPE(find->options), now);
2118 copy_namehook_lists(adb, find, adbname);
2204 dns_adb_t *adb = NULL;
2213 adb = find->adb;
2227 free_adbaddrinfo(adb, &ai);
2256 REQUIRE(DNS_ADB_VALID(find->adb));
2306 dns_adb_dump(dns_adb_t *adb, FILE *f) {
2309 REQUIRE(DNS_ADB_VALID(adb));
2312 if (atomic_load(&adb->exiting)) {
2316 cleanup_names(adb, now);
2317 cleanup_entries(adb, now);
2318 dump_adb(adb, f, false, now);
2333 dump_adb(dns_adb_t *adb, FILE *f, bool debug, isc_stdtime_t now) {
2338 fprintf(f, "; addr %p, references %" PRIuFAST32 "\n", adb,
2339 isc_refcount_current(&adb->references));
2345 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
2347 for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
2374 print_namehook_list(f, "v4", adb, &name->v4, debug, now);
2375 print_namehook_list(f, "v6", adb, &name->v6, debug, now);
2384 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
2386 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
2391 dump_entry(f, adb, adbentry, debug, now);
2396 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
2397 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
2401 dump_entry(FILE *f, dns_adb_t *adb, dns_adbentry_t *entry, bool debug,
2432 if (adb != NULL && adb->quota != 0 && adb->atr_freq != 0) {
2496 print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
2508 dump_entry(f, adb, nh->entry, debug, now);
2553 dns_adb_dumpquota(dns_adb_t *adb, isc_buffer_t **buf) {
2554 REQUIRE(DNS_ADB_VALID(adb));
2559 RWLOCK(&adb->entries_lock, isc_rwlocktype_read);
2560 isc_hashmap_iter_create(adb->entries, &it);
2572 if (entry->atr == 0.0 && entry->quota == adb->quota) {
2581 atomic_load_relaxed(&entry->quota), adb->quota,
2588 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_read);
2597 dns_adb_t *adb = NULL;
2603 adb = adbname->adb;
2605 REQUIRE(DNS_ADB_VALID(adb));
2625 result = dns_view_find(adb->view, adbname->name, rdtype, now,
2660 "adb name %p: Caching auth negative entry for A",
2669 "adb name %p: Caching auth negative entry for AAAA",
2694 "adb name %p: Caching negative entry for A (ttl %u)",
2698 "adb name %p: Caching negative entry for AAAA (ttl "
2712 clean_target(adb, &adbname->target);
2714 result = set_target(adb, adbname->name, fname, &rdataset,
2718 DP(NCACHE_LEVEL, "adb name %p: caching alias target",
2744 dns_adb_t *adb = NULL;
2752 dns_adb_attach(name->adb, &adb);
2754 REQUIRE(DNS_ADB_VALID(adb));
2806 "adb fetch name %p: "
2814 inc_resstats(adb, dns_resstatscounter_gluefetchv4fail);
2819 "adb fetch name %p: "
2827 inc_resstats(adb, dns_resstatscounter_gluefetchv6fail);
2837 clean_target(adb, &name->target);
2839 result = set_target(adb, name->name, resp->foundname,
2843 "adb fetch name %p: caching alias target", name);
2858 DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf,
2872 inc_resstats(adb, dns_resstatscounter_gluefetchv4fail);
2876 inc_resstats(adb, dns_resstatscounter_gluefetchv6fail);
2898 free_adbfetch(adb, &fetch);
2905 dns_adb_detach(&adb);
2914 dns_adb_t *adb = NULL;
2923 adb = adbname->adb;
2925 REQUIRE(DNS_ADB_VALID(adb));
2940 result = dns_view_findzonecut(adb->view, adbname->name, name,
2948 } else if (adb->view->qminimization) {
2950 if (adb->view->qmin_strict) {
2955 fetch = new_adbfetch(adb);
2967 adb->res, adbname->name, type, name, nameservers, NULL, NULL, 0,
2979 inc_resstats(adb, dns_resstatscounter_gluefetchv4);
2982 inc_resstats(adb, dns_resstatscounter_gluefetchv6);
2988 free_adbfetch(adb, &fetch);
2998 dns_adb_adjustsrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int rtt,
3000 REQUIRE(DNS_ADB_VALID(adb));
3013 dns_adb_agesrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, isc_stdtime_t now) {
3014 REQUIRE(DNS_ADB_VALID(adb));
3043 dns_adb_changeflags(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int bits,
3045 REQUIRE(DNS_ADB_VALID(adb));
3085 * The adb entry associated with 'addr' must be locked.
3088 maybe_adjust_quota(dns_adb_t *adb, dns_adbaddrinfo_t *addr, bool timeout) {
3091 UNUSED(adb);
3093 if (adb->quota == 0 || adb->atr_freq == 0) {
3101 if (addr->entry->completed++ <= adb->atr_freq) {
3114 INSIST(adb->atr_discount >= 0.0);
3115 INSIST(adb->atr_discount <= 1.0);
3116 addr->entry->atr *= 1.0 - adb->atr_discount;
3117 addr->entry->atr += tr * adb->atr_discount;
3120 if (addr->entry->atr < adb->atr_low && addr->entry->mode > 0) {
3122 adb->quota * quota_adj[--addr->entry->mode] / 10000;
3128 } else if (addr->entry->atr > adb->atr_high &&
3132 adb->quota * quota_adj[++addr->entry->mode] / 10000;
3144 dns_adb_plainresponse(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3145 adb));
3151 maybe_adjust_quota(adb, addr, false);
3164 dns_adb_timeout(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3165 REQUIRE(DNS_ADB_VALID(adb));
3171 maybe_adjust_quota(adb, addr, true);
3184 dns_adb_ednsto(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3185 REQUIRE(DNS_ADB_VALID(adb));
3191 maybe_adjust_quota(adb, addr, true);
3204 dns_adb_setudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int size) {
3205 REQUIRE(DNS_ADB_VALID(adb));
3218 maybe_adjust_quota(adb, addr, false);
3231 dns_adb_getudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3232 REQUIRE(DNS_ADB_VALID(adb));
3246 dns_adb_setcookie(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
3248 REQUIRE(DNS_ADB_VALID(adb));
3258 isc_mem_put(adb->mctx, entry->cookie, entry->cookielen);
3264 entry->cookie = isc_mem_get(adb->mctx, len);
3301 dns_adb_findaddrinfo(dns_adb_t *adb, const isc_sockaddr_t *sa,
3303 REQUIRE(DNS_ADB_VALID(adb));
3312 if (atomic_load(&adb->exiting)) {
3316 entry = get_attached_and_locked_entry(adb, now, sa);
3321 addr = new_adbaddrinfo(adb, entry, port);
3330 dns_adb_freeaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **addrp) {
3334 REQUIRE(DNS_ADB_VALID(adb));
3346 free_adbaddrinfo(adb, &addr);
3350 dns_adb_flush(dns_adb_t *adb) {
3351 REQUIRE(DNS_ADB_VALID(adb));
3353 if (atomic_load(&adb->exiting)) {
3357 cleanup_names(adb, INT_MAX);
3358 cleanup_entries(adb, INT_MAX);
3360 dump_adb(adb, stdout, true, INT_MAX);
3365 dns_adb_flushname(dns_adb_t *adb, const dns_name_t *name) {
3372 REQUIRE(DNS_ADB_VALID(adb));
3375 if (atomic_load(&adb->exiting)) {
3379 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
3388 result = isc_hashmap_find(adb->names, hash_adbname(&key), match_adbname,
3407 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
3411 dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
3414 REQUIRE(DNS_ADB_VALID(adb));
3417 if (atomic_load(&adb->exiting)) {
3421 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
3422 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
3434 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
3438 dns_adb_setadbsize(dns_adb_t *adb, size_t size) {
3441 REQUIRE(DNS_ADB_VALID(adb));
3451 isc_mem_clearwater(adb->mctx);
3453 isc_mem_setwater(adb->mctx, hiwater, lowater);
3458 dns_adb_setquota(dns_adb_t *adb, uint32_t quota, uint32_t freq, double low,
3460 REQUIRE(DNS_ADB_VALID(adb));
3462 adb->quota = quota;
3463 adb->atr_freq = freq;
3464 adb->atr_low = low;
3465 adb->atr_high = high;
3466 adb->atr_discount = discount;
3470 dns_adb_getquota(dns_adb_t *adb, uint32_t *quotap, uint32_t *freqp,
3472 REQUIRE(DNS_ADB_VALID(adb));
3474 SET_IF_NOT_NULL(quotap, adb->quota);
3476 SET_IF_NOT_NULL(freqp, adb->atr_freq);
3478 SET_IF_NOT_NULL(lowp, adb->atr_low);
3480 SET_IF_NOT_NULL(highp, adb->atr_high);
3482 SET_IF_NOT_NULL(discountp, adb->atr_discount);
3496 dns_adb_overquota(dns_adb_t *adb ISC_ATTR_UNUSED, dns_adbaddrinfo_t *addrinfo) {
3503 dns_adb_beginudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3506 REQUIRE(DNS_ADB_VALID(adb));
3514 dns_adb_endudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3517 REQUIRE(DNS_ADB_VALID(adb));
3525 dns_adb_getstats(dns_adb_t *adb) {
3526 REQUIRE(DNS_ADB_VALID(adb));
3528 return adb->stats;
Indexes created Sat Feb 28 05:31:39 UTC 2026