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)
9 * CSH 01/09-2000 Created
10 * Alex 16/07/2004 - Complete Rewrite
18 #include <wine/debug.h>
19 WINE_DEFAULT_DEBUG_CHANNEL(msafd
);
22 WSPUPCALLTABLE Upcalls
;
23 DWORD CatalogEntryId
; /* CatalogEntryId for upcalls */
24 LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
;
25 PSOCKET_INFORMATION SocketListHead
= NULL
;
26 CRITICAL_SECTION SocketListLock
;
27 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
28 ULONG SockAsyncThreadRefCount
;
29 HANDLE SockAsyncHelperAfdHandle
;
30 HANDLE SockAsyncCompletionPort
= NULL
;
31 BOOLEAN SockAsyncSelectCalled
;
36 * FUNCTION: Creates a new socket
40 * protocol = Protocol type
41 * lpProtocolInfo = Pointer to protocol information
43 * dwFlags = Socket flags
44 * lpErrno = Address of buffer for error information
46 * Created socket, or INVALID_SOCKET if it could not be created
50 WSPSocket(int AddressFamily
,
53 LPWSAPROTOCOL_INFOW lpProtocolInfo
,
58 OBJECT_ATTRIBUTES Object
;
62 PAFD_CREATE_PACKET AfdPacket
;
64 PSOCKET_INFORMATION Socket
= NULL
;
65 PFILE_FULL_EA_INFORMATION EABuffer
= NULL
;
66 PHELPER_DATA HelperData
;
67 PVOID HelperDLLContext
;
69 UNICODE_STRING TransportName
;
70 UNICODE_STRING DevName
;
71 LARGE_INTEGER GroupData
;
73 PSOCK_SHARED_INFO SharedData
= NULL
;
75 TRACE("Creating Socket, getting TDI Name - AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
76 AddressFamily
, SocketType
, Protocol
);
78 if (lpProtocolInfo
&& lpProtocolInfo
->dwServiceFlags3
!= 0 && lpProtocolInfo
->dwServiceFlags4
!= 0)
80 /* Duplpicating socket from different process */
81 if ((HANDLE
)lpProtocolInfo
->dwServiceFlags3
== INVALID_HANDLE_VALUE
)
83 if ((HANDLE
)lpProtocolInfo
->dwServiceFlags4
== INVALID_HANDLE_VALUE
)
85 SharedData
= MapViewOfFile((HANDLE
)lpProtocolInfo
->dwServiceFlags3
,
89 sizeof(SOCK_SHARED_INFO
));
92 InterlockedIncrement(&SharedData
->RefCount
);
93 AddressFamily
= SharedData
->AddressFamily
;
94 SocketType
= SharedData
->SocketType
;
95 Protocol
= SharedData
->Protocol
;
98 if (AddressFamily
== AF_UNSPEC
&& SocketType
== 0 && Protocol
== 0)
101 /* Set the defaults */
102 if (AddressFamily
== AF_UNSPEC
)
103 AddressFamily
= AF_INET
;
110 SocketType
= SOCK_STREAM
;
113 SocketType
= SOCK_DGRAM
;
116 SocketType
= SOCK_RAW
;
119 TRACE("Unknown Protocol (%d). We will try SOCK_STREAM.\n", Protocol
);
120 SocketType
= SOCK_STREAM
;
130 Protocol
= IPPROTO_TCP
;
133 Protocol
= IPPROTO_UDP
;
136 Protocol
= IPPROTO_RAW
;
139 TRACE("Unknown SocketType (%d). We will try IPPROTO_TCP.\n", SocketType
);
140 Protocol
= IPPROTO_TCP
;
145 /* Get Helper Data and Transport */
146 Status
= SockGetTdiName (&AddressFamily
,
156 /* Check for error */
157 if (Status
!= NO_ERROR
)
159 ERR("SockGetTdiName: Status %x\n", Status
);
163 /* AFD Device Name */
164 RtlInitUnicodeString(&DevName
, L
"\\Device\\Afd\\Endpoint");
166 /* Set Socket Data */
167 Socket
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
));
170 Status
= STATUS_INSUFFICIENT_RESOURCES
;
173 RtlZeroMemory(Socket
, sizeof(*Socket
));
176 Socket
->SharedData
= SharedData
;
177 Socket
->SharedDataHandle
= (HANDLE
)lpProtocolInfo
->dwServiceFlags3
;
178 Sock
= (HANDLE
)lpProtocolInfo
->dwServiceFlags4
;
179 Socket
->Handle
= (SOCKET
)lpProtocolInfo
->dwServiceFlags4
;
183 Socket
->SharedDataHandle
= INVALID_HANDLE_VALUE
;
184 Socket
->SharedData
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
->SharedData
));
185 if (!Socket
->SharedData
)
187 Status
= STATUS_INSUFFICIENT_RESOURCES
;
190 RtlZeroMemory(Socket
->SharedData
, sizeof(*Socket
->SharedData
));
191 Socket
->SharedData
->State
= SocketOpen
;
192 Socket
->SharedData
->RefCount
= 1L;
193 Socket
->SharedData
->Listening
= FALSE
;
194 Socket
->SharedData
->AddressFamily
= AddressFamily
;
195 Socket
->SharedData
->SocketType
= SocketType
;
196 Socket
->SharedData
->Protocol
= Protocol
;
197 Socket
->SharedData
->SizeOfLocalAddress
= HelperData
->MaxWSAddressLength
;
198 Socket
->SharedData
->SizeOfRemoteAddress
= HelperData
->MaxWSAddressLength
;
199 Socket
->SharedData
->UseDelayedAcceptance
= HelperData
->UseDelayedAcceptance
;
200 Socket
->SharedData
->CreateFlags
= dwFlags
;
201 Socket
->SharedData
->ServiceFlags1
= lpProtocolInfo
->dwServiceFlags1
;
202 Socket
->SharedData
->ProviderFlags
= lpProtocolInfo
->dwProviderFlags
;
203 Socket
->SharedData
->UseSAN
= FALSE
;
204 Socket
->SharedData
->NonBlocking
= FALSE
; /* Sockets start blocking */
205 Socket
->SharedData
->RecvTimeout
= INFINITE
;
206 Socket
->SharedData
->SendTimeout
= INFINITE
;
207 Socket
->SharedData
->OobInline
= FALSE
;
209 /* Ask alex about this */
210 if( Socket
->SharedData
->SocketType
== SOCK_DGRAM
||
211 Socket
->SharedData
->SocketType
== SOCK_RAW
)
213 TRACE("Connectionless socket\n");
214 Socket
->SharedData
->ServiceFlags1
|= XP1_CONNECTIONLESS
;
216 Socket
->Handle
= INVALID_SOCKET
;
219 Socket
->HelperContext
= HelperDLLContext
;
220 Socket
->HelperData
= HelperData
;
221 Socket
->HelperEvents
= HelperEvents
;
222 Socket
->LocalAddress
= &Socket
->SharedData
->WSLocalAddress
;
223 Socket
->RemoteAddress
= &Socket
->SharedData
->WSRemoteAddress
;
224 Socket
->SanData
= NULL
;
225 RtlCopyMemory(&Socket
->ProtocolInfo
, lpProtocolInfo
, sizeof(Socket
->ProtocolInfo
));
230 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
233 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
235 /* Set up EA Buffer */
236 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
239 Status
= STATUS_INSUFFICIENT_RESOURCES
;
243 RtlZeroMemory(EABuffer
, SizeOfEA
);
244 EABuffer
->NextEntryOffset
= 0;
246 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
247 RtlCopyMemory (EABuffer
->EaName
,
249 AFD_PACKET_COMMAND_LENGTH
+ 1);
250 EABuffer
->EaValueLength
= SizeOfPacket
;
252 /* Set up AFD Packet */
253 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
254 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
255 RtlCopyMemory (AfdPacket
->TransportName
,
256 TransportName
.Buffer
,
257 TransportName
.Length
+ sizeof(WCHAR
));
258 AfdPacket
->GroupID
= g
;
260 /* Set up Endpoint Flags */
261 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
263 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
265 /* Only RAW or UDP can be Connectionless */
268 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
271 if ((Socket
->SharedData
->ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
273 if (SocketType
== SOCK_STREAM
)
275 if ((Socket
->SharedData
->ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
277 /* The Provider doesn't actually support Message Oriented Streams */
281 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
284 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
286 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
287 WSA_FLAG_MULTIPOINT_C_LEAF
|
288 WSA_FLAG_MULTIPOINT_D_ROOT
|
289 WSA_FLAG_MULTIPOINT_D_LEAF
))
291 if ((Socket
->SharedData
->ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
293 /* The Provider doesn't actually support Multipoint */
296 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
298 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
300 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
301 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
303 /* The Provider doesn't support Control Planes, or you already gave a leaf */
306 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
309 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
311 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
312 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
314 /* The Provider doesn't support Data Planes, or you already gave a leaf */
317 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
321 /* Set up Object Attributes */
322 InitializeObjectAttributes (&Object
,
324 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
328 /* Create the Socket as asynchronous. That means we have to block
329 ourselves after every call to NtDeviceIoControlFile. This is
330 because the kernel doesn't support overlapping synchronous I/O
331 requests (made from multiple threads) at this time (Sep 2005) */
332 Status
= NtCreateFile(&Sock
,
333 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
338 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
344 HeapFree(GlobalHeap
, 0, EABuffer
);
346 if (!NT_SUCCESS(Status
))
348 ERR("Failed to open socket. Status 0x%08x\n", Status
);
353 Socket
->Handle
= (SOCKET
)Sock
;
355 /* Save Group Info */
358 GetSocketInformation(Socket
,
359 AFD_INFO_GROUP_ID_TYPE
,
365 Socket
->SharedData
->GroupID
= GroupData
.u
.LowPart
;
366 Socket
->SharedData
->GroupType
= GroupData
.u
.HighPart
;
369 /* Get Window Sizes and Save them */
370 GetSocketInformation (Socket
,
371 AFD_INFO_SEND_WINDOW_SIZE
,
373 &Socket
->SharedData
->SizeOfSendBuffer
,
378 GetSocketInformation (Socket
,
379 AFD_INFO_RECEIVE_WINDOW_SIZE
,
381 &Socket
->SharedData
->SizeOfRecvBuffer
,
387 /* Save in Process Sockets List */
388 EnterCriticalSection(&SocketListLock
);
389 Socket
->NextSocket
= SocketListHead
;
390 SocketListHead
= Socket
;
391 LeaveCriticalSection(&SocketListLock
);
393 /* Create the Socket Context */
394 CreateContext(Socket
);
397 Upcalls
.lpWPUModifyIFSHandle(Socket
->ProtocolInfo
.dwCatalogEntryId
, (SOCKET
)Sock
, lpErrno
);
399 /* Return Socket Handle */
400 TRACE("Success %x\n", Sock
);
405 ERR("Ending %x\n", Status
);
409 UnmapViewOfFile(SharedData
);
410 NtClose((HANDLE
)lpProtocolInfo
->dwServiceFlags3
);
414 if( Socket
&& Socket
->SharedData
)
415 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
419 HeapFree(GlobalHeap
, 0, Socket
);
422 HeapFree(GlobalHeap
, 0, EABuffer
);
427 return INVALID_SOCKET
;
435 IN DWORD dwProcessId
,
436 OUT LPWSAPROTOCOL_INFOW lpProtocolInfo
,
439 HANDLE hProcess
, hDuplicatedSharedData
, hDuplicatedHandle
;
440 PSOCKET_INFORMATION Socket
;
441 PSOCK_SHARED_INFO pSharedData
, pOldSharedData
;
444 if (Handle
== INVALID_SOCKET
)
445 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
446 Socket
= GetSocketStructure(Handle
);
450 *lpErrno
= WSAENOTSOCK
;
453 if ( !(hProcess
= OpenProcess(PROCESS_DUP_HANDLE
, FALSE
, dwProcessId
)) )
454 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
456 /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
457 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
459 Socket
->SharedDataHandle
= CreateFileMapping(INVALID_HANDLE_VALUE
,
461 PAGE_READWRITE
| SEC_COMMIT
,
463 (sizeof(SOCK_SHARED_INFO
) + PAGE_SIZE
- 1) & ~(PAGE_SIZE
- 1),
465 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
466 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
467 pSharedData
= MapViewOfFile(Socket
->SharedDataHandle
,
471 sizeof(SOCK_SHARED_INFO
));
473 RtlCopyMemory(pSharedData
, Socket
->SharedData
, sizeof(SOCK_SHARED_INFO
));
474 pOldSharedData
= Socket
->SharedData
;
475 Socket
->SharedData
= pSharedData
;
476 HeapFree(GlobalHeap
, 0, pOldSharedData
);
478 /* Duplicate the handles for the new process */
479 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
480 Socket
->SharedDataHandle
,
482 (LPHANDLE
)&hDuplicatedSharedData
,
485 DUPLICATE_SAME_ACCESS
);
489 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
491 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
492 (HANDLE
)Socket
->Handle
,
494 (LPHANDLE
)&hDuplicatedHandle
,
497 DUPLICATE_SAME_ACCESS
);
500 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
504 return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION
, lpErrno
, 0, NULL
);
506 RtlCopyMemory(lpProtocolInfo
, &Socket
->ProtocolInfo
, sizeof(*lpProtocolInfo
));
508 lpProtocolInfo
->iAddressFamily
= Socket
->SharedData
->AddressFamily
;
509 lpProtocolInfo
->iProtocol
= Socket
->SharedData
->Protocol
;
510 lpProtocolInfo
->iSocketType
= Socket
->SharedData
->SocketType
;
511 lpProtocolInfo
->dwServiceFlags3
= (DWORD
)hDuplicatedSharedData
;
512 lpProtocolInfo
->dwServiceFlags4
= (DWORD
)hDuplicatedHandle
;
521 TranslateNtStatusError(NTSTATUS Status
)
525 case STATUS_CANT_WAIT
:
526 return WSAEWOULDBLOCK
;
534 case STATUS_FILE_CLOSED
:
535 return WSAECONNRESET
;
537 case STATUS_END_OF_FILE
:
541 return WSA_IO_PENDING
;
543 case STATUS_BUFFER_TOO_SMALL
:
544 case STATUS_BUFFER_OVERFLOW
:
547 case STATUS_NO_MEMORY
:
548 case STATUS_INSUFFICIENT_RESOURCES
:
551 case STATUS_INVALID_CONNECTION
:
554 case STATUS_PROTOCOL_NOT_SUPPORTED
:
555 return WSAEAFNOSUPPORT
;
557 case STATUS_INVALID_ADDRESS
:
558 return WSAEADDRNOTAVAIL
;
560 case STATUS_REMOTE_NOT_LISTENING
:
561 case STATUS_REMOTE_DISCONNECT
:
562 return WSAECONNREFUSED
;
564 case STATUS_NETWORK_UNREACHABLE
:
565 return WSAENETUNREACH
;
567 case STATUS_INVALID_PARAMETER
:
570 case STATUS_CANCELLED
:
571 return WSA_OPERATION_ABORTED
;
573 case STATUS_ADDRESS_ALREADY_EXISTS
:
574 return WSAEADDRINUSE
;
576 case STATUS_LOCAL_DISCONNECT
:
577 return WSAECONNABORTED
;
579 case STATUS_ACCESS_VIOLATION
:
582 case STATUS_ACCESS_DENIED
:
585 case STATUS_NOT_IMPLEMENTED
:
586 return WSAEOPNOTSUPP
;
589 ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
595 * FUNCTION: Closes an open socket
597 * s = Socket descriptor
598 * lpErrno = Address of buffer for error information
600 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
604 WSPCloseSocket(IN SOCKET Handle
,
607 IO_STATUS_BLOCK IoStatusBlock
;
608 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
611 AFD_DISCONNECT_INFO DisconnectInfo
;
612 SOCKET_STATE OldState
;
613 LONG LingerWait
= -1;
616 /* Get the Socket Structure associate to this Socket*/
617 Socket
= GetSocketStructure(Handle
);
620 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
624 /* Create the Wait Event */
625 Status
= NtCreateEvent(&SockEvent
,
631 if(!NT_SUCCESS(Status
))
633 ERR("NtCreateEvent failed: 0x%08x", Status
);
637 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
639 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
641 Socket
->TdiAddressHandle
,
642 Socket
->TdiConnectionHandle
,
647 if (lpErrno
) *lpErrno
= Status
;
648 ERR("WSHNotify failed. Error 0x%#x", Status
);
654 /* If a Close is already in Process, give up */
655 if (Socket
->SharedData
->State
== SocketClosed
)
657 WARN("Socket is closing.\n");
659 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
662 /* Set the state to close */
663 OldState
= Socket
->SharedData
->State
;
664 Socket
->SharedData
->State
= SocketClosed
;
666 /* Decrement reference count on SharedData */
667 References
= InterlockedDecrement(&Socket
->SharedData
->RefCount
);
671 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
672 /* FIXME: Should we do this on Datagram Sockets too? */
673 if ((OldState
== SocketConnected
) && (Socket
->SharedData
->LingerData
.l_onoff
))
675 ULONG SendsInProgress
;
678 /* We need to respect the timeout */
680 LingerWait
= Socket
->SharedData
->LingerData
.l_linger
* 1000;
682 /* Loop until no more sends are pending, within the timeout */
685 /* Find out how many Sends are in Progress */
686 if (GetSocketInformation(Socket
,
687 AFD_INFO_SENDS_IN_PROGRESS
,
694 /* Bail out if anything but NO_ERROR */
699 /* Bail out if no more sends are pending */
700 if (!SendsInProgress
)
707 * We have to execute a sleep, so it's kind of like
708 * a block. If the socket is Nonblock, we cannot
709 * go on since asyncronous operation is expected
710 * and we cannot offer it
712 if (Socket
->SharedData
->NonBlocking
)
714 WARN("Would block!\n");
716 Socket
->SharedData
->State
= OldState
;
717 if (lpErrno
) *lpErrno
= WSAEWOULDBLOCK
;
721 /* Now we can sleep, and decrement the linger wait */
723 * FIXME: It seems Windows does some funky acceleration
724 * since the waiting seems to be longer and longer. I
725 * don't think this improves performance so much, so we
726 * wait a fixed time instead.
729 LingerWait
-= SleepWait
;
733 if (OldState
== SocketConnected
)
737 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
738 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
740 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
->SendShutdown
)) ||
741 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
->ReceiveShutdown
)))
744 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
749 IOCTL_AFD_DISCONNECT
,
751 sizeof(DisconnectInfo
),
755 /* Wait for return */
756 if (Status
== STATUS_PENDING
)
758 WaitForSingleObject(SockEvent
, INFINITE
);
759 Status
= IoStatusBlock
.Status
;
766 Socket
->HelperContext
= NULL
;
767 Socket
->SharedData
->AsyncDisabledEvents
= -1;
768 NtClose(Socket
->TdiAddressHandle
);
769 Socket
->TdiAddressHandle
= NULL
;
770 NtClose(Socket
->TdiConnectionHandle
);
771 Socket
->TdiConnectionHandle
= NULL
;
773 EnterCriticalSection(&SocketListLock
);
774 if (SocketListHead
== Socket
)
776 SocketListHead
= SocketListHead
->NextSocket
;
780 CurrentSocket
= SocketListHead
;
781 while (CurrentSocket
->NextSocket
)
783 if (CurrentSocket
->NextSocket
== Socket
)
785 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
789 CurrentSocket
= CurrentSocket
->NextSocket
;
792 LeaveCriticalSection(&SocketListLock
);
794 /* Close the handle */
795 NtClose((HANDLE
)Handle
);
798 if( Socket
->SharedDataHandle
!= INVALID_HANDLE_VALUE
)
800 /* It is a duplicated socket, so unmap the memory */
801 UnmapViewOfFile(Socket
->SharedData
);
802 NtClose(Socket
->SharedDataHandle
);
803 Socket
->SharedData
= NULL
;
805 if( !References
&& Socket
->SharedData
)
807 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
809 HeapFree(GlobalHeap
, 0, Socket
);
810 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
815 * FUNCTION: Associates a local address with a socket
817 * s = Socket descriptor
818 * name = Pointer to local address
819 * namelen = Length of name
820 * lpErrno = Address of buffer for error information
822 * 0, or SOCKET_ERROR if the socket could not be bound
826 WSPBind(SOCKET Handle
,
827 const struct sockaddr
*SocketAddress
,
828 int SocketAddressLength
,
831 IO_STATUS_BLOCK IOSB
;
832 PAFD_BIND_DATA BindData
;
833 PSOCKET_INFORMATION Socket
= NULL
;
835 SOCKADDR_INFO SocketInfo
;
838 /* Get the Socket Structure associate to this Socket*/
839 Socket
= GetSocketStructure(Handle
);
842 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
846 Status
= NtCreateEvent(&SockEvent
,
852 if (!NT_SUCCESS(Status
))
858 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
861 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
864 /* Set up Address in TDI Format */
865 BindData
->Address
.TAAddressCount
= 1;
866 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
867 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
868 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
869 SocketAddress
->sa_data
,
870 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
872 /* Get Address Information */
873 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
877 /* Set the Share Type */
878 if (Socket
->SharedData
->ExclusiveAddressUse
)
880 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
882 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
884 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
886 else if (Socket
->SharedData
->ReuseAddresses
)
888 BindData
->ShareType
= AFD_SHARE_REUSE
;
892 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
896 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
903 0xA + Socket
->SharedData
->SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
905 0xA + Socket
->SharedData
->SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
907 /* Wait for return */
908 if (Status
== STATUS_PENDING
)
910 WaitForSingleObject(SockEvent
, INFINITE
);
911 Status
= IOSB
.Status
;
914 NtClose( SockEvent
);
915 HeapFree(GlobalHeap
, 0, BindData
);
917 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
918 if (Status
!= STATUS_SUCCESS
)
919 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
921 /* Set up Socket Data */
922 Socket
->SharedData
->State
= SocketBound
;
923 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
925 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
927 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
929 Socket
->TdiAddressHandle
,
930 Socket
->TdiConnectionHandle
,
935 if (lpErrno
) *lpErrno
= Status
;
940 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
945 WSPListen(SOCKET Handle
,
949 IO_STATUS_BLOCK IOSB
;
950 AFD_LISTEN_DATA ListenData
;
951 PSOCKET_INFORMATION Socket
= NULL
;
955 /* Get the Socket Structure associate to this Socket*/
956 Socket
= GetSocketStructure(Handle
);
959 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
963 if (Socket
->SharedData
->Listening
)
966 Status
= NtCreateEvent(&SockEvent
,
972 if( !NT_SUCCESS(Status
) )
975 /* Set Up Listen Structure */
976 ListenData
.UseSAN
= FALSE
;
977 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
->UseDelayedAcceptance
;
978 ListenData
.Backlog
= Backlog
;
981 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
986 IOCTL_AFD_START_LISTEN
,
992 /* Wait for return */
993 if (Status
== STATUS_PENDING
)
995 WaitForSingleObject(SockEvent
, INFINITE
);
996 Status
= IOSB
.Status
;
999 NtClose( SockEvent
);
1001 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1002 if (Status
!= STATUS_SUCCESS
)
1003 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1005 /* Set to Listening */
1006 Socket
->SharedData
->Listening
= TRUE
;
1008 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
1010 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1012 Socket
->TdiAddressHandle
,
1013 Socket
->TdiConnectionHandle
,
1018 if (lpErrno
) *lpErrno
= Status
;
1019 return SOCKET_ERROR
;
1023 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1029 WSPSelect(IN
int nfds
,
1030 IN OUT fd_set
*readfds OPTIONAL
,
1031 IN OUT fd_set
*writefds OPTIONAL
,
1032 IN OUT fd_set
*exceptfds OPTIONAL
,
1033 IN
const struct timeval
*timeout OPTIONAL
,
1036 IO_STATUS_BLOCK IOSB
;
1037 PAFD_POLL_INFO PollInfo
;
1040 ULONG PollBufferSize
;
1044 LARGE_INTEGER Timeout
;
1045 PSOCKET_INFORMATION Socket
;
1049 /* Find out how many sockets we have, and how large the buffer needs
1052 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
1053 ( writefds
? writefds
->fd_count
: 0 ) +
1054 ( exceptfds
? exceptfds
->fd_count
: 0 );
1056 if ( HandleCount
== 0 )
1058 WARN("No handles! Returning SOCKET_ERROR\n", HandleCount
);
1059 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1060 return SOCKET_ERROR
;
1063 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
1065 TRACE("HandleCount: %u BufferSize: %u\n", HandleCount
, PollBufferSize
);
1067 /* Convert Timeout to NT Format */
1068 if (timeout
== NULL
)
1070 Timeout
.u
.LowPart
= -1;
1071 Timeout
.u
.HighPart
= 0x7FFFFFFF;
1072 TRACE("Infinite timeout\n");
1076 Timeout
= RtlEnlargedIntegerMultiply
1077 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
1078 /* Negative timeouts are illegal. Since the kernel represents an
1079 * incremental timeout as a negative number, we check for a positive
1082 if (Timeout
.QuadPart
> 0)
1084 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1085 return SOCKET_ERROR
;
1087 TRACE("Timeout: Orig %d.%06d kernel %d\n",
1088 timeout
->tv_sec
, timeout
->tv_usec
,
1092 Status
= NtCreateEvent(&SockEvent
,
1098 if(!NT_SUCCESS(Status
))
1101 *lpErrno
= WSAEFAULT
;
1103 ERR("NtCreateEvent failed, 0x%08x\n", Status
);
1104 return SOCKET_ERROR
;
1108 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
1113 *lpErrno
= WSAEFAULT
;
1115 return SOCKET_ERROR
;
1118 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
1120 RtlZeroMemory( PollInfo
, PollBufferSize
);
1122 /* Number of handles for AFD to Check */
1123 PollInfo
->Exclusive
= FALSE
;
1124 PollInfo
->Timeout
= Timeout
;
1126 if (readfds
!= NULL
) {
1127 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
1129 Socket
= GetSocketStructure(readfds
->fd_array
[i
]);
1132 ERR("Invalid socket handle provided in readfds %d\n", readfds
->fd_array
[i
]);
1133 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1134 HeapFree(GlobalHeap
, 0, PollBuffer
);
1136 return SOCKET_ERROR
;
1138 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
1139 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
1140 AFD_EVENT_DISCONNECT
|
1144 if (Socket
->SharedData
->OobInline
!= 0)
1145 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_OOB_RECEIVE
;
1148 if (writefds
!= NULL
)
1150 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
1152 Socket
= GetSocketStructure(writefds
->fd_array
[i
]);
1155 ERR("Invalid socket handle provided in writefds %d\n", writefds
->fd_array
[i
]);
1156 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1157 HeapFree(GlobalHeap
, 0, PollBuffer
);
1159 return SOCKET_ERROR
;
1161 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
1162 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
;
1163 if (Socket
->SharedData
->NonBlocking
!= 0)
1164 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_CONNECT
;
1167 if (exceptfds
!= NULL
)
1169 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
1171 Socket
= GetSocketStructure(exceptfds
->fd_array
[i
]);
1174 TRACE("Invalid socket handle provided in exceptfds %d\n", exceptfds
->fd_array
[i
]);
1175 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1176 HeapFree(GlobalHeap
, 0, PollBuffer
);
1178 return SOCKET_ERROR
;
1180 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
1181 PollInfo
->Handles
[j
].Events
= 0;
1182 if (Socket
->SharedData
->OobInline
== 0)
1183 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_OOB_RECEIVE
;
1184 if (Socket
->SharedData
->NonBlocking
!= 0)
1185 PollInfo
->Handles
[j
].Events
|= AFD_EVENT_CONNECT_FAIL
;
1186 if (PollInfo
->Handles
[j
].Events
== 0)
1188 TRACE("No events can be checked for exceptfds %d. It is nonblocking and OOB line is disabled. Skipping it.", exceptfds
->fd_array
[i
]);
1194 PollInfo
->HandleCount
= j
;
1195 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
1198 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
1209 TRACE("DeviceIoControlFile => %x\n", Status
);
1211 /* Wait for Completition */
1212 if (Status
== STATUS_PENDING
)
1214 WaitForSingleObject(SockEvent
, INFINITE
);
1215 Status
= IOSB
.Status
;
1218 /* Clear the Structures */
1226 /* Loop through return structure */
1227 HandleCount
= PollInfo
->HandleCount
;
1229 /* Return in FDSET Format */
1230 for (i
= 0; i
< HandleCount
; i
++)
1232 Events
= PollInfo
->Handles
[i
].Events
;
1233 Handle
= PollInfo
->Handles
[i
].Handle
;
1234 for(x
= 1; x
; x
<<=1)
1236 Socket
= GetSocketStructure(Handle
);
1239 TRACE("Invalid socket handle found %d\n", Handle
);
1240 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1241 HeapFree(GlobalHeap
, 0, PollBuffer
);
1243 return SOCKET_ERROR
;
1247 case AFD_EVENT_RECEIVE
:
1248 case AFD_EVENT_DISCONNECT
:
1249 case AFD_EVENT_ABORT
:
1250 case AFD_EVENT_ACCEPT
:
1251 case AFD_EVENT_CLOSE
:
1252 TRACE("Event %x on handle %x\n",
1255 if ((Events
& x
) == AFD_EVENT_DISCONNECT
|| (Events
& x
) == AFD_EVENT_CLOSE
)
1256 Socket
->SharedData
->SocketLastError
= WSAECONNRESET
;
1257 if ((Events
& x
) == AFD_EVENT_ABORT
)
1258 Socket
->SharedData
->SocketLastError
= WSAECONNABORTED
;
1260 FD_SET(Handle
, readfds
);
1262 case AFD_EVENT_SEND
:
1263 TRACE("Event %x on handle %x\n",
1267 FD_SET(Handle
, writefds
);
1269 case AFD_EVENT_CONNECT
:
1270 TRACE("Event %x on handle %x\n",
1273 if( writefds
&& Socket
->SharedData
->NonBlocking
!= 0 )
1274 FD_SET(Handle
, writefds
);
1276 case AFD_EVENT_OOB_RECEIVE
:
1277 TRACE("Event %x on handle %x\n",
1280 if( readfds
&& Socket
->SharedData
->OobInline
!= 0 )
1281 FD_SET(Handle
, readfds
);
1282 if( exceptfds
&& Socket
->SharedData
->OobInline
== 0 )
1283 FD_SET(Handle
, exceptfds
);
1285 case AFD_EVENT_CONNECT_FAIL
:
1286 TRACE("Event %x on handle %x\n",
1289 if( exceptfds
&& Socket
->SharedData
->NonBlocking
!= 0 )
1290 FD_SET(Handle
, exceptfds
);
1296 HeapFree( GlobalHeap
, 0, PollBuffer
);
1297 NtClose( SockEvent
);
1301 switch( IOSB
.Status
)
1303 case STATUS_SUCCESS
:
1304 case STATUS_TIMEOUT
:
1308 *lpErrno
= WSAEINVAL
;
1311 TRACE("*lpErrno = %x\n", *lpErrno
);
1314 HandleCount
= (readfds
? readfds
->fd_count
: 0) +
1315 (writefds
&& writefds
!= readfds
? writefds
->fd_count
: 0) +
1316 (exceptfds
&& exceptfds
!= readfds
&& exceptfds
!= writefds
? exceptfds
->fd_count
: 0);
1318 TRACE("%d events\n", HandleCount
);
1324 GetCurrentTimeInSeconds()
1327 FILETIME Adjustment
;
1328 ULARGE_INTEGER lTime
, lAdj
;
1329 SYSTEMTIME st
= { 1970,1,0,1,0,0,0 };
1330 SystemTimeToFileTime(&st
, &Adjustment
);
1331 memcpy(&lAdj
, &Adjustment
, sizeof(lAdj
));
1332 GetSystemTimeAsFileTime(&Time
);
1333 memcpy(&lTime
, &Time
, sizeof(lTime
));
1334 lTime
.QuadPart
-= lAdj
.QuadPart
;
1335 return (DWORD
)(lTime
.QuadPart
/ 10000000LLU);
1340 WSPAccept(SOCKET Handle
,
1341 struct sockaddr
*SocketAddress
,
1342 int *SocketAddressLength
,
1343 LPCONDITIONPROC lpfnCondition
,
1344 DWORD dwCallbackData
,
1347 IO_STATUS_BLOCK IOSB
;
1348 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1349 AFD_ACCEPT_DATA AcceptData
;
1350 AFD_DEFER_ACCEPT_DATA DeferData
;
1351 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1352 PSOCKET_INFORMATION Socket
= NULL
;
1354 struct fd_set ReadSet
;
1355 struct timeval Timeout
;
1356 PVOID PendingData
= NULL
;
1357 ULONG PendingDataLength
= 0;
1358 PVOID CalleeDataBuffer
;
1359 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1360 PSOCKADDR RemoteAddress
= NULL
;
1363 SOCKET AcceptSocket
;
1364 PSOCKET_INFORMATION AcceptSocketInfo
;
1365 UCHAR ReceiveBuffer
[0x1A];
1368 /* Get the Socket Structure associate to this Socket*/
1369 Socket
= GetSocketStructure(Handle
);
1372 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1373 return SOCKET_ERROR
;
1375 if ((SocketAddress
&& !SocketAddressLength
) ||
1376 (SocketAddressLength
&& !SocketAddress
) ||
1377 (SocketAddressLength
&& *SocketAddressLength
< sizeof(SOCKADDR
)))
1379 if (lpErrno
) *lpErrno
= WSAEFAULT
;
1380 return INVALID_SOCKET
;
1383 Status
= NtCreateEvent(&SockEvent
,
1389 if( !NT_SUCCESS(Status
) )
1391 return SOCKET_ERROR
;
1394 /* Dynamic Structure...ugh */
1395 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1397 /* If this is non-blocking, make sure there's something for us to accept */
1399 FD_SET(Socket
->Handle
, &ReadSet
);
1403 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1406 return SOCKET_ERROR
;
1409 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1412 if (lpErrno
) *lpErrno
= WSAEWOULDBLOCK
;
1413 return SOCKET_ERROR
;
1417 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1422 IOCTL_AFD_WAIT_FOR_LISTEN
,
1426 0xA + sizeof(*ListenReceiveData
));
1428 /* Wait for return */
1429 if (Status
== STATUS_PENDING
)
1431 WaitForSingleObject(SockEvent
, INFINITE
);
1432 Status
= IOSB
.Status
;
1435 if (!NT_SUCCESS(Status
))
1437 NtClose( SockEvent
);
1438 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1441 if (lpfnCondition
!= NULL
)
1443 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1445 /* Find out how much data is pending */
1446 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1447 PendingAcceptData
.ReturnSize
= TRUE
;
1450 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1455 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1457 sizeof(PendingAcceptData
),
1459 sizeof(PendingAcceptData
));
1461 /* Wait for return */
1462 if (Status
== STATUS_PENDING
)
1464 WaitForSingleObject(SockEvent
, INFINITE
);
1465 Status
= IOSB
.Status
;
1468 if (!NT_SUCCESS(Status
))
1470 NtClose( SockEvent
);
1471 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1474 /* How much data to allocate */
1475 PendingDataLength
= IOSB
.Information
;
1477 if (PendingDataLength
)
1479 /* Allocate needed space */
1480 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1483 return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1486 /* We want the data now */
1487 PendingAcceptData
.ReturnSize
= FALSE
;
1490 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1495 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1497 sizeof(PendingAcceptData
),
1501 /* Wait for return */
1502 if (Status
== STATUS_PENDING
)
1504 WaitForSingleObject(SockEvent
, INFINITE
);
1505 Status
= IOSB
.Status
;
1508 if (!NT_SUCCESS(Status
))
1510 NtClose( SockEvent
);
1511 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1516 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1518 /* I don't support this yet */
1521 /* Build Callee ID */
1522 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1523 CalleeID
.len
= Socket
->SharedData
->SizeOfLocalAddress
;
1525 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1528 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1531 /* Set up Address in SOCKADDR Format */
1532 RtlCopyMemory (RemoteAddress
,
1533 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1534 sizeof(*RemoteAddress
));
1536 /* Build Caller ID */
1537 CallerID
.buf
= (PVOID
)RemoteAddress
;
1538 CallerID
.len
= sizeof(*RemoteAddress
);
1540 /* Build Caller Data */
1541 CallerData
.buf
= PendingData
;
1542 CallerData
.len
= PendingDataLength
;
1544 /* Check if socket supports Conditional Accept */
1545 if (Socket
->SharedData
->UseDelayedAcceptance
!= 0)
1547 /* Allocate Buffer for Callee Data */
1548 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1549 if (!CalleeDataBuffer
) {
1550 return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1552 CalleeData
.buf
= CalleeDataBuffer
;
1553 CalleeData
.len
= 4096;
1562 /* Call the Condition Function */
1563 CallBack
= (lpfnCondition
)(&CallerID
,
1564 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1568 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1572 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1574 /* TBD: Check for Validity */
1577 if (CallBack
== CF_ACCEPT
)
1579 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1581 /* I don't support this yet */
1585 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1590 /* Callback rejected. Build Defer Structure */
1591 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1592 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1595 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1600 IOCTL_AFD_DEFER_ACCEPT
,
1606 /* Wait for return */
1607 if (Status
== STATUS_PENDING
)
1609 WaitForSingleObject(SockEvent
, INFINITE
);
1610 Status
= IOSB
.Status
;
1613 NtClose( SockEvent
);
1615 if (!NT_SUCCESS(Status
))
1617 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1620 if (CallBack
== CF_REJECT
)
1622 if (lpErrno
) *lpErrno
= WSAECONNREFUSED
;
1623 return SOCKET_ERROR
;
1627 if (lpErrno
) *lpErrno
= WSAECONNREFUSED
;
1628 return SOCKET_ERROR
;
1633 /* Create a new Socket */
1634 AcceptSocket
= WSPSocket (Socket
->SharedData
->AddressFamily
,
1635 Socket
->SharedData
->SocketType
,
1636 Socket
->SharedData
->Protocol
,
1637 &Socket
->ProtocolInfo
,
1639 Socket
->SharedData
->CreateFlags
,
1641 if (AcceptSocket
== INVALID_SOCKET
)
1642 return SOCKET_ERROR
;
1644 /* Set up the Accept Structure */
1645 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1646 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1648 /* Send IOCTL to Accept */
1649 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1660 /* Wait for return */
1661 if (Status
== STATUS_PENDING
)
1663 WaitForSingleObject(SockEvent
, INFINITE
);
1664 Status
= IOSB
.Status
;
1667 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1668 if (!NT_SUCCESS(Status
))
1671 WSPCloseSocket( AcceptSocket
, lpErrno
);
1672 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1675 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1676 if (!AcceptSocketInfo
)
1679 WSPCloseSocket( AcceptSocket
, lpErrno
);
1680 return MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED
, lpErrno
, 0, NULL
);
1683 AcceptSocketInfo
->SharedData
->State
= SocketConnected
;
1684 AcceptSocketInfo
->SharedData
->ConnectTime
= GetCurrentTimeInSeconds();
1686 /* Return Address in SOCKADDR FORMAT */
1689 RtlCopyMemory (SocketAddress
,
1690 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1691 sizeof(*RemoteAddress
));
1692 if( SocketAddressLength
)
1693 *SocketAddressLength
= sizeof(*RemoteAddress
);
1696 NtClose( SockEvent
);
1698 /* Re-enable Async Event */
1699 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1701 TRACE("Socket %x\n", AcceptSocket
);
1703 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1705 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1707 Socket
->TdiAddressHandle
,
1708 Socket
->TdiConnectionHandle
,
1713 if (lpErrno
) *lpErrno
= Status
;
1714 return SOCKET_ERROR
;
1718 if (lpErrno
) *lpErrno
= NO_ERROR
;
1721 return AcceptSocket
;
1726 WSPConnect(SOCKET Handle
,
1727 const struct sockaddr
* SocketAddress
,
1728 int SocketAddressLength
,
1729 LPWSABUF lpCallerData
,
1730 LPWSABUF lpCalleeData
,
1735 IO_STATUS_BLOCK IOSB
;
1736 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1737 PSOCKET_INFORMATION Socket
;
1740 ULONG ConnectDataLength
;
1741 ULONG InConnectDataLength
;
1742 INT BindAddressLength
;
1743 PSOCKADDR BindAddress
;
1745 int SocketDataLength
;
1747 TRACE("Called (%lx) %lx:%d\n", Handle
, ((const struct sockaddr_in
*)SocketAddress
)->sin_addr
, ((const struct sockaddr_in
*)SocketAddress
)->sin_port
);
1749 /* Get the Socket Structure associate to this Socket*/
1750 Socket
= GetSocketStructure(Handle
);
1753 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1754 return SOCKET_ERROR
;
1757 Status
= NtCreateEvent(&SockEvent
,
1763 if (!NT_SUCCESS(Status
))
1764 return SOCKET_ERROR
;
1767 if (Socket
->SharedData
->State
== SocketOpen
)
1769 /* Get the Wildcard Address */
1770 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1771 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1775 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1777 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1779 &BindAddressLength
);
1781 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1782 return SOCKET_ERROR
;
1785 /* Set the Connect Data */
1786 if (lpCallerData
!= NULL
)
1788 ConnectDataLength
= lpCallerData
->len
;
1789 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1794 IOCTL_AFD_SET_CONNECT_DATA
,
1799 /* Wait for return */
1800 if (Status
== STATUS_PENDING
)
1802 WaitForSingleObject(SockEvent
, INFINITE
);
1803 Status
= IOSB
.Status
;
1806 if (Status
!= STATUS_SUCCESS
)
1810 /* Calculate the size of SocketAddress->sa_data */
1811 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1813 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1814 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1815 FIELD_OFFSET(AFD_CONNECT_INFO
,
1816 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1819 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1823 /* Set up Address in TDI Format */
1824 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1825 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1826 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1827 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1828 SocketAddress
->sa_data
,
1832 * Disable FD_WRITE and FD_CONNECT
1833 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1834 * at the end of this function right after the Async Thread disables it.
1835 * This should only happen at the *next* WSPConnect
1837 if (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
)
1839 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1842 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1843 if (lpCalleeData
!= NULL
)
1845 InConnectDataLength
= lpCalleeData
->len
;
1846 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1851 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1852 &InConnectDataLength
,
1853 sizeof(InConnectDataLength
),
1857 /* Wait for return */
1858 if (Status
== STATUS_PENDING
)
1860 WaitForSingleObject(SockEvent
, INFINITE
);
1861 Status
= IOSB
.Status
;
1864 if (Status
!= STATUS_SUCCESS
)
1868 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1869 ConnectInfo
->Root
= 0;
1870 ConnectInfo
->UseSAN
= FALSE
;
1871 ConnectInfo
->Unknown
= 0;
1873 /* FIXME: Handle Async Connect */
1874 if (Socket
->SharedData
->NonBlocking
)
1876 ERR("Async Connect UNIMPLEMENTED!\n");
1880 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1890 /* Wait for return */
1891 if (Status
== STATUS_PENDING
)
1893 WaitForSingleObject(SockEvent
, INFINITE
);
1894 Status
= IOSB
.Status
;
1897 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
1898 if (Status
!= STATUS_SUCCESS
)
1901 Socket
->SharedData
->State
= SocketConnected
;
1902 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1903 Socket
->SharedData
->ConnectTime
= GetCurrentTimeInSeconds();
1905 /* Get any pending connect data */
1906 if (lpCalleeData
!= NULL
)
1908 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1913 IOCTL_AFD_GET_CONNECT_DATA
,
1918 /* Wait for return */
1919 if (Status
== STATUS_PENDING
)
1921 WaitForSingleObject(SockEvent
, INFINITE
);
1922 Status
= IOSB
.Status
;
1926 TRACE("Ending %lx\n", IOSB
.Status
);
1929 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
1931 /* Re-enable Async Event */
1932 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1934 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1935 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1939 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1941 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1943 Socket
->TdiAddressHandle
,
1944 Socket
->TdiConnectionHandle
,
1945 WSH_NOTIFY_CONNECT
);
1949 if (lpErrno
) *lpErrno
= Errno
;
1950 return SOCKET_ERROR
;
1953 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1955 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1957 Socket
->TdiAddressHandle
,
1958 Socket
->TdiConnectionHandle
,
1959 WSH_NOTIFY_CONNECT_ERROR
);
1963 if (lpErrno
) *lpErrno
= Errno
;
1964 return SOCKET_ERROR
;
1968 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1972 WSPShutdown(SOCKET Handle
,
1977 IO_STATUS_BLOCK IOSB
;
1978 AFD_DISCONNECT_INFO DisconnectInfo
;
1979 PSOCKET_INFORMATION Socket
= NULL
;
1985 /* Get the Socket Structure associate to this Socket*/
1986 Socket
= GetSocketStructure(Handle
);
1989 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1990 return SOCKET_ERROR
;
1993 Status
= NtCreateEvent(&SockEvent
,
1999 if( !NT_SUCCESS(Status
) )
2000 return SOCKET_ERROR
;
2002 /* Set AFD Disconnect Type */
2006 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
2007 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
2010 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
2011 Socket
->SharedData
->SendShutdown
= TRUE
;
2014 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
2015 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
2016 Socket
->SharedData
->SendShutdown
= TRUE
;
2020 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
2023 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
2028 IOCTL_AFD_DISCONNECT
,
2030 sizeof(DisconnectInfo
),
2034 /* Wait for return */
2035 if (Status
== STATUS_PENDING
)
2037 WaitForSingleObject(SockEvent
, INFINITE
);
2038 Status
= IOSB
.Status
;
2043 NtClose( SockEvent
);
2045 Socket
->SharedData
->SocketLastError
= TranslateNtStatusError(Status
);
2046 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
2052 WSPGetSockName(IN SOCKET Handle
,
2053 OUT LPSOCKADDR Name
,
2054 IN OUT LPINT NameLength
,
2057 IO_STATUS_BLOCK IOSB
;
2058 ULONG TdiAddressSize
;
2059 PTDI_ADDRESS_INFO TdiAddress
;
2060 PTRANSPORT_ADDRESS SocketAddress
;
2061 PSOCKET_INFORMATION Socket
= NULL
;
2065 /* Get the Socket Structure associate to this Socket*/
2066 Socket
= GetSocketStructure(Handle
);
2069 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2070 return SOCKET_ERROR
;
2073 if (!Name
|| !NameLength
)
2075 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2076 return SOCKET_ERROR
;
2079 Status
= NtCreateEvent(&SockEvent
,
2085 if( !NT_SUCCESS(Status
) )
2086 return SOCKET_ERROR
;
2088 /* Allocate a buffer for the address */
2090 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfLocalAddress
;
2091 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2093 if ( TdiAddress
== NULL
)
2095 NtClose( SockEvent
);
2096 if (lpErrno
) *lpErrno
= WSAENOBUFS
;
2097 return SOCKET_ERROR
;
2100 SocketAddress
= &TdiAddress
->Address
;
2103 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2108 IOCTL_AFD_GET_SOCK_NAME
,
2114 /* Wait for return */
2115 if (Status
== STATUS_PENDING
)
2117 WaitForSingleObject(SockEvent
, INFINITE
);
2118 Status
= IOSB
.Status
;
2121 NtClose( SockEvent
);
2123 if (NT_SUCCESS(Status
))
2125 if (*NameLength
>= Socket
->SharedData
->SizeOfLocalAddress
)
2127 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2128 RtlCopyMemory (Name
->sa_data
,
2129 SocketAddress
->Address
[0].Address
,
2130 SocketAddress
->Address
[0].AddressLength
);
2131 *NameLength
= Socket
->SharedData
->SizeOfLocalAddress
;
2132 TRACE("NameLength %d Address: %x Port %x\n",
2133 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2134 ((struct sockaddr_in
*)Name
)->sin_port
);
2135 HeapFree(GlobalHeap
, 0, TdiAddress
);
2140 HeapFree(GlobalHeap
, 0, TdiAddress
);
2141 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2142 return SOCKET_ERROR
;
2146 HeapFree(GlobalHeap
, 0, TdiAddress
);
2148 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2154 WSPGetPeerName(IN SOCKET s
,
2155 OUT LPSOCKADDR Name
,
2156 IN OUT LPINT NameLength
,
2159 IO_STATUS_BLOCK IOSB
;
2160 ULONG TdiAddressSize
;
2161 PTRANSPORT_ADDRESS SocketAddress
;
2162 PSOCKET_INFORMATION Socket
= NULL
;
2166 /* Get the Socket Structure associate to this Socket*/
2167 Socket
= GetSocketStructure(s
);
2170 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2171 return SOCKET_ERROR
;
2174 if (Socket
->SharedData
->State
!= SocketConnected
)
2176 if (lpErrno
) *lpErrno
= WSAENOTCONN
;
2177 return SOCKET_ERROR
;
2180 if (!Name
|| !NameLength
)
2182 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2183 return SOCKET_ERROR
;
2186 Status
= NtCreateEvent(&SockEvent
,
2192 if( !NT_SUCCESS(Status
) )
2193 return SOCKET_ERROR
;
2195 /* Allocate a buffer for the address */
2196 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfRemoteAddress
;
2197 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2199 if ( SocketAddress
== NULL
)
2201 NtClose( SockEvent
);
2202 if (lpErrno
) *lpErrno
= WSAENOBUFS
;
2203 return SOCKET_ERROR
;
2207 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2212 IOCTL_AFD_GET_PEER_NAME
,
2218 /* Wait for return */
2219 if (Status
== STATUS_PENDING
)
2221 WaitForSingleObject(SockEvent
, INFINITE
);
2222 Status
= IOSB
.Status
;
2225 NtClose( SockEvent
);
2227 if (NT_SUCCESS(Status
))
2229 if (*NameLength
>= Socket
->SharedData
->SizeOfRemoteAddress
)
2231 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2232 RtlCopyMemory (Name
->sa_data
,
2233 SocketAddress
->Address
[0].Address
,
2234 SocketAddress
->Address
[0].AddressLength
);
2235 *NameLength
= Socket
->SharedData
->SizeOfRemoteAddress
;
2236 TRACE("NameLength %d Address: %x Port %x\n",
2237 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2238 ((struct sockaddr_in
*)Name
)->sin_port
);
2239 HeapFree(GlobalHeap
, 0, SocketAddress
);
2244 HeapFree(GlobalHeap
, 0, SocketAddress
);
2245 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2246 return SOCKET_ERROR
;
2250 HeapFree(GlobalHeap
, 0, SocketAddress
);
2252 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2257 WSPIoctl(IN SOCKET Handle
,
2258 IN DWORD dwIoControlCode
,
2259 IN LPVOID lpvInBuffer
,
2260 IN DWORD cbInBuffer
,
2261 OUT LPVOID lpvOutBuffer
,
2262 IN DWORD cbOutBuffer
,
2263 OUT LPDWORD lpcbBytesReturned
,
2264 IN LPWSAOVERLAPPED lpOverlapped
,
2265 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
2266 IN LPWSATHREADID lpThreadId
,
2269 PSOCKET_INFORMATION Socket
= NULL
;
2270 BOOL NeedsCompletion
= lpOverlapped
!= NULL
;
2271 BOOLEAN NonBlocking
;
2272 INT Errno
= NO_ERROR
, Ret
= SOCKET_ERROR
;
2275 /* Get the Socket Structure associate to this Socket*/
2276 Socket
= GetSocketStructure(Handle
);
2280 *lpErrno
= WSAENOTSOCK
;
2281 return SOCKET_ERROR
;
2284 if (!lpcbBytesReturned
&& !lpOverlapped
)
2287 *lpErrno
= WSAEFAULT
;
2288 return SOCKET_ERROR
;
2291 switch( dwIoControlCode
)
2294 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2299 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2300 /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
2303 /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
2304 if (Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
))
2309 /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
2310 if (Socket
->NetworkEvents
)
2316 Socket
->SharedData
->NonBlocking
= NonBlocking
? 1 : 0;
2317 NeedsCompletion
= FALSE
;
2318 Errno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2319 if (Errno
== NO_ERROR
)
2323 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2325 cbRet
= sizeof(ULONG
);
2329 if (cbOutBuffer
< sizeof(ULONG
))
2334 NeedsCompletion
= FALSE
;
2335 Errno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2336 if (Errno
== NO_ERROR
)
2338 cbRet
= sizeof(ULONG
);
2343 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2345 cbRet
= sizeof(BOOL
);
2349 if (cbOutBuffer
< sizeof(BOOL
))
2354 if (Socket
->SharedData
->SocketType
!= SOCK_STREAM
)
2360 /* FIXME: Return false if OOBINLINE is true for now
2361 We should MSG_PEEK|MSG_OOB check with driver
2363 *(BOOL
*)lpvOutBuffer
= !Socket
->SharedData
->OobInline
;
2365 cbRet
= sizeof(BOOL
);
2369 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2372 case SIO_ADDRESS_LIST_QUERY
:
2373 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2375 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2379 if (cbOutBuffer
< sizeof(INT
))
2385 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2387 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->iAddressCount
= 1;
2389 if (cbOutBuffer
< (sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
)))
2395 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].iSockaddrLength
= sizeof(Socket
->SharedData
->WSLocalAddress
);
2396 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].lpSockaddr
= &Socket
->SharedData
->WSLocalAddress
;
2402 Errno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2404 Socket
->TdiAddressHandle
,
2405 Socket
->TdiConnectionHandle
,
2413 lpCompletionRoutine
,
2416 if (Errno
== NO_ERROR
)
2420 if (lpOverlapped
&& NeedsCompletion
)
2422 lpOverlapped
->Internal
= Errno
;
2423 lpOverlapped
->InternalHigh
= cbRet
;
2424 if (lpCompletionRoutine
!= NULL
)
2426 lpCompletionRoutine(Errno
, cbRet
, lpOverlapped
, 0);
2428 if (lpOverlapped
->hEvent
)
2429 SetEvent(lpOverlapped
->hEvent
);
2430 if (!PostQueuedCompletionStatus((HANDLE
)Handle
, cbRet
, 0, lpOverlapped
))
2432 ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
2438 if (lpcbBytesReturned
)
2439 *lpcbBytesReturned
= cbRet
;
2446 WSPGetSockOpt(IN SOCKET Handle
,
2449 OUT CHAR FAR
* OptionValue
,
2450 IN OUT LPINT OptionLength
,
2453 PSOCKET_INFORMATION Socket
= NULL
;
2462 /* Get the Socket Structure associate to this Socket*/
2463 Socket
= GetSocketStructure(Handle
);
2466 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2467 return SOCKET_ERROR
;
2469 if (!OptionLength
|| !OptionValue
)
2471 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2472 return SOCKET_ERROR
;
2481 Buffer
= &Socket
->SharedData
->SocketType
;
2482 BufferSize
= sizeof(INT
);
2486 Buffer
= &Socket
->SharedData
->SizeOfRecvBuffer
;
2487 BufferSize
= sizeof(INT
);
2491 Buffer
= &Socket
->SharedData
->SizeOfSendBuffer
;
2492 BufferSize
= sizeof(INT
);
2496 BoolBuffer
= Socket
->SharedData
->Listening
;
2497 Buffer
= &BoolBuffer
;
2498 BufferSize
= sizeof(BOOL
);
2502 BoolBuffer
= Socket
->SharedData
->Broadcast
;
2503 Buffer
= &BoolBuffer
;
2504 BufferSize
= sizeof(BOOL
);
2508 BoolBuffer
= Socket
->SharedData
->Debug
;
2509 Buffer
= &BoolBuffer
;
2510 BufferSize
= sizeof(BOOL
);
2514 BoolBuffer
= (Socket
->SharedData
->LingerData
.l_onoff
== 0);
2515 Buffer
= &BoolBuffer
;
2516 BufferSize
= sizeof(BOOL
);
2520 if (Socket
->SharedData
->SocketType
== SOCK_DGRAM
)
2522 if (lpErrno
) *lpErrno
= WSAENOPROTOOPT
;
2523 return SOCKET_ERROR
;
2525 Buffer
= &Socket
->SharedData
->LingerData
;
2526 BufferSize
= sizeof(struct linger
);
2530 BoolBuffer
= (Socket
->SharedData
->OobInline
!= 0);
2531 Buffer
= &BoolBuffer
;
2532 BufferSize
= sizeof(BOOL
);
2537 /* These guys go directly to the helper */
2540 case SO_CONDITIONAL_ACCEPT
:
2541 BoolBuffer
= (Socket
->SharedData
->UseDelayedAcceptance
!= 0);
2542 Buffer
= &BoolBuffer
;
2543 BufferSize
= sizeof(BOOL
);
2547 BoolBuffer
= (Socket
->SharedData
->ReuseAddresses
!= 0);
2548 Buffer
= &BoolBuffer
;
2549 BufferSize
= sizeof(BOOL
);
2552 case SO_EXCLUSIVEADDRUSE
:
2553 BoolBuffer
= (Socket
->SharedData
->ExclusiveAddressUse
!= 0);
2554 Buffer
= &BoolBuffer
;
2555 BufferSize
= sizeof(BOOL
);
2559 Buffer
= &Socket
->SharedData
->SocketLastError
;
2560 BufferSize
= sizeof(INT
);
2563 case SO_CONNECT_TIME
:
2564 DwordBuffer
= GetCurrentTimeInSeconds() - Socket
->SharedData
->ConnectTime
;
2565 Buffer
= &DwordBuffer
;
2566 BufferSize
= sizeof(DWORD
);
2570 Buffer
= &Socket
->SharedData
->SendTimeout
;
2571 BufferSize
= sizeof(DWORD
);
2574 Buffer
= &Socket
->SharedData
->RecvTimeout
;
2575 BufferSize
= sizeof(DWORD
);
2577 case SO_PROTOCOL_INFOW
:
2578 Buffer
= &Socket
->ProtocolInfo
;
2579 BufferSize
= sizeof(Socket
->ProtocolInfo
);
2583 case SO_GROUP_PRIORITY
:
2584 case SO_MAX_MSG_SIZE
:
2587 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2588 if (lpErrno
) *lpErrno
= WSAENOPROTOOPT
;
2589 return SOCKET_ERROR
;
2592 if (*OptionLength
< BufferSize
)
2594 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2595 *OptionLength
= BufferSize
;
2596 return SOCKET_ERROR
;
2598 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2603 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2604 return SOCKET_ERROR
;
2608 Errno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2610 Socket
->TdiAddressHandle
,
2611 Socket
->TdiConnectionHandle
,
2615 (LPINT
)OptionLength
);
2616 if (lpErrno
) *lpErrno
= Errno
;
2617 return (Errno
== NO_ERROR
) ? NO_ERROR
: SOCKET_ERROR
;
2626 IN CONST CHAR FAR
* optval
,
2630 PSOCKET_INFORMATION Socket
;
2633 /* Get the Socket Structure associate to this Socket*/
2634 Socket
= GetSocketStructure(s
);
2637 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
2638 return SOCKET_ERROR
;
2642 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2643 return SOCKET_ERROR
;
2647 /* FIXME: We should handle some more cases here */
2648 if (level
== SOL_SOCKET
)
2653 if (optlen
< sizeof(BOOL
))
2655 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2656 return SOCKET_ERROR
;
2658 Socket
->SharedData
->Broadcast
= (*optval
!= 0) ? 1 : 0;
2662 if (optlen
< sizeof(BOOL
))
2664 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2665 return SOCKET_ERROR
;
2667 Socket
->SharedData
->OobInline
= (*optval
!= 0) ? 1 : 0;
2671 if (optlen
< sizeof(BOOL
))
2673 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2674 return SOCKET_ERROR
;
2676 Socket
->SharedData
->LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2680 if (optlen
< sizeof(BOOL
))
2682 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2683 return SOCKET_ERROR
;
2685 Socket
->SharedData
->ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2688 case SO_EXCLUSIVEADDRUSE
:
2689 if (optlen
< sizeof(BOOL
))
2691 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2692 return SOCKET_ERROR
;
2694 Socket
->SharedData
->ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2698 if (optlen
< sizeof(struct linger
))
2700 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2701 return SOCKET_ERROR
;
2703 RtlCopyMemory(&Socket
->SharedData
->LingerData
,
2705 sizeof(struct linger
));
2709 if (optlen
< sizeof(DWORD
))
2711 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2712 return SOCKET_ERROR
;
2715 /* TODO: The total per-socket buffer space reserved for sends */
2716 ERR("Setting send buf to %x is not implemented yet\n", optval
);
2720 if (optlen
< sizeof(INT
))
2722 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2723 return SOCKET_ERROR
;
2726 RtlCopyMemory(&Socket
->SharedData
->SocketLastError
,
2732 if (optlen
< sizeof(DWORD
))
2734 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2735 return SOCKET_ERROR
;
2738 RtlCopyMemory(&Socket
->SharedData
->SendTimeout
,
2744 if (optlen
< sizeof(DWORD
))
2746 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2747 return SOCKET_ERROR
;
2750 RtlCopyMemory(&Socket
->SharedData
->RecvTimeout
,
2757 /* These go directly to the helper dll */
2761 /* Obviously this is a hack */
2762 ERR("MSAFD: Set unknown optname %x\n", optname
);
2768 Errno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2770 Socket
->TdiAddressHandle
,
2771 Socket
->TdiConnectionHandle
,
2776 if (lpErrno
) *lpErrno
= Errno
;
2777 return (Errno
== NO_ERROR
) ? NO_ERROR
: SOCKET_ERROR
;
2781 * FUNCTION: Initialize service provider for a client
2783 * wVersionRequested = Highest WinSock SPI version that the caller can use
2784 * lpWSPData = Address of WSPDATA structure to initialize
2785 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2786 * UpcallTable = Pointer to upcall table of the WinSock DLL
2787 * lpProcTable = Address of procedure table to initialize
2789 * Status of operation
2793 WSPStartup(IN WORD wVersionRequested
,
2794 OUT LPWSPDATA lpWSPData
,
2795 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2796 IN WSPUPCALLTABLE UpcallTable
,
2797 OUT LPWSPPROC_TABLE lpProcTable
)
2802 if (((LOBYTE(wVersionRequested
) == 2) && (HIBYTE(wVersionRequested
) < 2)) ||
2803 (LOBYTE(wVersionRequested
) < 2))
2805 ERR("WSPStartup NOT SUPPORTED for version 0x%X\n", wVersionRequested
);
2806 return WSAVERNOTSUPPORTED
;
2810 /* FIXME: Enable all cases of WSPStartup status */
2811 Upcalls
= UpcallTable
;
2813 if (Status
== NO_ERROR
)
2815 lpProcTable
->lpWSPAccept
= WSPAccept
;
2816 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2817 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2818 lpProcTable
->lpWSPBind
= WSPBind
;
2819 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2820 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2821 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2822 lpProcTable
->lpWSPConnect
= WSPConnect
;
2823 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2824 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2825 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2826 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2827 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2828 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2829 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2830 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2831 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2832 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2833 lpProcTable
->lpWSPListen
= WSPListen
;
2834 lpProcTable
->lpWSPRecv
= WSPRecv
;
2835 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2836 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2837 lpProcTable
->lpWSPSelect
= WSPSelect
;
2838 lpProcTable
->lpWSPSend
= WSPSend
;
2839 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2840 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2841 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2842 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2843 lpProcTable
->lpWSPSocket
= WSPSocket
;
2844 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2845 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2846 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2847 /* Save CatalogEntryId for all upcalls */
2848 CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
2851 TRACE("Status (%d).\n", Status
);
2858 WSPAddressToString(IN LPSOCKADDR lpsaAddress
,
2859 IN DWORD dwAddressLength
,
2860 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2861 OUT LPWSTR lpszAddressString
,
2862 IN OUT LPDWORD lpdwAddressStringLength
,
2866 WCHAR buffer
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2869 if (!lpsaAddress
|| !lpszAddressString
|| !lpdwAddressStringLength
)
2871 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2872 return SOCKET_ERROR
;
2875 switch (lpsaAddress
->sa_family
)
2878 if (dwAddressLength
< sizeof(SOCKADDR_IN
))
2880 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2881 return SOCKET_ERROR
;
2885 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 24 & 0xff),
2886 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 16 & 0xff),
2887 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 8 & 0xff),
2888 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) & 0xff),
2889 ntohs(((SOCKADDR_IN
*)lpsaAddress
)->sin_port
));
2891 p
= wcschr(buffer
, L
':');
2892 if (!((SOCKADDR_IN
*)lpsaAddress
)->sin_port
)
2898 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2899 return SOCKET_ERROR
;
2902 size
= wcslen(buffer
) + 1;
2904 if (*lpdwAddressStringLength
< size
)
2906 *lpdwAddressStringLength
= size
;
2907 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2908 return SOCKET_ERROR
;
2911 *lpdwAddressStringLength
= size
;
2912 wcscpy(lpszAddressString
, buffer
);
2918 WSPStringToAddress(IN LPWSTR AddressString
,
2919 IN INT AddressFamily
,
2920 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2921 OUT LPSOCKADDR lpAddress
,
2922 IN OUT LPINT lpAddressLength
,
2927 LONG inetaddr
= 0, ip_part
;
2929 SOCKADDR_IN
*sockaddr
;
2931 if (!lpAddressLength
|| !lpAddress
|| !AddressString
)
2933 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2934 return SOCKET_ERROR
;
2937 sockaddr
= (SOCKADDR_IN
*)lpAddress
;
2939 /* Set right address family */
2940 if (lpProtocolInfo
!= NULL
)
2942 sockaddr
->sin_family
= lpProtocolInfo
->iAddressFamily
;
2946 sockaddr
->sin_family
= AddressFamily
;
2950 if (AddressFamily
== AF_INET
)
2952 if (*lpAddressLength
< (INT
)sizeof(SOCKADDR_IN
))
2954 if (lpErrno
) *lpErrno
= WSAEFAULT
;
2958 // translate ip string to ip
2961 bp
= &AddressString
;
2964 while (*bp
< &AddressString
[wcslen(AddressString
)])
2966 ip_part
= wcstol(*bp
, bp
, 10);
2967 /* ip part number should be in range 0-255 */
2968 if (ip_part
< 0 || ip_part
> 255)
2970 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2971 return SOCKET_ERROR
;
2973 inetaddr
= (inetaddr
<< 8) + ip_part
;
2974 /* we end on string end or port separator */
2975 if ((*bp
)[0] == 0 || (*bp
)[0] == L
':')
2977 /* ip parts are dot separated. verify it */
2978 if ((*bp
)[0] != L
'.')
2980 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2981 return SOCKET_ERROR
;
2983 /* count the dots */
2985 /* move over the dot to next ip part */
2989 /* check dots count */
2992 if (lpErrno
) *lpErrno
= WSAEINVAL
;
2993 return SOCKET_ERROR
;
2996 /* Get port number */
2997 if ((*bp
)[0] == L
':')
2999 /* move over the column to port part */
3001 /* next char should be numeric */
3002 if ((*bp
)[0] < L
'0' || (*bp
)[0] > L
'9')
3004 if (lpErrno
) *lpErrno
= WSAEINVAL
;
3005 return SOCKET_ERROR
;
3007 port
= wcstol(*bp
, bp
, 10);
3014 if (lpErrno
) *lpErrno
= NO_ERROR
;
3015 /* rest sockaddr.sin_addr.s_addr
3016 for we need to be sure it is zero when we come to while */
3017 *lpAddressLength
= sizeof(*sockaddr
);
3018 memset(lpAddress
, 0, sizeof(*sockaddr
));
3019 sockaddr
->sin_family
= AF_INET
;
3020 sockaddr
->sin_addr
.s_addr
= inetaddr
;
3021 sockaddr
->sin_port
= port
;
3025 if (lpErrno
&& !*lpErrno
)
3030 return SOCKET_ERROR
;
3034 * FUNCTION: Cleans up service provider for a client
3036 * lpErrno = Address of buffer for error information
3038 * 0 if successful, or SOCKET_ERROR if not
3042 WSPCleanup(OUT LPINT lpErrno
)
3045 TRACE("Leaving.\n");
3047 if (lpErrno
) *lpErrno
= NO_ERROR
;
3054 AfdInfoAPC(PVOID ApcContext
,
3055 PIO_STATUS_BLOCK IoStatusBlock
,
3058 PAFDAPCCONTEXT Context
= ApcContext
;
3060 Context
->lpCompletionRoutine(IoStatusBlock
->Status
, IoStatusBlock
->Information
, Context
->lpOverlapped
, 0);
3061 HeapFree(GlobalHeap
, 0, ApcContext
);
3065 GetSocketInformation(PSOCKET_INFORMATION Socket
,
3066 ULONG AfdInformationClass
,
3067 PBOOLEAN Boolean OPTIONAL
,
3068 PULONG Ulong OPTIONAL
,
3069 PLARGE_INTEGER LargeInteger OPTIONAL
,
3070 LPWSAOVERLAPPED Overlapped OPTIONAL
,
3071 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
3073 PIO_STATUS_BLOCK IOSB
;
3074 IO_STATUS_BLOCK DummyIOSB
;
3077 PAFDAPCCONTEXT APCContext
;
3078 PIO_APC_ROUTINE APCFunction
;
3079 HANDLE Event
= NULL
;
3082 Status
= NtCreateEvent(&SockEvent
,
3088 if( !NT_SUCCESS(Status
) )
3089 return SOCKET_ERROR
;
3091 /* Set Info Class */
3092 InfoData
.InformationClass
= AfdInformationClass
;
3094 /* Verify if we should use APC */
3095 if (Overlapped
== NULL
)
3097 /* Not using Overlapped structure, so use normal blocking on event */
3105 /* Overlapped request for non overlapped opened socket */
3106 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
3108 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3111 if (CompletionRoutine
== NULL
)
3113 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3114 APCContext
= (PAFDAPCCONTEXT
)Overlapped
;
3116 Event
= Overlapped
->hEvent
;
3120 /* Using Overlapped Structure and a Completition Routine, so use an APC */
3121 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
3122 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
3125 ERR("Not enough memory for APC Context\n");
3128 APCContext
->lpCompletionRoutine
= CompletionRoutine
;
3129 APCContext
->lpOverlapped
= Overlapped
;
3130 APCContext
->lpSocket
= Socket
;
3133 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
3136 IOSB
->Status
= STATUS_PENDING
;
3139 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3150 /* Wait for return */
3151 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
3153 WaitForSingleObject(SockEvent
, INFINITE
);
3154 Status
= IOSB
->Status
;
3157 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
3159 if (Status
== STATUS_PENDING
)
3161 TRACE("Leaving (Pending)\n");
3162 return WSA_IO_PENDING
;
3165 if (Status
!= STATUS_SUCCESS
)
3166 return SOCKET_ERROR
;
3168 /* Return Information */
3171 *Ulong
= InfoData
.Information
.Ulong
;
3173 if (LargeInteger
!= NULL
)
3175 *LargeInteger
= InfoData
.Information
.LargeInteger
;
3177 if (Boolean
!= NULL
)
3179 *Boolean
= InfoData
.Information
.Boolean
;
3182 NtClose( SockEvent
);
3190 SetSocketInformation(PSOCKET_INFORMATION Socket
,
3191 ULONG AfdInformationClass
,
3192 PBOOLEAN Boolean OPTIONAL
,
3193 PULONG Ulong OPTIONAL
,
3194 PLARGE_INTEGER LargeInteger OPTIONAL
,
3195 LPWSAOVERLAPPED Overlapped OPTIONAL
,
3196 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
3198 PIO_STATUS_BLOCK IOSB
;
3199 IO_STATUS_BLOCK DummyIOSB
;
3202 PAFDAPCCONTEXT APCContext
;
3203 PIO_APC_ROUTINE APCFunction
;
3204 HANDLE Event
= NULL
;
3207 Status
= NtCreateEvent(&SockEvent
,
3213 if( !NT_SUCCESS(Status
) )
3214 return SOCKET_ERROR
;
3216 /* Set Info Class */
3217 InfoData
.InformationClass
= AfdInformationClass
;
3219 /* Set Information */
3222 InfoData
.Information
.Ulong
= *Ulong
;
3224 if (LargeInteger
!= NULL
)
3226 InfoData
.Information
.LargeInteger
= *LargeInteger
;
3228 if (Boolean
!= NULL
)
3230 InfoData
.Information
.Boolean
= *Boolean
;
3233 /* Verify if we should use APC */
3234 if (Overlapped
== NULL
)
3236 /* Not using Overlapped structure, so use normal blocking on event */
3244 /* Overlapped request for non overlapped opened socket */
3245 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
3247 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3250 if (CompletionRoutine
== NULL
)
3252 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3253 APCContext
= (PAFDAPCCONTEXT
)Overlapped
;
3255 Event
= Overlapped
->hEvent
;
3259 /* Using Overlapped Structure and a Completition Routine, so use an APC */
3260 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
3261 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
3264 ERR("Not enough memory for APC Context\n");
3267 APCContext
->lpCompletionRoutine
= CompletionRoutine
;
3268 APCContext
->lpOverlapped
= Overlapped
;
3269 APCContext
->lpSocket
= Socket
;
3272 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
3275 IOSB
->Status
= STATUS_PENDING
;
3278 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3289 /* Wait for return */
3290 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
3292 WaitForSingleObject(SockEvent
, INFINITE
);
3293 Status
= IOSB
->Status
;
3296 NtClose( SockEvent
);
3298 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
3300 if (Status
== STATUS_PENDING
)
3302 TRACE("Leaving (Pending)\n");
3303 return WSA_IO_PENDING
;
3306 return Status
== STATUS_SUCCESS
? NO_ERROR
: SOCKET_ERROR
;
3311 GetSocketStructure(SOCKET Handle
)
3313 PSOCKET_INFORMATION CurrentSocket
;
3315 EnterCriticalSection(&SocketListLock
);
3317 CurrentSocket
= SocketListHead
;
3318 while (CurrentSocket
)
3320 if (CurrentSocket
->Handle
== Handle
)
3322 LeaveCriticalSection(&SocketListLock
);
3323 return CurrentSocket
;
3326 CurrentSocket
= CurrentSocket
->NextSocket
;
3329 LeaveCriticalSection(&SocketListLock
);
3334 int CreateContext(PSOCKET_INFORMATION Socket
)
3336 IO_STATUS_BLOCK IOSB
;
3337 SOCKET_CONTEXT ContextData
;
3341 Status
= NtCreateEvent(&SockEvent
,
3347 if( !NT_SUCCESS(Status
) )
3348 return SOCKET_ERROR
;
3350 /* Create Context */
3351 ContextData
.SharedData
= *Socket
->SharedData
;
3352 ContextData
.SizeOfHelperData
= 0;
3353 RtlCopyMemory (&ContextData
.LocalAddress
,
3354 Socket
->LocalAddress
,
3355 Socket
->SharedData
->SizeOfLocalAddress
);
3356 RtlCopyMemory (&ContextData
.RemoteAddress
,
3357 Socket
->RemoteAddress
,
3358 Socket
->SharedData
->SizeOfRemoteAddress
);
3361 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3366 IOCTL_AFD_SET_CONTEXT
,
3368 sizeof(ContextData
),
3372 /* Wait for Completition */
3373 if (Status
== STATUS_PENDING
)
3375 WaitForSingleObject(SockEvent
, INFINITE
);
3376 Status
= IOSB
.Status
;
3379 NtClose( SockEvent
);
3381 return Status
== STATUS_SUCCESS
? NO_ERROR
: SOCKET_ERROR
;
3384 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
3386 HANDLE hAsyncThread
;
3387 DWORD AsyncThreadId
;
3389 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3392 /* Check if the Thread Already Exists */
3393 if (SockAsyncThreadRefCount
)
3395 ASSERT(SockAsyncCompletionPort
);
3399 /* Create the Completion Port */
3400 if (!SockAsyncCompletionPort
)
3402 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
3403 IO_COMPLETION_ALL_ACCESS
,
3405 2); // Allow 2 threads only
3406 if (!NT_SUCCESS(Status
))
3408 ERR("Failed to create completion port: 0x%08x\n", Status
);
3411 /* Protect Handle */
3412 HandleFlags
.ProtectFromClose
= TRUE
;
3413 HandleFlags
.Inherit
= FALSE
;
3414 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
3415 ObjectHandleFlagInformation
,
3417 sizeof(HandleFlags
));
3420 /* Create the Async Event */
3421 Status
= NtCreateEvent(&AsyncEvent
,
3427 /* Create the Async Thread */
3428 hAsyncThread
= CreateThread(NULL
,
3430 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
3435 /* Close the Handle */
3436 NtClose(hAsyncThread
);
3438 /* Increase the Reference Count */
3439 SockAsyncThreadRefCount
++;
3443 int SockAsyncThread(PVOID ThreadParam
)
3446 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
3447 IO_STATUS_BLOCK IOSB
;
3450 /* Make the Thread Higher Priority */
3451 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
3453 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3456 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
3457 (PVOID
*)&AsyncCompletionRoutine
,
3461 /* Call the Async Function */
3462 if (NT_SUCCESS(Status
))
3464 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
3468 /* It Failed, sleep for a second */
3471 } while ((Status
!= STATUS_TIMEOUT
));
3473 /* The Thread has Ended */
3477 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
3479 UNICODE_STRING AfdHelper
;
3480 OBJECT_ATTRIBUTES ObjectAttributes
;
3481 IO_STATUS_BLOCK IoSb
;
3482 FILE_COMPLETION_INFORMATION CompletionInfo
;
3483 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3485 /* First, make sure we're not already intialized */
3486 if (SockAsyncHelperAfdHandle
)
3491 /* Set up Handle Name and Object */
3492 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
3493 InitializeObjectAttributes(&ObjectAttributes
,
3495 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
3499 /* Open the Handle to AFD */
3500 NtCreateFile(&SockAsyncHelperAfdHandle
,
3501 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
3506 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3513 * Now Set up the Completion Port Information
3514 * This means that whenever a Poll is finished, the routine will be executed
3516 CompletionInfo
.Port
= SockAsyncCompletionPort
;
3517 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
3518 NtSetInformationFile(SockAsyncHelperAfdHandle
,
3521 sizeof(CompletionInfo
),
3522 FileCompletionInformation
);
3525 /* Protect the Handle */
3526 HandleFlags
.ProtectFromClose
= TRUE
;
3527 HandleFlags
.Inherit
= FALSE
;
3528 NtSetInformationObject(SockAsyncCompletionPort
,
3529 ObjectHandleFlagInformation
,
3531 sizeof(HandleFlags
));
3534 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
3535 SockAsyncSelectCalled
= TRUE
;
3539 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3542 PASYNC_DATA AsyncData
= Context
;
3543 PSOCKET_INFORMATION Socket
;
3546 /* Get the Socket */
3547 Socket
= AsyncData
->ParentSocket
;
3549 /* Check if the Sequence Number Changed behind our back */
3550 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
->SequenceNumber
)
3555 /* Check we were manually called b/c of a failure */
3556 if (!NT_SUCCESS(IoStatusBlock
->Status
))
3558 /* FIXME: Perform Upcall */
3562 for (x
= 1; x
; x
<<=1)
3564 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
3566 case AFD_EVENT_RECEIVE
:
3567 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_READ
) &&
3568 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_READ
))
3570 /* Make the Notifcation */
3571 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3572 Socket
->SharedData
->wMsg
,
3574 WSAMAKESELECTREPLY(FD_READ
, 0));
3575 /* Disable this event until the next read(); */
3576 Socket
->SharedData
->AsyncDisabledEvents
|= FD_READ
;
3580 case AFD_EVENT_OOB_RECEIVE
:
3581 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_OOB
) &&
3582 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_OOB
))
3584 /* Make the Notifcation */
3585 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3586 Socket
->SharedData
->wMsg
,
3588 WSAMAKESELECTREPLY(FD_OOB
, 0));
3589 /* Disable this event until the next read(); */
3590 Socket
->SharedData
->AsyncDisabledEvents
|= FD_OOB
;
3594 case AFD_EVENT_SEND
:
3595 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_WRITE
) &&
3596 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_WRITE
))
3598 /* Make the Notifcation */
3599 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3600 Socket
->SharedData
->wMsg
,
3602 WSAMAKESELECTREPLY(FD_WRITE
, 0));
3603 /* Disable this event until the next write(); */
3604 Socket
->SharedData
->AsyncDisabledEvents
|= FD_WRITE
;
3608 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3609 case AFD_EVENT_CONNECT
:
3610 case AFD_EVENT_CONNECT_FAIL
:
3611 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
) &&
3612 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CONNECT
))
3614 /* Make the Notifcation */
3615 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3616 Socket
->SharedData
->wMsg
,
3618 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
3619 /* Disable this event forever; */
3620 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
;
3624 case AFD_EVENT_ACCEPT
:
3625 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_ACCEPT
) &&
3626 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_ACCEPT
))
3628 /* Make the Notifcation */
3629 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3630 Socket
->SharedData
->wMsg
,
3632 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
3633 /* Disable this event until the next accept(); */
3634 Socket
->SharedData
->AsyncDisabledEvents
|= FD_ACCEPT
;
3638 case AFD_EVENT_DISCONNECT
:
3639 case AFD_EVENT_ABORT
:
3640 case AFD_EVENT_CLOSE
:
3641 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CLOSE
) &&
3642 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CLOSE
))
3644 /* Make the Notifcation */
3645 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3646 Socket
->SharedData
->wMsg
,
3648 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
3649 /* Disable this event forever; */
3650 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CLOSE
;
3653 /* FIXME: Support QOS */
3657 /* Check if there are any events left for us to check */
3658 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3664 SockProcessAsyncSelect(Socket
, AsyncData
);
3668 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
3671 ULONG lNetworkEvents
;
3674 /* Set up the Async Data Event Info */
3675 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
3676 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
3677 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
3678 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
3679 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
3680 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
3682 /* Remove unwanted events */
3683 lNetworkEvents
= Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
);
3685 /* Set Events to wait for */
3686 if (lNetworkEvents
& FD_READ
)
3688 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
3691 if (lNetworkEvents
& FD_WRITE
)
3693 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
3696 if (lNetworkEvents
& FD_OOB
)
3698 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
3701 if (lNetworkEvents
& FD_ACCEPT
)
3703 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
3706 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3707 if (lNetworkEvents
& FD_CONNECT
)
3709 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
3712 if (lNetworkEvents
& FD_CLOSE
)
3714 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
3717 if (lNetworkEvents
& FD_QOS
)
3719 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
3722 if (lNetworkEvents
& FD_GROUP_QOS
)
3724 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
3728 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
3732 &AsyncData
->IoStatusBlock
,
3734 &AsyncData
->AsyncSelectInfo
,
3735 sizeof(AsyncData
->AsyncSelectInfo
),
3736 &AsyncData
->AsyncSelectInfo
,
3737 sizeof(AsyncData
->AsyncSelectInfo
));
3739 /* I/O Manager Won't call the completion routine, let's do it manually */
3740 if (NT_SUCCESS(Status
))
3746 AsyncData
->IoStatusBlock
.Status
= Status
;
3747 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3751 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3753 PASYNC_DATA AsyncData
= Context
;
3754 BOOL FreeContext
= TRUE
;
3755 PSOCKET_INFORMATION Socket
;
3757 /* Get the Socket */
3758 Socket
= AsyncData
->ParentSocket
;
3760 /* If someone closed it, stop the function */
3761 if (Socket
->SharedData
->State
!= SocketClosed
)
3763 /* Check if the Sequence Number changed by now, in which case quit */
3764 if (AsyncData
->SequenceNumber
== Socket
->SharedData
->SequenceNumber
)
3766 /* Do the actuall select, if needed */
3767 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)))
3769 SockProcessAsyncSelect(Socket
, AsyncData
);
3770 FreeContext
= FALSE
;
3775 /* Free the Context */
3778 HeapFree(GetProcessHeap(), 0, AsyncData
);
3785 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3788 PASYNC_DATA AsyncData
;
3790 /* Make sure the event is actually disabled */
3791 if (!(Socket
->SharedData
->AsyncDisabledEvents
& Event
))
3797 Socket
->SharedData
->AsyncDisabledEvents
&= ~Event
;
3799 /* Return if no more events are being polled */
3800 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3805 /* Wait on new events */
3806 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
3807 if (!AsyncData
) return;
3809 /* Create the Asynch Thread if Needed */
3810 SockCreateOrReferenceAsyncThread();
3812 /* Increase the sequence number to stop anything else */
3813 Socket
->SharedData
->SequenceNumber
++;
3815 /* Set up the Async Data */
3816 AsyncData
->ParentSocket
= Socket
;
3817 AsyncData
->SequenceNumber
= Socket
->SharedData
->SequenceNumber
;
3819 /* Begin Async Select by using I/O Completion */
3820 NtSetIoCompletion(SockAsyncCompletionPort
,
3821 (PVOID
)&SockProcessQueuedAsyncSelect
,
3832 DllMain(HANDLE hInstDll
,
3839 case DLL_PROCESS_ATTACH
:
3841 TRACE("Loading MSAFD.DLL \n");
3843 /* Don't need thread attach notifications
3844 so disable them to improve performance */
3845 DisableThreadLibraryCalls(hInstDll
);
3847 /* List of DLL Helpers */
3848 InitializeListHead(&SockHelpersListHead
);
3850 /* Heap to use when allocating */
3851 GlobalHeap
= GetProcessHeap();
3853 /* Initialize the lock that protects our socket list */
3854 InitializeCriticalSection(&SocketListLock
);
3856 TRACE("MSAFD.DLL has been loaded\n");
3860 case DLL_THREAD_ATTACH
:
3863 case DLL_THREAD_DETACH
:
3866 case DLL_PROCESS_DETACH
:
3868 /* Delete the socket list lock */
3869 DeleteCriticalSection(&SocketListLock
);
3874 TRACE("DllMain of msafd.dll (leaving)\n");