Lines Matching refs:header
237 * If this is the top header for an rdataset, 'next' points
238 * to the top header for the next rdataset (i.e., the next type).
239 * Otherwise, it points up to the header whose down pointer points
240 * at this header.
245 * Points to the header for the next older version of
290 rdatasetheader_t *header;
308 #define EXISTS(header) \
309 (((header)->attributes & RDATASET_ATTR_NONEXISTENT) == 0)
310 #define NONEXISTENT(header) \
311 (((header)->attributes & RDATASET_ATTR_NONEXISTENT) != 0)
312 #define IGNORE(header) \
313 (((header)->attributes & RDATASET_ATTR_IGNORE) != 0)
314 #define RETAIN(header) \
315 (((header)->attributes & RDATASET_ATTR_RETAIN) != 0)
316 #define NXDOMAIN(header) \
317 (((header)->attributes & RDATASET_ATTR_NXDOMAIN) != 0)
318 #define RESIGN(header) \
319 (((header)->attributes & RDATASET_ATTR_RESIGN) != 0)
320 #define OPTOUT(header) \
321 (((header)->attributes & RDATASET_ATTR_OPTOUT) != 0)
322 #define NEGATIVE(header) \
323 (((header)->attributes & RDATASET_ATTR_NEGATIVE) != 0)
527 static inline isc_boolean_t need_headerupdate(rdatasetheader_t *header,
529 static void update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
531 static void expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
642 * Both init_count and header->count can be ISC_UINT32_MAX.
697 update_rrsetstats(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
707 if (NEGATIVE(header)) {
708 if (NXDOMAIN(header))
712 base = RBTDB_RDATATYPE_EXT(header->type);
715 base = RBTDB_RDATATYPE_BASE(header->type);
725 set_ttl(dns_rbtdb_t *rbtdb, rdatasetheader_t *header, dns_ttl_t newttl) {
730 oldttl = header->rdh_ttl;
731 header->rdh_ttl = newttl;
741 if (header->heap_index == 0 || newttl == oldttl)
743 idx = header->node->locknum;
749 isc_heap_increased(heap, header->heap_index);
751 isc_heap_decreased(heap, header->heap_index);
779 * This function sets the heap index into the header.
1193 free_acachearray(isc_mem_t *mctx, rdatasetheader_t *header,
1207 raw = (unsigned char *)header + sizeof(*header);
1244 fprintf(stderr, "initialized header: %p\n", h);
1261 fprintf(stderr, "allocated header: %p\n", h);
1305 rdatasetheader_t *header, *dcurrent;
1317 for (header = node->data; header != NULL; header = header->next) {
1318 if (header->serial == serial) {
1319 header->attributes |= RDATASET_ATTR_IGNORE;
1322 for (dcurrent = header->down;
2023 rdatasetheader_t *header, *header_next;
2033 for (header = node->data;
2034 header != NULL;
2035 header = header_next) {
2036 header_next = header->next;
2038 if (header->serial <= version->serial &&
2039 !IGNORE(header)) {
2040 if (NONEXISTENT(header))
2041 header = NULL;
2044 header = header->down;
2045 } while (header != NULL);
2047 if (header != NULL &&
2048 header->type == dns_rdatatype_nsec3param) {
2052 raw = (unsigned char *)header + sizeof(*header);
2156 rdatasetheader_t *header;
2328 for (header = HEAD(resigned_list);
2329 header != NULL;
2330 header = HEAD(resigned_list)) {
2333 ISC_LIST_UNLINK(resigned_list, header, link);
2335 lock = &rbtdb->node_locks[header->node->locknum].lock;
2338 resign_insert(rbtdb, header->node->locknum, header);
2339 decrement_reference(rbtdb, header->node, least_serial,
2567 rdatasetheader_t *header, *header_next;
2594 for (header = node->data; header != NULL; header = header_next) {
2595 header_next = header->next;
2596 if (header->type == dns_rdatatype_ns ||
2597 header->type == dns_rdatatype_dname ||
2598 header->type == RBTDB_RDATATYPE_SIGDNAME) {
2600 if (header->serial <= search->serial &&
2601 !IGNORE(header)) {
2606 if (NONEXISTENT(header))
2607 header = NULL;
2610 header = header->down;
2611 } while (header != NULL);
2612 if (header != NULL) {
2613 if (header->type == dns_rdatatype_dname)
2614 dname_header = header;
2615 else if (header->type ==
2617 sigdname_header = header;
2628 ns_header = header;
2710 rdatasetheader_t *header, isc_stdtime_t now,
2718 * the header count below. However, since the actual counter value
2732 rdataset->type = RBTDB_RDATATYPE_BASE(header->type);
2733 rdataset->covers = RBTDB_RDATATYPE_EXT(header->type);
2734 rdataset->ttl = header->rdh_ttl - now;
2735 rdataset->trust = header->trust;
2736 if (NEGATIVE(header))
2738 if (NXDOMAIN(header))
2740 if (OPTOUT(header))
2744 raw = (unsigned char *)header + sizeof(*header);
2746 rdataset->count = header->count++;
2759 rdataset->private6 = header->noqname;
2762 rdataset->private7 = header->closest;
2769 if (RESIGN(header)) {
2771 rdataset->resign = header->resign;
2843 rdatasetheader_t *header;
2863 header = search->zonecut_rdataset;
2864 raw = (unsigned char *)header + sizeof(*header);
2911 rdatasetheader_t *header;
2930 for (header = node->data;
2931 header != NULL;
2932 header = header->next) {
2933 if (header->serial <= search->serial &&
2934 !IGNORE(header) && EXISTS(header))
2939 if (header != NULL)
2968 rdatasetheader_t *header;
2997 for (header = node->data;
2998 header != NULL;
2999 header = header->next) {
3000 if (header->serial <= search->serial &&
3001 !IGNORE(header) && EXISTS(header))
3006 if (header != NULL)
3024 for (header = node->data;
3025 header != NULL;
3026 header = header->next) {
3027 if (header->serial <= search->serial &&
3028 !IGNORE(header) && EXISTS(header))
3033 if (header != NULL)
3071 rdatasetheader_t *header;
3109 for (header = node->data;
3110 header != NULL;
3111 header = header->next) {
3112 if (header->serial <= search->serial &&
3113 !IGNORE(header) && EXISTS(header))
3116 if (header != NULL)
3169 for (header = wnode->data;
3170 header != NULL;
3171 header = header->next) {
3172 if (header->serial <= search->serial &&
3173 !IGNORE(header) && EXISTS(header))
3177 if (header != NULL ||
3222 matchparams(rdatasetheader_t *header, rbtdb_search_t *search)
3231 REQUIRE(header->type == dns_rdatatype_nsec3);
3233 raw = (unsigned char *)header + sizeof(*header);
3275 rdatasetheader_t *header, *header_next, *found, *foundsig;
3311 for (header = node->data;
3312 header != NULL;
3313 header = header_next) {
3314 header_next = header->next;
3319 if (header->serial <= search->serial &&
3320 !IGNORE(header)) {
3325 if (NONEXISTENT(header))
3326 header = NULL;
3329 header = header->down;
3330 } while (header != NULL);
3331 if (header != NULL) {
3337 if (header->type == type) {
3338 found = header;
3341 } else if (header->type == sigtype) {
3342 foundsig = header;
3453 rdatasetheader_t *header, *header_next, *found, *nsecheader;
3615 for (header = node->data; header != NULL; header = header_next) {
3616 header_next = header->next;
3621 if (header->serial <= search.serial &&
3622 !IGNORE(header)) {
3627 if (NONEXISTENT(header))
3628 header = NULL;
3631 header = header->down;
3632 } while (header != NULL);
3633 if (header != NULL) {
3644 header->type == dns_rdatatype_ns) {
3652 search.zonecut_rdataset = header;
3683 if (header->type == dns_rdatatype_nsec3 &&
3684 !matchparams(header, &search)) {
3692 if (header->type == type ||
3694 (header->type == dns_rdatatype_cname &&
3699 found = header;
3700 if (header->type == dns_rdatatype_cname &&
3721 } else if (header->type == sigtype) {
3726 foundsig = header;
3732 } else if (header->type == dns_rdatatype_nsec &&
3739 nsecheader = header;
3740 } else if (header->type == RBTDB_RDATATYPE_SIGNSEC &&
3746 nsecsig = header;
3748 header->type == RBTDB_RDATATYPE_SIGCNAME) {
3753 cnamesig = header;
3970 rdatasetheader_t *header, *header_prev, *header_next;
3995 for (header = node->data; header != NULL; header = header_next) {
3996 header_next = header->next;
3997 if (header->rdh_ttl < search->now) {
4005 if ((header->rdh_ttl < search->now - RBTDB_VIRTUAL) &&
4023 * header->down can be non-NULL if the
4033 header);
4036 header->next;
4038 node->data = header->next;
4040 header);
4042 header->attributes |=
4045 header_prev = header;
4048 header_prev = header;
4049 } else if (header->type == dns_rdatatype_dname &&
4050 EXISTS(header)) {
4051 dname_header = header;
4052 header_prev = header;
4053 } else if (header->type == RBTDB_RDATATYPE_SIGDNAME &&
4054 EXISTS(header)) {
4055 sigdname_header = header;
4056 header_prev = header;
4058 header_prev = header;
4090 rdatasetheader_t *header, *header_prev, *header_next;
4117 for (header = node->data;
4118 header != NULL;
4119 header = header_next) {
4120 header_next = header->next;
4121 if (header->rdh_ttl < search->now) {
4129 if ((header->rdh_ttl < search->now -
4146 m, header);
4149 header->next;
4152 header->next;
4154 header);
4156 header->attributes |=
4159 header_prev = header;
4162 header_prev = header;
4163 } else if (EXISTS(header)) {
4168 if (header->type == dns_rdatatype_ns) {
4169 found = header;
4172 } else if (header->type ==
4174 foundsig = header;
4178 header_prev = header;
4180 header_prev = header;
4263 rdatasetheader_t *header, *header_next, *header_prev;
4294 for (header = node->data;
4295 header != NULL;
4296 header = header_next) {
4297 header_next = header->next;
4298 if (header->rdh_ttl < now) {
4306 if ((header->rdh_ttl < now - RBTDB_VIRTUAL) &&
4322 m, header);
4325 header->next;
4327 node->data = header->next;
4329 header);
4331 header->attributes |=
4334 header_prev = header;
4337 header_prev = header;
4340 if (NONEXISTENT(header) ||
4341 RBTDB_RDATATYPE_BASE(header->type) == 0) {
4342 header_prev = header;
4346 if (header->type == matchtype)
4347 found = header;
4348 else if (header->type == sigmatchtype)
4349 foundsig = header;
4350 header_prev = header;
4389 rdatasetheader_t *header, *header_prev, *header_next;
4478 for (header = node->data; header != NULL; header = header_next) {
4479 header_next = header->next;
4480 if (header->rdh_ttl < now) {
4487 if ((header->rdh_ttl < now - RBTDB_VIRTUAL) &&
4501 header);
4504 header->next;
4506 node->data = header->next;
4508 header);
4510 header->attributes |=
4513 header_prev = header;
4516 header_prev = header;
4517 } else if (EXISTS(header)) {
4528 if (header->type == type ||
4530 RBTDB_RDATATYPE_BASE(header->type) != 0) ||
4531 (cname_ok && header->type ==
4536 found = header;
4537 if (header->type == dns_rdatatype_cname &&
4546 } else if (header->type == sigtype) {
4551 foundsig = header;
4552 } else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
4553 header->type == negtype) {
4557 found = header;
4558 } else if (header->type == dns_rdatatype_ns) {
4564 nsheader = header;
4565 } else if (header->type == RBTDB_RDATATYPE_SIGNS) {
4570 nssig = header;
4572 header->type == RBTDB_RDATATYPE_SIGCNAME) {
4577 cnamesig = header;
4579 header_prev = header;
4581 header_prev = header;
4732 rdatasetheader_t *header, *header_prev, *header_next;
4785 for (header = node->data; header != NULL; header = header_next) {
4786 header_next = header->next;
4787 if (header->rdh_ttl < now) {
4794 if ((header->rdh_ttl < now - RBTDB_VIRTUAL) &&
4808 header);
4811 header->next;
4813 node->data = header->next;
4815 header);
4817 header->attributes |=
4820 header_prev = header;
4823 header_prev = header;
4824 } else if (EXISTS(header)) {
4829 if (header->type == dns_rdatatype_ns) {
4835 found = header;
4836 } else if (header->type == RBTDB_RDATATYPE_SIGNS) {
4841 foundsig = header;
4843 header_prev = header;
4845 header_prev = header;
4968 rdatasetheader_t *header;
5019 for (header = rbtnode->data; header != NULL; header = header->next)
5020 if (header->rdh_ttl <= now - RBTDB_VIRTUAL) {
5027 header->attributes |= RDATASET_ATTR_STALE;
5034 if (! RETAIN(header)) {
5035 set_ttl(rbtdb, header, 0);
5036 header->attributes |= RDATASET_ATTR_STALE;
5158 rdatasetheader_t *header, *header_next, *found, *foundsig;
5186 for (header = rbtnode->data; header != NULL; header = header_next) {
5187 header_next = header->next;
5189 if (header->serial <= serial &&
5190 !IGNORE(header)) {
5195 if (NONEXISTENT(header))
5196 header = NULL;
5199 header = header->down;
5200 } while (header != NULL);
5201 if (header != NULL) {
5206 if (header->type == matchtype) {
5207 found = header;
5210 } else if (header->type == sigmatchtype) {
5211 foundsig = header;
5245 rdatasetheader_t *header, *header_next, *found, *foundsig;
5274 for (header = rbtnode->data; header != NULL; header = header_next) {
5275 header_next = header->next;
5276 if (header->rdh_ttl < now) {
5277 if ((header->rdh_ttl < now - RBTDB_VIRTUAL) &&
5293 header->attributes |= RDATASET_ATTR_STALE;
5296 } else if (EXISTS(header)) {
5297 if (header->type == matchtype)
5298 found = header;
5299 else if (header->type == RBTDB_RDATATYPE_NCACHEANY ||
5300 header->type == negtype)
5301 found = header;
5302 else if (header->type == sigmatchtype)
5303 foundsig = header;
5390 rdatasetheader_t *header, *header_next;
5403 for (header = node->data; header != NULL; header = header_next) {
5404 header_next = header->next;
5405 if (header->type == dns_rdatatype_cname) {
5410 if (header->serial <= serial &&
5411 !IGNORE(header)) {
5416 if (NONEXISTENT(header))
5417 header = NULL;
5420 header = header->down;
5421 } while (header != NULL);
5422 if (header != NULL)
5431 rdtype = RBTDB_RDATATYPE_BASE(header->type);
5440 if (header->serial <= serial &&
5441 !IGNORE(header)) {
5446 if (NONEXISTENT(header))
5447 header = NULL;
5450 header = header->down;
5451 } while (header != NULL);
5452 if (header != NULL)
5482 rdatasetheader_t *topheader, *topheader_prev, *header, *sigheader;
5628 * If header isn't NULL, we've found the right type. There may be
5632 header = topheader;
5633 while (header != NULL && IGNORE(header))
5634 header = header->down;
5635 if (header != NULL) {
5636 header_nx = NONEXISTENT(header) ? ISC_TRUE : ISC_FALSE;
5650 if (rbtversion == NULL && trust < header->trust &&
5651 (header->rdh_ttl >= now || header_nx)) {
5654 bind_rdataset(rbtdb, rbtnode, header, now,
5667 * that is the union of 'newheader' and 'header'.
5671 INSIST(rbtversion->serial >= header->serial);
5678 newheader->rdh_ttl != header->rdh_ttl)
5680 else if (newheader->rdh_ttl != header->rdh_ttl)
5684 (unsigned char *)header,
5689 (dns_rdatatype_t)header->type,
5693 * If 'header' has the same serial number as
5704 RESIGN(header) &&
5705 header->resign < newheader->resign)
5706 newheader->resign = header->resign;
5720 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5721 header->type == dns_rdatatype_ns &&
5723 header->trust >= newheader->trust &&
5724 dns_rdataslab_equalx((unsigned char *)header,
5728 (dns_rdatatype_t)header->type)) {
5733 if (header->rdh_ttl > newheader->rdh_ttl)
5734 set_ttl(rbtdb, header, newheader->rdh_ttl);
5735 if (header->noqname == NULL &&
5737 header->noqname = newheader->noqname;
5740 if (header->closest == NULL &&
5742 header->closest = newheader->closest;
5747 bind_rdataset(rbtdb, rbtnode, header, now,
5756 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5757 header->type == dns_rdatatype_ns &&
5759 header->trust <= newheader->trust) {
5760 if (newheader->rdh_ttl > header->rdh_ttl) {
5761 newheader->rdh_ttl = header->rdh_ttl;
5764 if (IS_CACHE(rbtdb) && header->rdh_ttl >= now &&
5765 (header->type == dns_rdatatype_a ||
5766 header->type == dns_rdatatype_aaaa ||
5767 header->type == dns_rdatatype_ds ||
5768 header->type == RBTDB_RDATATYPE_SIGDDS) &&
5770 header->trust >= newheader->trust &&
5771 dns_rdataslab_equal((unsigned char *)header,
5778 if (header->rdh_ttl > newheader->rdh_ttl)
5779 set_ttl(rbtdb, header, newheader->rdh_ttl);
5780 if (header->noqname == NULL &&
5782 header->noqname = newheader->noqname;
5785 if (header->closest == NULL &&
5787 header->closest = newheader->closest;
5792 bind_rdataset(rbtdb, rbtnode, header, now,
5805 * There are no other references to 'header' when
5806 * loading, so we MAY clean up 'header' now.
5808 * loading, we MUST clean up 'header' now.
5811 free_rdataset(rbtdb, rbtdb->common.mctx, header);
5819 set_ttl(rbtdb, header, 0);
5820 header->attributes |= RDATASET_ATTR_STALE;
6040 rdatasetheader_t *header;
6156 header = isc_heap_element(rbtdb->heaps[rbtnode->locknum], 1);
6157 if (header && header->rdh_ttl < now - RBTDB_VIRTUAL)
6158 expire_header(rbtdb, header, tree_locked);
6200 rdatasetheader_t *topheader, *topheader_prev, *header, *newheader;
6263 * If header isn't NULL, we've found the right type. There may be
6267 header = topheader;
6268 while (header != NULL && IGNORE(header))
6269 header = header->down;
6270 if (header != NULL && EXISTS(header)) {
6276 if (newheader->rdh_ttl != header->rdh_ttl)
6281 (unsigned char *)header,
6286 (dns_rdatatype_t)header->type,
6295 * header, not newheader.
6308 * add a nonexistent header instead.
6777 rdatasetheader_t *header;
6783 header = rdataset->private3;
6784 header--;
6786 NODE_LOCK(&rbtdb->node_locks[header->node->locknum].lock,
6789 oldresign = header->resign;
6790 header->resign = resign;
6791 if (header->heap_index != 0) {
6792 INSIST(RESIGN(header));
6794 isc_heap_delete(rbtdb->heaps[header->node->locknum],
6795 header->heap_index);
6796 header->heap_index = 0;
6798 isc_heap_increased(rbtdb->heaps[header->node->locknum],
6799 header->heap_index);
6801 isc_heap_decreased(rbtdb->heaps[header->node->locknum],
6802 header->heap_index);
6803 } else if (resign && header->heap_index == 0) {
6804 header->attributes |= RDATASET_ATTR_RESIGN;
6805 result = resign_insert(rbtdb, header->node->locknum, header);
6807 NODE_UNLOCK(&rbtdb->node_locks[header->node->locknum].lock,
6817 rdatasetheader_t *header = NULL, *this;
6834 if (header == NULL)
6835 header = this;
6836 else if (isc_serial_lt(this->resign, header->resign)) {
6837 locknum = header->node->locknum;
6840 header = this;
6846 if (header == NULL)
6849 bind_rdataset(rbtdb, header->node, header, 0, rdataset);
6852 dns_rbt_fullnamefromnode(header->node, foundname);
6854 NODE_UNLOCK(&rbtdb->node_locks[header->node->locknum].lock,
6871 rdatasetheader_t *header;
6883 header = rdataset->private3;
6884 INSIST(header != NULL);
6885 header--;
6895 isc_heap_delete(rbtdb->heaps[node->locknum], header->heap_index);
6896 header->heap_index = 0;
6897 ISC_LIST_APPEND(rbtversion->resigned_list, header, link);
7566 rdatasetheader_t *header = rdataset->private3;
7568 header--;
7571 header->trust = rdataset->trust = trust;
7580 rdatasetheader_t *header = rdataset->private3;
7582 header--;
7585 expire_header(rbtdb, header, ISC_FALSE);
7616 rdatasetheader_t *header, *top_next;
7631 for (header = rbtnode->data; header != NULL; header = top_next) {
7632 top_next = header->next;
7634 if (header->serial <= serial && !IGNORE(header)) {
7640 * check for now > header->rdh_ttl instead
7641 * of now >= header->rdh_ttl. This allows
7645 if (NONEXISTENT(header) ||
7646 (now != 0 && now > header->rdh_ttl))
7647 header = NULL;
7650 header = header->down;
7651 } while (header != NULL);
7652 if (header != NULL)
7659 rbtiterator->current = header;
7661 if (header == NULL)
7673 rdatasetheader_t *header, *top_next;
7679 header = rbtiterator->current;
7680 if (header == NULL)
7694 type = header->type;
7695 rdtype = RBTDB_RDATATYPE_BASE(header->type);
7696 if (NEGATIVE(header)) {
7697 covers = RBTDB_RDATATYPE_EXT(header->type);
7701 for (header = header->next; header != NULL; header = top_next) {
7702 top_next = header->next;
7706 if (header->type != type && header->type != negtype) {
7708 if (header->serial <= serial &&
7709 !IGNORE(header)) {
7715 * check for now > header->ttl instead
7716 * of now >= header->ttl. This allows
7720 if ((header->attributes &
7722 (now != 0 && now > header->rdh_ttl))
7723 header = NULL;
7726 header = header->down;
7727 } while (header != NULL);
7728 if (header != NULL)
7736 rbtiterator->current = header;
7738 if (header == NULL)
7749 rdatasetheader_t *header;
7751 header = rbtiterator->current;
7752 REQUIRE(header != NULL);
7757 bind_rdataset(rbtdb, rbtnode, header, rbtiterator->common.now,
8290 rdatasetheader_t *header;
8300 header = (struct rdatasetheader *)(raw - sizeof(*header));
8313 acarray = header->additional_auth;
8319 acarray = header->additional_glue;
8375 acarray = cbarg->header->additional_auth;
8378 acarray = cbarg->header->additional_glue;
8434 rdatasetheader_t *header;
8447 header = (struct rdatasetheader *)(raw - sizeof(*header));
8458 newcbarg->header = header;
8482 acarray = header->additional_auth;
8485 acarray = header->additional_glue;
8509 header->additional_auth = acarray;
8512 header->additional_glue = acarray;
8564 rdatasetheader_t *header;
8577 header = (struct rdatasetheader *)(raw - sizeof(*header));
8591 acarray = header->additional_auth;
8594 acarray = header->additional_glue;
8647 need_headerupdate(rdatasetheader_t *header, isc_stdtime_t now) {
8648 if ((header->attributes &
8653 if (header->type == dns_rdatatype_ns ||
8654 (header->trust == dns_trust_glue &&
8655 (header->type == dns_rdatatype_a ||
8656 header->type == dns_rdatatype_aaaa))) {
8661 return (header->last_used + 60 <= now);
8665 return (header->last_used + 300 <= now);
8682 update_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
8688 INSIST(ISC_LINK_LINKED(header, link));
8690 ISC_LIST_UNLINK(rbtdb->rdatasets[header->node->locknum], header, link);
8691 header->last_used = now;
8692 ISC_LIST_PREPEND(rbtdb->rdatasets[header->node->locknum], header, link);
8709 rdatasetheader_t *header, *header_prev;
8719 header = isc_heap_element(rbtdb->heaps[locknum], 1);
8720 if (header && header->rdh_ttl < now - RBTDB_VIRTUAL) {
8721 expire_header(rbtdb, header, tree_locked);
8725 for (header = ISC_LIST_TAIL(rbtdb->rdatasets[locknum]);
8726 header != NULL && purgecount > 0;
8727 header = header_prev) {
8728 header_prev = ISC_LIST_PREV(header, link);
8736 ISC_LIST_UNLINK(rbtdb->rdatasets[locknum], header,
8738 expire_header(rbtdb, header, tree_locked);
8748 expire_header(dns_rbtdb_t *rbtdb, rdatasetheader_t *header,
8751 set_ttl(rbtdb, header, 0);
8752 header->attributes |= RDATASET_ATTR_STALE;
8753 header->node->dirty = 1;
8759 if (dns_rbtnode_refcurrent(header->node) == 0) {
8765 new_reference(rbtdb, header->node);
8766 decrement_reference(rbtdb, header->node, 0,