Lines Matching defs:adb
1 /* $NetBSD: adb.c,v 1.13 2025/01/26 16:25:21 christos Exp $ */
38 #include <dns/adb.h>
94 /*% dns adb structure */
131 * up via the adb->names hash table. It holds references to fetches
139 dns_adb_t *adb;
204 * up via the adb->entries hash table. Also, each dns_adbnamehook and
214 dns_adb_t *adb;
272 new_adbname(dns_adb_t *adb, const dns_name_t *, unsigned int flags);
280 new_adbnamehook(dns_adb_t *adb);
282 free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehookp);
284 new_adbentry(dns_adb_t *adb, const isc_sockaddr_t *addr, isc_stdtime_t now);
300 purge_stale_names(dns_adb_t *adb, isc_stdtime_t now);
305 purge_stale_entries(dns_adb_t *adb, isc_stdtime_t now);
307 get_attached_and_locked_entry(dns_adb_t *adb, isc_stdtime_t now,
312 print_namehook_list(FILE *, const char *legend, dns_adb_t *adb,
497 inc_resstats(dns_adb_t *adb, isc_statscounter_t counter) {
498 if (adb->res != NULL) {
499 dns_resolver_incstats(adb->res, counter);
504 * Set adb-related statistics counters.
507 set_adbstat(dns_adb_t *adb, uint64_t val, isc_statscounter_t counter) {
508 if (adb->stats != NULL) {
509 isc_stats_set(adb->stats, val, counter);
514 dec_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
515 if (adb->stats != NULL) {
516 isc_stats_decrement(adb->stats, counter);
521 inc_adbstats(dns_adb_t *adb, isc_statscounter_t counter) {
522 if (adb->stats != NULL) {
523 isc_stats_increment(adb->stats, counter);
548 dns_adb_t *adb = NULL;
553 adb = adbname->adb;
555 REQUIRE(DNS_ADB_VALID(adb));
603 entry = get_attached_and_locked_entry(adb, now, &sockaddr);
615 nh = new_adbnamehook(adb);
662 dns_adb_t *adb = adbname->adb;
664 REQUIRE(DNS_ADB_VALID(adb));
674 clean_namehooks(adb, &adbname->v4);
675 clean_namehooks(adb, &adbname->v6);
676 clean_target(adb, &adbname->target);
691 result = isc_hashmap_delete(adb->names, hash_adbname(adbname),
695 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
706 REQUIRE(DNS_ADB_VALID(adbname->adb));
708 dns_adb_t *adb = adbname->adb;
716 clean_namehooks(adb, &adbname->v4);
729 clean_namehooks(adb, &adbname->v6);
740 clean_target(adb, &adbname->target);
746 shutdown_names(dns_adb_t *adb) {
749 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
750 for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
766 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
770 shutdown_entries(dns_adb_t *adb) {
772 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
773 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
779 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
786 clean_namehooks(dns_adb_t *adb, dns_adbnamehooklist_t *namehooks) {
807 free_adbnamehook(adb, &namehook);
814 clean_target(dns_adb_t *adb, dns_name_t *target) {
816 dns_name_free(target, adb->mctx);
822 set_target(dns_adb_t *adb, const dns_name_t *name, const dns_name_t *fname,
844 dns_name_dup(&cname.cname, adb->mctx, target);
883 dns_name_dup(new_target, adb->mctx, target);
961 new_adbname(dns_adb_t *adb, const dns_name_t *dnsname, unsigned int flags) {
964 name = isc_mem_get(adb->mctx, sizeof(*name));
966 .adb = dns_adb_ref(adb),
992 inc_adbstats(adb, dns_adbstats_namescnt);
1006 dns_adb_t *adb = name->adb;
1018 isc_mem_put(adb->mctx, name, sizeof(*name));
1020 dec_adbstats(adb, dns_adbstats_namescnt);
1021 dns_adb_detach(&adb);
1025 new_adbnamehook(dns_adb_t *adb) {
1026 dns_adbnamehook_t *nh = isc_mem_get(adb->mctx, sizeof(*nh));
1037 free_adbnamehook(dns_adb_t *adb, dns_adbnamehook_t **namehook) {
1051 isc_mem_put(adb->mctx, nh, sizeof(*nh));
1055 new_adbentry(dns_adb_t *adb, const isc_sockaddr_t *addr, isc_stdtime_t now) {
1058 entry = isc_mem_get(adb->mctx, sizeof(*entry));
1063 .quota = adb->quota,
1065 .adb = dns_adb_ref(adb),
1076 inc_adbstats(adb, dns_adbstats_entriescnt);
1085 dns_adb_t *adb = entry->adb;
1098 isc_mem_put(adb->mctx, entry->cookie, entry->cookielen);
1102 isc_mem_put(adb->mctx, entry, sizeof(*entry));
1104 dec_adbstats(adb, dns_adbstats_entriescnt);
1106 dns_adb_detach(&adb);
1116 new_adbfind(dns_adb_t *adb, in_port_t port) {
1119 find = isc_mem_get(adb->mctx, sizeof(*find));
1129 dns_adb_attach(adb, &find->adb);
1139 dns_adb_t *adb = NULL;
1147 adb = find->adb;
1158 isc_mem_put(adb->mctx, find, sizeof(*find));
1159 dns_adb_detach(&adb);
1163 new_adbfetch(dns_adb_t *adb) {
1166 fetch = isc_mem_get(adb->mctx, sizeof(*fetch));
1176 free_adbfetch(dns_adb_t *adb, dns_adbfetch_t **fetchp) {
1190 isc_mem_put(adb->mctx, fetch, sizeof(*fetch));
1198 new_adbaddrinfo(dns_adb_t *adb, dns_adbentry_t *entry, in_port_t port) {
1201 ai = isc_mem_get(adb->mctx, sizeof(*ai));
1217 free_adbaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **ainfo) {
1234 isc_mem_put(adb->mctx, ai, sizeof(*ai));
1267 get_attached_and_locked_name(dns_adb_t *adb, const dns_name_t *name,
1282 RWLOCK(&adb->names_lock, locktype);
1283 last_update = adb->names_last_update;
1286 isc_mem_isovermem(adb->mctx))
1289 UPGRADELOCK(&adb->names_lock, locktype);
1290 purge_stale_names(adb, now);
1291 adb->names_last_update = last_update;
1294 result = isc_hashmap_find(adb->names, hashval, match_adbname,
1298 UPGRADELOCK(&adb->names_lock, locktype);
1301 adbname = new_adbname(adb, name, key.flags);
1304 result = isc_hashmap_add(adb->names, hashval, match_adbname,
1310 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1317 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1331 ISC_LIST_PREPEND(adb->names_lru, adbname, link);
1339 RWUNLOCK(&adb->names_lock, locktype);
1345 upgrade_entries_lock(dns_adb_t *adb, isc_rwlocktype_t *locktypep,
1348 UPGRADELOCK(&adb->entries_lock, *locktypep);
1349 purge_stale_entries(adb, now);
1350 adb->entries_last_update = now;
1362 * Find the entry in the adb->entries hashtable.
1365 get_attached_and_locked_entry(dns_adb_t *adb, isc_stdtime_t now,
1376 RWLOCK(&adb->entries_lock, locktype);
1377 last_update = adb->entries_last_update;
1380 isc_mem_isovermem(adb->mctx))
1384 upgrade_entries_lock(adb, &locktype, now);
1387 result = isc_hashmap_find(adb->entries, hashval, match_adbentry,
1391 upgrade_entries_lock(adb, &locktype, now);
1397 adbentry = new_adbentry(adb, addr, now);
1400 result = isc_hashmap_add(adb->entries, hashval, match_adbentry,
1403 ISC_LIST_PREPEND(adb->entries_lru, adbentry, link);
1426 upgrade_entries_lock(adb, &locktype, now);
1444 ISC_LIST_UNLINK(adb->entries_lru, adbentry, link);
1445 ISC_LIST_PREPEND(adb->entries_lru, adbentry, link);
1449 RWUNLOCK(&adb->entries_lock, locktype);
1470 "adb: quota %s (%" PRIuFAST32 "/%" PRIuFAST32 "): %s",
1476 copy_namehook_lists(dns_adb_t *adb, dns_adbfind_t *find, dns_adbname_t *name) {
1493 addrinfo = new_adbaddrinfo(adb, entry, find->port);
1517 addrinfo = new_adbaddrinfo(adb, entry, find->port);
1530 * The name must be locked and write lock on adb->names_lock must be held.
1562 dns_adb_t *adb = adbentry->adb;
1568 adb->entries,
1572 ISC_LIST_UNLINK(adb->entries_lru, adbentry, link);
1611 * adb->names_lock MUST be write locked
1614 purge_stale_names(dns_adb_t *adb, isc_stdtime_t now) {
1615 bool overmem = isc_mem_isovermem(adb->mctx);
1627 for (dns_adbname_t *adbname = ISC_LIST_TAIL(adb->names_lru);
1683 cleanup_names(dns_adb_t *adb, isc_stdtime_t now) {
1686 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
1687 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
1705 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
1716 * adb->entries_lock MUST be write locked
1719 purge_stale_entries(dns_adb_t *adb, isc_stdtime_t now) {
1720 bool overmem = isc_mem_isovermem(adb->mctx);
1732 for (dns_adbentry_t *adbentry = ISC_LIST_TAIL(adb->entries_lru);
1786 cleanup_entries(dns_adb_t *adb, isc_stdtime_t now) {
1789 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
1790 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
1801 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
1805 destroy(dns_adb_t *adb) {
1806 DP(DEF_LEVEL, "destroying ADB %p", adb);
1808 adb->magic = 0;
1810 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
1811 INSIST(isc_hashmap_count(adb->names) == 0);
1812 isc_hashmap_destroy(&adb->names);
1813 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
1814 isc_rwlock_destroy(&adb->names_lock);
1816 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
1818 INSIST(isc_hashmap_count(adb->entries) == 0);
1819 isc_hashmap_destroy(&adb->entries);
1820 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
1821 isc_rwlock_destroy(&adb->entries_lock);
1823 isc_mem_detach(&adb->hmctx);
1825 isc_mutex_destroy(&adb->lock);
1827 isc_stats_detach(&adb->stats);
1828 dns_resolver_detach(&adb->res);
1829 dns_view_weakdetach(&adb->view);
1830 isc_mem_putanddetach(&adb->mctx, adb, sizeof(dns_adb_t));
1845 dns_adb_t *adb = NULL;
1851 adb = isc_mem_get(mem, sizeof(dns_adb_t));
1852 *adb = (dns_adb_t){
1863 __FILE__, __LINE__ + 1, adb);
1865 isc_refcount_init(&adb->references, 1);
1866 dns_view_weakattach(view, &adb->view);
1867 dns_resolver_attach(view->resolver, &adb->res);
1868 isc_mem_attach(mem, &adb->mctx);
1870 isc_mem_create(&adb->hmctx);
1871 isc_mem_setname(adb->hmctx, "ADB_hashmaps");
1873 isc_hashmap_create(adb->hmctx, ADB_HASH_BITS, &adb->names);
1874 isc_rwlock_init(&adb->names_lock);
1876 isc_hashmap_create(adb->hmctx, ADB_HASH_BITS, &adb->entries);
1877 isc_rwlock_init(&adb->entries_lock);
1879 isc_mutex_init(&adb->lock);
1881 isc_stats_create(adb->mctx, &adb->stats, dns_adbstats_max);
1883 set_adbstat(adb, 0, dns_adbstats_nnames);
1884 set_adbstat(adb, 0, dns_adbstats_nentries);
1889 adb->magic = DNS_ADB_MAGIC;
1890 *newadb = adb;
1894 dns_adb_shutdown(dns_adb_t *adb) {
1895 if (!atomic_compare_exchange_strong(&adb->exiting, &(bool){ false },
1901 DP(DEF_LEVEL, "shutting down ADB %p", adb);
1903 isc_mem_clearwater(adb->mctx);
1905 shutdown_names(adb);
1906 shutdown_entries(adb);
1927 dns_adb_createfind(dns_adb_t *adb, isc_loop_t *loop, isc_job_cb cb, void *cbarg,
1945 REQUIRE(DNS_ADB_VALID(adb));
1956 if (atomic_load(&adb->exiting)) {
1977 find = new_adbfind(adb, port);
1990 adbname = get_attached_and_locked_name(adb, name, find->options, now);
2168 copy_namehook_lists(adb, find, adbname);
2254 dns_adb_t *adb = NULL;
2263 adb = find->adb;
2277 free_adbaddrinfo(adb, &ai);
2306 REQUIRE(DNS_ADB_VALID(find->adb));
2356 dns_adb_dump(dns_adb_t *adb, FILE *f) {
2359 REQUIRE(DNS_ADB_VALID(adb));
2362 if (atomic_load(&adb->exiting)) {
2366 cleanup_names(adb, now);
2367 cleanup_entries(adb, now);
2368 dump_adb(adb, f, false, now);
2383 dump_adb(dns_adb_t *adb, FILE *f, bool debug, isc_stdtime_t now) {
2388 fprintf(f, "; addr %p, references %" PRIuFAST32 "\n", adb,
2389 isc_refcount_current(&adb->references));
2395 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
2397 for (dns_adbname_t *name = ISC_LIST_HEAD(adb->names_lru); name != NULL;
2424 print_namehook_list(f, "v4", adb, &name->v4, debug, now);
2425 print_namehook_list(f, "v6", adb, &name->v6, debug, now);
2434 RWLOCK(&adb->entries_lock, isc_rwlocktype_write);
2436 for (dns_adbentry_t *adbentry = ISC_LIST_HEAD(adb->entries_lru);
2441 dump_entry(f, adb, adbentry, debug, now);
2446 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_write);
2447 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
2451 dump_entry(FILE *f, dns_adb_t *adb, dns_adbentry_t *entry, bool debug,
2482 if (adb != NULL && adb->quota != 0 && adb->atr_freq != 0) {
2546 print_namehook_list(FILE *f, const char *legend, dns_adb_t *adb,
2558 dump_entry(f, adb, nh->entry, debug, now);
2603 dns_adb_dumpquota(dns_adb_t *adb, isc_buffer_t **buf) {
2604 REQUIRE(DNS_ADB_VALID(adb));
2609 RWLOCK(&adb->entries_lock, isc_rwlocktype_read);
2610 isc_hashmap_iter_create(adb->entries, &it);
2622 if (entry->atr == 0.0 && entry->quota == adb->quota) {
2631 atomic_load_relaxed(&entry->quota), adb->quota,
2638 RWUNLOCK(&adb->entries_lock, isc_rwlocktype_read);
2647 dns_adb_t *adb = NULL;
2653 adb = adbname->adb;
2655 REQUIRE(DNS_ADB_VALID(adb));
2676 dns_view_find(adb->view, adbname->name, rdtype, now,
2710 "adb name %p: Caching auth negative entry for A",
2719 "adb name %p: Caching auth negative entry for AAAA",
2744 "adb name %p: Caching negative entry for A (ttl %u)",
2748 "adb name %p: Caching negative entry for AAAA (ttl "
2762 clean_target(adb, &adbname->target);
2764 result = set_target(adb, adbname->name, fname, &rdataset,
2768 DP(NCACHE_LEVEL, "adb name %p: caching alias target",
2794 dns_adb_t *adb = NULL;
2802 dns_adb_attach(name->adb, &adb);
2804 REQUIRE(DNS_ADB_VALID(adb));
2856 "adb fetch name %p: "
2864 inc_resstats(adb, dns_resstatscounter_gluefetchv4fail);
2869 "adb fetch name %p: "
2877 inc_resstats(adb, dns_resstatscounter_gluefetchv6fail);
2887 clean_target(adb, &name->target);
2889 result = set_target(adb, name->name, resp->foundname,
2893 "adb fetch name %p: caching alias target", name);
2908 DP(DEF_LEVEL, "adb: fetch of '%s' %s failed: %s", buf,
2922 inc_resstats(adb, dns_resstatscounter_gluefetchv4fail);
2926 inc_resstats(adb, dns_resstatscounter_gluefetchv6fail);
2948 free_adbfetch(adb, &fetch);
2955 dns_adb_detach(&adb);
2963 dns_adb_t *adb = NULL;
2972 adb = adbname->adb;
2974 REQUIRE(DNS_ADB_VALID(adb));
2989 result = dns_view_findzonecut(adb->view, adbname->name, name,
2997 } else if (adb->view->qminimization) {
2999 if (adb->view->qmin_strict) {
3004 fetch = new_adbfetch(adb);
3015 adb->res, adbname->name, type, name, nameservers, NULL, NULL, 0,
3028 inc_resstats(adb, dns_resstatscounter_gluefetchv4);
3031 inc_resstats(adb, dns_resstatscounter_gluefetchv6);
3037 free_adbfetch(adb, &fetch);
3047 dns_adb_adjustsrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int rtt,
3049 REQUIRE(DNS_ADB_VALID(adb));
3062 dns_adb_agesrtt(dns_adb_t *adb, dns_adbaddrinfo_t *addr, isc_stdtime_t now) {
3063 REQUIRE(DNS_ADB_VALID(adb));
3092 dns_adb_changeflags(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int bits,
3094 REQUIRE(DNS_ADB_VALID(adb));
3134 * The adb entry associated with 'addr' must be locked.
3137 maybe_adjust_quota(dns_adb_t *adb, dns_adbaddrinfo_t *addr, bool timeout) {
3140 UNUSED(adb);
3142 if (adb->quota == 0 || adb->atr_freq == 0) {
3150 if (addr->entry->completed++ <= adb->atr_freq) {
3163 INSIST(adb->atr_discount >= 0.0);
3164 INSIST(adb->atr_discount <= 1.0);
3165 addr->entry->atr *= 1.0 - adb->atr_discount;
3166 addr->entry->atr += tr * adb->atr_discount;
3169 if (addr->entry->atr < adb->atr_low && addr->entry->mode > 0) {
3171 adb->quota * quota_adj[--addr->entry->mode] / 10000;
3177 } else if (addr->entry->atr > adb->atr_high &&
3181 adb->quota * quota_adj[++addr->entry->mode] / 10000;
3193 dns_adb_plainresponse(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3194 REQUIRE(DNS_ADB_VALID(adb));
3200 maybe_adjust_quota(adb, addr, false);
3213 dns_adb_timeout(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3214 REQUIRE(DNS_ADB_VALID(adb));
3220 maybe_adjust_quota(adb, addr, true);
3233 dns_adb_ednsto(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3234 REQUIRE(DNS_ADB_VALID(adb));
3240 maybe_adjust_quota(adb, addr, true);
3253 dns_adb_setudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr, unsigned int size) {
3254 REQUIRE(DNS_ADB_VALID(adb));
3267 maybe_adjust_quota(adb, addr, false);
3280 dns_adb_getudpsize(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3281 REQUIRE(DNS_ADB_VALID(adb));
3295 dns_adb_setcookie(dns_adb_t *adb, dns_adbaddrinfo_t *addr,
3297 REQUIRE(DNS_ADB_VALID(adb));
3307 isc_mem_put(adb->mctx, entry->cookie, entry->cookielen);
3313 entry->cookie = isc_mem_get(adb->mctx, len);
3350 dns_adb_findaddrinfo(dns_adb_t *adb, const isc_sockaddr_t *sa,
3352 REQUIRE(DNS_ADB_VALID(adb));
3361 if (atomic_load(&adb->exiting)) {
3365 entry = get_attached_and_locked_entry(adb, now, sa);
3370 addr = new_adbaddrinfo(adb, entry, port);
3379 dns_adb_freeaddrinfo(dns_adb_t *adb, dns_adbaddrinfo_t **addrp) {
3383 REQUIRE(DNS_ADB_VALID(adb));
3395 free_adbaddrinfo(adb, &addr);
3399 dns_adb_flush(dns_adb_t *adb) {
3400 REQUIRE(DNS_ADB_VALID(adb));
3402 if (atomic_load(&adb->exiting)) {
3406 cleanup_names(adb, INT_MAX);
3407 cleanup_entries(adb, INT_MAX);
3409 dump_adb(adb, stdout, true, INT_MAX);
3414 dns_adb_flushname(dns_adb_t *adb, const dns_name_t *name) {
3421 REQUIRE(DNS_ADB_VALID(adb));
3424 if (atomic_load(&adb->exiting)) {
3428 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
3437 result = isc_hashmap_find(adb->names, hash_adbname(&key), match_adbname,
3456 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
3460 dns_adb_flushnames(dns_adb_t *adb, const dns_name_t *name) {
3463 REQUIRE(DNS_ADB_VALID(adb));
3466 if (atomic_load(&adb->exiting)) {
3470 RWLOCK(&adb->names_lock, isc_rwlocktype_write);
3471 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
3483 RWUNLOCK(&adb->names_lock, isc_rwlocktype_write);
3487 dns_adb_setadbsize(dns_adb_t *adb, size_t size) {
3490 REQUIRE(DNS_ADB_VALID(adb));
3500 isc_mem_clearwater(adb->mctx);
3502 isc_mem_setwater(adb->mctx, hiwater, lowater);
3507 dns_adb_setquota(dns_adb_t *adb, uint32_t quota, uint32_t freq, double low,
3509 REQUIRE(DNS_ADB_VALID(adb));
3511 adb->quota = quota;
3512 adb->atr_freq = freq;
3513 adb->atr_low = low;
3514 adb->atr_high = high;
3515 adb->atr_discount = discount;
3519 dns_adb_getquota(dns_adb_t *adb, uint32_t *quotap, uint32_t *freqp,
3521 REQUIRE(DNS_ADB_VALID(adb));
3523 SET_IF_NOT_NULL(quotap, adb->quota);
3525 SET_IF_NOT_NULL(freqp, adb->atr_freq);
3527 SET_IF_NOT_NULL(lowp, adb->atr_low);
3529 SET_IF_NOT_NULL(highp, adb->atr_high);
3531 SET_IF_NOT_NULL(discountp, adb->atr_discount);
3545 dns_adb_overquota(dns_adb_t *adb ISC_ATTR_UNUSED, dns_adbaddrinfo_t *addrinfo) {
3552 dns_adb_beginudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3555 REQUIRE(DNS_ADB_VALID(adb));
3563 dns_adb_endudpfetch(dns_adb_t *adb, dns_adbaddrinfo_t *addr) {
3566 REQUIRE(DNS_ADB_VALID(adb));
3574 dns_adb_getstats(dns_adb_t *adb) {
3575 REQUIRE(DNS_ADB_VALID(adb));
3577 return adb->stats;