Lines Matching refs:outnet
89 /** remove waiting tcp from the outnet waiting list */
90 static void waiting_list_remove(struct outside_network* outnet,
94 static void reuse_tcp_remove_tree_list(struct outside_network* outnet,
212 num = w->outnet->num_ip6;
215 num = w->outnet->num_ip4;
224 pi = &w->outnet->ip6_ifs[ub_random_max(w->outnet->rnd, num)];
227 pi = &w->outnet->ip4_ifs[ub_random_max(w->outnet->rnd, num)];
428 reuse_tcp_insert(struct outside_network* outnet, struct pending_tcp* pend_tcp)
438 if(!rbtree_insert(&outnet->tcp_reuse, &pend_tcp->reuse.node)) {
446 if(outnet->tcp_reuse_first) {
447 pend_tcp->reuse.lru_next = outnet->tcp_reuse_first;
448 outnet->tcp_reuse_first->lru_prev = &pend_tcp->reuse;
451 outnet->tcp_reuse_last = &pend_tcp->reuse;
453 outnet->tcp_reuse_first = &pend_tcp->reuse;
460 reuse_tcp_find(struct outside_network* outnet, struct sockaddr_storage* addr,
483 (unsigned)outnet->tcp_reuse.count);
484 if(outnet->tcp_reuse.root == NULL ||
485 outnet->tcp_reuse.root == RBTREE_NULL)
487 if(rbtree_find_less_equal(&outnet->tcp_reuse, &key_p.reuse,
556 struct pending_tcp* pend = w->outnet->tcp_free;
565 s = outnet_get_tcp_fd(&w->addr, w->addrlen, w->outnet->tcp_mss, w->outnet->ip_dscp);
602 if (w->outnet->sslctx && w->ssl_upstream) {
634 if(w->outnet->sslctx && w->ssl_upstream) {
635 pend->c->ssl = outgoing_ssl_fd(w->outnet->sslctx, s);
648 w->outnet->tls_use_sni)) {
659 w->outnet->num_tcp_outgoing++;
660 w->outnet->tcp_free = pend->next_free;
663 pend->reuse.outnet = w->outnet;
677 reuse_tcp_remove_tree_list(w->outnet, &pend->reuse);
683 (void)reuse_tcp_insert(w->outnet, pend);
693 reuse_tcp_lru_touch(struct outside_network* outnet, struct reuse_tcp* reuse)
706 else outnet->tcp_reuse_last = reuse->lru_prev;
709 reuse->lru_next = outnet->tcp_reuse_first;
712 * the list, so outnet->tcp_reuse_last does not need to be modified */
713 outnet->tcp_reuse_first = reuse;
729 use_free_buffer(struct outside_network* outnet)
732 while(outnet->tcp_free && outnet->tcp_wait_first
733 && !outnet->want_to_quit) {
735 w = outnet->tcp_wait_first;
736 outnet->tcp_wait_first = w->next_waiting;
737 if(outnet->tcp_wait_last == w)
738 outnet->tcp_wait_last = NULL;
740 reuse = reuse_tcp_find(outnet, &w->addr, w->addrlen,
745 reuse_tcp_lru_touch(outnet, reuse);
762 struct pending_tcp* pend = w->outnet->tcp_free;
776 /** add waiting_tcp element to the outnet tcp waiting list */
778 outnet_add_tcp_waiting(struct outside_network* outnet, struct waiting_tcp* w)
784 if(outnet->tcp_wait_last)
785 outnet->tcp_wait_last->next_waiting = w;
786 else outnet->tcp_wait_first = w;
787 outnet->tcp_wait_last = w;
807 reuse_move_writewait_away(struct outside_network* outnet,
844 outnet_add_tcp_waiting(outnet, w);
855 outnet_add_tcp_waiting(outnet, w);
861 reuse_tcp_remove_tree_list(struct outside_network* outnet,
867 (void)rbtree_delete(&outnet->tcp_reuse, reuse);
879 outnet->tcp_reuse_first = reuse->lru_next;
888 outnet->tcp_reuse_last = reuse->lru_prev;
914 decommission_pending_tcp(struct outside_network* outnet,
918 pend->next_free = outnet->tcp_free;
919 outnet->tcp_free = pend;
922 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
924 /* free SSL structure after remove from outnet tcp reuse tree,
964 static void reuse_cb_and_decommission(struct outside_network* outnet,
973 decommission_pending_tcp(outnet, pend);
1003 struct outside_network* outnet = pend->reuse.outnet;
1020 reuse_tcp_remove_tree_list(outnet, &pend->reuse);
1023 verbose(VERB_ALGO, "outnet tcp pkt was written event");
1034 verbose(VERB_ALGO, "outnet tcp setup next pkt");
1045 verbose(VERB_ALGO, "outnet tcp writes done, wait");
1056 reuse_move_writewait_away(outnet, pend);
1082 if(outnet->tcp_reuse.count < outnet->tcp_reuse_max) {
1083 (void)reuse_tcp_insert(outnet, pend);
1088 verbose(VERB_CLIENT, "outnet tcp callback query err %d buflen %d",
1110 reuse_cb_and_decommission(outnet, pend, (error==NETEVENT_TIMEOUT?
1112 use_free_buffer(outnet);
1118 portcomm_loweruse(struct outside_network* outnet, struct port_comm* pc)
1136 pc->next = outnet->unused_fds;
1137 outnet->unused_fds = pc;
1142 outnet_send_wait_udp(struct outside_network* outnet)
1146 while(outnet->udp_wait_first && outnet->unused_fds
1147 && !outnet->want_to_quit) {
1148 pend = outnet->udp_wait_first;
1149 outnet->udp_wait_first = pend->next_waiting;
1150 if(!pend->next_waiting) outnet->udp_wait_last = NULL;
1151 sldns_buffer_clear(outnet->udp_buff);
1152 sldns_buffer_write(outnet->udp_buff, pend->pkt, pend->pkt_len);
1153 sldns_buffer_flip(outnet->udp_buff);
1157 if(!randomize_and_send_udp(pend, outnet->udp_buff,
1162 (void)(*pend->cb)(outnet->unused_fds->cp, pend->cb_arg,
1165 pending_delete(outnet, pend);
1174 struct outside_network* outnet = (struct outside_network*)arg;
1198 verbose(VERB_ALGO, "lookup size is %d entries", (int)outnet->pending->count);
1199 p = (struct pending*)rbtree_search(outnet->pending, &key);
1203 outnet->unwanted_replies++;
1204 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1205 >= outnet->unwanted_threshold) {
1209 (unsigned)outnet->unwanted_threshold);
1211 outnet->unwanted_action));
1212 (*outnet->unwanted_action)(outnet->unwanted_param);
1213 outnet->unwanted_total = 0;
1223 outnet->unwanted_replies++;
1224 if(outnet->unwanted_threshold && ++outnet->unwanted_total
1225 >= outnet->unwanted_threshold) {
1229 (unsigned)outnet->unwanted_threshold);
1231 outnet->unwanted_action));
1232 (*outnet->unwanted_action)(outnet->unwanted_param);
1233 outnet->unwanted_total = 0;
1238 verbose(VERB_ALGO, "outnet handle udp reply");
1240 (void)rbtree_delete(outnet->pending, p->node.key);
1245 portcomm_loweruse(outnet, p->pc);
1247 outnet_send_wait_udp(outnet);
1283 struct outside_network* outnet = p->outnet;
1285 portcomm_loweruse(outnet, p->pc);
1286 pending_delete(outnet, p);
1287 outnet_send_wait_udp(outnet);
1294 struct outside_network* outnet = p->outnet;
1305 if(outnet->delayclose && !outnet->udp_wait_first) {
1308 comm_timer_set(p->timer, &outnet->delay_tv);
1311 portcomm_loweruse(outnet, p->pc);
1312 pending_delete(outnet, p);
1313 outnet_send_wait_udp(outnet);
1318 create_pending_tcp(struct outside_network* outnet, size_t bufsize)
1321 if(outnet->num_tcp == 0)
1323 if(!(outnet->tcp_conns = (struct pending_tcp **)calloc(
1324 outnet->num_tcp, sizeof(struct pending_tcp*))))
1326 for(i=0; i<outnet->num_tcp; i++) {
1327 if(!(outnet->tcp_conns[i] = (struct pending_tcp*)calloc(1,
1330 outnet->tcp_conns[i]->next_free = outnet->tcp_free;
1331 outnet->tcp_free = outnet->tcp_conns[i];
1332 outnet->tcp_conns[i]->c = comm_point_create_tcp_out(
1333 outnet->base, bufsize, outnet_tcp_cb,
1334 outnet->tcp_conns[i]);
1335 if(!outnet->tcp_conns[i]->c)
1374 struct outside_network* outnet = (struct outside_network*)
1377 if(!outnet) {
1381 comm_base_timept(base, &outnet->now_secs, &outnet->now_tv);
1382 outnet->base = base;
1383 outnet->num_tcp = num_tcp;
1384 outnet->num_tcp_outgoing = 0;
1385 outnet->infra = infra;
1386 outnet->rnd = rnd;
1387 outnet->sslctx = sslctx;
1388 outnet->tls_use_sni = tls_use_sni;
1390 outnet->dtenv = dtenv;
1394 outnet->svcd_overhead = 0;
1395 outnet->want_to_quit = 0;
1396 outnet->unwanted_threshold = unwanted_threshold;
1397 outnet->unwanted_action = unwanted_action;
1398 outnet->unwanted_param = unwanted_param;
1399 outnet->use_caps_for_id = use_caps_for_id;
1400 outnet->do_udp = do_udp;
1401 outnet->tcp_mss = tcp_mss;
1402 outnet->ip_dscp = dscp;
1405 outnet->delayclose = 1;
1406 outnet->delay_tv.tv_sec = delayclose/1000;
1407 outnet->delay_tv.tv_usec = (delayclose%1000)*1000;
1411 outnet->udp_connect = 1;
1415 outside_network_delete(outnet);
1422 &outnet->num_ip4, &outnet->num_ip6);
1423 if(outnet->num_ip4 != 0) {
1424 if(!(outnet->ip4_ifs = (struct port_if*)calloc(
1425 (size_t)outnet->num_ip4, sizeof(struct port_if)))) {
1427 outside_network_delete(outnet);
1431 if(outnet->num_ip6 != 0) {
1432 if(!(outnet->ip6_ifs = (struct port_if*)calloc(
1433 (size_t)outnet->num_ip6, sizeof(struct port_if)))) {
1435 outside_network_delete(outnet);
1439 if( !(outnet->udp_buff = sldns_buffer_new(bufsize)) ||
1440 !(outnet->pending = rbtree_create(pending_cmp)) ||
1441 !(outnet->serviced = rbtree_create(serviced_cmp)) ||
1442 !create_pending_tcp(outnet, bufsize)) {
1444 outside_network_delete(outnet);
1447 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1448 outnet->tcp_reuse_max = num_tcp;
1456 outside_network_delete(outnet);
1459 pc->cp = comm_point_create_udp(outnet->base, -1,
1460 outnet->udp_buff, outnet_udp_cb, outnet);
1464 outside_network_delete(outnet);
1467 pc->next = outnet->unused_fds;
1468 outnet->unused_fds = pc;
1473 if(do_ip4 && !setup_if(&outnet->ip4_ifs[0], "0.0.0.0",
1476 outside_network_delete(outnet);
1479 if(do_ip6 && !setup_if(&outnet->ip6_ifs[0], "::",
1482 outside_network_delete(outnet);
1490 if(!setup_if(&outnet->ip6_ifs[done_6], ifs[i],
1493 outside_network_delete(outnet);
1499 if(!setup_if(&outnet->ip4_ifs[done_4], ifs[i],
1502 outside_network_delete(outnet);
1509 return outnet;
1517 struct outside_network* outnet = (struct outside_network*)arg;
1518 pending_delete(outnet, pend);
1540 outside_network_quit_prepare(struct outside_network* outnet)
1542 if(!outnet)
1545 outnet->want_to_quit = 1;
1549 outside_network_delete(struct outside_network* outnet)
1551 if(!outnet)
1553 outnet->want_to_quit = 1;
1555 if(outnet->pending) {
1557 traverse_postorder(outnet->pending, pending_node_del, NULL);
1558 free(outnet->pending);
1560 if(outnet->serviced) {
1561 traverse_postorder(outnet->serviced, serviced_node_del, NULL);
1562 free(outnet->serviced);
1564 if(outnet->udp_buff)
1565 sldns_buffer_free(outnet->udp_buff);
1566 if(outnet->unused_fds) {
1567 struct port_comm* p = outnet->unused_fds, *np;
1574 outnet->unused_fds = NULL;
1576 if(outnet->ip4_ifs) {
1578 for(i=0; i<outnet->num_ip4; i++) {
1579 for(k=0; k<outnet->ip4_ifs[i].inuse; k++) {
1580 struct port_comm* pc = outnet->ip4_ifs[i].
1586 free(outnet->ip4_ifs[i].avail_ports);
1588 free(outnet->ip4_ifs[i].out);
1590 free(outnet->ip4_ifs);
1592 if(outnet->ip6_ifs) {
1594 for(i=0; i<outnet->num_ip6; i++) {
1595 for(k=0; k<outnet->ip6_ifs[i].inuse; k++) {
1596 struct port_comm* pc = outnet->ip6_ifs[i].
1602 free(outnet->ip6_ifs[i].avail_ports);
1604 free(outnet->ip6_ifs[i].out);
1606 free(outnet->ip6_ifs);
1608 if(outnet->tcp_conns) {
1610 for(i=0; i<outnet->num_tcp; i++)
1611 if(outnet->tcp_conns[i]) {
1612 if(outnet->tcp_conns[i]->query &&
1613 !outnet->tcp_conns[i]->query->
1618 (struct pending_tcp*)outnet->
1621 decommission_pending_tcp(outnet, pend);
1623 comm_point_delete(outnet->tcp_conns[i]->c);
1624 waiting_tcp_delete(outnet->tcp_conns[i]->query);
1625 free(outnet->tcp_conns[i]);
1627 free(outnet->tcp_conns);
1629 if(outnet->tcp_wait_first) {
1630 struct waiting_tcp* p = outnet->tcp_wait_first, *np;
1638 rbtree_init(&outnet->tcp_reuse, reuse_cmp);
1639 outnet->tcp_reuse_first = NULL;
1640 outnet->tcp_reuse_last = NULL;
1641 if(outnet->udp_wait_first) {
1642 struct pending* p = outnet->udp_wait_first, *np;
1649 free(outnet);
1653 pending_delete(struct outside_network* outnet, struct pending* p)
1657 if(outnet && outnet->udp_wait_first &&
1658 (p->next_waiting || p == outnet->udp_wait_last) ) {
1660 struct pending* prev = NULL, *x = outnet->udp_wait_first;
1669 else outnet->udp_wait_first = p->next_waiting;
1670 if(outnet->udp_wait_last == p)
1671 outnet->udp_wait_last = prev;
1674 if(outnet) {
1675 (void)rbtree_delete(outnet->pending, p->node.key);
1741 select_id(struct outside_network* outnet, struct pending* pend,
1745 pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
1750 while(!rbtree_insert(outnet->pending, &pend->node)) {
1752 pend->id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
1794 select_ifport(struct outside_network* outnet, struct pending* pend,
1805 log_assert(outnet->unused_fds);
1808 my_if = ub_random_max(outnet->rnd, num_if);
1811 if(outnet->udp_connect) {
1820 my_port = pif->inuse + ub_random_max(outnet->rnd,
1823 my_port = ub_random_max(outnet->rnd, pif->avail_total);
1839 portno, &inuse, outnet->rnd, outnet->ip_dscp);
1847 if(outnet->udp_connect) {
1861 pend->pc = outnet->unused_fds;
1862 outnet->unused_fds = pend->pc->next;
1899 struct outside_network* outnet = pend->sq->outnet;
1902 if(!select_id(outnet, pend, packet)) {
1908 if(!select_ifport(outnet, pend,
1909 outnet->num_ip6, outnet->ip6_ifs))
1912 if(!select_ifport(outnet, pend,
1913 outnet->num_ip4, outnet->ip4_ifs))
1920 (struct sockaddr*)&pend->addr, pend->addrlen, outnet->udp_connect)) {
1921 portcomm_loweruse(outnet, pend->pc);
1934 if(outnet->dtenv &&
1935 (outnet->dtenv->log_resolver_query_messages ||
1936 outnet->dtenv->log_forwarder_query_messages))
1937 dt_msg_send_outside_query(outnet->dtenv, &pend->addr, comm_udp,
1949 pend->outnet = sq->outnet;
1956 pend->timer = comm_timer_create(sq->outnet->base, pending_udp_timer_cb,
1963 if(sq->outnet->unused_fds == NULL) {
1976 if(sq->outnet->udp_wait_last)
1977 sq->outnet->udp_wait_last->next_waiting = pend;
1979 sq->outnet->udp_wait_first = pend;
1980 sq->outnet->udp_wait_last = pend;
1984 pending_delete(sq->outnet, pend);
1994 struct outside_network* outnet = w->outnet;
1998 waiting_list_remove(outnet, w);
2004 reuse_cb_and_decommission(outnet, pend, NETEVENT_TIMEOUT);
2006 use_free_buffer(outnet);
2012 reuse_tcp_close_oldest(struct outside_network* outnet)
2016 if(!outnet->tcp_reuse_last) return;
2017 pend = outnet->tcp_reuse_last->pending;
2022 outnet->tcp_reuse_last = pend->reuse.lru_prev;
2025 outnet->tcp_reuse_last = NULL;
2026 outnet->tcp_reuse_first = NULL;
2031 reuse_cb_and_decommission(outnet, pend, NETEVENT_CLOSED);
2037 reuse_tcp_select_id(struct reuse_tcp* reuse, struct outside_network* outnet)
2047 id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
2053 id = ((unsigned)ub_random(outnet->rnd)>>8) & 0xffff;
2063 select = ub_random_max(outnet->rnd, 0xffff - reuse->tree_by_id.count);
2108 struct pending_tcp* pend = sq->outnet->tcp_free;
2120 reuse = reuse_tcp_find(sq->outnet, &sq->addr, sq->addrlen,
2126 reuse_tcp_lru_touch(sq->outnet, reuse);
2134 reuse_tcp_close_oldest(sq->outnet);
2135 pend = sq->outnet->tcp_free;
2144 if(!(w->timer = comm_timer_create(sq->outnet->base, outnet_tcptimer, w))) {
2152 w->id = reuse_tcp_select_id(reuse, sq->outnet);
2153 else w->id = ((unsigned)ub_random(sq->outnet->rnd)>>8) & 0xffff;
2157 w->outnet = sq->outnet;
2209 outnet_add_tcp_waiting(sq->outnet, w);
2212 if(sq->outnet->dtenv &&
2213 (sq->outnet->dtenv->log_resolver_query_messages ||
2214 sq->outnet->dtenv->log_forwarder_query_messages))
2215 dt_msg_send_outside_query(sq->outnet->dtenv, &sq->addr,
2241 lookup_serviced(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2252 key.outnet = outnet;
2254 return (struct serviced_query*)rbtree_search(outnet->serviced, &key);
2259 serviced_create(struct outside_network* outnet, sldns_buffer* buff, int dnssec,
2315 sq->outnet = outnet;
2327 rbtree_insert(outnet->serviced, &sq->node);
2332 /** remove waiting tcp from the outnet waiting list */
2334 waiting_list_remove(struct outside_network* outnet, struct waiting_tcp* w)
2336 struct waiting_tcp* p = outnet->tcp_wait_first, *prev = NULL;
2343 else outnet->tcp_wait_first = w->next_waiting;
2344 if(outnet->tcp_wait_last == w)
2345 outnet->tcp_wait_last = prev;
2382 if(pend_tcp->c->fd != -1 && sq->outnet->tcp_reuse.count <
2383 sq->outnet->tcp_reuse_max) {
2386 if(!reuse_tcp_insert(sq->outnet, pend_tcp)) {
2409 portcomm_loweruse(sq->outnet, p->pc);
2410 pending_delete(sq->outnet, p);
2413 outnet_send_wait_udp(sq->outnet);
2432 reuse_cb_and_decommission(sq->outnet,
2434 use_free_buffer(sq->outnet);
2439 waiting_list_remove(sq->outnet, w);
2492 if(sq->outnet->use_caps_for_id && !sq->nocaps) {
2493 serviced_perturb_qname(sq->outnet->rnd, sq->qbuf, sq->qbuflen);
2550 time_t now = *sq->outnet->now_secs;
2552 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
2566 sq->last_sent_time = *sq->outnet->now_tv;
2643 rbtree_delete(sq->outnet->serviced, sq);
2647 if(sq->outnet->use_caps_for_id && error == NETEVENT_NOERROR && c &&
2694 sq->outnet->svcd_overhead = backlen;
2710 sq->outnet->svcd_overhead = 0;
2728 infra_update_tcp_works(sq->outnet->infra, &sq->addr,
2731 if(error==NETEVENT_NOERROR && sq->outnet->dtenv &&
2732 (sq->outnet->dtenv->log_resolver_response_messages ||
2733 sq->outnet->dtenv->log_forwarder_response_messages))
2734 dt_msg_send_outside_response(sq->outnet->dtenv, &sq->addr,
2736 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
2757 if(!infra_edns_update(sq->outnet->infra, &sq->addr,
2759 *sq->outnet->now_secs))
2764 struct timeval now = *sq->outnet->now_tv;
2766 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
2781 if(!infra_rtt_update(sq->outnet->infra, &sq->addr,
2806 sq->last_sent_time = *sq->outnet->now_tv;
2823 if(!infra_host(sq->outnet->infra, &sq->addr, sq->addrlen, sq->zone,
2824 sq->zonelen, *sq->outnet->now_secs, &vs, &edns_lame_known,
2832 sq->last_sent_time = *sq->outnet->now_tv;
2888 struct outside_network* outnet = sq->outnet;
2889 struct timeval now = *sq->outnet->now_tv;
2908 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
2927 if(error == NETEVENT_NOERROR && outnet->dtenv &&
2928 (outnet->dtenv->log_resolver_response_messages ||
2929 outnet->dtenv->log_forwarder_response_messages))
2930 dt_msg_send_outside_response(outnet->dtenv, &sq->addr, c->type,
2932 &sq->last_sent_time, sq->outnet->now_tv, c->buffer);
2954 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
2971 if(!infra_edns_update(outnet->infra, &sq->addr, sq->addrlen,
2993 if(!infra_rtt_update(outnet->infra, &sq->addr, sq->addrlen,
3019 outnet_serviced_query(struct outside_network* outnet,
3045 sq = lookup_serviced(outnet, buff, dnssec, addr, addrlen,
3054 sq = serviced_create(outnet, buff, dnssec, want_dnssec, nocaps,
3065 if(outnet->do_udp && !(tcp_upstream || ssl_upstream)) {
3067 (void)rbtree_delete(outnet->serviced, sq);
3074 (void)rbtree_delete(outnet->serviced, sq);
3112 (void)rbtree_delete(sq->outnet->serviced, sq);
3119 fd_for_dest(struct outside_network* outnet, struct sockaddr_storage* to_addr,
3128 dscp = outnet->ip_dscp;
3138 if(outnet->num_ip6 == 0) {
3144 i = ub_random_max(outnet->rnd, outnet->num_ip6);
3145 pif = &outnet->ip6_ifs[i];
3147 if(outnet->num_ip4 == 0) {
3153 i = ub_random_max(outnet->rnd, outnet->num_ip4);
3154 pif = &outnet->ip4_ifs[i];
3159 pnum = ub_random_max(outnet->rnd, pif->avail_total);
3196 outnet_comm_point_for_udp(struct outside_network* outnet,
3201 int fd = fd_for_dest(outnet, to_addr, to_addrlen);
3205 cp = comm_point_create_udp(outnet->base, fd, outnet->udp_buff,
3217 setup_comm_ssl(struct comm_point* cp, struct outside_network* outnet,
3220 cp->ssl = outgoing_ssl_fd(outnet->sslctx, fd);
3231 if(outnet->tls_use_sni) {
3236 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3255 if((SSL_CTX_get_verify_mode(outnet->sslctx)&SSL_VERIFY_PEER)) {
3272 outnet_comm_point_for_tcp(struct outside_network* outnet,
3278 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3287 cp = comm_point_create_tcp_out(outnet->base, 65552, cb, cb_arg);
3298 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3333 outnet_comm_point_for_http(struct outside_network* outnet,
3340 int fd = outnet_get_tcp_fd(to_addr, to_addrlen, outnet->tcp_mss, outnet->ip_dscp);
3349 cp = comm_point_create_http_out(outnet->base, 65552, cb, cb_arg,
3350 outnet->udp_buff);
3361 if(!setup_comm_ssl(cp, outnet, fd, host)) {
3418 size_t outnet_get_mem(struct outside_network* outnet)
3427 size_t s = sizeof(*outnet) + sizeof(*outnet->base) +
3428 sizeof(*outnet->udp_buff) +
3429 sldns_buffer_capacity(outnet->udp_buff);
3431 for(pc = outnet->unused_fds; pc; pc = pc->next) {
3434 for(k=0; k<outnet->num_ip4; k++)
3435 s += if_get_mem(&outnet->ip4_ifs[k]);
3436 for(k=0; k<outnet->num_ip6; k++)
3437 s += if_get_mem(&outnet->ip6_ifs[k]);
3438 for(u=outnet->udp_wait_first; u; u=u->next_waiting)
3441 s += sizeof(struct pending_tcp*)*outnet->num_tcp;
3442 for(i=0; i<outnet->num_tcp; i++) {
3444 s += comm_point_get_mem(outnet->tcp_conns[i]->c);
3445 if(outnet->tcp_conns[i]->query)
3446 s += waiting_tcp_get_mem(outnet->tcp_conns[i]->query);
3448 for(w=outnet->tcp_wait_first; w; w = w->next_waiting)
3450 s += sizeof(*outnet->pending);
3452 outnet->pending->count;
3453 s += sizeof(*outnet->serviced);
3454 s += outnet->svcd_overhead;
3455 RBTREE_FOR(sq, struct serviced_query*, outnet->serviced) {