Lines Matching +full:no +full:- +full:pc +full:- +full:write
2 * services/outside_network.c - implement sending of queries and wait answer.
26 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
108 if(p1->id < p2->id)
109 return -1;
110 if(p1->id > p2->id)
112 log_assert(p1->id == p2->id);
113 return sockaddr_cmp(&p1->addr, p1->addrlen, &p2->addr, p2->addrlen);
122 if(q1->qbuflen < q2->qbuflen)
123 return -1;
124 if(q1->qbuflen > q2->qbuflen)
126 log_assert(q1->qbuflen == q2->qbuflen);
127 log_assert(q1->qbuflen >= 15 /* 10 header, root, type, class */);
129 if((r = memcmp(q1->qbuf, q2->qbuf, 10)) != 0)
131 if((r = memcmp(q1->qbuf+q1->qbuflen-4, q2->qbuf+q2->qbuflen-4, 4)) != 0)
133 if(q1->dnssec != q2->dnssec) {
134 if(q1->dnssec < q2->dnssec)
135 return -1;
138 if((r = query_dname_compare(q1->qbuf+10, q2->qbuf+10)) != 0)
140 if((r = edns_opt_list_compare(q1->opt_list, q2->opt_list)) != 0)
142 return sockaddr_cmp(&q1->addr, q1->addrlen, &q2->addr, q2->addrlen);
145 /** compare if the reuse element has the same address, port and same ssl-is
146 * used-for-it characteristic */
154 r = sockaddr_cmp(&r1->addr, r1->addrlen, &r2->addr, r2->addrlen);
158 /* compare if SSL-enabled */
159 if(r1->is_ssl && !r2->is_ssl)
161 if(!r1->is_ssl && r2->is_ssl)
162 return -1;
175 if(key1 < key2) return -1;
184 if(w1->id < w2->id)
185 return -1;
186 if(w1->id > w2->id)
198 if(w->timer)
199 comm_timer_delete(w->timer);
204 * Pick random outgoing-interface of that family, and bind it.
217 pend->pi = NULL;
219 if(addr_is_ip6(&w->addr, w->addrlen))
220 num = w->outnet->num_ip6;
223 num = w->outnet->num_ip4;
225 log_err("no TCP outgoing interfaces of family");
226 log_addr(VERB_OPS, "for addr", &w->addr, w->addrlen);
231 if(addr_is_ip6(&w->addr, w->addrlen))
232 pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)];
235 pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)];
237 pend->pi = pi;
238 if(addr_is_any(&pi->addr, pi->addrlen)) {
243 if(addr_is_ip6(&pi->addr, pi->addrlen))
244 ((struct sockaddr_in6*)&pi->addr)->sin6_port = 0;
245 else ((struct sockaddr_in*)&pi->addr)->sin_port = 0;
246 if(bind(s, (struct sockaddr*)&pi->addr, pi->addrlen) != 0) {
258 log_addr(VERB_ALGO, "tcp bound to src", &pi->addr, pi->addrlen);
262 /** get TCP file descriptor for address, returns -1 on failure,
284 if(s == -1) {
287 return -1;
330 if(connect(s, (struct sockaddr*)addr, addrlen) == -1) {
362 if(!reuse || !reuse->pending || !reuse->pending->c)
364 addr_to_str(&reuse->addr, reuse->addrlen, addrbuf, sizeof(addrbuf));
365 port = ntohs(((struct sockaddr_in*)&reuse->addr)->sin_port);
367 reuse->pending->c->fd);
374 struct waiting_tcp* w = reuse->write_wait_first;
377 log_assert(w->write_wait_queued);
378 log_assert(!w->write_wait_prev);
379 reuse->write_wait_first = w->write_wait_next;
380 if(w->write_wait_next)
381 w->write_wait_next->write_wait_prev = NULL;
382 else reuse->write_wait_last = NULL;
383 w->write_wait_queued = 0;
384 w->write_wait_next = NULL;
385 w->write_wait_prev = NULL;
394 log_assert(w->write_wait_queued);
397 if(!w->write_wait_queued)
399 if(w->write_wait_prev)
400 w->write_wait_prev->write_wait_next = w->write_wait_next;
401 else reuse->write_wait_first = w->write_wait_next;
402 log_assert(!w->write_wait_prev ||
403 w->write_wait_prev->write_wait_next != w->write_wait_prev);
404 if(w->write_wait_next)
405 w->write_wait_next->write_wait_prev = w->write_wait_prev;
406 else reuse->write_wait_last = w->write_wait_prev;
407 log_assert(!w->write_wait_next
408 || w->write_wait_next->write_wait_prev != w->write_wait_next);
409 w->write_wait_queued = 0;
410 w->write_wait_next = NULL;
411 w->write_wait_prev = NULL;
419 log_assert(!w->write_wait_queued);
420 if(reuse->write_wait_last) {
421 reuse->write_wait_last->write_wait_next = w;
422 log_assert(reuse->write_wait_last->write_wait_next !=
423 reuse->write_wait_last);
424 w->write_wait_prev = reuse->write_wait_last;
426 reuse->write_wait_first = w;
427 w->write_wait_prev = NULL;
429 w->write_wait_next = NULL;
430 reuse->write_wait_last = w;
431 w->write_wait_queued = 1;
441 log_assert(w->id_node.key == NULL);
442 w->id_node.key = w;
448 rbtree_insert(&reuse->tree_by_id, &w->id_node);
461 n = rbtree_search(&reuse->tree_by_id, &key_w);
463 return (struct waiting_tcp*)n->key;
470 struct waiting_tcp* w = (struct waiting_tcp*)node->key;
471 return w->id;
478 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_insert", &pend_tcp->reuse);
479 if(pend_tcp->reuse.item_on_lru_list) {
480 if(!pend_tcp->reuse.node.key)
485 pend_tcp->reuse.node.key = &pend_tcp->reuse;
486 pend_tcp->reuse.pending = pend_tcp;
487 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
495 pend_tcp->reuse.lru_prev = NULL;
496 if(outnet->tcp_reuse_first) {
497 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
498 log_assert(pend_tcp->reuse.lru_next != &pend_tcp->reuse);
499 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
500 log_assert(outnet->tcp_reuse_first->lru_prev !=
501 outnet->tcp_reuse_first);
503 pend_tcp->reuse.lru_next = NULL;
504 outnet->tcp_reuse_last = &pend_tcp->reuse;
506 outnet->tcp_reuse_first = &pend_tcp->reuse;
507 pend_tcp->reuse.item_on_lru_list = 1;
508 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
509 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
510 log_assert(outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_next &&
511 outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_prev);
512 log_assert(outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_next &&
513 outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_prev);
542 (unsigned)outnet->tcp_reuse.count);
543 if(outnet->tcp_reuse.root == NULL ||
544 outnet->tcp_reuse.root == RBTREE_NULL)
546 if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
551 log_assert(&key_p != ((struct reuse_tcp*)result)->pending);
559 result = rbtree_first(&outnet->tcp_reuse);
570 if (reuse_cmp_addrportssl(result->key, &key_p.reuse) < 0) {
583 reuse_cmp_addrportssl(prev->key, &key_p.reuse) == 0) {
590 reuse_cmp_addrportssl(result->key, &key_p.reuse) == 0) {
591 if(((struct reuse_tcp*)result)->tree_by_id.count <
592 outnet->max_reuse_tcp_queries) {
593 /* same address, port, ssl-yes-or-no, and has
608 verbose(VERB_CLIENT, "outnet_tcp_take_query_setup: setup packet to write "
610 (int)w->pkt_len, w->timeout);
611 pend->c->tcp_write_pkt = w->pkt;
612 pend->c->tcp_write_pkt_len = w->pkt_len;
613 pend->c->tcp_write_and_read = 1;
614 pend->c->tcp_write_byte_count = 0;
615 pend->c->tcp_is_reading = 0;
616 comm_point_start_listening(pend->c, s, -1);
617 /* set timer on the waiting_tcp entry, this is the write timeout
618 * for the written packet. The timer on pend->c is the timer
619 * for when there is no written packet and we have readtimeouts */
621 tv.tv_sec = w->timeout/1000;
622 tv.tv_usec = (w->timeout%1000)*1000;
627 comm_timer_set(w->timer, &tv);
634 struct pending_tcp* pend = w->outnet->tcp_free;
637 log_assert(w->pkt);
638 log_assert(w->pkt_len > 0);
639 log_assert(w->addrlen > 0);
640 pend->c->tcp_do_toggle_rw = 0;
641 pend->c->tcp_do_close = 0;
643 /* Consistency check, if we have ssl_upstream but no sslctx, then
646 if (w->ssl_upstream && !w->outnet->sslctx) {
647 log_err("SSL upstream requested but no SSL context");
652 s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss, w->outnet->ip_dscp);
654 if(s == -1)
665 struct sockaddr_in *addr_in = (struct sockaddr_in *)&w->addr;
666 addr_in->sin_len = w->addrlen;
671 endpoints.sae_dstaddr = (struct sockaddr *)&w->addr;
672 endpoints.sae_dstaddrlen = w->addrlen;
675 NULL, 0, NULL, NULL) == -1) {
682 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
685 pend->c->tcp_do_fastopen = 1;
686 /* Only do TFO for TCP in which case no connect() is required here.
689 if (w->outnet->sslctx && w->ssl_upstream) {
690 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
692 if(connect(s, (struct sockaddr*)&w->addr, w->addrlen) == -1) {
702 (struct sockaddr*)&w->addr, w->addrlen))
704 strerror(errno), &w->addr, w->addrlen);
721 if(w->outnet->sslctx && w->ssl_upstream) {
722 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
723 if(!pend->c->ssl) {
724 pend->c->fd = s;
725 comm_point_close(pend->c);
729 (w->tls_auth_name?w->tls_auth_name:"an unauthenticated connection"));
731 comm_point_tcp_win_bio_cb(pend->c, pend->c->ssl);
733 pend->c->ssl_shake_state = comm_ssl_shake_write;
734 if(!set_auth_name_on_ssl(pend->c->ssl, w->tls_auth_name,
735 w->outnet->tls_use_sni)) {
736 pend->c->fd = s;
738 SSL_free(pend->c->ssl);
740 pend->c->ssl = NULL;
741 comm_point_close(pend->c);
745 w->next_waiting = (void*)pend;
746 w->outnet->num_tcp_outgoing++;
747 w->outnet->tcp_free = pend->next_free;
748 pend->next_free = NULL;
749 pend->query = w;
750 pend->reuse.outnet = w->outnet;
751 pend->c->repinfo.remote_addrlen = w->addrlen;
752 pend->c->tcp_more_read_again = &pend->reuse.cp_more_read_again;
753 pend->c->tcp_more_write_again = &pend->reuse.cp_more_write_again;
754 pend->reuse.cp_more_read_again = 0;
755 pend->reuse.cp_more_write_again = 0;
756 memcpy(&pend->c->repinfo.remote_addr, &w->addr, w->addrlen);
757 pend->reuse.pending = pend;
762 * previous node) but their ->key would be changed to NULL. */
763 if(pend->reuse.node.key)
764 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
766 if(pend->c->ssl)
767 pend->reuse.is_ssl = 1;
768 else pend->reuse.is_ssl = 0;
770 (void)reuse_tcp_insert(w->outnet, pend);
771 reuse_tree_by_id_insert(&pend->reuse, w);
782 if(!reuse->item_on_lru_list) {
784 return; /* not on the list, no lru to modify */
786 log_assert(reuse->lru_prev ||
787 (!reuse->lru_prev && outnet->tcp_reuse_first == reuse));
788 if(!reuse->lru_prev)
792 reuse->lru_prev->lru_next = reuse->lru_next;
793 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
794 if(reuse->lru_next)
795 reuse->lru_next->lru_prev = reuse->lru_prev;
796 else outnet->tcp_reuse_last = reuse->lru_prev;
797 log_assert(!reuse->lru_next || reuse->lru_next->lru_prev != reuse->lru_next);
798 log_assert(outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_next &&
799 outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_prev);
801 reuse->lru_prev = NULL;
802 reuse->lru_next = outnet->tcp_reuse_first;
803 if(outnet->tcp_reuse_first) {
804 outnet->tcp_reuse_first->lru_prev = reuse;
806 log_assert(reuse->lru_next != reuse);
809 * the list, so outnet->tcp_reuse_last does not need to be modified */
810 outnet->tcp_reuse_first = reuse;
811 log_assert(outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_next &&
812 outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_prev);
813 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
814 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
821 struct reuse_tcp* reuse = outnet->tcp_reuse_last;
824 log_assert(reuse->lru_next == NULL);
825 if(reuse->lru_prev) {
826 outnet->tcp_reuse_last = reuse->lru_prev;
827 reuse->lru_prev->lru_next = NULL;
829 outnet->tcp_reuse_last = NULL;
830 outnet->tcp_reuse_first = NULL;
832 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
833 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
834 reuse->item_on_lru_list = 0;
835 reuse->lru_next = NULL;
836 reuse->lru_prev = NULL;
844 struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
845 w->on_tcp_waiting_list = 0;
850 prev->next_waiting = w->next_waiting;
851 else outnet->tcp_wait_first = w->next_waiting;
852 if(outnet->tcp_wait_last == w)
853 outnet->tcp_wait_last = prev;
854 w->next_waiting = NULL;
858 p = p->next_waiting;
869 struct waiting_tcp* w = outnet->tcp_wait_first;
870 if(!outnet->tcp_wait_first) return NULL;
871 log_assert(w->on_tcp_waiting_list);
872 outnet->tcp_wait_first = w->next_waiting;
873 if(outnet->tcp_wait_last == w)
874 outnet->tcp_wait_last = NULL;
875 w->on_tcp_waiting_list = 0;
876 w->next_waiting = NULL;
886 log_assert(!w->on_tcp_waiting_list);
887 if(w->on_tcp_waiting_list)
889 w->next_waiting = NULL;
890 if(outnet->tcp_wait_last)
891 outnet->tcp_wait_last->next_waiting = w;
892 else outnet->tcp_wait_first = w;
893 outnet->tcp_wait_last = w;
894 w->on_tcp_waiting_list = 1;
897 tv.tv_sec = w->timeout/1000;
898 tv.tv_usec = (w->timeout%1000)*1000;
900 comm_timer_set(w->timer, &tv);
910 log_assert(!w->on_tcp_waiting_list);
911 if(w->on_tcp_waiting_list)
913 w->next_waiting = outnet->tcp_wait_first;
914 log_assert(w->next_waiting != w);
915 if(!outnet->tcp_wait_last)
916 outnet->tcp_wait_last = w;
917 outnet->tcp_wait_first = w;
918 w->on_tcp_waiting_list = 1;
921 tv.tv_sec = w->timeout/1000;
922 tv.tv_usec = (w->timeout%1000)*1000;
924 comm_timer_set(w->timer, &tv);
927 (!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
928 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
936 if(w && w->cb) {
937 fptr_ok(fptr_whitelist_pending_tcp(w->cb));
938 (void)(*w->cb)(c, w->cb_arg, error, reply_info);
947 while(outnet->tcp_wait_first && !outnet->want_to_quit) {
954 (!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
955 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
956 reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
957 w->ssl_upstream);
958 /* re-select an ID when moving to a new TCP buffer */
959 w->id = tcp_select_id(outnet, reuse);
960 LDNS_ID_SET(w->pkt, w->id);
965 pend_tcp = reuse->pending;
968 comm_timer_disable(w->timer);
969 w->next_waiting = (void*)reuse->pending;
971 if(reuse->pending->query) {
972 /* on the write wait list */
975 /* write straight away */
977 comm_point_stop_listening(reuse->pending->c);
978 reuse->pending->query = w;
980 reuse->pending->c->fd, reuse->pending,
983 } else if(outnet->tcp_free) {
984 struct pending_tcp* pend = w->outnet->tcp_free;
985 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
986 pend->reuse.pending = pend;
987 memcpy(&pend->reuse.addr, &w->addr, w->addrlen);
988 pend->reuse.addrlen = w->addrlen;
1001 /* no reuse and no free buffer, put back at the start */
1006 if(outnet->dtenv && pend_tcp && w && w->sq &&
1007 (outnet->dtenv->log_resolver_query_messages ||
1008 outnet->dtenv->log_forwarder_query_messages)) {
1010 sldns_buffer_init_frm_data(&tmp, w->pkt, w->pkt_len);
1011 dt_msg_send_outside_query(outnet->dtenv, &w->sq->addr,
1012 &pend_tcp->pi->addr, comm_tcp, NULL, w->sq->zone,
1013 w->sq->zonelen, &tmp);
1026 log_assert(w->id_node.key != NULL);
1032 rbtree_delete(&reuse->tree_by_id, w);
1034 w->id_node.key = NULL;
1049 if(pend->query && pend->query->error_count == 0 &&
1050 pend->c->tcp_write_pkt == pend->query->pkt &&
1051 pend->c->tcp_write_pkt_len == pend->query->pkt_len) {
1054 if(verbosity >= VERB_CLIENT && pend->query->pkt_len > 12+2+2 &&
1055 LDNS_QDCOUNT(pend->query->pkt) > 0 &&
1056 dname_valid(pend->query->pkt+12, pend->query->pkt_len-12)) {
1058 dname_str(pend->query->pkt+12, buf);
1060 buf, (int)pend->c->tcp_write_byte_count);
1062 pend->c->tcp_write_pkt = NULL;
1063 pend->c->tcp_write_pkt_len = 0;
1064 pend->c->tcp_write_and_read = 0;
1065 pend->reuse.cp_more_read_again = 0;
1066 pend->reuse.cp_more_write_again = 0;
1067 pend->c->tcp_is_reading = 1;
1068 w = pend->query;
1069 pend->query = NULL;
1074 w->error_count ++;
1075 reuse_tree_by_id_delete(&pend->reuse, w);
1078 while((w = reuse_write_wait_pop(&pend->reuse)) != NULL) {
1079 if(verbosity >= VERB_CLIENT && w->pkt_len > 12+2+2 &&
1080 LDNS_QDCOUNT(w->pkt) > 0 &&
1081 dname_valid(w->pkt+12, w->pkt_len-12)) {
1083 dname_str(w->pkt+12, buf);
1086 reuse_tree_by_id_delete(&pend->reuse, w);
1097 if(reuse->node.key) {
1099 if(!rbtree_delete(&outnet->tcp_reuse, reuse)) {
1102 addr_to_str(&reuse->addr, reuse->addrlen, buf,
1104 log_err("reuse tcp delete: node not present, internal error, %s ssl %d lru %d", buf, reuse->is_ssl, reuse->item_on_lru_list);
1106 reuse->node.key = NULL;
1109 memset(&reuse->node, 0, sizeof(reuse->node));
1112 if(reuse->item_on_lru_list) {
1113 if(reuse->lru_prev) {
1116 log_assert(reuse->lru_prev->pending);
1117 reuse->lru_prev->lru_next = reuse->lru_next;
1118 log_assert(reuse->lru_prev->lru_next != reuse->lru_prev);
1120 log_assert(!reuse->lru_next || reuse->lru_next->pending);
1121 outnet->tcp_reuse_first = reuse->lru_next;
1122 log_assert(!outnet->tcp_reuse_first ||
1123 (outnet->tcp_reuse_first !=
1124 outnet->tcp_reuse_first->lru_next &&
1125 outnet->tcp_reuse_first !=
1126 outnet->tcp_reuse_first->lru_prev));
1128 if(reuse->lru_next) {
1131 log_assert(reuse->lru_next->pending);
1132 reuse->lru_next->lru_prev = reuse->lru_prev;
1133 log_assert(reuse->lru_next->lru_prev != reuse->lru_next);
1135 log_assert(!reuse->lru_prev || reuse->lru_prev->pending);
1136 outnet->tcp_reuse_last = reuse->lru_prev;
1137 log_assert(!outnet->tcp_reuse_last ||
1138 (outnet->tcp_reuse_last !=
1139 outnet->tcp_reuse_last->lru_next &&
1140 outnet->tcp_reuse_last !=
1141 outnet->tcp_reuse_last->lru_prev));
1143 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
1144 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
1145 reuse->item_on_lru_list = 0;
1146 reuse->lru_next = NULL;
1147 reuse->lru_prev = NULL;
1149 reuse->pending = NULL;
1156 struct waiting_tcp* w = (struct waiting_tcp*)node->key;
1163 if(tree_by_id->root == NULL ||
1164 tree_by_id->root == RBTREE_NULL)
1178 if(outnet->tcp_free != pend) {
1179 pend->next_free = outnet->tcp_free;
1180 outnet->tcp_free = pend;
1182 if(pend->reuse.node.key) {
1184 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1187 * because the c->ssl null or not is used for sorting in the tree */
1188 if(pend->c->ssl) {
1190 SSL_shutdown(pend->c->ssl);
1191 SSL_free(pend->c->ssl);
1192 pend->c->ssl = NULL;
1195 comm_point_close(pend->c);
1196 pend->reuse.cp_more_read_again = 0;
1197 pend->reuse.cp_more_write_again = 0;
1200 pend->query = NULL;
1201 pend->reuse.write_wait_first = NULL;
1202 pend->reuse.write_wait_last = NULL;
1203 reuse_del_readwait(&pend->reuse.tree_by_id);
1210 if(tree_by_id->root == NULL ||
1211 tree_by_id->root == RBTREE_NULL)
1215 struct waiting_tcp* w = (struct waiting_tcp*)node->key;
1225 struct waiting_tcp* w = (struct waiting_tcp*)node->key;
1229 w->in_cb_and_decommission = 1;
1233 if(w->cb)
1234 ((struct serviced_query*)w->cb_arg)->to_be_deleted = 1;
1238 * the callbacks remove references in sq->pending to the waiting_tcp
1246 store = pend->reuse.tree_by_id;
1247 pend->query = NULL;
1248 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
1249 pend->reuse.write_wait_first = NULL;
1250 pend->reuse.write_wait_last = NULL;
1263 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_timeout", &pend_tcp->reuse);
1264 comm_point_start_listening(pend_tcp->c, -1, tcp_reuse_timeout);
1271 log_reuse_tcp(VERB_CLIENT, "reuse_tcp_setup_readtimeout", &pend_tcp->reuse);
1272 sldns_buffer_clear(pend_tcp->c->buffer);
1273 pend_tcp->c->tcp_is_reading = 1;
1274 pend_tcp->c->tcp_byte_count = 0;
1275 comm_point_stop_listening(pend_tcp->c);
1276 comm_point_start_listening(pend_tcp->c, -1, tcp_reuse_timeout);
1284 struct outside_network* outnet = pend->reuse.outnet;
1286 log_assert(pend->reuse.item_on_lru_list && pend->reuse.node.key);
1289 if(pend->c->tcp_write_and_read) {
1291 "for read, ignored because write underway");
1292 /* if we are writing, ignore readtimer, wait for write timer
1293 * or write is done */
1297 (pend->reuse.tree_by_id.count?"for reading pkt":
1302 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1304 /* the packet we want to write has been written. */
1306 log_assert(c == pend->c);
1307 log_assert(pend->query->pkt == pend->c->tcp_write_pkt);
1308 log_assert(pend->query->pkt_len == pend->c->tcp_write_pkt_len);
1309 pend->c->tcp_write_pkt = NULL;
1310 pend->c->tcp_write_pkt_len = 0;
1312 log_assert(pend->query->id_node.key);
1313 pend->query = NULL;
1314 /* setup to write next packet or setup read timeout */
1315 if(pend->reuse.write_wait_first) {
1317 /* we can write it straight away perhaps, set flag
1318 * because this callback called after a tcp write
1320 * and we can write some more. */
1321 pend->reuse.cp_more_write_again = 1;
1322 pend->query = reuse_write_wait_pop(&pend->reuse);
1323 comm_point_stop_listening(pend->c);
1324 outnet_tcp_take_query_setup(pend->c->fd, pend,
1325 pend->query);
1328 pend->c->tcp_write_and_read = 0;
1329 pend->reuse.cp_more_read_again = 0;
1330 pend->reuse.cp_more_write_again = 0;
1331 pend->c->tcp_is_reading = 1;
1332 comm_point_stop_listening(pend->c);
1333 reuse_tcp_setup_timeout(pend, outnet->tcp_reuse_timeout);
1342 if(sldns_buffer_limit(c->buffer) < sizeof(uint16_t)) {
1345 &pend->reuse.addr, pend->reuse.addrlen);
1349 c->buffer));
1351 w = reuse_tcp_by_id_find(&pend->reuse, id);
1356 if(w && (w->on_tcp_waiting_list || w->write_wait_queued))
1361 /* no struct waiting found in tree, no reply to call */
1363 &pend->reuse.addr, pend->reuse.addrlen);
1370 if(outnet->tcp_reuse.count < outnet->tcp_reuse_max) {
1375 log_assert(!w->on_tcp_waiting_list);
1376 log_assert(!w->write_wait_queued);
1377 reuse_tree_by_id_delete(&pend->reuse, w);
1379 error, (int)sldns_buffer_limit(c->buffer));
1384 if(error == NETEVENT_NOERROR && pend->reuse.node.key) {
1392 if(pend->reuse.tree_by_id.count != 0)
1393 pend->reuse.cp_more_read_again = 1;
1394 reuse_tcp_setup_read_and_timeout(pend, outnet->tcp_reuse_timeout);
1398 /* no queries on it, no space to keep it. or timeout or closed due
1406 /** lower use count on pc, see if it can be closed */
1408 portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
1411 pc->num_outstanding--;
1412 if(pc->num_outstanding > 0) {
1416 verbose(VERB_ALGO, "close of port %d", pc->number);
1417 comm_point_close(pc->cp);
1418 pif = pc->pif;
1419 log_assert(pif->inuse > 0);
1421 pif->avail_ports[pif->avail_total - pif->inuse] = pc->number;
1423 pif->inuse--;
1424 pif->out[pc->index] = pif->out[pif->inuse];
1425 pif->out[pc->index]->index = pc->index;
1426 pc->next = outnet->unused_fds;
1427 outnet->unused_fds = pc;
1436 while(outnet->udp_wait_first && outnet->unused_fds
1437 && !outnet->want_to_quit) {
1438 pend = outnet->udp_wait_first;
1439 outnet->udp_wait_first = pend->next_waiting;
1440 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
1441 sldns_buffer_clear(outnet->udp_buff);
1442 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
1443 sldns_buffer_flip(outnet->udp_buff);
1444 free(pend->pkt); /* freeing now makes get_mem correct */
1445 pend->pkt = NULL;
1446 pend->pkt_len = 0;
1447 log_assert(!pend->sq->busy);
1448 pend->sq->busy = 1;
1449 if(!randomize_and_send_udp(pend, outnet->udp_buff,
1450 pend->timeout)) {
1452 if(pend->cb) {
1453 fptr_ok(fptr_whitelist_pending_udp(pend->cb));
1454 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
1459 pend->sq->busy = 0;
1477 if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1484 key.id = (unsigned)LDNS_ID_WIRE(sldns_buffer_begin(c->buffer));
1485 memcpy(&key.addr, &reply_info->remote_addr, reply_info->remote_addrlen);
1486 key.addrlen = reply_info->remote_addrlen;
1489 &reply_info->remote_addr, reply_info->remote_addrlen);
1492 verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
1493 p = (struct pending*)rbtree_search(outnet->pending, &key);
1496 log_buf(VERB_ALGO, "dropped message", c->buffer);
1497 outnet->unwanted_replies++;
1498 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1499 >= outnet->unwanted_threshold) {
1503 (unsigned)outnet->unwanted_threshold);
1505 outnet->unwanted_action));
1506 (*outnet->unwanted_action)(outnet->unwanted_param);
1507 outnet->unwanted_total = 0;
1513 log_buf(VERB_ALGO, "udp message", c->buffer);
1514 if(p->pc->cp != c) {
1517 outnet->unwanted_replies++;
1518 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1519 >= outnet->unwanted_threshold) {
1523 (unsigned)outnet->unwanted_threshold);
1525 outnet->unwanted_action));
1526 (*outnet->unwanted_action)(outnet->unwanted_param);
1527 outnet->unwanted_total = 0;
1531 comm_timer_disable(p->timer);
1534 (void)rbtree_delete(outnet->pending, p->node.key);
1535 if(p->cb) {
1536 fptr_ok(fptr_whitelist_pending_udp(p->cb));
1537 (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_NOERROR, reply_info);
1539 portcomm_loweruse(outnet, p->pc);
1576 struct outside_network* outnet = p->outnet;
1578 portcomm_loweruse(outnet, p->pc);
1587 struct outside_network* outnet = p->outnet;
1590 if(p->cb) {
1591 fptr_ok(fptr_whitelist_pending_udp(p->cb));
1592 (void)(*p->cb)(p->pc->cp, p->cb_arg, NETEVENT_TIMEOUT, NULL);
1598 if(outnet->delayclose && !outnet->udp_wait_first) {
1599 p->cb = NULL;
1600 p->timer->callback = &pending_udp_timer_delay_cb;
1601 comm_timer_set(p->timer, &outnet->delay_tv);
1604 portcomm_loweruse(outnet, p->pc);
1614 if(outnet->num_tcp == 0)
1615 return 1; /* no tcp needed, nothing to do */
1616 if(!(outnet->tcp_conns = (struct pending_tcp **)calloc(
1617 outnet->num_tcp, sizeof(struct pending_tcp*))))
1619 for(i=0; i<outnet->num_tcp; i++) {
1620 if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1,
1623 outnet->tcp_conns[i]->next_free = outnet->tcp_free;
1624 outnet->tcp_free = outnet->tcp_conns[i];
1625 outnet->tcp_conns[i]->c = comm_point_create_tcp_out(
1626 outnet->base, bufsize, outnet_tcp_cb,
1627 outnet->tcp_conns[i]);
1628 if(!outnet->tcp_conns[i]->c)
1639 pif->avail_total = numavail;
1640 pif->avail_ports = (int*)memdup(avail, (size_t)numavail*sizeof(int));
1641 if(!pif->avail_ports)
1644 if(!ipstrtoaddr(addrstr, UNBOUND_DNS_PORT, &pif->addr, &pif->addrlen) &&
1646 &pif->addr, &pif->addrlen, &pif->pfxlen))
1648 pif->maxout = (int)numfd;
1649 pif->inuse = 0;
1650 pif->out = (struct port_comm**)calloc(numfd,
1652 if(!pif->out)
1675 comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
1676 outnet->base = base;
1677 outnet->num_tcp = num_tcp;
1678 outnet->max_reuse_tcp_queries = max_reuse_tcp_queries;
1679 outnet->tcp_reuse_timeout= tcp_reuse_timeout;
1680 outnet->tcp_auth_query_timeout = tcp_auth_query_timeout;
1681 outnet->num_tcp_outgoing = 0;
1682 outnet->num_udp_outgoing = 0;
1683 outnet->infra = infra;
1684 outnet->rnd = rnd;
1685 outnet->sslctx = sslctx;
1686 outnet->tls_use_sni = tls_use_sni;
1688 outnet->dtenv = dtenv;
1692 outnet->svcd_overhead = 0;
1693 outnet->want_to_quit = 0;
1694 outnet->unwanted_threshold = unwanted_threshold;
1695 outnet->unwanted_action = unwanted_action;
1696 outnet->unwanted_param = unwanted_param;
1697 outnet->use_caps_for_id = use_caps_for_id;
1698 outnet->do_udp = do_udp;
1699 outnet->tcp_mss = tcp_mss;
1700 outnet->ip_dscp = dscp;
1703 outnet->delayclose = 1;
1704 outnet->delay_tv.tv_sec = delayclose/1000;
1705 outnet->delay_tv.tv_usec = (delayclose%1000)*1000;
1709 outnet->udp_connect = 1;
1712 log_err("no outgoing ports available");
1720 &outnet->num_ip4, &outnet->num_ip6);
1721 if(outnet->num_ip4 != 0) {
1722 if(!(outnet->ip4_ifs = (struct port_if*)calloc(
1723 (size_t)outnet->num_ip4, sizeof(struct port_if)))) {
1729 if(outnet->num_ip6 != 0) {
1730 if(!(outnet->ip6_ifs = (struct port_if*)calloc(
1731 (size_t)outnet->num_ip6, sizeof(struct port_if)))) {
1737 if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
1738 !(outnet->pending = rbtree_create(pending_cmp)) ||
1739 !(outnet->serviced = rbtree_create(serviced_cmp)) ||
1745 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1746 outnet->tcp_reuse_max = num_tcp;
1750 struct port_comm* pc;
1751 pc = (struct port_comm*)calloc(1, sizeof(*pc));
1752 if(!pc) {
1757 pc->cp = comm_point_create_udp(outnet->base, -1,
1758 outnet->udp_buff, 0, outnet_udp_cb, outnet, NULL);
1759 if(!pc->cp) {
1761 free(pc);
1765 pc->next = outnet->unused_fds;
1766 outnet->unused_fds = pc;
1771 if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0",
1777 if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
1788 if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
1797 if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
1824 alloc_reg_release(sq->alloc, sq->region);
1825 if(sq->timer)
1826 comm_timer_delete(sq->timer);
1836 outnet->want_to_quit = 1;
1844 outnet->want_to_quit = 1;
1846 if(outnet->pending) {
1847 /* free pending elements, but do no unlink from tree. */
1848 traverse_postorder(outnet->pending, pending_node_del, NULL);
1849 free(outnet->pending);
1851 if(outnet->serviced) {
1852 traverse_postorder(outnet->serviced, serviced_node_del, NULL);
1853 free(outnet->serviced);
1855 if(outnet->udp_buff)
1856 sldns_buffer_free(outnet->udp_buff);
1857 if(outnet->unused_fds) {
1858 struct port_comm* p = outnet->unused_fds, *np;
1860 np = p->next;
1861 comm_point_delete(p->cp);
1865 outnet->unused_fds = NULL;
1867 if(outnet->ip4_ifs) {
1869 for(i=0; i<outnet->num_ip4; i++) {
1870 for(k=0; k<outnet->ip4_ifs[i].inuse; k++) {
1871 struct port_comm* pc = outnet->ip4_ifs[i].
1873 comm_point_delete(pc->cp);
1874 free(pc);
1877 free(outnet->ip4_ifs[i].avail_ports);
1879 free(outnet->ip4_ifs[i].out);
1881 free(outnet->ip4_ifs);
1883 if(outnet->ip6_ifs) {
1885 for(i=0; i<outnet->num_ip6; i++) {
1886 for(k=0; k<outnet->ip6_ifs[i].inuse; k++) {
1887 struct port_comm* pc = outnet->ip6_ifs[i].
1889 comm_point_delete(pc->cp);
1890 free(pc);
1893 free(outnet->ip6_ifs[i].avail_ports);
1895 free(outnet->ip6_ifs[i].out);
1897 free(outnet->ip6_ifs);
1899 if(outnet->tcp_conns) {
1901 for(i=0; i<outnet->num_tcp; i++)
1902 if(outnet->tcp_conns[i]) {
1904 pend = outnet->tcp_conns[i];
1905 if(pend->reuse.item_on_lru_list) {
1910 comm_point_delete(outnet->tcp_conns[i]->c);
1911 free(outnet->tcp_conns[i]);
1912 outnet->tcp_conns[i] = NULL;
1914 free(outnet->tcp_conns);
1915 outnet->tcp_conns = NULL;
1917 if(outnet->tcp_wait_first) {
1918 struct waiting_tcp* p = outnet->tcp_wait_first, *np;
1920 np = p->next_waiting;
1926 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1927 outnet->tcp_reuse_first = NULL;
1928 outnet->tcp_reuse_last = NULL;
1929 if(outnet->udp_wait_first) {
1930 struct pending* p = outnet->udp_wait_first, *np;
1932 np = p->next_waiting;
1945 if(outnet && outnet->udp_wait_first &&
1946 (p->next_waiting || p == outnet->udp_wait_last) ) {
1948 struct pending* prev = NULL, *x = outnet->udp_wait_first;
1951 x = x->next_waiting;
1956 prev->next_waiting = p->next_waiting;
1957 else outnet->udp_wait_first = p->next_waiting;
1958 if(outnet->udp_wait_last == p)
1959 outnet->udp_wait_last = prev;
1963 (void)rbtree_delete(outnet->pending, p->node.key);
1965 if(p->timer)
1966 comm_timer_delete(p->timer);
1967 free(p->pkt);
1977 for(i = 0; i < (128 - pfxlen) / 8; i++) {
1978 sa->sin6_addr.s6_addr[15-i] = (uint8_t)ub_random_max(rnd, 256);
1982 sa->sin6_addr.s6_addr[15-i] |=
1994 * @param inuse: if -1 is returned, this bool means the port was in use.
1997 * @return fd or -1
2019 sa->sin_port = (in_port_t)htons((uint16_t)port);
2033 pend->id = GET_RANDOM_ID(outnet->rnd);
2034 LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
2037 pend->node.key = pend;
2038 while(!rbtree_insert(outnet->pending, &pend->node)) {
2040 pend->id = GET_RANDOM_ID(outnet->rnd);
2041 LDNS_ID_SET(sldns_buffer_begin(packet), pend->id);
2044 pend->id=99999; /* non existent ID */
2049 verbose(VERB_ALGO, "inserted new pending reply id=%4.4x", pend->id);
2104 verbose(VERB_QUERY, "Need to send query but have no "
2108 log_assert(outnet->unused_fds);
2111 my_if = ub_random_max(outnet->rnd, num_if);
2114 if(outnet->udp_connect) {
2116 if(pif->inuse >= pif->avail_total) {
2123 my_port = pif->inuse + ub_random_max(outnet->rnd,
2124 pif->avail_total - pif->inuse);
2126 my_port = ub_random_max(outnet->rnd, pif->avail_total);
2127 if(my_port < pif->inuse) {
2129 pend->pc = pif->out[my_port];
2131 my_if, pend->pc->number);
2136 log_assert(pif->inuse < pif->maxout);
2137 portno = pif->avail_ports[my_port - pif->inuse];
2141 fd = udp_sockport(&pif->addr, pif->addrlen, pif->pfxlen,
2142 portno, &inuse, outnet->rnd, outnet->ip_dscp);
2143 if(fd == -1 && !inuse) {
2147 if(fd != -1) {
2150 if(outnet->udp_connect) {
2152 if(connect(fd, (struct sockaddr*)&pend->addr,
2153 pend->addrlen) < 0) {
2155 &pend->addr, pend->addrlen)) {
2157 strerror(errno), &pend->addr,
2158 pend->addrlen);
2165 pend->pc = outnet->unused_fds;
2166 outnet->unused_fds = pend->pc->next;
2169 pend->pc->next = NULL;
2170 pend->pc->number = portno;
2171 pend->pc->pif = pif;
2172 pend->pc->index = pif->inuse;
2173 pend->pc->num_outstanding = 0;
2174 comm_point_start_listening(pend->pc->cp, fd, -1);
2177 pif->out[pif->inuse] = pend->pc;
2179 pif->avail_ports[my_port - pif->inuse] =
2180 pif->avail_ports[pif->avail_total-pif->inuse-1];
2182 pif->inuse++;
2193 log_assert(pend->pc);
2194 pend->pc->num_outstanding++;
2203 struct outside_network* outnet = pend->sq->outnet;
2211 if(addr_is_ip6(&pend->addr, pend->addrlen)) {
2213 outnet->num_ip6, outnet->ip6_ifs))
2217 outnet->num_ip4, outnet->ip4_ifs))
2220 log_assert(pend->pc && pend->pc->cp);
2223 if(!comm_point_send_udp_msg(pend->pc->cp, packet,
2224 (struct sockaddr*)&pend->addr, pend->addrlen, outnet->udp_connect)) {
2225 portcomm_loweruse(outnet, pend->pc);
2228 outnet->num_udp_outgoing++;
2236 comm_timer_set(pend->timer, &tv);
2241 * There are no chances to get the src (local service) addr if unbound
2242 * is not configured with specific outgoing IP-addresses. So we will
2246 if(outnet->dtenv &&
2247 (outnet->dtenv->log_resolver_query_messages ||
2248 outnet->dtenv->log_forwarder_query_messages)) {
2249 log_addr(VERB_ALGO, "from local addr", &pend->pc->pif->addr, pend->pc->pif->addrlen);
2250 log_addr(VERB_ALGO, "request to upstream", &pend->addr, pend->addrlen);
2251 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, &pend->pc->pif->addr, comm_udp, NULL,
2252 pend->sq->zone, pend->sq->zonelen, packet);
2264 pend->outnet = sq->outnet;
2265 pend->sq = sq;
2266 pend->addrlen = sq->addrlen;
2267 memmove(&pend->addr, &sq->addr, sq->addrlen);
2268 pend->cb = cb;
2269 pend->cb_arg = cb_arg;
2270 pend->node.key = pend;
2271 pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
2273 if(!pend->timer) {
2278 if(sq->outnet->unused_fds == NULL) {
2279 /* no unused fd, cannot create a new port (randomly) */
2280 verbose(VERB_ALGO, "no fds available, udp query waiting");
2281 pend->timeout = timeout;
2282 pend->pkt_len = sldns_buffer_limit(packet);
2283 pend->pkt = (uint8_t*)memdup(sldns_buffer_begin(packet),
2284 pend->pkt_len);
2285 if(!pend->pkt) {
2286 comm_timer_delete(pend->timer);
2291 if(sq->outnet->udp_wait_last)
2292 sq->outnet->udp_wait_last->next_waiting = pend;
2294 sq->outnet->udp_wait_first = pend;
2295 sq->outnet->udp_wait_last = pend;
2298 log_assert(!sq->busy);
2299 sq->busy = 1;
2301 pending_delete(sq->outnet, pend);
2304 sq->busy = 0;
2312 struct outside_network* outnet = w->outnet;
2314 if(w->on_tcp_waiting_list) {
2321 struct pending_tcp* pend=(struct pending_tcp*)w->next_waiting;
2337 reuse_cb_and_decommission(outnet, reuse->pending, NETEVENT_CLOSED);
2345 return GET_RANDOM_ID(outnet->rnd);
2360 if(reuse->tree_by_id.count == 0) {
2361 id = GET_RANDOM_ID(outnet->rnd);
2367 id = GET_RANDOM_ID(outnet->rnd);
2374 * not in use. Pick a the n-th index of an unused number,
2376 log_assert(reuse->tree_by_id.count < 0xffff);
2377 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2378 /* select value now in 0 .. num free - 1 */
2381 node = rbtree_first(&reuse->tree_by_id);
2396 space = nextid - curid - 1;
2400 return curid + 1 + (select - count);
2411 node = rbtree_last(&reuse->tree_by_id);
2414 log_assert(count + (0xffff-curid) + reuse->tree_by_id.count == 0xffff);
2415 return curid + 1 + (select - count);
2422 struct pending_tcp* pend = sq->outnet->tcp_free;
2434 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2435 sq->ssl_upstream);
2438 log_assert(reuse->pending);
2439 pend = reuse->pending;
2440 reuse_tcp_lru_touch(sq->outnet, reuse);
2445 * to be able to open a new one to this target, no use waiting
2449 reuse_tcp_close_oldest(sq->outnet);
2450 pend = sq->outnet->tcp_free;
2451 log_assert(!reuse || (pend == reuse->pending));
2460 if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
2464 w->pkt = (uint8_t*)w + sizeof(struct waiting_tcp);
2465 w->pkt_len = sldns_buffer_limit(packet);
2466 memmove(w->pkt, sldns_buffer_begin(packet), w->pkt_len);
2467 w->id = tcp_select_id(sq->outnet, reuse);
2468 LDNS_ID_SET(w->pkt, w->id);
2469 memcpy(&w->addr, &sq->addr, sq->addrlen);
2470 w->addrlen = sq->addrlen;
2471 w->outnet = sq->outnet;
2472 w->on_tcp_waiting_list = 0;
2473 w->next_waiting = NULL;
2474 w->cb = callback;
2475 w->cb_arg = callback_arg;
2476 w->ssl_upstream = sq->ssl_upstream;
2477 w->tls_auth_name = sq->tls_auth_name;
2478 w->timeout = timeout;
2479 w->id_node.key = NULL;
2480 w->write_wait_prev = NULL;
2481 w->write_wait_next = NULL;
2482 w->write_wait_queued = 0;
2483 w->error_count = 0;
2485 w->sq = NULL;
2487 w->in_cb_and_decommission = 0;
2491 log_assert(reuse == &pend->reuse);
2492 /* reuse existing fd, write query and continue */
2495 w->next_waiting = (void*)pend;
2496 reuse_tree_by_id_insert(&pend->reuse, w);
2497 /* can we write right now? */
2498 if(pend->query == NULL) {
2499 /* write straight away */
2501 comm_point_stop_listening(pend->c);
2502 pend->query = w;
2503 outnet_tcp_take_query_setup(pend->c->fd, pend,
2508 reuse_write_wait_push_back(&pend->reuse, w);
2512 * write query */
2514 rbtree_init(&pend->reuse.tree_by_id, reuse_id_cmp);
2515 pend->reuse.pending = pend;
2516 memcpy(&pend->reuse.addr, &sq->addr, sq->addrlen);
2517 pend->reuse.addrlen = sq->addrlen;
2524 if(sq->outnet->dtenv &&
2525 (sq->outnet->dtenv->log_resolver_query_messages ||
2526 sq->outnet->dtenv->log_forwarder_query_messages)) {
2527 /* use w->pkt, because it has the ID value */
2529 sldns_buffer_init_frm_data(&tmp, w->pkt, w->pkt_len);
2530 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
2531 &pend->pi->addr, comm_tcp, NULL, sq->zone,
2532 sq->zonelen, &tmp);
2541 w->sq = sq;
2543 outnet_waiting_tcp_list_add(sq->outnet, w, 1);
2581 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
2588 struct outside_network* outnet = sq->outnet;
2592 if(!sq->cblist)
2595 if(outnet->do_udp && !(sq->tcp_upstream || sq->ssl_upstream)) {
2596 if(!serviced_udp_send(sq, outnet->udp_buff))
2599 if(!serviced_tcp_send(sq, outnet->udp_buff))
2628 sq->node.key = sq;
2629 sq->alloc = alloc;
2630 sq->region = region;
2631 sq->qbuf = regional_alloc_init(region, sldns_buffer_begin(buff),
2633 if(!sq->qbuf) {
2638 sq->qbuflen = sldns_buffer_limit(buff);
2639 sq->zone = regional_alloc_init(region, zone, zonelen);
2640 if(!sq->zone) {
2645 sq->zonelen = zonelen;
2646 sq->qtype = qtype;
2647 sq->dnssec = dnssec;
2648 sq->want_dnssec = want_dnssec;
2649 sq->nocaps = nocaps;
2650 sq->tcp_upstream = tcp_upstream;
2651 sq->ssl_upstream = ssl_upstream;
2653 sq->tls_auth_name = regional_strdup(region, tls_auth_name);
2654 if(!sq->tls_auth_name) {
2660 sq->tls_auth_name = NULL;
2662 memcpy(&sq->addr, addr, addrlen);
2663 sq->addrlen = addrlen;
2664 sq->opt_list = opt_list;
2665 sq->busy = 0;
2666 sq->timer = comm_timer_create(outnet->base, serviced_timer_cb, sq);
2667 if(!sq->timer) {
2673 comm_timer_set(sq->timer, &t);
2674 sq->outnet = outnet;
2675 sq->cblist = NULL;
2676 sq->pending = NULL;
2677 sq->status = serviced_initial;
2678 sq->retry = 0;
2679 sq->to_be_deleted = 0;
2680 sq->padding_block_size = pad_queries_block_size;
2686 rbtree_insert(outnet->serviced, &sq->node);
2697 struct pending_tcp* pend_tcp = (struct pending_tcp*)w->next_waiting;
2699 /* remove the callback. let query continue to write to not cancel
2701 * in case the answer returns (that we no longer want), but we cannot
2703 w->cb = NULL;
2705 * for that the FD has to be non-1 */
2706 if(pend_tcp->c->fd == -1) {
2707 verbose(VERB_CLIENT, "reuse_tcp_remove_serviced_keep: -1 fd");
2711 if(pend_tcp->reuse.node.key) {
2716 * eg. iterator no longer interested in this query */
2720 if(pend_tcp->c->fd != -1 && sq->outnet->tcp_reuse.count <
2721 sq->outnet->tcp_reuse_max) {
2724 if(!reuse_tcp_insert(sq->outnet, pend_tcp)) {
2727 reuse_tcp_setup_timeout(pend_tcp, sq->outnet->tcp_reuse_timeout);
2738 if(sq->pending) {
2740 if(sq->status == serviced_query_UDP_EDNS ||
2741 sq->status == serviced_query_UDP ||
2742 sq->status == serviced_query_UDP_EDNS_FRAG ||
2743 sq->status == serviced_query_UDP_EDNS_fallback) {
2744 struct pending* p = (struct pending*)sq->pending;
2746 if(p->pc)
2747 portcomm_loweruse(sq->outnet, p->pc);
2748 pending_delete(sq->outnet, p);
2751 outnet_send_wait_udp(sq->outnet);
2754 sq->pending;
2756 log_assert(!(w->write_wait_queued && w->on_tcp_waiting_list));
2757 /* if on stream-write-waiting list then
2759 if(w->write_wait_queued) {
2761 (struct pending_tcp*)w->next_waiting;
2763 if(!w->in_cb_and_decommission)
2764 reuse_tree_by_id_delete(&pend->reuse, w);
2765 reuse_write_wait_remove(&pend->reuse, w);
2766 if(!w->in_cb_and_decommission)
2768 } else if(!w->on_tcp_waiting_list) {
2770 (struct pending_tcp*)w->next_waiting;
2775 w->cb = NULL;
2777 if(!w->in_cb_and_decommission)
2778 reuse_cb_and_decommission(sq->outnet,
2780 use_free_buffer(sq->outnet);
2782 sq->pending = NULL;
2785 outnet_waiting_tcp_list_remove(sq->outnet, w);
2786 if(!w->in_cb_and_decommission)
2792 serviced_node_del(&sq->node, NULL);
2807 while(lablen--) {
2808 /* only perturb A-Z, a-z */
2821 bits--;
2838 if(addr_is_ip6(&sq->addr, sq->addrlen)) {
2858 if(sq->outnet->use_caps_for_id && !sq->nocaps) {
2859 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
2864 sldns_buffer_write(buff, sq->qbuf, sq->qbuflen);
2874 edns.opt_list_out = sq->opt_list;
2876 edns.udp_size = serviced_query_udp_size(sq, sq->status);
2878 if(sq->dnssec & EDNS_DO)
2880 if(sq->dnssec & BIT_CD)
2882 if (sq->ssl_upstream && sq->padding_block_size) {
2888 edns.padding_block_size = sq->padding_block_size;
2906 time_t now = *sq->outnet->now_secs;
2908 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
2909 sq->zonelen, now, &vs, &edns_lame_known, &rtt))
2911 sq->last_rtt = rtt;
2913 if(sq->status == serviced_initial) {
2914 if(vs != -1) {
2915 sq->status = serviced_query_UDP_EDNS;
2917 sq->status = serviced_query_UDP;
2920 serviced_encode(sq, buff, (sq->status == serviced_query_UDP_EDNS) ||
2921 (sq->status == serviced_query_UDP_EDNS_FRAG));
2922 sq->last_sent_time = *sq->outnet->now_tv;
2923 sq->edns_lame_known = (int)edns_lame_known;
2925 sq->pending = pending_udp_query(sq, buff, rtt,
2927 if(!sq->pending)
2971 /* compare the labels - bitwise identical */
2988 int dobackup = (sq->cblist && sq->cblist->next); /* >1 cb*/
2999 rbtree_delete(sq->outnet->serviced, sq);
3001 sq->to_be_deleted = 1;
3003 if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
3004 !sq->nocaps && sq->qtype != LDNS_RR_TYPE_PTR) {
3009 if(sldns_buffer_read_u16_at(c->buffer, 4) == 0 &&
3010 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
3012 LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
3014 verbose(VERB_DETAIL, "no qname in reply to check 0x20ID");
3016 &sq->addr, sq->addrlen);
3017 log_buf(VERB_DETAIL, "for packet", c->buffer);
3020 } else if(sldns_buffer_read_u16_at(c->buffer, 4) > 0 &&
3021 !serviced_check_qname(c->buffer, sq->qbuf,
3022 sq->qbuflen)) {
3023 verbose(VERB_DETAIL, "wrong 0x20-ID in reply qname");
3025 &sq->addr, sq->addrlen);
3026 log_buf(VERB_DETAIL, "for packet", c->buffer);
3029 pkt_dname_tolower(c->buffer,
3030 sldns_buffer_at(c->buffer, 12));
3032 verbose(VERB_ALGO, "good 0x20-ID in reply qname");
3034 pkt_dname_tolower(c->buffer,
3035 sldns_buffer_at(c->buffer, 12));
3043 backlen = sldns_buffer_limit(c->buffer);
3044 backup_p = regional_alloc_init(sq->region,
3045 sldns_buffer_begin(c->buffer), backlen);
3051 sq->outnet->svcd_overhead = backlen;
3053 /* test the actual sq->cblist, because the next elem could be deleted*/
3054 while((p=sq->cblist) != NULL) {
3055 sq->cblist = p->next; /* remove this element */
3057 sldns_buffer_clear(c->buffer);
3058 sldns_buffer_write(c->buffer, backup_p, backlen);
3059 sldns_buffer_flip(c->buffer);
3061 fptr_ok(fptr_whitelist_serviced_query(p->cb));
3062 (void)(*p->cb)(c, p->cb_arg, error, rep);
3065 sq->outnet->svcd_overhead = 0;
3068 log_assert(sq->cblist == NULL);
3079 struct waiting_tcp* w = (struct waiting_tcp*)sq->pending;
3082 if(w && !w->on_tcp_waiting_list && w->next_waiting) {
3083 pend_tcp = (struct pending_tcp*)w->next_waiting;
3084 pi = pend_tcp->pi;
3087 sq->pending = NULL; /* removed after this callback */
3090 &sq->addr, sq->addrlen);
3092 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
3093 sq->addrlen, sq->zone, sq->zonelen);
3098 if(error==NETEVENT_NOERROR && pi && sq->outnet->dtenv &&
3099 (sq->outnet->dtenv->log_resolver_response_messages ||
3100 sq->outnet->dtenv->log_forwarder_response_messages)) {
3101 log_addr(VERB_ALGO, "response from upstream", &sq->addr, sq->addrlen);
3102 log_addr(VERB_ALGO, "to local addr", &pi->addr, pi->addrlen);
3103 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
3104 &pi->addr, c->type, c->ssl, sq->zone, sq->zonelen, sq->qbuf,
3105 sq->qbuflen, &sq->last_sent_time, sq->outnet->now_tv,
3106 c->buffer);
3109 if(error==NETEVENT_NOERROR && sq->status == serviced_query_TCP_EDNS &&
3110 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
3112 c->buffer)) == LDNS_RCODE_NOTIMPL) ) {
3114 sq->status = serviced_query_TCP_EDNS_fallback;
3115 serviced_tcp_initiate(sq, c->buffer);
3118 sq->status == serviced_query_TCP_EDNS_fallback &&
3119 (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
3121 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NXDOMAIN
3122 || LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
3127 if(!sq->want_dnssec)
3128 if(!infra_edns_update(sq->outnet->infra, &sq->addr,
3129 sq->addrlen, sq->zone, sq->zonelen, -1,
3130 *sq->outnet->now_secs))
3131 log_err("Out of memory caching no edns for host");
3132 sq->status = serviced_query_TCP;
3134 if(sq->tcp_upstream || sq->ssl_upstream) {
3135 struct timeval now = *sq->outnet->now_tv;
3137 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3138 sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
3139 -1, sq->last_rtt, (time_t)now.tv_sec))
3141 } else if(now.tv_sec > sq->last_sent_time.tv_sec ||
3142 (now.tv_sec == sq->last_sent_time.tv_sec &&
3143 now.tv_usec > sq->last_sent_time.tv_usec)) {
3145 int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
3146 + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
3147 verbose(VERB_ALGO, "measured TCP-time at %d msec", roundtime);
3150 * huge due to system-hibernated and we woke up */
3152 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3153 sq->addrlen, sq->zone, sq->zonelen, sq->qtype,
3154 roundtime, sq->last_rtt, (time_t)now.tv_sec))
3165 memcpy(&rep->remote_addr, &sq->addr, sq->addrlen);
3166 rep->remote_addrlen = sq->addrlen;
3175 sq->status==serviced_query_TCP_EDNS?"EDNS":"");
3176 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
3177 sq->last_sent_time = *sq->outnet->now_tv;
3178 log_assert(!sq->busy);
3179 sq->busy = 1;
3180 sq->pending = pending_tcp_query(sq, buff, sq->outnet->tcp_auth_query_timeout,
3182 sq->busy = 0;
3183 if(!sq->pending) {
3197 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
3198 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
3201 sq->last_rtt = rtt;
3202 if(vs != -1)
3203 sq->status = serviced_query_TCP_EDNS;
3204 else sq->status = serviced_query_TCP;
3205 serviced_encode(sq, buff, sq->status == serviced_query_TCP_EDNS);
3206 sq->last_sent_time = *sq->outnet->now_tv;
3207 if(sq->tcp_upstream || sq->ssl_upstream) {
3209 if(rtt >= UNKNOWN_SERVER_NICENESS && rtt < sq->outnet->tcp_auth_query_timeout)
3210 timeout = sq->outnet->tcp_auth_query_timeout;
3212 timeout = sq->outnet->tcp_auth_query_timeout;
3214 log_assert(!sq->busy);
3215 sq->busy = 1;
3216 sq->pending = pending_tcp_query(sq, buff, timeout,
3218 sq->busy = 0;
3219 return sq->pending != NULL;
3242 sldns_buffer_limit(buf)-LDNS_HEADER_SIZE);
3265 struct outside_network* outnet = sq->outnet;
3266 struct timeval now = *sq->outnet->now_tv;
3268 struct pending* p = (struct pending*)sq->pending;
3271 sq->pending = NULL; /* removed after callback */
3273 if(sq->status == serviced_query_UDP_EDNS && sq->last_rtt < 5000 &&
3276 sq->status = serviced_query_UDP_EDNS_FRAG;
3277 log_name_addr(VERB_ALGO, "try edns1xx0", sq->qbuf+10,
3278 &sq->addr, sq->addrlen);
3279 if(!serviced_udp_send(sq, c->buffer)) {
3284 if(sq->status == serviced_query_UDP_EDNS_FRAG) {
3286 sq->status = serviced_query_UDP_EDNS;
3288 sq->retry++;
3289 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3290 sq->zone, sq->zonelen, sq->qtype, -1, sq->last_rtt,
3293 if(sq->retry < OUTBOUND_UDP_RETRY) {
3294 log_name_addr(VERB_ALGO, "retry query", sq->qbuf+10,
3295 &sq->addr, sq->addrlen);
3296 if(!serviced_udp_send(sq, c->buffer)) {
3303 /* udp returns error (due to no ID or interface available) */
3311 if(error == NETEVENT_NOERROR && outnet->dtenv && p->pc &&
3312 (outnet->dtenv->log_resolver_response_messages ||
3313 outnet->dtenv->log_forwarder_response_messages)) {
3314 log_addr(VERB_ALGO, "response from upstream", &sq->addr, sq->addrlen);
3315 log_addr(VERB_ALGO, "to local addr", &p->pc->pif->addr,
3316 p->pc->pif->addrlen);
3317 dt_msg_send_outside_response(outnet->dtenv, &sq->addr,
3318 &p->pc->pif->addr, c->type, c->ssl, sq->zone, sq->zonelen,
3319 sq->qbuf, sq->qbuflen, &sq->last_sent_time,
3320 sq->outnet->now_tv, c->buffer);
3323 if( (sq->status == serviced_query_UDP_EDNS
3324 ||sq->status == serviced_query_UDP_EDNS_FRAG)
3325 && (LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer))
3327 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOTIMPL
3328 || packet_edns_malformed(c->buffer, sq->qtype)
3332 sq->status = serviced_query_UDP_EDNS_fallback;
3333 sq->retry = 0;
3334 if(!serviced_udp_send(sq, c->buffer)) {
3338 } else if(sq->status == serviced_query_UDP_EDNS &&
3339 !sq->edns_lame_known) {
3342 &sq->addr, sq->addrlen);
3343 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3344 sq->zone, sq->zonelen, 0, (time_t)now.tv_sec)) {
3347 sq->edns_lame_known = 1;
3348 } else if(sq->status == serviced_query_UDP_EDNS_fallback &&
3349 !sq->edns_lame_known && (LDNS_RCODE_WIRE(
3350 sldns_buffer_begin(c->buffer)) == LDNS_RCODE_NOERROR ||
3351 LDNS_RCODE_WIRE(sldns_buffer_begin(c->buffer)) ==
3353 c->buffer)) == LDNS_RCODE_YXDOMAIN)) {
3357 if(!sq->want_dnssec) {
3359 &sq->addr, sq->addrlen);
3360 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3361 sq->zone, sq->zonelen, -1, (time_t)now.tv_sec)) {
3362 log_err("Out of memory caching no edns for host");
3366 "not stored because need DNSSEC for", &sq->addr,
3367 sq->addrlen);
3369 sq->status = serviced_query_UDP;
3371 if(now.tv_sec > sq->last_sent_time.tv_sec ||
3372 (now.tv_sec == sq->last_sent_time.tv_sec &&
3373 now.tv_usec > sq->last_sent_time.tv_usec)) {
3375 int roundtime = ((int)(now.tv_sec - sq->last_sent_time.tv_sec))*1000
3376 + ((int)now.tv_usec - (int)sq->last_sent_time.tv_usec)/1000;
3382 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3383 sq->zone, sq->zonelen, sq->qtype, roundtime,
3384 sq->last_rtt, (time_t)now.tv_sec))
3390 if(LDNS_TC_WIRE(sldns_buffer_begin(c->buffer))) {
3393 if(sq->status == serviced_query_UDP_EDNS ||
3394 sq->status == serviced_query_UDP_EDNS_FRAG ||
3395 sq->status == serviced_query_UDP_EDNS_fallback)
3397 sq->status = serviced_query_TCP_EDNS;
3398 else sq->status = serviced_query_TCP;
3399 serviced_tcp_initiate(sq, c->buffer);
3420 struct edns_option* backed_up_opt_list = qstate->edns_opts_back_out;
3429 region = alloc_reg_obtain(env->alloc);
3431 if(qstate->edns_opts_back_out) {
3433 qstate->edns_opts_back_out, region);
3435 alloc_reg_release(env->alloc, region);
3438 qstate->edns_opts_back_out = per_upstream_opt_list;
3443 alloc_reg_release(env->alloc, region);
3448 per_upstream_opt_list = qstate->edns_opts_back_out;
3449 qstate->edns_opts_back_out = backed_up_opt_list;
3452 &env->edns_strings->client_strings, addr, addrlen))) {
3454 env->edns_strings->client_string_opcode,
3455 client_string_addr->string_len,
3456 client_string_addr->string, region);
3459 serviced_gen_query(buff, qinfo->qname, qinfo->qname_len, qinfo->qtype,
3460 qinfo->qclass, flags);
3466 timenow = *env->now;
3467 if(!infra_ratelimit_inc(env->infra_cache, zone,
3468 zonelen, timenow, env->cfg->ratelimit_backoff,
3469 &qstate->qinfo,
3470 qstate->mesh_info->reply_list
3471 ?&qstate->mesh_info->reply_list->query_reply
3474 if(env->cfg->ratelimit_factor == 0 ||
3475 ub_random_max(env->rnd,
3476 env->cfg->ratelimit_factor) != 1) {
3478 alloc_reg_release(env->alloc, region);
3490 addrlen, zone, zonelen, (int)qinfo->qtype,
3492 ( ssl_upstream && env->cfg->pad_queries
3493 ? env->cfg->pad_queries_block_size : 0 ),
3494 env->alloc, region);
3497 infra_ratelimit_dec(env->infra_cache,
3503 sq->region, sizeof(*cb)))) {
3505 infra_ratelimit_dec(env->infra_cache,
3508 (void)rbtree_delete(outnet->serviced, sq);
3509 serviced_node_del(&sq->node, NULL);
3512 /* No network action at this point; it will be invoked with the
3516 alloc_reg_release(env->alloc, region);
3519 * to be doubly-removed (with callbacks perhaps). */
3521 sq->region, sizeof(*cb)))) {
3526 cb->cb = callback;
3527 cb->cb_arg = callback_arg;
3528 cb->next = sq->cblist;
3529 sq->cblist = cb;
3537 struct service_callback** pp = &sq->cblist;
3539 if((*pp)->cb_arg == cb_arg) {
3541 *pp = del->next;
3544 pp = &(*pp)->next;
3554 if(!sq->cblist && !sq->busy && !sq->to_be_deleted) {
3555 (void)rbtree_delete(sq->outnet->serviced, sq);
3571 dscp = outnet->ip_dscp;
3577 int fd = -1;
3581 if(outnet->num_ip6 == 0) {
3584 verbose(VERB_QUERY, "need ipv6 to send, but no ipv6 outgoing interfaces, for %s", to);
3585 return -1;
3587 i = ub_random_max(outnet->rnd, outnet->num_ip6);
3588 pif = &outnet->ip6_ifs[i];
3590 if(outnet->num_ip4 == 0) {
3593 verbose(VERB_QUERY, "need ipv4 to send, but no ipv4 outgoing interfaces, for %s", to);
3594 return -1;
3596 i = ub_random_max(outnet->rnd, outnet->num_ip4);
3597 pif = &outnet->ip4_ifs[i];
3599 addr = &pif->addr;
3600 addrlen = pif->addrlen;
3602 pnum = ub_random_max(outnet->rnd, pif->avail_total);
3603 if(pnum < pif->inuse) {
3605 port = pif->out[pnum]->number;
3608 port = pif->avail_ports[pnum - pif->inuse];
3621 sa->sin_port = (in_port_t)htons((uint16_t)port);
3626 if(fd != -1) {
3630 return -1;
3635 return -1;
3645 if(fd == -1) {
3648 cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff, 0,
3663 cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
3664 if(!cp->ssl) {
3669 comm_point_tcp_win_bio_cb(cp, cp->ssl);
3671 cp->ssl_shake_state = comm_ssl_shake_write;
3674 if(outnet->tls_use_sni) {
3675 (void)SSL_set_tlsext_host_name(cp->ssl, host);
3679 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3690 if(!SSL_set1_host(cp->ssl, host)) {
3698 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3699 X509_VERIFY_PARAM* param = SSL_get0_param(cp->ssl);
3721 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3722 if(fd == -1) {
3730 cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
3736 cp->repinfo.remote_addrlen = to_addrlen;
3737 memcpy(&cp->repinfo.remote_addr, to_addr, to_addrlen);
3750 /* copy scratch buffer to cp->buffer */
3751 sldns_buffer_copy(cp->buffer, query);
3755 /** setup the User-Agent HTTP header based on http-user-agent configuration */
3759 if(cfg->hide_http_user_agent) return;
3760 if(cfg->http_user_agent==NULL || cfg->http_user_agent[0] == 0) {
3761 sldns_buffer_printf(buf, "User-Agent: %s/%s\r\n", PACKAGE_NAME,
3764 sldns_buffer_printf(buf, "User-Agent: %s\r\n", cfg->http_user_agent);
3796 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3797 if(fd == -1) {
3805 cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
3806 outnet->udp_buff);
3812 cp->repinfo.remote_addrlen = to_addrlen;
3813 memcpy(&cp->repinfo.remote_addr, to_addr, to_addrlen);
3827 /* setup http request in cp->buffer */
3828 if(!setup_http_request(cp->buffer, host, path, cfg)) {
3842 s = sizeof(*w) + w->pkt_len;
3843 if(w->timer)
3844 s += comm_timer_get_mem(w->timer);
3856 sizeof(int)*pif->avail_total +
3858 sizeof(struct port_comm*)*pif->maxout;
3859 for(i=0; i<pif->inuse; i++)
3860 s += sizeof(*pif->out[i]) +
3861 comm_point_get_mem(pif->out[i]->cp);
3870 s = sizeof(*w) + comm_timer_get_mem(w->timer) + w->pkt_len;
3882 struct port_comm* pc;
3883 size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
3884 sizeof(*outnet->udp_buff) +
3885 sldns_buffer_capacity(outnet->udp_buff);
3887 for(pc = outnet->unused_fds; pc; pc = pc->next) {
3888 s += sizeof(*pc) + comm_point_get_mem(pc->cp);
3890 for(k=0; k<outnet->num_ip4; k++)
3891 s += if_get_mem(&outnet->ip4_ifs[k]);
3892 for(k=0; k<outnet->num_ip6; k++)
3893 s += if_get_mem(&outnet->ip6_ifs[k]);
3894 for(u=outnet->udp_wait_first; u; u=u->next_waiting)
3897 s += sizeof(struct pending_tcp*)*outnet->num_tcp;
3898 for(i=0; i<outnet->num_tcp; i++) {
3900 s += comm_point_get_mem(outnet->tcp_conns[i]->c);
3901 if(outnet->tcp_conns[i]->query)
3902 s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query);
3904 for(w=outnet->tcp_wait_first; w; w = w->next_waiting)
3906 s += sizeof(*outnet->pending);
3908 outnet->pending->count;
3909 s += sizeof(*outnet->serviced);
3910 s += outnet->svcd_overhead;
3911 RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) {
3912 s += sizeof(*sq) + sq->qbuflen;
3913 for(sb = sq->cblist; sb; sb = sb->next)
3924 s = sizeof(*sq) + sq->qbuflen;
3925 for(sb = sq->cblist; sb; sb = sb->next)
3927 if(sq->status == serviced_query_UDP_EDNS ||
3928 sq->status == serviced_query_UDP ||
3929 sq->status == serviced_query_UDP_EDNS_FRAG ||
3930 sq->status == serviced_query_UDP_EDNS_fallback) {