Lines Matching defs:qstate
139 iter_new(struct module_qstate* qstate, int id)
142 qstate->region, sizeof(struct iter_qstate));
143 qstate->minfo[id] = iq;
167 iq->chase_flags = qstate->query_flags;
169 iq->qchase = qstate->qinfo;
173 if (qstate->env->cfg->qname_minimisation)
213 * The response is stored in the qstate->buf buffer.
227 * @param qstate: query state that failed.
232 error_supers(struct module_qstate* qstate, int id, struct module_qstate* super)
234 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
237 if(qstate->qinfo.qtype == LDNS_RR_TYPE_A ||
238 qstate->qinfo.qtype == LDNS_RR_TYPE_AAAA) {
244 qstate->qinfo.qname, qstate->qinfo.qname_len);
260 delegpt_mark_neg(dpns, qstate->qinfo.qtype);
267 if(qstate->qinfo.qtype == LDNS_RR_TYPE_NS) {
278 * @param qstate: our query state
285 error_response(struct module_qstate* qstate, int id, int rcode)
290 qstate->return_rcode = rcode;
291 qstate->return_msg = NULL;
292 qstate->ext_state[id] = module_finished;
299 * @param qstate: our query state
306 error_response_cache(struct module_qstate* qstate, int id, int rcode)
310 if(qstate->no_cache_store) {
311 return error_response(qstate, id, rcode);
313 if(qstate->prefetch_leeway > NORR_TTL) {
316 if(dns_cache_prefetch_adjust(qstate->env, &qstate->qinfo,
317 NORR_TTL, qstate->query_flags))
318 return error_response(qstate, id, rcode);
321 if((msg=msg_cache_lookup(qstate->env,
322 qstate->qinfo.qname, qstate->qinfo.qname_len,
323 qstate->qinfo.qtype, qstate->qinfo.qclass,
324 qstate->query_flags, 0,
325 qstate->env->cfg->serve_expired)) != NULL) {
327 if(qstate->env->cfg->serve_expired && rep) {
328 if(qstate->env->cfg->serve_expired_ttl_reset &&
329 *qstate->env->now + qstate->env->cfg->serve_expired_ttl
333 rep->serve_expired_ttl = *qstate->env->now +
334 qstate->env->cfg->serve_expired_ttl;
339 *qstate->env->now;
347 (qstate->env->cfg->serve_expired ||
348 *qstate->env->now <= rep->ttl)) {
351 return error_response(qstate, id, rcode);
370 iter_dns_store(qstate->env, &qstate->qinfo, &err, 0, 0, 0, NULL,
371 qstate->query_flags, qstate->qstarttime);
372 return error_response(qstate, id, rcode);
479 * @param qstate: query state.
485 iter_add_prepend_answer(struct module_qstate* qstate, struct iter_qstate* iq,
489 qstate->region, sizeof(struct iter_prep_list));
504 * @param qstate: query state.
510 iter_add_prepend_auth(struct module_qstate* qstate, struct iter_qstate* iq,
514 qstate->region, sizeof(struct iter_prep_list));
534 * @param qstate: query state.
542 handle_cname_response(struct module_qstate* qstate, struct iter_qstate* iq,
561 if(!iter_add_prepend_answer(qstate, iq, r))
570 if(!iter_add_prepend_answer(qstate, iq, r))
584 if(!iter_add_prepend_auth(qstate, iq, r))
641 errinf_reply(struct module_qstate* qstate, struct iter_qstate* iq)
643 if(qstate->env->cfg->val_log_level < 2 && !qstate->env->cfg->log_servfail)
645 if((qstate->reply && qstate->reply->remote_addrlen != 0) ||
648 if(qstate->reply && qstate->reply->remote_addrlen != 0)
649 addr_to_str(&qstate->reply->remote_addr,
650 qstate->reply->remote_addrlen, from,
655 errinf(qstate, frm);
659 errinf(qstate, "upstream response failed scrub");
661 errinf(qstate, "could not parse upstream response");
663 errinf(qstate, "upstream server timeout");
665 errinf(qstate, "no server to query");
668 errinf(qstate, "no addresses for nameservers");
669 else errinf(qstate, "nameserver addresses not usable");
671 errinf(qstate, "have no nameserver names");
673 errinf(qstate, "NS record was dnssec bogus");
683 errinf(qstate, rcode);
687 errinf(qstate, "nodata answer");
794 * @param qstate The event that is generating this event.
804 * @param detached: true if this qstate should not attach to the subquery
809 uint16_t qclass, struct module_qstate* qstate, int id,
842 qstate->env->add_sub));
843 if(!(*qstate->env->add_sub)(qstate, &qinf,
851 qstate->env->attach_sub));
852 if(!(*qstate->env->attach_sub)(qstate, &qinf, qflags, prime,
867 qstate->env->kill_sub));
868 (*qstate->env->kill_sub)(subq);
889 if(qstate->env->cfg->qname_minimisation)
900 * @param qstate: the qtstate that triggered the need to prime.
907 prime_root(struct module_qstate* qstate, struct iter_qstate* iq, int id,
916 dp = hints_find_root(qstate->env->hints, qclass, nolock);
924 qclass, qstate, id, iq, QUERYTARGETS_STATE, PRIME_RESP_STATE,
926 lock_rw_unlock(&qstate->env->hints->lock);
937 lock_rw_unlock(&qstate->env->hints->lock);
941 qstate->env->kill_sub));
942 (*qstate->env->kill_sub)(subq);
948 qstate->env, subiq->dp, NULL, subq->qinfo.qclass);
950 lock_rw_unlock(&qstate->env->hints->lock);
954 qstate->ext_state[id] = module_wait_subquery;
962 * @param qstate: the qtstate that triggered the need to prime.
973 prime_stub(struct module_qstate* qstate, struct iter_qstate* iq, int id,
984 stub = hints_lookup_stub(qstate->env->hints, qname, qclass, iq->dp,
993 lock_rw_unlock(&qstate->env->hints->lock);
1003 iq->dp = delegpt_copy(stub_dp, qstate->region);
1004 lock_rw_unlock(&qstate->env->hints->lock);
1007 errinf(qstate, "malloc failure, priming stub");
1008 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1023 LDNS_RR_TYPE_NS, qclass, qstate, id, iq,
1025 lock_rw_unlock(&qstate->env->hints->lock);
1027 errinf(qstate, "could not generate lookup for stub prime");
1028 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1038 lock_rw_unlock(&qstate->env->hints->lock);
1042 qstate->env->kill_sub));
1043 (*qstate->env->kill_sub)(subq);
1044 errinf(qstate, "malloc failure, in stub prime");
1045 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1054 qstate->env, subiq->dp, NULL, subq->qinfo.qclass);
1056 lock_rw_unlock(&qstate->env->hints->lock);
1060 qstate->ext_state[id] = module_wait_subquery;
1069 auth_zone_delegpt(struct module_qstate* qstate, struct iter_qstate* iq,
1079 lock_rw_rdlock(&qstate->env->auth_zones->lock);
1080 z = auth_zones_find_zone(qstate->env->auth_zones, delname, delnamelen,
1081 qstate->qinfo.qclass);
1083 lock_rw_unlock(&qstate->env->auth_zones->lock);
1087 lock_rw_unlock(&qstate->env->auth_zones->lock);
1090 && iq->dp->auth_dp && qstate->blacklist &&
1107 if(qstate->blacklist && z->fallback_enabled) {
1122 qstate->region, sizeof(*dp));
1130 errinf(qstate, "malloc failure");
1133 dp->name = regional_alloc_init(qstate->region,
1142 errinf(qstate, "malloc failure");
1160 * @param qstate: the qtstate that triggered the need to prime.
1165 generate_a_aaaa_check(struct module_qstate* qstate, struct iter_qstate* iq,
1168 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
1188 if(qstate->qinfo.qtype == ntohs(s->rk.type) &&
1189 qstate->qinfo.qclass == ntohs(s->rk.rrset_class) &&
1190 query_dname_compare(qstate->qinfo.qname,
1192 (qstate->query_flags&BIT_RD) &&
1193 !(qstate->query_flags&BIT_CD))
1202 qstate, id, iq,
1215 * @param qstate: the qstate that triggered the need to prime.
1220 generate_ns_check(struct module_qstate* qstate, struct iter_qstate* iq, int id)
1222 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
1228 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen,
1232 if(qstate->qinfo.qtype == LDNS_RR_TYPE_NS &&
1233 query_dname_compare(iq->dp->name, qstate->qinfo.qname)==0 &&
1234 (qstate->query_flags&BIT_RD) && !(qstate->query_flags&BIT_CD)){
1236 generate_a_aaaa_check(qstate, iq, id);
1240 if(qstate->qinfo.qtype == LDNS_RR_TYPE_DS)
1246 LDNS_RR_TYPE_NS, iq->qchase.qclass, qstate, id, iq,
1262 qstate->env->kill_sub));
1263 (*qstate->env->kill_sub)(subq);
1281 * @param qstate: the qtstate that triggered the need to prime.
1286 generate_dnskey_prefetch(struct module_qstate* qstate,
1293 if(qstate->qinfo.qtype == LDNS_RR_TYPE_DNSKEY &&
1294 query_dname_compare(iq->dp->name, qstate->qinfo.qname)==0 &&
1295 (qstate->query_flags&BIT_RD) && !(qstate->query_flags&BIT_CD)){
1305 if(mesh_jostle_exceeded(qstate->env->mesh))
1312 LDNS_RR_TYPE_DNSKEY, iq->qchase.qclass, qstate, id, iq,
1321 /* this qstate has the right delegation for the dnskey lookup*/
1331 * @param qstate: query state.
1337 forward_request(struct module_qstate* qstate, struct iter_qstate* iq)
1351 dp = forwards_lookup(qstate->env->fwds, delname, iq->qchase.qclass,
1356 iq->dp = delegpt_copy(dp, qstate->region);
1357 lock_rw_unlock(&qstate->env->fwds->lock);
1374 * @param qstate: query state.
1382 processInitRequest(struct module_qstate* qstate, struct iter_qstate* iq,
1390 log_query_info(VERB_DETAIL, "resolving", &qstate->qinfo);
1398 errinf(qstate, "request has exceeded the maximum number "
1401 errinf_dname(qstate, "stop at", iq->qchase.qname);
1402 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
1413 errinf(qstate, "request has exceeded the maximum dependency "
1415 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1419 if(qstate->qinfo.qclass == LDNS_RR_CLASS_ANY) {
1431 !can_have_last_resort(qstate->env, iq->dp->name,
1442 if(qstate->env->auth_zones) {
1445 rpz_callback_from_iterator_cname(qstate, iq);
1457 if(!handle_cname_response(qstate, iq, forged_response,
1459 errinf(qstate, "malloc failure, CNAME info");
1460 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1465 rpz_callback_from_iterator_cname(qstate, iq);
1468 qstate->ext_state[id] = module_finished;
1469 qstate->return_rcode = LDNS_RCODE_NOERROR;
1470 qstate->return_msg = forged_response;
1473 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
1475 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1477 qstate->return_msg->qinfo = qstate->qinfo;
1486 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1487 if(qstate->env->cfg->qname_minimisation)
1493 if (iter_stub_fwd_no_cache(qstate, &iq->qchase, &dpname, &dpnamelen,
1497 qstate->no_cache_lookup = 1;
1498 qstate->no_cache_store = 1;
1500 } else if(qstate->blacklist) {
1505 } else if(!qstate->no_cache_lookup) {
1506 msg = dns_cache_lookup(qstate->env, iq->qchase.qname,
1508 iq->qchase.qclass, qstate->query_flags,
1509 qstate->region, qstate->env->scratch, 0, dpname,
1511 if(!msg && qstate->env->neg_cache &&
1512 iter_qname_indicates_dnssec(qstate->env, &iq->qchase)) {
1515 msg = val_neg_getmsg(qstate->env->neg_cache, &iq->qchase,
1516 qstate->region, qstate->env->rrset_cache,
1517 qstate->env->scratch_buffer,
1518 *qstate->env->now, 1/*add SOA*/, NULL,
1519 qstate->env->cfg);
1523 if(msg && query_dname_compare(qstate->qinfo.qname,
1544 if(!handle_cname_response(qstate, iq, msg,
1546 errinf(qstate, "failed to prepend CNAME "
1548 return error_response(qstate, id,
1560 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1561 if(qstate->env->cfg->qname_minimisation)
1566 if(qstate->reply_origin)
1567 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1569 errinf(qstate, "SERVFAIL in cache");
1577 if(forward_request(qstate, iq))
1581 errinf(qstate, "malloc failure for forward zone");
1582 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1584 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
1585 qstate->region, iq->dp, 0)) {
1586 errinf(qstate, "malloc failure, copy extra info into delegation point");
1587 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1589 if((qstate->query_flags&BIT_RD)==0) {
1599 errinf(qstate, "cannot forward RD=0 query");
1600 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1619 errinf(qstate, "malloc failure, for delegation info");
1620 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1629 (iq->qchase.qtype == LDNS_RR_TYPE_NS && qstate->prefetch_leeway
1630 && can_have_last_resort(qstate->env, delname, delnamelen, iq->qchase.qclass, NULL, NULL, NULL))) {
1638 qstate->prefetch_leeway)))
1648 iq->dp = dns_cache_find_delegation(qstate->env, delname,
1650 qstate->region, &iq->deleg_msg,
1651 *qstate->env->now+qstate->prefetch_leeway, 1,
1661 if(!auth_zone_delegpt(qstate, iq, delname, delnamelen))
1662 return error_response(qstate, id,
1667 r = prime_stub(qstate, iq, id, delname,
1673 if(forwards_lookup_root(qstate->env->fwds,
1675 lock_rw_unlock(&qstate->env->fwds->lock);
1678 iq->dp = hints_find_root(qstate->env->hints,
1682 errinf(qstate, "no hints for this class");
1683 return error_response_cache(qstate, id,
1686 iq->dp = delegpt_copy(iq->dp, qstate->region);
1687 lock_rw_unlock(&qstate->env->hints->lock);
1690 errinf(qstate, "malloc failure, in safety belt");
1691 return error_response(qstate, id,
1698 if(!prime_root(qstate, iq, id, iq->qchase.qclass))
1699 return error_response(qstate, id,
1708 if(!iq->ratelimit_ok && qstate->prefetch_leeway)
1724 if(iter_dp_is_useless(&qstate->qinfo, qstate->query_flags,
1728 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen, iq->qchase.qclass, &have_dp, &iq->dp, qstate->region)) {
1736 errinf(qstate, "malloc failure, for fallback to config");
1737 return error_response(qstate,
1745 errinf(qstate, "no useful nameservers, "
1747 errinf_dname(qstate, "for zone", iq->dp->name);
1748 return error_response(qstate, id,
1756 iq->dp = hints_find_root(qstate->env->hints,
1762 return error_response(qstate, id,
1765 iq->dp = delegpt_copy(iq->dp, qstate->region);
1766 lock_rw_unlock(&qstate->env->hints->lock);
1769 errinf(qstate, "malloc failure, in safety belt, for root");
1770 return error_response(qstate, id,
1803 * @param qstate: query state.
1810 processInitRequest2(struct module_qstate* qstate, struct iter_qstate* iq,
1816 &qstate->qinfo);
1825 errinf(qstate, "malloc failure, no delegation info");
1826 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1831 qstate->env->hints, iq->qchase.qname, iq->qchase.qclass,
1839 if(stub) { lock_rw_unlock(&qstate->env->hints->lock); }
1849 if(!auth_zone_delegpt(qstate, iq, delname, delnamelen))
1850 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
1853 if(prime_stub(qstate, iq, id, delname, iq->qchase.qclass)) {
1868 * @param qstate: query state.
1874 processInitRequest3(struct module_qstate* qstate, struct iter_qstate* iq,
1878 &qstate->qinfo);
1881 iq->dnssec_expected = iter_indicates_dnssec(qstate->env, iq->dp,
1886 if(!(qstate->query_flags & BIT_RD) && iq->deleg_msg) {
1891 if(qstate->reply_origin)
1892 sock_list_insert(&qstate->reply_origin, NULL, 0, qstate->region);
1900 if(iq->dnssec_expected && qstate->env->cfg->prefetch_key &&
1901 !(qstate->query_flags&BIT_CD)) {
1902 generate_dnskey_prefetch(qstate, iq, id);
1904 qstate->env->detach_subs));
1905 (*qstate->env->detach_subs)(qstate);
1917 * @param qstate: query state.
1927 generate_parentside_target_query(struct module_qstate* qstate,
1932 if(!generate_sub_request(name, namelen, qtype, qclass, qstate,
1944 qstate->env, subiq->dp, NULL,
1948 subiq->dp = dns_cache_find_delegation(qstate->env,
1951 *qstate->env->now+subq->prefetch_leeway,
1956 qstate->env, subiq->dp, NULL,
1970 * @param qstate: query state.
1980 generate_target_query(struct module_qstate* qstate, struct iter_qstate* iq,
1984 if(!generate_sub_request(name, namelen, qtype, qclass, qstate,
1995 * @param qstate: query state.
2007 query_for_targets(struct module_qstate* qstate, struct iter_qstate* iq,
2015 iter_mark_cycle_targets(qstate, iq->dp);
2037 dname_str(qstate->qinfo.qname, s);
2045 dname_str(qstate->qinfo.qname, s);
2061 if(!iter_ns_probability(qstate->env->rnd, toget, missing)) {
2072 if(!generate_target_query(qstate, iq, id,
2077 qstate->ext_state[id] = module_wait_subquery;
2087 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2102 if(!generate_target_query(qstate, iq, id,
2107 qstate->ext_state[id] = module_wait_subquery;
2112 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2130 qstate->ext_state[id] = module_wait_subquery;
2140 * @param qstate: query state.
2148 processLastResort(struct module_qstate* qstate, struct iter_qstate* iq,
2156 if(!can_have_last_resort(qstate->env, iq->dp->name, iq->dp->namelen,
2160 errinf(qstate, "all the configured stub or forward servers failed,");
2161 errinf_dname(qstate, "at zone", iq->dp->name);
2162 errinf_reply(qstate, iq);
2164 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2166 if(qstate->env->cfg->harden_unverified_glue) {
2167 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
2168 qstate->region, iq->dp, PACKED_RRSET_UNVERIFIED_GLUE))
2178 dp = hints_find_root(qstate->env->hints,
2184 (void)delegpt_add_ns(iq->dp, qstate->region,
2189 (void)delegpt_add_addr(iq->dp, qstate->region,
2193 lock_rw_unlock(&qstate->env->hints->lock);
2197 if(!iter_lookup_parent_NS_from_cache(qstate->env, iq->dp,
2198 qstate->region, &qstate->qinfo)
2210 if(qstate->env->cfg->qname_minimisation)
2216 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
2217 qstate->region, iq->dp, 0))
2224 if(iter_lookup_parent_glue_from_cache(qstate->env, iq->dp,
2225 qstate->region, &qstate->qinfo)) {
2234 if((ret=query_for_targets(qstate, iq, ie, id, 1, &qs))!=0) {
2235 errinf(qstate, "could not fetch nameserver");
2236 errinf_dname(qstate, "at zone", iq->dp->name);
2238 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2239 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2244 qstate->ext_state[id] = module_wait_subquery;
2250 errinf(qstate, "cannot fetch more nameservers because at max dependency depth");
2251 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2256 dname_str(qstate->qinfo.qname, s);
2260 errinf(qstate, "exceeded the maximum number of glue fetches");
2261 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2264 iter_mark_pside_cycle_targets(qstate, iq->dp);
2272 !can_have_last_resort(qstate->env, ns->name, ns->namelen,
2284 if(!generate_parentside_target_query(qstate, iq, id,
2287 errinf_dname(qstate, "could not generate nameserver AAAA lookup for", ns->name);
2288 return error_response(qstate, id,
2293 if(mesh_jostle_exceeded(qstate->env->mesh)) {
2299 qstate->ext_state[id] = module_wait_subquery;
2305 if(!generate_parentside_target_query(qstate, iq, id,
2308 errinf_dname(qstate, "could not generate nameserver A lookup for", ns->name);
2309 return error_response(qstate, id,
2319 qstate->ext_state[id] = module_wait_subquery;
2326 if(!qstate->no_cache_store && iq->query_for_pside_glue
2328 iter_store_parentside_neg(qstate->env, &qstate->qinfo,
2332 errinf(qstate, "all servers for this domain failed,");
2333 errinf_dname(qstate, "at zone", iq->dp->name);
2334 errinf_reply(qstate, iq);
2338 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2348 * @param qstate: query state.
2356 processDSNSFind(struct module_qstate* qstate, struct iter_qstate* iq, int id)
2368 errinf_dname(qstate, "for DS query parent-child nameserver search the query is not under the zone", iq->dp->name);
2369 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2387 LDNS_RR_TYPE_NS, iq->qchase.qclass, qstate, id, iq,
2389 errinf_dname(qstate, "for DS query parent-child nameserver search, could not generate NS lookup for", iq->dsns_point);
2390 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2401 check_waiting_queries(struct iter_qstate* iq, struct module_qstate* qstate,
2409 qstate->ext_state[id] = module_wait_reply;
2413 qstate->ext_state[id] = module_wait_subquery;
2418 qstate->ext_state[id] = module_wait_reply;
2430 * @param qstate: query state.
2439 processQueryTargets(struct module_qstate* qstate, struct iter_qstate* iq,
2458 log_query_info(VERB_QUERY, "processQueryTargets:", &qstate->qinfo);
2467 errinf(qstate, "exceeded the maximum of referrals");
2468 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2473 errinf(qstate, "exceeded the maximum number of sends");
2474 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2483 check_waiting_queries(iq, qstate, id);
2493 errinf(qstate, "failed to get a delegation (eg. prime "
2495 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2503 errinf(qstate, "exceeded the maximum nameserver nxdomains");
2504 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2520 errinf(qstate, "exceeded the maximum nameserver "
2522 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2529 check_waiting_queries(iq, qstate, id);
2536 errinf(qstate, "failed to get a delegation (eg. prime "
2538 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2546 errinf(qstate, "exceeded the maximum nameserver nxdomains");
2547 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2567 errinf(qstate, "failed to get a delegation (eg. prime failure)");
2568 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2581 qstate->ext_state[id] = module_wait_reply;
2660 else if(!qstate->no_cache_lookup) {
2661 struct dns_msg* msg = dns_cache_lookup(qstate->env,
2664 qstate->query_flags, qstate->region,
2665 qstate->env->scratch, 0, iq->dp->name,
2674 qstate->env->need_to_validate &&
2675 qstate->env->cfg->harden_below_nxdomain) {
2687 qstate, id, iq,
2709 else if(!qstate->env->cfg->qname_minimisation_strict)
2721 if(!iq->auth_zone_avoid && qstate->blacklist) {
2722 if(auth_zones_can_fallback(qstate->env->auth_zones,
2733 } else if(auth_zones_lookup(qstate->env->auth_zones, &iq->qinfo_out,
2734 qstate->region, &iq->response, &auth_fallback, iq->dp->name,
2744 lock_rw_wrlock(&qstate->env->auth_zones->lock);
2745 qstate->env->auth_zones->num_query_up++;
2746 lock_rw_unlock(&qstate->env->auth_zones->lock);
2760 errinf(qstate, "auth zone lookup failed, fallback is off");
2761 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2784 if(can_do_promisc && !mesh_jostle_exceeded(qstate->env->mesh)) {
2792 if((ret=query_for_targets(qstate, iq, ie, id, -1, &extra))!=0) {
2793 errinf(qstate, "could not fetch nameservers for 0x20 fallback");
2795 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2796 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
2803 qstate->ext_state[id] = module_wait_reply;
2846 (void)query_for_targets(qstate, iq, ie, id, tf_policy, &extra);
2856 if(qstate->env->auth_zones) {
2861 struct dns_msg* forged_response = rpz_callback_from_iterator_module(qstate, iq);
2870 if(!handle_cname_response(qstate, iq, forged_response,
2872 errinf(qstate, "malloc failure, CNAME info");
2873 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2878 rpz_callback_from_iterator_cname(qstate, iq);
2891 if(qstate->env->cfg->qname_minimisation)
2896 qstate->env->detach_subs));
2897 (*qstate->env->detach_subs)(qstate);
2903 qstate->ext_state[id] = module_finished;
2904 qstate->return_rcode = LDNS_RCODE_NOERROR;
2905 qstate->return_msg = forged_response;
2908 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
2910 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
2917 target = iter_server_selection(ie, qstate->env, iq->dp,
2920 iq->num_target_queries, qstate->blacklist,
2921 qstate->prefetch_leeway);
2942 if((ret=query_for_targets(qstate, iq, ie, id,
2944 errinf(qstate, "could not fetch nameserver");
2945 errinf_dname(qstate, "at zone", iq->dp->name);
2947 return error_response(qstate, id,
2949 return error_response_cache(qstate, id,
2967 errinf(qstate, "could not generate nameserver lookups");
2968 errinf_dname(qstate, "at zone", iq->dp->name);
2969 return error_response(qstate, id,
2997 return processLastResort(qstate, iq, ie, id);
3004 check_waiting_queries(iq, qstate, id);
3024 && !ub_random_max(qstate->env->rnd, 10)) {
3028 (void)query_for_targets(qstate, iq, ie, id, 1, &extra);
3034 check_waiting_queries(iq, qstate, id);
3050 dname_str(qstate->qinfo.qname, s);
3054 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3081 fptr_ok(fptr_whitelist_modenv_send_query(qstate->env->send_query));
3082 outq = (*qstate->env->send_query)(&iq->qinfo_out,
3087 (qstate->env->cfg->disable_edns_do?0:EDNS_DO)|
3089 !qstate->blacklist&&(!iter_qname_indicates_dnssec(qstate->env,
3094 (iq->dp->tcp_upstream || qstate->env->cfg->tcp_upstream),
3095 (iq->dp->ssl_upstream || qstate->env->cfg->ssl_upstream),
3096 target->tls_auth_name, qstate, &sq_was_ratelimited);
3103 qstate->was_ratelimited = 1;
3104 errinf_dname(qstate, "exceeded ratelimit for zone",
3106 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3110 if(qstate->env->cfg->qname_minimisation)
3117 qstate->ext_state[id] = module_wait_reply;
3141 * @param qstate: query state.
3150 processQueryResponse(struct module_qstate* qstate, struct iter_qstate* iq,
3158 if(!inplace_cb_query_response_call(qstate->env, qstate, iq->response))
3163 if(qstate->env->cfg->qname_minimisation) {
3183 if(qstate->reply) {
3185 iq->dp, &qstate->reply->remote_addr,
3186 qstate->reply->remote_addrlen);
3198 if(!qstate->env->cfg->disable_dnssec_lame_check && iq->dnssec_expected
3213 if(qstate->reply) {
3215 iq->dp, &qstate->reply->remote_addr,
3216 qstate->reply->remote_addrlen);
3224 qstate->reply = NULL;
3294 qstate->env->detach_subs));
3295 (*qstate->env->detach_subs)(qstate);
3297 return processDSNSFind(qstate, iq, id);
3299 if(!qstate->no_cache_store)
3300 iter_dns_store(qstate->env, &iq->response->qinfo,
3303 qstate->prefetch_leeway,
3305 qstate->region, qstate->query_flags,
3306 qstate->qstarttime);
3311 qstate->env->detach_subs));
3312 (*qstate->env->detach_subs)(qstate);
3314 if(qstate->reply)
3315 sock_list_insert(&qstate->reply_origin,
3316 &qstate->reply->remote_addr,
3317 qstate->reply->remote_addrlen, qstate->region);
3322 if(qstate->env->cfg->qname_minimisation_strict) {
3328 return error_response_cache(qstate, id,
3350 if(qstate->env->cfg->harden_below_nxdomain &&
3351 qstate->env->need_to_validate) {
3361 qstate, id, iq,
3379 if(!qstate->no_cache_store &&
3380 (!qstate->env->cfg->harden_referral_path ||
3381 ( qstate->qinfo.qtype == LDNS_RR_TYPE_NS
3382 && (qstate->query_flags&BIT_RD)
3383 && !(qstate->query_flags&BIT_CD)
3398 iter_dns_store(qstate->env, &iq->response->qinfo,
3400 qstate->qstarttime);
3402 iter_store_parentside_NS(qstate->env,
3404 if(qstate->env->neg_cache)
3405 val_neg_addreferral(qstate->env->neg_cache,
3409 if(!qstate->no_cache_store && iq->query_for_pside_glue
3417 iter_store_parentside_rrset(qstate->env,
3427 iq->dp = delegpt_from_message(iq->response, qstate->region);
3428 if (qstate->env->cfg->qname_minimisation)
3431 errinf(qstate, "malloc failure, for delegation point");
3432 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3443 rrset_cache_remove_above(qstate->env->rrset_cache,
3445 iq->qchase.qclass, *qstate->env->now,
3448 if(!cache_fill_missing(qstate->env, iq->qchase.qclass,
3449 qstate->region, iq->dp, 0)) {
3450 errinf(qstate, "malloc failure, copy extra info into delegation point");
3451 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3464 iq->dnssec_expected = iter_indicates_dnssec(qstate->env,
3467 if(iq->dnssec_expected && qstate->env->cfg->prefetch_key &&
3468 !(qstate->query_flags&BIT_CD))
3469 generate_dnskey_prefetch(qstate, iq, id);
3475 if(qstate->env->cfg->harden_referral_path)
3476 generate_ns_check(qstate, iq, id);
3485 qstate->env->detach_subs));
3486 (*qstate->env->detach_subs)(qstate);
3511 qstate->env->detach_subs));
3512 (*qstate->env->detach_subs)(qstate);
3514 return processDSNSFind(qstate, iq, id);
3517 if(!handle_cname_response(qstate, iq, iq->response,
3519 errinf(qstate, "malloc failure, CNAME info");
3520 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3526 if(!qstate->no_cache_store)
3527 iter_dns_store(qstate->env, &iq->response->qinfo,
3528 iq->response->rep, 1, qstate->prefetch_leeway,
3530 qstate->query_flags, qstate->qstarttime);
3534 if(qstate->env->auth_zones) {
3537 rpz_callback_from_iterator_cname(qstate, iq);
3546 if(!handle_cname_response(qstate, iq, forged_response,
3548 errinf(qstate, "malloc failure, CNAME info");
3549 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3554 rpz_callback_from_iterator_cname(qstate, iq);
3557 qstate->ext_state[id] = module_finished;
3558 qstate->return_rcode = LDNS_RCODE_NOERROR;
3559 qstate->return_msg = forged_response;
3562 if(!iter_prepend(iq, qstate->return_msg, qstate->region)) {
3564 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
3566 qstate->return_msg->qinfo = qstate->qinfo;
3581 if(qstate->env->cfg->qname_minimisation)
3591 qstate->env->detach_subs));
3592 (*qstate->env->detach_subs)(qstate);
3594 if(qstate->reply)
3595 sock_list_insert(&qstate->reply_origin,
3596 &qstate->reply->remote_addr,
3597 qstate->reply->remote_addrlen, qstate->region);
3608 } else if(qstate->reply) {
3611 if(!infra_set_lame(qstate->env->infra_cache,
3612 &qstate->reply->remote_addr,
3613 qstate->reply->remote_addrlen,
3615 *qstate->env->now, dnsseclame, 0,
3626 } else if(qstate->reply) {
3630 if(!infra_set_lame(qstate->env->infra_cache,
3631 &qstate->reply->remote_addr,
3632 qstate->reply->remote_addrlen,
3634 *qstate->env->now, 0, 1, iq->qchase.qtype))
3651 if (qstate->env->cfg->qname_minimisation &&
3652 !qstate->env->cfg->qname_minimisation_strict)
3657 if(!auth_zones_can_fallback(qstate->env->auth_zones,
3658 iq->dp->name, iq->dp->namelen, qstate->qinfo.qclass)) {
3661 errinf_dname(qstate, "response is bad, no fallback, "
3663 return error_response_cache(qstate, id, LDNS_RCODE_SERVFAIL);
3684 * @param qstate: priming query state that finished.
3686 * @param forq: the qstate for which priming has been done.
3689 prime_supers(struct module_qstate* qstate, int id, struct module_qstate* forq)
3694 log_assert(qstate->is_priming || foriq->wait_priming_stub);
3695 log_assert(qstate->return_rcode == LDNS_RCODE_NOERROR);
3697 dp = delegpt_from_message(qstate->return_msg, forq->region);
3708 log_query_info(VERB_DETAIL, "priming successful for", &qstate->qinfo);
3711 foriq->deleg_msg = dns_copy_msg(qstate->return_msg, forq->region);
3735 * @param qstate: query state.
3741 processPrimeResponse(struct module_qstate* qstate, int id)
3743 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
3750 qstate->return_rcode = LDNS_RCODE_NOERROR;
3751 qstate->return_msg = iq->response;
3753 errinf(qstate, "prime response did not get an answer");
3754 errinf_dname(qstate, "for", qstate->qinfo.qname);
3755 qstate->return_rcode = LDNS_RCODE_SERVFAIL;
3756 qstate->return_msg = NULL;
3763 if(qstate->env->cfg->harden_referral_path) {
3766 qstate->qinfo.qname, qstate->qinfo.qtype,
3767 qstate->qinfo.qclass);
3768 if(!generate_sub_request(qstate->qinfo.qname,
3769 qstate->qinfo.qname_len, qstate->qinfo.qtype,
3770 qstate->qinfo.qclass, qstate, id, iq,
3774 generate_a_aaaa_check(qstate, iq, id);
3778 qstate->ext_state[id] = module_finished;
3791 * @param qstate: query state.
3796 processTargetResponse(struct module_qstate* qstate, int id,
3799 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
3800 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
3804 log_assert(qstate->return_rcode == LDNS_RCODE_NOERROR);
3807 log_query_info(VERB_ALGO, "processTargetResponse", &qstate->qinfo);
3819 dpns = delegpt_find_ns(foriq->dp, qstate->qinfo.qname,
3820 qstate->qinfo.qname_len);
3846 rrset = reply_find_answer_rrset(&iq->qchase, qstate->return_msg->rep);
3873 delegpt_mark_neg(dpns, qstate->qinfo.qtype);
3878 if(qstate->reply_origin && qstate->reply_origin->len != 0) {
3889 * @param qstate: query state.
3894 processDSNSResponse(struct module_qstate* qstate, int id,
3901 if(qstate->return_rcode != LDNS_RCODE_NOERROR)
3904 if(!reply_find_rrset(qstate->return_msg->rep, qstate->qinfo.qname,
3905 qstate->qinfo.qname_len, LDNS_RR_TYPE_NS,
3906 qstate->qinfo.qclass)){
3912 foriq->dp = delegpt_from_message(qstate->return_msg, forq->region);
3915 errinf(qstate, "malloc failure, in DS search");
3925 * @param qstate: query state.
3930 processClassResponse(struct module_qstate* qstate, int id,
3934 struct dns_msg* from = qstate->return_msg;
3935 log_query_info(VERB_ALGO, "processClassResponse", &qstate->qinfo);
3937 if(qstate->return_rcode != LDNS_RCODE_NOERROR) {
4032 * @param qstate: query state.
4037 processCollectClass(struct module_qstate* qstate, int id)
4039 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
4048 while(iter_get_next_root(qstate->env->hints,
4049 qstate->env->fwds, &c)) {
4052 qstate->qinfo.qname, qstate->qinfo.qtype, c);
4053 if(!generate_sub_request(qstate->qinfo.qname,
4054 qstate->qinfo.qname_len, qstate->qinfo.qtype,
4055 c, qstate, id, iq, INIT_REQUEST_STATE,
4057 (int)!(qstate->query_flags&BIT_CD), 0)) {
4058 errinf(qstate, "could not generate class ANY"
4060 return error_response(qstate, id,
4073 return error_response_cache(qstate, id, LDNS_RCODE_REFUSED);
4085 * @param qstate: query state.
4092 processFinished(struct module_qstate* qstate, struct iter_qstate* iq,
4096 &qstate->qinfo);
4099 if(!qstate->no_cache_store && iq->query_for_pside_glue
4101 iter_store_parentside_neg(qstate->env, &qstate->qinfo,
4106 errinf(qstate, "(no response found at query finish)");
4107 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4123 if((qstate->env->cfg->val_log_level >= 2 ||
4124 qstate->env->cfg->log_servfail) && qstate->errinf &&
4125 !qstate->env->cfg->val_log_squelch) {
4126 char* err_str = errinf_to_str_misc(qstate);
4134 qstate->ext_state[id] = module_finished;
4141 if(!iter_prepend(iq, iq->response, qstate->region)) {
4143 return error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4146 iq->response->qinfo = qstate->qinfo;
4152 if(!qstate->no_cache_store && qstate->query_flags&BIT_RD) {
4153 iter_dns_store(qstate->env, &qstate->qinfo,
4154 iq->response->rep, 0, qstate->prefetch_leeway,
4156 qstate->region, qstate->query_flags,
4157 qstate->qstarttime);
4160 qstate->return_rcode = LDNS_RCODE_NOERROR;
4161 qstate->return_msg = iq->response;
4171 * @param qstate: query state that finished.
4173 * @param super: the qstate to inform.
4176 iter_inform_super(struct module_qstate* qstate, int id,
4179 if(!qstate->is_priming && super->qinfo.qclass == LDNS_RR_CLASS_ANY)
4180 processClassResponse(qstate, id, super);
4183 processDSNSResponse(qstate, id, super);
4184 else if(qstate->return_rcode != LDNS_RCODE_NOERROR)
4185 error_supers(qstate, id, super);
4186 else if(qstate->is_priming)
4187 prime_supers(qstate, id, super);
4188 else processTargetResponse(qstate, id, super);
4198 * @param qstate: query state.
4204 iter_handle(struct module_qstate* qstate, struct iter_qstate* iq,
4213 cont = processInitRequest(qstate, iq, ie, id);
4216 cont = processInitRequest2(qstate, iq, id);
4219 cont = processInitRequest3(qstate, iq, id);
4222 cont = processQueryTargets(qstate, iq, ie, id);
4225 cont = processQueryResponse(qstate, iq, ie, id);
4228 cont = processPrimeResponse(qstate, id);
4231 cont = processCollectClass(qstate, id);
4234 cont = processDSNSFind(qstate, iq, id);
4237 cont = processFinished(qstate, iq, id);
4251 * @param qstate: query state.
4257 process_request(struct module_qstate* qstate, struct iter_qstate* iq,
4265 iter_handle(qstate, iq, ie, id);
4270 process_response(struct module_qstate* qstate, struct iter_qstate* iq,
4283 qstate->env->cfg->use_caps_bits_for_id &&
4302 || !qstate->reply) {
4305 errinf(qstate, "module iterator received wrong internal event with a response message");
4306 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4311 fill_fail_addr(iq, &qstate->reply->remote_addr,
4312 qstate->reply->remote_addrlen);
4313 prs = (struct msg_parse*)regional_alloc(qstate->env->scratch,
4322 pkt = qstate->reply->c->buffer;
4324 if(parse_packet(pkt, prs, qstate->env->scratch) != LDNS_RCODE_NOERROR) {
4330 if(parse_extract_edns_from_response_msg(prs, &edns, qstate->env->scratch) !=
4338 qstate->edns_opts_back_in = edns_opt_copy_region(edns.opt_list_in,
4339 qstate->region);
4340 if(!qstate->edns_opts_back_in) {
4346 if(!inplace_cb_edns_back_parsed_call(qstate->env, qstate)) {
4356 qstate->env->scratch, qstate->env, qstate, ie)) {
4373 iq->response = dns_alloc_msg(pkt, prs, qstate->region);
4376 log_query_info(VERB_DETAIL, "response for", &qstate->qinfo);
4378 &qstate->reply->remote_addr, qstate->reply->remote_addrlen);
4383 if(qstate->env->cfg->aggressive_nsec) {
4387 if(qstate->env->cfg->qname_minimisation &&
4438 qstate->env->scratch)) {
4442 errinf(qstate, "0x20 failed, then got different replies in fallback");
4443 (void)error_response_cache(qstate, id,
4460 iter_handle(qstate, iq, ie, id);
4464 iter_operate(struct module_qstate* qstate, enum module_ev event, int id,
4467 struct iter_env* ie = (struct iter_env*)qstate->env->modinfo[id];
4468 struct iter_qstate* iq = (struct iter_qstate*)qstate->minfo[id];
4470 id, strextstate(qstate->ext_state[id]), strmodulevent(event));
4472 &qstate->qinfo);
4473 if(iq && qstate->qinfo.qname != iq->qchase.qname)
4480 if(!iter_new(qstate, id)) {
4481 errinf(qstate, "malloc failure, new iterator module allocation");
4482 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4485 iq = (struct iter_qstate*)qstate->minfo[id];
4486 process_request(qstate, iq, ie, id);
4490 iter_handle(qstate, iq, ie, id);
4494 process_response(qstate, iq, ie, id, outbound, event);
4499 errinf(qstate, "iterator module got the error event");
4500 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4505 errinf(qstate, "iterator module received wrong event");
4506 (void)error_response(qstate, id, LDNS_RCODE_SERVFAIL);
4510 iter_clear(struct module_qstate* qstate, int id)
4513 if(!qstate)
4515 iq = (struct iter_qstate*)qstate->minfo[id];
4525 qstate->minfo[id] = NULL;