Lines Matching +full:- +full:c
2 * util/netevent.c - event notification
4 * Copyright (c) 2007, NLnet Labs. All rights reserved.
86 /* -------- Start of local definitions -------- */
94 # define CMSG_ALIGN(len) (((len)+sizeof(long)-1) & ~(sizeof(long)-1))
201 /* -------- End of local definitions -------- */
212 b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base)); in comm_base_create()
213 if(!b->eb) { in comm_base_create()
217 b->eb->base = ub_default_event_base(sigs, &b->eb->secs, &b->eb->now); in comm_base_create()
218 if(!b->eb->base) { in comm_base_create()
219 free(b->eb); in comm_base_create()
224 ub_get_event_sys(b->eb->base, &evnm, &evsys, &evmethod); in comm_base_create()
236 b->eb = (struct internal_base*)calloc(1, sizeof(struct internal_base)); in comm_base_create_event()
237 if(!b->eb) { in comm_base_create_event()
241 b->eb->base = base; in comm_base_create_event()
251 if(b->eb->slow_accept_enabled) { in comm_base_delete()
252 if(ub_event_del(b->eb->slow_accept) != 0) { in comm_base_delete()
255 ub_event_free(b->eb->slow_accept); in comm_base_delete()
257 ub_event_base_free(b->eb->base); in comm_base_delete()
258 b->eb->base = NULL; in comm_base_delete()
259 free(b->eb); in comm_base_delete()
268 if(b->eb->slow_accept_enabled) { in comm_base_delete_no_base()
269 if(ub_event_del(b->eb->slow_accept) != 0) { in comm_base_delete_no_base()
272 ub_event_free(b->eb->slow_accept); in comm_base_delete_no_base()
274 b->eb->base = NULL; in comm_base_delete_no_base()
275 free(b->eb); in comm_base_delete_no_base()
282 *tt = &b->eb->secs; in comm_base_timept()
283 *tv = &b->eb->now; in comm_base_timept()
290 retval = ub_event_base_dispatch(b->eb->base); in comm_base_dispatch()
299 if(ub_event_base_loopexit(b->eb->base) != 0) { in comm_base_exit()
307 b->stop_accept = stop_acc; in comm_base_set_slow_accept_handlers()
308 b->start_accept = start_acc; in comm_base_set_slow_accept_handlers()
309 b->cb_arg = arg; in comm_base_set_slow_accept_handlers()
314 return b->eb->base; in comm_base_internal()
382 comm_point_send_udp_msg(struct comm_point *c, sldns_buffer* packet, argument
386 log_assert(c->fd != -1);
393 sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
397 sent = send(c->fd, (void*)sldns_buffer_begin(packet),
400 if(sent == -1) {
419 while(sent == -1 && retries < SEND_BLOCKED_MAX_RETRY && (
444 p.fd = c->fd;
454 struct comm_base* b = c->ev->base;
455 if(b->eb->last_writewait_log+SLOW_LOG_TIME <=
456 b->eb->secs) {
457 b->eb->last_writewait_log = b->eb->secs;
522 sent = sendto(c->fd, (void*)sldns_buffer_begin(packet),
526 sent = send(c->fd, (void*)sldns_buffer_begin(packet),
532 if(sent == -1) {
556 if(r->srctype != 4 && r->srctype != 6) {
557 log_info("%s: unknown srctype %d", str, r->srctype);
561 if(r->srctype == 6) {
564 if(inet_ntop(AF_INET6, &r->pktinfo.v6info.ipi6_addr,
568 buf[sizeof(buf)-1]=0;
569 log_info("%s: %s %d", str, buf, r->pktinfo.v6info.ipi6_ifindex);
571 } else if(r->srctype == 4) {
574 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_addr,
578 buf1[sizeof(buf1)-1]=0;
580 if(inet_ntop(AF_INET, &r->pktinfo.v4info.ipi_spec_dst,
584 buf2[sizeof(buf2)-1]=0;
588 log_info("%s: %d %s %s", str, r->pktinfo.v4info.ipi_ifindex,
592 if(inet_ntop(AF_INET, &r->pktinfo.v4addr,
596 buf1[sizeof(buf1)-1]=0;
605 comm_point_send_udp_msg_if(struct comm_point *c, sldns_buffer* packet, argument
620 log_assert(c->fd != -1);
641 if(r->srctype == 4) {
646 cmsg->cmsg_level = IPPROTO_IP;
647 cmsg->cmsg_type = IP_PKTINFO;
648 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4info,
652 ((struct in_pktinfo *) cmsg_data)->ipi_ifindex = 0;
653 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
655 if(sizeof(struct in_pktinfo) < cmsg->cmsg_len)
657 sizeof(struct in_pktinfo), 0, cmsg->cmsg_len
658 - sizeof(struct in_pktinfo));
662 cmsg->cmsg_level = IPPROTO_IP;
663 cmsg->cmsg_type = IP_SENDSRCADDR;
664 memmove(CMSG_DATA(cmsg), &r->pktinfo.v4addr,
666 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
668 if(sizeof(struct in_addr) < cmsg->cmsg_len)
670 sizeof(struct in_addr), 0, cmsg->cmsg_len
671 - sizeof(struct in_addr));
676 } else if(r->srctype == 6) {
680 cmsg->cmsg_level = IPPROTO_IPV6;
681 cmsg->cmsg_type = IPV6_PKTINFO;
682 memmove(CMSG_DATA(cmsg), &r->pktinfo.v6info,
686 ((struct in6_pktinfo *) cmsg_data)->ipi6_ifindex = 0;
687 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
689 if(sizeof(struct in6_pktinfo) < cmsg->cmsg_len)
691 sizeof(struct in6_pktinfo), 0, cmsg->cmsg_len
692 - sizeof(struct in6_pktinfo));
697 cmsg->cmsg_level = IPPROTO_IPV6;
698 cmsg->cmsg_type = IPV6_PKTINFO;
700 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
702 if(sizeof(struct in6_pktinfo) < cmsg->cmsg_len)
704 sizeof(struct in6_pktinfo), 0, cmsg->cmsg_len
705 - sizeof(struct in6_pktinfo));
708 if(verbosity >= VERB_ALGO && r->srctype != 0)
710 sent = sendmsg(c->fd, &msg, 0);
711 if(sent == -1) {
728 while(sent == -1 && retries < SEND_BLOCKED_MAX_RETRY && (
753 p.fd = c->fd;
763 struct comm_base* b = c->ev->base;
764 if(b->eb->last_writewait_log+SLOW_LOG_TIME <=
765 b->eb->secs) {
766 b->eb->last_writewait_log = b->eb->secs;
830 sent = sendmsg(c->fd, &msg, 0);
834 if(sent == -1) {
842 if(errno == EINVAL && r->srctype == 4)
844 "Please disable interface-automatic");
854 (void)c;
909 size = PP2_HEADER_SIZE + ntohs(header->len);
910 if((header->ver_cmd & 0xF) == PP2_CMD_LOCAL) {
915 if(header->fam_prot == PP2_UNSPEC_UNSPEC) {
922 switch(header->fam_prot) {
927 (struct sockaddr_in*)&rep->client_addr;
928 addr->sin_family = AF_INET;
929 addr->sin_addr.s_addr = header->addr.addr4.src_addr;
930 addr->sin_port = header->addr.addr4.src_port;
931 rep->client_addrlen = (socklen_t)sizeof(struct sockaddr_in);
939 (struct sockaddr_in6*)&rep->client_addr;
941 addr->sin6_family = AF_INET6;
942 memcpy(&addr->sin6_addr,
943 header->addr.addr6.src_addr, 16);
944 addr->sin6_port = header->addr.addr6.src_port;
945 rep->client_addrlen = (socklen_t)sizeof(struct sockaddr_in6);
951 "protocol 0x%x", (int)header->fam_prot);
954 rep->is_proxied = 1;
961 sldns_buffer_limit(buf)-size);
962 sldns_buffer_set_limit(buf, sldns_buffer_limit(buf)-size);
987 rep.c = (struct comm_point*)arg;
988 log_assert(rep.c->type == comm_udp);
992 log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
993 ub_comm_base_now(rep.c->ev->base);
995 sldns_buffer_clear(rep.c->buffer);
996 timeval_clear(&rep.c->recv_tv);
998 log_assert(fd != -1);
999 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
1002 iov[0].iov_base = sldns_buffer_begin(rep.c->buffer);
1003 iov[0].iov_len = sldns_buffer_remaining(rep.c->buffer);
1012 if(rcv == -1) {
1020 sldns_buffer_skip(rep.c->buffer, rcv);
1021 sldns_buffer_flip(rep.c->buffer);
1027 if( cmsg->cmsg_level == IPPROTO_IPV6 &&
1028 cmsg->cmsg_type == IPV6_PKTINFO) {
1034 } else if( cmsg->cmsg_level == IPPROTO_IP &&
1035 cmsg->cmsg_type == IP_PKTINFO) {
1041 } else if( cmsg->cmsg_level == IPPROTO_IP &&
1042 cmsg->cmsg_type == IP_RECVDSTADDR) {
1049 } else if( cmsg->cmsg_level == SOL_SOCKET &&
1050 cmsg->cmsg_type == SO_TIMESTAMPNS) {
1052 TIMESPEC_TO_TIMEVAL(&rep.c->recv_tv, ts);
1053 } else if( cmsg->cmsg_level == SOL_SOCKET &&
1054 cmsg->cmsg_type == SO_TIMESTAMPING) {
1056 TIMESPEC_TO_TIMEVAL(&rep.c->recv_tv, ts);
1057 } else if( cmsg->cmsg_level == SOL_SOCKET &&
1058 cmsg->cmsg_type == SO_TIMESTAMP) {
1059 memmove(&rep.c->recv_tv, CMSG_DATA(cmsg), sizeof(struct timeval));
1068 if(rep.c->pp2_enabled && !consume_pp2_header(rep.c->buffer,
1079 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
1080 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
1084 buffer = rep.c->dnscrypt_buffer;
1086 buffer = rep.c->buffer;
1088 (void)comm_point_send_udp_msg_if(rep.c, buffer,
1092 if(!rep.c || rep.c->fd == -1) /* commpoint closed */
1106 rep.c = (struct comm_point*)arg;
1107 log_assert(rep.c->type == comm_udp);
1111 log_assert(rep.c && rep.c->buffer && rep.c->fd == fd);
1112 ub_comm_base_now(rep.c->ev->base);
1114 sldns_buffer_clear(rep.c->buffer);
1116 log_assert(fd != -1);
1117 log_assert(sldns_buffer_remaining(rep.c->buffer) > 0);
1118 rcv = recvfrom(fd, (void*)sldns_buffer_begin(rep.c->buffer),
1119 sldns_buffer_remaining(rep.c->buffer), MSG_DONTWAIT,
1121 if(rcv == -1) {
1137 sldns_buffer_skip(rep.c->buffer, rcv);
1138 sldns_buffer_flip(rep.c->buffer);
1142 if(rep.c->pp2_enabled && !consume_pp2_header(rep.c->buffer,
1153 fptr_ok(fptr_whitelist_comm_point(rep.c->callback));
1154 if((*rep.c->callback)(rep.c, rep.c->cb_arg, NETEVENT_NOERROR, &rep)) {
1157 buffer = rep.c->dnscrypt_buffer;
1159 buffer = rep.c->buffer;
1161 (void)comm_point_send_udp_msg(rep.c, buffer,
1165 if(!rep.c || rep.c->fd != fd) /* commpoint closed to -1 or reused for
1166 another UDP port. Note rep.c cannot be reused with TCP fd. */
1175 paddr->addrlen = (socklen_t)sizeof(paddr->addr);
1176 paddr->localaddrlen = (socklen_t)sizeof(paddr->localaddr);
1177 paddr->ifindex = 0;
1187 (socklen_t)sizeof(val)) == -1) {
1194 (socklen_t)sizeof(val)) == -1) {
1211 if(localaddr->sockaddr.in.sin_family == AF_INET) {
1216 msg->msg_controllen = CMSG_SPACE(sizeof(struct in_pktinfo));
1217 memset(msg->msg_control, 0, msg->msg_controllen);
1218 log_assert(msg->msg_controllen <= control_size);
1219 cmsg->cmsg_level = IPPROTO_IP;
1220 cmsg->cmsg_type = IP_PKTINFO;
1223 memmove(&v4info.ipi_spec_dst, &sa->sin_addr,
1226 memmove(&v4info.ipi_addr, &sa->sin_addr,
1231 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_pktinfo));
1235 msg->msg_controllen = CMSG_SPACE(sizeof(struct in_addr));
1236 memset(msg->msg_control, 0, msg->msg_controllen);
1237 log_assert(msg->msg_controllen <= control_size);
1238 cmsg->cmsg_level = IPPROTO_IP;
1239 cmsg->cmsg_type = IP_SENDSRCADDR;
1240 memmove(CMSG_DATA(cmsg), &sa->sin_addr,
1242 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in_addr));
1248 msg->msg_controllen = CMSG_SPACE(sizeof(struct in6_pktinfo));
1249 memset(msg->msg_control, 0, msg->msg_controllen);
1250 log_assert(msg->msg_controllen <= control_size);
1251 cmsg->cmsg_level = IPPROTO_IPV6;
1252 cmsg->cmsg_type = IPV6_PKTINFO;
1254 memmove(&v6info.ipi6_addr, &sa6->sin6_addr,
1258 cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
1271 if(addr->sockaddr.in.sin_family == AF_INET) {
1274 if(inet_ntop(sa->sin_family, &sa->sin_addr, host,
1276 log_hex("inet_ntop error: address", &sa->sin_addr,
1277 sizeof(sa->sin_addr));
1280 snprintf(port, portlen, "%u", (unsigned)ntohs(sa->sin_port));
1281 } else if(addr->sockaddr.in.sin_family == AF_INET6) {
1284 if(inet_ntop(sa6->sin6_family, &sa6->sin6_addr, host,
1286 log_hex("inet_ntop error: address", &sa6->sin6_addr,
1287 sizeof(sa6->sin6_addr));
1290 snprintf(port, portlen, "%u", (unsigned)ntohs(sa6->sin6_port));
1297 doq_store_blocked_pkt(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1300 if(c->doq_socket->have_blocked_pkt)
1303 if(sldns_buffer_limit(c->doq_socket->pkt_buf) >
1304 sldns_buffer_capacity(c->doq_socket->blocked_pkt))
1307 c->doq_socket->have_blocked_pkt = 1;
1308 c->doq_socket->blocked_pkt_pi.ecn = ecn;
1309 memcpy(c->doq_socket->blocked_paddr, paddr,
1310 sizeof(*c->doq_socket->blocked_paddr));
1311 sldns_buffer_clear(c->doq_socket->blocked_pkt);
1312 sldns_buffer_write(c->doq_socket->blocked_pkt,
1313 sldns_buffer_begin(c->doq_socket->pkt_buf),
1314 sldns_buffer_limit(c->doq_socket->pkt_buf));
1315 sldns_buffer_flip(c->doq_socket->blocked_pkt);
1319 doq_send_pkt(struct comm_point* c, struct doq_pkt_addr* paddr, uint32_t ecn) argument
1328 iov[0].iov_base = sldns_buffer_begin(c->doq_socket->pkt_buf);
1329 iov[0].iov_len = sldns_buffer_limit(c->doq_socket->pkt_buf);
1331 msg.msg_name = (void*)&paddr->addr;
1332 msg.msg_namelen = paddr->addrlen;
1341 doq_set_localaddr_cmsg(&msg, sizeof(control.buf), &paddr->localaddr,
1342 paddr->localaddrlen, paddr->ifindex);
1343 doq_set_ecn(c->fd, paddr->addr.sockaddr.in.sin_family, ecn);
1346 ret = sendmsg(c->fd, &msg, MSG_DONTWAIT);
1347 if(ret == -1 && errno == EINTR)
1351 if(ret == -1) {
1365 doq_store_blocked_pkt(c, paddr, ecn);
1368 if(!udp_send_errno_needs_log((void*)&paddr->addr,
1369 paddr->addrlen))
1373 if(doq_print_addr_port(&paddr->addr, paddr->addrlen,
1384 } else if(ret != (ssize_t)sldns_buffer_limit(c->doq_socket->pkt_buf)) {
1386 if(doq_print_addr_port(&paddr->addr, paddr->addrlen, host,
1391 (int)sldns_buffer_limit(c->doq_socket->pkt_buf));
1395 (int)ret, (int)sldns_buffer_limit(c->doq_socket->pkt_buf));
1405 if(addr->sockaddr.in.sin_family == AF_INET) {
1407 return ntohs(sa->sin_port);
1408 } else if(addr->sockaddr.in.sin_family == AF_INET6) {
1410 return ntohs(sa6->sin6_port);
1417 doq_get_localaddr_cmsg(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1424 memset(&paddr->localaddr, 0, sizeof(paddr->localaddr));
1428 if( cmsg->cmsg_level == IPPROTO_IPV6 &&
1429 cmsg->cmsg_type == IPV6_PKTINFO) {
1433 &paddr->localaddr;
1435 &paddr->addr;
1436 if(rema->sin6_family != AF_INET6) {
1441 sa->sin6_family = AF_INET6;
1442 sa->sin6_port = htons(doq_sockaddr_get_port(
1443 (void*)c->socket->addr));
1444 paddr->ifindex = v6info->ipi6_ifindex;
1445 memmove(&sa->sin6_addr, &v6info->ipi6_addr,
1447 paddr->localaddrlen = sizeof(struct sockaddr_in6);
1450 } else if( cmsg->cmsg_level == IPPROTO_IP &&
1451 cmsg->cmsg_type == IP_PKTINFO) {
1455 &paddr->localaddr;
1457 &paddr->addr;
1458 if(rema->sin_family != AF_INET) {
1463 sa->sin_family = AF_INET;
1464 sa->sin_port = htons(doq_sockaddr_get_port(
1465 (void*)c->socket->addr));
1466 paddr->ifindex = v4info->ipi_ifindex;
1467 memmove(&sa->sin_addr, &v4info->ipi_addr,
1469 paddr->localaddrlen = sizeof(struct sockaddr_in);
1472 } else if( cmsg->cmsg_level == IPPROTO_IP &&
1473 cmsg->cmsg_type == IP_RECVDSTADDR) {
1475 &paddr->localaddr;
1477 &paddr->addr;
1478 if(rema->sin_family != AF_INET) {
1483 sa->sin_family = AF_INET;
1484 sa->sin_port = htons(doq_sockaddr_get_port(
1485 (void*)c->socket->addr));
1486 paddr->ifindex = 0;
1489 paddr->localaddrlen = sizeof(struct sockaddr_in);
1508 if(cmsg->cmsg_level == IPPROTO_IPV6 &&
1509 cmsg->cmsg_type == IPV6_TCLASS &&
1510 cmsg->cmsg_len != 0) {
1519 if(cmsg->cmsg_level == IPPROTO_IP &&
1520 cmsg->cmsg_type == IP_TOS &&
1521 cmsg->cmsg_len != 0) {
1534 doq_recv(struct comm_point* c, struct doq_pkt_addr* paddr, int* pkt_continue, argument
1545 msg.msg_name = &paddr->addr;
1546 msg.msg_namelen = (socklen_t)sizeof(paddr->addr);
1547 iov[0].iov_base = sldns_buffer_begin(c->doq_socket->pkt_buf);
1548 iov[0].iov_len = sldns_buffer_remaining(c->doq_socket->pkt_buf);
1557 rcv = recvmsg(c->fd, &msg, MSG_DONTWAIT);
1558 if(rcv == -1) {
1567 paddr->addrlen = msg.msg_namelen;
1568 sldns_buffer_skip(c->doq_socket->pkt_buf, rcv);
1569 sldns_buffer_flip(c->doq_socket->pkt_buf);
1570 if(!doq_get_localaddr_cmsg(c, paddr, pkt_continue, &msg))
1572 pi->ecn = msghdr_get_ecn(&msg, paddr->addr.sockaddr.in.sin_family);
1579 doq_send_version_negotiation(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1591 unused_random = ub_random_max(c->doq_socket->rnd, 256);
1592 sldns_buffer_clear(c->doq_socket->pkt_buf);
1594 sldns_buffer_begin(c->doq_socket->pkt_buf),
1595 sldns_buffer_capacity(c->doq_socket->pkt_buf), unused_random,
1602 sldns_buffer_set_position(c->doq_socket->pkt_buf, ret);
1603 sldns_buffer_flip(c->doq_socket->pkt_buf);
1604 doq_send_pkt(c, paddr, 0);
1625 node = rbtree_search(table->conn_tree, &key);
1627 return (struct doq_conn*)node->key;
1637 lock_rw_rdlock(&table->conid_lock);
1642 struct doq_conn_key key = conid->key;
1644 log_assert(conid->key.dcidlen <= NGTCP2_MAX_CIDLEN);
1645 memcpy(cid, conid->key.dcid, conid->key.dcidlen);
1647 lock_rw_unlock(&table->conid_lock);
1650 lock_rw_rdlock(&table->lock);
1659 lock_rw_unlock(&table->lock);
1662 lock_basic_lock(&conn->lock);
1663 if(conn->is_deleted) {
1664 lock_rw_unlock(&table->lock);
1665 lock_basic_unlock(&conn->lock);
1668 lock_rw_unlock(&table->lock);
1671 lock_rw_unlock(&table->conid_lock);
1681 lock_rw_rdlock(&table->lock);
1682 conn = doq_conn_find(table, &paddr->addr, paddr->addrlen,
1683 &paddr->localaddr, paddr->localaddrlen, paddr->ifindex,
1685 if(conn && conn->is_deleted) {
1689 lock_basic_lock(&conn->lock);
1690 lock_rw_unlock(&table->lock);
1693 lock_rw_unlock(&table->lock);
1705 doq_decode_pkt_header_negotiate(struct comm_point* c, argument
1719 sldns_buffer_begin(c->doq_socket->pkt_buf),
1720 sldns_buffer_limit(c->doq_socket->pkt_buf),
1721 c->doq_socket->sv_scidlen);
1724 &scid, &scidlen, sldns_buffer_begin(c->doq_socket->pkt_buf),
1725 sldns_buffer_limit(c->doq_socket->pkt_buf), c->doq_socket->sv_scidlen);
1730 doq_send_version_negotiation(c, paddr,
1768 *conn = doq_conn_find_by_addr_or_cid(c->doq_socket->table, paddr,
1776 (*conn)->doq_socket = c->doq_socket;
1793 doq_send_retry(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1802 if(!doq_print_addr_port(&paddr->addr, paddr->addrlen, host,
1810 scid.datalen = c->doq_socket->sv_scidlen;
1811 doq_cid_randfill(&scid, scid.datalen, c->doq_socket->rnd);
1816 c->doq_socket->static_secret, c->doq_socket->static_secret_len,
1817 hd->version, (void*)&paddr->addr, paddr->addrlen, &scid,
1818 &hd->dcid, ts);
1825 sldns_buffer_clear(c->doq_socket->pkt_buf);
1826 ret = ngtcp2_crypto_write_retry(sldns_buffer_begin(c->doq_socket->pkt_buf),
1827 sldns_buffer_capacity(c->doq_socket->pkt_buf), hd->version,
1828 &hd->scid, &scid, &hd->dcid, token, tokenlen);
1834 sldns_buffer_set_position(c->doq_socket->pkt_buf, ret);
1835 sldns_buffer_flip(c->doq_socket->pkt_buf);
1836 doq_send_pkt(c, paddr, 0);
1841 doq_send_stateless_connection_close(struct comm_point* c, argument
1846 sldns_buffer_clear(c->doq_socket->pkt_buf);
1848 sldns_buffer_begin(c->doq_socket->pkt_buf),
1849 sldns_buffer_capacity(c->doq_socket->pkt_buf), hd->version, &hd->scid,
1850 &hd->dcid, error_code, NULL, 0);
1856 sldns_buffer_set_position(c->doq_socket->pkt_buf, ret);
1857 sldns_buffer_flip(c->doq_socket->pkt_buf);
1858 doq_send_pkt(c, paddr, 0);
1863 doq_verify_retry_token(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1868 if(!doq_print_addr_port(&paddr->addr, paddr->addrlen, host,
1878 hd->token, hd->tokenlen,
1880 hd->token.base, hd->token.len,
1882 c->doq_socket->static_secret,
1883 c->doq_socket->static_secret_len, hd->version,
1884 (void*)&paddr->addr, paddr->addrlen, &hd->dcid,
1896 doq_verify_token(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1901 if(!doq_print_addr_port(&paddr->addr, paddr->addrlen, host,
1910 hd->token, hd->tokenlen,
1912 hd->token.base, hd->token.len,
1914 c->doq_socket->static_secret, c->doq_socket->static_secret_len,
1915 (void*)&paddr->addr, paddr->addrlen, 3600*NGTCP2_SECONDS,
1927 doq_delete_connection(struct comm_point* c, struct doq_conn* conn) argument
1935 conn->is_deleted = 1;
1937 copy.key = conn->key;
1938 log_assert(conn->key.dcidlen <= NGTCP2_MAX_CIDLEN);
1939 memcpy(cid, conn->key.dcid, conn->key.dcidlen);
1942 lock_basic_unlock(&conn->lock);
1945 lock_rw_wrlock(&c->doq_socket->table->lock);
1946 node = rbtree_delete(c->doq_socket->table->conn_tree, copy.node.key);
1948 conn = (struct doq_conn*)node->key;
1949 lock_basic_lock(&conn->lock);
1950 doq_conn_write_list_remove(c->doq_socket->table, conn);
1951 if(conn->timer.timer_in_list) {
1956 doq_timer_list_remove(c->doq_socket->table,
1957 &conn->timer);
1959 if(conn->timer.timer_in_tree)
1960 doq_timer_tree_remove(c->doq_socket->table,
1961 &conn->timer);
1963 lock_rw_unlock(&c->doq_socket->table->lock);
1965 lock_basic_unlock(&conn->lock);
1966 doq_table_quic_size_subtract(c->doq_socket->table,
1967 sizeof(*conn)+conn->key.dcidlen);
1968 doq_conn_delete(conn, c->doq_socket->table);
1976 doq_setup_new_conn(struct comm_point* c, struct doq_pkt_addr* paddr, argument
1980 if(!doq_table_quic_size_available(c->doq_socket->table,
1981 c->doq_socket->cfg, sizeof(*conn)+hd->dcid.datalen
1986 doq_send_stateless_connection_close(c, paddr, hd,
1990 conn = doq_conn_create(c, paddr, hd->dcid.data, hd->dcid.datalen,
1991 hd->version);
1996 lock_rw_wrlock(&c->doq_socket->table->lock);
1997 lock_basic_lock(&conn->lock);
1998 if(!rbtree_insert(c->doq_socket->table->conn_tree, &conn->node)) {
1999 lock_rw_unlock(&c->doq_socket->table->lock);
2002 lock_basic_unlock(&conn->lock);
2003 doq_conn_delete(conn, c->doq_socket->table);
2006 lock_rw_unlock(&c->doq_socket->table->lock);
2007 doq_table_quic_size_add(c->doq_socket->table,
2008 sizeof(*conn)+conn->key.dcidlen);
2014 if(!doq_conn_setup(conn, hd->scid.data, hd->scid.datalen,
2015 (ocid?ocid->data:NULL), (ocid?ocid->datalen:0),
2017 hd->token, hd->tokenlen
2019 hd->token.base, hd->token.len
2023 doq_delete_connection(c, conn);
2031 doq_address_validation(struct comm_point* c, struct doq_pkt_addr* paddr, argument
2036 const uint8_t* token = hd->token;
2037 size_t tokenlen = hd->tokenlen;
2039 const uint8_t* token = hd->token.base;
2040 size_t tokenlen = hd->token.len;
2045 doq_send_retry(c, paddr, hd);
2049 hd->dcid.datalen < NGTCP2_MIN_INITIAL_DCIDLEN) {
2050 doq_send_stateless_connection_close(c, paddr, hd,
2055 if(!doq_verify_retry_token(c, paddr, ocid, hd)) {
2056 doq_send_stateless_connection_close(c, paddr, hd,
2062 if(!doq_verify_token(c, paddr, hd)) {
2063 doq_send_retry(c, paddr, hd);
2067 hd->token = NULL;
2068 hd->tokenlen = 0;
2070 hd->token.base = NULL;
2071 hd->token.len = 0;
2077 if(c->doq_socket->validate_addr) {
2078 doq_send_retry(c, paddr, hd);
2082 hd->token = NULL;
2083 hd->tokenlen = 0;
2085 hd->token.base = NULL;
2086 hd->token.len = 0;
2094 doq_accept(struct comm_point* c, struct doq_pkt_addr* paddr, argument
2102 rv = ngtcp2_accept(&hd, sldns_buffer_begin(c->doq_socket->pkt_buf),
2103 sldns_buffer_limit(c->doq_socket->pkt_buf));
2106 doq_send_retry(c, paddr, &hd);
2113 if(c->doq_socket->validate_addr ||
2120 if(!doq_address_validation(c, paddr, &hd, &ocid, &pocid))
2123 *conn = doq_setup_new_conn(c, paddr, &hd, pocid);
2126 (*conn)->doq_socket = c->doq_socket;
2127 if(!doq_conn_recv(c, paddr, *conn, pi, &err_retry, NULL)) {
2129 doq_send_retry(c, paddr, &hd);
2130 doq_delete_connection(c, *conn);
2139 doq_pickup_timer(struct comm_point* c) argument
2146 lock_rw_wrlock(&c->doq_socket->table->lock);
2147 RBTREE_FOR(t, struct doq_timer*, c->doq_socket->table->timer_tree) {
2148 if(t->worker_doq_socket == NULL ||
2149 t->worker_doq_socket == c->doq_socket) {
2151 t->worker_doq_socket = c->doq_socket;
2153 memcpy(&tv, &t->time, sizeof(tv));
2157 lock_rw_unlock(&c->doq_socket->table->lock);
2161 timeval_subtract(&rel, &tv, c->doq_socket->now_tv);
2162 comm_timer_set(c->doq_socket->timer, &rel);
2163 memcpy(&c->doq_socket->marked_time, &tv,
2164 sizeof(c->doq_socket->marked_time));
2169 if(comm_timer_is_set(c->doq_socket->timer))
2170 comm_timer_disable(c->doq_socket->timer);
2171 memset(&c->doq_socket->marked_time, 0,
2172 sizeof(c->doq_socket->marked_time));
2179 doq_done_setup_timer_and_write(struct comm_point* c, struct doq_conn* conn) argument
2189 conn->doq_socket = NULL;
2193 if( (conn->write_interest && !conn->on_write_list) ||
2194 (!conn->write_interest && conn->on_write_list))
2199 lock_basic_unlock(&conn->lock);
2206 copy.key = conn->key;
2207 log_assert(conn->key.dcidlen <= NGTCP2_MAX_CIDLEN);
2208 memcpy(cid, conn->key.dcid, conn->key.dcidlen);
2211 lock_basic_unlock(&conn->lock);
2213 lock_rw_wrlock(&c->doq_socket->table->lock);
2214 node = rbtree_search(c->doq_socket->table->conn_tree, copy.node.key);
2216 lock_rw_unlock(&c->doq_socket->table->lock);
2220 conn = (struct doq_conn*)node->key;
2221 lock_basic_lock(&conn->lock);
2222 if(conn->is_deleted) {
2224 lock_rw_unlock(&c->doq_socket->table->lock);
2225 lock_basic_unlock(&conn->lock);
2233 doq_conn_set_write_list(c->doq_socket->table, conn);
2236 doq_timer_set(c->doq_socket->table, &conn->timer,
2237 c->doq_socket, &new_tv);
2239 lock_rw_unlock(&c->doq_socket->table->lock);
2240 lock_basic_unlock(&conn->lock);
2245 doq_done_with_conn_cb(struct comm_point* c, struct doq_conn* conn) argument
2253 conn->doq_socket = NULL;
2255 if( (conn->write_interest && conn->on_write_list) ||
2256 (!conn->write_interest && !conn->on_write_list)) {
2259 lock_basic_unlock(&conn->lock);
2265 copy.key = conn->key;
2266 log_assert(conn->key.dcidlen <= NGTCP2_MAX_CIDLEN);
2267 memcpy(cid, conn->key.dcid, conn->key.dcidlen);
2270 lock_basic_unlock(&conn->lock);
2272 lock_rw_wrlock(&c->doq_socket->table->lock);
2273 node = rbtree_search(c->doq_socket->table->conn_tree, copy.node.key);
2275 lock_rw_unlock(&c->doq_socket->table->lock);
2279 conn = (struct doq_conn*)node->key;
2280 lock_basic_lock(&conn->lock);
2281 if(conn->is_deleted) {
2283 lock_rw_unlock(&c->doq_socket->table->lock);
2284 lock_basic_unlock(&conn->lock);
2291 doq_conn_set_write_list(c->doq_socket->table, conn);
2292 lock_rw_unlock(&c->doq_socket->table->lock);
2293 lock_basic_unlock(&conn->lock);
2298 doq_write_list_length(struct comm_point* c) argument
2302 lock_rw_rdlock(&c->doq_socket->table->lock);
2303 conn = c->doq_socket->table->write_list_first;
2306 conn = conn->write_next;
2308 lock_rw_unlock(&c->doq_socket->table->lock);
2314 doq_pop_write_conn(struct comm_point* c) argument
2317 lock_rw_wrlock(&c->doq_socket->table->lock);
2318 conn = doq_table_pop_first(c->doq_socket->table);
2319 while(conn && conn->is_deleted) {
2320 lock_basic_unlock(&conn->lock);
2321 conn = doq_table_pop_first(c->doq_socket->table);
2323 lock_rw_unlock(&c->doq_socket->table->lock);
2325 conn->doq_socket = c->doq_socket;
2331 doq_done_with_write_cb(struct comm_point* c, struct doq_conn* conn, argument
2335 doq_delete_connection(c, conn);
2338 doq_done_setup_timer_and_write(c, conn);
2343 doq_socket_want_write(struct comm_point* c) argument
2346 if(c->doq_socket->have_blocked_pkt)
2348 lock_rw_rdlock(&c->doq_socket->table->lock);
2349 if(c->doq_socket->table->write_list_first)
2351 lock_rw_unlock(&c->doq_socket->table->lock);
2357 doq_socket_write_enable(struct comm_point* c) argument
2360 if(c->doq_socket->event_has_write)
2362 comm_point_listen_for_rw(c, 1, 1);
2363 c->doq_socket->event_has_write = 1;
2368 doq_socket_write_disable(struct comm_point* c) argument
2371 if(!c->doq_socket->event_has_write)
2373 comm_point_listen_for_rw(c, 1, 0);
2374 c->doq_socket->event_has_write = 0;
2379 doq_write_blocked_pkt(struct comm_point* c) argument
2382 if(!c->doq_socket->have_blocked_pkt)
2384 c->doq_socket->have_blocked_pkt = 0;
2385 if(sldns_buffer_limit(c->doq_socket->blocked_pkt) >
2386 sldns_buffer_remaining(c->doq_socket->pkt_buf))
2389 sldns_buffer_clear(c->doq_socket->pkt_buf);
2390 sldns_buffer_write(c->doq_socket->pkt_buf,
2391 sldns_buffer_begin(c->doq_socket->blocked_pkt),
2392 sldns_buffer_limit(c->doq_socket->blocked_pkt));
2393 sldns_buffer_flip(c->doq_socket->pkt_buf);
2394 memcpy(&paddr, c->doq_socket->blocked_paddr, sizeof(paddr));
2395 doq_send_pkt(c, &paddr, c->doq_socket->blocked_pkt_pi.ecn);
2396 if(c->doq_socket->have_blocked_pkt)
2407 lock_rw_wrlock(&doq_socket->table->lock);
2408 node = rbtree_first(doq_socket->table->timer_tree);
2411 conn = t->conn;
2414 if(timeval_smaller(doq_socket->now_tv, &t->time)) {
2415 lock_rw_unlock(&doq_socket->table->lock);
2419 lock_basic_lock(&conn->lock);
2420 conn->doq_socket = doq_socket;
2423 doq_timer_unset(doq_socket->table, t);
2424 lock_rw_unlock(&doq_socket->table->lock);
2427 lock_rw_unlock(&doq_socket->table->lock);
2436 lock_rw_wrlock(&doq_socket->table->lock);
2437 t = doq_timer_find_time(doq_socket->table, &doq_socket->marked_time);
2438 if(t && t->worker_doq_socket == doq_socket)
2439 t->worker_doq_socket = NULL;
2440 lock_rw_unlock(&doq_socket->table->lock);
2441 memset(&doq_socket->marked_time, 0, sizeof(doq_socket->marked_time));
2454 if(conn->is_deleted ||
2456 ngtcp2_conn_in_closing_period(conn->conn) ||
2458 ngtcp2_conn_is_in_closing_period(conn->conn) ||
2461 ngtcp2_conn_in_draining_period(conn->conn)
2463 ngtcp2_conn_is_in_draining_period(conn->conn)
2468 addr_to_str((void*)&conn->key.paddr.addr,
2469 conn->key.paddr.addrlen, remotestr,
2474 doq_delete_connection(doq_socket->cp, conn);
2478 doq_delete_connection(doq_socket->cp, conn);
2479 else doq_done_setup_timer_and_write(doq_socket->cp, conn);
2482 if(doq_socket_want_write(doq_socket->cp))
2483 doq_socket_write_enable(doq_socket->cp);
2484 else doq_socket_write_disable(doq_socket->cp);
2485 doq_pickup_timer(doq_socket->cp);
2491 struct comm_point* c; local
2498 c = (struct comm_point*)arg;
2499 log_assert(c->type == comm_doq);
2501 log_assert(c && c->doq_socket->pkt_buf && c->fd == fd);
2502 ub_comm_base_now(c->ev->base);
2509 if(c->doq_socket->have_blocked_pkt) {
2510 if(!doq_write_blocked_pkt(c)) {
2514 if(!c->doq_socket->event_has_write)
2515 doq_socket_write_enable(c);
2516 doq_pickup_timer(c);
2523 num_len = doq_write_list_length(c);
2524 while((conn = doq_pop_write_conn(c)) != NULL) {
2525 if(conn->is_deleted ||
2527 ngtcp2_conn_in_closing_period(conn->conn) ||
2529 ngtcp2_conn_is_in_closing_period(conn->conn) ||
2532 ngtcp2_conn_in_draining_period(conn->conn)
2534 ngtcp2_conn_is_in_draining_period(conn->conn)
2537 conn->doq_socket = NULL;
2538 lock_basic_unlock(&conn->lock);
2539 if(c->doq_socket->have_blocked_pkt) {
2540 if(!c->doq_socket->event_has_write)
2541 doq_socket_write_enable(c);
2542 doq_pickup_timer(c);
2551 addr_to_str((void*)&conn->key.paddr.addr,
2552 conn->key.paddr.addrlen, remotestr,
2556 &conn->key.paddr.addr));
2558 if(doq_conn_write_streams(c, conn, &err_drop))
2560 doq_done_with_write_cb(c, conn, err_drop);
2561 if(c->doq_socket->have_blocked_pkt) {
2562 if(!c->doq_socket->event_has_write)
2563 doq_socket_write_enable(c);
2564 doq_pickup_timer(c);
2582 if(c->doq_socket->have_blocked_pkt) {
2583 if(!c->doq_socket->event_has_write)
2584 doq_socket_write_enable(c);
2585 doq_pickup_timer(c);
2588 sldns_buffer_clear(c->doq_socket->pkt_buf);
2590 log_assert(fd != -1);
2591 log_assert(sldns_buffer_remaining(c->doq_socket->pkt_buf) > 0);
2592 if(!doq_recv(c, &paddr, &pkt_continue, &pi)) {
2613 (int)sldns_buffer_limit(c->doq_socket->pkt_buf),
2617 if(sldns_buffer_limit(c->doq_socket->pkt_buf) == 0)
2621 if(!doq_decode_pkt_header_negotiate(c, &paddr, &conn))
2624 if(!doq_accept(c, &paddr, &conn, &pi))
2626 if(!doq_conn_write_streams(c, conn, NULL)) {
2627 doq_delete_connection(c, conn);
2630 doq_done_setup_timer_and_write(c, conn);
2635 ngtcp2_conn_in_closing_period(conn->conn)
2637 ngtcp2_conn_is_in_closing_period(conn->conn)
2640 if(!doq_conn_send_close(c, conn)) {
2641 doq_delete_connection(c, conn);
2643 doq_done_setup_timer_and_write(c, conn);
2649 ngtcp2_conn_in_draining_period(conn->conn)
2651 ngtcp2_conn_is_in_draining_period(conn->conn)
2654 doq_done_setup_timer_and_write(c, conn);
2657 if(!doq_conn_recv(c, &paddr, conn, &pi, NULL, &err_drop)) {
2662 doq_delete_connection(c, conn);
2664 doq_done_setup_timer_and_write(c, conn);
2668 if(!doq_conn_write_streams(c, conn, &err_drop)) {
2670 doq_delete_connection(c, conn);
2672 doq_done_setup_timer_and_write(c, conn);
2676 doq_done_setup_timer_and_write(c, conn);
2681 if(doq_socket_want_write(c))
2682 doq_socket_write_enable(c);
2683 else doq_socket_write_disable(c);
2684 doq_pickup_timer(c);
2691 struct comm_point* c, struct comm_base* base, struct config_file* cfg) argument
2699 doq_socket->table = table;
2700 doq_socket->rnd = rnd;
2701 doq_socket->validate_addr = 1;
2703 log_err("doq server socket create: no tls-service-key");
2708 log_err("doq server socket create: no tls-service-pem");
2712 doq_socket->ssl_service_key = strdup(ssl_service_key);
2713 if(!doq_socket->ssl_service_key) {
2717 doq_socket->ssl_service_pem = strdup(ssl_service_pem);
2718 if(!doq_socket->ssl_service_pem) {
2719 free(doq_socket->ssl_service_key);
2723 doq_socket->ssl_verify_pem = NULL;
2726 doq_socket->static_secret_len = table->static_secret_len;
2727 doq_socket->static_secret = memdup(table->static_secret,
2728 table->static_secret_len);
2729 if(!doq_socket->static_secret) {
2730 free(doq_socket->ssl_service_key);
2731 free(doq_socket->ssl_service_pem);
2732 free(doq_socket->ssl_verify_pem);
2737 free(doq_socket->ssl_service_key);
2738 free(doq_socket->ssl_service_pem);
2739 free(doq_socket->ssl_verify_pem);
2740 free(doq_socket->static_secret);
2744 doq_socket->idle_timeout = table->idle_timeout;
2745 doq_socket->sv_scidlen = table->sv_scidlen;
2746 doq_socket->cp = c;
2747 doq_socket->pkt_buf = sldns_buffer_new(doq_buffer_size);
2748 if(!doq_socket->pkt_buf) {
2749 free(doq_socket->ssl_service_key);
2750 free(doq_socket->ssl_service_pem);
2751 free(doq_socket->ssl_verify_pem);
2752 free(doq_socket->static_secret);
2753 SSL_CTX_free(doq_socket->ctx);
2757 doq_socket->blocked_pkt = sldns_buffer_new(
2758 sldns_buffer_capacity(doq_socket->pkt_buf));
2759 if(!doq_socket->pkt_buf) {
2760 free(doq_socket->ssl_service_key);
2761 free(doq_socket->ssl_service_pem);
2762 free(doq_socket->ssl_verify_pem);
2763 free(doq_socket->static_secret);
2764 SSL_CTX_free(doq_socket->ctx);
2765 sldns_buffer_free(doq_socket->pkt_buf);
2769 doq_socket->blocked_paddr = calloc(1,
2770 sizeof(*doq_socket->blocked_paddr));
2771 if(!doq_socket->blocked_paddr) {
2772 free(doq_socket->ssl_service_key);
2773 free(doq_socket->ssl_service_pem);
2774 free(doq_socket->ssl_verify_pem);
2775 free(doq_socket->static_secret);
2776 SSL_CTX_free(doq_socket->ctx);
2777 sldns_buffer_free(doq_socket->pkt_buf);
2778 sldns_buffer_free(doq_socket->blocked_pkt);
2782 doq_socket->timer = comm_timer_create(base, doq_timer_cb, doq_socket);
2783 if(!doq_socket->timer) {
2784 free(doq_socket->ssl_service_key);
2785 free(doq_socket->ssl_service_pem);
2786 free(doq_socket->ssl_verify_pem);
2787 free(doq_socket->static_secret);
2788 SSL_CTX_free(doq_socket->ctx);
2789 sldns_buffer_free(doq_socket->pkt_buf);
2790 sldns_buffer_free(doq_socket->blocked_pkt);
2791 free(doq_socket->blocked_paddr);
2795 memset(&doq_socket->marked_time, 0, sizeof(doq_socket->marked_time));
2796 comm_base_timept(base, &doq_socket->now_tt, &doq_socket->now_tv);
2797 doq_socket->cfg = cfg;
2807 free(doq_socket->static_secret);
2808 SSL_CTX_free(doq_socket->ctx);
2810 free(doq_socket->quic_method);
2812 free(doq_socket->ssl_service_key);
2813 free(doq_socket->ssl_service_pem);
2814 free(doq_socket->ssl_verify_pem);
2815 sldns_buffer_free(doq_socket->pkt_buf);
2816 sldns_buffer_free(doq_socket->blocked_pkt);
2817 free(doq_socket->blocked_paddr);
2818 comm_timer_delete(doq_socket->timer);
2829 lock_rw_rdlock(&table->lock);
2835 lock_basic_lock(&conn->lock);
2836 lock_rw_unlock(&table->lock);
2839 lock_rw_unlock(&table->lock);
2845 doq_lookup_conn_stream(struct comm_reply* repinfo, struct comm_point* c, argument
2848 if(c->doq_socket->current_conn) {
2849 *conn = c->doq_socket->current_conn;
2851 *conn = doq_lookup_repinfo(c->doq_socket->table, repinfo);
2852 if((*conn) && (*conn)->is_deleted) {
2853 lock_basic_unlock(&(*conn)->lock);
2857 (*conn)->doq_socket = c->doq_socket;
2864 *stream = doq_stream_find(*conn, repinfo->doq_streamid);
2866 if(!c->doq_socket->current_conn) {
2869 lock_basic_unlock(&(*conn)->lock);
2873 if((*stream)->is_closed) {
2875 if(!c->doq_socket->current_conn) {
2878 lock_basic_unlock(&(*conn)->lock);
2891 log_assert(repinfo->c->type == comm_doq);
2892 if(!doq_lookup_conn_stream(repinfo, repinfo->c, &conn, &stream)) {
2899 if(!doq_stream_send_reply(conn, stream, repinfo->c->buffer))
2901 if(!repinfo->c->doq_socket->current_conn) {
2904 doq_done_with_conn_cb(repinfo->c, conn);
2910 * repinfo->c->fd, and that collates answers. That would
2912 doq_socket_write_enable(repinfo->c);
2922 log_assert(repinfo->c->type == comm_doq);
2923 if(!doq_lookup_conn_stream(repinfo, repinfo->c, &conn, &stream)) {
2930 if(!repinfo->c->doq_socket->current_conn) {
2933 doq_done_with_conn_cb(repinfo->c, conn);
2934 doq_socket_write_enable(repinfo->c);
2939 int adjusted_tcp_timeout(struct comm_point* c) argument
2941 if(c->tcp_timeout_msec < TCP_QUERY_TIMEOUT_MINIMUM)
2943 return c->tcp_timeout_msec;
2948 setup_tcp_handler(struct comm_point* c, int fd, int cur, int max) argument
2951 log_assert(c->type == comm_tcp || c->type == comm_http);
2952 log_assert(c->fd == -1);
2953 sldns_buffer_clear(c->buffer);
2955 if (c->dnscrypt)
2956 sldns_buffer_clear(c->dnscrypt_buffer);
2958 c->tcp_is_reading = 1;
2959 c->tcp_byte_count = 0;
2960 c->tcp_keepalive = 0;
2975 c->tcp_timeout_msec /= 100;
2977 c->tcp_timeout_msec /= 500;
2979 c->tcp_timeout_msec = 0;
2980 comm_point_start_listening(c, fd, adjusted_tcp_timeout(c));
2987 /* timeout for the slow accept, re-enable accepts again */
2988 if(b->start_accept) {
2990 fptr_ok(fptr_whitelist_start_accept(b->start_accept));
2991 (*b->start_accept)(b->cb_arg);
2992 b->eb->slow_accept_enabled = 0;
2996 int comm_point_perform_accept(struct comm_point* c, argument
3002 new_fd = accept(c->fd, (struct sockaddr*)addr, addrlen);
3005 new_fd = accept4(c->fd, (struct sockaddr*)addr, addrlen, SOCK_NONBLOCK);
3007 if(new_fd == -1) {
3021 return -1;
3026 if(c->ev->base->stop_accept) {
3027 struct comm_base* b = c->ev->base;
3032 if(b->eb->last_slow_log+SLOW_LOG_TIME <=
3033 b->eb->secs) {
3034 b->eb->last_slow_log = b->eb->secs;
3041 b->eb->slow_accept_enabled = 1;
3043 b->stop_accept));
3044 (*b->stop_accept)(b->cb_arg);
3048 b->eb->slow_accept = ub_event_new(b->eb->base,
3049 -1, UB_EV_TIMEOUT,
3051 if(b->eb->slow_accept == NULL) {
3056 else if(ub_event_add(b->eb->slow_accept, &tv)
3065 return -1;
3071 return -1;
3073 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
3074 return -1;
3079 return -1;
3081 if(c->tcp_conn_limit && c->type == comm_tcp_accept) {
3082 c->tcl_addr = tcl_addr_lookup(c->tcp_conn_limit, addr, *addrlen);
3083 if(!tcl_new_connection(c->tcl_addr)) {
3088 return -1;
3134 comm_point_tcp_win_bio_cb(struct comm_point* c, void* thessl) argument
3143 BIO_set_callback_arg(SSL_get_rbio(ssl), (char*)c->ev->ev);
3149 BIO_set_callback_arg(SSL_get_wbio(ssl), (char*)c->ev->ev);
3157 log_assert(h2_session->callbacks);
3158 h2_session->is_drop = 0;
3159 if(nghttp2_session_server_new(&h2_session->session,
3160 h2_session->callbacks,
3175 h2_session->c->http2_max_streams}};
3177 ret = nghttp2_submit_settings(h2_session->session, NGHTTP2_FLAG_NONE,
3192 struct comm_point* c = (struct comm_point*)arg, *c_hdl; local
3194 log_assert(c->type == comm_tcp_accept);
3199 ub_comm_base_now(c->ev->base);
3201 if(!c->tcp_free) {
3206 c_hdl = c->tcp_free;
3209 ub_event_free(c_hdl->ev->ev);
3210 c_hdl->ev->ev = NULL;
3211 if((c_hdl->type == comm_tcp && c_hdl->tcp_req_info) ||
3212 c_hdl->type == comm_local || c_hdl->type == comm_raw)
3213 c_hdl->tcp_do_toggle_rw = 0;
3214 else c_hdl->tcp_do_toggle_rw = 1;
3216 if(c_hdl->type == comm_http) {
3218 if(!c_hdl->h2_session ||
3219 !http2_session_server_create(c_hdl->h2_session)) {
3223 if(!c_hdl->h2_session ||
3224 !http2_submit_settings(c_hdl->h2_session)) {
3228 if(!c->ssl) {
3229 c_hdl->tcp_do_toggle_rw = 0;
3230 c_hdl->use_h2 = 1;
3233 c_hdl->ev->ev = ub_event_new(c_hdl->ev->base->eb->base, -1,
3237 c_hdl->ev->ev = ub_event_new(c_hdl->ev->base->eb->base, -1,
3241 if(!c_hdl->ev->ev) {
3245 log_assert(fd != -1);
3247 new_fd = comm_point_perform_accept(c, &c_hdl->repinfo.remote_addr,
3248 &c_hdl->repinfo.remote_addrlen);
3249 if(new_fd == -1)
3253 c_hdl->repinfo.client_addrlen = c_hdl->repinfo.remote_addrlen;
3254 memmove(&c_hdl->repinfo.client_addr,
3255 &c_hdl->repinfo.remote_addr,
3256 c_hdl->repinfo.remote_addrlen);
3257 if(c->ssl) {
3258 c_hdl->ssl = incoming_ssl_fd(c->ssl, new_fd);
3259 if(!c_hdl->ssl) {
3260 c_hdl->fd = new_fd;
3264 c_hdl->ssl_shake_state = comm_ssl_shake_read;
3266 comm_point_tcp_win_bio_cb(c_hdl, c_hdl->ssl);
3271 c->cur_tcp_count++;
3272 c->tcp_free = c_hdl->tcp_free;
3273 c_hdl->tcp_free = NULL;
3274 if(!c->tcp_free) {
3276 comm_point_stop_listening(c);
3278 setup_tcp_handler(c_hdl, new_fd, c->cur_tcp_count, c->max_tcp_count);
3283 reclaim_tcp_handler(struct comm_point* c) argument
3285 log_assert(c->type == comm_tcp);
3286 if(c->ssl) {
3288 SSL_shutdown(c->ssl);
3289 SSL_free(c->ssl);
3290 c->ssl = NULL;
3293 comm_point_close(c);
3294 if(c->tcp_parent) {
3295 if(c != c->tcp_parent->tcp_free) {
3296 c->tcp_parent->cur_tcp_count--;
3297 c->tcp_free = c->tcp_parent->tcp_free;
3298 c->tcp_parent->tcp_free = c;
3300 if(!c->tcp_free) {
3301 /* re-enable listening on accept socket */
3302 comm_point_start_listening(c->tcp_parent, -1, -1);
3305 c->tcp_more_read_again = NULL;
3306 c->tcp_more_write_again = NULL;
3307 c->tcp_byte_count = 0;
3308 c->pp2_header_state = pp2_header_none;
3309 sldns_buffer_clear(c->buffer);
3314 tcp_callback_writer(struct comm_point* c) argument
3316 log_assert(c->type == comm_tcp);
3317 if(!c->tcp_write_and_read) {
3318 sldns_buffer_clear(c->buffer);
3319 c->tcp_byte_count = 0;
3321 if(c->tcp_do_toggle_rw)
3322 c->tcp_is_reading = 1;
3324 if(c->tcp_req_info) {
3325 tcp_req_info_handle_writedone(c->tcp_req_info);
3327 comm_point_stop_listening(c);
3328 if(c->tcp_write_and_read) {
3329 fptr_ok(fptr_whitelist_comm_point(c->callback));
3330 if( (*c->callback)(c, c->cb_arg, NETEVENT_PKT_WRITTEN,
3331 &c->repinfo) ) {
3332 comm_point_start_listening(c, -1,
3333 adjusted_tcp_timeout(c));
3336 comm_point_start_listening(c, -1,
3337 adjusted_tcp_timeout(c));
3344 tcp_callback_reader(struct comm_point* c) argument
3346 log_assert(c->type == comm_tcp || c->type == comm_local);
3347 sldns_buffer_flip(c->buffer);
3348 if(c->tcp_do_toggle_rw)
3349 c->tcp_is_reading = 0;
3350 c->tcp_byte_count = 0;
3351 if(c->tcp_req_info) {
3352 tcp_req_info_handle_readdone(c->tcp_req_info);
3354 if(c->type == comm_tcp)
3355 comm_point_stop_listening(c);
3356 fptr_ok(fptr_whitelist_comm_point(c->callback));
3357 if( (*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &c->repinfo) ) {
3358 comm_point_start_listening(c, -1,
3359 adjusted_tcp_timeout(c));
3395 ssl_handshake(struct comm_point* c) argument
3398 if(c->ssl_shake_state == comm_ssl_shake_hs_read) {
3400 comm_point_listen_for_rw(c, 0, 1);
3401 c->ssl_shake_state = comm_ssl_shake_none;
3404 if(c->ssl_shake_state == comm_ssl_shake_hs_write) {
3406 comm_point_listen_for_rw(c, 1, 0);
3407 c->ssl_shake_state = comm_ssl_shake_none;
3412 r = SSL_do_handshake(c->ssl);
3414 int want = SSL_get_error(c->ssl, r);
3416 if(c->ssl_shake_state == comm_ssl_shake_read)
3418 c->ssl_shake_state = comm_ssl_shake_read;
3419 comm_point_listen_for_rw(c, 1, 0);
3422 if(c->ssl_shake_state == comm_ssl_shake_write)
3424 c->ssl_shake_state = comm_ssl_shake_write;
3425 comm_point_listen_for_rw(c, 0, 1);
3440 (struct sockaddr*)&c->repinfo.remote_addr,
3441 c->repinfo.remote_addrlen))
3455 if((vr=SSL_get_verify_result(c->ssl)) != 0)
3460 &c->repinfo.remote_addr,
3461 c->repinfo.remote_addrlen);
3467 if((SSL_get_verify_mode(c->ssl)&SSL_VERIFY_PEER)) {
3469 if(SSL_get_verify_result(c->ssl) == X509_V_OK) {
3471 X509* x = SSL_get1_peer_certificate(c->ssl);
3473 X509* x = SSL_get_peer_certificate(c->ssl);
3478 &c->repinfo.remote_addr,
3479 c->repinfo.remote_addrlen);
3484 if(SSL_get0_peername(c->ssl)) {
3488 SSL_get0_peername(c->ssl));
3489 log_addr(VERB_ALGO, buf, &c->repinfo.remote_addr,
3490 c->repinfo.remote_addrlen);
3494 "authenticated", &c->repinfo.remote_addr,
3495 c->repinfo.remote_addrlen);
3502 X509* x = SSL_get1_peer_certificate(c->ssl);
3504 X509* x = SSL_get_peer_certificate(c->ssl);
3512 &c->repinfo.remote_addr,
3513 c->repinfo.remote_addrlen);
3518 * in c->ssl when the ssl object was created from ssl_ctx */
3519 log_addr(VERB_ALGO, "SSL connection", &c->repinfo.remote_addr,
3520 c->repinfo.remote_addrlen);
3525 if(c->type == comm_http && c->h2_session) {
3528 SSL_get0_alpn_selected(c->ssl, &alpn, &alpnlen);
3531 c->tcp_do_toggle_rw = 0;
3532 c->use_h2 = 1;
3541 if(c->tcp_is_reading) {
3542 if(c->ssl_shake_state != comm_ssl_shake_read)
3543 comm_point_listen_for_rw(c, 1, 0);
3545 comm_point_listen_for_rw(c, 0, 1);
3547 c->ssl_shake_state = comm_ssl_shake_none;
3554 ssl_handle_read(struct comm_point* c) argument
3558 if(c->ssl_shake_state != comm_ssl_shake_none) {
3559 if(!ssl_handshake(c))
3561 if(c->ssl_shake_state != comm_ssl_shake_none)
3564 if(c->pp2_enabled && c->pp2_header_state != pp2_header_done) {
3568 if(c->pp2_header_state == pp2_header_none) {
3570 if(sldns_buffer_remaining(c->buffer)<want_read_size) {
3573 &c->repinfo.remote_addr,
3574 c->repinfo.remote_addrlen);
3581 if(c->tcp_byte_count < current_read_size) {
3583 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(
3584 c->buffer, c->tcp_byte_count),
3585 current_read_size -
3586 c->tcp_byte_count)) <= 0) {
3587 int want = SSL_get_error(c->ssl, r);
3589 if(c->tcp_req_info)
3590 return tcp_req_info_handle_read_close(c->tcp_req_info);
3594 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
3598 c->ssl_shake_state = comm_ssl_shake_hs_write;
3599 comm_point_listen_for_rw(c, 0, 1);
3615 c->tcp_byte_count += r;
3616 sldns_buffer_skip(c->buffer, r);
3617 if(c->tcp_byte_count != current_read_size) return 1;
3618 c->pp2_header_state = pp2_header_init;
3621 if(c->pp2_header_state == pp2_header_init) {
3624 sldns_buffer_begin(c->buffer),
3625 sldns_buffer_limit(c->buffer));
3632 header = (struct pp2_header*)sldns_buffer_begin(c->buffer);
3633 want_read_size = ntohs(header->len);
3634 if(sldns_buffer_limit(c->buffer) <
3638 &c->repinfo.remote_addr,
3639 c->repinfo.remote_addrlen);
3648 c->pp2_header_state = pp2_header_done;
3649 } else if(c->tcp_byte_count < current_read_size) {
3651 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(
3652 c->buffer, c->tcp_byte_count),
3653 current_read_size -
3654 c->tcp_byte_count)) <= 0) {
3655 int want = SSL_get_error(c->ssl, r);
3657 if(c->tcp_req_info)
3658 return tcp_req_info_handle_read_close(c->tcp_req_info);
3662 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
3666 c->ssl_shake_state = comm_ssl_shake_hs_write;
3667 comm_point_listen_for_rw(c, 0, 1);
3683 c->tcp_byte_count += r;
3684 sldns_buffer_skip(c->buffer, r);
3685 if(c->tcp_byte_count != current_read_size) return 1;
3686 c->pp2_header_state = pp2_header_done;
3689 if(c->pp2_header_state != pp2_header_done || !header) {
3691 "PROXYv2 header", "", &c->repinfo.remote_addr,
3692 c->repinfo.remote_addrlen);
3695 sldns_buffer_flip(c->buffer);
3696 if(!consume_pp2_header(c->buffer, &c->repinfo, 1)) {
3698 "PROXYv2 header", "", &c->repinfo.remote_addr,
3699 c->repinfo.remote_addrlen);
3706 sldns_buffer_clear(c->buffer);
3707 c->tcp_byte_count = 0;
3710 if(c->tcp_byte_count < sizeof(uint16_t)) {
3713 if((r=SSL_read(c->ssl, (void*)sldns_buffer_at(c->buffer,
3714 c->tcp_byte_count), (int)(sizeof(uint16_t) -
3715 c->tcp_byte_count))) <= 0) {
3716 int want = SSL_get_error(c->ssl, r);
3718 if(c->tcp_req_info)
3719 return tcp_req_info_handle_read_close(c->tcp_req_info);
3723 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
3727 c->ssl_shake_state = comm_ssl_shake_hs_write;
3728 comm_point_listen_for_rw(c, 0, 1);
3743 c->tcp_byte_count += r;
3744 if(c->tcp_byte_count < sizeof(uint16_t))
3746 if(sldns_buffer_read_u16_at(c->buffer, 0) >
3747 sldns_buffer_capacity(c->buffer)) {
3751 sldns_buffer_set_limit(c->buffer,
3752 sldns_buffer_read_u16_at(c->buffer, 0));
3753 if(sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
3757 sldns_buffer_skip(c->buffer, (ssize_t)(c->tcp_byte_count-sizeof(uint16_t)));
3759 (int)sldns_buffer_limit(c->buffer));
3761 if(sldns_buffer_remaining(c->buffer) > 0) {
3763 r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
3764 (int)sldns_buffer_remaining(c->buffer));
3766 int want = SSL_get_error(c->ssl, r);
3768 if(c->tcp_req_info)
3769 return tcp_req_info_handle_read_close(c->tcp_req_info);
3773 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
3777 c->ssl_shake_state = comm_ssl_shake_hs_write;
3778 comm_point_listen_for_rw(c, 0, 1);
3793 sldns_buffer_skip(c->buffer, (ssize_t)r);
3795 if(sldns_buffer_remaining(c->buffer) <= 0) {
3796 tcp_callback_reader(c);
3800 (void)c;
3807 ssl_handle_write(struct comm_point* c) argument
3811 if(c->ssl_shake_state != comm_ssl_shake_none) {
3812 if(!ssl_handshake(c))
3814 if(c->ssl_shake_state != comm_ssl_shake_none)
3818 (void)SSL_set_mode(c->ssl, (long)SSL_MODE_ENABLE_PARTIAL_WRITE);
3819 if((c->tcp_write_and_read?c->tcp_write_byte_count:c->tcp_byte_count) < sizeof(uint16_t)) {
3820 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(c->buffer));
3822 if(c->tcp_write_and_read) {
3823 if(c->tcp_write_pkt_len + 2 < LDNS_RR_BUF_SIZE) {
3829 c->tcp_write_pkt,
3830 c->tcp_write_pkt_len);
3831 r = SSL_write(c->ssl,
3832 (void*)(buf+c->tcp_write_byte_count),
3833 c->tcp_write_pkt_len + 2 -
3834 c->tcp_write_byte_count);
3836 r = SSL_write(c->ssl,
3837 (void*)(((uint8_t*)&len)+c->tcp_write_byte_count),
3838 (int)(sizeof(uint16_t)-c->tcp_write_byte_count));
3840 } else if(sizeof(uint16_t)+sldns_buffer_remaining(c->buffer) <
3847 sldns_buffer_current(c->buffer),
3848 sldns_buffer_remaining(c->buffer));
3849 r = SSL_write(c->ssl, (void*)(buf+c->tcp_byte_count),
3851 sldns_buffer_remaining(c->buffer)
3852 - c->tcp_byte_count));
3854 r = SSL_write(c->ssl,
3855 (void*)(((uint8_t*)&len)+c->tcp_byte_count),
3856 (int)(sizeof(uint16_t)-c->tcp_byte_count));
3859 int want = SSL_get_error(c->ssl, r);
3863 c->ssl_shake_state = comm_ssl_shake_hs_read;
3864 comm_point_listen_for_rw(c, 1, 0);
3868 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
3884 if(c->tcp_write_and_read) {
3885 c->tcp_write_byte_count += r;
3886 if(c->tcp_write_byte_count < sizeof(uint16_t))
3889 c->tcp_byte_count += r;
3890 if(c->tcp_byte_count < sizeof(uint16_t))
3892 sldns_buffer_set_position(c->buffer, c->tcp_byte_count -
3895 …if((!c->tcp_write_and_read && sldns_buffer_remaining(c->buffer) == 0) || (c->tcp_write_and_read &&…
3896 tcp_callback_writer(c);
3900 log_assert(c->tcp_write_and_read || sldns_buffer_remaining(c->buffer) > 0);
3901 log_assert(!c->tcp_write_and_read || c->tcp_write_byte_count < c->tcp_write_pkt_len + 2);
3903 if(c->tcp_write_and_read) {
3904 r = SSL_write(c->ssl, (void*)(c->tcp_write_pkt + c->tcp_write_byte_count - 2),
3905 (int)(c->tcp_write_pkt_len + 2 - c->tcp_write_byte_count));
3907 r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
3908 (int)sldns_buffer_remaining(c->buffer));
3911 int want = SSL_get_error(c->ssl, r);
3915 c->ssl_shake_state = comm_ssl_shake_hs_read;
3916 comm_point_listen_for_rw(c, 1, 0);
3920 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
3936 if(c->tcp_write_and_read) {
3937 c->tcp_write_byte_count += r;
3939 sldns_buffer_skip(c->buffer, (ssize_t)r);
3942 …if((!c->tcp_write_and_read && sldns_buffer_remaining(c->buffer) == 0) || (c->tcp_write_and_read &&…
3943 tcp_callback_writer(c);
3947 (void)c;
3954 ssl_handle_it(struct comm_point* c, int is_write) argument
3958 if(is_write && c->ssl_shake_state == comm_ssl_shake_hs_write)
3959 return ssl_handle_read(c);
3960 else if(!is_write && c->ssl_shake_state == comm_ssl_shake_hs_read)
3961 return ssl_handle_write(c);
3965 return ssl_handle_read(c);
3966 return ssl_handle_write(c);
3972 * @param c: comm point to read from into buffer.
3977 comm_point_tcp_handle_read(int fd, struct comm_point* c, int short_ok) argument
3981 log_assert(c->type == comm_tcp || c->type == comm_local);
3982 if(c->ssl)
3983 return ssl_handle_it(c, 0);
3984 if(!c->tcp_is_reading && !c->tcp_write_and_read)
3987 log_assert(fd != -1);
3988 if(c->pp2_enabled && c->pp2_header_state != pp2_header_done) {
3992 if(c->pp2_header_state == pp2_header_none) {
3994 if(sldns_buffer_remaining(c->buffer)<want_read_size) {
3997 &c->repinfo.remote_addr,
3998 c->repinfo.remote_addrlen);
4005 if(c->tcp_byte_count < current_read_size) {
4006 r = recv(fd, (void*)sldns_buffer_at(c->buffer,
4007 c->tcp_byte_count),
4008 current_read_size-c->tcp_byte_count, MSG_DONTWAIT);
4010 if(c->tcp_req_info)
4011 return tcp_req_info_handle_read_close(c->tcp_req_info);
4013 } else if(r == -1) {
4016 c->tcp_byte_count += r;
4017 sldns_buffer_skip(c->buffer, r);
4018 if(c->tcp_byte_count != current_read_size) return 1;
4019 c->pp2_header_state = pp2_header_init;
4022 if(c->pp2_header_state == pp2_header_init) {
4025 sldns_buffer_begin(c->buffer),
4026 sldns_buffer_limit(c->buffer));
4033 header = (struct pp2_header*)sldns_buffer_begin(c->buffer);
4034 want_read_size = ntohs(header->len);
4035 if(sldns_buffer_limit(c->buffer) <
4039 &c->repinfo.remote_addr,
4040 c->repinfo.remote_addrlen);
4049 c->pp2_header_state = pp2_header_done;
4050 } else if(c->tcp_byte_count < current_read_size) {
4051 r = recv(fd, (void*)sldns_buffer_at(c->buffer,
4052 c->tcp_byte_count),
4053 current_read_size-c->tcp_byte_count, MSG_DONTWAIT);
4055 if(c->tcp_req_info)
4056 return tcp_req_info_handle_read_close(c->tcp_req_info);
4058 } else if(r == -1) {
4061 c->tcp_byte_count += r;
4062 sldns_buffer_skip(c->buffer, r);
4063 if(c->tcp_byte_count != current_read_size) return 1;
4064 c->pp2_header_state = pp2_header_done;
4067 if(c->pp2_header_state != pp2_header_done || !header) {
4069 "PROXYv2 header", "", &c->repinfo.remote_addr,
4070 c->repinfo.remote_addrlen);
4073 sldns_buffer_flip(c->buffer);
4074 if(!consume_pp2_header(c->buffer, &c->repinfo, 1)) {
4076 "PROXYv2 header", "", &c->repinfo.remote_addr,
4077 c->repinfo.remote_addrlen);
4084 sldns_buffer_clear(c->buffer);
4085 c->tcp_byte_count = 0;
4089 if(c->tcp_byte_count < sizeof(uint16_t)) {
4091 r = recv(fd,(void*)sldns_buffer_at(c->buffer,c->tcp_byte_count),
4092 sizeof(uint16_t)-c->tcp_byte_count, MSG_DONTWAIT);
4094 if(c->tcp_req_info)
4095 return tcp_req_info_handle_read_close(c->tcp_req_info);
4097 } else if(r == -1) {
4098 if(c->pp2_enabled) goto recv_error;
4101 c->tcp_byte_count += r;
4102 if(c->tcp_byte_count != sizeof(uint16_t))
4104 if(sldns_buffer_read_u16_at(c->buffer, 0) >
4105 sldns_buffer_capacity(c->buffer)) {
4109 sldns_buffer_set_limit(c->buffer,
4110 sldns_buffer_read_u16_at(c->buffer, 0));
4112 sldns_buffer_limit(c->buffer) < LDNS_HEADER_SIZE) {
4117 (int)sldns_buffer_limit(c->buffer));
4120 if(sldns_buffer_remaining(c->buffer) == 0)
4124 r = recv(fd, (void*)sldns_buffer_current(c->buffer),
4125 sldns_buffer_remaining(c->buffer), MSG_DONTWAIT);
4127 if(c->tcp_req_info)
4128 return tcp_req_info_handle_read_close(c->tcp_req_info);
4130 } else if(r == -1) {
4133 sldns_buffer_skip(c->buffer, r);
4134 if(sldns_buffer_remaining(c->buffer) <= 0) {
4135 tcp_callback_reader(c);
4178 "enabled [--disable-tfo-client "
4179 "--disable-tfo-server] but does not "
4181 &c->repinfo.remote_addr,
4182 c->repinfo.remote_addrlen);
4205 ub_winsock_tcp_wouldblock(c->ev->ev,
4211 sock_strerror(errno), &c->repinfo.remote_addr,
4212 c->repinfo.remote_addrlen);
4219 * @param c: comm point to write buffer out of.
4223 comm_point_tcp_handle_write(int fd, struct comm_point* c) argument
4227 log_assert(c->type == comm_tcp);
4229 buffer = c->dnscrypt_buffer;
4231 buffer = c->buffer;
4233 if(c->tcp_is_reading && !c->ssl && !c->tcp_write_and_read)
4235 log_assert(fd != -1);
4236 …if(((!c->tcp_write_and_read && c->tcp_byte_count == 0) || (c->tcp_write_and_read && c->tcp_write_b…
4259 &c->repinfo.remote_addr,
4260 c->repinfo.remote_addrlen);
4266 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
4272 &c->repinfo.remote_addr,
4273 c->repinfo.remote_addrlen);
4278 if(c->ssl)
4279 return ssl_handle_it(c, 1);
4285 if(c->tcp_do_fastopen == 1) {
4288 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(buffer));
4291 c->tcp_do_fastopen = 0;
4293 if(c->tcp_write_and_read) {
4294 iov[0].iov_base = (uint8_t*)&len + c->tcp_write_byte_count;
4295 iov[0].iov_len = sizeof(uint16_t) - c->tcp_write_byte_count;
4296 iov[1].iov_base = c->tcp_write_pkt;
4297 iov[1].iov_len = c->tcp_write_pkt_len;
4299 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
4300 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
4305 msg.msg_name = &c->repinfo.remote_addr;
4306 msg.msg_namelen = c->repinfo.remote_addrlen;
4310 if (r == -1) {
4332 &c->repinfo.remote_addr,
4333 c->repinfo.remote_addrlen);
4340 if(connect(fd, (struct sockaddr *)&c->repinfo.remote_addr,
4341 c->repinfo.remote_addrlen) == -1) {
4352 (struct sockaddr *)&c->repinfo.remote_addr,
4353 c->repinfo.remote_addrlen)) {
4356 &c->repinfo.remote_addr,
4357 c->repinfo.remote_addrlen);
4363 if(c->tcp_write_and_read) {
4364 c->tcp_write_byte_count += r;
4365 if(c->tcp_write_byte_count < sizeof(uint16_t))
4368 c->tcp_byte_count += r;
4369 if(c->tcp_byte_count < sizeof(uint16_t))
4371 sldns_buffer_set_position(buffer, c->tcp_byte_count -
4374 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
4375 tcp_callback_writer(c);
4382 if((c->tcp_write_and_read?c->tcp_write_byte_count:c->tcp_byte_count) < sizeof(uint16_t)) {
4383 uint16_t len = htons(c->tcp_write_and_read?c->tcp_write_pkt_len:sldns_buffer_limit(buffer));
4386 if(c->tcp_write_and_read) {
4387 iov[0].iov_base = (uint8_t*)&len + c->tcp_write_byte_count;
4388 iov[0].iov_len = sizeof(uint16_t) - c->tcp_write_byte_count;
4389 iov[1].iov_base = c->tcp_write_pkt;
4390 iov[1].iov_len = c->tcp_write_pkt_len;
4392 iov[0].iov_base = (uint8_t*)&len + c->tcp_byte_count;
4393 iov[0].iov_len = sizeof(uint16_t) - c->tcp_byte_count;
4400 if(c->tcp_write_and_read) {
4401 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_write_byte_count),
4402 sizeof(uint16_t)-c->tcp_write_byte_count, 0);
4404 r = send(fd, (void*)(((uint8_t*)&len)+c->tcp_byte_count),
4405 sizeof(uint16_t)-c->tcp_byte_count, 0);
4408 if(r == -1) {
4422 &c->repinfo.remote_addr,
4423 c->repinfo.remote_addrlen);
4426 &c->repinfo.remote_addr,
4427 c->repinfo.remote_addrlen);
4435 ub_winsock_tcp_wouldblock(c->ev->ev,
4443 &c->repinfo.remote_addr,
4444 c->repinfo.remote_addrlen);
4448 if(c->tcp_write_and_read) {
4449 c->tcp_write_byte_count += r;
4450 if(c->tcp_write_byte_count < sizeof(uint16_t))
4453 c->tcp_byte_count += r;
4454 if(c->tcp_byte_count < sizeof(uint16_t))
4456 sldns_buffer_set_position(buffer, c->tcp_byte_count -
4459 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
4460 tcp_callback_writer(c);
4464 log_assert(c->tcp_write_and_read || sldns_buffer_remaining(buffer) > 0);
4465 log_assert(!c->tcp_write_and_read || c->tcp_write_byte_count < c->tcp_write_pkt_len + 2);
4466 if(c->tcp_write_and_read) {
4467 r = send(fd, (void*)(c->tcp_write_pkt + c->tcp_write_byte_count - 2),
4468 c->tcp_write_pkt_len + 2 - c->tcp_write_byte_count, 0);
4473 if(r == -1) {
4485 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
4492 &c->repinfo.remote_addr,
4493 c->repinfo.remote_addrlen);
4496 if(c->tcp_write_and_read) {
4497 c->tcp_write_byte_count += r;
4502 …if((!c->tcp_write_and_read && sldns_buffer_remaining(buffer) == 0) || (c->tcp_write_and_read && c-…
4503 tcp_callback_writer(c);
4512 tcp_req_info_read_again(int fd, struct comm_point* c) argument
4514 while(c->tcp_req_info->read_again) {
4516 c->tcp_req_info->read_again = 0;
4517 if(c->tcp_is_reading)
4518 r = comm_point_tcp_handle_read(fd, c, 0);
4519 else r = comm_point_tcp_handle_write(fd, c);
4521 reclaim_tcp_handler(c);
4522 if(!c->tcp_do_close) {
4524 c->callback));
4525 (void)(*c->callback)(c, c->cb_arg,
4536 tcp_more_read_again(int fd, struct comm_point* c) argument
4542 int* moreread = c->tcp_more_read_again;
4545 if(!comm_point_tcp_handle_read(fd, c, 0)) {
4546 reclaim_tcp_handler(c);
4547 if(!c->tcp_do_close) {
4549 c->callback));
4550 (void)(*c->callback)(c, c->cb_arg,
4560 tcp_more_write_again(int fd, struct comm_point* c) argument
4566 int* morewrite = c->tcp_more_write_again;
4569 if(!comm_point_tcp_handle_write(fd, c)) {
4570 reclaim_tcp_handler(c);
4571 if(!c->tcp_do_close) {
4573 c->callback));
4574 (void)(*c->callback)(c, c->cb_arg,
4585 struct comm_point* c = (struct comm_point*)arg; local
4586 log_assert(c->type == comm_tcp);
4587 ub_comm_base_now(c->ev->base);
4589 if(c->fd == -1 || c->fd != fd)
4594 if(c->tcp_parent) {
4595 c->dnscrypt = c->tcp_parent->dnscrypt;
4597 if(c->dnscrypt && c->dnscrypt_buffer == c->buffer) {
4598 c->dnscrypt_buffer = sldns_buffer_new(sldns_buffer_capacity(c->buffer));
4599 if(!c->dnscrypt_buffer) {
4601 reclaim_tcp_handler(c);
4602 if(!c->tcp_do_close) {
4604 c->callback));
4605 (void)(*c->callback)(c, c->cb_arg,
4615 reclaim_tcp_handler(c);
4616 if(!c->tcp_do_close) {
4617 fptr_ok(fptr_whitelist_comm_point(c->callback));
4618 (void)(*c->callback)(c, c->cb_arg,
4625 && !(c->tcp_do_fastopen && (event&UB_EV_WRITE))
4628 int has_tcpq = (c->tcp_req_info != NULL);
4629 int* moreread = c->tcp_more_read_again;
4630 if(!comm_point_tcp_handle_read(fd, c, 0)) {
4631 reclaim_tcp_handler(c);
4632 if(!c->tcp_do_close) {
4634 c->callback));
4635 (void)(*c->callback)(c, c->cb_arg,
4640 if(has_tcpq && c->tcp_req_info && c->tcp_req_info->read_again) {
4641 if(!tcp_req_info_read_again(fd, c))
4645 tcp_more_read_again(fd, c);
4649 int has_tcpq = (c->tcp_req_info != NULL);
4650 int* morewrite = c->tcp_more_write_again;
4651 if(!comm_point_tcp_handle_write(fd, c)) {
4652 reclaim_tcp_handler(c);
4653 if(!c->tcp_do_close) {
4655 c->callback));
4656 (void)(*c->callback)(c, c->cb_arg,
4661 if(has_tcpq && c->tcp_req_info && c->tcp_req_info->read_again) {
4662 if(!tcp_req_info_read_again(fd, c))
4666 tcp_more_write_again(fd, c);
4674 reclaim_http_handler(struct comm_point* c) argument
4676 log_assert(c->type == comm_http);
4677 if(c->ssl) {
4679 SSL_shutdown(c->ssl);
4680 SSL_free(c->ssl);
4681 c->ssl = NULL;
4684 comm_point_close(c);
4685 if(c->tcp_parent) {
4686 if(c != c->tcp_parent->tcp_free) {
4687 c->tcp_parent->cur_tcp_count--;
4688 c->tcp_free = c->tcp_parent->tcp_free;
4689 c->tcp_parent->tcp_free = c;
4691 if(!c->tcp_free) {
4692 /* re-enable listening on accept socket */
4693 comm_point_start_listening(c->tcp_parent, -1, -1);
4700 ssl_http_read_more(struct comm_point* c) argument
4704 log_assert(sldns_buffer_remaining(c->buffer) > 0);
4706 r = SSL_read(c->ssl, (void*)sldns_buffer_current(c->buffer),
4707 (int)sldns_buffer_remaining(c->buffer));
4709 int want = SSL_get_error(c->ssl, r);
4715 c->ssl_shake_state = comm_ssl_shake_hs_write;
4716 comm_point_listen_for_rw(c, 0, 1);
4732 (int)sldns_buffer_position(c->buffer), (int)r);
4733 sldns_buffer_skip(c->buffer, (ssize_t)r);
4736 (void)c;
4743 http_read_more(int fd, struct comm_point* c) argument
4746 log_assert(sldns_buffer_remaining(c->buffer) > 0);
4747 r = recv(fd, (void*)sldns_buffer_current(c->buffer),
4748 sldns_buffer_remaining(c->buffer), MSG_DONTWAIT);
4751 } else if(r == -1) {
4761 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
4766 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
4770 (int)sldns_buffer_position(c->buffer), (int)r);
4771 sldns_buffer_skip(c->buffer, r);
4789 * past that line and puts zero terminator into linefeed-newline */
4822 http_process_initial_header(struct comm_point* c) argument
4824 char* line = http_header_line(c->buffer);
4833 } else if(strncasecmp(line, "Content-Length: ", 16) == 0) {
4834 if(!c->http_is_chunked)
4835 c->tcp_byte_count = (size_t)atoi(line+16);
4836 } else if(strncasecmp(line, "Transfer-Encoding: chunked", 19+7) == 0) {
4837 c->tcp_byte_count = 0;
4838 c->http_is_chunked = 1;
4841 c->http_in_headers = 0;
4842 if(c->http_is_chunked)
4843 c->http_in_chunk_headers = 1;
4848 http_moveover_buffer(c->buffer);
4849 sldns_buffer_flip(c->buffer);
4859 http_process_chunk_header(struct comm_point* c) argument
4861 char* line = http_header_line(c->buffer);
4863 if(c->http_in_chunk_headers == 3) {
4866 if(line[0] == 0 && c->tcp_byte_count == 0) {
4869 sldns_buffer_set_position(c->buffer, 0);
4870 sldns_buffer_set_limit(c->buffer, 0);
4871 fptr_ok(fptr_whitelist_comm_point(c->callback));
4872 (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
4878 c->http_in_chunk_headers = 1;
4880 http_moveover_buffer(c->buffer);
4881 sldns_buffer_flip(c->buffer);
4888 if(c->http_in_chunk_headers == 1) {
4891 c->tcp_byte_count = (size_t)strtol(line, &end, 16);
4894 c->http_in_chunk_headers = 0;
4896 http_moveover_buffer(c->buffer);
4897 sldns_buffer_flip(c->buffer);
4898 if(c->tcp_byte_count == 0) {
4900 c->http_in_chunk_headers = 3;
4910 http_nonchunk_segment(struct comm_point* c) argument
4912 /* c->buffer at position..limit has new data we read in.
4917 size_t got_now = sldns_buffer_limit(c->buffer);
4918 if(c->tcp_byte_count <= got_now) {
4920 c->http_stored = 0;
4921 sldns_buffer_set_position(c->buffer, 0);
4922 fptr_ok(fptr_whitelist_comm_point(c->callback));
4923 (void)(*c->callback)(c, c->cb_arg, NETEVENT_DONE, NULL);
4928 remainbufferlen = sldns_buffer_capacity(c->buffer) -
4929 sldns_buffer_limit(c->buffer);
4930 if(remainbufferlen+got_now >= c->tcp_byte_count ||
4931 remainbufferlen >= (size_t)(c->ssl?16384:2048)) {
4932 size_t total = sldns_buffer_limit(c->buffer);
4933 sldns_buffer_clear(c->buffer);
4934 sldns_buffer_set_position(c->buffer, total);
4935 c->http_stored = total;
4941 c->tcp_byte_count -= got_now;
4942 c->http_stored = 0;
4943 sldns_buffer_set_position(c->buffer, 0);
4944 fptr_ok(fptr_whitelist_comm_point(c->callback));
4945 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
4946 /* c->callback has to buffer_clear(c->buffer). */
4953 http_chunked_segment(struct comm_point* c) argument
4955 /* the c->buffer has from position..limit new data we read. */
4960 size_t got_now = sldns_buffer_limit(c->buffer) - c->http_stored;
4961 …%d", (int)got_now, (int)c->tcp_byte_count, (int)c->http_stored, (int)sldns_buffer_position(c->buff…
4962 if(c->tcp_byte_count <= got_now) {
4968 c->http_stored = 0;
4969 sldns_buffer_skip(c->buffer, (ssize_t)c->tcp_byte_count);
4970 sldns_buffer_clear(c->http_temp);
4971 sldns_buffer_write(c->http_temp,
4972 sldns_buffer_current(c->buffer),
4973 sldns_buffer_remaining(c->buffer));
4974 sldns_buffer_flip(c->http_temp);
4977 fraglen = sldns_buffer_position(c->buffer);
4978 sldns_buffer_set_position(c->buffer, 0);
4979 sldns_buffer_set_limit(c->buffer, fraglen);
4980 repinfo = c->repinfo;
4981 fptr_ok(fptr_whitelist_comm_point(c->callback));
4982 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, &repinfo);
4983 /* c->callback has to buffer_clear(). */
4986 if(!repinfo.c) {
4990 sldns_buffer_clear(c->buffer);
4991 sldns_buffer_write(c->buffer,
4992 sldns_buffer_begin(c->http_temp),
4993 sldns_buffer_remaining(c->http_temp));
4994 sldns_buffer_flip(c->buffer);
4997 c->http_in_chunk_headers = 3;
5001 c->tcp_byte_count -= got_now;
5005 remainbufferlen = sldns_buffer_capacity(c->buffer) -
5006 sldns_buffer_limit(c->buffer);
5007 if(remainbufferlen >= c->tcp_byte_count ||
5009 size_t total = sldns_buffer_limit(c->buffer);
5010 sldns_buffer_clear(c->buffer);
5011 sldns_buffer_set_position(c->buffer, total);
5012 c->http_stored = total;
5018 c->http_stored = 0;
5019 sldns_buffer_set_position(c->buffer, 0);
5020 fptr_ok(fptr_whitelist_comm_point(c->callback));
5021 (void)(*c->callback)(c, c->cb_arg, NETEVENT_NOERROR, NULL);
5022 /* c->callback has to buffer_clear(c->buffer). */
5029 static struct http2_session* http2_session_create(struct comm_point* c) argument
5036 session->c = c;
5046 if(h2_session->callbacks)
5047 nghttp2_session_callbacks_del(h2_session->callbacks);
5062 h2_stream->stream_id = stream_id;
5070 if(h2_stream->mesh_state) {
5071 mesh_state_remove_reply(h2_stream->mesh, h2_stream->mesh_state,
5072 h2_session->c);
5073 h2_stream->mesh_state = NULL;
5083 h2_stream->mesh = mesh;
5084 h2_stream->mesh_state = m;
5091 h2_stream->mesh_state = NULL;
5099 nghttp2_session_del(h2_session->session); /* NULL input is fine */
5100 h2_session->session = NULL;
5101 for(h2_stream = h2_session->first_stream; h2_stream;) {
5102 next = h2_stream->next;
5106 h2_session->first_stream = NULL;
5107 h2_session->is_drop = 0;
5108 h2_session->postpone_drop = 0;
5109 h2_session->c->h2_stream = NULL;
5118 if(h2_session->first_stream)
5119 h2_session->first_stream->prev = h2_stream;
5120 h2_stream->next = h2_session->first_stream;
5121 h2_session->first_stream = h2_stream;
5129 if(h2_stream->prev)
5130 h2_stream->prev->next = h2_stream->next;
5132 h2_session->first_stream = h2_stream->next;
5133 if(h2_stream->next)
5134 h2_stream->next->prev = h2_stream->prev;
5144 h2_session->session, stream_id))) {
5158 log_assert(h2_session->c->type == comm_http);
5159 log_assert(h2_session->c->h2_session);
5162 if(h2_session->c->ssl) {
5165 r = SSL_read(h2_session->c->ssl, buf, len);
5167 int want = SSL_get_error(h2_session->c->ssl, r);
5173 h2_session->c->ssl_shake_state = comm_ssl_shake_hs_write;
5174 comm_point_listen_for_rw(h2_session->c, 0, 1);
5193 ret = recv(h2_session->c->fd, buf, len, MSG_DONTWAIT);
5205 &h2_session->c->repinfo.remote_addr,
5206 h2_session->c->repinfo.remote_addrlen);
5213 ub_winsock_tcp_wouldblock(h2_session->c->ev->ev,
5219 &h2_session->c->repinfo.remote_addr,
5220 h2_session->c->repinfo.remote_addrlen);
5230 comm_point_http2_handle_read(int ATTR_UNUSED(fd), struct comm_point* c) argument
5234 log_assert(c->h2_session);
5237 ret = nghttp2_session_recv(c->h2_session->session);
5242 addr_to_str(&c->repinfo.remote_addr,
5243 c->repinfo.remote_addrlen, a, sizeof(a));
5249 if(nghttp2_session_want_write(c->h2_session->session)) {
5250 c->tcp_is_reading = 0;
5251 comm_point_stop_listening(c);
5252 comm_point_start_listening(c, -1, adjusted_tcp_timeout(c));
5253 } else if(!nghttp2_session_want_read(c->h2_session->session))
5257 (void)c;
5265 * @param c: comm point to read from into buffer.
5269 comm_point_http_handle_read(int fd, struct comm_point* c) argument
5271 log_assert(c->type == comm_http);
5272 log_assert(fd != -1);
5276 if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
5277 if(!ssl_handshake(c))
5279 if(c->ssl_shake_state != comm_ssl_shake_none)
5284 if(!c->tcp_is_reading)
5287 if(c->use_h2) {
5288 return comm_point_http2_handle_read(fd, c);
5293 if(c->http_min_version >= http_version_2) {
5299 if(c->ssl) {
5300 if(!ssl_http_read_more(c))
5303 if(!http_read_more(fd, c))
5307 if(c->http_stored >= sldns_buffer_position(c->buffer)) {
5312 sldns_buffer_flip(c->buffer);
5315 if(c->http_stored < sldns_buffer_limit(c->buffer))
5316 sldns_buffer_set_position(c->buffer, c->http_stored);
5317 else sldns_buffer_set_position(c->buffer, sldns_buffer_limit(c->buffer));
5319 while(sldns_buffer_remaining(c->buffer) > 0) {
5322 if(c->http_in_headers || c->http_in_chunk_headers) {
5324 if(!http_header_done(c->buffer)) {
5327 http_moveover_buffer(c->buffer);
5331 if(!c->http_in_chunk_headers) {
5333 if(!http_process_initial_header(c))
5337 int r = http_process_chunk_header(c);
5346 if(!c->http_is_chunked) {
5348 return http_nonchunk_segment(c);
5351 int r = http_chunked_segment(c);
5360 http_moveover_buffer(c->buffer);
5367 http_check_connect(int fd, struct comm_point* c) argument
5391 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
5397 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
5403 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
5413 ssl_http_write_more(struct comm_point* c) argument
5417 log_assert(sldns_buffer_remaining(c->buffer) > 0);
5419 r = SSL_write(c->ssl, (void*)sldns_buffer_current(c->buffer),
5420 (int)sldns_buffer_remaining(c->buffer));
5422 int want = SSL_get_error(c->ssl, r);
5426 c->ssl_shake_state = comm_ssl_shake_hs_read;
5427 comm_point_listen_for_rw(c, 1, 0);
5444 sldns_buffer_skip(c->buffer, (ssize_t)r);
5447 (void)c;
5454 http_write_more(int fd, struct comm_point* c) argument
5457 log_assert(sldns_buffer_remaining(c->buffer) > 0);
5458 r = send(fd, (void*)sldns_buffer_current(c->buffer),
5459 sldns_buffer_remaining(c->buffer), 0);
5460 if(r == -1) {
5468 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
5473 &c->repinfo.remote_addr, c->repinfo.remote_addrlen);
5476 sldns_buffer_skip(c->buffer, r);
5486 log_assert(h2_session->c->type == comm_http);
5487 log_assert(h2_session->c->h2_session);
5490 if(h2_session->c->ssl) {
5493 r = SSL_write(h2_session->c->ssl, buf, len);
5495 int want = SSL_get_error(h2_session->c->ssl, r);
5499 h2_session->c->ssl_shake_state = comm_ssl_shake_hs_read;
5500 comm_point_listen_for_rw(h2_session->c, 1, 0);
5521 ret = send(h2_session->c->fd, buf, len, 0);
5537 &h2_session->c->repinfo.remote_addr,
5538 h2_session->c->repinfo.remote_addrlen);
5545 ub_winsock_tcp_wouldblock(h2_session->c->ev->ev,
5553 &h2_session->c->repinfo.remote_addr,
5554 h2_session->c->repinfo.remote_addrlen);
5564 comm_point_http2_handle_write(int ATTR_UNUSED(fd), struct comm_point* c) argument
5568 log_assert(c->h2_session);
5570 ret = nghttp2_session_send(c->h2_session->session);
5577 if(nghttp2_session_want_read(c->h2_session->session)) {
5578 c->tcp_is_reading = 1;
5579 comm_point_stop_listening(c);
5580 comm_point_start_listening(c, -1, adjusted_tcp_timeout(c));
5581 } else if(!nghttp2_session_want_write(c->h2_session->session))
5585 (void)c;
5593 * @param c: comm point to write buffer out of.
5597 comm_point_http_handle_write(int fd, struct comm_point* c) argument
5599 log_assert(c->type == comm_http);
5600 log_assert(fd != -1);
5604 if(c->tcp_check_nb_connect) {
5605 int r = http_check_connect(fd, c);
5608 c->tcp_check_nb_connect = 0;
5612 if(c->ssl && c->ssl_shake_state != comm_ssl_shake_none) {
5613 if(!ssl_handshake(c))
5615 if(c->ssl_shake_state != comm_ssl_shake_none)
5619 if(c->tcp_is_reading)
5622 if(c->use_h2) {
5623 return comm_point_http2_handle_write(fd, c);
5628 if(c->http_min_version >= http_version_2) {
5634 if(c->ssl) {
5635 if(!ssl_http_write_more(c))
5638 if(!http_write_more(fd, c))
5645 if(sldns_buffer_remaining(c->buffer) == 0) {
5646 sldns_buffer_clear(c->buffer);
5647 if(c->tcp_do_toggle_rw)
5648 c->tcp_is_reading = 1;
5649 c->tcp_byte_count = 0;
5651 comm_point_stop_listening(c);
5652 comm_point_start_listening(c, -1, -1);
5660 struct comm_point* c = (struct comm_point*)arg; local
5661 log_assert(c->type == comm_http);
5662 ub_comm_base_now(c->ev->base);
5666 reclaim_http_handler(c);
5667 if(!c->tcp_do_close) {
5668 fptr_ok(fptr_whitelist_comm_point(c->callback));
5669 (void)(*c->callback)(c, c->cb_arg,
5675 if(!comm_point_http_handle_read(fd, c)) {
5676 reclaim_http_handler(c);
5677 if(!c->tcp_do_close) {
5679 c->callback));
5680 (void)(*c->callback)(c, c->cb_arg,
5687 if(!comm_point_http_handle_write(fd, c)) {
5688 reclaim_http_handler(c);
5689 if(!c->tcp_do_close) {
5691 c->callback));
5692 (void)(*c->callback)(c, c->cb_arg,
5703 struct comm_point* c = (struct comm_point*)arg; local
5704 log_assert(c->type == comm_local);
5705 ub_comm_base_now(c->ev->base);
5708 if(!comm_point_tcp_handle_read(fd, c, 1)) {
5709 fptr_ok(fptr_whitelist_comm_point(c->callback));
5710 (void)(*c->callback)(c, c->cb_arg, NETEVENT_CLOSED,
5721 struct comm_point* c = (struct comm_point*)arg; local
5723 log_assert(c->type == comm_raw);
5724 ub_comm_base_now(c->ev->base);
5728 fptr_ok(fptr_whitelist_comm_point_raw(c->callback));
5729 (void)(*c->callback)(c, c->cb_arg, err, NULL);
5737 struct comm_point* c = (struct comm_point*)calloc(1, local
5740 if(!c)
5742 c->ev = (struct internal_event*)calloc(1,
5744 if(!c->ev) {
5745 free(c);
5748 c->ev->base = base;
5749 c->fd = fd;
5750 c->buffer = buffer;
5751 c->timeout = NULL;
5752 c->tcp_is_reading = 0;
5753 c->tcp_byte_count = 0;
5754 c->tcp_parent = NULL;
5755 c->max_tcp_count = 0;
5756 c->cur_tcp_count = 0;
5757 c->tcp_handlers = NULL;
5758 c->tcp_free = NULL;
5759 c->type = comm_udp;
5760 c->tcp_do_close = 0;
5761 c->do_not_close = 0;
5762 c->tcp_do_toggle_rw = 0;
5763 c->tcp_check_nb_connect = 0;
5765 c->tcp_do_fastopen = 0;
5768 c->dnscrypt = 0;
5769 c->dnscrypt_buffer = buffer;
5771 c->inuse = 0;
5772 c->callback = callback;
5773 c->cb_arg = callback_arg;
5774 c->socket = socket;
5775 c->pp2_enabled = pp2_enabled;
5776 c->pp2_header_state = pp2_header_none;
5779 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
5780 comm_point_udp_callback, c);
5781 if(c->ev->ev == NULL) {
5783 comm_point_delete(c);
5786 if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
5788 comm_point_delete(c);
5791 c->event_added = 1;
5792 return c;
5801 struct comm_point* c = (struct comm_point*)calloc(1, local
5804 if(!c)
5806 c->ev = (struct internal_event*)calloc(1,
5808 if(!c->ev) {
5809 free(c);
5812 c->ev->base = base;
5813 c->fd = fd;
5814 c->buffer = buffer;
5815 c->timeout = NULL;
5816 c->tcp_is_reading = 0;
5817 c->tcp_byte_count = 0;
5818 c->tcp_parent = NULL;
5819 c->max_tcp_count = 0;
5820 c->cur_tcp_count = 0;
5821 c->tcp_handlers = NULL;
5822 c->tcp_free = NULL;
5823 c->type = comm_udp;
5824 c->tcp_do_close = 0;
5825 c->do_not_close = 0;
5827 c->dnscrypt = 0;
5828 c->dnscrypt_buffer = buffer;
5830 c->inuse = 0;
5831 c->tcp_do_toggle_rw = 0;
5832 c->tcp_check_nb_connect = 0;
5834 c->tcp_do_fastopen = 0;
5836 c->callback = callback;
5837 c->cb_arg = callback_arg;
5838 c->socket = socket;
5839 c->pp2_enabled = pp2_enabled;
5840 c->pp2_header_state = pp2_header_none;
5843 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
5844 comm_point_udp_ancil_callback, c);
5845 if(c->ev->ev == NULL) {
5847 comm_point_delete(c);
5850 if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
5852 comm_point_delete(c);
5855 c->event_added = 1;
5856 return c;
5868 struct comm_point* c = (struct comm_point*)calloc(1, local
5871 if(!c)
5873 c->ev = (struct internal_event*)calloc(1,
5875 if(!c->ev) {
5876 free(c);
5879 c->ev->base = base;
5880 c->fd = fd;
5881 c->buffer = buffer;
5882 c->timeout = NULL;
5883 c->tcp_is_reading = 0;
5884 c->tcp_byte_count = 0;
5885 c->tcp_parent = NULL;
5886 c->max_tcp_count = 0;
5887 c->cur_tcp_count = 0;
5888 c->tcp_handlers = NULL;
5889 c->tcp_free = NULL;
5890 c->type = comm_doq;
5891 c->tcp_do_close = 0;
5892 c->do_not_close = 0;
5893 c->tcp_do_toggle_rw = 0;
5894 c->tcp_check_nb_connect = 0;
5896 c->tcp_do_fastopen = 0;
5899 c->dnscrypt = 0;
5900 c->dnscrypt_buffer = NULL;
5903 c->doq_socket = doq_server_socket_create(table, rnd, ssl_service_key,
5904 ssl_service_pem, c, base, cfg);
5905 if(!c->doq_socket) {
5907 comm_point_delete(c);
5911 c->inuse = 0;
5912 c->callback = callback;
5913 c->cb_arg = callback_arg;
5914 c->socket = socket;
5915 c->pp2_enabled = 0;
5916 c->pp2_header_state = pp2_header_none;
5919 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
5920 comm_point_doq_callback, c);
5921 if(c->ev->ev == NULL) {
5923 comm_point_delete(c);
5926 if(fd!=-1 && ub_event_add(c->ev->ev, c->timeout) != 0 ) {
5928 comm_point_delete(c);
5931 c->event_added = 1;
5932 return c;
5956 struct comm_point* c = (struct comm_point*)calloc(1, local
5959 if(!c)
5961 c->ev = (struct internal_event*)calloc(1,
5963 if(!c->ev) {
5964 free(c);
5967 c->ev->base = base;
5968 c->fd = -1;
5969 c->buffer = sldns_buffer_new(bufsize);
5970 if(!c->buffer) {
5971 free(c->ev);
5972 free(c);
5975 c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
5976 if(!c->timeout) {
5977 sldns_buffer_free(c->buffer);
5978 free(c->ev);
5979 free(c);
5982 c->tcp_is_reading = 0;
5983 c->tcp_byte_count = 0;
5984 c->tcp_parent = parent;
5985 c->tcp_timeout_msec = parent->tcp_timeout_msec;
5986 c->tcp_conn_limit = parent->tcp_conn_limit;
5987 c->tcl_addr = NULL;
5988 c->tcp_keepalive = 0;
5989 c->max_tcp_count = 0;
5990 c->cur_tcp_count = 0;
5991 c->tcp_handlers = NULL;
5992 c->tcp_free = NULL;
5993 c->type = comm_tcp;
5994 c->tcp_do_close = 0;
5995 c->do_not_close = 0;
5996 c->tcp_do_toggle_rw = 1;
5997 c->tcp_check_nb_connect = 0;
5999 c->tcp_do_fastopen = 0;
6002 c->dnscrypt = 0;
6005 c->dnscrypt_buffer = c->buffer;
6007 c->repinfo.c = c;
6008 c->callback = callback;
6009 c->cb_arg = callback_arg;
6010 c->socket = socket;
6011 c->pp2_enabled = parent->pp2_enabled;
6012 c->pp2_header_state = pp2_header_none;
6014 c->tcp_req_info = tcp_req_info_create(spoolbuf);
6015 if(!c->tcp_req_info) {
6017 sldns_buffer_free(c->buffer);
6018 free(c->timeout);
6019 free(c->ev);
6020 free(c);
6023 c->tcp_req_info->cp = c;
6024 c->tcp_do_close = 1;
6025 c->tcp_do_toggle_rw = 0;
6028 c->tcp_free = parent->tcp_free;
6029 parent->tcp_free = c;
6032 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6033 comm_point_tcp_handle_callback, c);
6034 if(c->ev->ev == NULL)
6037 parent->tcp_free = c->tcp_free;
6038 tcp_req_info_delete(c->tcp_req_info);
6039 sldns_buffer_free(c->buffer);
6040 free(c->timeout);
6041 free(c->ev);
6042 free(c);
6045 return c;
6055 struct comm_point* c = (struct comm_point*)calloc(1, local
6058 if(!c)
6060 c->ev = (struct internal_event*)calloc(1,
6062 if(!c->ev) {
6063 free(c);
6066 c->ev->base = base;
6067 c->fd = -1;
6068 c->buffer = sldns_buffer_new(bufsize);
6069 if(!c->buffer) {
6070 free(c->ev);
6071 free(c);
6074 c->timeout = (struct timeval*)malloc(sizeof(struct timeval));
6075 if(!c->timeout) {
6076 sldns_buffer_free(c->buffer);
6077 free(c->ev);
6078 free(c);
6081 c->tcp_is_reading = 0;
6082 c->tcp_byte_count = 0;
6083 c->tcp_parent = parent;
6084 c->tcp_timeout_msec = parent->tcp_timeout_msec;
6085 c->tcp_conn_limit = parent->tcp_conn_limit;
6086 c->tcl_addr = NULL;
6087 c->tcp_keepalive = 0;
6088 c->max_tcp_count = 0;
6089 c->cur_tcp_count = 0;
6090 c->tcp_handlers = NULL;
6091 c->tcp_free = NULL;
6092 c->type = comm_http;
6093 c->tcp_do_close = 1;
6094 c->do_not_close = 0;
6095 c->tcp_do_toggle_rw = 1; /* will be set to 0 after http2 upgrade */
6096 c->tcp_check_nb_connect = 0;
6098 c->tcp_do_fastopen = 0;
6101 c->dnscrypt = 0;
6102 c->dnscrypt_buffer = NULL;
6104 c->repinfo.c = c;
6105 c->callback = callback;
6106 c->cb_arg = callback_arg;
6107 c->socket = socket;
6108 c->pp2_enabled = 0;
6109 c->pp2_header_state = pp2_header_none;
6111 c->http_min_version = http_version_2;
6112 c->http2_stream_max_qbuffer_size = bufsize;
6114 c->http2_stream_max_qbuffer_size = 512;
6115 c->http2_max_streams = http_max_streams;
6116 if(!(c->http_endpoint = strdup(http_endpoint))) {
6118 sldns_buffer_free(c->buffer);
6119 free(c->timeout);
6120 free(c->ev);
6121 free(c);
6124 c->use_h2 = 0;
6126 if(!(c->h2_session = http2_session_create(c))) {
6128 free(c->http_endpoint);
6129 sldns_buffer_free(c->buffer);
6130 free(c->timeout);
6131 free(c->ev);
6132 free(c);
6135 if(!(c->h2_session->callbacks = http2_req_callbacks_create())) {
6137 http2_session_delete(c->h2_session);
6138 free(c->http_endpoint);
6139 sldns_buffer_free(c->buffer);
6140 free(c->timeout);
6141 free(c->ev);
6142 free(c);
6148 c->tcp_free = parent->tcp_free;
6149 parent->tcp_free = c;
6152 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6153 comm_point_http_handle_callback, c);
6154 if(c->ev->ev == NULL)
6157 parent->tcp_free = c->tcp_free;
6158 http2_session_delete(c->h2_session);
6159 sldns_buffer_free(c->buffer);
6160 free(c->timeout);
6161 free(c->ev);
6162 free(c);
6165 return c;
6177 struct comm_point* c = (struct comm_point*)calloc(1, local
6182 if(!c)
6184 c->ev = (struct internal_event*)calloc(1,
6186 if(!c->ev) {
6187 free(c);
6190 c->ev->base = base;
6191 c->fd = fd;
6192 c->buffer = NULL;
6193 c->timeout = NULL;
6194 c->tcp_is_reading = 0;
6195 c->tcp_byte_count = 0;
6196 c->tcp_timeout_msec = idle_timeout;
6197 c->tcp_conn_limit = tcp_conn_limit;
6198 c->tcl_addr = NULL;
6199 c->tcp_keepalive = 0;
6200 c->tcp_parent = NULL;
6201 c->max_tcp_count = num;
6202 c->cur_tcp_count = 0;
6203 c->tcp_handlers = (struct comm_point**)calloc((size_t)num,
6205 if(!c->tcp_handlers) {
6206 free(c->ev);
6207 free(c);
6210 c->tcp_free = NULL;
6211 c->type = comm_tcp_accept;
6212 c->tcp_do_close = 0;
6213 c->do_not_close = 0;
6214 c->tcp_do_toggle_rw = 0;
6215 c->tcp_check_nb_connect = 0;
6217 c->tcp_do_fastopen = 0;
6220 c->dnscrypt = 0;
6221 c->dnscrypt_buffer = NULL;
6223 c->callback = NULL;
6224 c->cb_arg = NULL;
6225 c->socket = socket;
6226 c->pp2_enabled = (port_type==listen_type_http?0:pp2_enabled);
6227 c->pp2_header_state = pp2_header_none;
6230 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6231 comm_point_tcp_accept_callback, c);
6232 if(c->ev->ev == NULL) {
6234 comm_point_delete(c);
6237 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
6239 comm_point_delete(c);
6242 c->event_added = 1;
6248 c->tcp_handlers[i] = comm_point_create_tcp_handler(base,
6249 c, bufsize, spoolbuf, callback, callback_arg, socket);
6251 c->tcp_handlers[i] = comm_point_create_http_handler(
6252 base, c, bufsize, harden_large_queries,
6261 if(!c->tcp_handlers[i]) {
6262 comm_point_delete(c);
6267 return c;
6274 struct comm_point* c = (struct comm_point*)calloc(1, local
6277 if(!c)
6279 c->ev = (struct internal_event*)calloc(1,
6281 if(!c->ev) {
6282 free(c);
6285 c->ev->base = base;
6286 c->fd = -1;
6287 c->buffer = sldns_buffer_new(bufsize);
6288 if(!c->buffer) {
6289 free(c->ev);
6290 free(c);
6293 c->timeout = NULL;
6294 c->tcp_is_reading = 0;
6295 c->tcp_byte_count = 0;
6296 c->tcp_timeout_msec = TCP_QUERY_TIMEOUT;
6297 c->tcp_conn_limit = NULL;
6298 c->tcl_addr = NULL;
6299 c->tcp_keepalive = 0;
6300 c->tcp_parent = NULL;
6301 c->max_tcp_count = 0;
6302 c->cur_tcp_count = 0;
6303 c->tcp_handlers = NULL;
6304 c->tcp_free = NULL;
6305 c->type = comm_tcp;
6306 c->tcp_do_close = 0;
6307 c->do_not_close = 0;
6308 c->tcp_do_toggle_rw = 1;
6309 c->tcp_check_nb_connect = 1;
6311 c->tcp_do_fastopen = 1;
6314 c->dnscrypt = 0;
6315 c->dnscrypt_buffer = c->buffer;
6317 c->repinfo.c = c;
6318 c->callback = callback;
6319 c->cb_arg = callback_arg;
6320 c->pp2_enabled = 0;
6321 c->pp2_header_state = pp2_header_none;
6323 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6324 comm_point_tcp_handle_callback, c);
6325 if(c->ev->ev == NULL)
6328 sldns_buffer_free(c->buffer);
6329 free(c->ev);
6330 free(c);
6334 return c;
6342 struct comm_point* c = (struct comm_point*)calloc(1, local
6345 if(!c)
6347 c->ev = (struct internal_event*)calloc(1,
6349 if(!c->ev) {
6350 free(c);
6353 c->ev->base = base;
6354 c->fd = -1;
6355 c->buffer = sldns_buffer_new(bufsize);
6356 if(!c->buffer) {
6357 free(c->ev);
6358 free(c);
6361 c->timeout = NULL;
6362 c->tcp_is_reading = 0;
6363 c->tcp_byte_count = 0;
6364 c->tcp_parent = NULL;
6365 c->max_tcp_count = 0;
6366 c->cur_tcp_count = 0;
6367 c->tcp_handlers = NULL;
6368 c->tcp_free = NULL;
6369 c->type = comm_http;
6370 c->tcp_do_close = 0;
6371 c->do_not_close = 0;
6372 c->tcp_do_toggle_rw = 1;
6373 c->tcp_check_nb_connect = 1;
6374 c->http_in_headers = 1;
6375 c->http_in_chunk_headers = 0;
6376 c->http_is_chunked = 0;
6377 c->http_temp = temp;
6379 c->tcp_do_fastopen = 1;
6382 c->dnscrypt = 0;
6383 c->dnscrypt_buffer = c->buffer;
6385 c->repinfo.c = c;
6386 c->callback = callback;
6387 c->cb_arg = callback_arg;
6388 c->pp2_enabled = 0;
6389 c->pp2_header_state = pp2_header_none;
6391 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6392 comm_point_http_handle_callback, c);
6393 if(c->ev->ev == NULL)
6397 SSL_free(c->ssl);
6399 sldns_buffer_free(c->buffer);
6400 free(c->ev);
6401 free(c);
6405 return c;
6412 struct comm_point* c = (struct comm_point*)calloc(1, local
6415 if(!c)
6417 c->ev = (struct internal_event*)calloc(1,
6419 if(!c->ev) {
6420 free(c);
6423 c->ev->base = base;
6424 c->fd = fd;
6425 c->buffer = sldns_buffer_new(bufsize);
6426 if(!c->buffer) {
6427 free(c->ev);
6428 free(c);
6431 c->timeout = NULL;
6432 c->tcp_is_reading = 1;
6433 c->tcp_byte_count = 0;
6434 c->tcp_parent = NULL;
6435 c->max_tcp_count = 0;
6436 c->cur_tcp_count = 0;
6437 c->tcp_handlers = NULL;
6438 c->tcp_free = NULL;
6439 c->type = comm_local;
6440 c->tcp_do_close = 0;
6441 c->do_not_close = 1;
6442 c->tcp_do_toggle_rw = 0;
6443 c->tcp_check_nb_connect = 0;
6445 c->tcp_do_fastopen = 0;
6448 c->dnscrypt = 0;
6449 c->dnscrypt_buffer = c->buffer;
6451 c->callback = callback;
6452 c->cb_arg = callback_arg;
6453 c->pp2_enabled = 0;
6454 c->pp2_header_state = pp2_header_none;
6457 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6458 comm_point_local_handle_callback, c);
6459 if(c->ev->ev == NULL) {
6461 free(c->ev);
6462 free(c);
6465 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
6467 ub_event_free(c->ev->ev);
6468 free(c->ev);
6469 free(c);
6472 c->event_added = 1;
6473 return c;
6480 struct comm_point* c = (struct comm_point*)calloc(1, local
6483 if(!c)
6485 c->ev = (struct internal_event*)calloc(1,
6487 if(!c->ev) {
6488 free(c);
6491 c->ev->base = base;
6492 c->fd = fd;
6493 c->buffer = NULL;
6494 c->timeout = NULL;
6495 c->tcp_is_reading = 0;
6496 c->tcp_byte_count = 0;
6497 c->tcp_parent = NULL;
6498 c->max_tcp_count = 0;
6499 c->cur_tcp_count = 0;
6500 c->tcp_handlers = NULL;
6501 c->tcp_free = NULL;
6502 c->type = comm_raw;
6503 c->tcp_do_close = 0;
6504 c->do_not_close = 1;
6505 c->tcp_do_toggle_rw = 0;
6506 c->tcp_check_nb_connect = 0;
6508 c->tcp_do_fastopen = 0;
6511 c->dnscrypt = 0;
6512 c->dnscrypt_buffer = c->buffer;
6514 c->callback = callback;
6515 c->cb_arg = callback_arg;
6516 c->pp2_enabled = 0;
6517 c->pp2_header_state = pp2_header_none;
6522 c->ev->ev = ub_event_new(base->eb->base, c->fd, evbits,
6523 comm_point_raw_handle_callback, c);
6524 if(c->ev->ev == NULL) {
6526 free(c->ev);
6527 free(c);
6530 if (ub_event_add(c->ev->ev, c->timeout) != 0) {
6532 ub_event_free(c->ev->ev);
6533 free(c->ev);
6534 free(c);
6537 c->event_added = 1;
6538 return c;
6542 comm_point_close(struct comm_point* c) argument
6544 if(!c)
6546 if(c->fd != -1) {
6547 verbose(5, "comm_point_close of %d: event_del", c->fd);
6548 if(c->event_added) {
6549 if(ub_event_del(c->ev->ev) != 0) {
6552 c->event_added = 0;
6555 tcl_close_connection(c->tcl_addr);
6556 if(c->tcp_req_info)
6557 tcp_req_info_clear(c->tcp_req_info);
6558 if(c->h2_session)
6559 http2_session_server_delete(c->h2_session);
6561 if(c->tcp_more_read_again && *c->tcp_more_read_again)
6562 *c->tcp_more_read_again = 0;
6563 if(c->tcp_more_write_again && *c->tcp_more_write_again)
6564 *c->tcp_more_write_again = 0;
6567 if(c->fd != -1 && !c->do_not_close) {
6569 if(c->type == comm_tcp || c->type == comm_http) {
6571 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_READ);
6572 ub_winsock_tcp_wouldblock(c->ev->ev, UB_EV_WRITE);
6575 verbose(VERB_ALGO, "close fd %d", c->fd);
6576 sock_close(c->fd);
6578 c->fd = -1;
6582 comm_point_delete(struct comm_point* c) argument
6584 if(!c)
6586 if((c->type == comm_tcp || c->type == comm_http) && c->ssl) {
6588 SSL_shutdown(c->ssl);
6589 SSL_free(c->ssl);
6592 if(c->type == comm_http && c->http_endpoint) {
6593 free(c->http_endpoint);
6594 c->http_endpoint = NULL;
6596 comm_point_close(c);
6597 if(c->tcp_handlers) {
6599 for(i=0; i<c->max_tcp_count; i++)
6600 comm_point_delete(c->tcp_handlers[i]);
6601 free(c->tcp_handlers);
6603 free(c->timeout);
6604 if(c->type == comm_tcp || c->type == comm_local || c->type == comm_http) {
6605 sldns_buffer_free(c->buffer);
6607 if(c->dnscrypt && c->dnscrypt_buffer != c->buffer) {
6608 sldns_buffer_free(c->dnscrypt_buffer);
6611 if(c->tcp_req_info) {
6612 tcp_req_info_delete(c->tcp_req_info);
6614 if(c->h2_session) {
6615 http2_session_delete(c->h2_session);
6619 if(c->doq_socket)
6620 doq_server_socket_delete(c->doq_socket);
6622 ub_event_free(c->ev->ev);
6623 free(c->ev);
6624 free(c);
6645 log_assert(repinfo && repinfo->c);
6647 buffer = repinfo->c->dnscrypt_buffer;
6652 buffer = repinfo->c->buffer;
6654 if(repinfo->c->type == comm_udp) {
6655 if(repinfo->srctype)
6656 comm_point_send_udp_msg_if(repinfo->c, buffer,
6657 (struct sockaddr*)&repinfo->remote_addr,
6658 repinfo->remote_addrlen, repinfo);
6660 comm_point_send_udp_msg(repinfo->c, buffer,
6661 (struct sockaddr*)&repinfo->remote_addr,
6662 repinfo->remote_addrlen, 0);
6668 if(repinfo->c->dtenv != NULL && repinfo->c->dtenv->log_client_response_messages) {
6669 send_reply_dnstap(repinfo->c->dtenv,
6670 repinfo->c->socket->addr,
6671 repinfo->c->socket->addrlen,
6672 &repinfo->client_addr, repinfo->client_addrlen,
6673 repinfo->c->type, repinfo->c->ssl,
6674 repinfo->c->buffer);
6681 repinfo->c->doq_socket
6682 ?repinfo->c->dtenv:
6684 repinfo->c->tcp_parent->dtenv;
6685 struct sldns_buffer* dtbuffer = repinfo->c->tcp_req_info
6686 ?repinfo->c->tcp_req_info->spool_buffer
6687 :repinfo->c->buffer;
6689 if(repinfo->c->dnscrypt && repinfo->is_dnscrypted)
6690 dtbuffer = repinfo->c->buffer;
6696 if(dtenv != NULL && dtenv->log_client_response_messages) {
6698 repinfo->c->socket->addr,
6699 repinfo->c->socket->addrlen,
6700 &repinfo->client_addr, repinfo->client_addrlen,
6701 repinfo->c->type, repinfo->c->ssl,
6705 if(repinfo->c->tcp_req_info) {
6706 tcp_req_info_send_reply(repinfo->c->tcp_req_info);
6707 } else if(repinfo->c->use_h2) {
6708 if(!http2_submit_dns_response(repinfo->c->h2_session)) {
6712 repinfo->c->h2_stream = NULL;
6713 repinfo->c->tcp_is_reading = 0;
6714 comm_point_stop_listening(repinfo->c);
6715 comm_point_start_listening(repinfo->c, -1,
6716 adjusted_tcp_timeout(repinfo->c));
6719 } else if(repinfo->c->doq_socket) {
6723 comm_point_start_listening(repinfo->c, -1,
6724 adjusted_tcp_timeout(repinfo->c));
6734 log_assert(repinfo->c);
6735 log_assert(repinfo->c->type != comm_tcp_accept);
6736 if(repinfo->c->type == comm_udp)
6738 if(repinfo->c->tcp_req_info)
6739 repinfo->c->tcp_req_info->is_drop = 1;
6740 if(repinfo->c->type == comm_http) {
6741 if(repinfo->c->h2_session) {
6742 repinfo->c->h2_session->is_drop = 1;
6743 if(!repinfo->c->h2_session->postpone_drop)
6744 reclaim_http_handler(repinfo->c);
6747 reclaim_http_handler(repinfo->c);
6750 } else if(repinfo->c->type == comm_doq) {
6755 reclaim_tcp_handler(repinfo->c);
6759 comm_point_stop_listening(struct comm_point* c) argument
6761 verbose(VERB_ALGO, "comm point stop listening %d", c->fd);
6762 if(c->event_added) {
6763 if(ub_event_del(c->ev->ev) != 0) {
6766 c->event_added = 0;
6771 comm_point_start_listening(struct comm_point* c, int newfd, int msec) argument
6774 c->fd==-1?newfd:c->fd, msec);
6775 if(c->type == comm_tcp_accept && !c->tcp_free) {
6779 if(c->event_added) {
6780 if(ub_event_del(c->ev->ev) != 0) {
6783 c->event_added = 0;
6785 if(msec != -1 && msec != 0) {
6786 if(!c->timeout) {
6787 c->timeout = (struct timeval*)malloc(sizeof(
6789 if(!c->timeout) {
6794 ub_event_add_bits(c->ev->ev, UB_EV_TIMEOUT);
6796 c->timeout->tv_sec = msec/1000;
6797 c->timeout->tv_usec = (msec%1000)*1000;
6800 if(msec == 0 || !c->timeout) {
6801 ub_event_del_bits(c->ev->ev, UB_EV_TIMEOUT);
6804 if(c->type == comm_tcp || c->type == comm_http) {
6805 ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
6806 if(c->tcp_write_and_read) {
6807 verbose(5, "startlistening %d mode rw", (newfd==-1?c->fd:newfd));
6808 ub_event_add_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
6809 } else if(c->tcp_is_reading) {
6810 verbose(5, "startlistening %d mode r", (newfd==-1?c->fd:newfd));
6811 ub_event_add_bits(c->ev->ev, UB_EV_READ);
6813 verbose(5, "startlistening %d mode w", (newfd==-1?c->fd:newfd));
6814 ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
6817 if(newfd != -1) {
6818 if(c->fd != -1 && c->fd != newfd) {
6819 verbose(5, "cpsl close of fd %d for %d", c->fd, newfd);
6820 sock_close(c->fd);
6822 c->fd = newfd;
6823 ub_event_set_fd(c->ev->ev, c->fd);
6825 if(ub_event_add(c->ev->ev, msec==0?NULL:c->timeout) != 0) {
6829 c->event_added = 1;
6832 void comm_point_listen_for_rw(struct comm_point* c, int rd, int wr) argument
6834 verbose(VERB_ALGO, "comm point listen_for_rw %d %d", c->fd, wr);
6835 if(c->event_added) {
6836 if(ub_event_del(c->ev->ev) != 0) {
6839 c->event_added = 0;
6841 if(!c->timeout) {
6842 ub_event_del_bits(c->ev->ev, UB_EV_TIMEOUT);
6844 ub_event_del_bits(c->ev->ev, UB_EV_READ|UB_EV_WRITE);
6845 if(rd) ub_event_add_bits(c->ev->ev, UB_EV_READ);
6846 if(wr) ub_event_add_bits(c->ev->ev, UB_EV_WRITE);
6847 if(ub_event_add(c->ev->ev, c->timeout) != 0) {
6851 c->event_added = 1;
6854 size_t comm_point_get_mem(struct comm_point* c) argument
6857 if(!c)
6859 s = sizeof(*c) + sizeof(*c->ev);
6860 if(c->timeout)
6861 s += sizeof(*c->timeout);
6862 if(c->type == comm_tcp || c->type == comm_local) {
6863 s += sizeof(*c->buffer) + sldns_buffer_capacity(c->buffer);
6865 s += sizeof(*c->dnscrypt_buffer);
6866 if(c->buffer != c->dnscrypt_buffer) {
6867 s += sldns_buffer_capacity(c->dnscrypt_buffer);
6871 if(c->type == comm_tcp_accept) {
6873 for(i=0; i<c->max_tcp_count; i++)
6874 s += comm_point_get_mem(c->tcp_handlers[i]);
6888 tm->super.ev_timer = tm;
6889 tm->base = base;
6890 tm->super.callback = cb;
6891 tm->super.cb_arg = cb_arg;
6892 tm->ev = ub_event_new(base->eb->base, -1, UB_EV_TIMEOUT,
6893 comm_timer_callback, &tm->super);
6894 if(tm->ev == NULL) {
6899 return &tm->super;
6907 ub_timer_del(timer->ev_timer->ev);
6908 timer->ev_timer->enabled = 0;
6915 if(timer->ev_timer->enabled)
6917 if(ub_timer_add(timer->ev_timer->ev, timer->ev_timer->base->eb->base,
6920 timer->ev_timer->enabled = 1;
6929 /* Free the sub struct timer->ev_timer derived from the super struct timer.
6930 * i.e. assert(timer == timer->ev_timer)
6932 ub_event_free(timer->ev_timer->ev);
6933 free(timer->ev_timer);
6942 ub_comm_base_now(tm->ev_timer->base);
6943 tm->ev_timer->enabled = 0;
6944 fptr_ok(fptr_whitelist_comm_timer(tm->callback));
6945 (*tm->callback)(tm->cb_arg);
6951 return (int)timer->ev_timer->enabled;
6970 com->base = base;
6971 com->callback = callback;
6972 com->cb_arg = cb_arg;
6973 com->ev_signal = NULL;
6983 ub_comm_base_now(comsig->base);
6984 fptr_ok(fptr_whitelist_comm_signal(comsig->callback));
6985 (*comsig->callback)(sig, comsig->cb_arg);
6999 entry->ev = ub_signal_new(comsig->base->eb->base, sig,
7001 if(entry->ev == NULL) {
7006 if(ub_signal_add(entry->ev, NULL) != 0) {
7008 ub_event_free(entry->ev);
7013 entry->next = comsig->ev_signal;
7014 comsig->ev_signal = entry;
7024 p=comsig->ev_signal;
7026 np = p->next;
7027 ub_signal_del(p->ev);
7028 ub_event_free(p->ev);