Lines Matching defs:rdataset
57 #include <dns/rdataset.h>
150 /*% Does the rdataset 'r' have an attached 'No QNAME Proof'? */
153 /*% Does the rdataset 'r' contain a stale answer? */
156 /*% Does the rdataset 'r' is stale and within stale-refresh-time? */
217 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
222 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
233 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset);
525 dns_rdataset_t *rdataset;
550 rdataset = ISC_LIST_HEAD(client->query.qname->list);
551 if (rdataset != NULL) {
552 qtype = rdataset->type;
823 ns_client_putrdataset(client, &client->query.redirect.rdataset);
1251 dns_rdataset_t *rdataset;
1292 rdataset = ISC_LIST_HEAD(client->query.origqname->list);
1293 INSIST(rdataset != NULL);
1294 dns_rdataclass_format(rdataset->rdclass, classbuf, sizeof(classbuf));
1295 dns_rdatatype_format(rdataset->type, typebuf, sizeof(typebuf));
1568 * The name exists, but the rdataset does not.
1595 * - if 'type' is not ANY, dns_db_findext() will put the exact rdataset being
1596 * looked for in 'rdataset' and its signatures (if any) in 'sigrdataset',
1598 * - if 'type' is ANY, dns_db_findext() will leave 'rdataset' and
1606 * - 'rdataset' and 'sigrdataset' will remain disassociated.
1612 dns_name_t *fname, dns_rdataset_t *rdataset,
1629 fname, &cm, &ci, rdataset, sigrdataset);
1631 if (dns_rdataset_isassociated(rdataset)) {
1632 dns_rdataset_disassociate(rdataset);
1673 * - potentially bind 'rdataset' and 'sigrdataset', as explained in the
1680 * - 'rdataset' and 'sigrdataset' will remain disassociated.
1685 dns_name_t *fname, dns_rdataset_t *rdataset,
1714 &node, fname, rdataset, sigrdataset);
1737 rdataset, sigrdataset);
1762 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
1804 rdataset = ns_client_newrdataset(client);
1823 rdataset, sigrdataset);
1855 client->now, &node, fname, &cm, &ci, rdataset,
1866 if (dns_rdataset_isassociated(rdataset)) {
1867 dns_rdataset_disassociate(rdataset);
1914 client->now, &node, fname, &cm, &ci, rdataset,
1924 * We have found a potential additional data rdataset, or
1930 * Does the caller want the found rdataset?
1932 if (found != NULL && dns_rdataset_isassociated(rdataset)) {
1933 dns_rdataset_clone(rdataset, found);
1937 * If we have an rdataset, add it to the additional data
1941 if (dns_rdataset_isassociated(rdataset) &&
1951 ISC_LIST_APPEND(fname->list, rdataset, link);
1952 trdataset = rdataset;
1953 rdataset = NULL;
1957 * so we do not need to check if the SIG rdataset is already
1975 if (rdataset != NULL) {
1976 if (dns_rdataset_isassociated(rdataset)) {
1977 dns_rdataset_disassociate(rdataset);
1980 rdataset = ns_client_newrdataset(client);
1993 0, client->now, rdataset,
1998 dns_rdataset_disassociate(rdataset);
2009 (DNS_TRUST_PENDING(rdataset->trust) ||
2010 DNS_TRUST_GLUE(rdataset->trust)))
2012 /* validate() may change rdataset->trust */
2013 invalid = !validate(client, db, fname, rdataset,
2016 if (invalid && DNS_TRUST_PENDING(rdataset->trust)) {
2017 dns_rdataset_disassociate(rdataset);
2035 ISC_LIST_APPEND(fname->list, rdataset, link);
2045 rdataset = ns_client_newrdataset(client);
2047 dns_rdataset_disassociate(rdataset);
2062 rdataset, sigrdataset);
2066 dns_rdataset_disassociate(rdataset);
2078 (DNS_TRUST_PENDING(rdataset->trust) ||
2079 DNS_TRUST_GLUE(rdataset->trust)))
2081 /* validate() may change rdataset->trust */
2082 invalid = !validate(client, db, fname, rdataset,
2086 if (invalid && DNS_TRUST_PENDING(rdataset->trust)) {
2087 dns_rdataset_disassociate(rdataset);
2106 ISC_LIST_APPEND(fname->list, rdataset, link);
2115 rdataset = NULL;
2159 ns_client_putrdataset(client, &rdataset);
2178 * Add 'rdataset' to 'name'.
2181 query_addtoname(dns_name_t *name, dns_rdataset_t *rdataset) {
2182 ISC_LIST_APPEND(name->list, rdataset, link);
2186 * Set the ordering for 'rdataset'.
2189 query_setorder(query_ctx_t *qctx, dns_name_t *name, dns_rdataset_t *rdataset) {
2198 rdataset->attributes |= dns_order_find(
2199 order, name, rdataset->type, rdataset->rdclass);
2201 rdataset->attributes |= DNS_RDATASETATTR_LOADORDER;
2205 * Handle glue and fetch any other needed additional data for 'rdataset'.
2209 dns_rdataset_t *rdataset) {
2222 if (rdataset->type == dns_rdatatype_ns &&
2232 result = dns_db_addglue(qctx->db, dbversion->version, rdataset,
2244 (void)dns_rdataset_additionaldata(rdataset, name, query_additional_cb,
2256 dns_rdataset_t *rdataset = *rdatasetp, *mrdataset = NULL;
2278 rdataset->type, rdataset->covers, &mname,
2289 if ((rdataset->attributes & DNS_RDATASETATTR_REQUIRED) != 0) {
2292 if ((rdataset->attributes & DNS_RDATASETATTR_STALE_ADDED) != 0)
2314 if (rdataset->trust != dns_trust_secure &&
2321 * Update message name, set rdataset order, and do additional
2324 query_addtoname(mname, rdataset);
2325 query_setorder(qctx, mname, rdataset);
2326 query_additional(qctx, mname, rdataset);
2330 * we do not need to check if the SIG rdataset is already in the
2351 dns_rdata_rrsig_t *rrsig, dns_rdataset_t *rdataset,
2359 rdataset->trust = dns_trust_secure;
2373 dns_rdataset_trimttl(rdataset, sigrdataset, rrsig, now,
2376 (void)dns_db_addrdataset(db, node, NULL, client->now, rdataset, 0,
2451 verify(dst_key_t *key, dns_name_t *name, dns_rdataset_t *rdataset,
2460 result = dns_dnssec_verify(name, rdataset, key, ignore,
2474 * Validate the rdataset if possible with available records.
2478 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
2509 if (verify(key, name, rdataset, &rdata, client)) {
2512 mark_secure(client, db, name, &rrsig, rdataset,
2526 fixrdataset(ns_client_t *client, dns_rdataset_t **rdataset) {
2527 if (*rdataset == NULL) {
2528 *rdataset = ns_client_newrdataset(client);
2529 } else if (dns_rdataset_isassociated(*rdataset)) {
2530 dns_rdataset_disassociate(*rdataset);
2558 if (fresp->rdataset != NULL) {
2559 ns_client_putrdataset(client, &fresp->rdataset);
2691 &cm, &ci, qctx.rdataset, qctx.sigrdataset);
2817 dns_rdataset_t *rdataset) {
2822 rdataset->ttl > client->view->prefetch_trigger ||
2823 (rdataset->attributes & DNS_RDATASETATTR_PREFETCH) == 0)
2828 fetch_and_forget(client, qname, rdataset->type, RECTYPE_PREFETCH);
2830 dns_rdataset_clearprefetch(rdataset);
2881 rpz_clean(&st->m.zone, &st->m.db, &st->m.node, &st->m.rdataset);
2905 if (st->m.rdataset != NULL) {
2906 ns_client_putrdataset(client, &st->m.rdataset);
2919 if (st->q.rdataset != NULL) {
2920 ns_client_putrdataset(client, &st->q.rdataset);
3225 * The target DNS type, qtype, chooses the best rdataset for *rdatasetp.
3271 * Choose the best rdataset if we found something.
3408 * Save the replacement rdataset from the policy
3409 * and make the previous replacement rdataset scratch.
3411 SAVE(trdataset, st->m.rdataset);
3412 SAVE(st->m.rdataset, *rdatasetp);
3414 st->m.ttl = ISC_MIN(st->m.rdataset->ttl, rpz->max_policy_ttl);
3477 * Ready the shim database and rdataset for a DNSRPS hit.
3561 * Get the DNSPRS imitation rdataset.
3872 * Get the A or AAAA rdataset.
3929 * Check all of the IP addresses in the rdataset.
4022 * Try to rewrite a request for a qtype rdataset based on the trigger name
4024 * Record the results including the replacement rdataset if any
4026 * *rdatasetp is a scratch rdataset.
4225 dns_rdataset_t *rdataset;
4360 rdataset = NULL;
4396 zbits, &rdataset);
4412 allowed, norec, &rdataset);
4462 &rdataset, resuming);
4587 true, &rdataset);
4599 &rdataset, resuming);
4638 !dnsrps_set_p(&emsg, client, st, qtype, &rdataset,
4670 ns_client_putrdataset(client, &rdataset);
4684 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset) {
4715 if (rdataset == NULL || !dns_rdataset_isassociated(rdataset)) {
4721 if (rdataset->type == dns_rdatatype_nsec ||
4722 rdataset->type == dns_rdatatype_nsec3 ||
4723 rdataset->type == dns_rdatatype_rrsig)
4729 * Look for a signature in a negative cache rdataset.
4731 if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) == 0) {
4736 for (result = dns_rdataset_first(rdataset); result == ISC_R_SUCCESS;
4737 result = dns_rdataset_next(rdataset))
4739 dns_ncache_current(rdataset, found, &trdataset);
4839 warn_rfc1918(ns_client_t *client, dns_name_t *fname, dns_rdataset_t *rdataset) {
4850 rdataset, &rfc1918names[i], dns_rdatatype_soa,
4882 dns_rdataset_t *rdataset, dns_rdataset_t *sigrdataset,
4931 NULL, fname, &cm, &ci, rdataset, sigrdataset);
4934 if (!dns_rdataset_isassociated(rdataset)) {
4937 result = dns_rdataset_first(rdataset);
4939 dns_rdataset_current(rdataset, &rdata);
4947 dns_rdataset_disassociate(rdataset);
4988 dns_rdataset_t rdataset;
4992 dns_rdataset_init(&rdataset);
5000 &rdataset, NULL);
5004 result = dns_rdataset_first(&rdataset);
5009 dns_rdataset_current(&rdataset, &rdata);
5012 ttl = ISC_MIN(rdataset.ttl, soa.minimum);
5015 if (dns_rdataset_isassociated(&rdataset)) {
5016 dns_rdataset_disassociate(&rdataset);
5025 dns64_aaaaok(ns_client_t *client, dns_rdataset_t *rdataset,
5053 count = dns_rdataset_count(rdataset);
5058 rdataset, aaaaok, count))
5089 redirect(ns_client_t *client, dns_name_t *name, dns_rdataset_t *rdataset,
5121 if (WANTDNSSEC(client) && dns_rdataset_isassociated(rdataset)) {
5122 if (rdataset->trust == dns_trust_secure) {
5125 if (rdataset->trust == dns_trust_ultimate &&
5126 (rdataset->type == dns_rdatatype_nsec ||
5127 rdataset->type == dns_rdatatype_nsec3))
5131 if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) {
5132 for (result = dns_rdataset_first(rdataset);
5134 result = dns_rdataset_next(rdataset))
5136 dns_ncache_current(rdataset, found, &trdataset);
5174 if (dns_rdataset_isassociated(rdataset)) {
5175 dns_rdataset_disassociate(rdataset);
5194 if (dns_rdataset_isassociated(rdataset)) {
5195 dns_rdataset_disassociate(rdataset);
5198 dns_rdataset_clone(&trdataset, rdataset);
5219 redirect2(ns_client_t *client, dns_name_t *name, dns_rdataset_t *rdataset,
5259 if (WANTDNSSEC(client) && dns_rdataset_isassociated(rdataset)) {
5260 if (rdataset->trust == dns_trust_secure) {
5263 if (rdataset->trust == dns_trust_ultimate &&
5264 (rdataset->type == dns_rdatatype_nsec ||
5265 rdataset->type == dns_rdatatype_nsec3))
5269 if ((rdataset->attributes & DNS_RDATASETATTR_NEGATIVE) != 0) {
5270 for (result = dns_rdataset_first(rdataset);
5272 result = dns_rdataset_next(rdataset))
5274 dns_ncache_current(rdataset, found, &trdataset);
5322 if (dns_rdataset_isassociated(rdataset)) {
5323 dns_rdataset_disassociate(rdataset);
5379 if (dns_rdataset_isassociated(rdataset)) {
5380 dns_rdataset_disassociate(rdataset);
5383 dns_rdataset_clone(&trdataset, rdataset);
5450 * Clean up and disassociate the rdataset and node pointers in qctx.
5454 if (qctx->rdataset != NULL && dns_rdataset_isassociated(qctx->rdataset))
5456 dns_rdataset_disassociate(qctx->rdataset);
5473 if (qctx->rdataset != NULL) {
5474 ns_client_putrdataset(qctx->client, &qctx->rdataset);
5540 INITANDSAVE(tgt->rdataset, src->rdataset);
5804 ns_client_putrdataset(qctx->client, &qctx->rdataset);
5955 qctx->rdataset = ns_client_newrdataset(qctx->client);
6065 qctx->fname, &cm, &ci, qctx->rdataset,
6097 stale_refresh_window = (STALE_WINDOW(qctx->rdataset) &&
6109 if (dns_rdataset_isassociated(qctx->rdataset) &&
6110 dns_rdataset_count(qctx->rdataset) > 0 && !STALE(qctx->rdataset))
6112 /* Found non-stale usable rdataset. */
6123 if (dns_rdataset_isassociated(qctx->rdataset) &&
6124 dns_rdataset_count(qctx->rdataset) > 0 &&
6125 STALE(qctx->rdataset))
6135 qctx->rdataset->ttl = qctx->view->staleanswerttl;
6218 qctx->refresh_rrset = STALE(qctx->rdataset);
6238 qctx->rdataset->attributes |= DNS_RDATASETATTR_STALE_ADDED;
6258 * Clean up name lists by calling the rdataset disassociate function.
6534 dns_rdataset_t *rdataset, *sigrdataset;
6566 rdataset = ns_client_newrdataset(client);
6587 rdataset, sigrdataset, &FETCH_RECTYPE_NORMAL(client));
6591 ns_client_putrdataset(client, &rdataset);
6665 RESTORE(qctx->rdataset, qctx->rpz_st->q.rdataset);
6674 SAVE(qctx->rpz_st->r.r_rdataset, qctx->fresp->rdataset);
6692 INSIST(qctx->client->query.redirect.rdataset != NULL);
6693 RESTORE(qctx->rdataset, qctx->client->query.redirect.rdataset);
6705 ns_client_putrdataset(qctx->client, &qctx->fresp->rdataset);
6720 SAVE(qctx->rdataset, qctx->fresp->rdataset);
6723 INSIST(qctx->rdataset != NULL);
7158 qctx->rdataset != NULL &&
7159 dns_rdataset_isassociated(qctx->rdataset) &&
7160 (qctx->rdataset->attributes &
7168 for (nc_result = dns_rdataset_first(qctx->rdataset);
7170 nc_result = dns_rdataset_next(qctx->rdataset))
7172 dns_ncache_current(qctx->rdataset,
7281 qctx->rdataset, qctx->sigrdataset);
7301 SAVE(qctx->rpz_st->q.rdataset, qctx->rdataset);
7330 if (qctx->rpz_st->m.rdataset != NULL) {
7331 ns_client_putrdataset(qctx->client, &qctx->rdataset);
7332 RESTORE(qctx->rdataset, qctx->rpz_st->m.rdataset);
7400 if (dns_rdataset_isassociated(qctx->rdataset)) {
7402 qctx->rdataset);
7406 * We will add this rdataset.
7408 qctx->rdataset->ttl =
7409 ISC_MIN(qctx->rdataset->ttl,
7417 result = dns_rdataset_first(qctx->rdataset);
7419 dns_rdataset_current(qctx->rdataset, &rdata);
7625 if (!qctx->is_zone && qctx->rdataset->trust == dns_trust_secure &&
7931 dns_rdatasetiter_current(rdsiter, qctx->rdataset);
7937 qctx->rdataset->type == dns_rdatatype_ns)
7950 dns_rdatatype_isdnssec(qctx->rdataset->type))
7956 dns_rdataset_disassociate(qctx->rdataset);
7961 (qctx->rdataset->type == dns_rdatatype_sig ||
7962 qctx->rdataset->type == dns_rdatatype_rrsig))
7966 dns_rdataset_disassociate(qctx->rdataset);
7968 onetype != 0 && qctx->rdataset->type != onetype &&
7969 qctx->rdataset->covers != onetype)
7972 "minimal-any skip rdataset");
7973 dns_rdataset_disassociate(qctx->rdataset);
7975 qctx->rdataset->type == qctx->qtype) &&
7976 qctx->rdataset->type != 0)
7978 if (NOQNAME(qctx->rdataset) && WANTDNSSEC(qctx->client))
7980 qctx->noqname = qctx->rdataset;
7987 qctx->rdataset->ttl =
7988 ISC_MIN(qctx->rdataset->ttl,
7997 qctx->rdataset);
8004 if (qctx->rdataset->type == dns_rdatatype_sig ||
8005 qctx->rdataset->type == dns_rdatatype_rrsig)
8007 onetype = qctx->rdataset->covers;
8009 onetype = qctx->rdataset->type;
8015 &qctx->rdataset, NULL, NULL,
8024 * rdataset is non-NULL only in certain
8027 if (qctx->rdataset != NULL) {
8029 &qctx->rdataset);
8032 qctx->rdataset = ns_client_newrdataset(qctx->client);
8035 * We're not interested in this rdataset.
8037 dns_rdataset_disassociate(qctx->rdataset);
8046 CCTRACE(ISC_LOG_ERROR, "query_respond_any: rdataset iterator "
8067 * At least one matching rdataset was found
8149 result = dns_rdataset_first(qctx->rdataset);
8152 dns_rdataset_current(qctx->rdataset, &rdata);
8198 dns_rdataset_disassociate(qctx->rdataset);
8200 &qctx->rdataset);
8226 ns_client_putrdataset(qctx->client, &qctx->rdataset);
8232 qctx->rdataset);
8237 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
8266 !dns64_aaaaok(qctx->client, qctx->rdataset, qctx->sigrdataset))
8271 qctx->client->query.dns64_ttl = qctx->rdataset->ttl;
8272 SAVE(qctx->client->query.dns64_aaaa, qctx->rdataset);
8292 if (NOQNAME(qctx->rdataset) && WANTDNSSEC(qctx->client)) {
8293 qctx->noqname = qctx->rdataset;
8336 * 'qctx->rdataset' will only be non-NULL here if the ANSWER section of
8338 * the same owner name and the same type as 'qctx->rdataset'. This
8342 * knowing that until now. In such a case, 'qctx->rdataset' will be
8345 INSIST(qctx->rdataset == NULL || qctx->qtype == dns_rdatatype_dname);
8398 qctx->rdataset->covers, &mname, &mrdataset);
8427 if (qctx->rdataset->trust != dns_trust_secure) {
8435 dns_rdataset_count(qctx->rdataset));
8443 dns64_rdatalist->ttl = ISC_MIN(qctx->rdataset->ttl,
8446 dns64_rdatalist->ttl = ISC_MIN(qctx->rdataset->ttl, 600);
8463 for (result = dns_rdataset_first(qctx->rdataset);
8465 result = dns_rdataset_next(qctx->rdataset))
8470 dns_rdataset_current(qctx->rdataset, &rdata);
8504 dns64_rdataset->trust = qctx->rdataset->trust;
8558 dns_rdataset_count(qctx->rdataset));
8568 qctx->rdataset->covers, &mname, &myrdataset);
8591 if (qctx->rdataset->trust != dns_trust_secure) {
8596 16 * dns_rdataset_count(qctx->rdataset));
8603 myrdatalist->ttl = qctx->rdataset->ttl;
8606 for (result = dns_rdataset_first(qctx->rdataset);
8608 result = dns_rdataset_next(qctx->rdataset))
8613 dns_rdataset_current(qctx->rdataset, &rdata);
8640 myrdataset->trust = qctx->rdataset->trust;
8710 qctx->rdataset, qctx->sigrdataset);
8807 query_addrrset(qctx, &qctx->fname, &qctx->rdataset, sigrdatasetp,
8859 ns_client_putrdataset(qctx->client, &qctx->rdataset);
8895 * rdataset, and sigrdataset. We'll then go looking for
8906 SAVE(qctx->zrdataset, qctx->rdataset);
8971 ns_client_putrdataset(qctx->client, &qctx->rdataset);
8983 RESTORE(qctx->rdataset, qctx->zrdataset);
9042 qctx->fname, qctx->rdataset,
9081 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
9098 rdataset = ns_client_newrdataset(client);
9105 dns_rdatatype_ds, 0, client->now, rdataset,
9113 0, client->now, rdataset, sigrdataset);
9118 if (!dns_rdataset_isassociated(rdataset) ||
9157 query_addrrset(qctx, &rname, &rdataset, &sigrdataset, NULL,
9171 if (dns_rdataset_isassociated(rdataset)) {
9172 dns_rdataset_disassociate(rdataset);
9178 query_findclosestnsec3(name, qctx->db, qctx->version, client, rdataset,
9181 if (!dns_rdataset_isassociated(rdataset)) {
9184 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
9196 fixrdataset(client, &rdataset);
9198 if (fname == NULL || rdataset == NULL || sigrdataset == NULL) {
9202 qctx->version, client, rdataset,
9204 if (!dns_rdataset_isassociated(rdataset)) {
9207 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
9212 if (rdataset != NULL) {
9213 ns_client_putrdataset(client, &rdataset);
9244 if (qctx->rdataset != NULL) {
9245 ns_client_putrdataset(qctx->client, &qctx->rdataset);
9250 RESTORE(qctx->rdataset, qctx->client->query.dns64_aaaa);
9283 if (qctx->rdataset->ttl != 0) {
9285 qctx->rdataset->ttl;
9288 if (dns_rdataset_first(qctx->rdataset) == ISC_R_SUCCESS)
9301 SAVE(qctx->client->query.dns64_aaaa, qctx->rdataset);
9317 if (dns_rdataset_isassociated(qctx->rdataset)) {
9322 ISC_LIST_APPEND(qctx->fname->list, qctx->rdataset,
9325 qctx->rdataset = NULL;
9350 if (!dns_rdataset_isassociated(qctx->rdataset) &&
9363 qctx->client, qctx->rdataset,
9371 if (dns_rdataset_isassociated(qctx->rdataset) &&
9384 &qctx->rdataset,
9395 fixrdataset(qctx->client, &qctx->rdataset);
9398 qctx->rdataset == NULL ||
9416 qctx->client, qctx->rdataset,
9425 if (dns_rdataset_isassociated(qctx->rdataset)) {
9457 dns_rdataset_isassociated(qctx->rdataset))
9478 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
9515 query_addrrset(qctx, &fname, &qctx->rdataset, &qctx->sigrdataset, dbuf,
9541 if (dns_rdataset_isassociated(qctx->rdataset)) {
9588 if (dns_rdataset_isassociated(qctx->rdataset)) {
9589 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
9628 result = redirect(qctx->client, qctx->fname, qctx->rdataset,
9646 result = redirect2(qctx->client, qctx->fname, qctx->rdataset,
9660 INSIST(qctx->rdataset != NULL);
9661 SAVE(qctx->client->query.redirect.rdataset, qctx->rdataset);
9747 ttl = query_synthttl(*soardatasetp, *sigsoardatasetp, qctx->rdataset,
9778 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
9791 * Synthesize a wildcard answer using the contents of 'rdataset'.
9795 query_synthwildcard(query_ctx_t *qctx, dns_rdataset_t *rdataset,
9819 dns_rdataset_clone(rdataset, cloneset);
9839 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
9858 * Add a synthesized CNAME record from the wildard RRset (rdataset)
9863 query_synthcnamewildcard(query_ctx_t *qctx, dns_rdataset_t *rdataset,
9870 result = query_synthwildcard(qctx, rdataset, sigrdataset);
9883 result = dns_rdataset_first(rdataset);
9889 dns_rdataset_current(rdataset, &rdata);
9935 ttl = query_synthttl(*soardatasetp, *sigsoardatasetp, qctx->rdataset,
9967 query_addrrset(qctx, &qctx->fname, &qctx->rdataset,
10071 dns_rdataset_t rdataset, sigrdataset;
10082 dns_rdataset_init(&rdataset);
10129 if (!dns_nsec_requiredtypespresent(qctx->rdataset)) {
10137 qctx->fname, qctx->rdataset, &exists,
10154 if (!qctx->resuming && !STALE(qctx->rdataset) &&
10155 qctx->rdataset->ttl == 0 && RECURSIONOK(qctx->client))
10188 &rdataset, &sigrdataset);
10190 if (rdataset.trust != dns_trust_secure ||
10216 if (!qctx->resuming && !STALE(&rdataset) && rdataset.ttl == 0 &&
10235 &rdataset, &exists, &data, NULL,
10242 (void)query_synthwildcard(qctx, &rdataset, &sigrdataset);
10246 (void)query_synthcnamewildcard(qctx, &rdataset, &sigrdataset);
10298 (void)query_synthnxdomainnodata(qctx, exists, nowild, &rdataset,
10304 if (dns_rdataset_isassociated(&rdataset)) {
10305 dns_rdataset_disassociate(&rdataset);
10338 ns_client_putrdataset(qctx->client, &qctx->rdataset);
10379 warn_rfc1918(qctx->client, qctx->fname, qctx->rdataset);
10398 if (qctx->is_zone || qctx->resuming || STALE(qctx->rdataset) ||
10399 qctx->rdataset->ttl != 0 || !RECURSIONOK(qctx->client))
10458 * Keep a copy of the rdataset. We have to do this because
10459 * query_addrrset may clear 'rdataset' (to prevent the
10462 trdataset = qctx->rdataset;
10478 if (NOQNAME(qctx->rdataset) && WANTDNSSEC(qctx->client)) {
10479 qctx->noqname = qctx->rdataset;
10485 query_prefetch(qctx->client, qctx->fname, qctx->rdataset);
10488 query_addrrset(qctx, &qctx->fname, &qctx->rdataset, sigrdatasetp,
10565 * Keep a copy of the rdataset. We have to do this because
10566 * query_addrrset may clear 'rdataset' (to prevent the
10569 trdataset = qctx->rdataset;
10586 query_prefetch(qctx->client, qctx->fname, qctx->rdataset);
10588 query_addrrset(qctx, &qctx->fname, &qctx->rdataset, sigrdatasetp,
10693 dns_rdataset_t *rdataset = NULL;
10707 dns_message_gettemprdataset(client->message, &rdataset);
10720 dns_rdatalist_tordataset(rdatalist, rdataset);
10721 rdataset->trust = trust;
10722 dns_rdataset_setownercase(rdataset, aname);
10724 query_addrrset(qctx, &aname, &rdataset, NULL, NULL, DNS_SECTION_ANSWER);
10725 if (rdataset != NULL) {
10726 if (dns_rdataset_isassociated(rdataset)) {
10727 dns_rdataset_disassociate(rdataset);
10729 dns_message_puttemprdataset(client->message, &rdataset);
10783 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
10797 (!WANTDNSSEC(client) || !dns_rdataset_isassociated(qctx->rdataset)))
10813 rdataset = ns_client_newrdataset(client);
10825 rdataset, sigrdataset);
10835 fname, &cm, &ci, rdataset, sigrdataset);
10850 result = dns_rdataset_first(rdataset);
10852 dns_rdataset_current(rdataset, &rdata);
10856 if (override_ttl != UINT32_MAX && override_ttl < rdataset->ttl)
10858 rdataset->ttl = override_ttl;
10868 if (rdataset->ttl > soa.minimum) {
10869 rdataset->ttl = soa.minimum;
10882 rdataset->attributes |= DNS_RDATASETATTR_REQUIRED;
10884 query_addrrset(qctx, &name, &rdataset, sigrdatasetp, NULL,
10888 ns_client_putrdataset(client, &rdataset);
10912 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
10933 rdataset = ns_client_newrdataset(client);
10940 * Find the NS rdataset.
10946 rdataset, sigrdataset);
10951 fname, &cm, &ci, rdataset, sigrdataset);
10959 * This is bad. We tried to get the NS rdataset at the zone
10967 query_addrrset(qctx, &name, &rdataset, sigrdatasetp, NULL,
10972 ns_client_putrdataset(client, &rdataset);
10996 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
11057 rdataset = ns_client_newrdataset(client);
11074 &ci, rdataset, sigrdataset);
11083 SAVE(zrdataset, rdataset);
11093 client->now, &node, fname, NULL, rdataset, sigrdataset);
11124 ns_client_putrdataset(client, &rdataset);
11136 RESTORE(rdataset, zrdataset);
11143 if ((DNS_TRUST_PENDING(rdataset->trust) ||
11145 !validate(client, db, fname, rdataset, sigrdataset) &&
11151 if ((DNS_TRUST_GLUE(rdataset->trust) ||
11153 !validate(client, db, fname, rdataset, sigrdataset) &&
11164 ((rdataset->trust != dns_trust_secure) ||
11178 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
11182 if (rdataset != NULL) {
11183 ns_client_putrdataset(client, &rdataset);
11218 dns_rdataset_t *rdataset = NULL, *sigrdataset = NULL;
11302 rdataset = ns_client_newrdataset(client);
11307 &cm, &ci, rdataset, sigrdataset);
11312 if (!dns_rdataset_isassociated(rdataset)) {
11348 rdataset, sigrdataset, fname, true,
11350 if (!dns_rdataset_isassociated(rdataset)) {
11354 query_addrrset(qctx, &fname, &rdataset, &sigrdataset,
11366 if (rdataset == NULL) {
11367 rdataset = ns_client_newrdataset(client);
11368 } else if (dns_rdataset_isassociated(rdataset)) {
11369 dns_rdataset_disassociate(rdataset);
11389 rdataset, sigrdataset, fname, false,
11391 if (!dns_rdataset_isassociated(rdataset)) {
11394 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
11409 if (rdataset == NULL) {
11410 rdataset = ns_client_newrdataset(client);
11411 } else if (dns_rdataset_isassociated(rdataset)) {
11412 dns_rdataset_disassociate(rdataset);
11431 rdataset, sigrdataset, fname, nodata,
11433 if (!dns_rdataset_isassociated(rdataset)) {
11436 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
11442 result = dns_rdataset_first(rdataset);
11445 dns_rdataset_current(rdataset, &rdata);
11472 query_addrrset(qctx, &fname, &rdataset, &sigrdataset, dbuf,
11475 if (rdataset != NULL) {
11476 ns_client_putrdataset(client, &rdataset);
11492 if (rdataset != NULL) {
11493 ns_client_putrdataset(client, &rdataset);
11615 dns_rdataset_t *rdataset = NULL;
11630 for (rdataset = ISC_LIST_HEAD(name->list);
11631 rdataset != NULL;
11632 rdataset = ISC_LIST_NEXT(rdataset, link))
11634 if (rdataset->type == qctx->qtype) {
11641 if (rdataset != NULL) {
11644 ISC_LIST_UNLINK(name->list, rdataset, link);
11645 ISC_LIST_PREPEND(name->list, rdataset, link);
11646 rdataset->attributes |= DNS_RDATASETATTR_REQUIRED;
11887 dns_rdataset_t *rdataset;
11894 rdataset = ISC_LIST_HEAD(client->query.qname->list);
11895 INSIST(rdataset != NULL);
11897 dns_rdataclass_format(rdataset->rdclass, classbuf, sizeof(classbuf));
11898 dns_rdatatype_format(rdataset->type, typebuf, sizeof(typebuf));
11918 dns_rdataset_t *rdataset;
11937 rdataset = ISC_LIST_HEAD(client->query.origqname->list);
11938 if (rdataset != NULL) {
11939 dns_rdataclass_format(rdataset->rdclass, classbuf,
11942 dns_rdatatype_format(rdataset->type, typebuf,
11959 dns_rdataset_t *rdataset;
12068 rdataset = ISC_LIST_HEAD(client->query.qname->list);
12069 INSIST(rdataset != NULL);
12070 client->query.qtype = qtype = rdataset->type;
12123 ns_xfr_start(client, rdataset->type);