Lines Matching defs:sock
94 #define CONSISTENT(sock) consistent(sock)
96 #define CONSISTENT(sock) do {} while (0)
98 static void consistent(isc_socket_t *sock);
277 #define _set_state(sock, _state) do { (sock)->state = (_state); (sock)->state_lineno = __LINE__; } while (0)
357 static isc_boolean_t senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev);
358 static isc_boolean_t acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev);
359 static isc_boolean_t connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev);
360 static void send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev);
361 static void send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev);
362 static void send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev);
363 static void send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev);
364 static void send_recvdone_abort(isc_socket_t *sock, isc_result_t result);
365 static void queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev);
366 static void queue_receive_request(isc_socket_t *sock);
369 * This is used to dump the contents of the sock structure
370 * You should make sure that the sock is locked before
375 sock_dump(isc_socket_t *sock) {
383 isc_socket_getpeername(sock, &addr);
386 isc_socket_getsockname(sock, &addr);
392 printf("\t\tfd: %u\n", sock->fd);
393 printf("\t\treferences: %d\n", sock->references);
394 printf("\t\tpending_accept: %d\n", sock->pending_accept);
395 printf("\t\tconnecting: %d\n", sock->pending_connect);
396 printf("\t\tconnected: %d\n", sock->connected);
397 printf("\t\tbound: %d\n", sock->bound);
398 printf("\t\tpending_iocp: %d\n", sock->pending_iocp);
399 printf("\t\tsocket type: %d\n", sock->type);
402 ldev = ISC_LIST_HEAD(sock->recv_list);
409 ldev = ISC_LIST_HEAD(sock->send_list);
416 ndev = ISC_LIST_HEAD(sock->accept_list);
424 socket_log(int lineno, isc_socket_t *sock, isc_sockaddr_t *address,
539 iocompletionport_update(isc_socket_t *sock) {
543 REQUIRE(VALID_SOCKET(sock));
545 hiocp = CreateIoCompletionPort((HANDLE)sock->fd,
546 sock->manager->hIoCompletionPort, (ULONG_PTR)sock, 0);
573 InterlockedIncrement(&sock->manager->iocp_total);
585 socket_close(isc_socket_t *sock) {
587 REQUIRE(sock != NULL);
589 if (sock->fd != INVALID_SOCKET) {
590 closesocket(sock->fd);
591 sock->fd = INVALID_SOCKET;
592 _set_state(sock, SOCK_CLOSED);
593 InterlockedDecrement(&sock->manager->totalSockets);
605 SOCKET sock;
630 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
631 INSIST(sock != INVALID_SOCKET);
632 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
638 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
644 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
650 closesocket(sock);
667 internal_sendmsg(isc_socket_t *sock, IoCompletionInfo *lpo,
676 Result = WSASendTo(sock->fd, messagehdr->msg_iov,
693 sock->pending_iocp++;
694 sock->pending_send++;
702 sock->pending_iocp++;
703 sock->pending_send++;
713 queue_receive_request(isc_socket_t *sock) {
729 if (sock->pending_recv > 0) {
738 if (ISC_LIST_EMPTY(sock->recv_list)) {
744 INSIST(sock->recvbuf.remaining == 0);
745 INSIST(sock->fd != INVALID_SOCKET);
747 iov[0].len = sock->recvbuf.len;
748 iov[0].buf = sock->recvbuf.base;
759 sock->recvbuf.from_addr_len = sizeof(sock->recvbuf.from_addr);
762 Result = WSARecvFrom((SOCKET)sock->fd, iov, 1,
764 (SOCKADDR *)&sock->recvbuf.from_addr,
765 &sock->recvbuf.from_addr_len,
774 sock->pending_iocp++;
775 sock->pending_recv++;
782 if (!sock->connected) {
795 send_recvdone_abort(sock, isc_result);
806 sock->pending_iocp++;
807 sock->pending_recv++;
810 socket_log(__LINE__, sock, NULL, IOEVENT,
814 sock->fd, Result, Error);
816 CONSISTENT(sock);
841 socket_log(int lineno, isc_socket_t *sock, isc_sockaddr_t *address,
861 "socket %p line %d: %s", sock, lineno, msgbuf);
866 "socket %p line %d peer %s: %s", sock, lineno,
940 build_msghdr_send(isc_socket_t *sock, isc_socketevent_t *dev,
970 socket_log(__LINE__, sock, NULL, TRACE,
1010 socket_log(__LINE__, sock, NULL, TRACE,
1035 set_dev_address(isc_sockaddr_t *address, isc_socket_t *sock,
1038 if (sock->type == isc_sockettype_udp) {
1042 dev->address = sock->address;
1043 } else if (sock->type == isc_sockettype_tcp) {
1045 dev->address = sock->address;
1059 allocate_socketevent(isc_socket_t *sock, isc_eventtype_t eventtype,
1064 ev = (isc_socketevent_t *)isc_event_allocate(sock->manager->mctx,
1065 sock, eventtype,
1086 dump_msg(struct msghdr *msg, isc_socket_t *sock) {
1089 printf("MSGHDR %p, Socket #: %u\n", msg, sock->fd);
1102 map_socket_error(isc_socket_t *sock, int windows_errno, int *isc_errno,
1109 if (sock->connected)
1117 if (sock->connected)
1126 if (sock->connected)
1133 if (sock->connected)
1140 if (sock->connected)
1147 if (sock->connected)
1157 if (sock->connected)
1164 if (sock->connected)
1207 fill_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
1213 INSIST(sock->recvbuf.remaining > 0);
1214 INSIST(sock->pending_recv == 0);
1216 if (sock->type == isc_sockettype_udp) {
1217 dev->address.length = sock->recvbuf.from_addr_len;
1218 memmove(&dev->address.type, &sock->recvbuf.from_addr,
1219 sock->recvbuf.from_addr_len);
1222 socket_log(__LINE__, sock, &dev->address, IOEVENT,
1227 sock->recvbuf.remaining = 0;
1230 } else if (sock->type == isc_sockettype_tcp) {
1231 dev->address = sock->address;
1241 while (buffer != NULL && sock->recvbuf.remaining > 0) {
1246 sock->recvbuf.remaining);
1247 memmove(r.base, sock->recvbuf.consume_position,
1249 sock->recvbuf.consume_position += copylen;
1250 sock->recvbuf.remaining -= copylen;
1257 copylen = min(dev->region.length - dev->n, sock->recvbuf.remaining);
1259 sock->recvbuf.consume_position, copylen);
1260 sock->recvbuf.consume_position += copylen;
1261 sock->recvbuf.remaining -= copylen;
1271 if (sock->type == isc_sockettype_udp)
1272 sock->recvbuf.remaining = 0;
1280 completeio_recv(isc_socket_t *sock)
1288 if (sock->pending_recv > 0)
1291 while (sock->recvbuf.remaining > 0 && !ISC_LIST_EMPTY(sock->recv_list)) {
1292 dev = ISC_LIST_HEAD(sock->recv_list);
1298 fill_recv(sock, dev);
1305 send_recvdone_event(sock, &dev);
1324 completeio_send(isc_socket_t *sock, isc_socketevent_t *dev,
1334 return (map_socket_error(sock, send_errno, &dev->result,
1370 startio_send(isc_socket_t *sock, isc_socketevent_t *dev, int *nbytes,
1389 build_msghdr_send(sock, dev, msghdr, cmsg, sock->iov, lpo);
1391 *nbytes = internal_sendmsg(sock, lpo, msghdr, 0, send_errno);
1413 socket_log(__LINE__, sock, NULL, IOEVENT,
1418 sock->fd, *nbytes, *send_errno, strbuf);
1426 _set_state(sock, SOCK_DATA);
1431 use_min_mtu(isc_socket_t *sock) {
1434 if (sock->pf == AF_INET6) {
1436 (void)setsockopt(sock->fd, IPPROTO_IPV6, IPV6_USE_MIN_MTU,
1440 UNUSED(sock);
1447 isc_socket_t *sock;
1450 sock = isc_mem_get(manager->mctx, sizeof(*sock));
1452 if (sock == NULL)
1455 sock->magic = 0;
1456 sock->references = 0;
1458 sock->manager = manager;
1459 sock->type = type;
1460 sock->fd = INVALID_SOCKET;
1462 ISC_LINK_INIT(sock, link);
1467 ISC_LIST_INIT(sock->recv_list);
1468 ISC_LIST_INIT(sock->send_list);
1469 ISC_LIST_INIT(sock->accept_list);
1470 sock->connect_ev = NULL;
1471 sock->pending_accept = 0;
1472 sock->pending_recv = 0;
1473 sock->pending_send = 0;
1474 sock->pending_iocp = 0;
1475 sock->listener = 0;
1476 sock->connected = 0;
1477 sock->pending_connect = 0;
1478 sock->bound = 0;
1479 memset(sock->name, 0, sizeof(sock->name)); // zero the name field
1480 _set_state(sock, SOCK_INITIALIZED);
1482 sock->recvbuf.len = 65536;
1483 sock->recvbuf.consume_position = sock->recvbuf.base;
1484 sock->recvbuf.remaining = 0;
1485 sock->recvbuf.base = isc_mem_get(manager->mctx, sock->recvbuf.len); // max buffer size
1486 if (sock->recvbuf.base == NULL) {
1494 result = isc_mutex_init(&sock->lock);
1498 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1501 sock->magic = SOCKET_MAGIC;
1502 *socketp = sock;
1507 if (sock->recvbuf.base != NULL)
1508 isc_mem_put(manager->mctx, sock->recvbuf.base, sock->recvbuf.len);
1509 isc_mem_put(manager->mctx, sock, sizeof(*sock));
1518 consistent(isc_socket_t *sock) {
1526 REQUIRE(sock->pending_iocp == sock->pending_recv + sock->pending_send
1527 + sock->pending_accept + sock->pending_connect);
1529 dev = ISC_LIST_HEAD(sock->send_list);
1535 if (count > sock->pending_send) {
1537 crash_reason = "send_list > sock->pending_send";
1540 nev = ISC_LIST_HEAD(sock->accept_list);
1546 if (count > sock->pending_accept) {
1548 crash_reason = "send_list > sock->pending_send";
1552 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
1555 sock_dump(sock);
1577 isc_socket_t *sock = *socketp;
1580 INSIST(VALID_SOCKET(sock));
1581 CONSISTENT(sock);
1583 if (sock->pending_iocp > 0
1584 || sock->pending_recv > 0
1585 || sock->pending_send > 0
1586 || sock->pending_accept > 0
1587 || sock->references > 0
1588 || sock->pending_connect == 1
1589 || !ISC_LIST_EMPTY(sock->recv_list)
1590 || !ISC_LIST_EMPTY(sock->send_list)
1591 || !ISC_LIST_EMPTY(sock->accept_list)
1592 || sock->fd != INVALID_SOCKET) {
1593 UNLOCK(&sock->lock);
1596 UNLOCK(&sock->lock);
1598 free_socket(&sock, lineno);
1604 isc_socket_t *sock = *sockp;
1610 manager = sock->manager;
1611 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat,
1614 lineno, sock->fd, &sock->lock, sock->lock.LockSemaphore);
1616 sock->magic = 0;
1617 DESTROYLOCK(&sock->lock);
1619 if (sock->recvbuf.base != NULL)
1620 isc_mem_put(manager->mctx, sock->recvbuf.base,
1621 sock->recvbuf.len);
1624 if (ISC_LINK_LINKED(sock, link))
1625 ISC_LIST_UNLINK(manager->socklist, sock, link);
1626 isc_mem_put(manager->mctx, sock, sizeof(*sock));
1642 isc_socket_t *sock = NULL;
1658 result = allocate_socket(manager, type, &sock);
1662 sock->pf = pf;
1665 sock->fd = socket(pf, SOCK_DGRAM, IPPROTO_UDP);
1666 if (sock->fd != INVALID_SOCKET) {
1667 result = connection_reset_fix(sock->fd);
1669 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1671 sock->pending_recv, sock->pending_send,
1672 sock->references);
1673 closesocket(sock->fd);
1674 _set_state(sock, SOCK_CLOSED);
1675 sock->fd = INVALID_SOCKET;
1676 free_socket(&sock, __LINE__);
1682 sock->fd = socket(pf, SOCK_STREAM, IPPROTO_TCP);
1686 if (sock->fd == INVALID_SOCKET) {
1688 free_socket(&sock, __LINE__);
1713 result = make_nonblock(sock->fd);
1715 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1717 sock->pending_recv, sock->pending_send,
1718 sock->references);
1719 closesocket(sock->fd);
1720 sock->fd = INVALID_SOCKET;
1721 free_socket(&sock, __LINE__);
1728 use_min_mtu(sock);
1738 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
1743 "%s: %s", sock->fd,
1753 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_PKTINFO,
1758 sock->fd,
1771 if (getsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
1775 (void)setsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
1783 _set_state(sock, SOCK_OPEN);
1784 sock->references = 1;
1785 *socketp = sock;
1787 iocompletionport_update(sock);
1794 ISC_LIST_APPEND(manager->socklist, sock, link);
1798 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
1799 ISC_MSG_CREATED, "created %u type %u", sock->fd, type);
1805 isc_socket_open(isc_socket_t *sock) {
1806 REQUIRE(VALID_SOCKET(sock));
1807 REQUIRE(sock->type != isc_sockettype_fdwatch);
1816 isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
1817 REQUIRE(VALID_SOCKET(sock));
1820 LOCK(&sock->lock);
1821 CONSISTENT(sock);
1822 sock->references++;
1823 UNLOCK(&sock->lock);
1825 *socketp = sock;
1834 isc_socket_t *sock;
1837 sock = *socketp;
1838 REQUIRE(VALID_SOCKET(sock));
1839 REQUIRE(sock->type != isc_sockettype_fdwatch);
1841 LOCK(&sock->lock);
1842 CONSISTENT(sock);
1843 REQUIRE(sock->references > 0);
1844 sock->references--;
1846 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1848 sock->pending_recv, sock->pending_send,
1849 sock->references);
1851 if (sock->references == 0 && sock->fd != INVALID_SOCKET) {
1852 closesocket(sock->fd);
1853 sock->fd = INVALID_SOCKET;
1854 _set_state(sock, SOCK_CLOSED);
1857 maybe_free_socket(&sock, __LINE__);
1863 isc_socket_close(isc_socket_t *sock) {
1864 REQUIRE(VALID_SOCKET(sock));
1865 REQUIRE(sock->type != isc_sockettype_fdwatch);
1881 send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
1885 (*dev)->ev_sender = sock;
1888 ISC_LIST_DEQUEUE(sock->recv_list, *dev, ev_link);
1896 CONSISTENT(sock);
1903 send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
1909 (*dev)->ev_sender = sock;
1912 ISC_LIST_DEQUEUE(sock->send_list, *dev, ev_link);
1920 CONSISTENT(sock);
1927 send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev) {
1933 (*adev)->ev_sender = sock;
1936 ISC_LIST_DEQUEUE(sock->accept_list, *adev, ev_link);
1940 CONSISTENT(sock);
1947 send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev) {
1953 (*cdev)->ev_sender = sock;
1955 sock->connect_ev = NULL;
1959 CONSISTENT(sock);
1971 internal_accept(isc_socket_t *sock, IoCompletionInfo *lpo, int accept_errno) {
1980 INSIST(VALID_SOCKET(sock));
1981 LOCK(&sock->lock);
1982 CONSISTENT(sock);
1984 socket_log(__LINE__, sock, NULL, TRACE,
1988 INSIST(sock->listener);
1990 INSIST(sock->pending_iocp > 0);
1991 sock->pending_iocp--;
1992 INSIST(sock->pending_accept > 0);
1993 sock->pending_accept--;
2000 if (!acceptdone_is_active(sock, adev))
2008 ISC_LIST_UNLINK(sock->accept_list, adev, ev_link);
2025 "internal_accept parent %p", sock);
2036 (char *)&sock->fd, sizeof(sock->fd)) == 0);
2050 socket_log(__LINE__, sock, &nsock->address, CREATION,
2056 send_acceptdone_event(sock, &adev);
2059 CONSISTENT(sock);
2060 UNLOCK(&sock->lock);
2071 internal_connect(isc_socket_t *sock, IoCompletionInfo *lpo, int connect_errno) {
2075 INSIST(VALID_SOCKET(sock));
2077 LOCK(&sock->lock);
2079 INSIST(sock->pending_iocp > 0);
2080 sock->pending_iocp--;
2081 INSIST(sock->pending_connect == 1);
2082 sock->pending_connect = 0;
2088 if (!connectdone_is_active(sock, cdev)) {
2089 sock->pending_connect = 0;
2090 if (sock->fd != INVALID_SOCKET) {
2091 closesocket(sock->fd);
2092 sock->fd = INVALID_SOCKET;
2093 _set_state(sock, SOCK_CLOSED);
2095 CONSISTENT(sock);
2096 UNLOCK(&sock->lock);
2110 sock->pending_connect = 1;
2111 CONSISTENT(sock);
2112 UNLOCK(&sock->lock);
2142 INSIST(setsockopt(sock->fd, SOL_SOCKET, SO_UPDATE_CONNECT_CONTEXT, NULL, 0) == 0);
2144 sock->connected = 1;
2145 socket_log(__LINE__, sock, &sock->address, IOEVENT,
2150 send_connectdone_event(sock, &cdev);
2152 UNLOCK(&sock->lock);
2159 send_recvdone_abort(isc_socket_t *sock, isc_result_t result) {
2162 while (!ISC_LIST_EMPTY(sock->recv_list)) {
2163 dev = ISC_LIST_HEAD(sock->recv_list);
2165 send_recvdone_event(sock, &dev);
2177 internal_recv(isc_socket_t *sock, int nbytes)
2179 INSIST(VALID_SOCKET(sock));
2181 LOCK(&sock->lock);
2182 CONSISTENT(sock);
2184 socket_log(__LINE__, sock, NULL, IOEVENT,
2193 INSIST(sock->pending_iocp > 0);
2194 sock->pending_iocp--;
2195 INSIST(sock->pending_recv > 0);
2196 sock->pending_recv--;
2207 if (nbytes == 0 && sock->type == isc_sockettype_tcp) {
2208 send_recvdone_abort(sock, ISC_R_EOF);
2209 maybe_free_socket(&sock, __LINE__);
2212 sock->recvbuf.remaining = nbytes;
2213 sock->recvbuf.consume_position = sock->recvbuf.base;
2214 completeio_recv(sock);
2220 queue_receive_request(sock);
2225 maybe_free_socket(&sock, __LINE__);
2229 internal_send(isc_socket_t *sock, isc_socketevent_t *dev,
2237 INSIST(VALID_SOCKET(sock));
2239 LOCK(&sock->lock);
2240 CONSISTENT(sock);
2242 socket_log(__LINE__, sock, NULL, IOEVENT,
2250 socket_log(__LINE__, sock, NULL, TRACE,
2259 INSIST(sock->pending_iocp > 0);
2260 sock->pending_iocp--;
2261 INSIST(sock->pending_send > 0);
2262 sock->pending_send--;
2265 if (!senddone_is_active(sock, dev))
2271 switch (completeio_send(sock, dev, messagehdr, nbytes, send_errno)) {
2276 send_senddone_event(sock, &dev);
2281 maybe_free_socket(&sock, __LINE__);
2290 senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev)
2294 ldev = ISC_LIST_HEAD(sock->send_list);
2302 acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev)
2306 ldev = ISC_LIST_HEAD(sock->accept_list);
2314 connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev)
2316 return (sock->connect_ev == dev ? ISC_TRUE : ISC_FALSE);
2387 isc_socket_t *sock = NULL;
2418 &nbytes, (LPDWORD)&sock,
2424 REQUIRE(VALID_SOCKET(sock));
2438 LOCK(&sock->lock);
2439 CONSISTENT(sock);
2442 INSIST(sock->pending_iocp > 0);
2443 sock->pending_iocp--;
2444 INSIST(sock->pending_recv > 0);
2445 sock->pending_recv--;
2446 if (!sock->connected &&
2451 queue_receive_request(sock);
2454 send_recvdone_abort(sock, isc_result);
2463 INSIST(sock->pending_iocp > 0);
2464 sock->pending_iocp--;
2465 INSIST(sock->pending_send > 0);
2466 sock->pending_send--;
2467 if (senddone_is_active(sock, lpo->dev)) {
2469 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2471 send_senddone_event(sock, &lpo->dev);
2476 INSIST(sock->pending_iocp > 0);
2477 INSIST(sock->pending_accept > 0);
2479 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2482 if (acceptdone_is_active(sock, lpo->adev)) {
2483 if (restart_accept(sock, lpo) == ISC_R_SUCCESS) {
2484 UNLOCK(&sock->lock);
2489 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2495 sock->pending_iocp--;
2496 sock->pending_accept--;
2497 if (acceptdone_is_active(sock, lpo->adev)) {
2503 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2505 send_acceptdone_event(sock, &lpo->adev);
2510 INSIST(sock->pending_iocp > 0);
2511 sock->pending_iocp--;
2512 INSIST(sock->pending_connect == 1);
2513 sock->pending_connect = 0;
2514 if (connectdone_is_active(sock, lpo->cdev)) {
2516 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2518 send_connectdone_event(sock, &lpo->cdev);
2522 maybe_free_socket(&sock, __LINE__);
2533 internal_recv(sock, nbytes);
2536 internal_send(sock, lpo->dev, messagehdr, nbytes, errstatus, lpo);
2539 internal_accept(sock, lpo, errstatus);
2542 internal_connect(sock, lpo, errstatus);
2703 queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev)
2714 ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
2716 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2729 socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
2736 if (sock->fd == INVALID_SOCKET)
2745 queue_receive_event(sock, task, dev);
2749 completeio_recv(sock);
2755 queue_receive_request(sock);
2761 isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
2771 REQUIRE(VALID_SOCKET(sock));
2772 LOCK(&sock->lock);
2773 CONSISTENT(sock);
2778 if (sock->fd == INVALID_SOCKET) {
2779 UNLOCK(&sock->lock);
2788 manager = sock->manager;
2794 INSIST(sock->bound);
2796 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
2798 UNLOCK(&sock->lock);
2805 if (sock->type == isc_sockettype_udp)
2824 ret = socket_recv(sock, dev, task, 0);
2826 UNLOCK(&sock->lock);
2831 isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
2838 REQUIRE(VALID_SOCKET(sock));
2839 LOCK(&sock->lock);
2840 CONSISTENT(sock);
2845 if (sock->fd == INVALID_SOCKET) {
2846 UNLOCK(&sock->lock);
2851 manager = sock->manager;
2854 INSIST(sock->bound);
2856 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
2858 UNLOCK(&sock->lock);
2862 ret = isc_socket_recv2(sock, region, minimum, task, dev, 0);
2863 UNLOCK(&sock->lock);
2868 isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
2874 REQUIRE(VALID_SOCKET(sock));
2875 LOCK(&sock->lock);
2876 CONSISTENT(sock);
2879 event->ev_sender = sock;
2883 if (sock->fd == INVALID_SOCKET) {
2884 UNLOCK(&sock->lock);
2897 if (sock->type == isc_sockettype_udp)
2906 ret = socket_recv(sock, event, task, flags);
2907 UNLOCK(&sock->lock);
2915 socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
2927 set_dev_address(address, sock, dev);
2929 socket_log(__LINE__, sock, NULL, TRACE, isc_msgcat, ISC_MSGSET_SOCKET,
2943 io_state = startio_send(sock, dev, &cc, &send_errno);
2959 ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
2961 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2978 isc_socket_send(isc_socket_t *sock, isc_region_t *region,
2984 return (isc_socket_sendto(sock, region, task, action, arg, NULL,
2989 isc_socket_sendto(isc_socket_t *sock, isc_region_t *region,
2997 REQUIRE(VALID_SOCKET(sock));
2998 REQUIRE(sock->type != isc_sockettype_fdwatch);
3000 LOCK(&sock->lock);
3001 CONSISTENT(sock);
3006 if (sock->fd == INVALID_SOCKET) {
3007 UNLOCK(&sock->lock);
3014 manager = sock->manager;
3017 INSIST(sock->bound);
3019 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
3021 UNLOCK(&sock->lock);
3026 ret = socket_send(sock, dev, task, address, pktinfo, 0);
3027 UNLOCK(&sock->lock);
3032 isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
3035 return (isc_socket_sendtov2(sock, buflist, task, action, arg, NULL,
3040 isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
3044 return (isc_socket_sendtov2(sock, buflist, task, action, arg, address,
3049 isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
3060 REQUIRE(VALID_SOCKET(sock));
3062 LOCK(&sock->lock);
3063 CONSISTENT(sock);
3068 if (sock->fd == INVALID_SOCKET) {
3069 UNLOCK(&sock->lock);
3077 manager = sock->manager;
3083 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
3085 UNLOCK(&sock->lock);
3099 ret = socket_send(sock, dev, task, address, pktinfo, flags);
3100 UNLOCK(&sock->lock);
3105 isc_socket_sendto2(isc_socket_t *sock, isc_region_t *region,
3112 REQUIRE(VALID_SOCKET(sock));
3113 LOCK(&sock->lock);
3114 CONSISTENT(sock);
3118 REQUIRE(sock->type == isc_sockettype_udp);
3119 event->ev_sender = sock;
3124 if (sock->fd == INVALID_SOCKET) {
3125 UNLOCK(&sock->lock);
3134 ret = socket_send(sock, event, task, address, pktinfo, flags);
3135 UNLOCK(&sock->lock);
3140 isc_socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
3146 REQUIRE(VALID_SOCKET(sock));
3147 LOCK(&sock->lock);
3148 CONSISTENT(sock);
3153 if (sock->fd == INVALID_SOCKET) {
3154 UNLOCK(&sock->lock);
3158 INSIST(!sock->bound);
3160 if (sock->pf != sockaddr->type.sa.sa_family) {
3161 UNLOCK(&sock->lock);
3169 setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, (void *)&on,
3172 "setsockopt(%d) %s", sock->fd,
3177 if (bind(sock->fd, &sockaddr->type.sa, sockaddr->length) < 0) {
3179 UNLOCK(&sock->lock);
3197 socket_log(__LINE__, sock, sockaddr, TRACE,
3199 sock->bound = 1;
3201 UNLOCK(&sock->lock);
3206 isc_socket_filter(isc_socket_t *sock, const char *filter) {
3207 UNUSED(sock);
3210 REQUIRE(VALID_SOCKET(sock));
3225 isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
3228 REQUIRE(VALID_SOCKET(sock));
3230 LOCK(&sock->lock);
3231 CONSISTENT(sock);
3236 if (sock->fd == INVALID_SOCKET) {
3237 UNLOCK(&sock->lock);
3241 REQUIRE(!sock->listener);
3242 REQUIRE(sock->bound);
3243 REQUIRE(sock->type == isc_sockettype_tcp);
3248 if (listen(sock->fd, (int)backlog) < 0) {
3249 UNLOCK(&sock->lock);
3257 socket_log(__LINE__, sock, NULL, TRACE,
3259 sock->listener = 1;
3260 _set_state(sock, SOCK_LISTEN);
3262 UNLOCK(&sock->lock);
3270 isc_socket_accept(isc_socket_t *sock,
3280 REQUIRE(VALID_SOCKET(sock));
3282 manager = sock->manager;
3285 LOCK(&sock->lock);
3286 CONSISTENT(sock);
3291 if (sock->fd == INVALID_SOCKET) {
3292 UNLOCK(&sock->lock);
3296 REQUIRE(sock->listener);
3307 UNLOCK(&sock->lock);
3312 result = allocate_socket(manager, sock->type, &nsock);
3315 UNLOCK(&sock->lock);
3322 nsock->fd = socket(sock->pf, SOCK_STREAM, IPPROTO_TCP);
3326 UNLOCK(&sock->lock);
3338 UNLOCK(&sock->lock);
3361 ISCAcceptEx(sock->fd,
3372 socket_log(__LINE__, sock, NULL, TRACE,
3379 ISC_LIST_ENQUEUE(sock->accept_list, adev, ev_link);
3380 sock->pending_accept++;
3381 sock->pending_iocp++;
3383 UNLOCK(&sock->lock);
3388 isc_socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
3398 REQUIRE(VALID_SOCKET(sock));
3403 manager = sock->manager;
3410 LOCK(&sock->lock);
3411 CONSISTENT(sock);
3416 if (sock->fd == INVALID_SOCKET) {
3417 UNLOCK(&sock->lock);
3424 if (!sock->bound) {
3428 if (bind(sock->fd, &any.type.sa, any.length) < 0) {
3430 UNLOCK(&sock->lock);
3448 sock->bound = 1;
3451 REQUIRE(!sock->pending_connect);
3453 cdev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
3458 UNLOCK(&sock->lock);
3463 if (sock->type == isc_sockettype_tcp) {
3473 sock->address = *addr;
3474 ISCConnectEx(sock->fd, &addr->type.sa, addr->length,
3483 sock->pending_connect = 1;
3484 _set_state(sock, SOCK_CONNECT);
3489 sock->connect_ev = cdev;
3490 sock->pending_iocp++;
3492 WSAConnect(sock->fd, &addr->type.sa, addr->length, NULL, NULL, NULL, NULL);
3496 CONSISTENT(sock);
3497 UNLOCK(&sock->lock);
3503 isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
3506 REQUIRE(VALID_SOCKET(sock));
3509 LOCK(&sock->lock);
3510 CONSISTENT(sock);
3515 if (sock->fd == INVALID_SOCKET) {
3516 UNLOCK(&sock->lock);
3520 if (sock->connected) {
3521 *addressp = sock->address;
3527 UNLOCK(&sock->lock);
3533 isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
3538 REQUIRE(VALID_SOCKET(sock));
3541 LOCK(&sock->lock);
3542 CONSISTENT(sock);
3547 if (sock->fd == INVALID_SOCKET) {
3548 UNLOCK(&sock->lock);
3552 if (!sock->bound) {
3560 if (getsockname(sock->fd, &addressp->type.sa, (void *)&len) < 0) {
3570 UNLOCK(&sock->lock);
3580 isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
3582 REQUIRE(VALID_SOCKET(sock));
3591 LOCK(&sock->lock);
3592 CONSISTENT(sock);
3597 if (sock->fd == INVALID_SOCKET) {
3598 UNLOCK(&sock->lock);
3618 dev = ISC_LIST_HEAD(sock->recv_list);
3624 send_recvdone_event(sock, &dev);
3636 dev = ISC_LIST_HEAD(sock->send_list);
3643 send_senddone_event(sock, &dev);
3651 && !ISC_LIST_EMPTY(sock->accept_list)) {
3656 dev = ISC_LIST_HEAD(sock->accept_list);
3669 send_acceptdone_event(sock, &dev);
3681 && sock->connect_ev != NULL) {
3685 INSIST(sock->pending_connect);
3687 dev = sock->connect_ev;
3691 closesocket(sock->fd);
3692 sock->fd = INVALID_SOCKET;
3693 _set_state(sock, SOCK_CLOSED);
3695 sock->connect_ev = NULL;
3697 send_connectdone_event(sock, &dev);
3702 maybe_free_socket(&sock, __LINE__);
3706 isc_socket_gettype(isc_socket_t *sock) {
3709 REQUIRE(VALID_SOCKET(sock));
3711 LOCK(&sock->lock);
3716 if (sock->fd == INVALID_SOCKET) {
3717 UNLOCK(&sock->lock);
3721 type = sock->type;
3722 UNLOCK(&sock->lock);
3727 isc_socket_isbound(isc_socket_t *sock) {
3730 REQUIRE(VALID_SOCKET(sock));
3732 LOCK(&sock->lock);
3733 CONSISTENT(sock);
3738 if (sock->fd == INVALID_SOCKET) {
3739 UNLOCK(&sock->lock);
3743 val = ((sock->bound) ? ISC_TRUE : ISC_FALSE);
3744 UNLOCK(&sock->lock);
3750 isc_socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes) {
3757 REQUIRE(VALID_SOCKET(sock));
3760 if (sock->pf == AF_INET6) {
3761 (void)setsockopt(sock->fd, IPPROTO_IPV6, IPV6_V6ONLY,