Lines Matching defs:adbname
278 hash_adbname(const dns_adbname_t *adbname);
327 maybe_expire_name(dns_adbname_t *adbname, isc_stdtime_t now);
329 expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat);
372 * Private flag(s) for adbname objects.
545 import_rdataset(dns_adbname_t *adbname, dns_rdataset_t *rdataset,
551 REQUIRE(DNS_ADBNAME_VALID(adbname));
553 adb = adbname->adb;
591 hookhead = &adbname->v4;
597 hookhead = &adbname->v6;
630 adbname->expire_v4 = ADJUSTED_EXPIRE(adbname->expire_v4, now,
633 adbname->expire_v4);
636 adbname->expire_v6 = ADJUSTED_EXPIRE(adbname->expire_v6, now,
639 adbname->expire_v6);
657 expire_name(dns_adbname_t *adbname, dns_adbstatus_t astat) {
660 REQUIRE(DNS_ADBNAME_VALID(adbname));
662 dns_adb_t *adb = adbname->adb;
666 DP(DEF_LEVEL, "killing name %p", adbname);
673 clean_finds_at_name(adbname, astat, DNS_ADBFIND_ADDRESSMASK);
674 clean_namehooks(adb, &adbname->v4);
675 clean_namehooks(adb, &adbname->v6);
676 clean_target(adb, &adbname->target);
678 if (NAME_FETCH_A(adbname)) {
679 dns_resolver_cancelfetch(adbname->fetch_a->fetch);
682 if (NAME_FETCH_AAAA(adbname)) {
683 dns_resolver_cancelfetch(adbname->fetch_aaaa->fetch);
686 adbname->flags |= NAME_IS_DEAD;
689 * Remove the adbname from the hashtable...
691 result = isc_hashmap_delete(adb->names, hash_adbname(adbname),
692 match_ptr, adbname);
695 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
697 dns_adbname_unref(adbname);
704 maybe_expire_namehooks(dns_adbname_t *adbname, isc_stdtime_t now) {
705 REQUIRE(DNS_ADBNAME_VALID(adbname));
706 REQUIRE(DNS_ADB_VALID(adbname->adb));
708 dns_adb_t *adb = adbname->adb;
713 if (!NAME_FETCH_A(adbname) && EXPIRE_OK(adbname->expire_v4, now)) {
714 if (NAME_HAS_V4(adbname)) {
715 DP(DEF_LEVEL, "expiring v4 for name %p", adbname);
716 clean_namehooks(adb, &adbname->v4);
717 adbname->partial_result &= ~DNS_ADBFIND_INET;
719 adbname->expire_v4 = INT_MAX;
720 adbname->fetch_err = FIND_ERR_UNEXPECTED;
726 if (!NAME_FETCH_AAAA(adbname) && EXPIRE_OK(adbname->expire_v6, now)) {
727 if (NAME_HAS_V6(adbname)) {
728 DP(DEF_LEVEL, "expiring v6 for name %p", adbname);
729 clean_namehooks(adb, &adbname->v6);
730 adbname->partial_result &= ~DNS_ADBFIND_INET6;
732 adbname->expire_v6 = INT_MAX;
733 adbname->fetch6_err = FIND_ERR_UNEXPECTED;
739 if (EXPIRE_OK(adbname->expire_target, now)) {
740 clean_target(adb, &adbname->target);
741 adbname->expire_target = INT_MAX;
941 find->adbname = NULL;
1152 REQUIRE(find->adbname == NULL);
1252 hash_adbname(const dns_adbname_t *adbname) {
1254 unsigned int flags = adbname->flags & ADBNAME_FLAGS_MASK;
1257 isc_hash32_hash(&hash, adbname->name->ndata, adbname->name->length,
1270 dns_adbname_t *adbname = NULL;
1295 (void *)&key, (void **)&adbname);
1301 adbname = new_adbname(adb, name, key.flags);
1305 (void *)&key, adbname, &found);
1307 destroy_adbname(adbname);
1308 adbname = found;
1310 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1317 ISC_LIST_UNLINK(adb->names_lru, adbname, link);
1324 dns_adbname_ref(adbname);
1326 LOCK(&adbname->lock); /* Must be unlocked by the caller */
1327 if (adbname->last_used + ADB_CACHE_MINIMUM <= last_update) {
1328 adbname->last_used = now;
1331 ISC_LIST_PREPEND(adb->names_lru, adbname, link);
1336 * expire_name() - the unused adbname stored in the hashtable and lru
1341 return adbname;
1533 maybe_expire_name(dns_adbname_t *adbname, isc_stdtime_t now) {
1534 REQUIRE(DNS_ADBNAME_VALID(adbname));
1537 if (NAME_HAS_V4(adbname) || NAME_HAS_V6(adbname)) {
1542 if (NAME_FETCH(adbname)) {
1547 if (!EXPIRE_OK(adbname->expire_v4, now) ||
1548 !EXPIRE_OK(adbname->expire_v6, now) ||
1549 !EXPIRE_OK(adbname->expire_target, now))
1554 expire_name(adbname, DNS_ADB_EXPIRED);
1627 for (dns_adbname_t *adbname = ISC_LIST_TAIL(adb->names_lru);
1628 adbname != NULL && removed < max_removed && scans < 10;
1629 adbname = prev)
1631 prev = ISC_LIST_PREV(adbname, link);
1633 dns_adbname_ref(adbname);
1634 LOCK(&adbname->lock);
1642 maybe_expire_namehooks(adbname, now);
1643 if (maybe_expire_name(adbname, now)) {
1652 if (adbname->last_used + ADB_CACHE_MINIMUM >= now) {
1658 expire_name(adbname, DNS_ADB_CANCELED);
1663 if (adbname->last_used + ADB_STALE_MARGIN < now) {
1664 expire_name(adbname, DNS_ADB_CANCELED);
1677 UNLOCK(&adbname->lock);
1678 dns_adbname_detach(&adbname);
1687 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
1688 adbname != NULL; adbname = next)
1690 next = ISC_LIST_NEXT(adbname, link);
1692 dns_adbname_ref(adbname);
1693 LOCK(&adbname->lock);
1700 maybe_expire_namehooks(adbname, now);
1701 (void)maybe_expire_name(adbname, now);
1702 UNLOCK(&adbname->lock);
1703 dns_adbname_detach(&adbname);
1935 dns_adbname_t *adbname = NULL;
1990 adbname = get_attached_and_locked_name(adb, name, find->options, now);
1992 if (NAME_DEAD(adbname)) {
1993 UNLOCK(&adbname->lock);
1994 dns_adbname_detach(&adbname);
2003 maybe_expire_namehooks(adbname, now);
2008 if (!EXPIRE_OK(adbname->expire_target, now)) {
2012 namebuf, adbname);
2022 if (!NAME_HAS_V4(adbname) && EXPIRE_OK(adbname->expire_v4, now) &&
2025 result = dbfind_name(adbname, now, dns_rdatatype_a);
2031 namebuf, adbname);
2038 namebuf, adbname);
2064 if (!NAME_FETCH_A(adbname) && !FIND_STATICSTUB(find)) {
2074 if (!NAME_HAS_V6(adbname) && EXPIRE_OK(adbname->expire_v6, now) &&
2077 result = dbfind_name(adbname, now, dns_rdatatype_aaaa);
2082 namebuf, adbname);
2089 namebuf, adbname);
2107 if (!NAME_FETCH_AAAA(adbname) && !FIND_STATICSTUB(find))
2116 if ((WANT_INET(wanted_addresses) && NAME_HAS_V4(adbname)) ||
2117 (WANT_INET6(wanted_addresses) && NAME_HAS_V6(adbname)))
2141 fetch_name(adbname, start_at_zone, depth, qc,
2147 namebuf, adbname);
2154 fetch_name(adbname, start_at_zone, depth, qc,
2160 namebuf, adbname);
2168 copy_namehook_lists(adb, find, adbname);
2171 if (NAME_FETCH_A(adbname)) {
2174 if (NAME_FETCH_AAAA(adbname)) {
2197 find->adbname = adbname;
2198 empty = ISC_LIST_EMPTY(adbname->finds);
2199 ISC_LIST_APPEND(adbname->finds, find, plink);
2203 DP(DEF_LEVEL, "createfind: attaching find %p to adbname %p %d",
2204 find, adbname, empty);
2218 find->partial_result |= (adbname->partial_result & wanted_addresses);
2221 dns_name_copy(&adbname->target, target);
2231 find->result_v4 = find_err_map[adbname->fetch_err];
2232 find->result_v6 = find_err_map[adbname->fetch6_err];
2244 UNLOCK(&adbname->lock);
2245 dns_adbname_detach(&adbname);
2267 REQUIRE(find->adbname == NULL);
2301 dns_adbname_t *adbname = NULL;
2311 adbname = find->adbname;
2313 if (adbname == NULL) {
2322 dns_adbname_ref(adbname);
2327 * lock, so we need to recheck whether the adbname is still
2328 * valid and reference the adbname, so it does not vanish before
2332 LOCK(&adbname->lock);
2335 if (find->adbname != NULL) {
2336 ISC_LIST_UNLINK(find->adbname->finds, find, plink);
2337 find->adbname = NULL;
2343 UNLOCK(&adbname->lock);
2344 dns_adbname_detach(&adbname);
2509 fprintf(f, ";\tname %p\n", find->adbname);
2644 dbfind_name(dns_adbname_t *adbname, isc_stdtime_t now, dns_rdatatype_t rdtype) {
2651 REQUIRE(DNS_ADBNAME_VALID(adbname));
2653 adb = adbname->adb;
2662 adbname->fetch_err = FIND_ERR_UNEXPECTED;
2664 adbname->fetch6_err = FIND_ERR_UNEXPECTED;
2676 dns_view_find(adb->view, adbname->name, rdtype, now,
2678 ((adbname->flags & DNS_ADBFIND_STARTATZONE) != 0),
2691 adbname->fetch_err = FIND_ERR_SUCCESS;
2693 adbname->fetch6_err = FIND_ERR_SUCCESS;
2695 result = import_rdataset(adbname, &rdataset, now);
2708 adbname->expire_v4 = now + 30;
2711 adbname);
2713 adbname->fetch_err = FIND_ERR_NXDOMAIN;
2715 adbname->fetch_err = FIND_ERR_NXRRSET;
2720 adbname);
2721 adbname->expire_v6 = now + 30;
2723 adbname->fetch6_err = FIND_ERR_NXDOMAIN;
2725 adbname->fetch6_err = FIND_ERR_NXRRSET;
2737 adbname->expire_v4 = rdataset.ttl + now;
2739 adbname->fetch_err = FIND_ERR_NXDOMAIN;
2741 adbname->fetch_err = FIND_ERR_NXRRSET;
2745 adbname, rdataset.ttl);
2750 adbname, rdataset.ttl);
2751 adbname->expire_v6 = rdataset.ttl + now;
2753 adbname->fetch6_err = FIND_ERR_NXDOMAIN;
2755 adbname->fetch6_err = FIND_ERR_NXRRSET;
2762 clean_target(adb, &adbname->target);
2763 adbname->expire_target = INT_MAX;
2764 result = set_target(adb, adbname->name, fname, &rdataset,
2765 &adbname->target);
2769 adbname);
2770 adbname->expire_target = ADJUSTED_EXPIRE(
2771 adbname->expire_target, now, rdataset.ttl);
2774 adbname->fetch_err = FIND_ERR_SUCCESS;
2776 adbname->fetch6_err = FIND_ERR_SUCCESS;
2959 fetch_name(dns_adbname_t *adbname, bool start_at_zone, unsigned int depth,
2970 REQUIRE(DNS_ADBNAME_VALID(adbname));
2972 adb = adbname->adb;
2976 REQUIRE((type == dns_rdatatype_a && !NAME_FETCH_A(adbname)) ||
2977 (type == dns_rdatatype_aaaa && !NAME_FETCH_AAAA(adbname)));
2979 adbname->fetch_err = FIND_ERR_NOTFOUND;
2987 adbname);
2989 result = dns_view_findzonecut(adb->view, adbname->name, name,
3015 adb->res, adbname->name, type, name, nameservers, NULL, NULL, 0,
3016 options, depth, qc, isc_loop(), fetch_callback, adbname,
3024 dns_adbname_ref(adbname);
3027 adbname->fetch_a = fetch;
3030 adbname->fetch_aaaa = fetch;
3415 dns_adbname_t *adbname = NULL;
3438 (void *)&key, (void **)&adbname);
3440 dns_adbname_ref(adbname);
3441 LOCK(&adbname->lock);
3442 if (dns_name_equal(name, adbname->name)) {
3443 expire_name(adbname, DNS_ADB_CANCELED);
3445 UNLOCK(&adbname->lock);
3446 dns_adbname_detach(&adbname);
3471 for (dns_adbname_t *adbname = ISC_LIST_HEAD(adb->names_lru);
3472 adbname != NULL; adbname = next)
3474 next = ISC_LIST_NEXT(adbname, link);
3475 dns_adbname_ref(adbname);
3476 LOCK(&adbname->lock);
3477 if (dns_name_issubdomain(adbname->name, name)) {
3478 expire_name(adbname, DNS_ADB_CANCELED);
3480 UNLOCK(&adbname->lock);
3481 dns_adbname_detach(&adbname);