Lines Matching refs:sock
94 #define CONSISTENT(sock) consistent(sock)
96 #define CONSISTENT(sock) do {} while (0)
98 static void consistent(isc_socket_t *sock);
278 #define _set_state(sock, _state) do { (sock)->state = (_state); (sock)->state_lineno = __LINE__; } while (0)
362 static isc_boolean_t senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev);
363 static isc_boolean_t acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev);
364 static isc_boolean_t connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev);
365 static void send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev);
366 static void send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev);
367 static void send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev);
368 static void send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev);
369 static void send_recvdone_abort(isc_socket_t *sock, isc_result_t result);
370 static void queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev);
371 static void queue_receive_request(isc_socket_t *sock);
374 * This is used to dump the contents of the sock structure
375 * You should make sure that the sock is locked before
380 sock_dump(isc_socket_t *sock) {
388 isc_socket_getpeername(sock, &addr);
391 isc_socket_getsockname(sock, &addr);
397 printf("\t\tfd: %u\n", sock->fd);
398 printf("\t\treferences: %d\n", sock->references);
399 printf("\t\tpending_accept: %d\n", sock->pending_accept);
400 printf("\t\tconnecting: %d\n", sock->pending_connect);
401 printf("\t\tconnected: %d\n", sock->connected);
402 printf("\t\tbound: %d\n", sock->bound);
403 printf("\t\tpending_iocp: %d\n", sock->pending_iocp);
404 printf("\t\tsocket type: %d\n", sock->type);
407 ldev = ISC_LIST_HEAD(sock->recv_list);
414 ldev = ISC_LIST_HEAD(sock->send_list);
421 ndev = ISC_LIST_HEAD(sock->accept_list);
429 socket_log(int lineno, isc_socket_t *sock, isc_sockaddr_t *address,
544 iocompletionport_update(isc_socket_t *sock) {
548 REQUIRE(VALID_SOCKET(sock));
550 hiocp = CreateIoCompletionPort((HANDLE)sock->fd,
551 sock->manager->hIoCompletionPort, (ULONG_PTR)sock, 0);
578 InterlockedIncrement(&sock->manager->iocp_total);
590 socket_close(isc_socket_t *sock) {
592 REQUIRE(sock != NULL);
594 if (sock->fd != INVALID_SOCKET) {
595 closesocket(sock->fd);
596 sock->fd = INVALID_SOCKET;
597 _set_state(sock, SOCK_CLOSED);
598 InterlockedDecrement(&sock->manager->totalSockets);
610 SOCKET sock;
635 sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
636 INSIST(sock != INVALID_SOCKET);
637 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
643 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
649 err = WSAIoctl(sock, SIO_GET_EXTENSION_FUNCTION_POINTER,
655 closesocket(sock);
672 internal_sendmsg(isc_socket_t *sock, IoCompletionInfo *lpo,
681 Result = WSASendTo(sock->fd, messagehdr->msg_iov,
698 sock->pending_iocp++;
699 sock->pending_send++;
707 sock->pending_iocp++;
708 sock->pending_send++;
718 queue_receive_request(isc_socket_t *sock) {
735 if (sock->pending_recv > 0) {
744 if (ISC_LIST_EMPTY(sock->recv_list)) {
750 INSIST(sock->recvbuf.remaining == 0);
751 INSIST(sock->fd != INVALID_SOCKET);
753 iov[0].len = sock->recvbuf.len;
754 iov[0].buf = sock->recvbuf.base;
765 sock->recvbuf.from_addr_len = sizeof(sock->recvbuf.from_addr);
768 Result = WSARecvFrom((SOCKET)sock->fd, iov, 1,
770 (SOCKADDR *)&sock->recvbuf.from_addr,
771 &sock->recvbuf.from_addr_len,
780 sock->pending_iocp++;
781 sock->pending_recv++;
788 if (!sock->connected) {
801 send_recvdone_abort(sock, isc_result);
812 sock->pending_iocp++;
813 sock->pending_recv++;
816 socket_log(__LINE__, sock, NULL, IOEVENT,
820 sock->fd, Result, Error);
822 CONSISTENT(sock);
847 socket_log(int lineno, isc_socket_t *sock, isc_sockaddr_t *address,
867 "socket %p line %d: %s", sock, lineno, msgbuf);
872 "socket %p line %d peer %s: %s", sock, lineno,
946 build_msghdr_send(isc_socket_t *sock, isc_socketevent_t *dev,
976 socket_log(__LINE__, sock, NULL, TRACE,
1016 socket_log(__LINE__, sock, NULL, TRACE,
1041 set_dev_address(isc_sockaddr_t *address, isc_socket_t *sock,
1044 if (sock->type == isc_sockettype_udp) {
1048 dev->address = sock->address;
1049 } else if (sock->type == isc_sockettype_tcp) {
1051 dev->address = sock->address;
1065 allocate_socketevent(isc_socket_t *sock, isc_eventtype_t eventtype,
1070 ev = (isc_socketevent_t *)isc_event_allocate(sock->manager->mctx,
1071 sock, eventtype,
1092 dump_msg(struct msghdr *msg, isc_socket_t *sock) {
1095 printf("MSGHDR %p, Socket #: %u\n", msg, sock->fd);
1109 map_socket_error(isc_socket_t *sock, int windows_errno, int *isc_errno,
1116 if (sock->connected)
1124 if (sock->connected)
1133 if (sock->connected)
1140 if (sock->connected)
1147 if (sock->connected)
1154 if (sock->connected)
1164 if (sock->connected)
1171 if (sock->connected)
1214 fill_recv(isc_socket_t *sock, isc_socketevent_t *dev) {
1220 INSIST(sock->recvbuf.remaining > 0);
1221 INSIST(sock->pending_recv == 0);
1223 if (sock->type == isc_sockettype_udp) {
1224 dev->address.length = sock->recvbuf.from_addr_len;
1225 memcpy(&dev->address.type, &sock->recvbuf.from_addr,
1226 sock->recvbuf.from_addr_len);
1229 socket_log(__LINE__, sock, &dev->address, IOEVENT,
1234 sock->recvbuf.remaining = 0;
1237 } else if (sock->type == isc_sockettype_tcp) {
1238 dev->address = sock->address;
1248 while (buffer != NULL && sock->recvbuf.remaining > 0) {
1252 copylen = min(r.length, sock->recvbuf.remaining);
1253 memcpy(r.base, sock->recvbuf.consume_position, copylen);
1254 sock->recvbuf.consume_position += copylen;
1255 sock->recvbuf.remaining -= copylen;
1262 copylen = min(dev->region.length - dev->n, sock->recvbuf.remaining);
1263 memcpy(dev->region.base + dev->n, sock->recvbuf.consume_position, copylen);
1264 sock->recvbuf.consume_position += copylen;
1265 sock->recvbuf.remaining -= copylen;
1275 if (sock->type == isc_sockettype_udp)
1276 sock->recvbuf.remaining = 0;
1284 completeio_recv(isc_socket_t *sock)
1292 if (sock->pending_recv > 0)
1295 while (sock->recvbuf.remaining > 0 && !ISC_LIST_EMPTY(sock->recv_list)) {
1296 dev = ISC_LIST_HEAD(sock->recv_list);
1302 fill_recv(sock, dev);
1309 send_recvdone_event(sock, &dev);
1328 completeio_send(isc_socket_t *sock, isc_socketevent_t *dev,
1338 return (map_socket_error(sock, send_errno, &dev->result,
1374 startio_send(isc_socket_t *sock, isc_socketevent_t *dev, int *nbytes,
1393 build_msghdr_send(sock, dev, msghdr, cmsg, sock->iov, lpo);
1395 *nbytes = internal_sendmsg(sock, lpo, msghdr, 0, send_errno);
1417 socket_log(__LINE__, sock, NULL, IOEVENT,
1422 sock->fd, *nbytes, *send_errno, strbuf);
1430 _set_state(sock, SOCK_DATA);
1437 isc_socket_t *sock;
1440 sock = isc_mem_get(manager->mctx, sizeof(*sock));
1442 if (sock == NULL)
1445 sock->magic = 0;
1446 sock->references = 0;
1448 sock->manager = manager;
1449 sock->type = type;
1450 sock->fd = INVALID_SOCKET;
1452 ISC_LINK_INIT(sock, link);
1457 ISC_LIST_INIT(sock->recv_list);
1458 ISC_LIST_INIT(sock->send_list);
1459 ISC_LIST_INIT(sock->accept_list);
1460 sock->connect_ev = NULL;
1461 sock->pending_accept = 0;
1462 sock->pending_recv = 0;
1463 sock->pending_send = 0;
1464 sock->pending_iocp = 0;
1465 sock->listener = 0;
1466 sock->connected = 0;
1467 sock->pending_connect = 0;
1468 sock->bound = 0;
1469 sock->dupped = 0;
1470 memset(sock->name, 0, sizeof(sock->name)); // zero the name field
1471 _set_state(sock, SOCK_INITIALIZED);
1473 sock->recvbuf.len = 65536;
1474 sock->recvbuf.consume_position = sock->recvbuf.base;
1475 sock->recvbuf.remaining = 0;
1476 sock->recvbuf.base = isc_mem_get(manager->mctx, sock->recvbuf.len); // max buffer size
1477 if (sock->recvbuf.base == NULL) {
1478 sock->magic = 0;
1485 result = isc_mutex_init(&sock->lock);
1487 sock->magic = 0;
1488 isc_mem_put(manager->mctx, sock->recvbuf.base, sock->recvbuf.len);
1489 sock->recvbuf.base = NULL;
1493 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1496 sock->magic = SOCKET_MAGIC;
1497 *socketp = sock;
1502 isc_mem_put(manager->mctx, sock, sizeof(*sock));
1511 consistent(isc_socket_t *sock) {
1519 REQUIRE(sock->pending_iocp == sock->pending_recv + sock->pending_send
1520 + sock->pending_accept + sock->pending_connect);
1522 dev = ISC_LIST_HEAD(sock->send_list);
1528 if (count > sock->pending_send) {
1530 crash_reason = "send_list > sock->pending_send";
1533 nev = ISC_LIST_HEAD(sock->accept_list);
1539 if (count > sock->pending_accept) {
1541 crash_reason = "send_list > sock->pending_send";
1545 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
1548 sock_dump(sock);
1570 isc_socket_t *sock = *socketp;
1573 INSIST(VALID_SOCKET(sock));
1574 CONSISTENT(sock);
1576 if (sock->pending_iocp > 0
1577 || sock->pending_recv > 0
1578 || sock->pending_send > 0
1579 || sock->pending_accept > 0
1580 || sock->references > 0
1581 || sock->pending_connect == 1
1582 || !ISC_LIST_EMPTY(sock->recv_list)
1583 || !ISC_LIST_EMPTY(sock->send_list)
1584 || !ISC_LIST_EMPTY(sock->accept_list)
1585 || sock->fd != INVALID_SOCKET) {
1586 UNLOCK(&sock->lock);
1589 UNLOCK(&sock->lock);
1591 free_socket(&sock, lineno);
1597 isc_socket_t *sock = *sockp;
1600 manager = sock->manager;
1605 manager = sock->manager;
1606 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat, ISC_MSGSET_SOCKET,
1608 lineno, sock->fd, &sock->lock, sock->lock.LockSemaphore);
1610 sock->magic = 0;
1611 DESTROYLOCK(&sock->lock);
1613 if (sock->recvbuf.base != NULL)
1614 isc_mem_put(manager->mctx, sock->recvbuf.base, sock->recvbuf.len);
1617 if (ISC_LINK_LINKED(sock, link))
1618 ISC_LIST_UNLINK(manager->socklist, sock, link);
1619 isc_mem_put(manager->mctx, sock, sizeof(*sock));
1636 isc_socket_t *sock = NULL;
1655 result = allocate_socket(manager, type, &sock);
1659 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,
1673 sock->pending_recv,
1674 sock->pending_send,
1675 sock->references);
1676 closesocket(sock->fd);
1677 _set_state(sock, SOCK_CLOSED);
1678 sock->fd = INVALID_SOCKET;
1679 free_socket(&sock, __LINE__);
1685 sock->fd = socket(pf, SOCK_STREAM, IPPROTO_TCP);
1695 sock->fd = _dup(dup_socket->fd);
1696 sock->dupped = 1;
1697 sock->bound = dup_socket->bound;
1701 if (sock->fd == INVALID_SOCKET) {
1703 free_socket(&sock, __LINE__);
1728 result = make_nonblock(sock->fd);
1730 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1732 sock->pending_recv, sock->pending_send,
1733 sock->references);
1734 closesocket(sock->fd);
1735 sock->fd = INVALID_SOCKET;
1736 free_socket(&sock, __LINE__);
1749 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_RECVPKTINFO,
1754 "%s: %s", sock->fd,
1764 && (setsockopt(sock->fd, IPPROTO_IPV6, IPV6_PKTINFO,
1769 sock->fd,
1780 (void)setsockopt(sock->fd, IPPROTO_IPV6,
1790 if (getsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
1794 (void)setsockopt(sock->fd, SOL_SOCKET, SO_RCVBUF,
1802 _set_state(sock, SOCK_OPEN);
1803 sock->references = 1;
1804 *socketp = sock;
1806 iocompletionport_update(sock);
1813 ISC_LIST_APPEND(manager->socklist, sock, link);
1817 socket_log(__LINE__, sock, NULL, CREATION, isc_msgcat,
1819 "created %u type %u", sock->fd, type);
1832 isc__socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
1833 REQUIRE(VALID_SOCKET(sock));
1839 return (socket_create(sock->manager, sock->pf, sock->type,
1840 socketp, sock));
1845 isc_socket_open(isc_socket_t *sock) {
1846 REQUIRE(VALID_SOCKET(sock));
1847 REQUIRE(sock->type != isc_sockettype_fdwatch);
1856 isc__socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
1857 REQUIRE(VALID_SOCKET(sock));
1860 LOCK(&sock->lock);
1861 CONSISTENT(sock);
1862 sock->references++;
1863 UNLOCK(&sock->lock);
1865 *socketp = sock;
1874 isc_socket_t *sock;
1878 sock = *socketp;
1879 REQUIRE(VALID_SOCKET(sock));
1880 REQUIRE(sock->type != isc_sockettype_fdwatch);
1882 LOCK(&sock->lock);
1883 CONSISTENT(sock);
1884 REQUIRE(sock->references > 0);
1885 sock->references--;
1887 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
1889 sock->pending_recv, sock->pending_send,
1890 sock->references);
1892 if (sock->references == 0 && sock->fd != INVALID_SOCKET) {
1893 closesocket(sock->fd);
1894 sock->fd = INVALID_SOCKET;
1895 _set_state(sock, SOCK_CLOSED);
1898 maybe_free_socket(&sock, __LINE__);
1904 isc_socket_close(isc_socket_t *sock) {
1905 REQUIRE(VALID_SOCKET(sock));
1906 REQUIRE(sock->type != isc_sockettype_fdwatch);
1922 send_recvdone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
1926 (*dev)->ev_sender = sock;
1929 ISC_LIST_DEQUEUE(sock->recv_list, *dev, ev_link);
1937 CONSISTENT(sock);
1944 send_senddone_event(isc_socket_t *sock, isc_socketevent_t **dev) {
1950 (*dev)->ev_sender = sock;
1953 ISC_LIST_DEQUEUE(sock->send_list, *dev, ev_link);
1961 CONSISTENT(sock);
1968 send_acceptdone_event(isc_socket_t *sock, isc_socket_newconnev_t **adev) {
1974 (*adev)->ev_sender = sock;
1977 ISC_LIST_DEQUEUE(sock->accept_list, *adev, ev_link);
1981 CONSISTENT(sock);
1988 send_connectdone_event(isc_socket_t *sock, isc_socket_connev_t **cdev) {
1994 (*cdev)->ev_sender = sock;
1996 sock->connect_ev = NULL;
2000 CONSISTENT(sock);
2012 internal_accept(isc_socket_t *sock, IoCompletionInfo *lpo, int accept_errno) {
2021 INSIST(VALID_SOCKET(sock));
2022 LOCK(&sock->lock);
2023 CONSISTENT(sock);
2025 socket_log(__LINE__, sock, NULL, TRACE,
2029 INSIST(sock->listener);
2031 INSIST(sock->pending_iocp > 0);
2032 sock->pending_iocp--;
2033 INSIST(sock->pending_accept > 0);
2034 sock->pending_accept--;
2041 if (!acceptdone_is_active(sock, adev))
2049 ISC_LIST_UNLINK(sock->accept_list, adev, ev_link);
2066 "internal_accept parent %p", sock);
2072 (char *)&sock->fd, sizeof(sock->fd)) == 0);
2086 socket_log(__LINE__, sock, &nsock->address, CREATION,
2092 send_acceptdone_event(sock, &adev);
2095 CONSISTENT(sock);
2096 UNLOCK(&sock->lock);
2107 internal_connect(isc_socket_t *sock, IoCompletionInfo *lpo, int connect_errno) {
2111 INSIST(VALID_SOCKET(sock));
2113 LOCK(&sock->lock);
2115 INSIST(sock->pending_iocp > 0);
2116 sock->pending_iocp--;
2117 INSIST(sock->pending_connect == 1);
2118 sock->pending_connect = 0;
2124 if (!connectdone_is_active(sock, cdev)) {
2125 sock->pending_connect = 0;
2126 if (sock->fd != INVALID_SOCKET) {
2127 closesocket(sock->fd);
2128 sock->fd = INVALID_SOCKET;
2129 _set_state(sock, SOCK_CLOSED);
2131 CONSISTENT(sock);
2132 UNLOCK(&sock->lock);
2146 sock->pending_connect = 1;
2147 CONSISTENT(sock);
2148 UNLOCK(&sock->lock);
2178 INSIST(setsockopt(sock->fd, SOL_SOCKET,
2181 sock->connected = 1;
2182 socket_log(__LINE__, sock, &sock->address, IOEVENT,
2187 send_connectdone_event(sock, &cdev);
2189 UNLOCK(&sock->lock);
2196 send_recvdone_abort(isc_socket_t *sock, isc_result_t result) {
2199 while (!ISC_LIST_EMPTY(sock->recv_list)) {
2200 dev = ISC_LIST_HEAD(sock->recv_list);
2202 send_recvdone_event(sock, &dev);
2214 internal_recv(isc_socket_t *sock, int nbytes)
2216 INSIST(VALID_SOCKET(sock));
2218 LOCK(&sock->lock);
2219 CONSISTENT(sock);
2221 socket_log(__LINE__, sock, NULL, IOEVENT,
2230 INSIST(sock->pending_iocp > 0);
2231 sock->pending_iocp--;
2232 INSIST(sock->pending_recv > 0);
2233 sock->pending_recv--;
2244 if (nbytes == 0 && sock->type == isc_sockettype_tcp) {
2245 send_recvdone_abort(sock, ISC_R_EOF);
2246 maybe_free_socket(&sock, __LINE__);
2249 sock->recvbuf.remaining = nbytes;
2250 sock->recvbuf.consume_position = sock->recvbuf.base;
2251 completeio_recv(sock);
2257 queue_receive_request(sock);
2262 maybe_free_socket(&sock, __LINE__);
2266 internal_send(isc_socket_t *sock, isc_socketevent_t *dev,
2274 INSIST(VALID_SOCKET(sock));
2276 LOCK(&sock->lock);
2277 CONSISTENT(sock);
2279 socket_log(__LINE__, sock, NULL, IOEVENT,
2287 socket_log(__LINE__, sock, NULL, TRACE,
2296 INSIST(sock->pending_iocp > 0);
2297 sock->pending_iocp--;
2298 INSIST(sock->pending_send > 0);
2299 sock->pending_send--;
2302 if (!senddone_is_active(sock, dev))
2308 switch (completeio_send(sock, dev, messagehdr, nbytes, send_errno)) {
2313 send_senddone_event(sock, &dev);
2318 maybe_free_socket(&sock, __LINE__);
2327 senddone_is_active(isc_socket_t *sock, isc_socketevent_t *dev)
2331 ldev = ISC_LIST_HEAD(sock->send_list);
2339 acceptdone_is_active(isc_socket_t *sock, isc_socket_newconnev_t *dev)
2343 ldev = ISC_LIST_HEAD(sock->accept_list);
2351 connectdone_is_active(isc_socket_t *sock, isc_socket_connev_t *dev)
2353 return (sock->connect_ev == dev ? ISC_TRUE : ISC_FALSE);
2424 isc_socket_t *sock = NULL;
2455 &nbytes, (LPDWORD)&sock,
2461 REQUIRE(VALID_SOCKET(sock));
2475 LOCK(&sock->lock);
2476 CONSISTENT(sock);
2479 INSIST(sock->pending_iocp > 0);
2480 sock->pending_iocp--;
2481 INSIST(sock->pending_recv > 0);
2482 sock->pending_recv--;
2483 if (!sock->connected &&
2488 queue_receive_request(sock);
2491 send_recvdone_abort(sock, isc_result);
2500 INSIST(sock->pending_iocp > 0);
2501 sock->pending_iocp--;
2502 INSIST(sock->pending_send > 0);
2503 sock->pending_send--;
2504 if (senddone_is_active(sock, lpo->dev)) {
2506 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2508 send_senddone_event(sock, &lpo->dev);
2513 INSIST(sock->pending_iocp > 0);
2514 INSIST(sock->pending_accept > 0);
2516 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2519 if (acceptdone_is_active(sock, lpo->adev)) {
2520 if (restart_accept(sock, lpo) == ISC_R_SUCCESS) {
2521 UNLOCK(&sock->lock);
2526 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2532 sock->pending_iocp--;
2533 sock->pending_accept--;
2534 if (acceptdone_is_active(sock, lpo->adev)) {
2540 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2542 send_acceptdone_event(sock, &lpo->adev);
2547 INSIST(sock->pending_iocp > 0);
2548 sock->pending_iocp--;
2549 INSIST(sock->pending_connect == 1);
2550 sock->pending_connect = 0;
2551 if (connectdone_is_active(sock, lpo->cdev)) {
2553 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2555 send_connectdone_event(sock, &lpo->cdev);
2559 maybe_free_socket(&sock, __LINE__);
2570 internal_recv(sock, nbytes);
2573 internal_send(sock, lpo->dev, messagehdr, nbytes, errstatus, lpo);
2576 internal_accept(sock, lpo, errstatus);
2579 internal_connect(sock, lpo, errstatus);
2740 queue_receive_event(isc_socket_t *sock, isc_task_t *task, isc_socketevent_t *dev)
2751 ISC_LIST_ENQUEUE(sock->recv_list, dev, ev_link);
2753 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
2766 socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
2776 if (sock->fd == INVALID_SOCKET)
2785 queue_receive_event(sock, task, dev);
2789 completeio_recv(sock);
2795 queue_receive_request(sock);
2801 isc__socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
2811 REQUIRE(VALID_SOCKET(sock));
2812 LOCK(&sock->lock);
2813 CONSISTENT(sock);
2818 if (sock->fd == INVALID_SOCKET) {
2819 UNLOCK(&sock->lock);
2828 manager = sock->manager;
2834 INSIST(sock->bound);
2836 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
2838 UNLOCK(&sock->lock);
2845 if (sock->type == isc_sockettype_udp)
2864 ret = socket_recv(sock, dev, task, 0);
2866 UNLOCK(&sock->lock);
2871 isc__socket_recv(isc_socket_t *sock, isc_region_t *region,
2879 REQUIRE(VALID_SOCKET(sock));
2880 LOCK(&sock->lock);
2881 CONSISTENT(sock);
2886 if (sock->fd == INVALID_SOCKET) {
2887 UNLOCK(&sock->lock);
2892 manager = sock->manager;
2895 INSIST(sock->bound);
2897 dev = allocate_socketevent(sock, ISC_SOCKEVENT_RECVDONE, action, arg);
2899 UNLOCK(&sock->lock);
2903 ret = isc_socket_recv2(sock, region, minimum, task, dev, 0);
2904 UNLOCK(&sock->lock);
2909 isc__socket_recv2(isc_socket_t *sock, isc_region_t *region,
2915 REQUIRE(VALID_SOCKET(sock));
2916 LOCK(&sock->lock);
2917 CONSISTENT(sock);
2920 event->ev_sender = sock;
2924 if (sock->fd == INVALID_SOCKET) {
2925 UNLOCK(&sock->lock);
2938 if (sock->type == isc_sockettype_udp)
2947 ret = socket_recv(sock, event, task, flags);
2948 UNLOCK(&sock->lock);
2956 socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
2968 set_dev_address(address, sock, dev);
2970 socket_log(__LINE__, sock, NULL, TRACE, isc_msgcat, ISC_MSGSET_SOCKET,
2984 io_state = startio_send(sock, dev, &cc, &send_errno);
3000 ISC_LIST_ENQUEUE(sock->send_list, dev, ev_link);
3002 socket_log(__LINE__, sock, NULL, EVENT, NULL, 0, 0,
3019 isc__socket_send(isc_socket_t *sock, isc_region_t *region,
3025 return (isc_socket_sendto(sock, region, task, action, arg, NULL,
3030 isc__socket_sendto(isc_socket_t *sock, isc_region_t *region,
3038 REQUIRE(VALID_SOCKET(sock));
3039 REQUIRE(sock->type != isc_sockettype_fdwatch);
3041 LOCK(&sock->lock);
3042 CONSISTENT(sock);
3047 if (sock->fd == INVALID_SOCKET) {
3048 UNLOCK(&sock->lock);
3055 manager = sock->manager;
3058 INSIST(sock->bound);
3060 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
3062 UNLOCK(&sock->lock);
3067 ret = socket_send(sock, dev, task, address, pktinfo, 0);
3068 UNLOCK(&sock->lock);
3073 isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
3076 return (isc_socket_sendtov(sock, buflist, task, action, arg, NULL,
3081 isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
3091 REQUIRE(VALID_SOCKET(sock));
3093 LOCK(&sock->lock);
3094 CONSISTENT(sock);
3099 if (sock->fd == INVALID_SOCKET) {
3100 UNLOCK(&sock->lock);
3108 manager = sock->manager;
3114 dev = allocate_socketevent(sock, ISC_SOCKEVENT_SENDDONE, action, arg);
3116 UNLOCK(&sock->lock);
3130 ret = socket_send(sock, dev, task, address, pktinfo, 0);
3131 UNLOCK(&sock->lock);
3136 isc__socket_sendto2(isc_socket_t *sock, isc_region_t *region,
3143 REQUIRE(VALID_SOCKET(sock));
3144 LOCK(&sock->lock);
3145 CONSISTENT(sock);
3149 REQUIRE(sock->type == isc_sockettype_udp);
3150 event->ev_sender = sock;
3155 if (sock->fd == INVALID_SOCKET) {
3156 UNLOCK(&sock->lock);
3165 ret = socket_send(sock, event, task, address, pktinfo, flags);
3166 UNLOCK(&sock->lock);
3171 isc__socket_bind(isc_socket_t *sock, isc_sockaddr_t *sockaddr,
3177 REQUIRE(VALID_SOCKET(sock));
3178 LOCK(&sock->lock);
3179 CONSISTENT(sock);
3184 if (sock->fd == INVALID_SOCKET) {
3185 UNLOCK(&sock->lock);
3189 INSIST(!sock->bound);
3190 INSIST(!sock->dupped);
3192 if (sock->pf != sockaddr->type.sa.sa_family) {
3193 UNLOCK(&sock->lock);
3201 setsockopt(sock->fd, SOL_SOCKET, SO_REUSEADDR, (char *)&on,
3204 "setsockopt(%d) %s", sock->fd,
3209 if (bind(sock->fd, &sockaddr->type.sa, sockaddr->length) < 0) {
3211 UNLOCK(&sock->lock);
3229 socket_log(__LINE__, sock, sockaddr, TRACE,
3231 sock->bound = 1;
3233 UNLOCK(&sock->lock);
3238 isc__socket_filter(isc_socket_t *sock, const char *filter) {
3239 UNUSED(sock);
3242 REQUIRE(VALID_SOCKET(sock));
3257 isc__socket_listen(isc_socket_t *sock, unsigned int backlog) {
3260 REQUIRE(VALID_SOCKET(sock));
3262 LOCK(&sock->lock);
3263 CONSISTENT(sock);
3268 if (sock->fd == INVALID_SOCKET) {
3269 UNLOCK(&sock->lock);
3273 REQUIRE(!sock->listener);
3274 REQUIRE(sock->bound);
3275 REQUIRE(sock->type == isc_sockettype_tcp);
3280 if (listen(sock->fd, (int)backlog) < 0) {
3281 UNLOCK(&sock->lock);
3289 socket_log(__LINE__, sock, NULL, TRACE,
3291 sock->listener = 1;
3292 _set_state(sock, SOCK_LISTEN);
3294 UNLOCK(&sock->lock);
3302 isc__socket_accept(isc_socket_t *sock,
3312 REQUIRE(VALID_SOCKET(sock));
3314 manager = sock->manager;
3317 LOCK(&sock->lock);
3318 CONSISTENT(sock);
3323 if (sock->fd == INVALID_SOCKET) {
3324 UNLOCK(&sock->lock);
3328 REQUIRE(sock->listener);
3339 UNLOCK(&sock->lock);
3344 result = allocate_socket(manager, sock->type, &nsock);
3347 UNLOCK(&sock->lock);
3354 nsock->fd = socket(sock->pf, SOCK_STREAM, IPPROTO_TCP);
3358 UNLOCK(&sock->lock);
3370 UNLOCK(&sock->lock);
3393 ISCAcceptEx(sock->fd,
3404 socket_log(__LINE__, sock, NULL, TRACE,
3411 ISC_LIST_ENQUEUE(sock->accept_list, adev, ev_link);
3412 sock->pending_accept++;
3413 sock->pending_iocp++;
3415 UNLOCK(&sock->lock);
3420 isc__socket_connect(isc_socket_t *sock, isc_sockaddr_t *addr,
3430 REQUIRE(VALID_SOCKET(sock));
3435 manager = sock->manager;
3442 LOCK(&sock->lock);
3443 CONSISTENT(sock);
3448 if (sock->fd == INVALID_SOCKET) {
3449 UNLOCK(&sock->lock);
3456 if (!sock->bound) {
3460 if (bind(sock->fd, &any.type.sa, any.length) < 0) {
3462 UNLOCK(&sock->lock);
3480 sock->bound = 1;
3483 REQUIRE(!sock->pending_connect);
3485 cdev = (isc_socket_connev_t *)isc_event_allocate(manager->mctx, sock,
3490 UNLOCK(&sock->lock);
3495 if (sock->type == isc_sockettype_tcp) {
3505 sock->address = *addr;
3506 ISCConnectEx(sock->fd, &addr->type.sa, addr->length,
3515 sock->pending_connect = 1;
3516 _set_state(sock, SOCK_CONNECT);
3521 sock->connect_ev = cdev;
3522 sock->pending_iocp++;
3524 WSAConnect(sock->fd, &addr->type.sa, addr->length, NULL, NULL, NULL, NULL);
3528 CONSISTENT(sock);
3529 UNLOCK(&sock->lock);
3535 isc__socket_getpeername(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->connected) {
3553 *addressp = sock->address;
3559 UNLOCK(&sock->lock);
3565 isc__socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
3570 REQUIRE(VALID_SOCKET(sock));
3573 LOCK(&sock->lock);
3574 CONSISTENT(sock);
3579 if (sock->fd == INVALID_SOCKET) {
3580 UNLOCK(&sock->lock);
3584 if (!sock->bound) {
3592 if (getsockname(sock->fd, &addressp->type.sa, (void *)&len) < 0) {
3602 UNLOCK(&sock->lock);
3612 isc__socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
3614 REQUIRE(VALID_SOCKET(sock));
3623 LOCK(&sock->lock);
3624 CONSISTENT(sock);
3629 if (sock->fd == INVALID_SOCKET) {
3630 UNLOCK(&sock->lock);
3650 dev = ISC_LIST_HEAD(sock->recv_list);
3656 send_recvdone_event(sock, &dev);
3668 dev = ISC_LIST_HEAD(sock->send_list);
3675 send_senddone_event(sock, &dev);
3683 && !ISC_LIST_EMPTY(sock->accept_list)) {
3688 dev = ISC_LIST_HEAD(sock->accept_list);
3701 send_acceptdone_event(sock, &dev);
3713 && sock->connect_ev != NULL) {
3717 INSIST(sock->pending_connect);
3719 dev = sock->connect_ev;
3723 closesocket(sock->fd);
3724 sock->fd = INVALID_SOCKET;
3725 _set_state(sock, SOCK_CLOSED);
3727 sock->connect_ev = NULL;
3729 send_connectdone_event(sock, &dev);
3734 maybe_free_socket(&sock, __LINE__);
3738 isc__socket_gettype(isc_socket_t *sock) {
3741 REQUIRE(VALID_SOCKET(sock));
3743 LOCK(&sock->lock);
3748 if (sock->fd == INVALID_SOCKET) {
3749 UNLOCK(&sock->lock);
3753 type = sock->type;
3754 UNLOCK(&sock->lock);
3759 isc__socket_isbound(isc_socket_t *sock) {
3762 REQUIRE(VALID_SOCKET(sock));
3764 LOCK(&sock->lock);
3765 CONSISTENT(sock);
3770 if (sock->fd == INVALID_SOCKET) {
3771 UNLOCK(&sock->lock);
3775 val = ((sock->bound) ? ISC_TRUE : ISC_FALSE);
3776 UNLOCK(&sock->lock);
3782 isc__socket_ipv6only(isc_socket_t *sock, isc_boolean_t yes) {
3789 REQUIRE(VALID_SOCKET(sock));
3792 if (sock->pf == AF_INET6) {
3793 (void)setsockopt(sock->fd, IPPROTO_IPV6, IPV6_V6ONLY,
3880 isc_socket_t *sock;
3894 sock = ISC_LIST_HEAD(mgr->socklist);
3895 while (sock != NULL) {
3896 LOCK(&sock->lock);
3900 xmlTextWriterWriteFormatString(writer, "%p", sock);
3903 if (sock->name[0] != 0) {
3906 sock->name);
3911 xmlTextWriterWriteFormatString(writer, "%d", sock->references);
3915 ISC_XMLCHAR _socktype(sock->type));
3917 if (sock->connected) {
3918 isc_sockaddr_format(&sock->address, peerbuf,
3926 if (getsockname(sock->fd, &addr.type.sa, (void *)&len) == 0) {
3934 if (sock->pending_recv)
3937 if (sock->pending_send)
3940 if (sock->pending_accept)
3943 if (sock->listener)
3946 if (sock->connected)
3949 if (sock->pending_connect)
3952 if (sock->bound)
3960 UNLOCK(&sock->lock);
3961 sock = ISC_LIST_NEXT(sock, link);