Lines Matching refs:outnet
90 static uint16_t tcp_select_id(struct outside_network* outnet,
220 num = w->outnet->num_ip6;
223 num = w->outnet->num_ip4;
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)];
490 reuse_tcp_insert(struct outside_network* outnet, struct pending_tcp* pend_tcp)
501 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
510 if(outnet->tcp_reuse_first) {
511 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
513 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
514 log_assert(outnet->tcp_reuse_first->lru_prev !=
515 outnet->tcp_reuse_first);
518 outnet->tcp_reuse_last = &pend_tcp->reuse;
520 outnet->tcp_reuse_first = &pend_tcp->reuse;
522 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
523 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
524 log_assert(outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_next &&
525 outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_prev);
526 log_assert(outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_next &&
527 outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_prev);
533 reuse_tcp_find(struct outside_network* outnet, struct sockaddr_storage* addr,
556 (unsigned)outnet->tcp_reuse.count);
557 if(outnet->tcp_reuse.root == NULL ||
558 outnet->tcp_reuse.root == RBTREE_NULL)
560 if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
573 result = rbtree_first(&outnet->tcp_reuse);
606 outnet->max_reuse_tcp_queries) {
648 struct pending_tcp* pend = w->outnet->tcp_free;
660 if (w->ssl_upstream && !w->outnet->sslctx) {
666 s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss,
667 w->outnet->ip_dscp, w->ssl_upstream);
704 if (w->outnet->sslctx && w->ssl_upstream) {
736 if(w->outnet->sslctx && w->ssl_upstream) {
737 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
750 w->outnet->tls_use_sni)) {
761 w->outnet->num_tcp_outgoing++;
762 w->outnet->tcp_free = pend->next_free;
765 pend->reuse.outnet = w->outnet;
779 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
785 (void)reuse_tcp_insert(w->outnet, pend);
795 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
802 (!reuse->lru_prev && outnet->tcp_reuse_first == reuse));
811 else outnet->tcp_reuse_last = reuse->lru_prev;
813 log_assert(outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_next &&
814 outnet->tcp_reuse_last != outnet->tcp_reuse_last->lru_prev);
817 reuse->lru_next = outnet->tcp_reuse_first;
818 if(outnet->tcp_reuse_first) {
819 outnet->tcp_reuse_first->lru_prev = reuse;
824 * the list, so outnet->tcp_reuse_last does not need to be modified */
825 outnet->tcp_reuse_first = reuse;
826 log_assert(outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_next &&
827 outnet->tcp_reuse_first != outnet->tcp_reuse_first->lru_prev);
828 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
829 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
834 reuse_tcp_lru_snip(struct outside_network* outnet)
836 struct reuse_tcp* reuse = outnet->tcp_reuse_last;
841 outnet->tcp_reuse_last = reuse->lru_prev;
844 outnet->tcp_reuse_last = NULL;
845 outnet->tcp_reuse_first = NULL;
847 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
848 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
855 /** remove waiting tcp from the outnet waiting list */
857 outnet_waiting_tcp_list_remove(struct outside_network* outnet, struct waiting_tcp* w)
859 struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
866 else outnet->tcp_wait_first = w->next_waiting;
867 if(outnet->tcp_wait_last == w)
868 outnet->tcp_wait_last = prev;
880 /** pop the first waiting tcp from the outnet waiting list */
882 outnet_waiting_tcp_list_pop(struct outside_network* outnet)
884 struct waiting_tcp* w = outnet->tcp_wait_first;
885 if(!outnet->tcp_wait_first) return NULL;
887 outnet->tcp_wait_first = w->next_waiting;
888 if(outnet->tcp_wait_last == w)
889 outnet->tcp_wait_last = NULL;
895 /** add waiting_tcp element to the outnet tcp waiting list */
897 outnet_waiting_tcp_list_add(struct outside_network* outnet,
905 if(outnet->tcp_wait_last)
906 outnet->tcp_wait_last->next_waiting = w;
907 else outnet->tcp_wait_first = w;
908 outnet->tcp_wait_last = w;
919 /** add waiting_tcp element as first to the outnet tcp waiting list */
921 outnet_waiting_tcp_list_add_first(struct outside_network* outnet,
928 w->next_waiting = outnet->tcp_wait_first;
930 if(!outnet->tcp_wait_last)
931 outnet->tcp_wait_last = w;
932 outnet->tcp_wait_first = w;
942 (!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
943 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
959 use_free_buffer(struct outside_network* outnet)
962 while(outnet->tcp_wait_first && !outnet->want_to_quit) {
967 w = outnet_waiting_tcp_list_pop(outnet);
969 (!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
970 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
971 reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
974 w->id = tcp_select_id(outnet, reuse);
982 reuse_tcp_lru_touch(outnet, reuse);
998 } else if(outnet->tcp_free) {
999 struct pending_tcp* pend = w->outnet->tcp_free;
1017 outnet_waiting_tcp_list_add_first(outnet, w, 0);
1021 if(outnet->dtenv && pend_tcp && w && w->sq &&
1022 (outnet->dtenv->log_resolver_query_messages ||
1023 outnet->dtenv->log_forwarder_query_messages)) {
1026 dt_msg_send_outside_query(outnet->dtenv, &w->sq->addr,
1054 reuse_move_writewait_away(struct outside_network* outnet,
1091 outnet_waiting_tcp_list_add(outnet, w, 1);
1102 outnet_waiting_tcp_list_add(outnet, w, 1);
1108 reuse_tcp_remove_tree_list(struct outside_network* outnet,
1114 if(!rbtree_delete(&outnet->tcp_reuse, reuse)) {
1136 outnet->tcp_reuse_first = reuse->lru_next;
1137 log_assert(!outnet->tcp_reuse_first ||
1138 (outnet->tcp_reuse_first !=
1139 outnet->tcp_reuse_first->lru_next &&
1140 outnet->tcp_reuse_first !=
1141 outnet->tcp_reuse_first->lru_prev));
1151 outnet->tcp_reuse_last = reuse->lru_prev;
1152 log_assert(!outnet->tcp_reuse_last ||
1153 (outnet->tcp_reuse_last !=
1154 outnet->tcp_reuse_last->lru_next &&
1155 outnet->tcp_reuse_last !=
1156 outnet->tcp_reuse_last->lru_prev));
1158 log_assert((!outnet->tcp_reuse_first && !outnet->tcp_reuse_last) ||
1159 (outnet->tcp_reuse_first && outnet->tcp_reuse_last));
1187 decommission_pending_tcp(struct outside_network* outnet,
1193 if(outnet->tcp_free != pend) {
1194 pend->next_free = outnet->tcp_free;
1195 outnet->tcp_free = pend;
1199 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1201 /* free SSL structure after remove from outnet tcp reuse tree,
1257 static void reuse_cb_and_decommission(struct outside_network* outnet,
1266 decommission_pending_tcp(outnet, pend);
1299 struct outside_network* outnet = pend->reuse.outnet;
1317 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1320 verbose(VERB_ALGO, "outnet tcp pkt was written event");
1331 verbose(VERB_ALGO, "outnet tcp setup next pkt");
1342 verbose(VERB_ALGO, "outnet tcp writes done, wait");
1348 reuse_tcp_setup_timeout(pend, outnet->tcp_reuse_timeout);
1353 reuse_move_writewait_away(outnet, pend);
1385 if(outnet->tcp_reuse.count < outnet->tcp_reuse_max) {
1386 (void)reuse_tcp_insert(outnet, pend);
1393 verbose(VERB_CLIENT, "outnet tcp callback query err %d buflen %d",
1409 reuse_tcp_setup_read_and_timeout(pend, outnet->tcp_reuse_timeout);
1415 reuse_cb_and_decommission(outnet, pend, (error==NETEVENT_TIMEOUT?
1417 use_free_buffer(outnet);
1423 portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
1441 pc->next = outnet->unused_fds;
1442 outnet->unused_fds = pc;
1447 outnet_send_wait_udp(struct outside_network* outnet)
1451 while(outnet->udp_wait_first && outnet->unused_fds
1452 && !outnet->want_to_quit) {
1453 pend = outnet->udp_wait_first;
1454 outnet->udp_wait_first = pend->next_waiting;
1455 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
1456 sldns_buffer_clear(outnet->udp_buff);
1457 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
1458 sldns_buffer_flip(outnet->udp_buff);
1464 if(!randomize_and_send_udp(pend, outnet->udp_buff,
1469 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
1472 pending_delete(outnet, pend);
1483 struct outside_network* outnet = (struct outside_network*)arg;
1507 verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
1508 p = (struct pending*)rbtree_search(outnet->pending, &key);
1512 outnet->unwanted_replies++;
1513 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1514 >= outnet->unwanted_threshold) {
1518 (unsigned)outnet->unwanted_threshold);
1520 outnet->unwanted_action));
1521 (*outnet->unwanted_action)(outnet->unwanted_param);
1522 outnet->unwanted_total = 0;
1532 outnet->unwanted_replies++;
1533 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1534 >= outnet->unwanted_threshold) {
1538 (unsigned)outnet->unwanted_threshold);
1540 outnet->unwanted_action));
1541 (*outnet->unwanted_action)(outnet->unwanted_param);
1542 outnet->unwanted_total = 0;
1547 verbose(VERB_ALGO, "outnet handle udp reply");
1549 (void)rbtree_delete(outnet->pending, p->node.key);
1554 portcomm_loweruse(outnet, p->pc);
1556 outnet_send_wait_udp(outnet);
1591 struct outside_network* outnet = p->outnet;
1593 portcomm_loweruse(outnet, p->pc);
1594 pending_delete(outnet, p);
1595 outnet_send_wait_udp(outnet);
1602 struct outside_network* outnet = p->outnet;
1613 if(outnet->delayclose && !outnet->udp_wait_first) {
1616 comm_timer_set(p->timer, &outnet->delay_tv);
1619 portcomm_loweruse(outnet, p->pc);
1620 pending_delete(outnet, p);
1621 outnet_send_wait_udp(outnet);
1626 create_pending_tcp(struct outside_network* outnet, size_t bufsize)
1629 if(outnet->num_tcp == 0)
1631 if(!(outnet->tcp_conns = (struct pending_tcp **)calloc(
1632 outnet->num_tcp, sizeof(struct pending_tcp*))))
1634 for(i=0; i<outnet->num_tcp; i++) {
1635 if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1,
1638 outnet->tcp_conns[i]->next_free = outnet->tcp_free;
1639 outnet->tcp_free = outnet->tcp_conns[i];
1640 outnet->tcp_conns[i]->c = comm_point_create_tcp_out(
1641 outnet->base, bufsize, outnet_tcp_cb,
1642 outnet->tcp_conns[i]);
1643 if(!outnet->tcp_conns[i]->c)
1683 struct outside_network* outnet = (struct outside_network*)
1686 if(!outnet) {
1690 comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
1691 outnet->base = base;
1692 outnet->num_tcp = num_tcp;
1693 outnet->max_reuse_tcp_queries = max_reuse_tcp_queries;
1694 outnet->tcp_reuse_timeout= tcp_reuse_timeout;
1695 outnet->tcp_auth_query_timeout = tcp_auth_query_timeout;
1696 outnet->num_tcp_outgoing = 0;
1697 outnet->num_udp_outgoing = 0;
1698 outnet->infra = infra;
1699 outnet->rnd = rnd;
1700 outnet->sslctx = sslctx;
1701 outnet->tls_use_sni = tls_use_sni;
1703 outnet->dtenv = dtenv;
1707 outnet->svcd_overhead = 0;
1708 outnet->want_to_quit = 0;
1709 outnet->unwanted_threshold = unwanted_threshold;
1710 outnet->unwanted_action = unwanted_action;
1711 outnet->unwanted_param = unwanted_param;
1712 outnet->use_caps_for_id = use_caps_for_id;
1713 outnet->do_udp = do_udp;
1714 outnet->tcp_mss = tcp_mss;
1715 outnet->ip_dscp = dscp;
1718 outnet->delayclose = 1;
1719 outnet->delay_tv.tv_sec = delayclose/1000;
1720 outnet->delay_tv.tv_usec = (delayclose%1000)*1000;
1724 outnet->udp_connect = 1;
1728 outside_network_delete(outnet);
1735 &outnet->num_ip4, &outnet->num_ip6);
1736 if(outnet->num_ip4 != 0) {
1737 if(!(outnet->ip4_ifs = (struct port_if*)calloc(
1738 (size_t)outnet->num_ip4, sizeof(struct port_if)))) {
1740 outside_network_delete(outnet);
1744 if(outnet->num_ip6 != 0) {
1745 if(!(outnet->ip6_ifs = (struct port_if*)calloc(
1746 (size_t)outnet->num_ip6, sizeof(struct port_if)))) {
1748 outside_network_delete(outnet);
1752 if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
1753 !(outnet->pending = rbtree_create(pending_cmp)) ||
1754 !(outnet->serviced = rbtree_create(serviced_cmp)) ||
1755 !create_pending_tcp(outnet, bufsize)) {
1757 outside_network_delete(outnet);
1760 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1761 outnet->tcp_reuse_max = num_tcp;
1769 outside_network_delete(outnet);
1772 pc->cp = comm_point_create_udp(outnet->base, -1,
1773 outnet->udp_buff, 0, outnet_udp_cb, outnet, NULL);
1777 outside_network_delete(outnet);
1780 pc->next = outnet->unused_fds;
1781 outnet->unused_fds = pc;
1786 if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0",
1789 outside_network_delete(outnet);
1792 if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
1795 outside_network_delete(outnet);
1803 if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
1806 outside_network_delete(outnet);
1812 if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
1815 outside_network_delete(outnet);
1822 return outnet;
1830 struct outside_network* outnet = (struct outside_network*)arg;
1831 pending_delete(outnet, pend);
1846 outside_network_quit_prepare(struct outside_network* outnet)
1848 if(!outnet)
1851 outnet->want_to_quit = 1;
1855 outside_network_delete(struct outside_network* outnet)
1857 if(!outnet)
1859 outnet->want_to_quit = 1;
1861 if(outnet->pending) {
1863 traverse_postorder(outnet->pending, pending_node_del, NULL);
1864 free(outnet->pending);
1866 if(outnet->serviced) {
1867 traverse_postorder(outnet->serviced, serviced_node_del, NULL);
1868 free(outnet->serviced);
1870 if(outnet->udp_buff)
1871 sldns_buffer_free(outnet->udp_buff);
1872 if(outnet->unused_fds) {
1873 struct port_comm* p = outnet->unused_fds, *np;
1880 outnet->unused_fds = NULL;
1882 if(outnet->ip4_ifs) {
1884 for(i=0; i<outnet->num_ip4; i++) {
1885 for(k=0; k<outnet->ip4_ifs[i].inuse; k++) {
1886 struct port_comm* pc = outnet->ip4_ifs[i].
1892 free(outnet->ip4_ifs[i].avail_ports);
1894 free(outnet->ip4_ifs[i].out);
1896 free(outnet->ip4_ifs);
1898 if(outnet->ip6_ifs) {
1900 for(i=0; i<outnet->num_ip6; i++) {
1901 for(k=0; k<outnet->ip6_ifs[i].inuse; k++) {
1902 struct port_comm* pc = outnet->ip6_ifs[i].
1908 free(outnet->ip6_ifs[i].avail_ports);
1910 free(outnet->ip6_ifs[i].out);
1912 free(outnet->ip6_ifs);
1914 if(outnet->tcp_conns) {
1916 for(i=0; i<outnet->num_tcp; i++)
1917 if(outnet->tcp_conns[i]) {
1919 pend = outnet->tcp_conns[i];
1923 decommission_pending_tcp(outnet, pend);
1925 comm_point_delete(outnet->tcp_conns[i]->c);
1926 free(outnet->tcp_conns[i]);
1927 outnet->tcp_conns[i] = NULL;
1929 free(outnet->tcp_conns);
1930 outnet->tcp_conns = NULL;
1932 if(outnet->tcp_wait_first) {
1933 struct waiting_tcp* p = outnet->tcp_wait_first, *np;
1941 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1942 outnet->tcp_reuse_first = NULL;
1943 outnet->tcp_reuse_last = NULL;
1944 if(outnet->udp_wait_first) {
1945 struct pending* p = outnet->udp_wait_first, *np;
1952 free(outnet);
1956 pending_delete(struct outside_network* outnet, struct pending* p)
1960 if(outnet && outnet->udp_wait_first &&
1961 (p->next_waiting || p == outnet->udp_wait_last) ) {
1963 struct pending* prev = NULL, *x = outnet->udp_wait_first;
1972 else outnet->udp_wait_first = p->next_waiting;
1973 if(outnet->udp_wait_last == p)
1974 outnet->udp_wait_last = prev;
1977 if(outnet) {
1978 (void)rbtree_delete(outnet->pending, p->node.key);
2044 select_id(struct outside_network* outnet, struct pending* pend,
2048 pend->id = GET_RANDOM_ID(outnet->rnd);
2053 while(!rbtree_insert(outnet->pending, &pend->node)) {
2055 pend->id = GET_RANDOM_ID(outnet->rnd);
2112 select_ifport(struct outside_network* outnet, struct pending* pend,
2123 log_assert(outnet->unused_fds);
2126 my_if = ub_random_max(outnet->rnd, num_if);
2129 if(outnet->udp_connect) {
2138 my_port = pif->inuse + ub_random_max(outnet->rnd,
2141 my_port = ub_random_max(outnet->rnd, pif->avail_total);
2157 portno, &inuse, outnet->rnd, outnet->ip_dscp);
2165 if(outnet->udp_connect) {
2180 pend->pc = outnet->unused_fds;
2181 outnet->unused_fds = pend->pc->next;
2218 struct outside_network* outnet = pend->sq->outnet;
2221 if(!select_id(outnet, pend, packet)) {
2227 if(!select_ifport(outnet, pend,
2228 outnet->num_ip6, outnet->ip6_ifs))
2231 if(!select_ifport(outnet, pend,
2232 outnet->num_ip4, outnet->ip4_ifs))
2239 (struct sockaddr*)&pend->addr, pend->addrlen, outnet->udp_connect)) {
2240 portcomm_loweruse(outnet, pend->pc);
2243 outnet->num_udp_outgoing++;
2261 if(outnet->dtenv &&
2262 (outnet->dtenv->log_resolver_query_messages ||
2263 outnet->dtenv->log_forwarder_query_messages)) {
2266 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, &pend->pc->pif->addr, comm_udp, NULL,
2279 pend->outnet = sq->outnet;
2286 pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
2293 if(sq->outnet->unused_fds == NULL) {
2306 if(sq->outnet->udp_wait_last)
2307 sq->outnet->udp_wait_last->next_waiting = pend;
2309 sq->outnet->udp_wait_first = pend;
2310 sq->outnet->udp_wait_last = pend;
2316 pending_delete(sq->outnet, pend);
2327 struct outside_network* outnet = w->outnet;
2331 outnet_waiting_tcp_list_remove(outnet, w);
2337 reuse_cb_and_decommission(outnet, pend, NETEVENT_TIMEOUT);
2339 use_free_buffer(outnet);
2345 reuse_tcp_close_oldest(struct outside_network* outnet)
2349 reuse = reuse_tcp_lru_snip(outnet);
2352 reuse_cb_and_decommission(outnet, reuse->pending, NETEVENT_CLOSED);
2356 tcp_select_id(struct outside_network* outnet, struct reuse_tcp* reuse)
2359 return reuse_tcp_select_id(reuse, outnet);
2360 return GET_RANDOM_ID(outnet->rnd);
2366 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2376 id = GET_RANDOM_ID(outnet->rnd);
2382 id = GET_RANDOM_ID(outnet->rnd);
2392 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2437 struct pending_tcp* pend = sq->outnet->tcp_free;
2449 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2455 reuse_tcp_lru_touch(sq->outnet, reuse);
2464 reuse_tcp_close_oldest(sq->outnet);
2465 pend = sq->outnet->tcp_free;
2475 if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
2482 w->id = tcp_select_id(sq->outnet, reuse);
2486 w->outnet = sq->outnet;
2539 if(sq->outnet->dtenv &&
2540 (sq->outnet->dtenv->log_resolver_query_messages ||
2541 sq->outnet->dtenv->log_forwarder_query_messages)) {
2545 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
2558 outnet_waiting_tcp_list_add(sq->outnet, w, 1);
2583 lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2594 key.outnet = outnet;
2596 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
2603 struct outside_network* outnet = sq->outnet;
2610 if(outnet->do_udp && !(sq->tcp_upstream || sq->ssl_upstream)) {
2611 if(!serviced_udp_send(sq, outnet->udp_buff))
2614 if(!serviced_tcp_send(sq, outnet->udp_buff))
2627 serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2681 sq->timer = comm_timer_create(outnet->base, serviced_timer_cb, sq);
2689 sq->outnet = outnet;
2701 rbtree_insert(outnet->serviced, &sq->node);
2735 if(pend_tcp->c->fd != -1 && sq->outnet->tcp_reuse.count <
2736 sq->outnet->tcp_reuse_max) {
2739 if(!reuse_tcp_insert(sq->outnet, pend_tcp)) {
2742 reuse_tcp_setup_timeout(pend_tcp, sq->outnet->tcp_reuse_timeout);
2762 portcomm_loweruse(sq->outnet, p->pc);
2763 pending_delete(sq->outnet, p);
2766 outnet_send_wait_udp(sq->outnet);
2793 reuse_cb_and_decommission(sq->outnet,
2795 use_free_buffer(sq->outnet);
2800 outnet_waiting_tcp_list_remove(sq->outnet, w);
2873 if(sq->outnet->use_caps_for_id && !sq->nocaps) {
2874 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
2921 time_t now = *sq->outnet->now_secs;
2923 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
2937 sq->last_sent_time = *sq->outnet->now_tv;
3014 rbtree_delete(sq->outnet->serviced, sq);
3018 if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
3066 sq->outnet->svcd_overhead = backlen;
3080 sq->outnet->svcd_overhead = 0;
3107 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
3113 if(error==NETEVENT_NOERROR && pi && sq->outnet->dtenv &&
3114 (sq->outnet->dtenv->log_resolver_response_messages ||
3115 sq->outnet->dtenv->log_forwarder_response_messages)) {
3118 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
3120 sq->qbuflen, &sq->last_sent_time, sq->outnet->now_tv,
3143 if(!infra_edns_update(sq->outnet->infra, &sq->addr,
3145 *sq->outnet->now_secs))
3150 struct timeval now = *sq->outnet->now_tv;
3152 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3167 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
3192 sq->last_sent_time = *sq->outnet->now_tv;
3195 sq->pending = pending_tcp_query(sq, buff, sq->outnet->tcp_auth_query_timeout,
3212 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
3213 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
3221 sq->last_sent_time = *sq->outnet->now_tv;
3224 if(rtt >= UNKNOWN_SERVER_NICENESS && rtt < sq->outnet->tcp_auth_query_timeout)
3225 timeout = sq->outnet->tcp_auth_query_timeout;
3227 timeout = sq->outnet->tcp_auth_query_timeout;
3280 struct outside_network* outnet = sq->outnet;
3281 struct timeval now = *sq->outnet->now_tv;
3304 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3326 if(error == NETEVENT_NOERROR && outnet->dtenv && p->pc &&
3327 (outnet->dtenv->log_resolver_response_messages ||
3328 outnet->dtenv->log_forwarder_response_messages)) {
3332 dt_msg_send_outside_response(outnet->dtenv, &sq->addr,
3335 sq->outnet->now_tv, c->buffer);
3358 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3375 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
3397 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3423 outnet_serviced_query(struct outside_network* outnet,
3476 sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen,
3503 sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
3523 (void)rbtree_delete(outnet->serviced, sq);
3570 (void)rbtree_delete(sq->outnet->serviced, sq);
3577 fd_for_dest(struct outside_network* outnet, struct sockaddr_storage* to_addr,
3586 dscp = outnet->ip_dscp;
3596 if(outnet->num_ip6 == 0) {
3602 i = ub_random_max(outnet->rnd, outnet->num_ip6);
3603 pif = &outnet->ip6_ifs[i];
3605 if(outnet->num_ip4 == 0) {
3611 i = ub_random_max(outnet->rnd, outnet->num_ip4);
3612 pif = &outnet->ip4_ifs[i];
3617 pnum = ub_random_max(outnet->rnd, pif->avail_total);
3654 outnet_comm_point_for_udp(struct outside_network* outnet,
3659 int fd = fd_for_dest(outnet, to_addr, to_addrlen);
3663 cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff, 0,
3675 setup_comm_ssl(struct comm_point* cp, struct outside_network* outnet,
3678 cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
3689 if(outnet->tls_use_sni) {
3694 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3713 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3730 outnet_comm_point_for_tcp(struct outside_network* outnet,
3736 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss,
3737 outnet->ip_dscp, ssl);
3746 cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
3757 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3805 outnet_comm_point_for_http(struct outside_network* outnet,
3812 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss,
3813 outnet->ip_dscp, ssl);
3822 cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
3823 outnet->udp_buff);
3834 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3891 size_t outnet_get_mem(struct outside_network* outnet)
3900 size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
3901 sizeof(*outnet->udp_buff) +
3902 sldns_buffer_capacity(outnet->udp_buff);
3904 for(pc = outnet->unused_fds; pc; pc = pc->next) {
3907 for(k=0; k<outnet->num_ip4; k++)
3908 s += if_get_mem(&outnet->ip4_ifs[k]);
3909 for(k=0; k<outnet->num_ip6; k++)
3910 s += if_get_mem(&outnet->ip6_ifs[k]);
3911 for(u=outnet->udp_wait_first; u; u=u->next_waiting)
3914 s += sizeof(struct pending_tcp*)*outnet->num_tcp;
3915 for(i=0; i<outnet->num_tcp; i++) {
3917 s += comm_point_get_mem(outnet->tcp_conns[i]->c);
3918 if(outnet->tcp_conns[i]->query)
3919 s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query);
3921 for(w=outnet->tcp_wait_first; w; w = w->next_waiting)
3923 s += sizeof(*outnet->pending);
3925 outnet->pending->count;
3926 s += sizeof(*outnet->serviced);
3927 s += outnet->svcd_overhead;
3928 RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) {