2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Ancillary Function Driver DLL
4 * FILE: dll/win32/msafd/misc/dllmain.c
5 * PURPOSE: DLL entry point
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Alex Ionescu (alex@relsoft.net)
8 * Pierre Schweitzer (pierre@reactos.org)
10 * CSH 01/09-2000 Created
11 * Alex 16/07/2004 - Complete Rewrite
20 WSPUPCALLTABLE Upcalls
;
21 DWORD CatalogEntryId
; /* CatalogEntryId for upcalls */
22 LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
;
23 PSOCKET_INFORMATION SocketListHead
= NULL
;
24 CRITICAL_SECTION SocketListLock
;
25 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
26 ULONG SockAsyncThreadRefCount
;
27 HANDLE SockAsyncHelperAfdHandle
;
28 HANDLE SockAsyncCompletionPort
= NULL
;
29 BOOLEAN SockAsyncSelectCalled
;
34 * FUNCTION: Creates a new socket
38 * protocol = Protocol type
39 * lpProtocolInfo = Pointer to protocol information
41 * dwFlags = Socket flags
42 * lpErrno = Address of buffer for error information
44 * Created socket, or INVALID_SOCKET if it could not be created
48 WSPSocket(int AddressFamily
,
51 LPWSAPROTOCOL_INFOW lpProtocolInfo
,
56 OBJECT_ATTRIBUTES Object
;
60 PAFD_CREATE_PACKET AfdPacket
;
62 PSOCKET_INFORMATION Socket
= NULL
;
63 PFILE_FULL_EA_INFORMATION EABuffer
= NULL
;
64 PHELPER_DATA HelperData
;
65 PVOID HelperDLLContext
;
67 UNICODE_STRING TransportName
;
68 UNICODE_STRING DevName
;
69 LARGE_INTEGER GroupData
;
71 PSOCK_SHARED_INFO SharedData
= NULL
;
73 TRACE("Creating Socket, getting TDI Name - AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
74 AddressFamily
, SocketType
, Protocol
);
76 if (lpProtocolInfo
&& lpProtocolInfo
->dwServiceFlags3
!= 0 && lpProtocolInfo
->dwServiceFlags4
!= 0)
78 /* Duplpicating socket from different process */
79 if (UlongToPtr(lpProtocolInfo
->dwServiceFlags3
) == INVALID_HANDLE_VALUE
)
84 if (UlongToPtr(lpProtocolInfo
->dwServiceFlags4
) == INVALID_HANDLE_VALUE
)
89 SharedData
= MapViewOfFile(UlongToPtr(lpProtocolInfo
->dwServiceFlags3
),
93 sizeof(SOCK_SHARED_INFO
));
99 InterlockedIncrement(&SharedData
->RefCount
);
100 AddressFamily
= SharedData
->AddressFamily
;
101 SocketType
= SharedData
->SocketType
;
102 Protocol
= SharedData
->Protocol
;
105 if (AddressFamily
== AF_UNSPEC
&& SocketType
== 0 && Protocol
== 0)
111 /* Set the defaults */
112 if (AddressFamily
== AF_UNSPEC
)
113 AddressFamily
= AF_INET
;
120 SocketType
= SOCK_STREAM
;
123 SocketType
= SOCK_DGRAM
;
126 SocketType
= SOCK_RAW
;
129 TRACE("Unknown Protocol (%d). We will try SOCK_STREAM.\n", Protocol
);
130 SocketType
= SOCK_STREAM
;
140 Protocol
= IPPROTO_TCP
;
143 Protocol
= IPPROTO_UDP
;
146 Protocol
= IPPROTO_RAW
;
149 TRACE("Unknown SocketType (%d). We will try IPPROTO_TCP.\n", SocketType
);
150 Protocol
= IPPROTO_TCP
;
155 /* Get Helper Data and Transport */
156 Status
= SockGetTdiName (&AddressFamily
,
166 /* Check for error */
167 if (Status
!= NO_ERROR
)
169 ERR("SockGetTdiName: Status %x\n", Status
);
173 /* AFD Device Name */
174 RtlInitUnicodeString(&DevName
, L
"\\Device\\Afd\\Endpoint");
176 /* Set Socket Data */
177 Socket
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
));
183 RtlZeroMemory(Socket
, sizeof(*Socket
));
186 Socket
->SharedData
= SharedData
;
187 Socket
->SharedDataHandle
= UlongToHandle(lpProtocolInfo
->dwServiceFlags3
);
188 Sock
= UlongToHandle(lpProtocolInfo
->dwServiceFlags4
);
189 Socket
->Handle
= (SOCKET
)lpProtocolInfo
->dwServiceFlags4
;
193 Socket
->SharedDataHandle
= INVALID_HANDLE_VALUE
;
194 Socket
->SharedData
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
->SharedData
));
195 if (!Socket
->SharedData
)
200 RtlZeroMemory(Socket
->SharedData
, sizeof(*Socket
->SharedData
));
201 Socket
->SharedData
->State
= SocketOpen
;
202 Socket
->SharedData
->RefCount
= 1L;
203 Socket
->SharedData
->Listening
= FALSE
;
204 Socket
->SharedData
->AddressFamily
= AddressFamily
;
205 Socket
->SharedData
->SocketType
= SocketType
;
206 Socket
->SharedData
->Protocol
= Protocol
;
207 Socket
->SharedData
->SizeOfLocalAddress
= HelperData
->MaxWSAddressLength
;
208 Socket
->SharedData
->SizeOfRemoteAddress
= HelperData
->MaxWSAddressLength
;
209 Socket
->SharedData
->UseDelayedAcceptance
= HelperData
->UseDelayedAcceptance
;
210 Socket
->SharedData
->CreateFlags
= dwFlags
;
211 Socket
->SharedData
->ServiceFlags1
= lpProtocolInfo
->dwServiceFlags1
;
212 Socket
->SharedData
->ProviderFlags
= lpProtocolInfo
->dwProviderFlags
;
213 Socket
->SharedData
->UseSAN
= FALSE
;
214 Socket
->SharedData
->NonBlocking
= FALSE
; /* Sockets start blocking */
215 Socket
->SharedData
->RecvTimeout
= INFINITE
;
216 Socket
->SharedData
->SendTimeout
= INFINITE
;
217 Socket
->SharedData
->OobInline
= FALSE
;
219 /* Ask alex about this */
220 if( Socket
->SharedData
->SocketType
== SOCK_DGRAM
||
221 Socket
->SharedData
->SocketType
== SOCK_RAW
)
223 TRACE("Connectionless socket\n");
224 Socket
->SharedData
->ServiceFlags1
|= XP1_CONNECTIONLESS
;
226 Socket
->Handle
= INVALID_SOCKET
;
229 Socket
->HelperContext
= HelperDLLContext
;
230 Socket
->HelperData
= HelperData
;
231 Socket
->HelperEvents
= HelperEvents
;
232 Socket
->LocalAddress
= &Socket
->SharedData
->WSLocalAddress
;
233 Socket
->RemoteAddress
= &Socket
->SharedData
->WSRemoteAddress
;
234 Socket
->SanData
= NULL
;
235 RtlCopyMemory(&Socket
->ProtocolInfo
, lpProtocolInfo
, sizeof(Socket
->ProtocolInfo
));
240 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
243 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
245 /* Set up EA Buffer */
246 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
253 RtlZeroMemory(EABuffer
, SizeOfEA
);
254 EABuffer
->NextEntryOffset
= 0;
256 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
257 RtlCopyMemory (EABuffer
->EaName
,
259 AFD_PACKET_COMMAND_LENGTH
+ 1);
260 EABuffer
->EaValueLength
= SizeOfPacket
;
262 /* Set up AFD Packet */
263 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
264 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
265 RtlCopyMemory (AfdPacket
->TransportName
,
266 TransportName
.Buffer
,
267 TransportName
.Length
+ sizeof(WCHAR
));
268 AfdPacket
->GroupID
= g
;
270 /* Set up Endpoint Flags */
271 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
273 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
275 /* Only RAW or UDP can be Connectionless */
279 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
282 if ((Socket
->SharedData
->ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
284 if (SocketType
== SOCK_STREAM
)
286 if ((Socket
->SharedData
->ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
288 /* The Provider doesn't actually support Message Oriented Streams */
293 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
296 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
298 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
299 WSA_FLAG_MULTIPOINT_C_LEAF
|
300 WSA_FLAG_MULTIPOINT_D_ROOT
|
301 WSA_FLAG_MULTIPOINT_D_LEAF
))
303 if ((Socket
->SharedData
->ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
305 /* The Provider doesn't actually support Multipoint */
309 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
311 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
313 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
314 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
316 /* The Provider doesn't support Control Planes, or you already gave a leaf */
320 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
323 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
325 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
326 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
328 /* The Provider doesn't support Data Planes, or you already gave a leaf */
332 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
336 /* Set up Object Attributes */
337 InitializeObjectAttributes (&Object
,
339 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
343 /* Create the Socket as asynchronous. That means we have to block
344 ourselves after every call to NtDeviceIoControlFile. This is
345 because the kernel doesn't support overlapping synchronous I/O
346 requests (made from multiple threads) at this time (Sep 2005) */
347 Status
= NtCreateFile(&Sock
,
348 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
353 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
359 HeapFree(GlobalHeap
, 0, EABuffer
);
361 if (!NT_SUCCESS(Status
))
363 ERR("Failed to open socket. Status 0x%08x\n", Status
);
364 Status
= TranslateNtStatusError(Status
);
369 Socket
->Handle
= (SOCKET
)Sock
;
371 /* Save Group Info */
374 GetSocketInformation(Socket
,
375 AFD_INFO_GROUP_ID_TYPE
,
381 Socket
->SharedData
->GroupID
= GroupData
.u
.LowPart
;
382 Socket
->SharedData
->GroupType
= GroupData
.u
.HighPart
;
385 /* Get Window Sizes and Save them */
386 GetSocketInformation (Socket
,
387 AFD_INFO_SEND_WINDOW_SIZE
,
389 &Socket
->SharedData
->SizeOfSendBuffer
,
394 GetSocketInformation (Socket
,
395 AFD_INFO_RECEIVE_WINDOW_SIZE
,
397 &Socket
->SharedData
->SizeOfRecvBuffer
,
403 /* Save in Process Sockets List */
404 EnterCriticalSection(&SocketListLock
);
405 Socket
->NextSocket
= SocketListHead
;
406 SocketListHead
= Socket
;
407 LeaveCriticalSection(&SocketListLock
);
409 /* Create the Socket Context */
410 CreateContext(Socket
);
413 Upcalls
.lpWPUModifyIFSHandle(Socket
->ProtocolInfo
.dwCatalogEntryId
, (SOCKET
)Sock
, lpErrno
);
415 /* Return Socket Handle */
416 TRACE("Success %x\n", Sock
);
421 ERR("Ending %x\n", Status
);
425 UnmapViewOfFile(SharedData
);
426 NtClose(UlongToHandle(lpProtocolInfo
->dwServiceFlags3
));
430 if( Socket
&& Socket
->SharedData
)
431 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
435 HeapFree(GlobalHeap
, 0, Socket
);
438 HeapFree(GlobalHeap
, 0, EABuffer
);
443 return INVALID_SOCKET
;
451 IN DWORD dwProcessId
,
452 OUT LPWSAPROTOCOL_INFOW lpProtocolInfo
,
455 HANDLE hProcess
, hDuplicatedSharedData
, hDuplicatedHandle
;
456 PSOCKET_INFORMATION Socket
;
457 PSOCK_SHARED_INFO pSharedData
, pOldSharedData
;
460 if (Handle
== INVALID_SOCKET
)
461 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
462 Socket
= GetSocketStructure(Handle
);
466 *lpErrno
= WSAENOTSOCK
;
469 if ( !(hProcess
= OpenProcess(PROCESS_DUP_HANDLE
, FALSE
, dwProcessId
)) )
470 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
472 /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
473 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
475 Socket
->SharedDataHandle
= CreateFileMapping(INVALID_HANDLE_VALUE
,
477 PAGE_READWRITE
| SEC_COMMIT
,
479 (sizeof(SOCK_SHARED_INFO
) + PAGE_SIZE
- 1) & ~(PAGE_SIZE
- 1),
481 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
482 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
483 pSharedData
= MapViewOfFile(Socket
->SharedDataHandle
,
487 sizeof(SOCK_SHARED_INFO
));
489 RtlCopyMemory(pSharedData
, Socket
->SharedData
, sizeof(SOCK_SHARED_INFO
));
490 pOldSharedData
= Socket
->SharedData
;
491 Socket
->SharedData
= pSharedData
;
492 HeapFree(GlobalHeap
, 0, pOldSharedData
);
494 /* Duplicate the handles for the new process */
495 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
496 Socket
->SharedDataHandle
,
498 (LPHANDLE
)&hDuplicatedSharedData
,
501 DUPLICATE_SAME_ACCESS
);
505 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
507 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
508 (HANDLE
)Socket
->Handle
,
510 (LPHANDLE
)&hDuplicatedHandle
,
513 DUPLICATE_SAME_ACCESS
);
516 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
520 return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION
, lpErrno
, 0, NULL
);
522 RtlCopyMemory(lpProtocolInfo
, &Socket
->ProtocolInfo
, sizeof(*lpProtocolInfo
));
524 lpProtocolInfo
->iAddressFamily
= Socket
->SharedData
->AddressFamily
;
525 lpProtocolInfo
->iProtocol
= Socket
->SharedData
->Protocol
;
526 lpProtocolInfo
->iSocketType
= Socket
->SharedData
->SocketType
;
527 lpProtocolInfo
->dwServiceFlags3
= HandleToUlong(hDuplicatedSharedData
);
528 lpProtocolInfo
->dwServiceFlags4
= HandleToUlong(hDuplicatedHandle
);
537 TranslateNtStatusError(NTSTATUS Status
)
541 case STATUS_CANT_WAIT
:
542 return WSAEWOULDBLOCK
;
550 case STATUS_FILE_CLOSED
:
551 return WSAECONNRESET
;
553 case STATUS_END_OF_FILE
:
557 return WSA_IO_PENDING
;
559 case STATUS_BUFFER_TOO_SMALL
:
560 case STATUS_BUFFER_OVERFLOW
:
563 case STATUS_NO_MEMORY
:
564 case STATUS_INSUFFICIENT_RESOURCES
:
567 case STATUS_INVALID_CONNECTION
:
570 case STATUS_PROTOCOL_NOT_SUPPORTED
:
571 return WSAEAFNOSUPPORT
;
573 case STATUS_INVALID_ADDRESS
:
574 return WSAEADDRNOTAVAIL
;
576 case STATUS_REMOTE_NOT_LISTENING
:
577 case STATUS_REMOTE_DISCONNECT
:
578 return WSAECONNREFUSED
;
580 case STATUS_NETWORK_UNREACHABLE
:
581 return WSAENETUNREACH
;
583 case STATUS_HOST_UNREACHABLE
:
584 return WSAEHOSTUNREACH
;
586 case STATUS_INVALID_PARAMETER
:
589 case STATUS_CANCELLED
:
590 return WSA_OPERATION_ABORTED
;
592 case STATUS_ADDRESS_ALREADY_EXISTS
:
593 return WSAEADDRINUSE
;
595 case STATUS_LOCAL_DISCONNECT
:
596 return WSAECONNABORTED
;
598 case STATUS_ACCESS_VIOLATION
:
601 case STATUS_ACCESS_DENIED
:
604 case STATUS_NOT_IMPLEMENTED
:
605 return WSAEOPNOTSUPP
;
608 ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
614 * FUNCTION: Closes an open socket
616 * s = Socket descriptor
617 * lpErrno = Address of buffer for error information
619 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
623 WSPCloseSocket(IN SOCKET Handle
,
626 IO_STATUS_BLOCK IoStatusBlock
;
627 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
630 AFD_DISCONNECT_INFO DisconnectInfo
;
631 SOCKET_STATE OldState
;
632 LONG LingerWait
= -1;
635 /* Get the Socket Structure associate to this Socket*/
636 Socket
= GetSocketStructure(Handle
);
639 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
643 /* Create the Wait Event */
644 Status
= NtCreateEvent(&SockEvent
,
647 SynchronizationEvent
,
650 if(!NT_SUCCESS(Status
))
652 ERR("NtCreateEvent failed: 0x%08x", Status
);
656 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
658 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
660 Socket
->TdiAddressHandle
,
661 Socket
->TdiConnectionHandle
,
666 if (lpErrno
) *lpErrno
= Status
;
667 ERR("WSHNotify failed. Error 0x%#x", Status
);
673 /* If a Close is already in Process, give up */
674 if (Socket
->SharedData
->State
== SocketClosed
)
676 WARN("Socket is closing.\n");
678 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
682 /* Decrement reference count on SharedData */
683 References
= InterlockedDecrement(&Socket
->SharedData
->RefCount
);
687 /* Set the state to close */
688 OldState
= Socket
->SharedData
->State
;
689 Socket
->SharedData
->State
= SocketClosed
;
691 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
692 /* FIXME: Should we do this on Datagram Sockets too? */
693 if ((OldState
== SocketConnected
) && (Socket
->SharedData
->LingerData
.l_onoff
))
695 ULONG SendsInProgress
;
698 /* We need to respect the timeout */
700 LingerWait
= Socket
->SharedData
->LingerData
.l_linger
* 1000;
702 /* Loop until no more sends are pending, within the timeout */
705 /* Find out how many Sends are in Progress */
706 if (GetSocketInformation(Socket
,
707 AFD_INFO_SENDS_IN_PROGRESS
,
714 /* Bail out if anything but NO_ERROR */
719 /* Bail out if no more sends are pending */
720 if (!SendsInProgress
)
727 * We have to execute a sleep, so it's kind of like
728 * a block. If the socket is Nonblock, we cannot
729 * go on since asynchronous operation is expected
730 * and we cannot offer it
732 if (Socket
->SharedData
->NonBlocking
)
734 WARN("Would block!\n");
736 Socket
->SharedData
->State
= OldState
;
737 if (lpErrno
) *lpErrno
= WSAEWOULDBLOCK
;
741 /* Now we can sleep, and decrement the linger wait */
743 * FIXME: It seems Windows does some funky acceleration
744 * since the waiting seems to be longer and longer. I
745 * don't think this improves performance so much, so we
746 * wait a fixed time instead.
749 LingerWait
-= SleepWait
;
753 if (OldState
== SocketConnected
)
757 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
758 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
760 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
->SendShutdown
)) ||
761 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
->ReceiveShutdown
)))
764 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
769 IOCTL_AFD_DISCONNECT
,
771 sizeof(DisconnectInfo
),
775 /* Wait for return */
776 if (Status
== STATUS_PENDING
)
778 WaitForSingleObject(SockEvent
, INFINITE
);
779 Status
= IoStatusBlock
.Status
;
786 Socket
->HelperContext
= NULL
;
787 Socket
->SharedData
->AsyncDisabledEvents
= -1;
788 NtClose(Socket
->TdiAddressHandle
);
789 Socket
->TdiAddressHandle
= NULL
;
790 NtClose(Socket
->TdiConnectionHandle
);
791 Socket
->TdiConnectionHandle
= NULL
;
793 EnterCriticalSection(&SocketListLock
);
794 if (SocketListHead
== Socket
)
796 SocketListHead
= SocketListHead
->NextSocket
;
800 CurrentSocket
= SocketListHead
;
801 while (CurrentSocket
->NextSocket
)
803 if (CurrentSocket
->NextSocket
== Socket
)
805 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
809 CurrentSocket
= CurrentSocket
->NextSocket
;
812 LeaveCriticalSection(&SocketListLock
);
814 /* Close the handle */
815 NtClose((HANDLE
)Handle
);
818 if( Socket
->SharedDataHandle
!= INVALID_HANDLE_VALUE
)
820 /* It is a duplicated socket, so unmap the memory */
821 UnmapViewOfFile(Socket
->SharedData
);
822 NtClose(Socket
->SharedDataHandle
);
823 Socket
->SharedData
= NULL
;
825 if( !References
&& Socket
->SharedData
)
827 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
829 HeapFree(GlobalHeap
, 0, Socket
);
830 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
835 * FUNCTION: Associates a local address with a socket
837 * s = Socket descriptor
838 * name = Pointer to local address
839 * namelen = Length of name
840 * lpErrno = Address of buffer for error information
842 * 0, or SOCKET_ERROR if the socket could not be bound
846 WSPBind(SOCKET Handle
,
847 const struct sockaddr
*SocketAddress
,
848 int SocketAddressLength
,
851 IO_STATUS_BLOCK IOSB
;
852 PAFD_BIND_DATA BindData
;
853 PSOCKET_INFORMATION Socket
= NULL
;
855 SOCKADDR_INFO SocketInfo
;
858 /* Get the Socket Structure associate to this Socket*/
859 Socket
= GetSocketStructure(Handle
);
862 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
865 if (Socket
->SharedData
->State
!= SocketOpen
)
867 if (lpErrno
) *lpErrno
= WSAEINVAL
;
870 if (!SocketAddress
|| SocketAddressLength
< Socket
->SharedData
->SizeOfLocalAddress
)
872 if (lpErrno
) *lpErrno
= WSAEINVAL
;
876 /* Get Address Information */
877 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
881 if (SocketInfo
.AddressInfo
== SockaddrAddressInfoBroadcast
&& !Socket
->SharedData
->Broadcast
)
883 if (lpErrno
) *lpErrno
= WSAEADDRNOTAVAIL
;
887 Status
= NtCreateEvent(&SockEvent
,
890 SynchronizationEvent
,
893 if (!NT_SUCCESS(Status
))
899 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
902 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
905 /* Set up Address in TDI Format */
906 BindData
->Address
.TAAddressCount
= 1;
907 BindData
->Address
.Address
[0].AddressLength
= (USHORT
)(SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
908 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
909 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
910 SocketAddress
->sa_data
,
911 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
913 /* Set the Share Type */
914 if (Socket
->SharedData
->ExclusiveAddressUse
)
916 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
918 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
920 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
922 else if (Socket
->SharedData
->ReuseAddresses
)
924 BindData
->ShareType
= AFD_SHARE_REUSE
;
928 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
932 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
939 0xA + Socket
->SharedData
->SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
941 0xA + Socket
->SharedData
->SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
943 /* Wait for return */
944 if (Status
== STATUS_PENDING
)
946 WaitForSingleObject(SockEvent
, INFINITE
);
947 Status
= IOSB
.Status
;
950 NtClose( SockEvent
);
951 HeapFree(GlobalHeap
, 0, BindData
);
953 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
954 if (Status
!= STATUS_SUCCESS
)
955 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
957 /* Set up Socket Data */
958 Socket
->SharedData
->State
= SocketBound
;
959 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
961 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
963 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
965 Socket
->TdiAddressHandle
,
966 Socket
->TdiConnectionHandle
,
971 if (lpErrno
) *lpErrno
= Status
;
976 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
981 WSPListen(SOCKET Handle
,
985 IO_STATUS_BLOCK IOSB
;
986 AFD_LISTEN_DATA ListenData
;
987 PSOCKET_INFORMATION Socket
= NULL
;
991 /* Get the Socket Structure associate to this Socket*/
992 Socket
= GetSocketStructure(Handle
);
995 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
999 if (Socket
->SharedData
->Listening
)
1002 Status
= NtCreateEvent(&SockEvent
,
1005 SynchronizationEvent
,
1008 if( !NT_SUCCESS(Status
) )
1009 return SOCKET_ERROR
;
1011 /* Set Up Listen Structure */
1012 ListenData
.UseSAN
= FALSE
;
1013 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
->UseDelayedAcceptance
;
1014 ListenData
.Backlog
= Backlog
;
1017 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1022 IOCTL_AFD_START_LISTEN
,
1028 /* Wait for return */
1029 if (Status
== STATUS_PENDING
)
1031 WaitForSingleObject(SockEvent
, INFINITE
);
1032 Status
= IOSB
.Status
;
1035 NtClose( SockEvent
);
1037 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1038 if (Status
!= STATUS_SUCCESS
)
1039 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1041 /* Set to Listening */
1042 Socket
->SharedData
->Listening
= TRUE
;
1044 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
1046 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1048 Socket
->TdiAddressHandle
,
1049 Socket
->TdiConnectionHandle
,
1054 if (lpErrno
) *lpErrno
= Status
;
1055 return SOCKET_ERROR
;
1059 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1065 WSPSelect(IN
int nfds
,
1066 IN OUT fd_set
*readfds OPTIONAL
,
1067 IN OUT fd_set
*writefds OPTIONAL
,
1068 IN OUT fd_set
*exceptfds OPTIONAL
,
1069 IN
const struct timeval
*timeout OPTIONAL
,
1072 IO_STATUS_BLOCK IOSB
;
1073 PAFD_POLL_INFO PollInfo
;
1076 ULONG PollBufferSize
;
1080 LARGE_INTEGER Timeout
;
1081 PSOCKET_INFORMATION Socket
;
1086 /* Find out how many sockets we have, and how large the buffer needs
1088 FD_ZERO(&selectfds
);
1089 if (readfds
!= NULL
)
1091 for (i
= 0; i
< readfds
->fd_count
; i
++)
1093 FD_SET(readfds
->fd_array
[i
], &selectfds
);
1096 if (writefds
!= NULL
)
1098 for (i
= 0; i
< writefds
->fd_count
; i
++)
1100 FD_SET(writefds
->fd_array
[i
], &selectfds
);
1103 if (exceptfds
!= NULL
)
1105 for (i
= 0; i
< exceptfds
->fd_count
; i
++)
1107 FD_SET(exceptfds
->fd_array
[i
], &selectfds
);
1111 HandleCount
= selectfds
.fd_count
;
1113 if ( HandleCount
== 0 )
1115 WARN("No handles! Returning SOCKET_ERROR\n", HandleCount
);
1116 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1117 return SOCKET_ERROR
;
1120 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
1122 TRACE("HandleCount: %u BufferSize: %u\n", HandleCount
, PollBufferSize
);
1124 /* Convert Timeout to NT Format */
1125 if (timeout
== NULL
)
1127 Timeout
.u
.LowPart
= -1;
1128 Timeout
.u
.HighPart
= 0x7FFFFFFF;
1129 TRACE("Infinite timeout\n");
1133 Timeout
= RtlEnlargedIntegerMultiply
1134 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
1135 /* Negative timeouts are illegal. Since the kernel represents an
1136 * incremental timeout as a negative number, we check for a positive
1139 if (Timeout
.QuadPart
> 0)
1141 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1142 return SOCKET_ERROR
;
1144 TRACE("Timeout: Orig %d.%06d kernel %d\n",
1145 timeout
->tv_sec
, timeout
->tv_usec
,
1149 Status
= NtCreateEvent(&SockEvent
,
1152 SynchronizationEvent
,
1155 if(!NT_SUCCESS(Status
))
1158 *lpErrno
= WSAEFAULT
;
1160 ERR("NtCreateEvent failed, 0x%08x\n", Status
);
1161 return SOCKET_ERROR
;
1165 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
1170 *lpErrno
= WSAEFAULT
;
1172 return SOCKET_ERROR
;
1175 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
1177 RtlZeroMemory( PollInfo
, PollBufferSize
);
1179 /* Number of handles for AFD to Check */
1180 PollInfo
->Exclusive
= FALSE
;
1181 PollInfo
->Timeout
= Timeout
;
1183 for (i
= 0; i
< selectfds
.fd_count
; i
++)
1185 PollInfo
->Handles
[i
].Handle
= selectfds
.fd_array
[i
];
1187 if (readfds
!= NULL
) {
1188 for (i
= 0; i
< readfds
->fd_count
; i
++)
1190 for (j
= 0; j
< HandleCount
; j
++)
1192 if (PollInfo
->Handles
[j
].Handle
== readfds
->fd_array
[i
])
1195 if (j
>= HandleCount
)
1197 ERR("Error while counting readfds %ld > %ld\n", j
, HandleCount
);
1198 if (lpErrno
) *lpErrno
= WSAEFAULT
;
1199 HeapFree(GlobalHeap
, 0, PollBuffer
);
1201 return SOCKET_ERROR
;
1203 Socket
= GetSocketStructure(readfds
->fd_array
[i
]);
1206 ERR("Invalid socket handle provided in readfds %d\n", readfds
->fd_array
[i
]);
1207 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1208 HeapFree(GlobalHeap
, 0, PollBuffer
);
1210 return SOCKET_ERROR
;
1212 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_RECEIVE
|
1213 AFD_EVENT_DISCONNECT
|
1217 //if (Socket->SharedData->OobInline != 0)
1218 // PollInfo->Handles[j].Events |= AFD_EVENT_OOB_RECEIVE;
1221 if (writefds
!= NULL
)
1223 for (i
= 0; i
< writefds
->fd_count
; i
++)
1225 for (j
= 0; j
< HandleCount
; j
++)
1227 if (PollInfo
->Handles
[j
].Handle
== writefds
->fd_array
[i
])
1230 if (j
>= HandleCount
)
1232 ERR("Error while counting writefds %ld > %ld\n", j
, HandleCount
);
1233 if (lpErrno
) *lpErrno
= WSAEFAULT
;
1234 HeapFree(GlobalHeap
, 0, PollBuffer
);
1236 return SOCKET_ERROR
;
1238 Socket
= GetSocketStructure(writefds
->fd_array
[i
]);
1241 ERR("Invalid socket handle provided in writefds %d\n", writefds
->fd_array
[i
]);
1242 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1243 HeapFree(GlobalHeap
, 0, PollBuffer
);
1245 return SOCKET_ERROR
;
1247 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
1248 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_SEND
;
1249 if (Socket
->SharedData
->NonBlocking
!= 0)
1250 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_CONNECT
;
1253 if (exceptfds
!= NULL
)
1255 for (i
= 0; i
< exceptfds
->fd_count
; i
++)
1257 for (j
= 0; j
< HandleCount
; j
++)
1259 if (PollInfo
->Handles
[j
].Handle
== exceptfds
->fd_array
[i
])
1262 if (j
> HandleCount
)
1264 ERR("Error while counting exceptfds %ld > %ld\n", j
, HandleCount
);
1265 if (lpErrno
) *lpErrno
= WSAEFAULT
;
1266 HeapFree(GlobalHeap
, 0, PollBuffer
);
1268 return SOCKET_ERROR
;
1270 Socket
= GetSocketStructure(exceptfds
->fd_array
[i
]);
1273 TRACE("Invalid socket handle provided in exceptfds %d\n", exceptfds
->fd_array
[i
]);
1274 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1275 HeapFree(GlobalHeap
, 0, PollBuffer
);
1277 return SOCKET_ERROR
;
1279 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
1280 if (Socket
->SharedData
->OobInline
== 0)
1281 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_OOB_RECEIVE
;
1282 if (Socket
->SharedData
->NonBlocking
!= 0)
1283 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_CONNECT_FAIL
;
1287 PollInfo
->HandleCount
= HandleCount
;
1288 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
1291 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
1302 TRACE("DeviceIoControlFile => %x\n", Status
);
1304 /* Wait for Completion */
1305 if (Status
== STATUS_PENDING
)
1307 WaitForSingleObject(SockEvent
, INFINITE
);
1308 Status
= IOSB
.Status
;
1311 /* Clear the Structures */
1319 /* Loop through return structure */
1320 HandleCount
= PollInfo
->HandleCount
;
1322 /* Return in FDSET Format */
1323 for (i
= 0; i
< HandleCount
; i
++)
1325 Events
= PollInfo
->Handles
[i
].Events
;
1326 Handle
= PollInfo
->Handles
[i
].Handle
;
1327 for(x
= 1; x
; x
<<=1)
1329 Socket
= GetSocketStructure(Handle
);
1332 TRACE("Invalid socket handle found %d\n", Handle
);
1333 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1334 HeapFree(GlobalHeap
, 0, PollBuffer
);
1336 return SOCKET_ERROR
;
1340 case AFD_EVENT_RECEIVE
:
1341 case AFD_EVENT_DISCONNECT
:
1342 case AFD_EVENT_ABORT
:
1343 case AFD_EVENT_ACCEPT
:
1344 case AFD_EVENT_CLOSE
:
1345 TRACE("Event %x on handle %x\n",
1348 if ((Events
& x
) == AFD_EVENT_DISCONNECT
|| (Events
& x
) == AFD_EVENT_CLOSE
)
1349 Socket
->SharedData
->SocketLastError
= WSAECONNRESET
;
1350 if ((Events
& x
) == AFD_EVENT_ABORT
)
1351 Socket
->SharedData
->SocketLastError
= WSAECONNABORTED
;
1353 FD_SET(Handle
, readfds
);
1355 case AFD_EVENT_SEND
:
1356 TRACE("Event %x on handle %x\n",
1360 FD_SET(Handle
, writefds
);
1362 case AFD_EVENT_CONNECT
:
1363 TRACE("Event %x on handle %x\n",
1366 if( writefds
&& Socket
->SharedData
->NonBlocking
!= 0 )
1367 FD_SET(Handle
, writefds
);
1369 case AFD_EVENT_OOB_RECEIVE
:
1370 TRACE("Event %x on handle %x\n",
1373 if( readfds
&& Socket
->SharedData
->OobInline
!= 0 )
1374 FD_SET(Handle
, readfds
);
1375 if( exceptfds
&& Socket
->SharedData
->OobInline
== 0 )
1376 FD_SET(Handle
, exceptfds
);
1378 case AFD_EVENT_CONNECT_FAIL
:
1379 TRACE("Event %x on handle %x\n",
1382 if( exceptfds
&& Socket
->SharedData
->NonBlocking
!= 0 )
1383 FD_SET(Handle
, exceptfds
);
1389 HeapFree( GlobalHeap
, 0, PollBuffer
);
1390 NtClose( SockEvent
);
1394 switch( IOSB
.Status
)
1396 case STATUS_SUCCESS
:
1397 case STATUS_TIMEOUT
:
1401 *lpErrno
= WSAEINVAL
;
1404 TRACE("*lpErrno = %x\n", *lpErrno
);
1407 HandleCount
= (readfds
? readfds
->fd_count
: 0) +
1408 (writefds
&& writefds
!= readfds
? writefds
->fd_count
: 0) +
1409 (exceptfds
&& exceptfds
!= readfds
&& exceptfds
!= writefds
? exceptfds
->fd_count
: 0);
1411 TRACE("%d events\n", HandleCount
);
1417 GetCurrentTimeInSeconds(VOID
)
1419 SYSTEMTIME st1970
= { 1970, 1, 0, 1, 0, 0, 0, 0 };
1426 GetSystemTimeAsFileTime(&Time
.ft
);
1427 SystemTimeToFileTime(&st1970
, &u1970
.ft
);
1428 return (DWORD
)((Time
.ll
- u1970
.ll
) / 10000000ULL);
1431 _Must_inspect_result_
1436 _Out_writes_bytes_to_opt_(*addrlen
, *addrlen
) struct sockaddr FAR
*SocketAddress
,
1437 _Inout_opt_ LPINT SocketAddressLength
,
1438 _In_opt_ LPCONDITIONPROC lpfnCondition
,
1439 _In_opt_ DWORD_PTR dwCallbackData
,
1440 _Out_ LPINT lpErrno
)
1442 IO_STATUS_BLOCK IOSB
;
1443 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1444 AFD_ACCEPT_DATA AcceptData
;
1445 AFD_DEFER_ACCEPT_DATA DeferData
;
1446 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1447 PSOCKET_INFORMATION Socket
= NULL
;
1449 struct fd_set ReadSet
;
1450 struct timeval Timeout
;
1451 PVOID PendingData
= NULL
;
1452 ULONG PendingDataLength
= 0;
1453 PVOID CalleeDataBuffer
;
1454 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1455 PSOCKADDR RemoteAddress
= NULL
;
1458 SOCKET AcceptSocket
;
1459 PSOCKET_INFORMATION AcceptSocketInfo
;
1460 UCHAR ReceiveBuffer
[0x1A];
1463 /* Get the Socket Structure associate to this Socket*/
1464 Socket
= GetSocketStructure(Handle
);
1467 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1468 return SOCKET_ERROR
;
1470 if (!Socket
->SharedData
->Listening
)
1472 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1473 return SOCKET_ERROR
;
1475 if ((SocketAddress
&& !SocketAddressLength
) ||
1476 (SocketAddressLength
&& !SocketAddress
) ||
1477 (SocketAddressLength
&& *SocketAddressLength
< sizeof(SOCKADDR
)))
1479 if (lpErrno
) *lpErrno
= WSAEFAULT
;
1480 return INVALID_SOCKET
;
1483 Status
= NtCreateEvent(&SockEvent
,
1486 SynchronizationEvent
,
1489 if( !NT_SUCCESS(Status
) )
1491 return SOCKET_ERROR
;
1494 /* Dynamic Structure...ugh */
1495 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1497 /* If this is non-blocking, make sure there's something for us to accept */
1499 FD_SET(Socket
->Handle
, &ReadSet
);
1503 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1506 return SOCKET_ERROR
;
1509 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1512 if (lpErrno
) *lpErrno
= WSAEWOULDBLOCK
;
1513 return SOCKET_ERROR
;
1517 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1522 IOCTL_AFD_WAIT_FOR_LISTEN
,
1526 0xA + sizeof(*ListenReceiveData
));
1528 /* Wait for return */
1529 if (Status
== STATUS_PENDING
)
1531 WaitForSingleObject(SockEvent
, INFINITE
);
1532 Status
= IOSB
.Status
;
1535 if (!NT_SUCCESS(Status
))
1537 NtClose( SockEvent
);
1538 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1541 if (lpfnCondition
!= NULL
)
1543 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1545 /* Find out how much data is pending */
1546 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1547 PendingAcceptData
.ReturnSize
= TRUE
;
1550 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1555 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1557 sizeof(PendingAcceptData
),
1559 sizeof(PendingAcceptData
));
1561 /* Wait for return */
1562 if (Status
== STATUS_PENDING
)
1564 WaitForSingleObject(SockEvent
, INFINITE
);
1565 Status
= IOSB
.Status
;
1568 if (!NT_SUCCESS(Status
))
1570 NtClose( SockEvent
);
1571 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1574 /* How much data to allocate */
1575 PendingDataLength
= IOSB
.Information
;
1577 if (PendingDataLength
)
1579 /* Allocate needed space */
1580 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1583 return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1586 /* We want the data now */
1587 PendingAcceptData
.ReturnSize
= FALSE
;
1590 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1595 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1597 sizeof(PendingAcceptData
),
1601 /* Wait for return */
1602 if (Status
== STATUS_PENDING
)
1604 WaitForSingleObject(SockEvent
, INFINITE
);
1605 Status
= IOSB
.Status
;
1608 if (!NT_SUCCESS(Status
))
1610 NtClose( SockEvent
);
1611 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1616 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1618 /* I don't support this yet */
1621 /* Build Callee ID */
1622 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1623 CalleeID
.len
= Socket
->SharedData
->SizeOfLocalAddress
;
1625 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1628 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1631 /* Set up Address in SOCKADDR Format */
1632 RtlCopyMemory (RemoteAddress
,
1633 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1634 sizeof(*RemoteAddress
));
1636 /* Build Caller ID */
1637 CallerID
.buf
= (PVOID
)RemoteAddress
;
1638 CallerID
.len
= sizeof(*RemoteAddress
);
1640 /* Build Caller Data */
1641 CallerData
.buf
= PendingData
;
1642 CallerData
.len
= PendingDataLength
;
1644 /* Check if socket supports Conditional Accept */
1645 if (Socket
->SharedData
->UseDelayedAcceptance
!= 0)
1647 /* Allocate Buffer for Callee Data */
1648 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1649 if (!CalleeDataBuffer
) {
1650 return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1652 CalleeData
.buf
= CalleeDataBuffer
;
1653 CalleeData
.len
= 4096;
1662 /* Call the Condition Function */
1663 CallBack
= (lpfnCondition
)(&CallerID
,
1664 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1668 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1672 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1674 /* TBD: Check for Validity */
1677 if (CallBack
== CF_ACCEPT
)
1679 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1681 /* I don't support this yet */
1685 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1690 /* Callback rejected. Build Defer Structure */
1691 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1692 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1695 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1700 IOCTL_AFD_DEFER_ACCEPT
,
1706 /* Wait for return */
1707 if (Status
== STATUS_PENDING
)
1709 WaitForSingleObject(SockEvent
, INFINITE
);
1710 Status
= IOSB
.Status
;
1713 NtClose( SockEvent
);
1715 if (!NT_SUCCESS(Status
))
1717 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1720 if (CallBack
== CF_REJECT
)
1722 if (lpErrno
) *lpErrno
= WSAECONNREFUSED
;
1723 return SOCKET_ERROR
;
1727 if (lpErrno
) *lpErrno
= WSAECONNREFUSED
;
1728 return SOCKET_ERROR
;
1733 /* Create a new Socket */
1734 AcceptSocket
= WSPSocket (Socket
->SharedData
->AddressFamily
,
1735 Socket
->SharedData
->SocketType
,
1736 Socket
->SharedData
->Protocol
,
1737 &Socket
->ProtocolInfo
,
1739 Socket
->SharedData
->CreateFlags
,
1741 if (AcceptSocket
== INVALID_SOCKET
)
1742 return SOCKET_ERROR
;
1744 /* Set up the Accept Structure */
1745 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1746 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1748 /* Send IOCTL to Accept */
1749 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1760 /* Wait for return */
1761 if (Status
== STATUS_PENDING
)
1763 WaitForSingleObject(SockEvent
, INFINITE
);
1764 Status
= IOSB
.Status
;
1767 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1768 if (!NT_SUCCESS(Status
))
1771 WSPCloseSocket( AcceptSocket
, lpErrno
);
1772 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1775 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1776 if (!AcceptSocketInfo
)
1779 WSPCloseSocket( AcceptSocket
, lpErrno
);
1780 return MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED
, lpErrno
, 0, NULL
);
1783 AcceptSocketInfo
->SharedData
->State
= SocketConnected
;
1784 AcceptSocketInfo
->SharedData
->ConnectTime
= GetCurrentTimeInSeconds();
1786 /* Return Address in SOCKADDR FORMAT */
1789 RtlCopyMemory (SocketAddress
,
1790 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1791 sizeof(*RemoteAddress
));
1792 if( SocketAddressLength
)
1793 *SocketAddressLength
= sizeof(*RemoteAddress
);
1796 NtClose( SockEvent
);
1798 /* Re-enable Async Event */
1799 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1801 TRACE("Socket %x\n", AcceptSocket
);
1803 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1805 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1807 Socket
->TdiAddressHandle
,
1808 Socket
->TdiConnectionHandle
,
1813 if (lpErrno
) *lpErrno
= Status
;
1814 return SOCKET_ERROR
;
1818 if (lpErrno
) *lpErrno
= NO_ERROR
;
1821 return AcceptSocket
;
1826 WSPConnect(SOCKET Handle
,
1827 const struct sockaddr
* SocketAddress
,
1828 int SocketAddressLength
,
1829 LPWSABUF lpCallerData
,
1830 LPWSABUF lpCalleeData
,
1835 IO_STATUS_BLOCK IOSB
;
1836 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1837 PSOCKET_INFORMATION Socket
;
1840 ULONG ConnectDataLength
;
1841 ULONG InConnectDataLength
;
1842 INT BindAddressLength
;
1843 PSOCKADDR BindAddress
;
1845 int SocketDataLength
;
1847 TRACE("Called (%lx) %lx:%d\n", Handle
, ((const struct sockaddr_in
*)SocketAddress
)->sin_addr
, ((const struct sockaddr_in
*)SocketAddress
)->sin_port
);
1849 /* Get the Socket Structure associate to this Socket*/
1850 Socket
= GetSocketStructure(Handle
);
1853 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1854 return SOCKET_ERROR
;
1857 Status
= NtCreateEvent(&SockEvent
,
1860 SynchronizationEvent
,
1863 if (!NT_SUCCESS(Status
))
1864 return SOCKET_ERROR
;
1867 if (Socket
->SharedData
->State
== SocketOpen
)
1869 /* Get the Wildcard Address */
1870 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1871 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1875 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1877 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1879 &BindAddressLength
);
1881 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1882 return SOCKET_ERROR
;
1885 /* Set the Connect Data */
1886 if (lpCallerData
!= NULL
)
1888 ConnectDataLength
= lpCallerData
->len
;
1889 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1894 IOCTL_AFD_SET_CONNECT_DATA
,
1899 /* Wait for return */
1900 if (Status
== STATUS_PENDING
)
1902 WaitForSingleObject(SockEvent
, INFINITE
);
1903 Status
= IOSB
.Status
;
1906 if (Status
!= STATUS_SUCCESS
)
1910 /* Calculate the size of SocketAddress->sa_data */
1911 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1913 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1914 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1915 FIELD_OFFSET(AFD_CONNECT_INFO
,
1916 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1919 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1923 /* Set up Address in TDI Format */
1924 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1925 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1926 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1927 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1928 SocketAddress
->sa_data
,
1932 * Disable FD_WRITE and FD_CONNECT
1933 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1934 * at the end of this function right after the Async Thread disables it.
1935 * This should only happen at the *next* WSPConnect
1937 if (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
)
1939 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1942 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1943 if (lpCalleeData
!= NULL
)
1945 InConnectDataLength
= lpCalleeData
->len
;
1946 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1951 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1952 &InConnectDataLength
,
1953 sizeof(InConnectDataLength
),
1957 /* Wait for return */
1958 if (Status
== STATUS_PENDING
)
1960 WaitForSingleObject(SockEvent
, INFINITE
);
1961 Status
= IOSB
.Status
;
1964 if (Status
!= STATUS_SUCCESS
)
1968 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1969 ConnectInfo
->Root
= 0;
1970 ConnectInfo
->UseSAN
= FALSE
;
1971 ConnectInfo
->Unknown
= 0;
1973 /* FIXME: Handle Async Connect */
1974 if (Socket
->SharedData
->NonBlocking
)
1976 ERR("Async Connect UNIMPLEMENTED!\n");
1980 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1990 /* Wait for return */
1991 if (Status
== STATUS_PENDING
)
1993 WaitForSingleObject(SockEvent
, INFINITE
);
1994 Status
= IOSB
.Status
;
1997 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1998 if (Status
!= STATUS_SUCCESS
)
2001 Socket
->SharedData
->State
= SocketConnected
;
2002 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
2003 Socket
->SharedData
->ConnectTime
= GetCurrentTimeInSeconds();
2005 /* Get any pending connect data */
2006 if (lpCalleeData
!= NULL
)
2008 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
2013 IOCTL_AFD_GET_CONNECT_DATA
,
2018 /* Wait for return */
2019 if (Status
== STATUS_PENDING
)
2021 WaitForSingleObject(SockEvent
, INFINITE
);
2022 Status
= IOSB
.Status
;
2026 TRACE("Ending %lx\n", IOSB
.Status
);
2029 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
2031 /* Re-enable Async Event */
2032 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
2034 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2035 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
2039 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
2041 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
2043 Socket
->TdiAddressHandle
,
2044 Socket
->TdiConnectionHandle
,
2045 WSH_NOTIFY_CONNECT
);
2049 if (lpErrno
) *lpErrno
= Errno
;
2050 return SOCKET_ERROR
;
2053 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
2055 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
2057 Socket
->TdiAddressHandle
,
2058 Socket
->TdiConnectionHandle
,
2059 WSH_NOTIFY_CONNECT_ERROR
);
2063 if (lpErrno
) *lpErrno
= Errno
;
2064 return SOCKET_ERROR
;
2068 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
2072 WSPShutdown(SOCKET Handle
,
2077 IO_STATUS_BLOCK IOSB
;
2078 AFD_DISCONNECT_INFO DisconnectInfo
;
2079 PSOCKET_INFORMATION Socket
= NULL
;
2085 /* Get the Socket Structure associate to this Socket*/
2086 Socket
= GetSocketStructure(Handle
);
2089 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2090 return SOCKET_ERROR
;
2093 Status
= NtCreateEvent(&SockEvent
,
2096 SynchronizationEvent
,
2099 if( !NT_SUCCESS(Status
) )
2100 return SOCKET_ERROR
;
2102 /* Set AFD Disconnect Type */
2106 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
2107 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
2110 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
2111 Socket
->SharedData
->SendShutdown
= TRUE
;
2114 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
2115 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
2116 Socket
->SharedData
->SendShutdown
= TRUE
;
2120 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
2123 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
2128 IOCTL_AFD_DISCONNECT
,
2130 sizeof(DisconnectInfo
),
2134 /* Wait for return */
2135 if (Status
== STATUS_PENDING
)
2137 WaitForSingleObject(SockEvent
, INFINITE
);
2138 Status
= IOSB
.Status
;
2143 NtClose( SockEvent
);
2145 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
2146 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
2152 WSPGetSockName(IN SOCKET Handle
,
2153 OUT LPSOCKADDR Name
,
2154 IN OUT LPINT NameLength
,
2157 IO_STATUS_BLOCK IOSB
;
2158 ULONG TdiAddressSize
;
2159 PTDI_ADDRESS_INFO TdiAddress
;
2160 PTRANSPORT_ADDRESS SocketAddress
;
2161 PSOCKET_INFORMATION Socket
= NULL
;
2165 /* Get the Socket Structure associate to this Socket*/
2166 Socket
= GetSocketStructure(Handle
);
2169 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2170 return SOCKET_ERROR
;
2173 if (!Name
|| !NameLength
)
2175 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2176 return SOCKET_ERROR
;
2179 Status
= NtCreateEvent(&SockEvent
,
2182 SynchronizationEvent
,
2185 if( !NT_SUCCESS(Status
) )
2186 return SOCKET_ERROR
;
2188 /* Allocate a buffer for the address */
2190 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfLocalAddress
;
2191 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2193 if ( TdiAddress
== NULL
)
2195 NtClose( SockEvent
);
2196 if (lpErrno
) *lpErrno
= WSAENOBUFS
;
2197 return SOCKET_ERROR
;
2200 SocketAddress
= &TdiAddress
->Address
;
2203 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2208 IOCTL_AFD_GET_SOCK_NAME
,
2214 /* Wait for return */
2215 if (Status
== STATUS_PENDING
)
2217 WaitForSingleObject(SockEvent
, INFINITE
);
2218 Status
= IOSB
.Status
;
2221 NtClose( SockEvent
);
2223 if (NT_SUCCESS(Status
))
2225 if (*NameLength
>= Socket
->SharedData
->SizeOfLocalAddress
)
2227 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2228 RtlCopyMemory (Name
->sa_data
,
2229 SocketAddress
->Address
[0].Address
,
2230 SocketAddress
->Address
[0].AddressLength
);
2231 *NameLength
= Socket
->SharedData
->SizeOfLocalAddress
;
2232 TRACE("NameLength %d Address: %x Port %x\n",
2233 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2234 ((struct sockaddr_in
*)Name
)->sin_port
);
2235 HeapFree(GlobalHeap
, 0, TdiAddress
);
2240 HeapFree(GlobalHeap
, 0, TdiAddress
);
2241 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2242 return SOCKET_ERROR
;
2246 HeapFree(GlobalHeap
, 0, TdiAddress
);
2248 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2254 WSPGetPeerName(IN SOCKET s
,
2255 OUT LPSOCKADDR Name
,
2256 IN OUT LPINT NameLength
,
2259 IO_STATUS_BLOCK IOSB
;
2260 ULONG TdiAddressSize
;
2261 PTRANSPORT_ADDRESS SocketAddress
;
2262 PSOCKET_INFORMATION Socket
= NULL
;
2266 /* Get the Socket Structure associate to this Socket*/
2267 Socket
= GetSocketStructure(s
);
2270 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2271 return SOCKET_ERROR
;
2274 if (Socket
->SharedData
->State
!= SocketConnected
)
2276 if (lpErrno
) *lpErrno
= WSAENOTCONN
;
2277 return SOCKET_ERROR
;
2280 if (!Name
|| !NameLength
)
2282 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2283 return SOCKET_ERROR
;
2286 Status
= NtCreateEvent(&SockEvent
,
2289 SynchronizationEvent
,
2292 if( !NT_SUCCESS(Status
) )
2293 return SOCKET_ERROR
;
2295 /* Allocate a buffer for the address */
2296 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfRemoteAddress
;
2297 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2299 if ( SocketAddress
== NULL
)
2301 NtClose( SockEvent
);
2302 if (lpErrno
) *lpErrno
= WSAENOBUFS
;
2303 return SOCKET_ERROR
;
2307 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2312 IOCTL_AFD_GET_PEER_NAME
,
2318 /* Wait for return */
2319 if (Status
== STATUS_PENDING
)
2321 WaitForSingleObject(SockEvent
, INFINITE
);
2322 Status
= IOSB
.Status
;
2325 NtClose( SockEvent
);
2327 if (NT_SUCCESS(Status
))
2329 if (*NameLength
>= Socket
->SharedData
->SizeOfRemoteAddress
)
2331 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2332 RtlCopyMemory (Name
->sa_data
,
2333 SocketAddress
->Address
[0].Address
,
2334 SocketAddress
->Address
[0].AddressLength
);
2335 *NameLength
= Socket
->SharedData
->SizeOfRemoteAddress
;
2336 TRACE("NameLength %d Address: %x Port %x\n",
2337 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2338 ((struct sockaddr_in
*)Name
)->sin_port
);
2339 HeapFree(GlobalHeap
, 0, SocketAddress
);
2344 HeapFree(GlobalHeap
, 0, SocketAddress
);
2345 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2346 return SOCKET_ERROR
;
2350 HeapFree(GlobalHeap
, 0, SocketAddress
);
2352 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2357 WSPIoctl(IN SOCKET Handle
,
2358 IN DWORD dwIoControlCode
,
2359 IN LPVOID lpvInBuffer
,
2360 IN DWORD cbInBuffer
,
2361 OUT LPVOID lpvOutBuffer
,
2362 IN DWORD cbOutBuffer
,
2363 OUT LPDWORD lpcbBytesReturned
,
2364 IN LPWSAOVERLAPPED lpOverlapped
,
2365 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
2366 IN LPWSATHREADID lpThreadId
,
2369 PSOCKET_INFORMATION Socket
= NULL
;
2370 BOOL NeedsCompletion
= lpOverlapped
!= NULL
;
2371 BOOLEAN NonBlocking
;
2372 INT Errno
= NO_ERROR
, Ret
= SOCKET_ERROR
;
2375 /* Get the Socket Structure associate to this Socket*/
2376 Socket
= GetSocketStructure(Handle
);
2380 *lpErrno
= WSAENOTSOCK
;
2381 return SOCKET_ERROR
;
2384 if (!lpcbBytesReturned
&& !lpOverlapped
)
2387 *lpErrno
= WSAEFAULT
;
2388 return SOCKET_ERROR
;
2391 switch( dwIoControlCode
)
2394 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2399 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2400 /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
2403 /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
2404 if (Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
))
2409 /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
2410 if (Socket
->NetworkEvents
)
2416 Socket
->SharedData
->NonBlocking
= NonBlocking
? 1 : 0;
2417 NeedsCompletion
= FALSE
;
2418 Errno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2419 if (Errno
== NO_ERROR
)
2423 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2425 cbRet
= sizeof(ULONG
);
2429 if (cbOutBuffer
< sizeof(ULONG
))
2434 NeedsCompletion
= FALSE
;
2435 Errno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2436 if (Errno
== NO_ERROR
)
2438 cbRet
= sizeof(ULONG
);
2443 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2445 cbRet
= sizeof(BOOL
);
2449 if (cbOutBuffer
< sizeof(BOOL
))
2454 if (Socket
->SharedData
->SocketType
!= SOCK_STREAM
)
2460 /* FIXME: Return false if OOBINLINE is true for now
2461 We should MSG_PEEK|MSG_OOB check with driver
2463 *(BOOL
*)lpvOutBuffer
= !Socket
->SharedData
->OobInline
;
2465 cbRet
= sizeof(BOOL
);
2469 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2470 if (cbOutBuffer
== 0)
2472 cbRet
= sizeof(PVOID
);
2477 if (cbInBuffer
< sizeof(GUID
) ||
2478 cbOutBuffer
< sizeof(PVOID
))
2485 GUID AcceptExGUID
= WSAID_ACCEPTEX
;
2486 GUID ConnectExGUID
= WSAID_CONNECTEX
;
2487 GUID DisconnectExGUID
= WSAID_DISCONNECTEX
;
2488 GUID GetAcceptExSockaddrsGUID
= WSAID_GETACCEPTEXSOCKADDRS
;
2490 if (IsEqualGUID(&AcceptExGUID
, lpvInBuffer
))
2492 *((PVOID
*)lpvOutBuffer
) = WSPAcceptEx
;
2493 cbRet
= sizeof(PVOID
);
2497 else if (IsEqualGUID(&ConnectExGUID
, lpvInBuffer
))
2499 *((PVOID
*)lpvOutBuffer
) = WSPConnectEx
;
2500 cbRet
= sizeof(PVOID
);
2504 else if (IsEqualGUID(&DisconnectExGUID
, lpvInBuffer
))
2506 *((PVOID
*)lpvOutBuffer
) = WSPDisconnectEx
;
2507 cbRet
= sizeof(PVOID
);
2511 else if (IsEqualGUID(&GetAcceptExSockaddrsGUID
, lpvInBuffer
))
2513 *((PVOID
*)lpvOutBuffer
) = WSPGetAcceptExSockaddrs
;
2514 cbRet
= sizeof(PVOID
);
2520 ERR("Querying unknown extension function: %x\n", ((GUID
*)lpvInBuffer
)->Data1
);
2521 Errno
= WSAEOPNOTSUPP
;
2526 case SIO_ADDRESS_LIST_QUERY
:
2527 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2529 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2533 if (cbOutBuffer
< sizeof(INT
))
2539 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2541 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->iAddressCount
= 1;
2543 if (cbOutBuffer
< (sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
)))
2549 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].iSockaddrLength
= sizeof(Socket
->SharedData
->WSLocalAddress
);
2550 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].lpSockaddr
= &Socket
->SharedData
->WSLocalAddress
;
2556 Errno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2558 Socket
->TdiAddressHandle
,
2559 Socket
->TdiConnectionHandle
,
2567 lpCompletionRoutine
,
2570 if (Errno
== NO_ERROR
)
2574 if (lpOverlapped
&& NeedsCompletion
)
2576 lpOverlapped
->Internal
= Errno
;
2577 lpOverlapped
->InternalHigh
= cbRet
;
2578 if (lpCompletionRoutine
!= NULL
)
2580 lpCompletionRoutine(Errno
, cbRet
, lpOverlapped
, 0);
2582 if (lpOverlapped
->hEvent
)
2583 SetEvent(lpOverlapped
->hEvent
);
2584 if (!PostQueuedCompletionStatus((HANDLE
)Handle
, cbRet
, 0, lpOverlapped
))
2586 ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
2592 if (lpcbBytesReturned
)
2593 *lpcbBytesReturned
= cbRet
;
2600 WSPGetSockOpt(IN SOCKET Handle
,
2603 OUT CHAR FAR
* OptionValue
,
2604 IN OUT LPINT OptionLength
,
2607 PSOCKET_INFORMATION Socket
= NULL
;
2616 /* Get the Socket Structure associate to this Socket*/
2617 Socket
= GetSocketStructure(Handle
);
2620 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2621 return SOCKET_ERROR
;
2623 if (!OptionLength
|| !OptionValue
)
2625 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2626 return SOCKET_ERROR
;
2635 Buffer
= &Socket
->SharedData
->SocketType
;
2636 BufferSize
= sizeof(INT
);
2640 Buffer
= &Socket
->SharedData
->SizeOfRecvBuffer
;
2641 BufferSize
= sizeof(ULONG
);
2645 Buffer
= &Socket
->SharedData
->SizeOfSendBuffer
;
2646 BufferSize
= sizeof(ULONG
);
2650 BoolBuffer
= Socket
->SharedData
->Listening
;
2651 Buffer
= &BoolBuffer
;
2652 BufferSize
= sizeof(BOOL
);
2656 BoolBuffer
= Socket
->SharedData
->Broadcast
;
2657 Buffer
= &BoolBuffer
;
2658 BufferSize
= sizeof(BOOL
);
2662 BoolBuffer
= Socket
->SharedData
->Debug
;
2663 Buffer
= &BoolBuffer
;
2664 BufferSize
= sizeof(BOOL
);
2668 BoolBuffer
= (Socket
->SharedData
->LingerData
.l_onoff
== 0);
2669 Buffer
= &BoolBuffer
;
2670 BufferSize
= sizeof(BOOL
);
2674 if (Socket
->SharedData
->SocketType
== SOCK_DGRAM
)
2676 if (lpErrno
) *lpErrno
= WSAENOPROTOOPT
;
2677 return SOCKET_ERROR
;
2679 Buffer
= &Socket
->SharedData
->LingerData
;
2680 BufferSize
= sizeof(struct linger
);
2684 BoolBuffer
= (Socket
->SharedData
->OobInline
!= 0);
2685 Buffer
= &BoolBuffer
;
2686 BufferSize
= sizeof(BOOL
);
2691 /* These guys go directly to the helper */
2694 case SO_CONDITIONAL_ACCEPT
:
2695 BoolBuffer
= (Socket
->SharedData
->UseDelayedAcceptance
!= 0);
2696 Buffer
= &BoolBuffer
;
2697 BufferSize
= sizeof(BOOL
);
2701 BoolBuffer
= (Socket
->SharedData
->ReuseAddresses
!= 0);
2702 Buffer
= &BoolBuffer
;
2703 BufferSize
= sizeof(BOOL
);
2706 case SO_EXCLUSIVEADDRUSE
:
2707 BoolBuffer
= (Socket
->SharedData
->ExclusiveAddressUse
!= 0);
2708 Buffer
= &BoolBuffer
;
2709 BufferSize
= sizeof(BOOL
);
2713 Buffer
= &Socket
->SharedData
->SocketLastError
;
2714 BufferSize
= sizeof(INT
);
2717 case SO_CONNECT_TIME
:
2718 DwordBuffer
= GetCurrentTimeInSeconds() - Socket
->SharedData
->ConnectTime
;
2719 Buffer
= &DwordBuffer
;
2720 BufferSize
= sizeof(DWORD
);
2724 Buffer
= &Socket
->SharedData
->SendTimeout
;
2725 BufferSize
= sizeof(DWORD
);
2728 Buffer
= &Socket
->SharedData
->RecvTimeout
;
2729 BufferSize
= sizeof(DWORD
);
2731 case SO_PROTOCOL_INFOW
:
2732 Buffer
= &Socket
->ProtocolInfo
;
2733 BufferSize
= sizeof(Socket
->ProtocolInfo
);
2737 case SO_GROUP_PRIORITY
:
2738 case SO_MAX_MSG_SIZE
:
2741 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2742 if (lpErrno
) *lpErrno
= WSAENOPROTOOPT
;
2743 return SOCKET_ERROR
;
2746 if (*OptionLength
< BufferSize
)
2748 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2749 *OptionLength
= BufferSize
;
2750 return SOCKET_ERROR
;
2752 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2757 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2758 return SOCKET_ERROR
;
2762 Errno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2764 Socket
->TdiAddressHandle
,
2765 Socket
->TdiConnectionHandle
,
2769 (LPINT
)OptionLength
);
2770 if (lpErrno
) *lpErrno
= Errno
;
2771 return (Errno
== NO_ERROR
) ? NO_ERROR
: SOCKET_ERROR
;
2780 IN CONST CHAR FAR
* optval
,
2784 PSOCKET_INFORMATION Socket
;
2787 /* Get the Socket Structure associate to this Socket*/
2788 Socket
= GetSocketStructure(s
);
2791 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2792 return SOCKET_ERROR
;
2796 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2797 return SOCKET_ERROR
;
2801 /* FIXME: We should handle some more cases here */
2802 if (level
== SOL_SOCKET
)
2807 if (optlen
< sizeof(BOOL
))
2809 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2810 return SOCKET_ERROR
;
2812 Socket
->SharedData
->Broadcast
= (*optval
!= 0) ? 1 : 0;
2816 if (optlen
< sizeof(BOOL
))
2818 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2819 return SOCKET_ERROR
;
2821 Socket
->SharedData
->OobInline
= (*optval
!= 0) ? 1 : 0;
2825 if (optlen
< sizeof(BOOL
))
2827 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2828 return SOCKET_ERROR
;
2830 Socket
->SharedData
->LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2834 if (optlen
< sizeof(BOOL
))
2836 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2837 return SOCKET_ERROR
;
2839 Socket
->SharedData
->ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2842 case SO_EXCLUSIVEADDRUSE
:
2843 if (optlen
< sizeof(BOOL
))
2845 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2846 return SOCKET_ERROR
;
2848 Socket
->SharedData
->ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2852 if (optlen
< sizeof(struct linger
))
2854 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2855 return SOCKET_ERROR
;
2857 RtlCopyMemory(&Socket
->SharedData
->LingerData
,
2859 sizeof(struct linger
));
2863 if (optlen
< sizeof(ULONG
))
2865 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2866 return SOCKET_ERROR
;
2869 SetSocketInformation(Socket
,
2870 AFD_INFO_SEND_WINDOW_SIZE
,
2876 GetSocketInformation(Socket
,
2877 AFD_INFO_SEND_WINDOW_SIZE
,
2879 &Socket
->SharedData
->SizeOfSendBuffer
,
2887 if (optlen
< sizeof(ULONG
))
2889 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2890 return SOCKET_ERROR
;
2893 SetSocketInformation(Socket
,
2894 AFD_INFO_RECEIVE_WINDOW_SIZE
,
2900 GetSocketInformation(Socket
,
2901 AFD_INFO_RECEIVE_WINDOW_SIZE
,
2903 &Socket
->SharedData
->SizeOfRecvBuffer
,
2911 if (optlen
< sizeof(INT
))
2913 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2914 return SOCKET_ERROR
;
2917 RtlCopyMemory(&Socket
->SharedData
->SocketLastError
,
2923 if (optlen
< sizeof(DWORD
))
2925 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2926 return SOCKET_ERROR
;
2929 RtlCopyMemory(&Socket
->SharedData
->SendTimeout
,
2935 if (optlen
< sizeof(DWORD
))
2937 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2938 return SOCKET_ERROR
;
2941 RtlCopyMemory(&Socket
->SharedData
->RecvTimeout
,
2948 /* These go directly to the helper dll */
2952 /* Obviously this is a hack */
2953 ERR("MSAFD: Set unknown optname %x\n", optname
);
2959 Errno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2961 Socket
->TdiAddressHandle
,
2962 Socket
->TdiConnectionHandle
,
2967 if (lpErrno
) *lpErrno
= Errno
;
2968 return (Errno
== NO_ERROR
) ? NO_ERROR
: SOCKET_ERROR
;
2972 * FUNCTION: Initialize service provider for a client
2974 * wVersionRequested = Highest WinSock SPI version that the caller can use
2975 * lpWSPData = Address of WSPDATA structure to initialize
2976 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2977 * UpcallTable = Pointer to upcall table of the WinSock DLL
2978 * lpProcTable = Address of procedure table to initialize
2980 * Status of operation
2982 _Must_inspect_result_
2986 _In_ WORD wVersionRequested
,
2987 _In_ LPWSPDATA lpWSPData
,
2988 _In_ LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2989 _In_ WSPUPCALLTABLE UpcallTable
,
2990 _Out_ LPWSPPROC_TABLE lpProcTable
)
2994 if (((LOBYTE(wVersionRequested
) == 2) && (HIBYTE(wVersionRequested
) < 2)) ||
2995 (LOBYTE(wVersionRequested
) < 2))
2997 ERR("WSPStartup NOT SUPPORTED for version 0x%X\n", wVersionRequested
);
2998 return WSAVERNOTSUPPORTED
;
3002 /* FIXME: Enable all cases of WSPStartup status */
3003 Upcalls
= UpcallTable
;
3005 if (Status
== NO_ERROR
)
3007 lpProcTable
->lpWSPAccept
= WSPAccept
;
3008 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
3009 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
3010 lpProcTable
->lpWSPBind
= WSPBind
;
3011 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
3012 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
3013 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
3014 lpProcTable
->lpWSPConnect
= WSPConnect
;
3015 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
3016 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
3017 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
3018 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
3019 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
3020 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
3021 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
3022 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
3023 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
3024 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
3025 lpProcTable
->lpWSPListen
= WSPListen
;
3026 lpProcTable
->lpWSPRecv
= WSPRecv
;
3027 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
3028 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
3029 lpProcTable
->lpWSPSelect
= WSPSelect
;
3030 lpProcTable
->lpWSPSend
= WSPSend
;
3031 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
3032 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
3033 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
3034 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
3035 lpProcTable
->lpWSPSocket
= WSPSocket
;
3036 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
3037 lpWSPData
->wVersion
= MAKEWORD(2, 2);
3038 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
3039 /* Save CatalogEntryId for all upcalls */
3040 CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
3043 TRACE("Status (%d).\n", Status
);
3050 WSPAddressToString(IN LPSOCKADDR lpsaAddress
,
3051 IN DWORD dwAddressLength
,
3052 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
3053 OUT LPWSTR lpszAddressString
,
3054 IN OUT LPDWORD lpdwAddressStringLength
,
3058 WCHAR buffer
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3061 if (!lpsaAddress
|| !lpszAddressString
|| !lpdwAddressStringLength
)
3063 if (lpErrno
) *lpErrno
= WSAEFAULT
;
3064 return SOCKET_ERROR
;
3067 switch (lpsaAddress
->sa_family
)
3070 if (dwAddressLength
< sizeof(SOCKADDR_IN
))
3072 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3073 return SOCKET_ERROR
;
3077 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 24 & 0xff),
3078 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 16 & 0xff),
3079 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 8 & 0xff),
3080 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) & 0xff),
3081 ntohs(((SOCKADDR_IN
*)lpsaAddress
)->sin_port
));
3083 p
= wcschr(buffer
, L
':');
3084 if (!((SOCKADDR_IN
*)lpsaAddress
)->sin_port
)
3090 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3091 return SOCKET_ERROR
;
3094 size
= wcslen(buffer
) + 1;
3096 if (*lpdwAddressStringLength
< size
)
3098 *lpdwAddressStringLength
= size
;
3099 if (lpErrno
) *lpErrno
= WSAEFAULT
;
3100 return SOCKET_ERROR
;
3103 *lpdwAddressStringLength
= size
;
3104 wcscpy(lpszAddressString
, buffer
);
3110 WSPStringToAddress(IN LPWSTR AddressString
,
3111 IN INT AddressFamily
,
3112 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
3113 OUT LPSOCKADDR lpAddress
,
3114 IN OUT LPINT lpAddressLength
,
3119 LONG inetaddr
= 0, ip_part
;
3121 SOCKADDR_IN
*sockaddr
;
3123 if (!lpAddressLength
|| !lpAddress
|| !AddressString
)
3125 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3126 return SOCKET_ERROR
;
3129 sockaddr
= (SOCKADDR_IN
*)lpAddress
;
3131 /* Set right address family */
3132 if (lpProtocolInfo
!= NULL
)
3134 sockaddr
->sin_family
= lpProtocolInfo
->iAddressFamily
;
3138 sockaddr
->sin_family
= AddressFamily
;
3142 if (AddressFamily
== AF_INET
)
3144 if (*lpAddressLength
< (INT
)sizeof(SOCKADDR_IN
))
3146 if (lpErrno
) *lpErrno
= WSAEFAULT
;
3150 // translate ip string to ip
3153 bp
= &AddressString
;
3156 while (*bp
< &AddressString
[wcslen(AddressString
)])
3158 ip_part
= wcstol(*bp
, bp
, 10);
3159 /* ip part number should be in range 0-255 */
3160 if (ip_part
< 0 || ip_part
> 255)
3162 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3163 return SOCKET_ERROR
;
3165 inetaddr
= (inetaddr
<< 8) + ip_part
;
3166 /* we end on string end or port separator */
3167 if ((*bp
)[0] == 0 || (*bp
)[0] == L
':')
3169 /* ip parts are dot separated. verify it */
3170 if ((*bp
)[0] != L
'.')
3172 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3173 return SOCKET_ERROR
;
3175 /* count the dots */
3177 /* move over the dot to next ip part */
3181 /* check dots count */
3184 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3185 return SOCKET_ERROR
;
3188 /* Get port number */
3189 if ((*bp
)[0] == L
':')
3191 /* move over the column to port part */
3193 /* next char should be numeric */
3194 if ((*bp
)[0] < L
'0' || (*bp
)[0] > L
'9')
3196 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3197 return SOCKET_ERROR
;
3199 port
= wcstol(*bp
, bp
, 10);
3206 if (lpErrno
) *lpErrno
= NO_ERROR
;
3207 /* rest sockaddr.sin_addr.s_addr
3208 for we need to be sure it is zero when we come to while */
3209 *lpAddressLength
= sizeof(*sockaddr
);
3210 memset(lpAddress
, 0, sizeof(*sockaddr
));
3211 sockaddr
->sin_family
= AF_INET
;
3212 sockaddr
->sin_addr
.s_addr
= inetaddr
;
3213 sockaddr
->sin_port
= port
;
3217 if (lpErrno
&& !*lpErrno
)
3222 return SOCKET_ERROR
;
3226 * FUNCTION: Cleans up service provider for a client
3228 * lpErrno = Address of buffer for error information
3230 * 0 if successful, or SOCKET_ERROR if not
3234 WSPCleanup(OUT LPINT lpErrno
)
3237 TRACE("Leaving.\n");
3239 if (lpErrno
) *lpErrno
= NO_ERROR
;
3246 AfdInfoAPC(PVOID ApcContext
,
3247 PIO_STATUS_BLOCK IoStatusBlock
,
3250 PAFDAPCCONTEXT Context
= ApcContext
;
3252 Context
->lpCompletionRoutine(IoStatusBlock
->Status
, IoStatusBlock
->Information
, Context
->lpOverlapped
, 0);
3253 HeapFree(GlobalHeap
, 0, ApcContext
);
3257 GetSocketInformation(PSOCKET_INFORMATION Socket
,
3258 ULONG AfdInformationClass
,
3259 PBOOLEAN Boolean OPTIONAL
,
3260 PULONG Ulong OPTIONAL
,
3261 PLARGE_INTEGER LargeInteger OPTIONAL
,
3262 LPWSAOVERLAPPED Overlapped OPTIONAL
,
3263 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
3265 PIO_STATUS_BLOCK IOSB
;
3266 IO_STATUS_BLOCK DummyIOSB
;
3269 PAFDAPCCONTEXT APCContext
;
3270 PIO_APC_ROUTINE APCFunction
;
3271 HANDLE Event
= NULL
;
3274 Status
= NtCreateEvent(&SockEvent
,
3277 SynchronizationEvent
,
3280 if( !NT_SUCCESS(Status
) )
3281 return SOCKET_ERROR
;
3283 /* Set Info Class */
3284 InfoData
.InformationClass
= AfdInformationClass
;
3286 /* Verify if we should use APC */
3287 if (Overlapped
== NULL
)
3289 /* Not using Overlapped structure, so use normal blocking on event */
3297 /* Overlapped request for non overlapped opened socket */
3298 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
3300 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3301 NtClose( SockEvent
);
3304 if (CompletionRoutine
== NULL
)
3306 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3307 APCContext
= (PAFDAPCCONTEXT
)Overlapped
;
3309 Event
= Overlapped
->hEvent
;
3313 /* Using Overlapped Structure and a Completition Routine, so use an APC */
3314 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
3315 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
3318 ERR("Not enough memory for APC Context\n");
3319 NtClose( SockEvent
);
3322 APCContext
->lpCompletionRoutine
= CompletionRoutine
;
3323 APCContext
->lpOverlapped
= Overlapped
;
3324 APCContext
->lpSocket
= Socket
;
3327 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
3330 IOSB
->Status
= STATUS_PENDING
;
3333 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3344 /* Wait for return */
3345 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
3347 WaitForSingleObject(SockEvent
, INFINITE
);
3348 Status
= IOSB
->Status
;
3351 NtClose( SockEvent
);
3353 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
3355 if (Status
== STATUS_PENDING
)
3357 TRACE("Leaving (Pending)\n");
3358 return WSA_IO_PENDING
;
3361 if (Status
!= STATUS_SUCCESS
)
3362 return SOCKET_ERROR
;
3364 /* Return Information */
3367 *Ulong
= InfoData
.Information
.Ulong
;
3369 if (LargeInteger
!= NULL
)
3371 *LargeInteger
= InfoData
.Information
.LargeInteger
;
3373 if (Boolean
!= NULL
)
3375 *Boolean
= InfoData
.Information
.Boolean
;
3384 SetSocketInformation(PSOCKET_INFORMATION Socket
,
3385 ULONG AfdInformationClass
,
3386 PBOOLEAN Boolean OPTIONAL
,
3387 PULONG Ulong OPTIONAL
,
3388 PLARGE_INTEGER LargeInteger OPTIONAL
,
3389 LPWSAOVERLAPPED Overlapped OPTIONAL
,
3390 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
3392 PIO_STATUS_BLOCK IOSB
;
3393 IO_STATUS_BLOCK DummyIOSB
;
3396 PAFDAPCCONTEXT APCContext
;
3397 PIO_APC_ROUTINE APCFunction
;
3398 HANDLE Event
= NULL
;
3401 Status
= NtCreateEvent(&SockEvent
,
3404 SynchronizationEvent
,
3407 if( !NT_SUCCESS(Status
) )
3408 return SOCKET_ERROR
;
3410 /* Set Info Class */
3411 InfoData
.InformationClass
= AfdInformationClass
;
3413 /* Set Information */
3416 InfoData
.Information
.Ulong
= *Ulong
;
3418 if (LargeInteger
!= NULL
)
3420 InfoData
.Information
.LargeInteger
= *LargeInteger
;
3422 if (Boolean
!= NULL
)
3424 InfoData
.Information
.Boolean
= *Boolean
;
3427 /* Verify if we should use APC */
3428 if (Overlapped
== NULL
)
3430 /* Not using Overlapped structure, so use normal blocking on event */
3438 /* Overlapped request for non overlapped opened socket */
3439 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
3441 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3442 NtClose( SockEvent
);
3445 if (CompletionRoutine
== NULL
)
3447 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3448 APCContext
= (PAFDAPCCONTEXT
)Overlapped
;
3450 Event
= Overlapped
->hEvent
;
3454 /* Using Overlapped Structure and a Completition Routine, so use an APC */
3455 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
3456 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
3459 ERR("Not enough memory for APC Context\n");
3460 NtClose( SockEvent
);
3463 APCContext
->lpCompletionRoutine
= CompletionRoutine
;
3464 APCContext
->lpOverlapped
= Overlapped
;
3465 APCContext
->lpSocket
= Socket
;
3468 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
3471 IOSB
->Status
= STATUS_PENDING
;
3474 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3485 /* Wait for return */
3486 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
3488 WaitForSingleObject(SockEvent
, INFINITE
);
3489 Status
= IOSB
->Status
;
3492 NtClose( SockEvent
);
3494 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
3496 if (Status
== STATUS_PENDING
)
3498 TRACE("Leaving (Pending)\n");
3499 return WSA_IO_PENDING
;
3502 return Status
== STATUS_SUCCESS
? NO_ERROR
: SOCKET_ERROR
;
3507 GetSocketStructure(SOCKET Handle
)
3509 PSOCKET_INFORMATION CurrentSocket
;
3511 EnterCriticalSection(&SocketListLock
);
3513 CurrentSocket
= SocketListHead
;
3514 while (CurrentSocket
)
3516 if (CurrentSocket
->Handle
== Handle
)
3518 LeaveCriticalSection(&SocketListLock
);
3519 return CurrentSocket
;
3522 CurrentSocket
= CurrentSocket
->NextSocket
;
3525 LeaveCriticalSection(&SocketListLock
);
3530 int CreateContext(PSOCKET_INFORMATION Socket
)
3532 IO_STATUS_BLOCK IOSB
;
3533 SOCKET_CONTEXT ContextData
;
3537 Status
= NtCreateEvent(&SockEvent
,
3540 SynchronizationEvent
,
3543 if( !NT_SUCCESS(Status
) )
3544 return SOCKET_ERROR
;
3546 /* Create Context */
3547 ContextData
.SharedData
= *Socket
->SharedData
;
3548 ContextData
.SizeOfHelperData
= 0;
3549 RtlCopyMemory (&ContextData
.LocalAddress
,
3550 Socket
->LocalAddress
,
3551 Socket
->SharedData
->SizeOfLocalAddress
);
3552 RtlCopyMemory (&ContextData
.RemoteAddress
,
3553 Socket
->RemoteAddress
,
3554 Socket
->SharedData
->SizeOfRemoteAddress
);
3557 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3562 IOCTL_AFD_SET_CONTEXT
,
3564 sizeof(ContextData
),
3568 /* Wait for Completion */
3569 if (Status
== STATUS_PENDING
)
3571 WaitForSingleObject(SockEvent
, INFINITE
);
3572 Status
= IOSB
.Status
;
3575 NtClose( SockEvent
);
3577 return Status
== STATUS_SUCCESS
? NO_ERROR
: SOCKET_ERROR
;
3580 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
3582 HANDLE hAsyncThread
;
3583 DWORD AsyncThreadId
;
3585 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3588 /* Check if the Thread Already Exists */
3589 if (SockAsyncThreadRefCount
)
3591 ASSERT(SockAsyncCompletionPort
);
3595 /* Create the Completion Port */
3596 if (!SockAsyncCompletionPort
)
3598 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
3599 IO_COMPLETION_ALL_ACCESS
,
3601 2); // Allow 2 threads only
3602 if (!NT_SUCCESS(Status
))
3604 ERR("Failed to create completion port: 0x%08x\n", Status
);
3607 /* Protect Handle */
3608 HandleFlags
.ProtectFromClose
= TRUE
;
3609 HandleFlags
.Inherit
= FALSE
;
3610 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
3611 ObjectHandleFlagInformation
,
3613 sizeof(HandleFlags
));
3616 /* Create the Async Event */
3617 Status
= NtCreateEvent(&AsyncEvent
,
3623 /* Create the Async Thread */
3624 hAsyncThread
= CreateThread(NULL
,
3631 /* Close the Handle */
3632 NtClose(hAsyncThread
);
3634 /* Increase the Reference Count */
3635 SockAsyncThreadRefCount
++;
3641 SockAsyncThread(PVOID ThreadParam
)
3644 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
3645 IO_STATUS_BLOCK IOSB
;
3648 /* Make the Thread Higher Priority */
3649 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
3651 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3654 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
3655 (PVOID
*)&AsyncCompletionRoutine
,
3659 /* Call the Async Function */
3660 if (NT_SUCCESS(Status
))
3662 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
3666 /* It Failed, sleep for a second */
3669 } while ((Status
!= STATUS_TIMEOUT
));
3671 /* The Thread has Ended */
3675 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
3677 UNICODE_STRING AfdHelper
;
3678 OBJECT_ATTRIBUTES ObjectAttributes
;
3679 IO_STATUS_BLOCK IoSb
;
3680 FILE_COMPLETION_INFORMATION CompletionInfo
;
3681 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3683 /* First, make sure we're not already initialized */
3684 if (SockAsyncHelperAfdHandle
)
3689 /* Set up Handle Name and Object */
3690 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
3691 InitializeObjectAttributes(&ObjectAttributes
,
3693 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
3697 /* Open the Handle to AFD */
3698 NtCreateFile(&SockAsyncHelperAfdHandle
,
3699 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
3704 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3711 * Now Set up the Completion Port Information
3712 * This means that whenever a Poll is finished, the routine will be executed
3714 CompletionInfo
.Port
= SockAsyncCompletionPort
;
3715 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
3716 NtSetInformationFile(SockAsyncHelperAfdHandle
,
3719 sizeof(CompletionInfo
),
3720 FileCompletionInformation
);
3723 /* Protect the Handle */
3724 HandleFlags
.ProtectFromClose
= TRUE
;
3725 HandleFlags
.Inherit
= FALSE
;
3726 NtSetInformationObject(SockAsyncCompletionPort
,
3727 ObjectHandleFlagInformation
,
3729 sizeof(HandleFlags
));
3732 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
3733 SockAsyncSelectCalled
= TRUE
;
3737 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3740 PASYNC_DATA AsyncData
= Context
;
3741 PSOCKET_INFORMATION Socket
;
3744 /* Get the Socket */
3745 Socket
= AsyncData
->ParentSocket
;
3747 /* Check if the Sequence Number Changed behind our back */
3748 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
->SequenceNumber
)
3753 /* Check we were manually called b/c of a failure */
3754 if (!NT_SUCCESS(IoStatusBlock
->Status
))
3756 /* FIXME: Perform Upcall */
3760 for (x
= 1; x
; x
<<=1)
3762 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
3764 case AFD_EVENT_RECEIVE
:
3765 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_READ
) &&
3766 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_READ
))
3768 /* Make the Notification */
3769 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3770 Socket
->SharedData
->wMsg
,
3772 WSAMAKESELECTREPLY(FD_READ
, 0));
3773 /* Disable this event until the next read(); */
3774 Socket
->SharedData
->AsyncDisabledEvents
|= FD_READ
;
3778 case AFD_EVENT_OOB_RECEIVE
:
3779 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_OOB
) &&
3780 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_OOB
))
3782 /* Make the Notification */
3783 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3784 Socket
->SharedData
->wMsg
,
3786 WSAMAKESELECTREPLY(FD_OOB
, 0));
3787 /* Disable this event until the next read(); */
3788 Socket
->SharedData
->AsyncDisabledEvents
|= FD_OOB
;
3792 case AFD_EVENT_SEND
:
3793 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_WRITE
) &&
3794 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_WRITE
))
3796 /* Make the Notification */
3797 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3798 Socket
->SharedData
->wMsg
,
3800 WSAMAKESELECTREPLY(FD_WRITE
, 0));
3801 /* Disable this event until the next write(); */
3802 Socket
->SharedData
->AsyncDisabledEvents
|= FD_WRITE
;
3806 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3807 case AFD_EVENT_CONNECT
:
3808 case AFD_EVENT_CONNECT_FAIL
:
3809 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
) &&
3810 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CONNECT
))
3812 /* Make the Notification */
3813 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3814 Socket
->SharedData
->wMsg
,
3816 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
3817 /* Disable this event forever; */
3818 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
;
3822 case AFD_EVENT_ACCEPT
:
3823 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_ACCEPT
) &&
3824 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_ACCEPT
))
3826 /* Make the Notification */
3827 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3828 Socket
->SharedData
->wMsg
,
3830 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
3831 /* Disable this event until the next accept(); */
3832 Socket
->SharedData
->AsyncDisabledEvents
|= FD_ACCEPT
;
3836 case AFD_EVENT_DISCONNECT
:
3837 case AFD_EVENT_ABORT
:
3838 case AFD_EVENT_CLOSE
:
3839 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CLOSE
) &&
3840 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CLOSE
))
3842 /* Make the Notification */
3843 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3844 Socket
->SharedData
->wMsg
,
3846 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
3847 /* Disable this event forever; */
3848 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CLOSE
;
3851 /* FIXME: Support QOS */
3855 /* Check if there are any events left for us to check */
3856 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3862 SockProcessAsyncSelect(Socket
, AsyncData
);
3866 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
3869 ULONG lNetworkEvents
;
3872 /* Set up the Async Data Event Info */
3873 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
3874 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
3875 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
3876 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
3877 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
3878 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
3880 /* Remove unwanted events */
3881 lNetworkEvents
= Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
);
3883 /* Set Events to wait for */
3884 if (lNetworkEvents
& FD_READ
)
3886 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
3889 if (lNetworkEvents
& FD_WRITE
)
3891 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
3894 if (lNetworkEvents
& FD_OOB
)
3896 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
3899 if (lNetworkEvents
& FD_ACCEPT
)
3901 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
3904 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3905 if (lNetworkEvents
& FD_CONNECT
)
3907 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
3910 if (lNetworkEvents
& FD_CLOSE
)
3912 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
3915 if (lNetworkEvents
& FD_QOS
)
3917 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
3920 if (lNetworkEvents
& FD_GROUP_QOS
)
3922 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
3926 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
3930 &AsyncData
->IoStatusBlock
,
3932 &AsyncData
->AsyncSelectInfo
,
3933 sizeof(AsyncData
->AsyncSelectInfo
),
3934 &AsyncData
->AsyncSelectInfo
,
3935 sizeof(AsyncData
->AsyncSelectInfo
));
3937 /* I/O Manager Won't call the completion routine, let's do it manually */
3938 if (NT_SUCCESS(Status
))
3944 AsyncData
->IoStatusBlock
.Status
= Status
;
3945 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3949 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3951 PASYNC_DATA AsyncData
= Context
;
3952 BOOL FreeContext
= TRUE
;
3953 PSOCKET_INFORMATION Socket
;
3955 /* Get the Socket */
3956 Socket
= AsyncData
->ParentSocket
;
3958 /* If someone closed it, stop the function */
3959 if (Socket
->SharedData
->State
!= SocketClosed
)
3961 /* Check if the Sequence Number changed by now, in which case quit */
3962 if (AsyncData
->SequenceNumber
== Socket
->SharedData
->SequenceNumber
)
3964 /* Do the actual select, if needed */
3965 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)))
3967 SockProcessAsyncSelect(Socket
, AsyncData
);
3968 FreeContext
= FALSE
;
3973 /* Free the Context */
3976 HeapFree(GetProcessHeap(), 0, AsyncData
);
3983 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3986 PASYNC_DATA AsyncData
;
3988 /* Make sure the event is actually disabled */
3989 if (!(Socket
->SharedData
->AsyncDisabledEvents
& Event
))
3995 Socket
->SharedData
->AsyncDisabledEvents
&= ~Event
;
3997 /* Return if no more events are being polled */
3998 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
4003 /* Wait on new events */
4004 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
4005 if (!AsyncData
) return;
4007 /* Create the Asynch Thread if Needed */
4008 SockCreateOrReferenceAsyncThread();
4010 /* Increase the sequence number to stop anything else */
4011 Socket
->SharedData
->SequenceNumber
++;
4013 /* Set up the Async Data */
4014 AsyncData
->ParentSocket
= Socket
;
4015 AsyncData
->SequenceNumber
= Socket
->SharedData
->SequenceNumber
;
4017 /* Begin Async Select by using I/O Completion */
4018 NtSetIoCompletion(SockAsyncCompletionPort
,
4019 (PVOID
)&SockProcessQueuedAsyncSelect
,
4030 DllMain(HANDLE hInstDll
,
4037 case DLL_PROCESS_ATTACH
:
4039 TRACE("Loading MSAFD.DLL \n");
4041 /* Don't need thread attach notifications
4042 so disable them to improve performance */
4043 DisableThreadLibraryCalls(hInstDll
);
4045 /* List of DLL Helpers */
4046 InitializeListHead(&SockHelpersListHead
);
4048 /* Heap to use when allocating */
4049 GlobalHeap
= GetProcessHeap();
4051 /* Initialize the lock that protects our socket list */
4052 InitializeCriticalSection(&SocketListLock
);
4054 TRACE("MSAFD.DLL has been loaded\n");
4058 case DLL_THREAD_ATTACH
:
4061 case DLL_THREAD_DETACH
:
4064 case DLL_PROCESS_DETACH
:
4066 /* Delete the socket list lock */
4067 DeleteCriticalSection(&SocketListLock
);
4072 TRACE("DllMain of msafd.dll (leaving)\n");