Lines Matching +full:num +full:- +full:transfer +full:- +full:bits
2 * daemon/worker.c - worker that handles a pending list of requests.
132 front = listen_get_mem(worker->front);
133 back = outnet_get_mem(worker->back);
134 msg = slabhash_get_mem(worker->env.msg_cache);
135 rrset = slabhash_get_mem(&worker->env.rrset_cache->table);
136 infra = infra_get_mem(worker->env.infra_cache);
137 mesh = mesh_get_mem(worker->env.mesh);
138 ac = alloc_get_mem(worker->alloc);
139 superac = alloc_get_mem(&worker->daemon->superalloc);
140 anch = anchors_get_mem(worker->env.anchors);
143 for(i=0; i<worker->env.mesh->mods.num; i++) {
144 fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh->
145 mods.mod[i]->get_mem));
146 if(strcmp(worker->env.mesh->mods.mod[i]->name, "validator")==0)
147 val += (*worker->env.mesh->mods.mod[i]->get_mem)
148 (&worker->env, i);
150 else if(strcmp(worker->env.mesh->mods.mod[i]->name,
152 subnet += (*worker->env.mesh->mods.mod[i]->get_mem)
153 (&worker->env, i);
155 else iter += (*worker->env.mesh->mods.mod[i]->get_mem)
156 (&worker->env, i);
158 me = sizeof(*worker) + sizeof(*worker->base) + sizeof(*worker->comsig)
159 + comm_point_get_mem(worker->cmd_com)
160 + sizeof(worker->rndstate)
161 + regional_get_mem(worker->scratchpad)
162 + sizeof(*worker->env.scratch_buffer)
163 + sldns_buffer_capacity(worker->env.scratch_buffer);
164 if(worker->daemon->env->fwds)
165 log_info("forwards=%u", (unsigned)forwards_get_mem(worker->env.fwds));
166 if(worker->daemon->env->hints)
167 log_info("hints=%u", (unsigned)hints_get_mem(worker->env.hints));
168 if(worker->thread_num == 0)
169 me += acl_list_get_mem(worker->daemon->acl);
193 log_info("Total heap memory estimate: %u total-alloc: %u "
194 "total-free: %u", (unsigned)total,
204 for(i=0; i<worker->env.mesh->mods.num; i++) {
205 fptr_ok(fptr_whitelist_mod_get_mem(worker->env.mesh->
206 mods.mod[i]->get_mem));
207 if(strcmp(worker->env.mesh->mods.mod[i]->name, "validator")==0)
208 val += (*worker->env.mesh->mods.mod[i]->get_mem)
209 (&worker->env, i);
211 else if(strcmp(worker->env.mesh->mods.mod[i]->name,
213 subnet += (*worker->env.mesh->mods.mod[i]->get_mem)
214 (&worker->env, i);
220 (unsigned)slabhash_get_mem(worker->env.msg_cache),
221 (unsigned)slabhash_get_mem(&worker->env.rrset_cache->table),
222 (unsigned)infra_get_mem(worker->env.infra_cache),
226 (unsigned)slabhash_get_mem(worker->env.msg_cache),
227 (unsigned)slabhash_get_mem(&worker->env.rrset_cache->table),
228 (unsigned)infra_get_mem(worker->env.infra_cache),
238 if(!tube_write_msg(worker->cmd, (uint8_t*)&c, sizeof(c), 0)) {
248 struct worker* worker = e->qstate->env->worker;
249 struct serviced_query *sq = e->qsent;
251 verbose(VERB_ALGO, "worker svcd callback for qstate %p", e->qstate);
253 mesh_report_reply(worker->env.mesh, e, reply_info, error);
258 if(!LDNS_QR_WIRE(sldns_buffer_begin(c->buffer))
259 || LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) !=
261 || LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) > 1) {
265 mesh_report_reply(worker->env.mesh, e, reply_info,
270 mesh_report_reply(worker->env.mesh, e, reply_info, NETEVENT_NOERROR);
278 * @return value of err if okay, or -1 if it should be discarded instead.
283 if(worker->err_limit_time == *worker->env.now) {
285 if(worker->err_limit_count++ > ERROR_RATELIMIT)
286 return -1;
289 worker->err_limit_time = *worker->env.now;
290 worker->err_limit_count = 1;
313 if(out->checked) return;
314 out->checked = 1;
317 out->value = -1;
321 worker->daemon->cfg->harden_large_queries) {
323 out->value = -1;
328 out->value = -1;
334 out->value = worker_err_ratelimit(worker, LDNS_RCODE_FORMERR);
341 out->value = worker_err_ratelimit(worker, LDNS_RCODE_NOTIMPL);
347 out->value = worker_err_ratelimit(worker, LDNS_RCODE_FORMERR);
355 out->value = worker_err_ratelimit(worker, LDNS_RCODE_FORMERR);
361 out->value = worker_err_ratelimit(worker, LDNS_RCODE_FORMERR);
367 out->value = worker_err_ratelimit(worker, LDNS_RCODE_FORMERR);
370 out->value = 0;
383 comm_base_exit(worker->base);
395 comm_base_exit(worker->base);
423 size_t num = rep->an_numrrsets + rep->ns_numrrsets;
425 for(i=0; i<num; i++) {
426 s = ((struct packed_rrset_data*)rep->rrsets[i]->entry.data)
427 ->security;
432 for(i=num; i<rep->rrset_count; i++) {
433 s = ((struct packed_rrset_data*)rep->rrsets[i]->entry.data)
434 ->security;
449 for(i = rep->an_numrrsets+rep->ns_numrrsets; i<rep->rrset_count; i++) {
450 s = ((struct packed_rrset_data*)rep->rrsets[i]->entry.data)
451 ->security;
453 memmove(rep->rrsets+i, rep->rrsets+i+1,
455 (rep->rrset_count - i - 1));
456 rep->ar_numrrsets--;
457 rep->rrset_count--;
458 i--;
478 uint16_t udpsize = edns->udp_size;
480 time_t timenow = *worker->env.now;
482 int must_validate = (!has_cd_bit || worker->env.cfg->ignore_cd)
483 && worker->env.need_to_validate;
487 dp = dns_cache_find_delegation(&worker->env, qinfo->qname,
488 qinfo->qname_len, qinfo->qtype, qinfo->qclass,
489 worker->scratchpad, &msg, timenow, 0, NULL, 0);
496 msg->qinfo.local_alias = qinfo->local_alias;
498 switch(check_delegation_secure(msg->rep)) {
506 edns->edns_version = EDNS_ADVERTISED_VERSION;
507 edns->udp_size = EDNS_ADVERTISED_SIZE;
508 edns->ext_rcode = 0;
509 edns->bits &= EDNS_DO;
510 if(!inplace_cb_reply_servfail_call(&worker->env, qinfo, NULL,
511 msg->rep, LDNS_RCODE_SERVFAIL, edns, repinfo, worker->scratchpad,
512 worker->env.now_tv))
515 if(worker->env.cfg->ede &&
516 msg->rep->reason_bogus != LDNS_EDE_NONE) {
517 edns_opt_list_append_ede(&edns->opt_list_out,
518 worker->scratchpad, msg->rep->reason_bogus,
519 msg->rep->reason_bogus_str);
521 error_encode(repinfo->c->buffer, LDNS_RCODE_SERVFAIL,
522 &msg->qinfo, id, flags, edns);
523 if(worker->stats.extended) {
524 worker->stats.ans_bogus++;
525 worker->stats.ans_rcode[LDNS_RCODE_SERVFAIL]++;
530 /* remove non-secure rrsets from the add. section*/
531 if(worker->env.cfg->val_clean_additional)
532 deleg_remove_nonsecure_additional(msg->rep);
544 edns->edns_version = EDNS_ADVERTISED_VERSION;
545 edns->udp_size = EDNS_ADVERTISED_SIZE;
546 edns->ext_rcode = 0;
547 edns->bits &= EDNS_DO;
548 if(worker->env.cfg->disable_edns_do && (edns->bits & EDNS_DO))
549 edns->edns_present = 0;
550 if(!inplace_cb_reply_cache_call(&worker->env, qinfo, NULL, msg->rep,
551 (int)(flags&LDNS_RCODE_MASK), edns, repinfo, worker->scratchpad,
552 worker->env.now_tv))
554 msg->rep->flags |= BIT_QR|BIT_RA;
557 if(worker->env.cfg->ede && has_cd_bit &&
558 (check_delegation_secure(msg->rep) == sec_status_bogus ||
559 check_delegation_secure(msg->rep) == sec_status_secure_sentinel_fail) &&
560 msg->rep->reason_bogus != LDNS_EDE_NONE) {
561 edns_opt_list_append_ede(&edns->opt_list_out,
562 worker->scratchpad, msg->rep->reason_bogus,
563 msg->rep->reason_bogus_str);
565 if(!reply_info_answer_encode(&msg->qinfo, msg->rep, id, flags,
566 repinfo->c->buffer, 0, 1, worker->scratchpad,
567 udpsize, edns, (int)(edns->bits & EDNS_DO), secure)) {
568 if(!inplace_cb_reply_servfail_call(&worker->env, qinfo, NULL, NULL,
569 LDNS_RCODE_SERVFAIL, edns, repinfo, worker->scratchpad,
570 worker->env.now_tv))
571 edns->opt_list_inplace_cb_out = NULL;
572 error_encode(repinfo->c->buffer, LDNS_RCODE_SERVFAIL,
573 &msg->qinfo, id, flags, edns);
575 if(worker->stats.extended) {
576 if(secure) worker->stats.ans_secure++;
577 server_stats_insrcode(&worker->stats, repinfo->c->buffer);
597 if(qinfo->qtype != LDNS_RR_TYPE_A &&
598 qinfo->qtype != LDNS_RR_TYPE_AAAA &&
599 qinfo->qtype != LDNS_RR_TYPE_ANY)
603 alias_rrset, 0, worker->scratchpad, az, NULL))
607 * was redirected to response-ip data. */
617 respip_inform_print(&actinfo, qinfo->qname,
618 qinfo->qtype, qinfo->qclass, qinfo->local_alias,
621 if(worker->stats.extended && actinfo.rpz_used) {
623 worker->stats.rpz_action[RPZ_DISABLED_ACTION]++;
625 worker->stats.rpz_action[RPZ_CNAME_OVERRIDE_ACTION]++;
627 worker->stats.rpz_action[
636 * Normally, the answer message will be built in repinfo->c->buffer; if the
651 time_t timenow = *worker->env.now;
652 uint16_t udpsize = edns->udp_size;
656 int must_validate = (!has_cd_bit || worker->env.cfg->ignore_cd)
657 && worker->env.need_to_validate;
661 if(rep->ttl < timenow) {
663 if(worker->env.cfg->serve_expired &&
664 /* if serve-expired-client-timeout is set, serve
668 (!worker->env.cfg->serve_expired_client_timeout ||
669 timenow < rep->serve_expired_norec_ttl)
671 && !(worker->env.cachedb_enabled &&
672 worker->env.cfg->cachedb_check_when_serve_expired)
677 if(!rrset_array_lock(rep->ref, rep->rrset_count, 0))
688 if(!rrset_array_lock(rep->ref, rep->rrset_count, timenow))
694 if(rep->an_numrrsets > 0 && (rep->rrsets[0]->rk.type ==
695 htons(LDNS_RR_TYPE_CNAME) || rep->rrsets[0]->rk.type ==
704 if(must_validate && (rep->security == sec_status_bogus ||
705 rep->security == sec_status_secure_sentinel_fail)) {
707 edns->edns_version = EDNS_ADVERTISED_VERSION;
708 edns->udp_size = EDNS_ADVERTISED_SIZE;
709 edns->ext_rcode = 0;
710 edns->bits &= EDNS_DO;
711 if(worker->env.cfg->disable_edns_do && (edns->bits & EDNS_DO))
712 edns->edns_present = 0;
713 if(!inplace_cb_reply_servfail_call(&worker->env, qinfo, NULL, rep,
714 LDNS_RCODE_SERVFAIL, edns, repinfo, worker->scratchpad,
715 worker->env.now_tv))
718 if(worker->env.cfg->ede && rep->reason_bogus != LDNS_EDE_NONE) {
719 edns_opt_list_append_ede(&edns->opt_list_out,
720 worker->scratchpad, rep->reason_bogus,
721 rep->reason_bogus_str);
723 error_encode(repinfo->c->buffer, LDNS_RCODE_SERVFAIL,
725 rrset_array_unlock_touch(worker->env.rrset_cache,
726 worker->scratchpad, rep->ref, rep->rrset_count);
727 if(worker->stats.extended) {
728 worker->stats.ans_bogus ++;
729 worker->stats.ans_rcode[LDNS_RCODE_SERVFAIL] ++;
732 } else if(rep->security == sec_status_unchecked && must_validate) {
736 } else if(rep->security == sec_status_secure) {
743 goto bail_out; /* rrset changed, re-verify */
749 edns->edns_version = EDNS_ADVERTISED_VERSION;
750 edns->udp_size = EDNS_ADVERTISED_SIZE;
751 edns->ext_rcode = 0;
752 edns->bits &= EDNS_DO;
753 if(worker->env.cfg->disable_edns_do && (edns->bits & EDNS_DO))
754 edns->edns_present = 0;
755 *alias_rrset = NULL; /* avoid confusion if caller set it to non-NULL */
756 if((worker->daemon->use_response_ip || worker->daemon->use_rpz) &&
758 &repinfo->client_addr, repinfo->client_addrlen, alias_rrset,
759 &encode_rep, worker->env.auth_zones)) {
763 must_validate, &encode_rep, worker->scratchpad,
764 worker->env.auth_zones)) {
779 worker->scratchpad);
785 worker->env.cfg->ede_serve_expired && worker->env.cfg->ede) {
786 EDNS_OPT_LIST_APPEND_EDE(&edns->opt_list_out,
787 worker->scratchpad, LDNS_EDE_STALE_ANSWER, "");
792 worker->env.cfg->ede && has_cd_bit &&
793 encode_rep->reason_bogus != LDNS_EDE_NONE) {
794 edns_opt_list_append_ede(&edns->opt_list_out,
795 worker->scratchpad, encode_rep->reason_bogus,
796 encode_rep->reason_bogus_str);
798 if(!inplace_cb_reply_cache_call(&worker->env, qinfo, NULL, encode_rep,
799 (int)(flags&LDNS_RCODE_MASK), edns, repinfo, worker->scratchpad,
800 worker->env.now_tv))
803 repinfo->c->buffer, timenow, 1, worker->scratchpad,
804 udpsize, edns, (int)(edns->bits & EDNS_DO),
806 if(!inplace_cb_reply_servfail_call(&worker->env, qinfo,
808 worker->scratchpad, worker->env.now_tv))
809 edns->opt_list_inplace_cb_out = NULL;
810 error_encode(repinfo->c->buffer, LDNS_RCODE_SERVFAIL,
816 rrset_array_unlock_touch(worker->env.rrset_cache, worker->scratchpad,
817 rep->ref, rep->rrset_count);
822 rrset_array_unlock_touch(worker->env.rrset_cache,
823 worker->scratchpad, rep->ref, rep->rrset_count);
837 if(repinfo->c->tcp_req_info) {
839 repinfo->c->tcp_req_info->spool_buffer,
840 repinfo->c->buffer);
844 server_stats_prefetch(&worker->stats, worker);
849 if(modstack_find(&worker->env.mesh->mods, "subnetcache") != -1
850 && worker->env.unique_mesh) {
851 mesh_new_prefetch(worker->env.mesh, qinfo, flags, leeway +
853 &repinfo->client_addr, opt_list);
861 mesh_new_prefetch(worker->env.mesh, qinfo, flags, leeway +
870 * @param num: number of strings in array.
876 chaos_replystr(sldns_buffer* pkt, char** str, int num, struct edns_data* edns,
882 size_t udpsize = edns->udp_size;
883 edns->edns_version = EDNS_ADVERTISED_VERSION;
884 edns->udp_size = EDNS_ADVERTISED_SIZE;
885 edns->bits &= EDNS_DO;
886 if(!inplace_cb_reply_local_call(&worker->env, NULL, NULL, NULL,
887 LDNS_RCODE_NOERROR, edns, repinfo, worker->scratchpad,
888 worker->env.now_tv))
889 edns->opt_list_inplace_cb_out = NULL;
896 sldns_buffer_write_u16(pkt, (uint16_t)num); /* ancount */
902 for(i=0; i<num; i++) {
948 int num = 0;
951 if(!w->env.need_to_validate) {
958 lock_basic_lock(&w->env.anchors->lock);
959 RBTREE_FOR(ta, struct trust_anchor*, w->env.anchors->tree) {
962 if(num == TA_RESPONSE_MAX_TXT) continue;
963 str = (char*)regional_alloc(w->scratchpad, str_len);
965 lock_basic_lock(&ta->lock);
969 lock_basic_unlock(&ta->lock);
972 str_array[num] = str;
973 num++;
976 (void)sldns_wire2str_dname_buf(ta->name, ta->namelen, str, str_len);
977 str_len -= strlen(str); str += strlen(str);
981 str_len -= strlen(str); str += strlen(str);
983 lock_basic_unlock(&ta->lock);
985 lock_basic_unlock(&w->env.anchors->lock);
987 chaos_replystr(pkt, str_array, num, edns, w, repinfo);
988 regional_free_all(w->scratchpad);
1004 struct config_file* cfg = w->env.cfg;
1005 if(qinfo->qtype != LDNS_RR_TYPE_ANY && qinfo->qtype != LDNS_RR_TYPE_TXT)
1007 if(query_dname_compare(qinfo->qname,
1009 query_dname_compare(qinfo->qname,
1012 if(cfg->hide_identity)
1014 if(cfg->identity==NULL || cfg->identity[0]==0) {
1024 else chaos_replyonestr(pkt, cfg->identity, edns, w, repinfo);
1027 if(query_dname_compare(qinfo->qname,
1029 query_dname_compare(qinfo->qname,
1032 if(cfg->hide_version)
1034 if(cfg->version==NULL || cfg->version[0]==0)
1036 else chaos_replyonestr(pkt, cfg->version, edns, w, repinfo);
1039 if(query_dname_compare(qinfo->qname,
1042 if(cfg->hide_trustanchor)
1071 if(!w->env.auth_zones) return;
1073 if(auth_zones_notify(w->env.auth_zones, &w->env, qinfo->qname,
1074 qinfo->qname_len, qinfo->qclass, addr,
1087 dname_str(qinfo->qname, zname);
1102 edns->edns_version = EDNS_ADVERTISED_VERSION;
1103 edns->udp_size = EDNS_ADVERTISED_SIZE;
1104 edns->ext_rcode = 0;
1105 edns->bits &= EDNS_DO;
1121 log_acl_action("dropped", &repinfo->client_addr,
1122 repinfo->client_addrlen, acl, acladdr);
1123 log_buf(VERB_ALGO, "dropped", c->buffer);
1126 if(worker->stats.extended)
1127 worker->stats.unwanted_queries++;
1133 log_acl_action("refused", &repinfo->client_addr,
1134 repinfo->client_addrlen, acl, acladdr);
1135 log_buf(VERB_ALGO, "refuse", c->buffer);
1138 if(worker->stats.extended)
1139 worker->stats.unwanted_queries++;
1140 worker_check_request(c->buffer, worker, check_result);
1141 if(check_result->value != 0) {
1142 if(check_result->value != -1) {
1143 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1144 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1145 check_result->value);
1154 log_assert(sldns_buffer_limit(c->buffer) >= LDNS_HEADER_SIZE
1155 && LDNS_QDCOUNT(sldns_buffer_begin(c->buffer)) == 1);
1157 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE); /* skip header */
1160 if(LDNS_ARCOUNT(sldns_buffer_begin(c->buffer)) != 1
1162 LDNS_QDCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1163 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1164 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1165 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1166 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1167 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1169 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
1170 sldns_buffer_flip(c->buffer);
1174 if (!query_dname_len(c->buffer)) {
1175 LDNS_QDCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1176 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1177 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1178 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1179 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1180 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1182 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
1183 sldns_buffer_flip(c->buffer);
1187 if (sldns_buffer_remaining(c->buffer) < 2 * sizeof(uint16_t)) {
1188 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1189 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1191 LDNS_QDCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1192 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1193 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1194 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1195 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
1196 sldns_buffer_flip(c->buffer);
1199 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1200 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1203 sldns_buffer_skip(c->buffer, (ssize_t)sizeof(uint16_t)); /* skip qtype */
1205 sldns_buffer_skip(c->buffer, (ssize_t)sizeof(uint16_t)); /* skip qclass */
1210 opt_rr_mark = sldns_buffer_position(c->buffer);
1213 if(LDNS_ANCOUNT(sldns_buffer_begin(c->buffer)) != 0 ||
1214 LDNS_NSCOUNT(sldns_buffer_begin(c->buffer)) != 0) {
1215 if(!skip_pkt_rrs(c->buffer,
1216 ((int)LDNS_ANCOUNT(sldns_buffer_begin(c->buffer)))+
1217 ((int)LDNS_NSCOUNT(sldns_buffer_begin(c->buffer))))) {
1218 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1220 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1221 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1222 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1223 sldns_buffer_set_position(c->buffer, opt_rr_mark);
1224 sldns_buffer_flip(c->buffer);
1230 if(sldns_buffer_remaining(c->buffer) < 1 || *sldns_buffer_current(c->buffer) != 0) {
1231 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1232 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1233 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1234 sldns_buffer_set_position(c->buffer, opt_rr_mark);
1235 sldns_buffer_flip(c->buffer);
1238 sldns_buffer_skip(c->buffer, 1); /* skip root label */
1240 if(sldns_buffer_remaining(c->buffer) < 2 ||
1241 sldns_buffer_read_u16(c->buffer) != LDNS_RR_TYPE_OPT) {
1242 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1243 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1244 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1245 sldns_buffer_set_position(c->buffer, opt_rr_mark);
1246 sldns_buffer_flip(c->buffer);
1252 LDNS_ANCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1253 LDNS_NSCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1254 sldns_buffer_clear(c->buffer); /* reset write limit */
1255 sldns_buffer_set_position(c->buffer, opt_rr_mark);
1260 * + EDE Option length (2) + EDE info-code (2)
1262 if (sldns_buffer_available(c->buffer, 17) == 0) {
1263 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 0);
1264 sldns_buffer_flip(c->buffer);
1268 LDNS_ARCOUNT_SET(sldns_buffer_begin(c->buffer), 1);
1271 sldns_buffer_write_u8(c->buffer, 0);
1272 sldns_buffer_write_u16(c->buffer, LDNS_RR_TYPE_OPT);
1273 sldns_buffer_write_u16(c->buffer, EDNS_ADVERTISED_SIZE);
1276 sldns_buffer_write_u32(c->buffer, 0);
1278 /* write rdata len: EDE option + length + info-code */
1279 sldns_buffer_write_u16(c->buffer, 6);
1282 sldns_buffer_write_u16(c->buffer, LDNS_EDNS_EDE);
1284 /* write single EDE option length (for just 1 info-code) */
1285 sldns_buffer_write_u16(c->buffer, 2);
1287 /* write single EDE info-code */
1288 sldns_buffer_write_u16(c->buffer, LDNS_EDE_PROHIBITED);
1290 sldns_buffer_flip(c->buffer);
1298 return -1;
1308 *acladdr = acl_addr_lookup(worker->daemon->acl,
1309 &repinfo->remote_addr, repinfo->remote_addrlen);
1311 *acladdr = acl_addr_lookup(worker->daemon->acl,
1312 &repinfo->client_addr, repinfo->client_addrlen);
1315 if(!(*acladdr) && c->socket) {
1316 *acladdr = c->socket->acl;
1339 if(!infra_ip_ratelimit_inc(worker->env.infra_cache, addr, addrlen,
1340 *worker->env.now, has_cookie,
1341 worker->env.cfg->ip_ratelimit_backoff, pkt)) {
1343 if(!has_cookie && worker->env.cfg->ip_ratelimit_factor != 0 &&
1344 ub_random_max(worker->env.rnd,
1345 worker->env.cfg->ip_ratelimit_factor) == 0) {
1396 if (worker->env.cfg->sock_queue_timeout && timeval_isset(&c->recv_tv)) {
1397 timeval_subtract(&wait_time, worker->env.now_tv, &c->recv_tv);
1399 if (worker->stats.max_query_time_us < wait_queue_time)
1400 worker->stats.max_query_time_us = wait_queue_time;
1402 (long long)(worker->env.cfg->sock_queue_timeout * 1000000)) {
1404 worker->stats.num_queries_timed_out++;
1410 repinfo->max_udp_size = worker->daemon->cfg->max_udp_size;
1411 if(!dnsc_handle_curved_request(worker->daemon->dnscenv, repinfo)) {
1412 worker->stats.num_query_dnscrypt_crypted_malformed++;
1415 if(c->dnscrypt && !repinfo->is_dnscrypted) {
1418 worker_check_request(c->buffer, worker, &check_result);
1422 log_addr(VERB_CLIENT,"from",&repinfo->client_addr,
1423 repinfo->client_addrlen);
1427 if(!query_info_parse(&qinfo, c->buffer)) {
1430 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1431 repinfo->client_addrlen);
1438 worker->daemon->dnscenv->provider_name) == 0)) {
1441 worker->daemon->dnscenv->provider_name,
1442 sldns_rr_descript(qinfo.qtype)->_name,
1445 worker->stats.num_query_dnscrypt_cleartext++;
1448 worker->stats.num_query_dnscrypt_cert++;
1449 sldns_buffer_rewind(c->buffer);
1450 } else if(c->dnscrypt && repinfo->is_dnscrypted) {
1451 worker->stats.num_query_dnscrypt_crypted++;
1458 if(worker->dtenv.log_client_query_messages) {
1459 log_addr(VERB_ALGO, "request from client", &repinfo->client_addr, repinfo->client_addrlen);
1460 log_addr(VERB_ALGO, "to local addr", (void*)repinfo->c->socket->addr, repinfo->c->socket->addrlen);
1461 dt_msg_send_client_query(&worker->dtenv, &repinfo->client_addr, (void*)repinfo->c->socket->addr, c->type, c->ssl, c->buffer,
1462 ((worker->env.cfg->sock_queue_timeout && timeval_isset(&c->recv_tv))?&c->recv_tv:NULL));
1466 if(repinfo->is_proxied) {
1468 worker->env.cfg->ede, 1, &check_result)) != -1) {
1475 worker->env.cfg->ede, 0, &check_result)) != -1) {
1481 worker_check_request(c->buffer, worker, &check_result);
1484 log_addr(VERB_CLIENT,"from",&repinfo->client_addr, repinfo->client_addrlen);
1485 if(check_result.value != -1) {
1486 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1487 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1495 worker->stats.num_queries++;
1496 pre_edns_ip_ratelimit = !worker->env.cfg->do_answer_cookie
1497 || sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE
1498 || LDNS_ARCOUNT(sldns_buffer_begin(c->buffer)) == 0;
1503 /* NOTE: we always check the repinfo->client_address.
1505 if(!check_ip_ratelimit(worker, &repinfo->client_addr,
1506 repinfo->client_addrlen, 0, c->buffer)) {
1507 worker->stats.num_queries_ip_ratelimited++;
1513 if(!query_info_parse(&qinfo, c->buffer)) {
1515 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1516 repinfo->client_addrlen);
1518 if(worker_err_ratelimit(worker, LDNS_RCODE_FORMERR) == -1) {
1522 sldns_buffer_rewind(c->buffer);
1523 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1524 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1528 if(worker->env.cfg->log_queries) {
1530 addr_to_str(&repinfo->client_addr, repinfo->client_addrlen, ip, sizeof(ip));
1535 verbose(VERB_ALGO, "worker request: refused zone transfer.");
1536 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1537 repinfo->client_addrlen);
1538 sldns_buffer_rewind(c->buffer);
1539 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1540 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1542 if(worker->stats.extended) {
1543 worker->stats.qtype[qinfo.qtype]++;
1553 verbose(VERB_ALGO, "worker request: formerror for meta-type.");
1554 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1555 repinfo->client_addrlen);
1556 if(worker_err_ratelimit(worker, LDNS_RCODE_FORMERR) == -1) {
1560 sldns_buffer_rewind(c->buffer);
1561 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1562 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1564 if(worker->stats.extended) {
1565 worker->stats.qtype[qinfo.qtype]++;
1570 c->buffer, &edns, worker->env.cfg, c, repinfo,
1571 (worker->env.now ? *worker->env.now : time(NULL)),
1572 worker->scratchpad,
1573 worker->daemon->cookie_secrets)) != 0) {
1576 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1577 repinfo->client_addrlen);
1580 error_encode(c->buffer, ret, &qinfo,
1581 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1582 sldns_buffer_read_u16_at(c->buffer, 2), &reply_edns);
1583 regional_free_all(worker->scratchpad);
1592 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1593 repinfo->client_addrlen);
1594 extended_error_encode(c->buffer, EDNS_RCODE_BADVERS, &qinfo,
1595 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1596 sldns_buffer_read_u16_at(c->buffer, 2), 0, &edns);
1597 regional_free_all(worker->scratchpad);
1601 worker->daemon->cfg->harden_short_bufsize) {
1604 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1605 repinfo->client_addrlen);
1611 server_stats_downstream_cookie(&worker->stats, &edns);
1615 /* NOTE: we always check the repinfo->client_address.
1617 if(!check_ip_ratelimit(worker, &repinfo->client_addr,
1618 repinfo->client_addrlen, edns.cookie_valid,
1619 c->buffer)) {
1620 worker->stats.num_queries_ip_ratelimited++;
1633 else if(c->type != comm_udp)
1638 extended_error_encode(c->buffer,
1641 sldns_buffer_begin(c->buffer),
1642 sldns_buffer_read_u16_at(c->buffer, 2),
1644 regional_free_all(worker->scratchpad);
1650 log_addr(VERB_ALGO, "from",&repinfo->remote_addr
1651 , repinfo->remote_addrlen);
1653 worker->scratchpad, LDNS_EDE_OTHER,
1655 error_encode(c->buffer,
1658 sldns_buffer_begin(c->buffer),
1659 sldns_buffer_read_u16_at(c->buffer, 2),
1661 regional_free_all(worker->scratchpad);
1665 if(edns.udp_size > worker->daemon->cfg->max_udp_size &&
1666 c->type == comm_udp) {
1669 " (%d to max-udp-size)", (int)edns.udp_size);
1670 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1671 repinfo->client_addrlen);
1672 edns.udp_size = worker->daemon->cfg->max_udp_size;
1676 log_addr(VERB_CLIENT, "from", &repinfo->client_addr,
1677 repinfo->client_addrlen);
1678 LDNS_QR_SET(sldns_buffer_begin(c->buffer));
1679 LDNS_TC_SET(sldns_buffer_begin(c->buffer));
1680 LDNS_RCODE_SET(sldns_buffer_begin(c->buffer),
1682 sldns_buffer_set_position(c->buffer, LDNS_HEADER_SIZE);
1683 sldns_buffer_write_at(c->buffer, 4,
1685 sldns_buffer_flip(c->buffer);
1686 regional_free_all(worker->scratchpad);
1689 if(worker->stats.extended)
1690 server_stats_insquery(&worker->stats, c, qinfo.qtype,
1692 if(c->type != comm_udp)
1695 &edns, repinfo, c->buffer)) {
1696 regional_free_all(worker->scratchpad);
1699 if(LDNS_OPCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
1701 answer_notify(worker, &qinfo, &edns, c->buffer,
1702 &repinfo->client_addr, repinfo->client_addrlen);
1703 regional_free_all(worker->scratchpad);
1706 if(local_zones_answer(worker->daemon->local_zones, &worker->env, &qinfo,
1707 &edns, c->buffer, worker->scratchpad, repinfo, acladdr->taglist,
1708 acladdr->taglen, acladdr->tag_actions,
1709 acladdr->tag_actions_size, acladdr->tag_datas,
1710 acladdr->tag_datas_size, worker->daemon->cfg->tagname,
1711 worker->daemon->cfg->num_tags, acladdr->view)) {
1712 regional_free_all(worker->scratchpad);
1713 if(sldns_buffer_limit(c->buffer) == 0) {
1719 if(worker->env.auth_zones &&
1720 rpz_callback_from_worker_request(worker->env.auth_zones,
1721 &worker->env, &qinfo, &edns, c->buffer, worker->scratchpad,
1722 repinfo, acladdr->taglist, acladdr->taglen, &worker->stats,
1724 regional_free_all(worker->scratchpad);
1725 if(sldns_buffer_limit(c->buffer) == 0) {
1731 if(worker->env.auth_zones &&
1732 auth_zones_answer(worker->env.auth_zones, &worker->env,
1733 &qinfo, &edns, repinfo, c->buffer, worker->scratchpad)) {
1734 regional_free_all(worker->scratchpad);
1735 if(sldns_buffer_limit(c->buffer) == 0) {
1741 if(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer)) &&
1743 LDNS_RA_SET(sldns_buffer_begin(c->buffer));
1750 worker->env.cfg->ede, &check_result)) != -1)
1752 regional_free_all(worker->scratchpad);
1760 if(!(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) &&
1762 LDNS_RD_SET(sldns_buffer_begin(c->buffer));
1767 if(!(LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) &&
1769 if(worker->env.cfg->ede) {
1771 worker->scratchpad, LDNS_EDE_NOT_AUTHORITATIVE, "");
1773 error_encode(c->buffer, LDNS_RCODE_REFUSED, &qinfo,
1774 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1775 sldns_buffer_read_u16_at(c->buffer, 2), &edns);
1776 regional_free_all(worker->scratchpad);
1778 &repinfo->client_addr, repinfo->client_addrlen);
1786 struct ub_packed_rrset_key* rrset = qinfo.local_alias->rrset;
1787 struct packed_rrset_data* d = rrset->entry.data;
1791 if(qinfo.local_alias->next ||
1792 rrset->rk.type != htons(LDNS_RR_TYPE_CNAME) ||
1793 d->count != 1) {
1795 regional_free_all(worker->scratchpad);
1798 qinfo.qname = d->rr_data[0] + 2;
1799 qinfo.qname_len = d->rr_len[0] - 2;
1802 /* If we may apply IP-based actions to the answer, build the client
1805 if((worker->daemon->use_response_ip || worker->daemon->use_rpz) &&
1809 cinfo_tmp.taglist = acladdr->taglist;
1810 cinfo_tmp.taglen = acladdr->taglen;
1811 cinfo_tmp.tag_actions = acladdr->tag_actions;
1812 cinfo_tmp.tag_actions_size = acladdr->tag_actions_size;
1813 cinfo_tmp.tag_datas = acladdr->tag_datas;
1814 cinfo_tmp.tag_datas_size = acladdr->tag_datas_size;
1815 cinfo_tmp.view = acladdr->view;
1816 cinfo_tmp.respip_set = worker->daemon->respip_set;
1827 * this is a two-pass operation, and lookup_qinfo is different for
1830 if(!edns_bypass_cache_stage(edns.opt_list_in, &worker->env)) {
1833 h = query_info_hash(lookup_qinfo, sldns_buffer_read_u16_at(c->buffer, 2));
1834 if((e=slabhash_lookup(worker->env.msg_cache, h, lookup_qinfo, 0))) {
1835 struct reply_info* rep = (struct reply_info*)e->data;
1836 /* answer from cache - we have acquired a readlock on it */
1840 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1841 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
1847 if((worker->env.cfg->prefetch &&
1848 *worker->env.now >= rep->prefetch_ttl) ||
1849 (worker->env.cfg->serve_expired &&
1850 *worker->env.now > rep->ttl)) {
1852 time_t leeway = rep->ttl - *worker->env.now;
1853 if(rep->ttl < *worker->env.now)
1855 lock_rw_unlock(&e->lock);
1858 sldns_buffer_read_u16_at(c->buffer, 2),
1865 regional_free_all(worker->scratchpad);
1869 lock_rw_unlock(&e->lock);
1870 regional_free_all(worker->scratchpad);
1875 lock_rw_unlock(&e->lock);
1888 regional_free_all(worker->scratchpad);
1897 lock_rw_unlock(&e->lock);
1900 if(!LDNS_RD_WIRE(sldns_buffer_begin(c->buffer))) {
1902 *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1903 sldns_buffer_read_u16_at(c->buffer, 2), repinfo,
1905 regional_free_all(worker->scratchpad);
1908 verbose(VERB_ALGO, "answer norec from cache -- "
1912 sldns_buffer_rewind(c->buffer);
1913 server_stats_querymiss(&worker->stats, worker);
1916 if(c->type == comm_udp)
1918 &repinfo->client_addr, repinfo->client_addrlen);
1920 &repinfo->client_addr, repinfo->client_addrlen);
1924 mesh_new_client(worker->env.mesh, &qinfo, cinfo,
1925 sldns_buffer_read_u16_at(c->buffer, 2),
1926 &edns, repinfo, *(uint16_t*)(void *)sldns_buffer_begin(c->buffer),
1928 regional_free_all(worker->scratchpad);
1940 worker->stats.ans_expired++;
1942 server_stats_insrcode(&worker->stats, c->buffer);
1943 if(worker->stats.extended) {
1944 if(is_secure_answer) worker->stats.ans_secure++;
1950 if(worker->dtenv.log_client_response_messages && rc !=0) {
1951 log_addr(VERB_ALGO, "from local addr", (void*)repinfo->c->socket->addr, repinfo->c->socket->addrlen);
1952 log_addr(VERB_ALGO, "response to client", &repinfo->client_addr, repinfo->client_addrlen);
1953 dt_msg_send_client_response(&worker->dtenv, &repinfo->client_addr, (void*)repinfo->c->socket->addr, c->type, c->ssl, c->buffer);
1956 if(worker->env.cfg->log_replies)
1960 if(qinfo.local_alias && qinfo.local_alias->rrset &&
1961 qinfo.local_alias->rrset->rk.dname) {
1964 qinfo.qname = qinfo.local_alias->rrset->rk.dname;
1966 &repinfo->client_addr, repinfo->client_addrlen,
1967 tv, 1, c->buffer,
1968 (worker->env.cfg->log_destaddr?(void*)repinfo->c->socket->addr:NULL),
1969 c->type);
1972 &repinfo->client_addr, repinfo->client_addrlen,
1973 tv, 1, c->buffer,
1974 (worker->env.cfg->log_destaddr?(void*)repinfo->c->socket->addr:NULL),
1975 c->type);
1990 * And cause hangups if the log-lock is held by the application. */
1995 comm_base_exit(worker->base);
2002 worker->need_to_exit = 1;
2003 comm_base_exit(worker->base);
2007 worker->need_to_exit = 1;
2008 comm_base_exit(worker->base);
2012 worker->need_to_exit = 1;
2013 comm_base_exit(worker->base);
2025 if(worker->env.cfg->stat_interval > 0) {
2028 tv.tv_sec = worker->env.cfg->stat_interval;
2031 comm_timer_set(worker->stat_timer, &tv);
2038 server_stats_log(&worker->stats, worker, worker->thread_num);
2039 mesh_stats(worker->env.mesh, "mesh has");
2042 if (worker->daemon->cfg->shm_enable) {
2045 if(!worker->daemon->cfg->stat_cumulative) {
2057 tv.tv_sec = (time_t)autr_probe_timer(&worker->env);
2061 comm_timer_set(worker->env.probe_timer, &tv);
2072 worker->numports = n;
2073 worker->ports = (int*)memdup(ports, sizeof(int)*n);
2074 if(!worker->ports) {
2078 worker->daemon = daemon;
2079 worker->thread_num = id;
2080 if(!(worker->cmd = tube_create())) {
2081 free(worker->ports);
2086 if(!(worker->rndstate = ub_initstate(daemon->rand))) {
2088 tube_delete(worker->cmd);
2089 free(worker->ports);
2102 struct dt_env* dtenv = &worker->dtenv;
2107 worker->thread_tid = gettid();
2109 worker->need_to_exit = 0;
2110 worker->base = comm_base_create(do_sigs);
2111 if(!worker->base) {
2116 comm_base_set_slow_accept_handlers(worker->base, &worker_stop_accept,
2131 worker->comsig = comm_signal_create(worker->base,
2133 if(!worker->comsig
2135 || !comm_signal_bind(worker->comsig, SIGHUP)
2138 || !comm_signal_bind(worker->comsig, SIGQUIT)
2140 || !comm_signal_bind(worker->comsig, SIGTERM)
2142 || !comm_signal_bind(worker->comsig, SIGBREAK)
2144 || !comm_signal_bind(worker->comsig, SIGINT)) {
2150 if(!daemon_remote_open_accept(worker->daemon->rc,
2151 worker->daemon->rc_ports, worker)) {
2159 worker->comsig = NULL;
2162 if(cfg->dnstap) {
2163 log_assert(worker->daemon->dtenv != NULL);
2164 memcpy(&worker->dtenv, worker->daemon->dtenv, sizeof(struct dt_env));
2165 if(!dt_init(&worker->dtenv, worker->base))
2169 worker->front = listen_create(worker->base, ports,
2170 cfg->msg_buffer_size, (int)cfg->incoming_num_tcp,
2171 cfg->do_tcp_keepalive
2172 ? cfg->tcp_keepalive_timeout
2173 : cfg->tcp_idle_timeout,
2174 cfg->harden_large_queries, cfg->http_max_streams,
2175 cfg->http_endpoint, cfg->http_notls_downstream,
2176 worker->daemon->tcl, worker->daemon->listen_sslctx,
2177 dtenv, worker->daemon->doq_table, worker->env.rnd,
2178 cfg->ssl_service_key, cfg->ssl_service_pem, cfg,
2180 if(!worker->front) {
2185 worker->back = outside_network_create(worker->base,
2186 cfg->msg_buffer_size, (size_t)cfg->outgoing_num_ports,
2187 cfg->out_ifs, cfg->num_out_ifs, cfg->do_ip4, cfg->do_ip6,
2188 cfg->do_tcp?cfg->outgoing_num_tcp:0, cfg->ip_dscp,
2189 worker->daemon->env->infra_cache, worker->rndstate,
2190 cfg->use_caps_bits_for_id, worker->ports, worker->numports,
2191 cfg->unwanted_threshold, cfg->outgoing_tcp_mss,
2193 cfg->do_udp || cfg->udp_upstream_without_downstream,
2194 worker->daemon->connect_sslctx, cfg->delay_close,
2195 cfg->tls_use_sni, dtenv, cfg->udp_connect,
2196 cfg->max_reuse_tcp_queries, cfg->tcp_reuse_timeout,
2197 cfg->tcp_auth_query_timeout);
2198 if(!worker->back) {
2203 iterator_set_ip46_support(&worker->daemon->mods, worker->daemon->env,
2204 worker->back);
2206 if(!tube_setup_bg_listen(worker->cmd, worker->base,
2212 worker->stat_timer = comm_timer_create(worker->base,
2214 if(!worker->stat_timer) {
2220 worker->scratchpad = regional_create_custom(cfg->msg_buffer_size);
2221 if(!worker->scratchpad) {
2227 server_stats_init(&worker->stats, cfg);
2228 worker->alloc = worker->daemon->worker_allocs[worker->thread_num];
2229 alloc_set_id_cleanup(worker->alloc, &worker_alloc_cleanup, worker);
2230 worker->env = *worker->daemon->env;
2231 comm_base_timept(worker->base, &worker->env.now, &worker->env.now_tv);
2232 worker->env.worker = worker;
2233 worker->env.worker_base = worker->base;
2234 worker->env.send_query = &worker_send_query;
2235 worker->env.alloc = worker->alloc;
2236 worker->env.outnet = worker->back;
2237 worker->env.rnd = worker->rndstate;
2240 * It would be prone to a use-after-free kind of bug, so we avoid
2243 worker->env.scratch = regional_create_custom(cfg->msg_buffer_size);
2244 if(!worker->env.scratch) {
2249 worker->env.mesh = mesh_create(&worker->daemon->mods, &worker->env);
2250 if(!worker->env.mesh) {
2256 worker->env.mesh->use_response_ip = worker->daemon->use_response_ip;
2257 worker->env.mesh->use_rpz = worker->daemon->use_rpz;
2259 worker->env.detach_subs = &mesh_detach_subs;
2260 worker->env.attach_sub = &mesh_attach_sub;
2261 worker->env.add_sub = &mesh_add_sub;
2262 worker->env.kill_sub = &mesh_state_delete;
2263 worker->env.detect_cycle = &mesh_detect_cycle;
2264 worker->env.scratch_buffer = sldns_buffer_new(cfg->msg_buffer_size);
2265 if(!worker->env.scratch_buffer) {
2270 /* one probe timer per process -- if we have 5011 anchors */
2271 if(autr_get_num_anchors(worker->env.anchors) > 0
2273 && worker->thread_num == 0
2279 worker->env.probe_timer = comm_timer_create(worker->base,
2281 if(!worker->env.probe_timer) {
2282 log_err("could not create 5011-probe timer");
2285 comm_timer_set(worker->env.probe_timer, &tv);
2288 /* zone transfer tasks, setup once per process, if any */
2289 if(worker->env.auth_zones
2291 && worker->thread_num == 0
2294 auth_xfer_pickup_initial(worker->env.auth_zones, &worker->env);
2295 auth_zones_pickup_zonemd_verify(worker->env.auth_zones,
2296 &worker->env);
2299 if(worker->daemon->cfg->dnstap
2301 && worker->thread_num == 0
2304 if(!dt_io_thread_start(dtenv->dtio, comm_base_internal(
2305 worker->base), worker->daemon->num)) {
2314 if(worker->env.cfg->stat_interval > 0) {
2316 worker->env.cfg->stat_interval);
2326 comm_base_dispatch(worker->base);
2334 if(worker->env.mesh && verbosity >= VERB_OPS) {
2335 server_stats_log(&worker->stats, worker, worker->thread_num);
2336 mesh_stats(worker->env.mesh, "mesh has");
2339 outside_network_quit_prepare(worker->back);
2340 mesh_delete(worker->env.mesh);
2341 sldns_buffer_free(worker->env.scratch_buffer);
2342 listen_delete(worker->front);
2343 outside_network_delete(worker->back);
2344 comm_signal_delete(worker->comsig);
2345 tube_delete(worker->cmd);
2346 comm_timer_delete(worker->stat_timer);
2347 comm_timer_delete(worker->env.probe_timer);
2348 free(worker->ports);
2349 if(worker->thread_num == 0) {
2355 if(worker->daemon->cfg->dnstap
2357 && worker->thread_num == 0
2360 dt_io_thread_stop(worker->dtenv.dtio);
2362 dt_deinit(&worker->dtenv);
2364 comm_base_delete(worker->base);
2365 ub_randfree(worker->rndstate);
2366 /* don't touch worker->alloc, as it's maintained in daemon */
2367 regional_destroy(worker->env.scratch);
2368 regional_destroy(worker->scratchpad);
2379 struct worker* worker = q->env->worker;
2381 q->region, sizeof(*e));
2384 e->qstate = q;
2385 e->qsent = outnet_serviced_query(worker->back, qinfo, flags, dnssec,
2388 worker_handle_service_reply, e, worker->back->udp_buff, q->env,
2390 if(!e->qsent) {
2400 slabhash_clear(&worker->env.rrset_cache->table);
2401 slabhash_clear(worker->env.msg_cache);
2406 server_stats_init(&worker->stats, worker->env.cfg);
2407 mesh_stats_clear(worker->env.mesh);
2408 worker->back->unwanted_replies = 0;
2409 worker->back->num_tcp_outgoing = 0;
2410 worker->back->num_udp_outgoing = 0;
2416 listen_start_accept(worker->front);
2417 if(worker->thread_num == 0)
2418 daemon_remote_start_accept(worker->daemon->rc);
2424 listen_stop_accept(worker->front);
2425 if(worker->thread_num == 0)
2426 daemon_remote_stop_accept(worker->daemon->rc);
2429 /* --- fake callbacks for fptr_wlist to work --- */