Lines Matching defs:query
118 "resquery %p (fctx %p(%s)): %s", query, query->fctx, \
119 query->fctx->info, (m))
172 * The maximum time we will wait for a single query.
188 * A minumum sane timeout value for the whole query to live when e.g. talking to
192 * values of 'resolver-query-timeout' less than or equal to 300 are treated as
200 * The default time in seconds for the whole query to live.
201 * We want to allow an individual query time to complete / timeout.
207 /* The maximum time in seconds for the whole query to live. */
253 * disable EDNS0 on the query.
259 typedef struct query {
271 ISC_LINK(struct query) link;
301 #define VALID_QUERY(query) ISC_MAGIC_VALID(query, QUERY_MAGIC)
595 unsigned int spillat; /* clients-per-query */
652 resquery_send(resquery_t *query);
723 * query (resquery) response handling logic.
725 * When a resolver query is sent and a response is received, the
758 * query (rctx_answer_scan()).
762 * or any records returned in response to a query of type ANY
780 * query to a different server (rctx_nextserver()).
782 * EDNS options, set up another query to the same server with changed
788 resquery_t *query;
810 bool resend; /* resend this query? */
854 rctx_respinit(resquery_t *query, fetchctx_t *fctx, isc_result_t result,
1003 resquery_destroy(resquery_t *query) {
1004 fetchctx_t *fctx = query->fctx;
1006 query->magic = 0;
1008 if (ISC_LINK_LINKED(query, link)) {
1009 ISC_LIST_UNLINK(fctx->queries, query, link);
1012 if (query->tsig != NULL) {
1013 isc_buffer_free(&query->tsig);
1016 if (query->tsigkey != NULL) {
1017 dns_tsigkey_detach(&query->tsigkey);
1020 if (query->dispentry != NULL) {
1021 dns_dispatch_done(&query->dispentry);
1024 if (query->dispatch != NULL) {
1025 dns_dispatch_detach(&query->dispatch);
1032 if (query->rmessage != NULL) {
1033 dns_message_detach(&query->rmessage);
1036 isc_mem_put(fctx->mctx, query, sizeof(*query));
1049 * query sent to it.
1052 update_edns_stats(resquery_t *query) {
1053 fetchctx_t *fctx = query->fctx;
1055 if ((query->options & DNS_FETCHOPT_TCP) != 0) {
1059 if ((query->options & DNS_FETCHOPT_NOEDNS0) == 0) {
1060 dns_adb_ednsto(fctx->adb, query->addrinfo);
1062 dns_adb_timeout(fctx->adb, query->addrinfo);
1101 resquery_t *query = NULL;
1109 query = *queryp;
1110 fctx = query->fctx;
1112 if (RESQUERY_CANCELED(query)) {
1118 query->attributes |= RESQUERY_ATTR_CANCELED;
1133 &query->start);
1160 update_edns_stats(query);
1164 * out, do not attempt to query it again in this fetch
1168 ISFORWARDER(query->addrinfo))
1170 add_bad(fctx, query->rmessage, query->addrinfo,
1175 * We don't have an RTT for this query. Maybe the
1181 if (query->addrinfo->srtt > 800000) {
1183 } else if (query->addrinfo->srtt > 400000) {
1185 } else if (query->addrinfo->srtt > 200000) {
1187 } else if (query->addrinfo->srtt > 100000) {
1189 } else if (query->addrinfo->srtt > 50000) {
1191 } else if (query->addrinfo->srtt > 25000) {
1201 if ((query->options & DNS_FETCHOPT_NOEDNS0) == 0 &&
1202 !EDNSOK(query->addrinfo))
1207 rtt = query->addrinfo->srtt + (value & mask);
1221 dns_adb_adjustsrtt(fctx->adb, query->addrinfo, rtt, factor);
1224 if ((query->options & DNS_FETCHOPT_TCP) == 0) {
1226 dns_adb_endudpfetch(fctx->adb, query->addrinfo);
1286 if (query->dispentry != NULL) {
1287 dns_dispatch_done(&query->dispentry);
1291 if (ISC_LINK_LINKED(query, link)) {
1292 ISC_LIST_UNLINK(fctx->queries, query, link);
1344 resquery_t *query = NULL, *next_query = NULL;
1359 for (query = ISC_LIST_HEAD(queries); query != NULL; query = next_query)
1361 next_query = ISC_LIST_NEXT(query, link);
1364 * Note that we have to unlink the query here,
1368 ISC_LIST_UNLINK(queries, query, link);
1369 fctx_cancelquery(&query, NULL, no_response, age_untried);
1643 "clients-per-query increased to %u",
1693 * query. That query should be canceled already. If
1739 resquery_t *query = (resquery_t *)arg;
1740 resquery_t *copy = query;
1747 REQUIRE(VALID_QUERY(query));
1748 fctx = query->fctx;
1752 if (RESQUERY_CANCELED(query)) {
1776 FCTXTRACE3("query canceled in resquery_senddone(): "
1779 add_bad(fctx, query->rmessage, query->addrinfo, eresult,
1787 FCTXTRACE3("query canceled in resquery_senddone() "
1796 resquery_detach(&query);
1888 resquery_t *query = NULL;
1894 FCTXTRACE("query");
1940 query = isc_mem_get(fctx->mctx, sizeof(*query));
1941 *query = (resquery_t){
1950 __FILE__, __LINE__, query);
1952 isc_refcount_init(&query->references, 1);
1956 * remain valid until this query is canceled.
1961 DNS_MESSAGE_INTENTPARSE, &query->rmessage);
1962 query->start = isc_time_now();
2014 query->options |= DNS_FETCHOPT_TCP;
2020 * If this is a TCP query, then we need to make a socket and
2024 if ((query->options & DNS_FETCHOPT_TCP) != 0) {
2051 &query->dispatch);
2061 &query->dispatch);
2070 &query->dispatch);
2075 &query->dispatch);
2090 INSIST(query->dispatch != NULL);
2095 fetchctx_attach(fctx, &query->fctx);
2096 query->magic = QUERY_MAGIC;
2098 if ((query->options & DNS_FETCHOPT_TCP) == 0) {
2109 ISC_LIST_APPEND(fctx->queries, query, link);
2113 /* Set up the dispatch and set the query ID */
2114 result = dns_dispatch_add(query->dispatch, fctx->loop, 0,
2118 resquery_response, query, &query->id,
2119 &query->dispentry);
2125 resquery_ref(query);
2126 result = dns_dispatch_connect(query->dispentry);
2128 if (result != ISC_R_SUCCESS && (query->options & DNS_FETCHOPT_TCP) != 0)
2143 dns_dispatch_done(&query->dispentry);
2152 if (!RESQUERY_CANCELED(query)) {
2153 if ((query->options & DNS_FETCHOPT_TCP) == 0) {
2161 if (ISC_LINK_LINKED(query, link)) {
2163 ISC_LIST_UNLINK(fctx->queries, query, link);
2168 fetchctx_detach(&query->fctx);
2170 if (query->dispatch != NULL) {
2171 dns_dispatch_detach(&query->dispatch);
2175 query->magic = 0;
2176 dns_message_detach(&query->rmessage);
2177 isc_mem_put(fctx->mctx, query, sizeof(*query));
2268 add_serveraddr(uint8_t *buf, const size_t bufsize, const resquery_t *query) {
2269 return addr2buf(buf, bufsize, &query->addrinfo->sockaddr);
2280 compute_cc(const resquery_t *query, uint8_t *cookie, const size_t len) {
2282 STATIC_ASSERT(sizeof(query->fctx->res->view->secret) >=
2288 size_t buflen = add_serveraddr(buf, sizeof(buf), query);
2291 isc_siphash24(query->fctx->res->view->secret, buf, buflen, true,
2320 resquery_send(resquery_t *query) {
2322 fetchctx_t *fctx = query->fctx;
2334 bool tcp = ((query->options & DNS_FETCHOPT_TCP) != 0);
2369 * query, or if we're sending to a forwarder.
2371 if ((query->options & DNS_FETCHOPT_RECURSIVE) != 0 ||
2372 ISFORWARDER(query->addrinfo))
2380 * recursive/forward query -- unless the client said not to.
2382 if ((query->options & DNS_FETCHOPT_NOCDFLAG) != 0) {
2384 } else if ((query->options & DNS_FETCHOPT_NOVALIDATE) != 0) {
2389 bool checknta = ((query->options & DNS_FETCHOPT_NONTA) == 0);
2392 isc_time_seconds(&query->start),
2398 (ISFORWARDER(query->addrinfo) && ntacovered))
2405 * We don't have to set opcode because it defaults to query.
2407 fctx->qmessage->id = query->id;
2414 isc_buffer_init(&buffer, query->data, sizeof(query->data));
2426 isc_netaddr_fromsockaddr(&ipaddr, &query->addrinfo->sockaddr);
2433 if ((query->addrinfo->flags & FCTX_ADDRINFO_NOEDNS0) == 0 &&
2438 query->options |= DNS_FETCHOPT_NOEDNS0;
2439 dns_adb_changeflags(fctx->adb, query->addrinfo,
2445 if ((query->addrinfo->flags & FCTX_ADDRINFO_NOEDNS0) != 0) {
2446 query->options |= DNS_FETCHOPT_NOEDNS0;
2449 if (fctx->timeout && (query->options & DNS_FETCHOPT_NOEDNS0) == 0) {
2450 isc_sockaddr_t *sockaddr = &query->addrinfo->sockaddr;
2465 query->addrinfo);
2467 if ((query->options & DNS_FETCHOPT_TCP) == 0) {
2470 * UDP fetch, and turn the query into
2471 * a TCP query.
2474 query->addrinfo);
2475 query->options |= DNS_FETCHOPT_TCP;
2486 if ((query->options & DNS_FETCHOPT_NOEDNS0) == 0) {
2487 if ((query->addrinfo->flags & FCTX_ADDRINFO_NOEDNS0) == 0) {
2490 unsigned int flags = query->addrinfo->flags;
2545 if (NOCOOKIE(query->addrinfo)) {
2560 query->addrinfo, cookie,
2568 compute_cc(query, cookie,
2606 query->ednsversion = version;
2610 query->options |= DNS_FETCHOPT_WANTNSID;
2617 query->options |= DNS_FETCHOPT_NOEDNS0;
2618 query->ednsversion = -1;
2627 query->options |= DNS_FETCHOPT_NOEDNS0;
2628 query->ednsversion = -1;
2631 query->ednsversion = -1;
2637 query->udpsize = udpsize;
2640 * If we need EDNS0 to do this query and aren't using it, we
2643 if (NEEDEDNS0(fctx) && (query->options & DNS_FETCHOPT_NOEDNS0) != 0) {
2648 add_triededns(fctx, &query->addrinfo->sockaddr);
2653 if ((query->options & DNS_FETCHOPT_NOEDNS0) != 0) {
2696 &query->tsigkey);
2698 &query->tsig);
2708 fctx->qmessage, "sending packet to", &query->addrinfo->sockaddr,
2713 * We're now done with the query message.
2720 resquery_ref(query);
2721 dns_dispatch_send(query->dispentry, &r);
2727 * Log the outgoing query via dnstap.
2735 result = dns_dispentry_getlocaladdress(query->dispentry, &localaddr);
2740 if (query->addrinfo->transport != NULL) {
2742 dns_transport_get_type(query->addrinfo->transport);
2743 } else if ((query->options & DNS_FETCHOPT_TCP) != 0) {
2749 dns_dt_send(fctx->res->view, dtmsgtype, la, &query->addrinfo->sockaddr,
2750 transport_type, &zr, &query->start, NULL, &buffer);
2763 dns_dispatch_done(&query->dispentry);
2770 resquery_t *query = (resquery_t *)arg;
2771 resquery_t *copy = query;
2777 REQUIRE(VALID_QUERY(query));
2783 fctx = query->fctx;
2790 if (RESQUERY_CANCELED(query)) {
2811 * happening, we cancel-and-detach 'copy' and detach 'query',
2817 * We are connected. Send the query.
2820 result = resquery_send(query);
2822 FCTXTRACE("query canceled: resquery_send() failed; "
2832 pf = isc_sockaddr_pf(&query->addrinfo->sockaddr);
2861 * Do not query this server again in this fetch context.
2863 FCTXTRACE3("query failed in resquery_connected(): "
2866 add_bad(fctx, query->rmessage, query->addrinfo, eresult,
2875 FCTXTRACE3("query canceled in resquery_connected() "
2885 resquery_detach(&query);
3222 * query, and since an ADB find with two pending fetches is a very rare
3251 * If this name is a subdomain of the query domain, tell
3461 * query gets root servers' IP addresses in ADDITIONAL section.
3982 /* We've already exceeded maximum query count */
4037 * we need to launch a query for NS for 'upper' domain
4269 * clear it before sending the final query to use proper
4625 * We're in forward-only mode. Set the query
4631 * Disable query minimization
4639 * The caller didn't supply a query domain and
4712 * the correct value before a query is issued.
5205 * started by a query with cd set)
5837 * If this is an ANY, SIG or RRSIG query, we're
5940 * query to the domain that owns them.)
5988 * query, additional should be cached as glue.
6103 * or SIG query. To keep things
6673 result = dns_message_findname(rctx->query->rmessage, section, addname,
6947 * response to any query we can make.
7197 log_nsid(isc_buffer_t *opt, size_t nsid_len, resquery_t *query, int level,
7228 isc_sockaddr_format(&query->addrinfo->sockaddr, addrbuf,
7253 for (result = dns_message_firstname(rctx->query->rmessage,
7256 result = dns_message_nextname(rctx->query->rmessage,
7260 dns_message_currentname(rctx->query->rmessage,
7283 resquery_t *query = (resquery_t *)arg;
7291 REQUIRE(VALID_QUERY(query));
7292 fctx = query->fctx;
7298 if (isc_sockaddr_pf(&query->addrinfo->sockaddr) == PF_INET) {
7305 rctx_respinit(query, fctx, eresult, region, rctx);
7322 fctx->addrinfo = query->addrinfo;
7334 if (query->tsig != NULL) {
7335 dns_message_setquerytsig(query->rmessage, query->tsig);
7338 if (query->tsigkey != NULL) {
7339 result = dns_message_settsigkey(query->rmessage,
7340 query->tsigkey);
7348 dns_message_setclass(query->rmessage, fctx->res->rdclass);
7353 fctx->adb, query->addrinfo,
7356 dns_adb_plainresponse(fctx->adb, query->addrinfo);
7373 if (query->rmessage->rdclass != fctx->res->rdclass) {
7383 rctx->opt = dns_message_getopt(query->rmessage);
7388 if (query->rmessage->cc_bad &&
7398 isc_sockaddr_format(&query->addrinfo->sockaddr, addrbuf,
7414 switch (query->rmessage->rcode) {
7417 if (query->rmessage->counts[DNS_SECTION_QUESTION] == 0) {
7429 result = same_question(fctx, query->rmessage);
7439 if (query->rmessage->tsigkey == NULL && query->rmessage->tsig == NULL &&
7440 query->rmessage->sig0 != NULL)
7448 query->rmessage, fctx->res->view, fctx->loop,
7456 result = dns_message_checksig(query->rmessage, fctx->res->view);
7470 resquery_t *query = rctx->query;
7487 INSIST((query->rmessage->flags & DNS_MESSAGEFLAG_QR) != 0);
7496 if (dns_message_gettsig(query->rmessage, NULL) == NULL &&
7497 !query->rmessage->cc_ok && !query->rmessage->cc_bad &&
7500 if (dns_adb_getcookie(query->addrinfo, NULL, 0) >
7505 isc_sockaddr_format(&query->addrinfo->sockaddr,
7522 &query->addrinfo->sockaddr);
7536 &query->addrinfo
7564 if ((query->rmessage->flags & DNS_MESSAGEFLAG_TC) != 0) {
7583 * Is it a query response?
7585 if (query->rmessage->opcode != dns_opcode_query) {
7596 switch (query->rmessage->rcode) {
7645 checknames(query->rmessage);
7656 if (query->rmessage->counts[DNS_SECTION_ANSWER] > 0 &&
7657 (query->rmessage->rcode == dns_rcode_noerror ||
7658 query->rmessage->rcode == dns_rcode_yxdomain ||
7659 query->rmessage->rcode == dns_rcode_nxdomain))
7665 } else if (query->rmessage->counts[DNS_SECTION_AUTHORITY] > 0 ||
7666 query->rmessage->rcode == dns_rcode_noerror ||
7667 query->rmessage->rcode == dns_rcode_nxdomain)
7721 tresult = cache_message(fctx, query->rmessage, query->addrinfo,
7745 * set the loop, event, query and fctx information from
7749 rctx_respinit(resquery_t *query, fetchctx_t *fctx, isc_result_t result,
7752 .query = query,
7755 .retryopts = query->options };
7780 rctx->aa = ((rctx->query->rmessage->flags & DNS_MESSAGEFLAG_AA) != 0);
7891 FCTXTRACE("query timed out; stopped trying to make "
7894 FCTXTRACE("query timed out; trying next server");
7916 resquery_t *query = rctx->query;
7918 result = dns_message_parse(query->rmessage, &rctx->buffer, 0);
7927 if (query->rmessage->question_ok &&
7928 (query->rmessage->flags & DNS_MESSAGEFLAG_TC) != 0 &&
7942 * and/or this is a response to a query we
7956 add_bad_edns(fctx, &query->addrinfo->sockaddr);
7974 add_bad_edns(fctx, &query->addrinfo->sockaddr);
8000 resquery_t *query = rctx->query;
8033 if ((query->options & DNS_FETCHOPT_WANTNSID) != 0) {
8034 log_nsid(&optbuf, optlen, query, ISC_LOG_INFO,
8046 compute_cc(query, cookie, sizeof(cookie));
8047 INSIST(query->rmessage->cc_bad == 0 &&
8048 query->rmessage->cc_ok == 0);
8055 query->rmessage->cc_bad = 1;
8061 query->rmessage->cc_echoed = 1;
8063 query->rmessage->cc_ok = 1;
8066 dns_adb_setcookie(fctx->adb, query->addrinfo,
8085 resquery_t *query = rctx->query;
8089 * We have an affirmative response to the query and we have
8094 if (rctx->opt == NULL && !EDNSOK(query->addrinfo) &&
8095 (query->rmessage->rcode == dns_rcode_noerror ||
8096 query->rmessage->rcode == dns_rcode_nxdomain ||
8097 query->rmessage->rcode == dns_rcode_refused ||
8098 query->rmessage->rcode == dns_rcode_yxdomain) &&
8099 bad_edns(fctx, &query->addrinfo->sockaddr))
8102 query->rmessage, "received packet (bad edns) from",
8103 &query->addrinfo->sockaddr, DNS_LOGCATEGORY_RESOLVER,
8105 dns_adb_changeflags(fctx->adb, query->addrinfo,
8109 (query->rmessage->flags & DNS_MESSAGEFLAG_TC) == 0 &&
8110 !EDNSOK(query->addrinfo) &&
8111 (query->rmessage->rcode == dns_rcode_noerror ||
8112 query->rmessage->rcode == dns_rcode_nxdomain) &&
8117 * query.
8128 query->rmessage, "received packet (no opt) from",
8129 &query->addrinfo->sockaddr, DNS_LOGCATEGORY_RESOLVER,
8131 dns_adb_changeflags(fctx->adb, query->addrinfo,
8140 if (rctx->opt != NULL && !EDNSOK(query->addrinfo) &&
8142 (query->rmessage->rcode == dns_rcode_noerror ||
8143 query->rmessage->rcode == dns_rcode_nxdomain ||
8144 query->rmessage->rcode == dns_rcode_refused ||
8145 query->rmessage->rcode == dns_rcode_yxdomain))
8147 dns_adb_changeflags(fctx->adb, query->addrinfo,
8162 resquery_t *query = rctx->query;
8164 if ((query->rmessage->flags & DNS_MESSAGEFLAG_AA) != 0 ||
8165 ISFORWARDER(query->addrinfo))
8171 } else if (iscname(query->rmessage, fctx->name) &&
8198 * non-authoritative answer to an NS query
8218 * delegation when the query is for that glue
8330 if (rctx->query->rmessage->rcode != dns_rcode_noerror) {
8368 for (result = dns_message_firstname(rctx->query->rmessage,
8371 result = dns_message_nextname(rctx->query->rmessage,
8379 dns_message_currentname(rctx->query->rmessage,
8525 * Handle responses that match the QNAME/QTYPE of the resolver query.
8726 result = dns_message_firstname(rctx->query->rmessage,
8731 dns_message_currentname(rctx->query->rmessage,
8778 result = dns_message_nextname(rctx->query->rmessage,
8803 if (rctx->query->rmessage->rcode == dns_rcode_nxdomain ||
8804 (rctx->query->rmessage->counts[DNS_SECTION_ANSWER] == 0 &&
8805 rctx->query->rmessage->counts[DNS_SECTION_AUTHORITY] == 0))
8852 rctx->query->rmessage->rcode == dns_rcode_noerror &&
8946 result = dns_message_firstname(rctx->query->rmessage, section);
8954 dns_message_currentname(rctx->query->rmessage, section, &name);
8955 result = dns_message_nextname(rctx->query->rmessage, section);
9072 if (rctx->query->rmessage->rcode == dns_rcode_nxdomain &&
9083 result = ncache_message(fctx, rctx->query->rmessage,
9084 rctx->query->addrinfo, covers, rctx->now);
9105 result = dns_message_firstname(rctx->query->rmessage,
9114 dns_message_currentname(rctx->query->rmessage,
9116 result = dns_message_nextname(rctx->query->rmessage,
9261 * If the referral name is not a parent of the query
9275 * query domain.
9310 * Set the current query domain to the referral name.
9377 for (result = dns_message_firstname(rctx->query->rmessage, section);
9379 result = dns_message_nextname(rctx->query->rmessage, section))
9383 dns_message_currentname(rctx->query->rmessage,
9493 * Resend the query, probably with the options changed. Calls
9495 * query->options, but may have been updated since the last time
9525 INSIST(rctx->query->dispentry != NULL);
9526 dns_message_reset(rctx->query->rmessage, DNS_MESSAGE_INTENTPARSE);
9527 result = dns_dispatch_getnext(rctx->query->dispentry);
9568 * This resolver query response is finished, either because we
9571 * query to the same server, resend to a new server, or clean up and
9576 resquery_t *query = rctx->query;
9578 dns_adbaddrinfo_t *addrinfo = query->addrinfo;
9587 dns_message_attach(query->rmessage, &message);
9589 FCTXTRACE4("query canceled in rctx_done();",
9596 fctx_cancelquery(&query, rctx->finish, rctx->no_response,
9613 /* Cancel the query */
9614 fctx_cancelquery(&query, rctx->finish, rctx->no_response, false);
9669 rctx->query->rmessage, "received packet from",
9670 &rctx->query->addrinfo->sockaddr, DNS_LOGCATEGORY_RESOLVER,
9694 result = dns_dispentry_getlocaladdress(rctx->query->dispentry,
9700 if (rctx->query->addrinfo->transport != NULL) {
9702 rctx->query->addrinfo->transport);
9703 } else if ((rctx->query->options & DNS_FETCHOPT_TCP) != 0) {
9710 &rctx->query->addrinfo->sockaddr, transport_type, &zr,
9711 &rctx->query->start, NULL, &rctx->buffer);
9722 resquery_t *query = rctx->query;
9725 dns_rcode_t rcode = rctx->query->rmessage->rcode;
9744 add_bad_edns(fctx, &query->addrinfo->sockaddr);
9747 if (query->rmessage->cc_echoed) {
9751 query->addrinfo->flags |= FCTX_ADDRINFO_NOCOOKIE;
9782 if (query->ednsversion > (int)version &&
9783 !EDNSOK(query->addrinfo))
9785 dns_adb_changeflags(fctx->adb, query->addrinfo,
9799 if ((int)version < query->ednsversion) {
9800 dns_adb_changeflags(fctx->adb, query->addrinfo, flags,
9811 } else if (rcode == dns_rcode_badcookie && rctx->query->rmessage->cc_ok)
9816 if (BADCOOKIE(query->addrinfo)) {
9819 query->addrinfo->flags |= FCTX_ADDRINFO_BADCOOKIE;
9843 resquery_t *query = rctx->query;
9845 if (ISFORWARDER(query->addrinfo) || !is_lame(fctx, query->rmessage)) {
9850 log_lame(fctx, query->addrinfo);
9948 "clients-per-query decreased to %u", spillat);
10061 "resolver priming query complete: %s",
10274 * We want to query for qmin_labels from fctx->name.