Lines Matching refs:c
374 comm_point_send_udp_msg(struct comm_point *c, sldns_buffer* packet, argument
378 log_assert(c->fd != -1);
385 sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
389 sent = send(c->fd, (void*)sldns_buffer_begin(packet),
436 p.fd = c->fd;
446 struct comm_base* b = c->ev->base;
514 sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
518 sent = send(c->fd, (void*)sldns_buffer_begin(packet),
597 comm_point_send_udp_msg_if(struct comm_point *c, sldns_buffer* packet, argument
612 log_assert(c->fd != -1);
702 sent = sendmsg(c->fd, &msg, 0);
745 p.fd = c->fd;
755 struct comm_base* b = c->ev->base;
822 sent = sendmsg(c->fd, &msg, 0);
846 (void)c;
979 rep.c = (struct comm_point*)arg;
980 log_assert(rep.c->type == comm_udp);
984 log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
985 ub_comm_base_now(rep.c->ev->base);
987 sldns_buffer_clear(rep.c->buffer);
988 timeval_clear(&rep.c->recv_tv);
991 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
994 iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
995 iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
1012 sldns_buffer_skip(rep.c->buffer, rcv);
1013 sldns_buffer_flip(rep.c->buffer);
1044 TIMESPEC_TO_TIMEVAL(&rep.c->recv_tv, ts);
1048 TIMESPEC_TO_TIMEVAL(&rep.c->recv_tv, ts);
1051 memmove(&rep.c->recv_tv, CMSG_DATA(cmsg), sizeof(struct timeval));
1060 if(rep.c->pp2_enabled && !consume_pp2_header(rep.c->buffer,
1071 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
1072 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
1076 buffer = rep.c->dnscrypt_buffer;
1078 buffer = rep.c->buffer;
1080 (void)comm_point_send_udp_msg_if(rep.c, buffer,
1084 if(!rep.c || rep.c->fd == -1) /* commpoint closed */
1098 rep.c = (struct comm_point*)arg;
1099 log_assert(rep.c->type == comm_udp);
1103 log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
1104 ub_comm_base_now(rep.c->ev->base);
1106 sldns_buffer_clear(rep.c->buffer);
1109 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
1110 rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
1111 sldns_buffer_remaining(rep.c->buffer), MSG_DONTWAIT,
1129 sldns_buffer_skip(rep.c->buffer, rcv);
1130 sldns_buffer_flip(rep.c->buffer);
1134 if(rep.c->pp2_enabled && !consume_pp2_header(rep.c->buffer,
1145 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
1146 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
1149 buffer = rep.c->dnscrypt_buffer;
1151 buffer = rep.c->buffer;
1153 (void)comm_point_send_udp_msg(rep.c, buffer,
1157 if(!rep.c || rep.c->fd != fd) /* commpoint closed to -1 or reused for
1163 int adjusted_tcp_timeout(struct comm_point* c) argument
1165 if(c->tcp_timeout_msec < TCP_QUERY_TIMEOUT_MINIMUM)
1167 return c->tcp_timeout_msec;
1172 setup_tcp_handler(struct comm_point* c, int fd, int cur, int max) argument
1175 log_assert(c->type == comm_tcp || c->type == comm_http);
1176 log_assert(c->fd == -1);
1177 sldns_buffer_clear(c->buffer);
1179 if (c->dnscrypt)
1180 sldns_buffer_clear(c->dnscrypt_buffer);
1182 c->tcp_is_reading = 1;
1183 c->tcp_byte_count = 0;
1184 c->tcp_keepalive = 0;
1199 c->tcp_timeout_msec /= 100;
1201 c->tcp_timeout_msec /= 500;
1203 c->tcp_timeout_msec = 0;
1204 comm_point_start_listening(c, fd, adjusted_tcp_timeout(c));
1220 int comm_point_perform_accept(struct comm_point* c, argument
1226 new_fd = accept(c->fd, (struct sockaddr*)addr, addrlen);
1229 new_fd = accept4(c->fd, (struct sockaddr*)addr, addrlen, SOCK_NONBLOCK);
1250 if(c->ev->base->stop_accept) {
1251 struct comm_base* b = c->ev->base;
1297 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1305 if(c->tcp_conn_limit && c->type == comm_tcp_accept) {
1306 c->tcl_addr = tcl_addr_lookup(c->tcp_conn_limit, addr, *addrlen);
1307 if(!tcl_new_connection(c->tcl_addr)) {
1358 comm_point_tcp_win_bio_cb(struct comm_point* c, void* thessl) argument
1367 BIO_set_callback_arg(SSL_get_rbio(ssl), (char*)c->ev->ev);
1373 BIO_set_callback_arg(SSL_get_wbio(ssl), (char*)c->ev->ev);
1399 h2_session->c->http2_max_streams}};
1416 struct comm_point* c = (struct comm_point*)arg, *c_hdl; local
1418 log_assert(c->type == comm_tcp_accept);
1423 ub_comm_base_now(c->ev->base);
1425 if(!c->tcp_free) {
1430 c_hdl = c->tcp_free;
1452 if(!c->ssl) {
1471 new_fd = comm_point_perform_accept(c, &c_hdl->repinfo.remote_addr,
1481 if(c->ssl) {
1482 c_hdl->ssl = incoming_ssl_fd(c->ssl, new_fd);
1495 c->cur_tcp_count++;
1496 c->tcp_free = c_hdl->tcp_free;
1498 if(!c->tcp_free) {
1500 comm_point_stop_listening(c);
1502 setup_tcp_handler(c_hdl, new_fd, c->cur_tcp_count, c->max_tcp_count);
1507 reclaim_tcp_handler(struct comm_point* c) argument
1509 log_assert(c->type == comm_tcp);
1510 if(c->ssl) {
1512 SSL_shutdown(c->ssl);
1513 SSL_free(c->ssl);
1514 c->ssl = NULL;
1517 comm_point_close(c);
1518 if(c->tcp_parent) {
1519 if(c != c->tcp_parent->tcp_free) {
1520 c->tcp_parent->cur_tcp_count--;
1521 c->tcp_free = c->tcp_parent->tcp_free;
1522 c->tcp_parent->tcp_free = c;
1524 if(!c->tcp_free) {
1526 comm_point_start_listening(c->tcp_parent, -1, -1);
1529 c->tcp_more_read_again = NULL;
1530 c->tcp_more_write_again = NULL;
1531 c->tcp_byte_count = 0;
1532 c->pp2_header_state = pp2_header_none;
1533 sldns_buffer_clear(c->buffer);
1538 tcp_callback_writer(struct comm_point* c) argument
1540 log_assert(c->type == comm_tcp);
1541 if(!c->tcp_write_and_read) {
1542 sldns_buffer_clear(c->buffer);
1543 c->tcp_byte_count = 0;
1545 if(c->tcp_do_toggle_rw)
1546 c->tcp_is_reading = 1;
1548 if(c->tcp_req_info) {
1549 tcp_req_info_handle_writedone(c->tcp_req_info);
1551 comm_point_stop_listening(c);
1552 if(c->tcp_write_and_read) {
1553 fptr_ok(fptr_whitelist_comm_point(c->callback));
1554 if( (*c->callback)(c, c->cb_arg, NETEVENT_PKT_WRITTEN,
1555 &c->repinfo) ) {
1556 comm_point_start_listening(c, -1,
1557 adjusted_tcp_timeout(c));
1560 comm_point_start_listening(c, -1,
1561 adjusted_tcp_timeout(c));
1568 tcp_callback_reader(struct comm_point* c) argument
1570 log_assert(c->type == comm_tcp || c->type == comm_local);
1571 sldns_buffer_flip(c->buffer);
1572 if(c->tcp_do_toggle_rw)
1573 c->tcp_is_reading = 0;
1574 c->tcp_byte_count = 0;
1575 if(c->tcp_req_info) {
1576 tcp_req_info_handle_readdone(c->tcp_req_info);
1578 if(c->type == comm_tcp)
1579 comm_point_stop_listening(c);
1580 fptr_ok(fptr_whitelist_comm_point(c->callback));
1581 if( (*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &c->repinfo) ) {
1582 comm_point_start_listening(c, -1,
1583 adjusted_tcp_timeout(c));
1619 ssl_handshake(struct comm_point* c) argument
1622 if(c->ssl_shake_state == comm_ssl_shake_hs_read) {
1624 comm_point_listen_for_rw(c, 0, 1);
1625 c->ssl_shake_state = comm_ssl_shake_none;
1628 if(c->ssl_shake_state == comm_ssl_shake_hs_write) {
1630 comm_point_listen_for_rw(c, 1, 0);
1631 c->ssl_shake_state = comm_ssl_shake_none;
1636 r = SSL_do_handshake(c->ssl);
1638 int want = SSL_get_error(c->ssl, r);
1640 if(c->ssl_shake_state == comm_ssl_shake_read)
1642 c->ssl_shake_state = comm_ssl_shake_read;
1643 comm_point_listen_for_rw(c, 1, 0);
1646 if(c->ssl_shake_state == comm_ssl_shake_write)
1648 c->ssl_shake_state = comm_ssl_shake_write;
1649 comm_point_listen_for_rw(c, 0, 1);
1664 (struct sockaddr*)&c->repinfo.remote_addr,
1665 c->repinfo.remote_addrlen))
1679 if((vr=SSL_get_verify_result(c->ssl)) != 0)
1684 &c->repinfo.remote_addr,
1685 c->repinfo.remote_addrlen);
1691 if((SSL_get_verify_mode(c->ssl)&SSL_VERIFY_PEER)) {
1693 if(SSL_get_verify_result(c->ssl) == X509_V_OK) {
1695 X509* x = SSL_get1_peer_certificate(c->ssl);
1697 X509* x = SSL_get_peer_certificate(c->ssl);
1702 &c->repinfo.remote_addr,
1703 c->repinfo.remote_addrlen);
1708 if(SSL_get0_peername(c->ssl)) {
1712 SSL_get0_peername(c->ssl));
1713 log_addr(VERB_ALGO, buf, &c->repinfo.remote_addr,
1714 c->repinfo.remote_addrlen);
1718 "authenticated", &c->repinfo.remote_addr,
1719 c->repinfo.remote_addrlen);
1726 X509* x = SSL_get1_peer_certificate(c->ssl);
1728 X509* x = SSL_get_peer_certificate(c->ssl);
1736 &c->repinfo.remote_addr,
1737 c->repinfo.remote_addrlen);
1743 log_addr(VERB_ALGO, "SSL connection", &c->repinfo.remote_addr,
1744 c->repinfo.remote_addrlen);
1749 if(c->type == comm_http && c->h2_session) {
1752 SSL_get0_alpn_selected(c->ssl, &alpn, &alpnlen);
1755 c->tcp_do_toggle_rw = 0;
1756 c->use_h2 = 1;
1765 if(c->tcp_is_reading) {
1766 if(c->ssl_shake_state != comm_ssl_shake_read)
1767 comm_point_listen_for_rw(c, 1, 0);
1769 comm_point_listen_for_rw(c, 0, 1);
1771 c->ssl_shake_state = comm_ssl_shake_none;
1778 ssl_handle_read(struct comm_point* c) argument
1782 if(c->ssl_shake_state != comm_ssl_shake_none) {
1783 if(!ssl_handshake(c))
1785 if(c->ssl_shake_state != comm_ssl_shake_none)
1788 if(c->pp2_enabled && c->pp2_header_state != pp2_header_done) {
1792 if(c->pp2_header_state == pp2_header_none) {
1794 if(sldns_buffer_remaining(c->buffer)<want_read_size) {
1797 &c->repinfo.remote_addr,
1798 c->repinfo.remote_addrlen);
1805 if(c->tcp_byte_count < current_read_size) {
1807 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(
1808 c->buffer, c->tcp_byte_count),
1810 c->tcp_byte_count)) <= 0) {
1811 int want = SSL_get_error(c->ssl, r);
1813 if(c->tcp_req_info)
1814 return tcp_req_info_handle_read_close(c->tcp_req_info);
1818 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1822 c->ssl_shake_state = comm_ssl_shake_hs_write;
1823 comm_point_listen_for_rw(c, 0, 1);
1839 c->tcp_byte_count += r;
1840 sldns_buffer_skip(c->buffer, r);
1841 if(c->tcp_byte_count != current_read_size) return 1;
1842 c->pp2_header_state = pp2_header_init;
1845 if(c->pp2_header_state == pp2_header_init) {
1848 sldns_buffer_begin(c->buffer),
1849 sldns_buffer_limit(c->buffer));
1856 header = (struct pp2_header*)sldns_buffer_begin(c->buffer);
1858 if(sldns_buffer_limit(c->buffer) <
1862 &c->repinfo.remote_addr,
1863 c->repinfo.remote_addrlen);
1872 c->pp2_header_state = pp2_header_done;
1873 } else if(c->tcp_byte_count < current_read_size) {
1875 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(
1876 c->buffer, c->tcp_byte_count),
1878 c->tcp_byte_count)) <= 0) {
1879 int want = SSL_get_error(c->ssl, r);
1881 if(c->tcp_req_info)
1882 return tcp_req_info_handle_read_close(c->tcp_req_info);
1886 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1890 c->ssl_shake_state = comm_ssl_shake_hs_write;
1891 comm_point_listen_for_rw(c, 0, 1);
1907 c->tcp_byte_count += r;
1908 sldns_buffer_skip(c->buffer, r);
1909 if(c->tcp_byte_count != current_read_size) return 1;
1910 c->pp2_header_state = pp2_header_done;
1913 if(c->pp2_header_state != pp2_header_done || !header) {
1915 "PROXYv2 header", "", &c->repinfo.remote_addr,
1916 c->repinfo.remote_addrlen);
1919 sldns_buffer_flip(c->buffer);
1920 if(!consume_pp2_header(c->buffer, &c->repinfo, 1)) {
1922 "PROXYv2 header", "", &c->repinfo.remote_addr,
1923 c->repinfo.remote_addrlen);
1930 sldns_buffer_clear(c->buffer);
1931 c->tcp_byte_count = 0;
1934 if(c->tcp_byte_count < sizeof(uint16_t)) {
1937 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(c->buffer,
1938 c->tcp_byte_count), (int)(sizeof(uint16_t) -
1939 c->tcp_byte_count))) <= 0) {
1940 int want = SSL_get_error(c->ssl, r);
1942 if(c->tcp_req_info)
1943 return tcp_req_info_handle_read_close(c->tcp_req_info);
1947 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
1951 c->ssl_shake_state = comm_ssl_shake_hs_write;
1952 comm_point_listen_for_rw(c, 0, 1);
1967 c->tcp_byte_count += r;
1968 if(c->tcp_byte_count < sizeof(uint16_t))
1970 if(sldns_buffer_read_u16_at(c->buffer, 0) >
1971 sldns_buffer_capacity(c->buffer)) {
1975 sldns_buffer_set_limit(c->buffer,
1976 sldns_buffer_read_u16_at(c->buffer, 0));
1977 if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
1981 sldns_buffer_skip(c->buffer, (ssize_t)(c->tcp_byte_count-sizeof(uint16_t)));
1983 (int)sldns_buffer_limit(c->buffer));
1985 if(sldns_buffer_remaining(c->buffer) > 0) {
1987 r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
1988 (int)sldns_buffer_remaining(c->buffer));
1990 int want = SSL_get_error(c->ssl, r);
1992 if(c->tcp_req_info)
1993 return tcp_req_info_handle_read_close(c->tcp_req_info);
1997 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
2001 c->ssl_shake_state = comm_ssl_shake_hs_write;
2002 comm_point_listen_for_rw(c, 0, 1);
2017 sldns_buffer_skip(c->buffer, (ssize_t)r);
2019 if(sldns_buffer_remaining(c->buffer) <= 0) {
2020 tcp_callback_reader(c);
2024 (void)c;
2031 ssl_handle_write(struct comm_point* c) argument
2035 if(c->ssl_shake_state != comm_ssl_shake_none) {
2036 if(!ssl_handshake(c))
2038 if(c->ssl_shake_state != comm_ssl_shake_none)
2042 (void)SSL_set_mode(c->ssl, (long)SSL_MODE_ENABLE_PARTIAL_WRITE);
2043 if((c->tcp_write_and_read?c->tcp_write_byte_count:c->tcp_byte_count) < sizeof(uint16_t)) {
2044 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(c->buffer));
2046 if(c->tcp_write_and_read) {
2047 if(c->tcp_write_pkt_len + 2 < LDNS_RR_BUF_SIZE) {
2053 c->tcp_write_pkt,
2054 c->tcp_write_pkt_len);
2055 r = SSL_write(c->ssl,
2056 (void*)(buf+c->tcp_write_byte_count),
2057 c->tcp_write_pkt_len + 2 -
2058 c->tcp_write_byte_count);
2060 r = SSL_write(c->ssl,
2061 (void*)(((uint8_t*)&len)+c->tcp_write_byte_count),
2062 (int)(sizeof(uint16_t)-c->tcp_write_byte_count));
2064 } else if(sizeof(uint16_t)+sldns_buffer_remaining(c->buffer) <
2071 sldns_buffer_current(c->buffer),
2072 sldns_buffer_remaining(c->buffer));
2073 r = SSL_write(c->ssl, (void*)(buf+c->tcp_byte_count),
2075 sldns_buffer_remaining(c->buffer)
2076 - c->tcp_byte_count));
2078 r = SSL_write(c->ssl,
2079 (void*)(((uint8_t*)&len)+c->tcp_byte_count),
2080 (int)(sizeof(uint16_t)-c->tcp_byte_count));
2083 int want = SSL_get_error(c->ssl, r);
2087 c->ssl_shake_state = comm_ssl_shake_hs_read;
2088 comm_point_listen_for_rw(c, 1, 0);
2092 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2108 if(c->tcp_write_and_read) {
2109 c->tcp_write_byte_count += r;
2110 if(c->tcp_write_byte_count < sizeof(uint16_t))
2113 c->tcp_byte_count += r;
2114 if(c->tcp_byte_count < sizeof(uint16_t))
2116 sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
2119 …if((!c->tcp_write_and_read && sldns_buffer_remaining(c->buffer) == 0) || (c->tcp_write_and_read &&…
2120 tcp_callback_writer(c);
2124 log_assert(c->tcp_write_and_read || sldns_buffer_remaining(c->buffer) > 0);
2125 log_assert(!c->tcp_write_and_read || c->tcp_write_byte_count < c->tcp_write_pkt_len + 2);
2127 if(c->tcp_write_and_read) {
2128 r = SSL_write(c->ssl, (void*)(c->tcp_write_pkt + c->tcp_write_byte_count - 2),
2129 (int)(c->tcp_write_pkt_len + 2 - c->tcp_write_byte_count));
2131 r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
2132 (int)sldns_buffer_remaining(c->buffer));
2135 int want = SSL_get_error(c->ssl, r);
2139 c->ssl_shake_state = comm_ssl_shake_hs_read;
2140 comm_point_listen_for_rw(c, 1, 0);
2144 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2160 if(c->tcp_write_and_read) {
2161 c->tcp_write_byte_count += r;
2163 sldns_buffer_skip(c->buffer, (ssize_t)r);
2166 …if((!c->tcp_write_and_read && sldns_buffer_remaining(c->buffer) == 0) || (c->tcp_write_and_read &&…
2167 tcp_callback_writer(c);
2171 (void)c;
2178 ssl_handle_it(struct comm_point* c, int is_write) argument
2182 if(is_write && c->ssl_shake_state == comm_ssl_shake_hs_write)
2183 return ssl_handle_read(c);
2184 else if(!is_write && c->ssl_shake_state == comm_ssl_shake_hs_read)
2185 return ssl_handle_write(c);
2189 return ssl_handle_read(c);
2190 return ssl_handle_write(c);
2201 comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok) argument
2205 log_assert(c->type == comm_tcp || c->type == comm_local);
2206 if(c->ssl)
2207 return ssl_handle_it(c, 0);
2208 if(!c->tcp_is_reading && !c->tcp_write_and_read)
2212 if(c->pp2_enabled && c->pp2_header_state != pp2_header_done) {
2216 if(c->pp2_header_state == pp2_header_none) {
2218 if(sldns_buffer_remaining(c->buffer)<want_read_size) {
2221 &c->repinfo.remote_addr,
2222 c->repinfo.remote_addrlen);
2229 if(c->tcp_byte_count < current_read_size) {
2230 r = recv(fd, (void*)sldns_buffer_at(c->buffer,
2231 c->tcp_byte_count),
2232 current_read_size-c->tcp_byte_count, MSG_DONTWAIT);
2234 if(c->tcp_req_info)
2235 return tcp_req_info_handle_read_close(c->tcp_req_info);
2240 c->tcp_byte_count += r;
2241 sldns_buffer_skip(c->buffer, r);
2242 if(c->tcp_byte_count != current_read_size) return 1;
2243 c->pp2_header_state = pp2_header_init;
2246 if(c->pp2_header_state == pp2_header_init) {
2249 sldns_buffer_begin(c->buffer),
2250 sldns_buffer_limit(c->buffer));
2257 header = (struct pp2_header*)sldns_buffer_begin(c->buffer);
2259 if(sldns_buffer_limit(c->buffer) <
2263 &c->repinfo.remote_addr,
2264 c->repinfo.remote_addrlen);
2273 c->pp2_header_state = pp2_header_done;
2274 } else if(c->tcp_byte_count < current_read_size) {
2275 r = recv(fd, (void*)sldns_buffer_at(c->buffer,
2276 c->tcp_byte_count),
2277 current_read_size-c->tcp_byte_count, MSG_DONTWAIT);
2279 if(c->tcp_req_info)
2280 return tcp_req_info_handle_read_close(c->tcp_req_info);
2285 c->tcp_byte_count += r;
2286 sldns_buffer_skip(c->buffer, r);
2287 if(c->tcp_byte_count != current_read_size) return 1;
2288 c->pp2_header_state = pp2_header_done;
2291 if(c->pp2_header_state != pp2_header_done || !header) {
2293 "PROXYv2 header", "", &c->repinfo.remote_addr,
2294 c->repinfo.remote_addrlen);
2297 sldns_buffer_flip(c->buffer);
2298 if(!consume_pp2_header(c->buffer, &c->repinfo, 1)) {
2300 "PROXYv2 header", "", &c->repinfo.remote_addr,
2301 c->repinfo.remote_addrlen);
2308 sldns_buffer_clear(c->buffer);
2309 c->tcp_byte_count = 0;
2313 if(c->tcp_byte_count < sizeof(uint16_t)) {
2315 r = recv(fd,(void*)sldns_buffer_at(c->buffer,c->tcp_byte_count),
2316 sizeof(uint16_t)-c->tcp_byte_count, MSG_DONTWAIT);
2318 if(c->tcp_req_info)
2319 return tcp_req_info_handle_read_close(c->tcp_req_info);
2322 if(c->pp2_enabled) goto recv_error;
2325 c->tcp_byte_count += r;
2326 if(c->tcp_byte_count != sizeof(uint16_t))
2328 if(sldns_buffer_read_u16_at(c->buffer, 0) >
2329 sldns_buffer_capacity(c->buffer)) {
2333 sldns_buffer_set_limit(c->buffer,
2334 sldns_buffer_read_u16_at(c->buffer, 0));
2336 sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
2341 (int)sldns_buffer_limit(c->buffer));
2344 if(sldns_buffer_remaining(c->buffer) == 0)
2348 r = recv(fd, (void*)sldns_buffer_current(c->buffer),
2349 sldns_buffer_remaining(c->buffer), MSG_DONTWAIT);
2351 if(c->tcp_req_info)
2352 return tcp_req_info_handle_read_close(c->tcp_req_info);
2357 sldns_buffer_skip(c->buffer, r);
2358 if(sldns_buffer_remaining(c->buffer) <= 0) {
2359 tcp_callback_reader(c);
2405 &c->repinfo.remote_addr,
2406 c->repinfo.remote_addrlen);
2429 ub_winsock_tcp_wouldblock(c->ev->ev,
2435 sock_strerror(errno), &c->repinfo.remote_addr,
2436 c->repinfo.remote_addrlen);
2447 comm_point_tcp_handle_write(int fd, struct comm_point* c) argument
2451 log_assert(c->type == comm_tcp);
2453 buffer = c->dnscrypt_buffer;
2455 buffer = c->buffer;
2457 if(c->tcp_is_reading && !c->ssl && !c->tcp_write_and_read)
2460 …if(((!c->tcp_write_and_read && c->tcp_byte_count == 0) || (c->tcp_write_and_read && c->tcp_write_b…
2483 &c->repinfo.remote_addr,
2484 c->repinfo.remote_addrlen);
2490 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2496 &c->repinfo.remote_addr,
2497 c->repinfo.remote_addrlen);
2502 if(c->ssl)
2503 return ssl_handle_it(c, 1);
2509 if(c->tcp_do_fastopen == 1) {
2512 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(buffer));
2515 c->tcp_do_fastopen = 0;
2517 if(c->tcp_write_and_read) {
2518 iov[0].iov_base = (uint8_t*)&len + c->tcp_write_byte_count;
2519 iov[0].iov_len = sizeof(uint16_t) - c->tcp_write_byte_count;
2520 iov[1].iov_base = c->tcp_write_pkt;
2521 iov[1].iov_len = c->tcp_write_pkt_len;
2523 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
2524 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
2529 msg.msg_name = &c->repinfo.remote_addr;
2530 msg.msg_namelen = c->repinfo.remote_addrlen;
2556 &c->repinfo.remote_addr,
2557 c->repinfo.remote_addrlen);
2564 if(connect(fd, (struct sockaddr *)&c->repinfo.remote_addr,
2565 c->repinfo.remote_addrlen) == -1) {
2576 (struct sockaddr *)&c->repinfo.remote_addr,
2577 c->repinfo.remote_addrlen)) {
2580 &c->repinfo.remote_addr,
2581 c->repinfo.remote_addrlen);
2587 if(c->tcp_write_and_read) {
2588 c->tcp_write_byte_count += r;
2589 if(c->tcp_write_byte_count < sizeof(uint16_t))
2592 c->tcp_byte_count += r;
2593 if(c->tcp_byte_count < sizeof(uint16_t))
2595 sldns_buffer_set_position(buffer, c->tcp_byte_count -
2598 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
2599 tcp_callback_writer(c);
2606 if((c->tcp_write_and_read?c->tcp_write_byte_count:c->tcp_byte_count) < sizeof(uint16_t)) {
2607 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(buffer));
2610 if(c->tcp_write_and_read) {
2611 iov[0].iov_base = (uint8_t*)&len + c->tcp_write_byte_count;
2612 iov[0].iov_len = sizeof(uint16_t) - c->tcp_write_byte_count;
2613 iov[1].iov_base = c->tcp_write_pkt;
2614 iov[1].iov_len = c->tcp_write_pkt_len;
2616 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
2617 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
2624 if(c->tcp_write_and_read) {
2625 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_write_byte_count),
2626 sizeof(uint16_t)-c->tcp_write_byte_count, 0);
2628 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_byte_count),
2629 sizeof(uint16_t)-c->tcp_byte_count, 0);
2646 &c->repinfo.remote_addr,
2647 c->repinfo.remote_addrlen);
2650 &c->repinfo.remote_addr,
2651 c->repinfo.remote_addrlen);
2659 ub_winsock_tcp_wouldblock(c->ev->ev,
2667 &c->repinfo.remote_addr,
2668 c->repinfo.remote_addrlen);
2672 if(c->tcp_write_and_read) {
2673 c->tcp_write_byte_count += r;
2674 if(c->tcp_write_byte_count < sizeof(uint16_t))
2677 c->tcp_byte_count += r;
2678 if(c->tcp_byte_count < sizeof(uint16_t))
2680 sldns_buffer_set_position(buffer, c->tcp_byte_count -
2683 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
2684 tcp_callback_writer(c);
2688 log_assert(c->tcp_write_and_read || sldns_buffer_remaining(buffer) > 0);
2689 log_assert(!c->tcp_write_and_read || c->tcp_write_byte_count < c->tcp_write_pkt_len + 2);
2690 if(c->tcp_write_and_read) {
2691 r = send(fd, (void*)(c->tcp_write_pkt + c->tcp_write_byte_count - 2),
2692 c->tcp_write_pkt_len + 2 - c->tcp_write_byte_count, 0);
2709 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
2716 &c->repinfo.remote_addr,
2717 c->repinfo.remote_addrlen);
2720 if(c->tcp_write_and_read) {
2721 c->tcp_write_byte_count += r;
2726 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
2727 tcp_callback_writer(c);
2736 tcp_req_info_read_again(int fd, struct comm_point* c) argument
2738 while(c->tcp_req_info->read_again) {
2740 c->tcp_req_info->read_again = 0;
2741 if(c->tcp_is_reading)
2742 r = comm_point_tcp_handle_read(fd, c, 0);
2743 else r = comm_point_tcp_handle_write(fd, c);
2745 reclaim_tcp_handler(c);
2746 if(!c->tcp_do_close) {
2748 c->callback));
2749 (void)(*c->callback)(c, c->cb_arg,
2760 tcp_more_read_again(int fd, struct comm_point* c) argument
2766 int* moreread = c->tcp_more_read_again;
2769 if(!comm_point_tcp_handle_read(fd, c, 0)) {
2770 reclaim_tcp_handler(c);
2771 if(!c->tcp_do_close) {
2773 c->callback));
2774 (void)(*c->callback)(c, c->cb_arg,
2784 tcp_more_write_again(int fd, struct comm_point* c) argument
2790 int* morewrite = c->tcp_more_write_again;
2793 if(!comm_point_tcp_handle_write(fd, c)) {
2794 reclaim_tcp_handler(c);
2795 if(!c->tcp_do_close) {
2797 c->callback));
2798 (void)(*c->callback)(c, c->cb_arg,
2809 struct comm_point* c = (struct comm_point*)arg; local
2810 log_assert(c->type == comm_tcp);
2811 ub_comm_base_now(c->ev->base);
2813 if(c->fd == -1 || c->fd != fd)
2818 if(c->tcp_parent) {
2819 c->dnscrypt = c->tcp_parent->dnscrypt;
2821 if(c->dnscrypt && c->dnscrypt_buffer == c->buffer) {
2822 c->dnscrypt_buffer = sldns_buffer_new(sldns_buffer_capacity(c->buffer));
2823 if(!c->dnscrypt_buffer) {
2825 reclaim_tcp_handler(c);
2826 if(!c->tcp_do_close) {
2828 c->callback));
2829 (void)(*c->callback)(c, c->cb_arg,
2839 reclaim_tcp_handler(c);
2840 if(!c->tcp_do_close) {
2841 fptr_ok(fptr_whitelist_comm_point(c->callback));
2842 (void)(*c->callback)(c, c->cb_arg,
2849 && !(c->tcp_do_fastopen && (event&UB_EV_WRITE))
2852 int has_tcpq = (c->tcp_req_info != NULL);
2853 int* moreread = c->tcp_more_read_again;
2854 if(!comm_point_tcp_handle_read(fd, c, 0)) {
2855 reclaim_tcp_handler(c);
2856 if(!c->tcp_do_close) {
2858 c->callback));
2859 (void)(*c->callback)(c, c->cb_arg,
2864 if(has_tcpq && c->tcp_req_info && c->tcp_req_info->read_again) {
2865 if(!tcp_req_info_read_again(fd, c))
2869 tcp_more_read_again(fd, c);
2873 int has_tcpq = (c->tcp_req_info != NULL);
2874 int* morewrite = c->tcp_more_write_again;
2875 if(!comm_point_tcp_handle_write(fd, c)) {
2876 reclaim_tcp_handler(c);
2877 if(!c->tcp_do_close) {
2879 c->callback));
2880 (void)(*c->callback)(c, c->cb_arg,
2885 if(has_tcpq && c->tcp_req_info && c->tcp_req_info->read_again) {
2886 if(!tcp_req_info_read_again(fd, c))
2890 tcp_more_write_again(fd, c);
2898 reclaim_http_handler(struct comm_point* c) argument
2900 log_assert(c->type == comm_http);
2901 if(c->ssl) {
2903 SSL_shutdown(c->ssl);
2904 SSL_free(c->ssl);
2905 c->ssl = NULL;
2908 comm_point_close(c);
2909 if(c->tcp_parent) {
2910 if(c != c->tcp_parent->tcp_free) {
2911 c->tcp_parent->cur_tcp_count--;
2912 c->tcp_free = c->tcp_parent->tcp_free;
2913 c->tcp_parent->tcp_free = c;
2915 if(!c->tcp_free) {
2917 comm_point_start_listening(c->tcp_parent, -1, -1);
2924 ssl_http_read_more(struct comm_point* c) argument
2928 log_assert(sldns_buffer_remaining(c->buffer) > 0);
2930 r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
2931 (int)sldns_buffer_remaining(c->buffer));
2933 int want = SSL_get_error(c->ssl, r);
2939 c->ssl_shake_state = comm_ssl_shake_hs_write;
2940 comm_point_listen_for_rw(c, 0, 1);
2956 (int)sldns_buffer_position(c->buffer), (int)r);
2957 sldns_buffer_skip(c->buffer, (ssize_t)r);
2960 (void)c;
2967 http_read_more(int fd, struct comm_point* c) argument
2970 log_assert(sldns_buffer_remaining(c->buffer) > 0);
2971 r = recv(fd, (void*)sldns_buffer_current(c->buffer),
2972 sldns_buffer_remaining(c->buffer), MSG_DONTWAIT);
2985 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
2990 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
2994 (int)sldns_buffer_position(c->buffer), (int)r);
2995 sldns_buffer_skip(c->buffer, r);
3046 http_process_initial_header(struct comm_point* c) argument
3048 char* line = http_header_line(c->buffer);
3058 if(!c->http_is_chunked)
3059 c->tcp_byte_count = (size_t)atoi(line+16);
3061 c->tcp_byte_count = 0;
3062 c->http_is_chunked = 1;
3065 c->http_in_headers = 0;
3066 if(c->http_is_chunked)
3067 c->http_in_chunk_headers = 1;
3072 http_moveover_buffer(c->buffer);
3073 sldns_buffer_flip(c->buffer);
3083 http_process_chunk_header(struct comm_point* c) argument
3085 char* line = http_header_line(c->buffer);
3087 if(c->http_in_chunk_headers == 3) {
3090 if(line[0] == 0 && c->tcp_byte_count == 0) {
3093 sldns_buffer_set_position(c->buffer, 0);
3094 sldns_buffer_set_limit(c->buffer, 0);
3095 fptr_ok(fptr_whitelist_comm_point(c->callback));
3096 (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
3102 c->http_in_chunk_headers = 1;
3104 http_moveover_buffer(c->buffer);
3105 sldns_buffer_flip(c->buffer);
3112 if(c->http_in_chunk_headers == 1) {
3115 c->tcp_byte_count = (size_t)strtol(line, &end, 16);
3118 c->http_in_chunk_headers = 0;
3120 http_moveover_buffer(c->buffer);
3121 sldns_buffer_flip(c->buffer);
3122 if(c->tcp_byte_count == 0) {
3124 c->http_in_chunk_headers = 3;
3134 http_nonchunk_segment(struct comm_point* c) argument
3141 size_t got_now = sldns_buffer_limit(c->buffer);
3142 if(c->tcp_byte_count <= got_now) {
3144 c->http_stored = 0;
3145 sldns_buffer_set_position(c->buffer, 0);
3146 fptr_ok(fptr_whitelist_comm_point(c->callback));
3147 (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
3152 remainbufferlen = sldns_buffer_capacity(c->buffer) -
3153 sldns_buffer_limit(c->buffer);
3154 if(remainbufferlen+got_now >= c->tcp_byte_count ||
3155 remainbufferlen >= (size_t)(c->ssl?16384:2048)) {
3156 size_t total = sldns_buffer_limit(c->buffer);
3157 sldns_buffer_clear(c->buffer);
3158 sldns_buffer_set_position(c->buffer, total);
3159 c->http_stored = total;
3165 c->tcp_byte_count -= got_now;
3166 c->http_stored = 0;
3167 sldns_buffer_set_position(c->buffer, 0);
3168 fptr_ok(fptr_whitelist_comm_point(c->callback));
3169 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
3177 http_chunked_segment(struct comm_point* c) argument
3184 size_t got_now = sldns_buffer_limit(c->buffer) - c->http_stored;
3185 …%d", (int)got_now, (int)c->tcp_byte_count, (int)c->http_stored, (int)sldns_buffer_position(c->buff…
3186 if(c->tcp_byte_count <= got_now) {
3192 c->http_stored = 0;
3193 sldns_buffer_skip(c->buffer, (ssize_t)c->tcp_byte_count);
3194 sldns_buffer_clear(c->http_temp);
3195 sldns_buffer_write(c->http_temp,
3196 sldns_buffer_current(c->buffer),
3197 sldns_buffer_remaining(c->buffer));
3198 sldns_buffer_flip(c->http_temp);
3201 fraglen = sldns_buffer_position(c->buffer);
3202 sldns_buffer_set_position(c->buffer, 0);
3203 sldns_buffer_set_limit(c->buffer, fraglen);
3204 repinfo = c->repinfo;
3205 fptr_ok(fptr_whitelist_comm_point(c->callback));
3206 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &repinfo);
3210 if(!repinfo.c) {
3214 sldns_buffer_clear(c->buffer);
3215 sldns_buffer_write(c->buffer,
3216 sldns_buffer_begin(c->http_temp),
3217 sldns_buffer_remaining(c->http_temp));
3218 sldns_buffer_flip(c->buffer);
3221 c->http_in_chunk_headers = 3;
3225 c->tcp_byte_count -= got_now;
3229 remainbufferlen = sldns_buffer_capacity(c->buffer) -
3230 sldns_buffer_limit(c->buffer);
3231 if(remainbufferlen >= c->tcp_byte_count ||
3233 size_t total = sldns_buffer_limit(c->buffer);
3234 sldns_buffer_clear(c->buffer);
3235 sldns_buffer_set_position(c->buffer, total);
3236 c->http_stored = total;
3242 c->http_stored = 0;
3243 sldns_buffer_set_position(c->buffer, 0);
3244 fptr_ok(fptr_whitelist_comm_point(c->callback));
3245 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
3253 static struct http2_session* http2_session_create(struct comm_point* c) argument
3260 session->c = c;
3296 h2_session->c);
3333 h2_session->c->h2_stream = NULL;
3382 log_assert(h2_session->c->type == comm_http);
3383 log_assert(h2_session->c->h2_session);
3386 if(h2_session->c->ssl) {
3389 r = SSL_read(h2_session->c->ssl, buf, len);
3391 int want = SSL_get_error(h2_session->c->ssl, r);
3397 h2_session->c->ssl_shake_state = comm_ssl_shake_hs_write;
3398 comm_point_listen_for_rw(h2_session->c, 0, 1);
3417 ret = recv(h2_session->c->fd, buf, len, MSG_DONTWAIT);
3429 &h2_session->c->repinfo.remote_addr,
3430 h2_session->c->repinfo.remote_addrlen);
3437 ub_winsock_tcp_wouldblock(h2_session->c->ev->ev,
3443 &h2_session->c->repinfo.remote_addr,
3444 h2_session->c->repinfo.remote_addrlen);
3454 comm_point_http2_handle_read(int ATTR_UNUSED(fd), struct comm_point* c) argument
3458 log_assert(c->h2_session);
3461 ret = nghttp2_session_recv(c->h2_session->session);
3466 addr_to_str(&c->repinfo.remote_addr,
3467 c->repinfo.remote_addrlen, a, sizeof(a));
3473 if(nghttp2_session_want_write(c->h2_session->session)) {
3474 c->tcp_is_reading = 0;
3475 comm_point_stop_listening(c);
3476 comm_point_start_listening(c, -1, adjusted_tcp_timeout(c));
3477 } else if(!nghttp2_session_want_read(c->h2_session->session))
3481 (void)c;
3493 comm_point_http_handle_read(int fd, struct comm_point* c) argument
3495 log_assert(c->type == comm_http);
3500 if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
3501 if(!ssl_handshake(c))
3503 if(c->ssl_shake_state != comm_ssl_shake_none)
3508 if(!c->tcp_is_reading)
3511 if(c->use_h2) {
3512 return comm_point_http2_handle_read(fd, c);
3517 if(c->http_min_version >= http_version_2) {
3523 if(c->ssl) {
3524 if(!ssl_http_read_more(c))
3527 if(!http_read_more(fd, c))
3531 if(c->http_stored >= sldns_buffer_position(c->buffer)) {
3536 sldns_buffer_flip(c->buffer);
3539 if(c->http_stored < sldns_buffer_limit(c->buffer))
3540 sldns_buffer_set_position(c->buffer, c->http_stored);
3541 else sldns_buffer_set_position(c->buffer, sldns_buffer_limit(c->buffer));
3543 while(sldns_buffer_remaining(c->buffer) > 0) {
3546 if(c->http_in_headers || c->http_in_chunk_headers) {
3548 if(!http_header_done(c->buffer)) {
3551 http_moveover_buffer(c->buffer);
3555 if(!c->http_in_chunk_headers) {
3557 if(!http_process_initial_header(c))
3561 int r = http_process_chunk_header(c);
3570 if(!c->http_is_chunked) {
3572 return http_nonchunk_segment(c);
3575 int r = http_chunked_segment(c);
3584 http_moveover_buffer(c->buffer);
3591 http_check_connect(int fd, struct comm_point* c) argument
3615 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
3621 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
3627 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
3637 ssl_http_write_more(struct comm_point* c) argument
3641 log_assert(sldns_buffer_remaining(c->buffer) > 0);
3643 r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
3644 (int)sldns_buffer_remaining(c->buffer));
3646 int want = SSL_get_error(c->ssl, r);
3650 c->ssl_shake_state = comm_ssl_shake_hs_read;
3651 comm_point_listen_for_rw(c, 1, 0);
3668 sldns_buffer_skip(c->buffer, (ssize_t)r);
3671 (void)c;
3678 http_write_more(int fd, struct comm_point* c) argument
3681 log_assert(sldns_buffer_remaining(c->buffer) > 0);
3682 r = send(fd, (void*)sldns_buffer_current(c->buffer),
3683 sldns_buffer_remaining(c->buffer), 0);
3692 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
3697 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
3700 sldns_buffer_skip(c->buffer, r);
3710 log_assert(h2_session->c->type == comm_http);
3711 log_assert(h2_session->c->h2_session);
3714 if(h2_session->c->ssl) {
3717 r = SSL_write(h2_session->c->ssl, buf, len);
3719 int want = SSL_get_error(h2_session->c->ssl, r);
3723 h2_session->c->ssl_shake_state = comm_ssl_shake_hs_read;
3724 comm_point_listen_for_rw(h2_session->c, 1, 0);
3745 ret = send(h2_session->c->fd, buf, len, 0);
3761 &h2_session->c->repinfo.remote_addr,
3762 h2_session->c->repinfo.remote_addrlen);
3769 ub_winsock_tcp_wouldblock(h2_session->c->ev->ev,
3777 &h2_session->c->repinfo.remote_addr,
3778 h2_session->c->repinfo.remote_addrlen);
3788 comm_point_http2_handle_write(int ATTR_UNUSED(fd), struct comm_point* c) argument
3792 log_assert(c->h2_session);
3794 ret = nghttp2_session_send(c->h2_session->session);
3801 if(nghttp2_session_want_read(c->h2_session->session)) {
3802 c->tcp_is_reading = 1;
3803 comm_point_stop_listening(c);
3804 comm_point_start_listening(c, -1, adjusted_tcp_timeout(c));
3805 } else if(!nghttp2_session_want_write(c->h2_session->session))
3809 (void)c;
3821 comm_point_http_handle_write(int fd, struct comm_point* c) argument
3823 log_assert(c->type == comm_http);
3828 if(c->tcp_check_nb_connect) {
3829 int r = http_check_connect(fd, c);
3832 c->tcp_check_nb_connect = 0;
3836 if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
3837 if(!ssl_handshake(c))
3839 if(c->ssl_shake_state != comm_ssl_shake_none)
3843 if(c->tcp_is_reading)
3846 if(c->use_h2) {
3847 return comm_point_http2_handle_write(fd, c);
3852 if(c->http_min_version >= http_version_2) {
3858 if(c->ssl) {
3859 if(!ssl_http_write_more(c))
3862 if(!http_write_more(fd, c))
3869 if(sldns_buffer_remaining(c->buffer) == 0) {
3870 sldns_buffer_clear(c->buffer);
3871 if(c->tcp_do_toggle_rw)
3872 c->tcp_is_reading = 1;
3873 c->tcp_byte_count = 0;
3875 comm_point_stop_listening(c);
3876 comm_point_start_listening(c, -1, -1);
3884 struct comm_point* c = (struct comm_point*)arg; local
3885 log_assert(c->type == comm_http);
3886 ub_comm_base_now(c->ev->base);
3890 reclaim_http_handler(c);
3891 if(!c->tcp_do_close) {
3892 fptr_ok(fptr_whitelist_comm_point(c->callback));
3893 (void)(*c->callback)(c, c->cb_arg,
3899 if(!comm_point_http_handle_read(fd, c)) {
3900 reclaim_http_handler(c);
3901 if(!c->tcp_do_close) {
3903 c->callback));
3904 (void)(*c->callback)(c, c->cb_arg,
3911 if(!comm_point_http_handle_write(fd, c)) {
3912 reclaim_http_handler(c);
3913 if(!c->tcp_do_close) {
3915 c->callback));
3916 (void)(*c->callback)(c, c->cb_arg,
3927 struct comm_point* c = (struct comm_point*)arg; local
3928 log_assert(c->type == comm_local);
3929 ub_comm_base_now(c->ev->base);
3932 if(!comm_point_tcp_handle_read(fd, c, 1)) {
3933 fptr_ok(fptr_whitelist_comm_point(c->callback));
3934 (void)(*c->callback)(c, c->cb_arg, NETEVENT_CLOSED,
3945 struct comm_point* c = (struct comm_point*)arg; local
3947 log_assert(c->type == comm_raw);
3948 ub_comm_base_now(c->ev->base);
3952 fptr_ok(fptr_whitelist_comm_point_raw(c->callback));
3953 (void)(*c->callback)(c, c->cb_arg, err, NULL);
3961 struct comm_point* c = (struct comm_point*)calloc(1, local
3964 if(!c)
3966 c->ev = (struct internal_event*)calloc(1,
3968 if(!c->ev) {
3969 free(c);
3972 c->ev->base = base;
3973 c->fd = fd;
3974 c->buffer = buffer;
3975 c->timeout = NULL;
3976 c->tcp_is_reading = 0;
3977 c->tcp_byte_count = 0;
3978 c->tcp_parent = NULL;
3979 c->max_tcp_count = 0;
3980 c->cur_tcp_count = 0;
3981 c->tcp_handlers = NULL;
3982 c->tcp_free = NULL;
3983 c->type = comm_udp;
3984 c->tcp_do_close = 0;
3985 c->do_not_close = 0;
3986 c->tcp_do_toggle_rw = 0;
3987 c->tcp_check_nb_connect = 0;
3989 c->tcp_do_fastopen = 0;
3992 c->dnscrypt = 0;
3993 c->dnscrypt_buffer = buffer;
3995 c->inuse = 0;
3996 c->callback = callback;
3997 c->cb_arg = callback_arg;
3998 c->socket = socket;
3999 c->pp2_enabled = pp2_enabled;
4000 c->pp2_header_state = pp2_header_none;
4003 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4004 comm_point_udp_callback, c);
4005 if(c->ev->ev == NULL) {
4007 comm_point_delete(c);
4010 if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
4012 comm_point_delete(c);
4015 c->event_added = 1;
4016 return c;
4025 struct comm_point* c = (struct comm_point*)calloc(1, local
4028 if(!c)
4030 c->ev = (struct internal_event*)calloc(1,
4032 if(!c->ev) {
4033 free(c);
4036 c->ev->base = base;
4037 c->fd = fd;
4038 c->buffer = buffer;
4039 c->timeout = NULL;
4040 c->tcp_is_reading = 0;
4041 c->tcp_byte_count = 0;
4042 c->tcp_parent = NULL;
4043 c->max_tcp_count = 0;
4044 c->cur_tcp_count = 0;
4045 c->tcp_handlers = NULL;
4046 c->tcp_free = NULL;
4047 c->type = comm_udp;
4048 c->tcp_do_close = 0;
4049 c->do_not_close = 0;
4051 c->dnscrypt = 0;
4052 c->dnscrypt_buffer = buffer;
4054 c->inuse = 0;
4055 c->tcp_do_toggle_rw = 0;
4056 c->tcp_check_nb_connect = 0;
4058 c->tcp_do_fastopen = 0;
4060 c->callback = callback;
4061 c->cb_arg = callback_arg;
4062 c->socket = socket;
4063 c->pp2_enabled = pp2_enabled;
4064 c->pp2_header_state = pp2_header_none;
4067 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4068 comm_point_udp_ancil_callback, c);
4069 if(c->ev->ev == NULL) {
4071 comm_point_delete(c);
4074 if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
4076 comm_point_delete(c);
4079 c->event_added = 1;
4080 return c;
4090 struct comm_point* c = (struct comm_point*)calloc(1, local
4093 if(!c)
4095 c->ev = (struct internal_event*)calloc(1,
4097 if(!c->ev) {
4098 free(c);
4101 c->ev->base = base;
4102 c->fd = -1;
4103 c->buffer = sldns_buffer_new(bufsize);
4104 if(!c->buffer) {
4105 free(c->ev);
4106 free(c);
4109 c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
4110 if(!c->timeout) {
4111 sldns_buffer_free(c->buffer);
4112 free(c->ev);
4113 free(c);
4116 c->tcp_is_reading = 0;
4117 c->tcp_byte_count = 0;
4118 c->tcp_parent = parent;
4119 c->tcp_timeout_msec = parent->tcp_timeout_msec;
4120 c->tcp_conn_limit = parent->tcp_conn_limit;
4121 c->tcl_addr = NULL;
4122 c->tcp_keepalive = 0;
4123 c->max_tcp_count = 0;
4124 c->cur_tcp_count = 0;
4125 c->tcp_handlers = NULL;
4126 c->tcp_free = NULL;
4127 c->type = comm_tcp;
4128 c->tcp_do_close = 0;
4129 c->do_not_close = 0;
4130 c->tcp_do_toggle_rw = 1;
4131 c->tcp_check_nb_connect = 0;
4133 c->tcp_do_fastopen = 0;
4136 c->dnscrypt = 0;
4139 c->dnscrypt_buffer = c->buffer;
4141 c->repinfo.c = c;
4142 c->callback = callback;
4143 c->cb_arg = callback_arg;
4144 c->socket = socket;
4145 c->pp2_enabled = parent->pp2_enabled;
4146 c->pp2_header_state = pp2_header_none;
4148 c->tcp_req_info = tcp_req_info_create(spoolbuf);
4149 if(!c->tcp_req_info) {
4151 sldns_buffer_free(c->buffer);
4152 free(c->timeout);
4153 free(c->ev);
4154 free(c);
4157 c->tcp_req_info->cp = c;
4158 c->tcp_do_close = 1;
4159 c->tcp_do_toggle_rw = 0;
4162 c->tcp_free = parent->tcp_free;
4163 parent->tcp_free = c;
4166 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4167 comm_point_tcp_handle_callback, c);
4168 if(c->ev->ev == NULL)
4171 parent->tcp_free = c->tcp_free;
4172 tcp_req_info_delete(c->tcp_req_info);
4173 sldns_buffer_free(c->buffer);
4174 free(c->timeout);
4175 free(c->ev);
4176 free(c);
4179 return c;
4189 struct comm_point* c = (struct comm_point*)calloc(1, local
4192 if(!c)
4194 c->ev = (struct internal_event*)calloc(1,
4196 if(!c->ev) {
4197 free(c);
4200 c->ev->base = base;
4201 c->fd = -1;
4202 c->buffer = sldns_buffer_new(bufsize);
4203 if(!c->buffer) {
4204 free(c->ev);
4205 free(c);
4208 c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
4209 if(!c->timeout) {
4210 sldns_buffer_free(c->buffer);
4211 free(c->ev);
4212 free(c);
4215 c->tcp_is_reading = 0;
4216 c->tcp_byte_count = 0;
4217 c->tcp_parent = parent;
4218 c->tcp_timeout_msec = parent->tcp_timeout_msec;
4219 c->tcp_conn_limit = parent->tcp_conn_limit;
4220 c->tcl_addr = NULL;
4221 c->tcp_keepalive = 0;
4222 c->max_tcp_count = 0;
4223 c->cur_tcp_count = 0;
4224 c->tcp_handlers = NULL;
4225 c->tcp_free = NULL;
4226 c->type = comm_http;
4227 c->tcp_do_close = 1;
4228 c->do_not_close = 0;
4229 c->tcp_do_toggle_rw = 1; /* will be set to 0 after http2 upgrade */
4230 c->tcp_check_nb_connect = 0;
4232 c->tcp_do_fastopen = 0;
4235 c->dnscrypt = 0;
4236 c->dnscrypt_buffer = NULL;
4238 c->repinfo.c = c;
4239 c->callback = callback;
4240 c->cb_arg = callback_arg;
4241 c->socket = socket;
4242 c->pp2_enabled = 0;
4243 c->pp2_header_state = pp2_header_none;
4245 c->http_min_version = http_version_2;
4246 c->http2_stream_max_qbuffer_size = bufsize;
4248 c->http2_stream_max_qbuffer_size = 512;
4249 c->http2_max_streams = http_max_streams;
4250 if(!(c->http_endpoint = strdup(http_endpoint))) {
4252 sldns_buffer_free(c->buffer);
4253 free(c->timeout);
4254 free(c->ev);
4255 free(c);
4258 c->use_h2 = 0;
4260 if(!(c->h2_session = http2_session_create(c))) {
4262 free(c->http_endpoint);
4263 sldns_buffer_free(c->buffer);
4264 free(c->timeout);
4265 free(c->ev);
4266 free(c);
4269 if(!(c->h2_session->callbacks = http2_req_callbacks_create())) {
4271 http2_session_delete(c->h2_session);
4272 free(c->http_endpoint);
4273 sldns_buffer_free(c->buffer);
4274 free(c->timeout);
4275 free(c->ev);
4276 free(c);
4282 c->tcp_free = parent->tcp_free;
4283 parent->tcp_free = c;
4286 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4287 comm_point_http_handle_callback, c);
4288 if(c->ev->ev == NULL)
4291 parent->tcp_free = c->tcp_free;
4292 http2_session_delete(c->h2_session);
4293 sldns_buffer_free(c->buffer);
4294 free(c->timeout);
4295 free(c->ev);
4296 free(c);
4299 return c;
4311 struct comm_point* c = (struct comm_point*)calloc(1, local
4316 if(!c)
4318 c->ev = (struct internal_event*)calloc(1,
4320 if(!c->ev) {
4321 free(c);
4324 c->ev->base = base;
4325 c->fd = fd;
4326 c->buffer = NULL;
4327 c->timeout = NULL;
4328 c->tcp_is_reading = 0;
4329 c->tcp_byte_count = 0;
4330 c->tcp_timeout_msec = idle_timeout;
4331 c->tcp_conn_limit = tcp_conn_limit;
4332 c->tcl_addr = NULL;
4333 c->tcp_keepalive = 0;
4334 c->tcp_parent = NULL;
4335 c->max_tcp_count = num;
4336 c->cur_tcp_count = 0;
4337 c->tcp_handlers = (struct comm_point**)calloc((size_t)num,
4339 if(!c->tcp_handlers) {
4340 free(c->ev);
4341 free(c);
4344 c->tcp_free = NULL;
4345 c->type = comm_tcp_accept;
4346 c->tcp_do_close = 0;
4347 c->do_not_close = 0;
4348 c->tcp_do_toggle_rw = 0;
4349 c->tcp_check_nb_connect = 0;
4351 c->tcp_do_fastopen = 0;
4354 c->dnscrypt = 0;
4355 c->dnscrypt_buffer = NULL;
4357 c->callback = NULL;
4358 c->cb_arg = NULL;
4359 c->socket = socket;
4360 c->pp2_enabled = (port_type==listen_type_http?0:pp2_enabled);
4361 c->pp2_header_state = pp2_header_none;
4364 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4365 comm_point_tcp_accept_callback, c);
4366 if(c->ev->ev == NULL) {
4368 comm_point_delete(c);
4371 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
4373 comm_point_delete(c);
4376 c->event_added = 1;
4382 c->tcp_handlers[i] = comm_point_create_tcp_handler(base,
4383 c, bufsize, spoolbuf, callback, callback_arg, socket);
4385 c->tcp_handlers[i] = comm_point_create_http_handler(
4386 base, c, bufsize, harden_large_queries,
4395 if(!c->tcp_handlers[i]) {
4396 comm_point_delete(c);
4401 return c;
4408 struct comm_point* c = (struct comm_point*)calloc(1, local
4411 if(!c)
4413 c->ev = (struct internal_event*)calloc(1,
4415 if(!c->ev) {
4416 free(c);
4419 c->ev->base = base;
4420 c->fd = -1;
4421 c->buffer = sldns_buffer_new(bufsize);
4422 if(!c->buffer) {
4423 free(c->ev);
4424 free(c);
4427 c->timeout = NULL;
4428 c->tcp_is_reading = 0;
4429 c->tcp_byte_count = 0;
4430 c->tcp_timeout_msec = TCP_QUERY_TIMEOUT;
4431 c->tcp_conn_limit = NULL;
4432 c->tcl_addr = NULL;
4433 c->tcp_keepalive = 0;
4434 c->tcp_parent = NULL;
4435 c->max_tcp_count = 0;
4436 c->cur_tcp_count = 0;
4437 c->tcp_handlers = NULL;
4438 c->tcp_free = NULL;
4439 c->type = comm_tcp;
4440 c->tcp_do_close = 0;
4441 c->do_not_close = 0;
4442 c->tcp_do_toggle_rw = 1;
4443 c->tcp_check_nb_connect = 1;
4445 c->tcp_do_fastopen = 1;
4448 c->dnscrypt = 0;
4449 c->dnscrypt_buffer = c->buffer;
4451 c->repinfo.c = c;
4452 c->callback = callback;
4453 c->cb_arg = callback_arg;
4454 c->pp2_enabled = 0;
4455 c->pp2_header_state = pp2_header_none;
4457 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4458 comm_point_tcp_handle_callback, c);
4459 if(c->ev->ev == NULL)
4462 sldns_buffer_free(c->buffer);
4463 free(c->ev);
4464 free(c);
4468 return c;
4476 struct comm_point* c = (struct comm_point*)calloc(1, local
4479 if(!c)
4481 c->ev = (struct internal_event*)calloc(1,
4483 if(!c->ev) {
4484 free(c);
4487 c->ev->base = base;
4488 c->fd = -1;
4489 c->buffer = sldns_buffer_new(bufsize);
4490 if(!c->buffer) {
4491 free(c->ev);
4492 free(c);
4495 c->timeout = NULL;
4496 c->tcp_is_reading = 0;
4497 c->tcp_byte_count = 0;
4498 c->tcp_parent = NULL;
4499 c->max_tcp_count = 0;
4500 c->cur_tcp_count = 0;
4501 c->tcp_handlers = NULL;
4502 c->tcp_free = NULL;
4503 c->type = comm_http;
4504 c->tcp_do_close = 0;
4505 c->do_not_close = 0;
4506 c->tcp_do_toggle_rw = 1;
4507 c->tcp_check_nb_connect = 1;
4508 c->http_in_headers = 1;
4509 c->http_in_chunk_headers = 0;
4510 c->http_is_chunked = 0;
4511 c->http_temp = temp;
4513 c->tcp_do_fastopen = 1;
4516 c->dnscrypt = 0;
4517 c->dnscrypt_buffer = c->buffer;
4519 c->repinfo.c = c;
4520 c->callback = callback;
4521 c->cb_arg = callback_arg;
4522 c->pp2_enabled = 0;
4523 c->pp2_header_state = pp2_header_none;
4525 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4526 comm_point_http_handle_callback, c);
4527 if(c->ev->ev == NULL)
4531 SSL_free(c->ssl);
4533 sldns_buffer_free(c->buffer);
4534 free(c->ev);
4535 free(c);
4539 return c;
4546 struct comm_point* c = (struct comm_point*)calloc(1, local
4549 if(!c)
4551 c->ev = (struct internal_event*)calloc(1,
4553 if(!c->ev) {
4554 free(c);
4557 c->ev->base = base;
4558 c->fd = fd;
4559 c->buffer = sldns_buffer_new(bufsize);
4560 if(!c->buffer) {
4561 free(c->ev);
4562 free(c);
4565 c->timeout = NULL;
4566 c->tcp_is_reading = 1;
4567 c->tcp_byte_count = 0;
4568 c->tcp_parent = NULL;
4569 c->max_tcp_count = 0;
4570 c->cur_tcp_count = 0;
4571 c->tcp_handlers = NULL;
4572 c->tcp_free = NULL;
4573 c->type = comm_local;
4574 c->tcp_do_close = 0;
4575 c->do_not_close = 1;
4576 c->tcp_do_toggle_rw = 0;
4577 c->tcp_check_nb_connect = 0;
4579 c->tcp_do_fastopen = 0;
4582 c->dnscrypt = 0;
4583 c->dnscrypt_buffer = c->buffer;
4585 c->callback = callback;
4586 c->cb_arg = callback_arg;
4587 c->pp2_enabled = 0;
4588 c->pp2_header_state = pp2_header_none;
4591 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4592 comm_point_local_handle_callback, c);
4593 if(c->ev->ev == NULL) {
4595 free(c->ev);
4596 free(c);
4599 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
4601 ub_event_free(c->ev->ev);
4602 free(c->ev);
4603 free(c);
4606 c->event_added = 1;
4607 return c;
4614 struct comm_point* c = (struct comm_point*)calloc(1, local
4617 if(!c)
4619 c->ev = (struct internal_event*)calloc(1,
4621 if(!c->ev) {
4622 free(c);
4625 c->ev->base = base;
4626 c->fd = fd;
4627 c->buffer = NULL;
4628 c->timeout = NULL;
4629 c->tcp_is_reading = 0;
4630 c->tcp_byte_count = 0;
4631 c->tcp_parent = NULL;
4632 c->max_tcp_count = 0;
4633 c->cur_tcp_count = 0;
4634 c->tcp_handlers = NULL;
4635 c->tcp_free = NULL;
4636 c->type = comm_raw;
4637 c->tcp_do_close = 0;
4638 c->do_not_close = 1;
4639 c->tcp_do_toggle_rw = 0;
4640 c->tcp_check_nb_connect = 0;
4642 c->tcp_do_fastopen = 0;
4645 c->dnscrypt = 0;
4646 c->dnscrypt_buffer = c->buffer;
4648 c->callback = callback;
4649 c->cb_arg = callback_arg;
4650 c->pp2_enabled = 0;
4651 c->pp2_header_state = pp2_header_none;
4656 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
4657 comm_point_raw_handle_callback, c);
4658 if(c->ev->ev == NULL) {
4660 free(c->ev);
4661 free(c);
4664 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
4666 ub_event_free(c->ev->ev);
4667 free(c->ev);
4668 free(c);
4671 c->event_added = 1;
4672 return c;
4676 comm_point_close(struct comm_point* c) argument
4678 if(!c)
4680 if(c->fd != -1) {
4681 verbose(5, "comm_point_close of %d: event_del", c->fd);
4682 if(c->event_added) {
4683 if(ub_event_del(c->ev->ev) != 0) {
4686 c->event_added = 0;
4689 tcl_close_connection(c->tcl_addr);
4690 if(c->tcp_req_info)
4691 tcp_req_info_clear(c->tcp_req_info);
4692 if(c->h2_session)
4693 http2_session_server_delete(c->h2_session);
4695 if(c->tcp_more_read_again && *c->tcp_more_read_again)
4696 *c->tcp_more_read_again = 0;
4697 if(c->tcp_more_write_again && *c->tcp_more_write_again)
4698 *c->tcp_more_write_again = 0;
4701 if(c->fd != -1 && !c->do_not_close) {
4703 if(c->type == comm_tcp || c->type == comm_http) {
4705 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
4706 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
4709 verbose(VERB_ALGO, "close fd %d", c->fd);
4710 sock_close(c->fd);
4712 c->fd = -1;
4716 comm_point_delete(struct comm_point* c) argument
4718 if(!c)
4720 if((c->type == comm_tcp || c->type == comm_http) && c->ssl) {
4722 SSL_shutdown(c->ssl);
4723 SSL_free(c->ssl);
4726 if(c->type == comm_http && c->http_endpoint) {
4727 free(c->http_endpoint);
4728 c->http_endpoint = NULL;
4730 comm_point_close(c);
4731 if(c->tcp_handlers) {
4733 for(i=0; i<c->max_tcp_count; i++)
4734 comm_point_delete(c->tcp_handlers[i]);
4735 free(c->tcp_handlers);
4737 free(c->timeout);
4738 if(c->type == comm_tcp || c->type == comm_local || c->type == comm_http) {
4739 sldns_buffer_free(c->buffer);
4741 if(c->dnscrypt && c->dnscrypt_buffer != c->buffer) {
4742 sldns_buffer_free(c->dnscrypt_buffer);
4745 if(c->tcp_req_info) {
4746 tcp_req_info_delete(c->tcp_req_info);
4748 if(c->h2_session) {
4749 http2_session_delete(c->h2_session);
4752 ub_event_free(c->ev->ev);
4753 free(c->ev);
4754 free(c);
4761 log_assert(repinfo && repinfo->c);
4763 buffer = repinfo->c->dnscrypt_buffer;
4768 buffer = repinfo->c->buffer;
4770 if(repinfo->c->type == comm_udp) {
4772 comm_point_send_udp_msg_if(repinfo->c, buffer,
4776 comm_point_send_udp_msg(repinfo->c, buffer,
4783 if(repinfo->c->dtenv != NULL && repinfo->c->dtenv->log_client_response_messages) {
4784 …log_addr(VERB_ALGO, "from local addr", (void*)repinfo->c->socket->addr, repinfo->c->socket->addrle…
4786 …nt_response(repinfo->c->dtenv, &repinfo->client_addr, (void*)repinfo->c->socket->addr, repinfo->c-…
4794 …if(repinfo->c->tcp_parent->dtenv != NULL && repinfo->c->tcp_parent->dtenv->log_client_response_mes…
4795 …log_addr(VERB_ALGO, "from local addr", (void*)repinfo->c->socket->addr, repinfo->c->socket->addrle…
4797 …ient_response(repinfo->c->tcp_parent->dtenv, &repinfo->client_addr, (void*)repinfo->c->socket->add…
4798 ( repinfo->c->tcp_req_info? repinfo->c->tcp_req_info->spool_buffer: repinfo->c->buffer ));
4801 if(repinfo->c->tcp_req_info) {
4802 tcp_req_info_send_reply(repinfo->c->tcp_req_info);
4803 } else if(repinfo->c->use_h2) {
4804 if(!http2_submit_dns_response(repinfo->c->h2_session)) {
4808 repinfo->c->h2_stream = NULL;
4809 repinfo->c->tcp_is_reading = 0;
4810 comm_point_stop_listening(repinfo->c);
4811 comm_point_start_listening(repinfo->c, -1,
4812 adjusted_tcp_timeout(repinfo->c));
4815 comm_point_start_listening(repinfo->c, -1,
4816 adjusted_tcp_timeout(repinfo->c));
4826 log_assert(repinfo->c);
4827 log_assert(repinfo->c->type != comm_tcp_accept);
4828 if(repinfo->c->type == comm_udp)
4830 if(repinfo->c->tcp_req_info)
4831 repinfo->c->tcp_req_info->is_drop = 1;
4832 if(repinfo->c->type == comm_http) {
4833 if(repinfo->c->h2_session) {
4834 repinfo->c->h2_session->is_drop = 1;
4835 if(!repinfo->c->h2_session->postpone_drop)
4836 reclaim_http_handler(repinfo->c);
4839 reclaim_http_handler(repinfo->c);
4842 reclaim_tcp_handler(repinfo->c);
4846 comm_point_stop_listening(struct comm_point* c) argument
4848 verbose(VERB_ALGO, "comm point stop listening %d", c->fd);
4849 if(c->event_added) {
4850 if(ub_event_del(c->ev->ev) != 0) {
4853 c->event_added = 0;
4858 comm_point_start_listening(struct comm_point* c, int newfd, int msec) argument
4861 c->fd==-1?newfd:c->fd, msec);
4862 if(c->type == comm_tcp_accept && !c->tcp_free) {
4866 if(c->event_added) {
4867 if(ub_event_del(c->ev->ev) != 0) {
4870 c->event_added = 0;
4873 if(!c->timeout) {
4874 c->timeout = (struct timeval*)malloc(sizeof(
4876 if(!c->timeout) {
4881 ub_event_add_bits(c->ev->ev, UB_EV_TIMEOUT);
4883 c->timeout->tv_sec = msec/1000;
4884 c->timeout->tv_usec = (msec%1000)*1000;
4887 if(msec == 0 || !c->timeout) {
4888 ub_event_del_bits(c->ev->ev, UB_EV_TIMEOUT);
4891 if(c->type == comm_tcp || c->type == comm_http) {
4892 ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
4893 if(c->tcp_write_and_read) {
4894 verbose(5, "startlistening %d mode rw", (newfd==-1?c->fd:newfd));
4895 ub_event_add_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
4896 } else if(c->tcp_is_reading) {
4897 verbose(5, "startlistening %d mode r", (newfd==-1?c->fd:newfd));
4898 ub_event_add_bits(c->ev->ev, UB_EV_READ);
4900 verbose(5, "startlistening %d mode w", (newfd==-1?c->fd:newfd));
4901 ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
4905 if(c->fd != -1 && c->fd != newfd) {
4906 verbose(5, "cpsl close of fd %d for %d", c->fd, newfd);
4907 sock_close(c->fd);
4909 c->fd = newfd;
4910 ub_event_set_fd(c->ev->ev, c->fd);
4912 if(ub_event_add(c->ev->ev, msec==0?NULL:c->timeout) != 0) {
4916 c->event_added = 1;
4919 void comm_point_listen_for_rw(struct comm_point* c, int rd, int wr) argument
4921 verbose(VERB_ALGO, "comm point listen_for_rw %d %d", c->fd, wr);
4922 if(c->event_added) {
4923 if(ub_event_del(c->ev->ev) != 0) {
4926 c->event_added = 0;
4928 if(!c->timeout) {
4929 ub_event_del_bits(c->ev->ev, UB_EV_TIMEOUT);
4931 ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
4932 if(rd) ub_event_add_bits(c->ev->ev, UB_EV_READ);
4933 if(wr) ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
4934 if(ub_event_add(c->ev->ev, c->timeout) != 0) {
4938 c->event_added = 1;
4941 size_t comm_point_get_mem(struct comm_point* c) argument
4944 if(!c)
4946 s = sizeof(*c) + sizeof(*c->ev);
4947 if(c->timeout)
4948 s += sizeof(*c->timeout);
4949 if(c->type == comm_tcp || c->type == comm_local) {
4950 s += sizeof(*c->buffer) + sldns_buffer_capacity(c->buffer);
4952 s += sizeof(*c->dnscrypt_buffer);
4953 if(c->buffer != c->dnscrypt_buffer) {
4954 s += sldns_buffer_capacity(c->dnscrypt_buffer);
4958 if(c->type == comm_tcp_accept) {
4960 for(i=0; i<c->max_tcp_count; i++)
4961 s += comm_point_get_mem(c->tcp_handlers[i]);