Lines Matching refs:outnet
90 static uint16_t tcp_select_id(struct outside_network* outnet,
220 num = w->outnet->num_ip6; in pick_outgoing_tcp()
223 num = w->outnet->num_ip4; in pick_outgoing_tcp()
232 pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)]; in pick_outgoing_tcp()
235 pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)]; in pick_outgoing_tcp()
476 reuse_tcp_insert(struct outside_network* outnet, struct pending_tcp* pend_tcp)
487 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
496 if(outnet->tcp_reuse_first) {
497 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
499 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
500 log_assert(outnet->tcp_reuse_first->lru_prev !=
501 outnet->tcp_reuse_first);
504 outnet->tcp_reuse_last = &pend_tcp->reuse;
506 outnet->tcp_reuse_first = &pend_tcp->reuse;
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);
519 reuse_tcp_find(struct outside_network* outnet, struct sockaddr_storage* addr,
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,
559 result = rbtree_first(&outnet->tcp_reuse);
592 outnet->max_reuse_tcp_queries) {
634 struct pending_tcp* pend = w->outnet->tcp_free;
646 if (w->ssl_upstream && !w->outnet->sslctx) {
652 s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss, w->outnet->ip_dscp);
689 if (w->outnet->sslctx && w->ssl_upstream) {
721 if(w->outnet->sslctx && w->ssl_upstream) {
722 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
735 w->outnet->tls_use_sni)) {
746 w->outnet->num_tcp_outgoing++;
747 w->outnet->tcp_free = pend->next_free;
750 pend->reuse.outnet = w->outnet;
764 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
770 (void)reuse_tcp_insert(w->outnet, pend);
780 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
787 (!reuse->lru_prev && outnet->tcp_reuse_first == reuse));
796 else outnet->tcp_reuse_last = reuse->lru_prev;
798 log_assert(outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_next &&
799 outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_prev);
802 reuse->lru_next = outnet->tcp_reuse_first;
803 if(outnet->tcp_reuse_first) {
804 outnet->tcp_reuse_first->lru_prev = reuse;
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));
819 reuse_tcp_lru_snip(struct outside_network* outnet)
821 struct reuse_tcp* reuse = outnet->tcp_reuse_last;
826 outnet->tcp_reuse_last = reuse->lru_prev;
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));
842 outnet_waiting_tcp_list_remove(struct outside_network* outnet, struct waiting_tcp* w)
844 struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
851 else outnet->tcp_wait_first = w->next_waiting;
852 if(outnet->tcp_wait_last == w)
853 outnet->tcp_wait_last = prev;
867 outnet_waiting_tcp_list_pop(struct outside_network* outnet)
869 struct waiting_tcp* w = outnet->tcp_wait_first;
870 if(!outnet->tcp_wait_first) return NULL;
872 outnet->tcp_wait_first = w->next_waiting;
873 if(outnet->tcp_wait_last == w)
874 outnet->tcp_wait_last = NULL;
882 outnet_waiting_tcp_list_add(struct outside_network* outnet,
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;
906 outnet_waiting_tcp_list_add_first(struct outside_network* outnet,
913 w->next_waiting = outnet->tcp_wait_first;
915 if(!outnet->tcp_wait_last)
916 outnet->tcp_wait_last = w;
917 outnet->tcp_wait_first = w;
927 (!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
928 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
944 use_free_buffer(struct outside_network* outnet)
947 while(outnet->tcp_wait_first && !outnet->want_to_quit) {
952 w = outnet_waiting_tcp_list_pop(outnet);
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,
959 w->id = tcp_select_id(outnet, reuse);
967 reuse_tcp_lru_touch(outnet, reuse);
983 } else if(outnet->tcp_free) {
984 struct pending_tcp* pend = w->outnet->tcp_free;
1002 outnet_waiting_tcp_list_add_first(outnet, w, 0);
1006 if(outnet->dtenv && pend_tcp && w && w->sq &&
1007 (outnet->dtenv->log_resolver_query_messages ||
1008 outnet->dtenv->log_forwarder_query_messages)) {
1011 dt_msg_send_outside_query(outnet->dtenv, &w->sq->addr,
1039 reuse_move_writewait_away(struct outside_network* outnet,
1076 outnet_waiting_tcp_list_add(outnet, w, 1);
1087 outnet_waiting_tcp_list_add(outnet, w, 1);
1093 reuse_tcp_remove_tree_list(struct outside_network* outnet,
1099 if(!rbtree_delete(&outnet->tcp_reuse, reuse)) {
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));
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));
1172 decommission_pending_tcp(struct outside_network* outnet,
1178 if(outnet->tcp_free != pend) {
1179 pend->next_free = outnet->tcp_free;
1180 outnet->tcp_free = pend;
1184 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1242 static void reuse_cb_and_decommission(struct outside_network* outnet,
1251 decommission_pending_tcp(outnet, pend);
1284 struct outside_network* outnet = pend->reuse.outnet; local
1302 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1333 reuse_tcp_setup_timeout(pend, outnet->tcp_reuse_timeout);
1338 reuse_move_writewait_away(outnet, pend);
1370 if(outnet->tcp_reuse.count < outnet->tcp_reuse_max) {
1371 (void)reuse_tcp_insert(outnet, pend);
1394 reuse_tcp_setup_read_and_timeout(pend, outnet->tcp_reuse_timeout);
1400 reuse_cb_and_decommission(outnet, pend, (error==NETEVENT_TIMEOUT?
1402 use_free_buffer(outnet);
1408 portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
1426 pc->next = outnet->unused_fds;
1427 outnet->unused_fds = pc;
1432 outnet_send_wait_udp(struct outside_network* outnet)
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);
1449 if(!randomize_and_send_udp(pend, outnet->udp_buff,
1454 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
1457 pending_delete(outnet, pend);
1468 struct outside_network* outnet = (struct outside_network*)arg; local
1492 verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
1493 p = (struct pending*)rbtree_search(outnet->pending, &key);
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;
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;
1534 (void)rbtree_delete(outnet->pending, p->node.key);
1539 portcomm_loweruse(outnet, p->pc);
1541 outnet_send_wait_udp(outnet);
1576 struct outside_network* outnet = p->outnet; local
1578 portcomm_loweruse(outnet, p->pc);
1579 pending_delete(outnet, p);
1580 outnet_send_wait_udp(outnet);
1587 struct outside_network* outnet = p->outnet; local
1598 if(outnet->delayclose && !outnet->udp_wait_first) {
1601 comm_timer_set(p->timer, &outnet->delay_tv);
1604 portcomm_loweruse(outnet, p->pc);
1605 pending_delete(outnet, p);
1606 outnet_send_wait_udp(outnet);
1611 create_pending_tcp(struct outside_network* outnet, size_t bufsize)
1614 if(outnet->num_tcp == 0)
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)
1668 struct outside_network* outnet = (struct outside_network*) local
1671 if(!outnet) {
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;
1713 outside_network_delete(outnet);
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)))) {
1725 outside_network_delete(outnet);
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)))) {
1733 outside_network_delete(outnet);
1737 if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
1738 !(outnet->pending = rbtree_create(pending_cmp)) ||
1739 !(outnet->serviced = rbtree_create(serviced_cmp)) ||
1740 !create_pending_tcp(outnet, bufsize)) {
1742 outside_network_delete(outnet);
1745 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1746 outnet->tcp_reuse_max = num_tcp;
1754 outside_network_delete(outnet);
1757 pc->cp = comm_point_create_udp(outnet->base, -1,
1758 outnet->udp_buff, 0, outnet_udp_cb, outnet, NULL);
1762 outside_network_delete(outnet);
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",
1774 outside_network_delete(outnet);
1777 if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
1780 outside_network_delete(outnet);
1788 if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
1791 outside_network_delete(outnet);
1797 if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
1800 outside_network_delete(outnet);
1807 return outnet;
1815 struct outside_network* outnet = (struct outside_network*)arg; local
1816 pending_delete(outnet, pend);
1831 outside_network_quit_prepare(struct outside_network* outnet)
1833 if(!outnet)
1836 outnet->want_to_quit = 1;
1840 outside_network_delete(struct outside_network* outnet)
1842 if(!outnet)
1844 outnet->want_to_quit = 1;
1846 if(outnet->pending) {
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;
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].
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].
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];
1908 decommission_pending_tcp(outnet, pend);
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;
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;
1937 free(outnet);
1941 pending_delete(struct outside_network* outnet, struct pending* p)
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;
1957 else outnet->udp_wait_first = p->next_waiting;
1958 if(outnet->udp_wait_last == p)
1959 outnet->udp_wait_last = prev;
1962 if(outnet) {
1963 (void)rbtree_delete(outnet->pending, p->node.key);
2029 select_id(struct outside_network* outnet, struct pending* pend,
2033 pend->id = GET_RANDOM_ID(outnet->rnd);
2038 while(!rbtree_insert(outnet->pending, &pend->node)) {
2040 pend->id = GET_RANDOM_ID(outnet->rnd);
2097 select_ifport(struct outside_network* outnet, struct pending* pend,
2108 log_assert(outnet->unused_fds);
2111 my_if = ub_random_max(outnet->rnd, num_if);
2114 if(outnet->udp_connect) {
2123 my_port = pif->inuse + ub_random_max(outnet->rnd,
2126 my_port = ub_random_max(outnet->rnd, pif->avail_total);
2142 portno, &inuse, outnet->rnd, outnet->ip_dscp);
2150 if(outnet->udp_connect) {
2165 pend->pc = outnet->unused_fds;
2166 outnet->unused_fds = pend->pc->next;
2203 struct outside_network* outnet = pend->sq->outnet; local
2206 if(!select_id(outnet, pend, packet)) {
2212 if(!select_ifport(outnet, pend,
2213 outnet->num_ip6, outnet->ip6_ifs))
2216 if(!select_ifport(outnet, pend,
2217 outnet->num_ip4, outnet->ip4_ifs))
2224 (struct sockaddr*)&pend->addr, pend->addrlen, outnet->udp_connect)) {
2225 portcomm_loweruse(outnet, pend->pc);
2228 outnet->num_udp_outgoing++;
2246 if(outnet->dtenv &&
2247 (outnet->dtenv->log_resolver_query_messages ||
2248 outnet->dtenv->log_forwarder_query_messages)) {
2251 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, &pend->pc->pif->addr, comm_udp, NULL,
2264 pend->outnet = sq->outnet;
2271 pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
2278 if(sq->outnet->unused_fds == NULL) {
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;
2301 pending_delete(sq->outnet, pend);
2312 struct outside_network* outnet = w->outnet; local
2316 outnet_waiting_tcp_list_remove(outnet, w);
2322 reuse_cb_and_decommission(outnet, pend, NETEVENT_TIMEOUT);
2324 use_free_buffer(outnet);
2330 reuse_tcp_close_oldest(struct outside_network* outnet)
2334 reuse = reuse_tcp_lru_snip(outnet);
2337 reuse_cb_and_decommission(outnet, reuse->pending, NETEVENT_CLOSED);
2341 tcp_select_id(struct outside_network* outnet, struct reuse_tcp* reuse)
2344 return reuse_tcp_select_id(reuse, outnet);
2345 return GET_RANDOM_ID(outnet->rnd);
2351 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2361 id = GET_RANDOM_ID(outnet->rnd);
2367 id = GET_RANDOM_ID(outnet->rnd);
2377 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2422 struct pending_tcp* pend = sq->outnet->tcp_free;
2434 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2440 reuse_tcp_lru_touch(sq->outnet, reuse);
2449 reuse_tcp_close_oldest(sq->outnet);
2450 pend = sq->outnet->tcp_free;
2460 if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
2467 w->id = tcp_select_id(sq->outnet, reuse);
2471 w->outnet = sq->outnet;
2524 if(sq->outnet->dtenv &&
2525 (sq->outnet->dtenv->log_resolver_query_messages ||
2526 sq->outnet->dtenv->log_forwarder_query_messages)) {
2530 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
2543 outnet_waiting_tcp_list_add(sq->outnet, w, 1);
2568 lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2579 key.outnet = outnet;
2581 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
2588 struct outside_network* outnet = sq->outnet; local
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))
2612 serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2666 sq->timer = comm_timer_create(outnet->base, serviced_timer_cb, sq);
2674 sq->outnet = outnet;
2686 rbtree_insert(outnet->serviced, &sq->node);
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);
2747 portcomm_loweruse(sq->outnet, p->pc);
2748 pending_delete(sq->outnet, p);
2751 outnet_send_wait_udp(sq->outnet);
2778 reuse_cb_and_decommission(sq->outnet,
2780 use_free_buffer(sq->outnet);
2785 outnet_waiting_tcp_list_remove(sq->outnet, w);
2858 if(sq->outnet->use_caps_for_id && !sq->nocaps) {
2859 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
2906 time_t now = *sq->outnet->now_secs;
2908 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
2922 sq->last_sent_time = *sq->outnet->now_tv;
2999 rbtree_delete(sq->outnet->serviced, sq);
3003 if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
3051 sq->outnet->svcd_overhead = backlen;
3065 sq->outnet->svcd_overhead = 0;
3092 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
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)) {
3103 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
3105 sq->qbuflen, &sq->last_sent_time, sq->outnet->now_tv,
3128 if(!infra_edns_update(sq->outnet->infra, &sq->addr,
3130 *sq->outnet->now_secs))
3135 struct timeval now = *sq->outnet->now_tv;
3137 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3152 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3177 sq->last_sent_time = *sq->outnet->now_tv;
3180 sq->pending = pending_tcp_query(sq, buff, sq->outnet->tcp_auth_query_timeout,
3197 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
3198 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
3206 sq->last_sent_time = *sq->outnet->now_tv;
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;
3265 struct outside_network* outnet = sq->outnet; local
3266 struct timeval now = *sq->outnet->now_tv;
3289 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3311 if(error == NETEVENT_NOERROR && outnet->dtenv && p->pc &&
3312 (outnet->dtenv->log_resolver_response_messages ||
3313 outnet->dtenv->log_forwarder_response_messages)) {
3317 dt_msg_send_outside_response(outnet->dtenv, &sq->addr,
3320 sq->outnet->now_tv, c->buffer);
3343 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3360 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3382 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3408 outnet_serviced_query(struct outside_network* outnet,
3461 sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen,
3488 sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
3508 (void)rbtree_delete(outnet->serviced, sq);
3555 (void)rbtree_delete(sq->outnet->serviced, sq);
3562 fd_for_dest(struct outside_network* outnet, struct sockaddr_storage* to_addr,
3571 dscp = outnet->ip_dscp;
3581 if(outnet->num_ip6 == 0) {
3587 i = ub_random_max(outnet->rnd, outnet->num_ip6);
3588 pif = &outnet->ip6_ifs[i];
3590 if(outnet->num_ip4 == 0) {
3596 i = ub_random_max(outnet->rnd, outnet->num_ip4);
3597 pif = &outnet->ip4_ifs[i];
3602 pnum = ub_random_max(outnet->rnd, pif->avail_total);
3639 outnet_comm_point_for_udp(struct outside_network* outnet,
3644 int fd = fd_for_dest(outnet, to_addr, to_addrlen);
3648 cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff, 0,
3660 setup_comm_ssl(struct comm_point* cp, struct outside_network* outnet,
3663 cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
3674 if(outnet->tls_use_sni) {
3679 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3698 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3715 outnet_comm_point_for_tcp(struct outside_network* outnet,
3721 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3730 cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
3741 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3789 outnet_comm_point_for_http(struct outside_network* outnet,
3796 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3805 cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
3806 outnet->udp_buff);
3817 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3874 size_t outnet_get_mem(struct outside_network* outnet)
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) {
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) {