Lines Matching defs:qstate
137 iter_new(struct module_qstate* qstate, int id)
140 qstate->region, sizeof(struct iter_qstate));
141 qstate->minfo[id] = iq;
165 iq->chase_flags = qstate->query_flags;
167 iq->qchase = qstate->qinfo;
171 if (qstate->env->cfg->qname_minimisation)
211 * The response is stored in the qstate->buf buffer.
225 * @param qstate: query state that failed.
230 error_supers(struct module_qstate* qstate, int id, struct module_qstate* super)
232 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
235 if(qstate->qinfo.qtype == LDNS_RR_TYPE_A ||
236 qstate->qinfo.qtype == LDNS_RR_TYPE_AAAA) {
242 qstate->qinfo.qname, qstate->qinfo.qname_len);
258 delegpt_mark_neg(dpns, qstate->qinfo.qtype);
265 if(qstate->qinfo.qtype == LDNS_RR_TYPE_NS) {
276 * @param qstate: our query state
283 error_response(struct module_qstate* qstate, int id, int rcode)
288 qstate->return_rcode = rcode;
289 qstate->return_msg = NULL;
290 qstate->ext_state[id] = module_finished;
297 * @param qstate: our query state
304 error_response_cache(struct module_qstate* qstate, int id, int rcode)
308 if(qstate->no_cache_store) {
309 return error_response(qstate, id, rcode);
311 if(qstate->prefetch_leeway > NORR_TTL) {
314 if(dns_cache_prefetch_adjust(qstate->env, &qstate->qinfo,
315 NORR_TTL, qstate->query_flags))
316 return error_response(qstate, id, rcode);
319 if((msg=msg_cache_lookup(qstate->env,
320 qstate->qinfo.qname, qstate->qinfo.qname_len,
321 qstate->qinfo.qtype, qstate->qinfo.qclass,
322 qstate->query_flags, 0,
323 qstate->env->cfg->serve_expired_ttl_reset)) != NULL) {
325 if(qstate->env->cfg->serve_expired &&
326 qstate->env->cfg->serve_expired_ttl_reset && rep &&
327 *qstate->env->now + qstate->env->cfg->serve_expired_ttl
331 rep->serve_expired_ttl = *qstate->env->now +
332 qstate->env->cfg->serve_expired_ttl;
340 (qstate->env->cfg->serve_expired ||
341 *qstate->env->now <= rep->ttl)) {
344 return error_response(qstate, id, rcode);
363 iter_dns_store(qstate->env, &qstate->qinfo, &err, 0, 0, 0, NULL,
364 qstate->query_flags, qstate->qstarttime);
365 return error_response(qstate, id, rcode);
466 * @param qstate: query state.
472 iter_add_prepend_answer(struct module_qstate* qstate, struct iter_qstate* iq,
476 qstate->region, sizeof(struct iter_prep_list));
491 * @param qstate: query state.
497 iter_add_prepend_auth(struct module_qstate* qstate, struct iter_qstate* iq,
501 qstate->region, sizeof(struct iter_prep_list));
521 * @param qstate: query state.
529 handle_cname_response(struct module_qstate* qstate, struct iter_qstate* iq,
548 if(!iter_add_prepend_answer(qstate, iq, r))
557 if(!iter_add_prepend_answer(qstate, iq, r))
571 if(!iter_add_prepend_auth(qstate, iq, r))
628 errinf_reply(struct module_qstate* qstate, struct iter_qstate* iq)
630 if(qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail)
632 if((qstate->reply && qstate->reply->remote_addrlen != 0) ||
635 if(qstate->reply && qstate->reply->remote_addrlen != 0)
636 addr_to_str(&qstate->reply->remote_addr,
637 qstate->reply->remote_addrlen, from,
642 errinf(qstate, frm);
646 errinf(qstate, "upstream response failed scrub");
648 errinf(qstate, "could not parse upstream response");
650 errinf(qstate, "upstream server timeout");
652 errinf(qstate, "no server to query");
655 errinf(qstate, "no addresses for nameservers");
656 else errinf(qstate, "nameserver addresses not usable");
658 errinf(qstate, "have no nameserver names");
660 errinf(qstate, "NS record was dnssec bogus");
670 errinf(qstate, rcode);
674 errinf(qstate, "nodata answer");
781 * @param qstate The event that is generating this event.
791 * @param detached: true if this qstate should not attach to the subquery
796 uint16_t qclass, struct module_qstate* qstate, int id,
829 qstate->env->add_sub));
830 if(!(*qstate->env->add_sub)(qstate, &qinf,
838 qstate->env->attach_sub));
839 if(!(*qstate->env->attach_sub)(qstate, &qinf, qflags, prime,
854 qstate->env->kill_sub));
855 (*qstate->env->kill_sub)(subq);
876 if(qstate->env->cfg->qname_minimisation)
887 * @param qstate: the qtstate that triggered the need to prime.
894 prime_root(struct module_qstate* qstate, struct iter_qstate* iq, int id,
903 dp = hints_find_root(qstate->env->hints, qclass, nolock);
911 qclass, qstate, id, iq, QUERYTARGETS_STATE, PRIME_RESP_STATE,
913 lock_rw_unlock(&qstate->env->hints->lock);
924 lock_rw_unlock(&qstate->env->hints->lock);
928 qstate->env->kill_sub));
929 (*qstate->env->kill_sub)(subq);
935 qstate->env, subiq->dp, NULL, subq->qinfo.qclass);
937 lock_rw_unlock(&qstate->env->hints->lock);
941 qstate->ext_state[id] = module_wait_subquery;
949 * @param qstate: the qtstate that triggered the need to prime.
960 prime_stub(struct module_qstate* qstate, struct iter_qstate* iq, int id,
971 stub = hints_lookup_stub(qstate->env->hints, qname, qclass, iq->dp,
980 lock_rw_unlock(&qstate->env->hints->lock);
990 iq->dp = delegpt_copy(stub_dp, qstate->region);
991 lock_rw_unlock(&qstate->env->hints->lock);
994 errinf(qstate, "malloc failure, priming stub");
995 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1010 LDNS_RR_TYPE_NS, qclass, qstate, id, iq,
1012 lock_rw_unlock(&qstate->env->hints->lock);
1014 errinf(qstate, "could not generate lookup for stub prime");
1015 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1025 lock_rw_unlock(&qstate->env->hints->lock);
1029 qstate->env->kill_sub));
1030 (*qstate->env->kill_sub)(subq);
1031 errinf(qstate, "malloc failure, in stub prime");
1032 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1041 qstate->env, subiq->dp, NULL, subq->qinfo.qclass);
1043 lock_rw_unlock(&qstate->env->hints->lock);
1047 qstate->ext_state[id] = module_wait_subquery;
1056 auth_zone_delegpt(struct module_qstate* qstate, struct iter_qstate* iq,
1066 lock_rw_rdlock(&qstate->env->auth_zones->lock);
1067 z = auth_zones_find_zone(qstate->env->auth_zones, delname, delnamelen,
1068 qstate->qinfo.qclass);
1070 lock_rw_unlock(&qstate->env->auth_zones->lock);
1074 lock_rw_unlock(&qstate->env->auth_zones->lock);
1077 && iq->dp->auth_dp && qstate->blacklist &&
1094 if(qstate->blacklist && z->fallback_enabled) {
1109 qstate->region, sizeof(*dp));
1117 errinf(qstate, "malloc failure");
1120 dp->name = regional_alloc_init(qstate->region,
1129 errinf(qstate, "malloc failure");
1147 * @param qstate: the qtstate that triggered the need to prime.
1152 generate_a_aaaa_check(struct module_qstate* qstate, struct iter_qstate* iq,
1155 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
1175 if(qstate->qinfo.qtype == ntohs(s->rk.type) &&
1176 qstate->qinfo.qclass == ntohs(s->rk.rrset_class) &&
1177 query_dname_compare(qstate->qinfo.qname,
1179 (qstate->query_flags&BIT_RD) &&
1180 !(qstate->query_flags&BIT_CD))
1189 qstate, id, iq,
1202 * @param qstate: the qstate that triggered the need to prime.
1207 generate_ns_check(struct module_qstate* qstate, struct iter_qstate* iq, int id)
1209 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
1215 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen,
1219 if(qstate->qinfo.qtype == LDNS_RR_TYPE_NS &&
1220 query_dname_compare(iq->dp->name, qstate->qinfo.qname)==0 &&
1221 (qstate->query_flags&BIT_RD) && !(qstate->query_flags&BIT_CD)){
1223 generate_a_aaaa_check(qstate, iq, id);
1227 if(qstate->qinfo.qtype == LDNS_RR_TYPE_DS)
1233 LDNS_RR_TYPE_NS, iq->qchase.qclass, qstate, id, iq,
1249 qstate->env->kill_sub));
1250 (*qstate->env->kill_sub)(subq);
1268 * @param qstate: the qtstate that triggered the need to prime.
1273 generate_dnskey_prefetch(struct module_qstate* qstate,
1280 if(qstate->qinfo.qtype == LDNS_RR_TYPE_DNSKEY &&
1281 query_dname_compare(iq->dp->name, qstate->qinfo.qname)==0 &&
1282 (qstate->query_flags&BIT_RD) && !(qstate->query_flags&BIT_CD)){
1292 if(mesh_jostle_exceeded(qstate->env->mesh))
1299 LDNS_RR_TYPE_DNSKEY, iq->qchase.qclass, qstate, id, iq,
1308 /* this qstate has the right delegation for the dnskey lookup*/
1318 * @param qstate: query state.
1324 forward_request(struct module_qstate* qstate, struct iter_qstate* iq)
1338 dp = forwards_lookup(qstate->env->fwds, delname, iq->qchase.qclass,
1343 iq->dp = delegpt_copy(dp, qstate->region);
1344 lock_rw_unlock(&qstate->env->fwds->lock);
1361 * @param qstate: query state.
1369 processInitRequest(struct module_qstate* qstate, struct iter_qstate* iq,
1377 log_query_info(VERB_DETAIL, "resolving", &qstate->qinfo);
1385 errinf(qstate, "request has exceeded the maximum number "
1388 errinf_dname(qstate, "stop at", iq->qchase.qname);
1389 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
1400 errinf(qstate, "request has exceeded the maximum dependency "
1402 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1406 if(qstate->qinfo.qclass == LDNS_RR_CLASS_ANY) {
1418 !can_have_last_resort(qstate->env, iq->dp->name,
1429 if(qstate->env->auth_zones) {
1432 rpz_callback_from_iterator_cname(qstate, iq);
1444 if(!handle_cname_response(qstate, iq, forged_response,
1446 errinf(qstate, "malloc failure, CNAME info");
1447 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1452 rpz_callback_from_iterator_cname(qstate, iq);
1455 qstate->ext_state[id] = module_finished;
1456 qstate->return_rcode = LDNS_RCODE_NOERROR;
1457 qstate->return_msg = forged_response;
1460 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
1462 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1464 qstate->return_msg->qinfo = qstate->qinfo;
1473 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1474 if(qstate->env->cfg->qname_minimisation)
1480 if (iter_stub_fwd_no_cache(qstate, &iq->qchase, &dpname, &dpnamelen,
1484 qstate->no_cache_lookup = 1;
1485 qstate->no_cache_store = 1;
1487 } else if(qstate->blacklist) {
1492 } else if(!qstate->no_cache_lookup) {
1493 msg = dns_cache_lookup(qstate->env, iq->qchase.qname,
1495 iq->qchase.qclass, qstate->query_flags,
1496 qstate->region, qstate->env->scratch, 0, dpname,
1498 if(!msg && qstate->env->neg_cache &&
1499 iter_qname_indicates_dnssec(qstate->env, &iq->qchase)) {
1502 msg = val_neg_getmsg(qstate->env->neg_cache, &iq->qchase,
1503 qstate->region, qstate->env->rrset_cache,
1504 qstate->env->scratch_buffer,
1505 *qstate->env->now, 1/*add SOA*/, NULL,
1506 qstate->env->cfg);
1510 if(msg && query_dname_compare(qstate->qinfo.qname,
1531 if(!handle_cname_response(qstate, iq, msg,
1533 errinf(qstate, "failed to prepend CNAME "
1535 return error_response(qstate, id,
1547 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1548 if(qstate->env->cfg->qname_minimisation)
1553 if(qstate->reply_origin)
1554 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1556 errinf(qstate, "SERVFAIL in cache");
1564 if(forward_request(qstate, iq))
1568 errinf(qstate, "malloc failure for forward zone");
1569 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1571 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
1572 qstate->region, iq->dp)) {
1573 errinf(qstate, "malloc failure, copy extra info into delegation point");
1574 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1576 if((qstate->query_flags&BIT_RD)==0) {
1586 errinf(qstate, "cannot forward RD=0 query");
1587 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1606 errinf(qstate, "malloc failure, for delegation info");
1607 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1616 (iq->qchase.qtype == LDNS_RR_TYPE_NS && qstate->prefetch_leeway
1617 && can_have_last_resort(qstate->env, delname, delnamelen, iq->qchase.qclass, NULL, NULL, NULL))) {
1625 qstate->prefetch_leeway)))
1635 iq->dp = dns_cache_find_delegation(qstate->env, delname,
1637 qstate->region, &iq->deleg_msg,
1638 *qstate->env->now+qstate->prefetch_leeway, 1,
1648 if(!auth_zone_delegpt(qstate, iq, delname, delnamelen))
1649 return error_response(qstate, id,
1654 r = prime_stub(qstate, iq, id, delname,
1660 if(forwards_lookup_root(qstate->env->fwds,
1662 lock_rw_unlock(&qstate->env->fwds->lock);
1665 iq->dp = hints_find_root(qstate->env->hints,
1669 errinf(qstate, "no hints for this class");
1670 return error_response_cache(qstate, id,
1673 iq->dp = delegpt_copy(iq->dp, qstate->region);
1674 lock_rw_unlock(&qstate->env->hints->lock);
1677 errinf(qstate, "malloc failure, in safety belt");
1678 return error_response(qstate, id,
1685 if(!prime_root(qstate, iq, id, iq->qchase.qclass))
1686 return error_response(qstate, id,
1695 if(!iq->ratelimit_ok && qstate->prefetch_leeway)
1711 if(iter_dp_is_useless(&qstate->qinfo, qstate->query_flags,
1715 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen, iq->qchase.qclass, &have_dp, &iq->dp, qstate->region)) {
1723 errinf(qstate, "malloc failure, for fallback to config");
1724 return error_response(qstate,
1732 errinf(qstate, "no useful nameservers, "
1734 errinf_dname(qstate, "for zone", iq->dp->name);
1735 return error_response(qstate, id,
1743 iq->dp = hints_find_root(qstate->env->hints,
1749 return error_response(qstate, id,
1752 iq->dp = delegpt_copy(iq->dp, qstate->region);
1753 lock_rw_unlock(&qstate->env->hints->lock);
1756 errinf(qstate, "malloc failure, in safety belt, for root");
1757 return error_response(qstate, id,
1790 * @param qstate: query state.
1797 processInitRequest2(struct module_qstate* qstate, struct iter_qstate* iq,
1803 &qstate->qinfo);
1812 errinf(qstate, "malloc failure, no delegation info");
1813 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1818 qstate->env->hints, iq->qchase.qname, iq->qchase.qclass,
1826 if(stub) { lock_rw_unlock(&qstate->env->hints->lock); }
1836 if(!auth_zone_delegpt(qstate, iq, delname, delnamelen))
1837 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1840 if(prime_stub(qstate, iq, id, delname, iq->qchase.qclass)) {
1855 * @param qstate: query state.
1861 processInitRequest3(struct module_qstate* qstate, struct iter_qstate* iq,
1865 &qstate->qinfo);
1868 iq->dnssec_expected = iter_indicates_dnssec(qstate->env, iq->dp,
1873 if(!(qstate->query_flags & BIT_RD) && iq->deleg_msg) {
1878 if(qstate->reply_origin)
1879 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1887 if(iq->dnssec_expected && qstate->env->cfg->prefetch_key &&
1888 !(qstate->query_flags&BIT_CD)) {
1889 generate_dnskey_prefetch(qstate, iq, id);
1891 qstate->env->detach_subs));
1892 (*qstate->env->detach_subs)(qstate);
1904 * @param qstate: query state.
1914 generate_parentside_target_query(struct module_qstate* qstate,
1919 if(!generate_sub_request(name, namelen, qtype, qclass, qstate,
1931 qstate->env, subiq->dp, NULL,
1935 subiq->dp = dns_cache_find_delegation(qstate->env,
1938 *qstate->env->now+subq->prefetch_leeway,
1943 qstate->env, subiq->dp, NULL,
1957 * @param qstate: query state.
1967 generate_target_query(struct module_qstate* qstate, struct iter_qstate* iq,
1971 if(!generate_sub_request(name, namelen, qtype, qclass, qstate,
1982 * @param qstate: query state.
1994 query_for_targets(struct module_qstate* qstate, struct iter_qstate* iq,
2002 iter_mark_cycle_targets(qstate, iq->dp);
2024 dname_str(qstate->qinfo.qname, s);
2032 dname_str(qstate->qinfo.qname, s);
2048 if(!iter_ns_probability(qstate->env->rnd, toget, missing)) {
2059 if(!generate_target_query(qstate, iq, id,
2064 qstate->ext_state[id] = module_wait_subquery;
2074 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2089 if(!generate_target_query(qstate, iq, id,
2094 qstate->ext_state[id] = module_wait_subquery;
2099 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2117 qstate->ext_state[id] = module_wait_subquery;
2127 * @param qstate: query state.
2135 processLastResort(struct module_qstate* qstate, struct iter_qstate* iq,
2143 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen,
2147 errinf(qstate, "all the configured stub or forward servers failed,");
2148 errinf_dname(qstate, "at zone", iq->dp->name);
2149 errinf_reply(qstate, iq);
2151 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2156 dp = hints_find_root(qstate->env->hints,
2162 (void)delegpt_add_ns(iq->dp, qstate->region,
2167 (void)delegpt_add_addr(iq->dp, qstate->region,
2171 lock_rw_unlock(&qstate->env->hints->lock);
2175 if(!iter_lookup_parent_NS_from_cache(qstate->env, iq->dp,
2176 qstate->region, &qstate->qinfo)
2188 if(qstate->env->cfg->qname_minimisation)
2194 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
2195 qstate->region, iq->dp))
2202 if(iter_lookup_parent_glue_from_cache(qstate->env, iq->dp,
2203 qstate->region, &qstate->qinfo)) {
2212 if((ret=query_for_targets(qstate, iq, ie, id, 1, &qs))!=0) {
2213 errinf(qstate, "could not fetch nameserver");
2214 errinf_dname(qstate, "at zone", iq->dp->name);
2216 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2217 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2222 qstate->ext_state[id] = module_wait_subquery;
2228 errinf(qstate, "cannot fetch more nameservers because at max dependency depth");
2229 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2234 dname_str(qstate->qinfo.qname, s);
2238 errinf(qstate, "exceeded the maximum number of glue fetches");
2239 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2242 iter_mark_pside_cycle_targets(qstate, iq->dp);
2250 !can_have_last_resort(qstate->env, ns->name, ns->namelen,
2262 if(!generate_parentside_target_query(qstate, iq, id,
2265 errinf_dname(qstate, "could not generate nameserver AAAA lookup for", ns->name);
2266 return error_response(qstate, id,
2271 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2277 qstate->ext_state[id] = module_wait_subquery;
2283 if(!generate_parentside_target_query(qstate, iq, id,
2286 errinf_dname(qstate, "could not generate nameserver A lookup for", ns->name);
2287 return error_response(qstate, id,
2297 qstate->ext_state[id] = module_wait_subquery;
2304 if(!qstate->no_cache_store && iq->query_for_pside_glue
2306 iter_store_parentside_neg(qstate->env, &qstate->qinfo,
2310 errinf(qstate, "all servers for this domain failed,");
2311 errinf_dname(qstate, "at zone", iq->dp->name);
2312 errinf_reply(qstate, iq);
2316 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2326 * @param qstate: query state.
2334 processDSNSFind(struct module_qstate* qstate, struct iter_qstate* iq, int id)
2346 errinf_dname(qstate, "for DS query parent-child nameserver search the query is not under the zone", iq->dp->name);
2347 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2365 LDNS_RR_TYPE_NS, iq->qchase.qclass, qstate, id, iq,
2367 errinf_dname(qstate, "for DS query parent-child nameserver search, could not generate NS lookup for", iq->dsns_point);
2368 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2379 check_waiting_queries(struct iter_qstate* iq, struct module_qstate* qstate,
2387 qstate->ext_state[id] = module_wait_reply;
2391 qstate->ext_state[id] = module_wait_subquery;
2396 qstate->ext_state[id] = module_wait_reply;
2408 * @param qstate: query state.
2417 processQueryTargets(struct module_qstate* qstate, struct iter_qstate* iq,
2436 log_query_info(VERB_QUERY, "processQueryTargets:", &qstate->qinfo);
2445 errinf(qstate, "exceeded the maximum of referrals");
2446 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2451 errinf(qstate, "exceeded the maximum number of sends");
2452 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2461 check_waiting_queries(iq, qstate, id);
2471 errinf(qstate, "failed to get a delegation (eg. prime "
2473 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2481 errinf(qstate, "exceeded the maximum nameserver nxdomains");
2482 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2498 errinf(qstate, "exceeded the maximum nameserver "
2500 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2507 check_waiting_queries(iq, qstate, id);
2514 errinf(qstate, "failed to get a delegation (eg. prime "
2516 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2524 errinf(qstate, "exceeded the maximum nameserver nxdomains");
2525 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2545 errinf(qstate, "failed to get a delegation (eg. prime failure)");
2546 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2559 qstate->ext_state[id] = module_wait_reply;
2638 else if(!qstate->no_cache_lookup) {
2639 struct dns_msg* msg = dns_cache_lookup(qstate->env,
2642 qstate->query_flags, qstate->region,
2643 qstate->env->scratch, 0, iq->dp->name,
2652 qstate->env->need_to_validate &&
2653 qstate->env->cfg->harden_below_nxdomain) {
2665 qstate, id, iq,
2687 else if(!qstate->env->cfg->qname_minimisation_strict)
2699 if(!iq->auth_zone_avoid && qstate->blacklist) {
2700 if(auth_zones_can_fallback(qstate->env->auth_zones,
2711 } else if(auth_zones_lookup(qstate->env->auth_zones, &iq->qinfo_out,
2712 qstate->region, &iq->response, &auth_fallback, iq->dp->name,
2722 lock_rw_wrlock(&qstate->env->auth_zones->lock);
2723 qstate->env->auth_zones->num_query_up++;
2724 lock_rw_unlock(&qstate->env->auth_zones->lock);
2738 errinf(qstate, "auth zone lookup failed, fallback is off");
2739 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2762 if(can_do_promisc && !mesh_jostle_exceeded(qstate->env->mesh)) {
2770 if((ret=query_for_targets(qstate, iq, ie, id, -1, &extra))!=0) {
2771 errinf(qstate, "could not fetch nameservers for 0x20 fallback");
2773 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2774 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2781 qstate->ext_state[id] = module_wait_reply;
2824 (void)query_for_targets(qstate, iq, ie, id, tf_policy, &extra);
2834 if(qstate->env->auth_zones) {
2839 struct dns_msg* forged_response = rpz_callback_from_iterator_module(qstate, iq);
2848 if(!handle_cname_response(qstate, iq, forged_response,
2850 errinf(qstate, "malloc failure, CNAME info");
2851 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2856 rpz_callback_from_iterator_cname(qstate, iq);
2869 if(qstate->env->cfg->qname_minimisation)
2874 qstate->env->detach_subs));
2875 (*qstate->env->detach_subs)(qstate);
2881 qstate->ext_state[id] = module_finished;
2882 qstate->return_rcode = LDNS_RCODE_NOERROR;
2883 qstate->return_msg = forged_response;
2886 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
2888 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2895 target = iter_server_selection(ie, qstate->env, iq->dp,
2898 iq->num_target_queries, qstate->blacklist,
2899 qstate->prefetch_leeway);
2920 if((ret=query_for_targets(qstate, iq, ie, id,
2922 errinf(qstate, "could not fetch nameserver");
2923 errinf_dname(qstate, "at zone", iq->dp->name);
2925 return error_response(qstate, id,
2927 return error_response_cache(qstate, id,
2945 errinf(qstate, "could not generate nameserver lookups");
2946 errinf_dname(qstate, "at zone", iq->dp->name);
2947 return error_response(qstate, id,
2975 return processLastResort(qstate, iq, ie, id);
2982 check_waiting_queries(iq, qstate, id);
3002 && !ub_random_max(qstate->env->rnd, 10)) {
3006 (void)query_for_targets(qstate, iq, ie, id, 1, &extra);
3012 check_waiting_queries(iq, qstate, id);
3028 dname_str(qstate->qinfo.qname, s);
3032 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3059 fptr_ok(fptr_whitelist_modenv_send_query(qstate->env->send_query));
3060 outq = (*qstate->env->send_query)(&iq->qinfo_out,
3065 (qstate->env->cfg->disable_edns_do?0:EDNS_DO)|
3067 !qstate->blacklist&&(!iter_qname_indicates_dnssec(qstate->env,
3072 (iq->dp->tcp_upstream || qstate->env->cfg->tcp_upstream),
3073 (iq->dp->ssl_upstream || qstate->env->cfg->ssl_upstream),
3074 target->tls_auth_name, qstate, &sq_was_ratelimited);
3081 qstate->was_ratelimited = 1;
3082 errinf_dname(qstate, "exceeded ratelimit for zone",
3084 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3088 if(qstate->env->cfg->qname_minimisation)
3095 qstate->ext_state[id] = module_wait_reply;
3119 * @param qstate: query state.
3128 processQueryResponse(struct module_qstate* qstate, struct iter_qstate* iq,
3136 if(!inplace_cb_query_response_call(qstate->env, qstate, iq->response))
3141 if(qstate->env->cfg->qname_minimisation) {
3161 if(qstate->reply) {
3163 iq->dp, &qstate->reply->remote_addr,
3164 qstate->reply->remote_addrlen);
3176 if(!qstate->env->cfg->disable_dnssec_lame_check && iq->dnssec_expected
3191 if(qstate->reply) {
3193 iq->dp, &qstate->reply->remote_addr,
3194 qstate->reply->remote_addrlen);
3202 qstate->reply = NULL;
3272 qstate->env->detach_subs));
3273 (*qstate->env->detach_subs)(qstate);
3275 return processDSNSFind(qstate, iq, id);
3277 if(!qstate->no_cache_store)
3278 iter_dns_store(qstate->env, &iq->response->qinfo,
3281 qstate->prefetch_leeway,
3283 qstate->region, qstate->query_flags,
3284 qstate->qstarttime);
3289 qstate->env->detach_subs));
3290 (*qstate->env->detach_subs)(qstate);
3292 if(qstate->reply)
3293 sock_list_insert(&qstate->reply_origin,
3294 &qstate->reply->remote_addr,
3295 qstate->reply->remote_addrlen, qstate->region);
3300 if(qstate->env->cfg->qname_minimisation_strict) {
3306 return error_response_cache(qstate, id,
3328 if(qstate->env->cfg->harden_below_nxdomain &&
3329 qstate->env->need_to_validate) {
3339 qstate, id, iq,
3357 if(!qstate->no_cache_store &&
3358 (!qstate->env->cfg->harden_referral_path ||
3359 ( qstate->qinfo.qtype == LDNS_RR_TYPE_NS
3360 && (qstate->query_flags&BIT_RD)
3361 && !(qstate->query_flags&BIT_CD)
3376 iter_dns_store(qstate->env, &iq->response->qinfo,
3378 qstate->qstarttime);
3380 iter_store_parentside_NS(qstate->env,
3382 if(qstate->env->neg_cache)
3383 val_neg_addreferral(qstate->env->neg_cache,
3387 if(!qstate->no_cache_store && iq->query_for_pside_glue
3395 iter_store_parentside_rrset(qstate->env,
3405 iq->dp = delegpt_from_message(iq->response, qstate->region);
3406 if (qstate->env->cfg->qname_minimisation)
3409 errinf(qstate, "malloc failure, for delegation point");
3410 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3421 rrset_cache_remove_above(qstate->env->rrset_cache,
3423 iq->qchase.qclass, *qstate->env->now,
3426 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
3427 qstate->region, iq->dp)) {
3428 errinf(qstate, "malloc failure, copy extra info into delegation point");
3429 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3442 iq->dnssec_expected = iter_indicates_dnssec(qstate->env,
3445 if(iq->dnssec_expected && qstate->env->cfg->prefetch_key &&
3446 !(qstate->query_flags&BIT_CD))
3447 generate_dnskey_prefetch(qstate, iq, id);
3453 if(qstate->env->cfg->harden_referral_path)
3454 generate_ns_check(qstate, iq, id);
3463 qstate->env->detach_subs));
3464 (*qstate->env->detach_subs)(qstate);
3489 qstate->env->detach_subs));
3490 (*qstate->env->detach_subs)(qstate);
3492 return processDSNSFind(qstate, iq, id);
3495 if(!handle_cname_response(qstate, iq, iq->response,
3497 errinf(qstate, "malloc failure, CNAME info");
3498 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3504 if(!qstate->no_cache_store)
3505 iter_dns_store(qstate->env, &iq->response->qinfo,
3506 iq->response->rep, 1, qstate->prefetch_leeway,
3508 qstate->query_flags, qstate->qstarttime);
3512 if(qstate->env->auth_zones) {
3515 rpz_callback_from_iterator_cname(qstate, iq);
3524 if(!handle_cname_response(qstate, iq, forged_response,
3526 errinf(qstate, "malloc failure, CNAME info");
3527 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3532 rpz_callback_from_iterator_cname(qstate, iq);
3535 qstate->ext_state[id] = module_finished;
3536 qstate->return_rcode = LDNS_RCODE_NOERROR;
3537 qstate->return_msg = forged_response;
3540 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
3542 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3544 qstate->return_msg->qinfo = qstate->qinfo;
3559 if(qstate->env->cfg->qname_minimisation)
3569 qstate->env->detach_subs));
3570 (*qstate->env->detach_subs)(qstate);
3572 if(qstate->reply)
3573 sock_list_insert(&qstate->reply_origin,
3574 &qstate->reply->remote_addr,
3575 qstate->reply->remote_addrlen, qstate->region);
3586 } else if(qstate->reply) {
3589 if(!infra_set_lame(qstate->env->infra_cache,
3590 &qstate->reply->remote_addr,
3591 qstate->reply->remote_addrlen,
3593 *qstate->env->now, dnsseclame, 0,
3604 } else if(qstate->reply) {
3608 if(!infra_set_lame(qstate->env->infra_cache,
3609 &qstate->reply->remote_addr,
3610 qstate->reply->remote_addrlen,
3612 *qstate->env->now, 0, 1, iq->qchase.qtype))
3629 if (qstate->env->cfg->qname_minimisation &&
3630 !qstate->env->cfg->qname_minimisation_strict)
3635 if(!auth_zones_can_fallback(qstate->env->auth_zones,
3636 iq->dp->name, iq->dp->namelen, qstate->qinfo.qclass)) {
3639 errinf_dname(qstate, "response is bad, no fallback, "
3641 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3662 * @param qstate: priming query state that finished.
3664 * @param forq: the qstate for which priming has been done.
3667 prime_supers(struct module_qstate* qstate, int id, struct module_qstate* forq)
3672 log_assert(qstate->is_priming || foriq->wait_priming_stub);
3673 log_assert(qstate->return_rcode == LDNS_RCODE_NOERROR);
3675 dp = delegpt_from_message(qstate->return_msg, forq->region);
3686 log_query_info(VERB_DETAIL, "priming successful for", &qstate->qinfo);
3689 foriq->deleg_msg = dns_copy_msg(qstate->return_msg, forq->region);
3713 * @param qstate: query state.
3719 processPrimeResponse(struct module_qstate* qstate, int id)
3721 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
3728 qstate->return_rcode = LDNS_RCODE_NOERROR;
3729 qstate->return_msg = iq->response;
3731 errinf(qstate, "prime response did not get an answer");
3732 errinf_dname(qstate, "for", qstate->qinfo.qname);
3733 qstate->return_rcode = LDNS_RCODE_SERVFAIL;
3734 qstate->return_msg = NULL;
3741 if(qstate->env->cfg->harden_referral_path) {
3744 qstate->qinfo.qname, qstate->qinfo.qtype,
3745 qstate->qinfo.qclass);
3746 if(!generate_sub_request(qstate->qinfo.qname,
3747 qstate->qinfo.qname_len, qstate->qinfo.qtype,
3748 qstate->qinfo.qclass, qstate, id, iq,
3752 generate_a_aaaa_check(qstate, iq, id);
3756 qstate->ext_state[id] = module_finished;
3769 * @param qstate: query state.
3774 processTargetResponse(struct module_qstate* qstate, int id,
3777 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
3778 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
3782 log_assert(qstate->return_rcode == LDNS_RCODE_NOERROR);
3785 log_query_info(VERB_ALGO, "processTargetResponse", &qstate->qinfo);
3797 dpns = delegpt_find_ns(foriq->dp, qstate->qinfo.qname,
3798 qstate->qinfo.qname_len);
3824 rrset = reply_find_answer_rrset(&iq->qchase, qstate->return_msg->rep);
3851 delegpt_mark_neg(dpns, qstate->qinfo.qtype);
3856 if(qstate->reply_origin && qstate->reply_origin->len != 0) {
3867 * @param qstate: query state.
3872 processDSNSResponse(struct module_qstate* qstate, int id,
3879 if(qstate->return_rcode != LDNS_RCODE_NOERROR)
3882 if(!reply_find_rrset(qstate->return_msg->rep, qstate->qinfo.qname,
3883 qstate->qinfo.qname_len, LDNS_RR_TYPE_NS,
3884 qstate->qinfo.qclass)){
3890 foriq->dp = delegpt_from_message(qstate->return_msg, forq->region);
3893 errinf(qstate, "malloc failure, in DS search");
3903 * @param qstate: query state.
3908 processClassResponse(struct module_qstate* qstate, int id,
3912 struct dns_msg* from = qstate->return_msg;
3913 log_query_info(VERB_ALGO, "processClassResponse", &qstate->qinfo);
3915 if(qstate->return_rcode != LDNS_RCODE_NOERROR) {
4008 * @param qstate: query state.
4013 processCollectClass(struct module_qstate* qstate, int id)
4015 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
4024 while(iter_get_next_root(qstate->env->hints,
4025 qstate->env->fwds, &c)) {
4028 qstate->qinfo.qname, qstate->qinfo.qtype, c);
4029 if(!generate_sub_request(qstate->qinfo.qname,
4030 qstate->qinfo.qname_len, qstate->qinfo.qtype,
4031 c, qstate, id, iq, INIT_REQUEST_STATE,
4033 (int)!(qstate->query_flags&BIT_CD), 0)) {
4034 errinf(qstate, "could not generate class ANY"
4036 return error_response(qstate, id,
4049 return error_response_cache(qstate, id, LDNS_RCODE_REFUSED);
4061 * @param qstate: query state.
4068 processFinished(struct module_qstate* qstate, struct iter_qstate* iq,
4072 &qstate->qinfo);
4075 if(!qstate->no_cache_store && iq->query_for_pside_glue
4077 iter_store_parentside_neg(qstate->env, &qstate->qinfo,
4082 errinf(qstate, "(no response found at query finish)");
4083 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4099 if((qstate->env->cfg->val_log_level >= 2 ||
4100 qstate->env->cfg->log_servfail) && qstate->errinf &&
4101 !qstate->env->cfg->val_log_squelch) {
4102 char* err_str = errinf_to_str_misc(qstate);
4110 qstate->ext_state[id] = module_finished;
4117 if(!iter_prepend(iq, iq->response, qstate->region)) {
4119 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4122 iq->response->qinfo = qstate->qinfo;
4128 if(!qstate->no_cache_store && qstate->query_flags&BIT_RD) {
4129 iter_dns_store(qstate->env, &qstate->qinfo,
4130 iq->response->rep, 0, qstate->prefetch_leeway,
4132 qstate->region, qstate->query_flags,
4133 qstate->qstarttime);
4136 qstate->return_rcode = LDNS_RCODE_NOERROR;
4137 qstate->return_msg = iq->response;
4147 * @param qstate: query state that finished.
4149 * @param super: the qstate to inform.
4152 iter_inform_super(struct module_qstate* qstate, int id,
4155 if(!qstate->is_priming && super->qinfo.qclass == LDNS_RR_CLASS_ANY)
4156 processClassResponse(qstate, id, super);
4159 processDSNSResponse(qstate, id, super);
4160 else if(qstate->return_rcode != LDNS_RCODE_NOERROR)
4161 error_supers(qstate, id, super);
4162 else if(qstate->is_priming)
4163 prime_supers(qstate, id, super);
4164 else processTargetResponse(qstate, id, super);
4174 * @param qstate: query state.
4180 iter_handle(struct module_qstate* qstate, struct iter_qstate* iq,
4189 cont = processInitRequest(qstate, iq, ie, id);
4192 cont = processInitRequest2(qstate, iq, id);
4195 cont = processInitRequest3(qstate, iq, id);
4198 cont = processQueryTargets(qstate, iq, ie, id);
4201 cont = processQueryResponse(qstate, iq, ie, id);
4204 cont = processPrimeResponse(qstate, id);
4207 cont = processCollectClass(qstate, id);
4210 cont = processDSNSFind(qstate, iq, id);
4213 cont = processFinished(qstate, iq, id);
4227 * @param qstate: query state.
4233 process_request(struct module_qstate* qstate, struct iter_qstate* iq,
4241 iter_handle(qstate, iq, ie, id);
4246 process_response(struct module_qstate* qstate, struct iter_qstate* iq,
4259 qstate->env->cfg->use_caps_bits_for_id &&
4278 || !qstate->reply) {
4281 errinf(qstate, "module iterator received wrong internal event with a response message");
4282 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4287 fill_fail_addr(iq, &qstate->reply->remote_addr,
4288 qstate->reply->remote_addrlen);
4289 prs = (struct msg_parse*)regional_alloc(qstate->env->scratch,
4298 pkt = qstate->reply->c->buffer;
4300 if(parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) {
4306 if(parse_extract_edns_from_response_msg(prs, &edns, qstate->env->scratch) !=
4314 qstate->edns_opts_back_in = edns_opt_copy_region(edns.opt_list_in,
4315 qstate->region);
4316 if(!qstate->edns_opts_back_in) {
4322 if(!inplace_cb_edns_back_parsed_call(qstate->env, qstate)) {
4332 qstate->env->scratch, qstate->env, qstate, ie)) {
4349 iq->response = dns_alloc_msg(pkt, prs, qstate->region);
4352 log_query_info(VERB_DETAIL, "response for", &qstate->qinfo);
4354 &qstate->reply->remote_addr, qstate->reply->remote_addrlen);
4360 if(qstate->env->cfg->qname_minimisation &&
4411 qstate->env->scratch)) {
4415 errinf(qstate, "0x20 failed, then got different replies in fallback");
4416 (void)error_response_cache(qstate, id,
4433 iter_handle(qstate, iq, ie, id);
4437 iter_operate(struct module_qstate* qstate, enum module_ev event, int id,
4440 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
4441 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
4443 id, strextstate(qstate->ext_state[id]), strmodulevent(event));
4445 &qstate->qinfo);
4446 if(iq && qstate->qinfo.qname != iq->qchase.qname)
4453 if(!iter_new(qstate, id)) {
4454 errinf(qstate, "malloc failure, new iterator module allocation");
4455 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4458 iq = (struct iter_qstate*)qstate->minfo[id];
4459 process_request(qstate, iq, ie, id);
4463 iter_handle(qstate, iq, ie, id);
4467 process_response(qstate, iq, ie, id, outbound, event);
4472 errinf(qstate, "iterator module got the error event");
4473 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4478 errinf(qstate, "iterator module received wrong event");
4479 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4483 iter_clear(struct module_qstate* qstate, int id)
4486 if(!qstate)
4488 iq = (struct iter_qstate*)qstate->minfo[id];
4498 qstate->minfo[id] = NULL;