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 */
206 /* Ask alex about this */
207 if( Socket
->SharedData
->SocketType
== SOCK_DGRAM
||
208 Socket
->SharedData
->SocketType
== SOCK_RAW
)
210 TRACE("Connectionless socket\n");
211 Socket
->SharedData
->ServiceFlags1
|= XP1_CONNECTIONLESS
;
216 Socket
->HelperContext
= HelperDLLContext
;
217 Socket
->HelperData
= HelperData
;
218 Socket
->HelperEvents
= HelperEvents
;
219 Socket
->LocalAddress
= &Socket
->SharedData
->WSLocalAddress
;
220 Socket
->RemoteAddress
= &Socket
->SharedData
->WSRemoteAddress
;
221 Socket
->SanData
= NULL
;
222 RtlCopyMemory(&Socket
->ProtocolInfo
, lpProtocolInfo
, sizeof(Socket
->ProtocolInfo
));
227 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
230 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
232 /* Set up EA Buffer */
233 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
236 Status
= STATUS_INSUFFICIENT_RESOURCES
;
240 RtlZeroMemory(EABuffer
, SizeOfEA
);
241 EABuffer
->NextEntryOffset
= 0;
243 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
244 RtlCopyMemory (EABuffer
->EaName
,
246 AFD_PACKET_COMMAND_LENGTH
+ 1);
247 EABuffer
->EaValueLength
= SizeOfPacket
;
249 /* Set up AFD Packet */
250 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
251 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
252 RtlCopyMemory (AfdPacket
->TransportName
,
253 TransportName
.Buffer
,
254 TransportName
.Length
+ sizeof(WCHAR
));
255 AfdPacket
->GroupID
= g
;
257 /* Set up Endpoint Flags */
258 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
260 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
262 /* Only RAW or UDP can be Connectionless */
265 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
268 if ((Socket
->SharedData
->ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
270 if (SocketType
== SOCK_STREAM
)
272 if ((Socket
->SharedData
->ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
274 /* The Provider doesn't actually support Message Oriented Streams */
278 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
281 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
283 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
284 WSA_FLAG_MULTIPOINT_C_LEAF
|
285 WSA_FLAG_MULTIPOINT_D_ROOT
|
286 WSA_FLAG_MULTIPOINT_D_LEAF
))
288 if ((Socket
->SharedData
->ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
290 /* The Provider doesn't actually support Multipoint */
293 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
295 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
297 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
298 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
300 /* The Provider doesn't support Control Planes, or you already gave a leaf */
303 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
306 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
308 if (((Socket
->SharedData
->ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
309 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
311 /* The Provider doesn't support Data Planes, or you already gave a leaf */
314 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
318 /* Set up Object Attributes */
319 InitializeObjectAttributes (&Object
,
321 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
325 /* Create the Socket as asynchronous. That means we have to block
326 ourselves after every call to NtDeviceIoControlFile. This is
327 because the kernel doesn't support overlapping synchronous I/O
328 requests (made from multiple threads) at this time (Sep 2005) */
329 Status
= NtCreateFile(&Sock
,
330 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
335 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
341 HeapFree(GlobalHeap
, 0, EABuffer
);
343 if (!NT_SUCCESS(Status
))
345 ERR("Failed to open socket. Status 0x%08x\n", Status
);
350 Socket
->Handle
= (SOCKET
)Sock
;
352 /* Save Group Info */
355 GetSocketInformation(Socket
,
356 AFD_INFO_GROUP_ID_TYPE
,
362 Socket
->SharedData
->GroupID
= GroupData
.u
.LowPart
;
363 Socket
->SharedData
->GroupType
= GroupData
.u
.HighPart
;
366 /* Get Window Sizes and Save them */
367 GetSocketInformation (Socket
,
368 AFD_INFO_SEND_WINDOW_SIZE
,
370 &Socket
->SharedData
->SizeOfSendBuffer
,
375 GetSocketInformation (Socket
,
376 AFD_INFO_RECEIVE_WINDOW_SIZE
,
378 &Socket
->SharedData
->SizeOfRecvBuffer
,
384 /* Save in Process Sockets List */
385 EnterCriticalSection(&SocketListLock
);
386 Socket
->NextSocket
= SocketListHead
;
387 SocketListHead
= Socket
;
388 LeaveCriticalSection(&SocketListLock
);
390 /* Create the Socket Context */
391 CreateContext(Socket
);
394 Upcalls
.lpWPUModifyIFSHandle(Socket
->ProtocolInfo
.dwCatalogEntryId
, (SOCKET
)Sock
, lpErrno
);
396 /* Return Socket Handle */
397 TRACE("Success %x\n", Sock
);
402 ERR("Ending %x\n", Status
);
406 UnmapViewOfFile(SharedData
);
407 NtClose((HANDLE
)lpProtocolInfo
->dwServiceFlags3
);
411 if( Socket
&& Socket
->SharedData
)
412 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
416 HeapFree(GlobalHeap
, 0, Socket
);
419 HeapFree(GlobalHeap
, 0, EABuffer
);
424 return INVALID_SOCKET
;
432 IN DWORD dwProcessId
,
433 OUT LPWSAPROTOCOL_INFOW lpProtocolInfo
,
436 HANDLE hProcess
, hDuplicatedSharedData
, hDuplicatedHandle
;
437 PSOCKET_INFORMATION Socket
;
438 PSOCK_SHARED_INFO pSharedData
, pOldSharedData
;
441 if (Handle
== INVALID_SOCKET
)
442 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
443 Socket
= GetSocketStructure(Handle
);
447 *lpErrno
= WSAENOTSOCK
;
450 if ( !(hProcess
= OpenProcess(PROCESS_DUP_HANDLE
, FALSE
, dwProcessId
)) )
451 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
453 /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
454 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
456 Socket
->SharedDataHandle
= CreateFileMapping(INVALID_HANDLE_VALUE
,
458 PAGE_READWRITE
| SEC_COMMIT
,
460 (sizeof(SOCK_SHARED_INFO
) + PAGE_SIZE
- 1) & ~(PAGE_SIZE
- 1),
462 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
463 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
464 pSharedData
= MapViewOfFile(Socket
->SharedDataHandle
,
468 sizeof(SOCK_SHARED_INFO
));
470 RtlCopyMemory(pSharedData
, Socket
->SharedData
, sizeof(SOCK_SHARED_INFO
));
471 pOldSharedData
= Socket
->SharedData
;
472 Socket
->SharedData
= pSharedData
;
473 HeapFree(GlobalHeap
, 0, pOldSharedData
);
475 /* Duplicate the handles for the new process */
476 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
477 Socket
->SharedDataHandle
,
479 (LPHANDLE
)&hDuplicatedSharedData
,
482 DUPLICATE_SAME_ACCESS
);
486 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
488 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
489 (HANDLE
)Socket
->Handle
,
491 (LPHANDLE
)&hDuplicatedHandle
,
494 DUPLICATE_SAME_ACCESS
);
497 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
501 return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION
, lpErrno
, 0, NULL
);
503 RtlCopyMemory(lpProtocolInfo
, &Socket
->ProtocolInfo
, sizeof(*lpProtocolInfo
));
505 lpProtocolInfo
->iAddressFamily
= Socket
->SharedData
->AddressFamily
;
506 lpProtocolInfo
->iProtocol
= Socket
->SharedData
->Protocol
;
507 lpProtocolInfo
->iSocketType
= Socket
->SharedData
->SocketType
;
508 lpProtocolInfo
->dwServiceFlags3
= (DWORD
)hDuplicatedSharedData
;
509 lpProtocolInfo
->dwServiceFlags4
= (DWORD
)hDuplicatedHandle
;
518 TranslateNtStatusError(NTSTATUS Status
)
522 case STATUS_CANT_WAIT
:
523 return WSAEWOULDBLOCK
;
531 case STATUS_FILE_CLOSED
:
532 return WSAECONNRESET
;
534 case STATUS_END_OF_FILE
:
538 return WSA_IO_PENDING
;
540 case STATUS_BUFFER_TOO_SMALL
:
541 case STATUS_BUFFER_OVERFLOW
:
544 case STATUS_NO_MEMORY
:
545 case STATUS_INSUFFICIENT_RESOURCES
:
548 case STATUS_INVALID_CONNECTION
:
551 case STATUS_PROTOCOL_NOT_SUPPORTED
:
552 return WSAEAFNOSUPPORT
;
554 case STATUS_INVALID_ADDRESS
:
555 return WSAEADDRNOTAVAIL
;
557 case STATUS_REMOTE_NOT_LISTENING
:
558 case STATUS_REMOTE_DISCONNECT
:
559 return WSAECONNREFUSED
;
561 case STATUS_NETWORK_UNREACHABLE
:
562 return WSAENETUNREACH
;
564 case STATUS_INVALID_PARAMETER
:
567 case STATUS_CANCELLED
:
568 return WSA_OPERATION_ABORTED
;
570 case STATUS_ADDRESS_ALREADY_EXISTS
:
571 return WSAEADDRINUSE
;
573 case STATUS_LOCAL_DISCONNECT
:
574 return WSAECONNABORTED
;
576 case STATUS_ACCESS_VIOLATION
:
579 case STATUS_ACCESS_DENIED
:
583 ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
589 * FUNCTION: Closes an open socket
591 * s = Socket descriptor
592 * lpErrno = Address of buffer for error information
594 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
598 WSPCloseSocket(IN SOCKET Handle
,
601 IO_STATUS_BLOCK IoStatusBlock
;
602 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
605 AFD_DISCONNECT_INFO DisconnectInfo
;
606 SOCKET_STATE OldState
;
607 LONG LingerWait
= -1;
610 /* Create the Wait Event */
611 Status
= NtCreateEvent(&SockEvent
,
617 if(!NT_SUCCESS(Status
))
619 ERR("NtCreateEvent failed: 0x%08x", Status
);
622 /* Get the Socket Structure associate to this Socket*/
623 Socket
= GetSocketStructure(Handle
);
627 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
631 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
633 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
635 Socket
->TdiAddressHandle
,
636 Socket
->TdiConnectionHandle
,
641 if (lpErrno
) *lpErrno
= Status
;
642 ERR("WSHNotify failed. Error 0x%#x", Status
);
648 /* If a Close is already in Process, give up */
649 if (Socket
->SharedData
->State
== SocketClosed
)
651 WARN("Socket is closing.\n");
653 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
656 /* Set the state to close */
657 OldState
= Socket
->SharedData
->State
;
658 Socket
->SharedData
->State
= SocketClosed
;
660 /* Decrement reference count on SharedData */
661 References
= InterlockedDecrement(&Socket
->SharedData
->RefCount
);
665 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
666 /* FIXME: Should we do this on Datagram Sockets too? */
667 if ((OldState
== SocketConnected
) && (Socket
->SharedData
->LingerData
.l_onoff
))
669 ULONG SendsInProgress
;
672 /* We need to respect the timeout */
674 LingerWait
= Socket
->SharedData
->LingerData
.l_linger
* 1000;
676 /* Loop until no more sends are pending, within the timeout */
679 /* Find out how many Sends are in Progress */
680 if (GetSocketInformation(Socket
,
681 AFD_INFO_SENDS_IN_PROGRESS
,
688 /* Bail out if anything but NO_ERROR */
693 /* Bail out if no more sends are pending */
694 if (!SendsInProgress
)
701 * We have to execute a sleep, so it's kind of like
702 * a block. If the socket is Nonblock, we cannot
703 * go on since asyncronous operation is expected
704 * and we cannot offer it
706 if (Socket
->SharedData
->NonBlocking
)
708 WARN("Would block!\n");
710 Socket
->SharedData
->State
= OldState
;
711 if (lpErrno
) *lpErrno
= WSAEWOULDBLOCK
;
715 /* Now we can sleep, and decrement the linger wait */
717 * FIXME: It seems Windows does some funky acceleration
718 * since the waiting seems to be longer and longer. I
719 * don't think this improves performance so much, so we
720 * wait a fixed time instead.
723 LingerWait
-= SleepWait
;
727 if (OldState
== SocketConnected
)
731 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
732 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
734 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
->SendShutdown
)) ||
735 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
->ReceiveShutdown
)))
738 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
743 IOCTL_AFD_DISCONNECT
,
745 sizeof(DisconnectInfo
),
749 /* Wait for return */
750 if (Status
== STATUS_PENDING
)
752 WaitForSingleObject(SockEvent
, INFINITE
);
753 Status
= IoStatusBlock
.Status
;
760 Socket
->HelperContext
= NULL
;
761 Socket
->SharedData
->AsyncDisabledEvents
= -1;
762 NtClose(Socket
->TdiAddressHandle
);
763 Socket
->TdiAddressHandle
= NULL
;
764 NtClose(Socket
->TdiConnectionHandle
);
765 Socket
->TdiConnectionHandle
= NULL
;
767 EnterCriticalSection(&SocketListLock
);
768 if (SocketListHead
== Socket
)
770 SocketListHead
= SocketListHead
->NextSocket
;
774 CurrentSocket
= SocketListHead
;
775 while (CurrentSocket
->NextSocket
)
777 if (CurrentSocket
->NextSocket
== Socket
)
779 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
783 CurrentSocket
= CurrentSocket
->NextSocket
;
786 LeaveCriticalSection(&SocketListLock
);
788 /* Close the handle */
789 NtClose((HANDLE
)Handle
);
792 if( Socket
->SharedDataHandle
!= INVALID_HANDLE_VALUE
)
794 /* It is a duplicated socket, so unmap the memory */
795 UnmapViewOfFile(Socket
->SharedData
);
796 NtClose(Socket
->SharedDataHandle
);
797 Socket
->SharedData
= NULL
;
799 if( !References
&& Socket
->SharedData
)
801 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
803 HeapFree(GlobalHeap
, 0, Socket
);
804 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
809 * FUNCTION: Associates a local address with a socket
811 * s = Socket descriptor
812 * name = Pointer to local address
813 * namelen = Length of name
814 * lpErrno = Address of buffer for error information
816 * 0, or SOCKET_ERROR if the socket could not be bound
820 WSPBind(SOCKET Handle
,
821 const struct sockaddr
*SocketAddress
,
822 int SocketAddressLength
,
825 IO_STATUS_BLOCK IOSB
;
826 PAFD_BIND_DATA BindData
;
827 PSOCKET_INFORMATION Socket
= NULL
;
829 SOCKADDR_INFO SocketInfo
;
833 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
836 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
839 Status
= NtCreateEvent(&SockEvent
,
845 if (!NT_SUCCESS(Status
))
847 HeapFree(GlobalHeap
, 0, BindData
);
851 /* Get the Socket Structure associate to this Socket*/
852 Socket
= GetSocketStructure(Handle
);
855 HeapFree(GlobalHeap
, 0, BindData
);
856 *lpErrno
= WSAENOTSOCK
;
860 /* Set up Address in TDI Format */
861 BindData
->Address
.TAAddressCount
= 1;
862 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
863 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
864 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
865 SocketAddress
->sa_data
,
866 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
868 /* Get Address Information */
869 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
873 /* Set the Share Type */
874 if (Socket
->SharedData
->ExclusiveAddressUse
)
876 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
878 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
880 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
882 else if (Socket
->SharedData
->ReuseAddresses
)
884 BindData
->ShareType
= AFD_SHARE_REUSE
;
888 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
892 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
899 0xA + Socket
->SharedData
->SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
901 0xA + Socket
->SharedData
->SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
903 /* Wait for return */
904 if (Status
== STATUS_PENDING
)
906 WaitForSingleObject(SockEvent
, INFINITE
);
907 Status
= IOSB
.Status
;
910 NtClose( SockEvent
);
911 HeapFree(GlobalHeap
, 0, BindData
);
913 if (Status
!= STATUS_SUCCESS
)
914 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
916 /* Set up Socket Data */
917 Socket
->SharedData
->State
= SocketBound
;
918 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
920 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
922 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
924 Socket
->TdiAddressHandle
,
925 Socket
->TdiConnectionHandle
,
930 if (lpErrno
) *lpErrno
= Status
;
935 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
940 WSPListen(SOCKET Handle
,
944 IO_STATUS_BLOCK IOSB
;
945 AFD_LISTEN_DATA ListenData
;
946 PSOCKET_INFORMATION Socket
= NULL
;
950 /* Get the Socket Structure associate to this Socket*/
951 Socket
= GetSocketStructure(Handle
);
954 *lpErrno
= WSAENOTSOCK
;
958 if (Socket
->SharedData
->Listening
)
961 Status
= NtCreateEvent(&SockEvent
,
967 if( !NT_SUCCESS(Status
) )
970 /* Set Up Listen Structure */
971 ListenData
.UseSAN
= FALSE
;
972 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
->UseDelayedAcceptance
;
973 ListenData
.Backlog
= Backlog
;
976 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
981 IOCTL_AFD_START_LISTEN
,
987 /* Wait for return */
988 if (Status
== STATUS_PENDING
)
990 WaitForSingleObject(SockEvent
, INFINITE
);
991 Status
= IOSB
.Status
;
994 NtClose( SockEvent
);
996 if (Status
!= STATUS_SUCCESS
)
997 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
999 /* Set to Listening */
1000 Socket
->SharedData
->Listening
= TRUE
;
1002 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
1004 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1006 Socket
->TdiAddressHandle
,
1007 Socket
->TdiConnectionHandle
,
1012 if (lpErrno
) *lpErrno
= Status
;
1013 return SOCKET_ERROR
;
1017 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1023 WSPSelect(IN
int nfds
,
1024 IN OUT fd_set
*readfds OPTIONAL
,
1025 IN OUT fd_set
*writefds OPTIONAL
,
1026 IN OUT fd_set
*exceptfds OPTIONAL
,
1027 IN
const struct timeval
*timeout OPTIONAL
,
1030 IO_STATUS_BLOCK IOSB
;
1031 PAFD_POLL_INFO PollInfo
;
1035 ULONG PollBufferSize
;
1040 LARGE_INTEGER Timeout
;
1042 /* Find out how many sockets we have, and how large the buffer needs
1045 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
1046 ( writefds
? writefds
->fd_count
: 0 ) +
1047 ( exceptfds
? exceptfds
->fd_count
: 0 );
1049 if ( HandleCount
== 0 )
1051 WARN("No handles! Returning SOCKET_ERROR\n", HandleCount
);
1052 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1053 return SOCKET_ERROR
;
1056 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
1058 TRACE("HandleCount: %u BufferSize: %u\n", HandleCount
, PollBufferSize
);
1060 /* Convert Timeout to NT Format */
1061 if (timeout
== NULL
)
1063 Timeout
.u
.LowPart
= -1;
1064 Timeout
.u
.HighPart
= 0x7FFFFFFF;
1065 TRACE("Infinite timeout\n");
1069 Timeout
= RtlEnlargedIntegerMultiply
1070 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
1071 /* Negative timeouts are illegal. Since the kernel represents an
1072 * incremental timeout as a negative number, we check for a positive
1075 if (Timeout
.QuadPart
> 0)
1077 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1078 return SOCKET_ERROR
;
1080 TRACE("Timeout: Orig %d.%06d kernel %d\n",
1081 timeout
->tv_sec
, timeout
->tv_usec
,
1085 Status
= NtCreateEvent(&SockEvent
,
1091 if(!NT_SUCCESS(Status
))
1094 *lpErrno
= WSAEFAULT
;
1096 ERR("NtCreateEvent failed, 0x%08x\n", Status
);
1097 return SOCKET_ERROR
;
1101 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
1106 *lpErrno
= WSAEFAULT
;
1108 return SOCKET_ERROR
;
1111 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
1113 RtlZeroMemory( PollInfo
, PollBufferSize
);
1115 /* Number of handles for AFD to Check */
1116 PollInfo
->Exclusive
= FALSE
;
1117 PollInfo
->Timeout
= Timeout
;
1119 if (readfds
!= NULL
) {
1120 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
1122 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
1123 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
1124 AFD_EVENT_DISCONNECT
|
1130 if (writefds
!= NULL
)
1132 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
1134 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
1135 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
1138 if (exceptfds
!= NULL
)
1140 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
1142 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
1143 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
1147 PollInfo
->HandleCount
= j
;
1148 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
1151 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
1162 TRACE("DeviceIoControlFile => %x\n", Status
);
1164 /* Wait for Completition */
1165 if (Status
== STATUS_PENDING
)
1167 WaitForSingleObject(SockEvent
, INFINITE
);
1168 Status
= IOSB
.Status
;
1171 /* Clear the Structures */
1179 /* Loop through return structure */
1180 HandleCount
= PollInfo
->HandleCount
;
1182 /* Return in FDSET Format */
1183 for (i
= 0; i
< HandleCount
; i
++)
1185 HandleCounted
= FALSE
;
1186 for(x
= 1; x
; x
<<=1)
1188 switch (PollInfo
->Handles
[i
].Events
& x
)
1190 case AFD_EVENT_RECEIVE
:
1191 case AFD_EVENT_DISCONNECT
:
1192 case AFD_EVENT_ABORT
:
1193 case AFD_EVENT_ACCEPT
:
1194 case AFD_EVENT_CLOSE
:
1195 TRACE("Event %x on handle %x\n",
1196 PollInfo
->Handles
[i
].Events
,
1197 PollInfo
->Handles
[i
].Handle
);
1198 if (! HandleCounted
)
1201 HandleCounted
= TRUE
;
1204 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
1206 case AFD_EVENT_SEND
:
1207 case AFD_EVENT_CONNECT
:
1208 TRACE("Event %x on handle %x\n",
1209 PollInfo
->Handles
[i
].Events
,
1210 PollInfo
->Handles
[i
].Handle
);
1211 if (! HandleCounted
)
1214 HandleCounted
= TRUE
;
1217 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
1219 case AFD_EVENT_OOB_RECEIVE
:
1220 case AFD_EVENT_CONNECT_FAIL
:
1221 TRACE("Event %x on handle %x\n",
1222 PollInfo
->Handles
[i
].Events
,
1223 PollInfo
->Handles
[i
].Handle
);
1224 if (! HandleCounted
)
1227 HandleCounted
= TRUE
;
1230 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1236 HeapFree( GlobalHeap
, 0, PollBuffer
);
1237 NtClose( SockEvent
);
1241 switch( IOSB
.Status
)
1243 case STATUS_SUCCESS
:
1244 case STATUS_TIMEOUT
:
1248 *lpErrno
= WSAEINVAL
;
1251 TRACE("*lpErrno = %x\n", *lpErrno
);
1254 TRACE("%d events\n", OutCount
);
1261 WSPAccept(SOCKET Handle
,
1262 struct sockaddr
*SocketAddress
,
1263 int *SocketAddressLength
,
1264 LPCONDITIONPROC lpfnCondition
,
1265 DWORD dwCallbackData
,
1268 IO_STATUS_BLOCK IOSB
;
1269 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1270 AFD_ACCEPT_DATA AcceptData
;
1271 AFD_DEFER_ACCEPT_DATA DeferData
;
1272 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1273 PSOCKET_INFORMATION Socket
= NULL
;
1275 struct fd_set ReadSet
;
1276 struct timeval Timeout
;
1277 PVOID PendingData
= NULL
;
1278 ULONG PendingDataLength
= 0;
1279 PVOID CalleeDataBuffer
;
1280 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1281 PSOCKADDR RemoteAddress
= NULL
;
1284 SOCKET AcceptSocket
;
1285 PSOCKET_INFORMATION AcceptSocketInfo
;
1286 UCHAR ReceiveBuffer
[0x1A];
1289 Status
= NtCreateEvent(&SockEvent
,
1295 if( !NT_SUCCESS(Status
) )
1297 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1298 return INVALID_SOCKET
;
1301 /* Dynamic Structure...ugh */
1302 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1304 /* Get the Socket Structure associate to this Socket*/
1305 Socket
= GetSocketStructure(Handle
);
1309 *lpErrno
= WSAENOTSOCK
;
1310 return INVALID_SOCKET
;
1313 /* If this is non-blocking, make sure there's something for us to accept */
1315 FD_SET(Socket
->Handle
, &ReadSet
);
1319 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1322 return INVALID_SOCKET
;
1325 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1328 *lpErrno
= WSAEWOULDBLOCK
;
1329 return INVALID_SOCKET
;
1333 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1338 IOCTL_AFD_WAIT_FOR_LISTEN
,
1342 0xA + sizeof(*ListenReceiveData
));
1344 /* Wait for return */
1345 if (Status
== STATUS_PENDING
)
1347 WaitForSingleObject(SockEvent
, INFINITE
);
1348 Status
= IOSB
.Status
;
1351 if (!NT_SUCCESS(Status
))
1353 NtClose( SockEvent
);
1354 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1355 return INVALID_SOCKET
;
1358 if (lpfnCondition
!= NULL
)
1360 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1362 /* Find out how much data is pending */
1363 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1364 PendingAcceptData
.ReturnSize
= TRUE
;
1367 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1372 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1374 sizeof(PendingAcceptData
),
1376 sizeof(PendingAcceptData
));
1378 /* Wait for return */
1379 if (Status
== STATUS_PENDING
)
1381 WaitForSingleObject(SockEvent
, INFINITE
);
1382 Status
= IOSB
.Status
;
1385 if (!NT_SUCCESS(Status
))
1387 NtClose( SockEvent
);
1388 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1389 return INVALID_SOCKET
;
1392 /* How much data to allocate */
1393 PendingDataLength
= IOSB
.Information
;
1395 if (PendingDataLength
)
1397 /* Allocate needed space */
1398 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1401 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1402 return INVALID_SOCKET
;
1405 /* We want the data now */
1406 PendingAcceptData
.ReturnSize
= FALSE
;
1409 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1414 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1416 sizeof(PendingAcceptData
),
1420 /* Wait for return */
1421 if (Status
== STATUS_PENDING
)
1423 WaitForSingleObject(SockEvent
, INFINITE
);
1424 Status
= IOSB
.Status
;
1427 if (!NT_SUCCESS(Status
))
1429 NtClose( SockEvent
);
1430 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1431 return INVALID_SOCKET
;
1436 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1438 /* I don't support this yet */
1441 /* Build Callee ID */
1442 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1443 CalleeID
.len
= Socket
->SharedData
->SizeOfLocalAddress
;
1445 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1448 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1449 return INVALID_SOCKET
;
1452 /* Set up Address in SOCKADDR Format */
1453 RtlCopyMemory (RemoteAddress
,
1454 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1455 sizeof(*RemoteAddress
));
1457 /* Build Caller ID */
1458 CallerID
.buf
= (PVOID
)RemoteAddress
;
1459 CallerID
.len
= sizeof(*RemoteAddress
);
1461 /* Build Caller Data */
1462 CallerData
.buf
= PendingData
;
1463 CallerData
.len
= PendingDataLength
;
1465 /* Check if socket supports Conditional Accept */
1466 if (Socket
->SharedData
->UseDelayedAcceptance
!= 0)
1468 /* Allocate Buffer for Callee Data */
1469 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1470 if (!CalleeDataBuffer
) {
1471 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1472 return INVALID_SOCKET
;
1474 CalleeData
.buf
= CalleeDataBuffer
;
1475 CalleeData
.len
= 4096;
1484 /* Call the Condition Function */
1485 CallBack
= (lpfnCondition
)(&CallerID
,
1486 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1490 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1494 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1496 /* TBD: Check for Validity */
1499 if (CallBack
== CF_ACCEPT
)
1501 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1503 /* I don't support this yet */
1507 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1512 /* Callback rejected. Build Defer Structure */
1513 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1514 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1517 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1522 IOCTL_AFD_DEFER_ACCEPT
,
1528 /* Wait for return */
1529 if (Status
== STATUS_PENDING
)
1531 WaitForSingleObject(SockEvent
, INFINITE
);
1532 Status
= IOSB
.Status
;
1535 NtClose( SockEvent
);
1537 if (!NT_SUCCESS(Status
))
1539 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1540 return INVALID_SOCKET
;
1543 if (CallBack
== CF_REJECT
)
1545 *lpErrno
= WSAECONNREFUSED
;
1546 return INVALID_SOCKET
;
1550 *lpErrno
= WSAECONNREFUSED
;
1551 return INVALID_SOCKET
;
1556 /* Create a new Socket */
1557 AcceptSocket
= WSPSocket (Socket
->SharedData
->AddressFamily
,
1558 Socket
->SharedData
->SocketType
,
1559 Socket
->SharedData
->Protocol
,
1560 &Socket
->ProtocolInfo
,
1562 Socket
->SharedData
->CreateFlags
,
1564 if (AcceptSocket
== INVALID_SOCKET
)
1565 return INVALID_SOCKET
;
1567 /* Set up the Accept Structure */
1568 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1569 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1571 /* Send IOCTL to Accept */
1572 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1583 /* Wait for return */
1584 if (Status
== STATUS_PENDING
)
1586 WaitForSingleObject(SockEvent
, INFINITE
);
1587 Status
= IOSB
.Status
;
1590 if (!NT_SUCCESS(Status
))
1593 WSPCloseSocket( AcceptSocket
, lpErrno
);
1594 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1595 return INVALID_SOCKET
;
1598 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1599 if (!AcceptSocketInfo
)
1602 WSPCloseSocket( AcceptSocket
, lpErrno
);
1603 MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED
, lpErrno
, 0, NULL
);
1604 return INVALID_SOCKET
;
1607 AcceptSocketInfo
->SharedData
->State
= SocketConnected
;
1609 /* Return Address in SOCKADDR FORMAT */
1612 RtlCopyMemory (SocketAddress
,
1613 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1614 sizeof(*RemoteAddress
));
1615 if( SocketAddressLength
)
1616 *SocketAddressLength
= sizeof(*RemoteAddress
);
1619 NtClose( SockEvent
);
1621 /* Re-enable Async Event */
1622 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1624 TRACE("Socket %x\n", AcceptSocket
);
1626 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1628 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1630 Socket
->TdiAddressHandle
,
1631 Socket
->TdiConnectionHandle
,
1636 if (lpErrno
) *lpErrno
= Status
;
1637 return INVALID_SOCKET
;
1644 return AcceptSocket
;
1649 WSPConnect(SOCKET Handle
,
1650 const struct sockaddr
* SocketAddress
,
1651 int SocketAddressLength
,
1652 LPWSABUF lpCallerData
,
1653 LPWSABUF lpCalleeData
,
1658 IO_STATUS_BLOCK IOSB
;
1659 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1660 PSOCKET_INFORMATION Socket
;
1663 ULONG ConnectDataLength
;
1664 ULONG InConnectDataLength
;
1665 INT BindAddressLength
;
1666 PSOCKADDR BindAddress
;
1668 int SocketDataLength
;
1670 Status
= NtCreateEvent(&SockEvent
,
1676 if (!NT_SUCCESS(Status
))
1677 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1681 /* Get the Socket Structure associate to this Socket*/
1682 Socket
= GetSocketStructure(Handle
);
1686 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1687 return SOCKET_ERROR
;
1691 if (Socket
->SharedData
->State
== SocketOpen
)
1693 /* Get the Wildcard Address */
1694 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1695 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1699 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1701 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1703 &BindAddressLength
);
1705 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1706 return SOCKET_ERROR
;
1709 /* Set the Connect Data */
1710 if (lpCallerData
!= NULL
)
1712 ConnectDataLength
= lpCallerData
->len
;
1713 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1718 IOCTL_AFD_SET_CONNECT_DATA
,
1723 /* Wait for return */
1724 if (Status
== STATUS_PENDING
)
1726 WaitForSingleObject(SockEvent
, INFINITE
);
1727 Status
= IOSB
.Status
;
1730 if (Status
!= STATUS_SUCCESS
)
1734 /* Calculate the size of SocketAddress->sa_data */
1735 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1737 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1738 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1739 FIELD_OFFSET(AFD_CONNECT_INFO
,
1740 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1743 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1747 /* Set up Address in TDI Format */
1748 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1749 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1750 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1751 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1752 SocketAddress
->sa_data
,
1756 * Disable FD_WRITE and FD_CONNECT
1757 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1758 * at the end of this function right after the Async Thread disables it.
1759 * This should only happen at the *next* WSPConnect
1761 if (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
)
1763 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1766 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1767 if (lpCalleeData
!= NULL
)
1769 InConnectDataLength
= lpCalleeData
->len
;
1770 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1775 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1776 &InConnectDataLength
,
1777 sizeof(InConnectDataLength
),
1781 /* Wait for return */
1782 if (Status
== STATUS_PENDING
)
1784 WaitForSingleObject(SockEvent
, INFINITE
);
1785 Status
= IOSB
.Status
;
1788 if (Status
!= STATUS_SUCCESS
)
1792 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1793 ConnectInfo
->Root
= 0;
1794 ConnectInfo
->UseSAN
= FALSE
;
1795 ConnectInfo
->Unknown
= 0;
1797 /* FIXME: Handle Async Connect */
1798 if (Socket
->SharedData
->NonBlocking
)
1800 ERR("Async Connect UNIMPLEMENTED!\n");
1804 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1814 /* Wait for return */
1815 if (Status
== STATUS_PENDING
)
1817 WaitForSingleObject(SockEvent
, INFINITE
);
1818 Status
= IOSB
.Status
;
1821 if (Status
!= STATUS_SUCCESS
)
1824 Socket
->SharedData
->State
= SocketConnected
;
1825 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1827 /* Get any pending connect data */
1828 if (lpCalleeData
!= NULL
)
1830 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1835 IOCTL_AFD_GET_CONNECT_DATA
,
1840 /* Wait for return */
1841 if (Status
== STATUS_PENDING
)
1843 WaitForSingleObject(SockEvent
, INFINITE
);
1844 Status
= IOSB
.Status
;
1851 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
1853 /* Re-enable Async Event */
1854 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1856 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1857 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1861 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1863 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1865 Socket
->TdiAddressHandle
,
1866 Socket
->TdiConnectionHandle
,
1867 WSH_NOTIFY_CONNECT
);
1871 if (lpErrno
) *lpErrno
= Errno
;
1872 return SOCKET_ERROR
;
1875 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1877 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1879 Socket
->TdiAddressHandle
,
1880 Socket
->TdiConnectionHandle
,
1881 WSH_NOTIFY_CONNECT_ERROR
);
1885 if (lpErrno
) *lpErrno
= Errno
;
1886 return SOCKET_ERROR
;
1890 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1894 WSPShutdown(SOCKET Handle
,
1899 IO_STATUS_BLOCK IOSB
;
1900 AFD_DISCONNECT_INFO DisconnectInfo
;
1901 PSOCKET_INFORMATION Socket
= NULL
;
1905 Status
= NtCreateEvent(&SockEvent
,
1911 if( !NT_SUCCESS(Status
) )
1916 /* Get the Socket Structure associate to this Socket*/
1917 Socket
= GetSocketStructure(Handle
);
1921 *lpErrno
= WSAENOTSOCK
;
1922 return SOCKET_ERROR
;
1925 /* Set AFD Disconnect Type */
1929 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1930 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
1933 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1934 Socket
->SharedData
->SendShutdown
= TRUE
;
1937 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1938 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
1939 Socket
->SharedData
->SendShutdown
= TRUE
;
1943 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
1946 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1951 IOCTL_AFD_DISCONNECT
,
1953 sizeof(DisconnectInfo
),
1957 /* Wait for return */
1958 if (Status
== STATUS_PENDING
)
1960 WaitForSingleObject(SockEvent
, INFINITE
);
1961 Status
= IOSB
.Status
;
1966 NtClose( SockEvent
);
1968 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1974 WSPGetSockName(IN SOCKET Handle
,
1975 OUT LPSOCKADDR Name
,
1976 IN OUT LPINT NameLength
,
1979 IO_STATUS_BLOCK IOSB
;
1980 ULONG TdiAddressSize
;
1981 PTDI_ADDRESS_INFO TdiAddress
;
1982 PTRANSPORT_ADDRESS SocketAddress
;
1983 PSOCKET_INFORMATION Socket
= NULL
;
1987 Status
= NtCreateEvent(&SockEvent
,
1993 if( !NT_SUCCESS(Status
) )
1994 return SOCKET_ERROR
;
1996 /* Get the Socket Structure associate to this Socket*/
1997 Socket
= GetSocketStructure(Handle
);
2001 *lpErrno
= WSAENOTSOCK
;
2002 return SOCKET_ERROR
;
2005 if (!Name
|| !NameLength
)
2008 *lpErrno
= WSAEFAULT
;
2009 return SOCKET_ERROR
;
2012 /* Allocate a buffer for the address */
2014 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfLocalAddress
;
2015 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2017 if ( TdiAddress
== NULL
)
2019 NtClose( SockEvent
);
2020 *lpErrno
= WSAENOBUFS
;
2021 return SOCKET_ERROR
;
2024 SocketAddress
= &TdiAddress
->Address
;
2027 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2032 IOCTL_AFD_GET_SOCK_NAME
,
2038 /* Wait for return */
2039 if (Status
== STATUS_PENDING
)
2041 WaitForSingleObject(SockEvent
, INFINITE
);
2042 Status
= IOSB
.Status
;
2045 NtClose( SockEvent
);
2047 if (NT_SUCCESS(Status
))
2049 if (*NameLength
>= Socket
->SharedData
->SizeOfLocalAddress
)
2051 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2052 RtlCopyMemory (Name
->sa_data
,
2053 SocketAddress
->Address
[0].Address
,
2054 SocketAddress
->Address
[0].AddressLength
);
2055 *NameLength
= Socket
->SharedData
->SizeOfLocalAddress
;
2056 TRACE("NameLength %d Address: %x Port %x\n",
2057 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2058 ((struct sockaddr_in
*)Name
)->sin_port
);
2059 HeapFree(GlobalHeap
, 0, TdiAddress
);
2064 HeapFree(GlobalHeap
, 0, TdiAddress
);
2065 *lpErrno
= WSAEFAULT
;
2066 return SOCKET_ERROR
;
2070 HeapFree(GlobalHeap
, 0, TdiAddress
);
2072 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2078 WSPGetPeerName(IN SOCKET s
,
2079 OUT LPSOCKADDR Name
,
2080 IN OUT LPINT NameLength
,
2083 IO_STATUS_BLOCK IOSB
;
2084 ULONG TdiAddressSize
;
2085 PTRANSPORT_ADDRESS SocketAddress
;
2086 PSOCKET_INFORMATION Socket
= NULL
;
2090 Status
= NtCreateEvent(&SockEvent
,
2096 if( !NT_SUCCESS(Status
) )
2097 return SOCKET_ERROR
;
2099 /* Get the Socket Structure associate to this Socket*/
2100 Socket
= GetSocketStructure(s
);
2104 *lpErrno
= WSAENOTSOCK
;
2105 return SOCKET_ERROR
;
2108 if (Socket
->SharedData
->State
!= SocketConnected
)
2111 *lpErrno
= WSAENOTCONN
;
2112 return SOCKET_ERROR
;
2115 if (!Name
|| !NameLength
)
2118 *lpErrno
= WSAEFAULT
;
2119 return SOCKET_ERROR
;
2122 /* Allocate a buffer for the address */
2123 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfRemoteAddress
;
2124 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2126 if ( SocketAddress
== NULL
)
2128 NtClose( SockEvent
);
2129 *lpErrno
= WSAENOBUFS
;
2130 return SOCKET_ERROR
;
2134 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2139 IOCTL_AFD_GET_PEER_NAME
,
2145 /* Wait for return */
2146 if (Status
== STATUS_PENDING
)
2148 WaitForSingleObject(SockEvent
, INFINITE
);
2149 Status
= IOSB
.Status
;
2152 NtClose( SockEvent
);
2154 if (NT_SUCCESS(Status
))
2156 if (*NameLength
>= Socket
->SharedData
->SizeOfRemoteAddress
)
2158 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2159 RtlCopyMemory (Name
->sa_data
,
2160 SocketAddress
->Address
[0].Address
,
2161 SocketAddress
->Address
[0].AddressLength
);
2162 *NameLength
= Socket
->SharedData
->SizeOfRemoteAddress
;
2163 TRACE("NameLength %d Address: %x Port %x\n",
2164 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2165 ((struct sockaddr_in
*)Name
)->sin_port
);
2166 HeapFree(GlobalHeap
, 0, SocketAddress
);
2171 HeapFree(GlobalHeap
, 0, SocketAddress
);
2172 *lpErrno
= WSAEFAULT
;
2173 return SOCKET_ERROR
;
2177 HeapFree(GlobalHeap
, 0, SocketAddress
);
2179 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2184 WSPIoctl(IN SOCKET Handle
,
2185 IN DWORD dwIoControlCode
,
2186 IN LPVOID lpvInBuffer
,
2187 IN DWORD cbInBuffer
,
2188 OUT LPVOID lpvOutBuffer
,
2189 IN DWORD cbOutBuffer
,
2190 OUT LPDWORD lpcbBytesReturned
,
2191 IN LPWSAOVERLAPPED lpOverlapped
,
2192 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
2193 IN LPWSATHREADID lpThreadId
,
2196 PSOCKET_INFORMATION Socket
= NULL
;
2197 BOOLEAN NeedsCompletion
= lpOverlapped
!= NULL
;
2198 BOOLEAN NonBlocking
;
2199 INT Errno
= NO_ERROR
, Ret
= SOCKET_ERROR
;
2202 /* Get the Socket Structure associate to this Socket*/
2203 Socket
= GetSocketStructure(Handle
);
2207 *lpErrno
= WSAENOTSOCK
;
2208 return SOCKET_ERROR
;
2211 if (!lpcbBytesReturned
&& !lpOverlapped
)
2214 *lpErrno
= WSAEFAULT
;
2215 return SOCKET_ERROR
;
2218 switch( dwIoControlCode
)
2221 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2226 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2227 Socket
->SharedData
->NonBlocking
= NonBlocking
? 1 : 0;
2228 NeedsCompletion
= FALSE
;
2229 Errno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2230 if (Errno
== NO_ERROR
)
2234 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2236 cbRet
= sizeof(ULONG
);
2240 if (cbOutBuffer
< sizeof(ULONG
))
2245 NeedsCompletion
= FALSE
;
2246 Errno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
, lpOverlapped
, lpCompletionRoutine
);
2247 if (Errno
== NO_ERROR
)
2249 cbRet
= sizeof(ULONG
);
2254 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2256 cbRet
= sizeof(BOOL
);
2260 if (cbOutBuffer
< sizeof(BOOL
))
2266 /* FIXME: Return false for now */
2267 *(BOOL
*)lpvOutBuffer
= FALSE
;
2269 cbRet
= sizeof(BOOL
);
2273 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2276 case SIO_ADDRESS_LIST_QUERY
:
2277 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2279 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2283 if (cbOutBuffer
< sizeof(INT
))
2289 cbRet
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2291 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->iAddressCount
= 1;
2293 if (cbOutBuffer
< (sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
)))
2299 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].iSockaddrLength
= sizeof(Socket
->SharedData
->WSLocalAddress
);
2300 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].lpSockaddr
= &Socket
->SharedData
->WSLocalAddress
;
2306 Errno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2308 Socket
->TdiAddressHandle
,
2309 Socket
->TdiConnectionHandle
,
2317 lpCompletionRoutine
,
2318 (LPBOOL
)&NeedsCompletion
);
2320 if (Errno
== NO_ERROR
)
2324 if (lpOverlapped
&& NeedsCompletion
)
2326 lpOverlapped
->Internal
= Errno
;
2327 lpOverlapped
->InternalHigh
= cbRet
;
2328 if (lpCompletionRoutine
!= NULL
)
2330 lpCompletionRoutine(Errno
, cbRet
, lpOverlapped
, 0);
2332 if (lpOverlapped
->hEvent
)
2333 SetEvent(lpOverlapped
->hEvent
);
2334 if (!PostQueuedCompletionStatus((HANDLE
)Handle
, cbRet
, 0, lpOverlapped
))
2336 ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
2342 if (lpcbBytesReturned
)
2343 *lpcbBytesReturned
= cbRet
;
2350 WSPGetSockOpt(IN SOCKET Handle
,
2353 OUT CHAR FAR
* OptionValue
,
2354 IN OUT LPINT OptionLength
,
2357 PSOCKET_INFORMATION Socket
= NULL
;
2363 /* Get the Socket Structure associate to this Socket*/
2364 Socket
= GetSocketStructure(Handle
);
2367 *lpErrno
= WSAENOTSOCK
;
2368 return SOCKET_ERROR
;
2379 Buffer
= &Socket
->SharedData
->SocketType
;
2380 BufferSize
= sizeof(INT
);
2384 Buffer
= &Socket
->SharedData
->SizeOfRecvBuffer
;
2385 BufferSize
= sizeof(INT
);
2389 Buffer
= &Socket
->SharedData
->SizeOfSendBuffer
;
2390 BufferSize
= sizeof(INT
);
2394 BoolBuffer
= Socket
->SharedData
->Listening
;
2395 Buffer
= &BoolBuffer
;
2396 BufferSize
= sizeof(BOOL
);
2400 BoolBuffer
= Socket
->SharedData
->Broadcast
;
2401 Buffer
= &BoolBuffer
;
2402 BufferSize
= sizeof(BOOL
);
2406 BoolBuffer
= Socket
->SharedData
->Debug
;
2407 Buffer
= &BoolBuffer
;
2408 BufferSize
= sizeof(BOOL
);
2412 BoolBuffer
= (Socket
->SharedData
->LingerData
.l_onoff
== 0);
2413 Buffer
= &BoolBuffer
;
2414 BufferSize
= sizeof(BOOL
);
2418 if (Socket
->SharedData
->SocketType
== SOCK_DGRAM
)
2420 *lpErrno
= WSAENOPROTOOPT
;
2421 return SOCKET_ERROR
;
2423 Buffer
= &Socket
->SharedData
->LingerData
;
2424 BufferSize
= sizeof(struct linger
);
2428 BoolBuffer
= (Socket
->SharedData
->OobInline
!= 0);
2429 Buffer
= &BoolBuffer
;
2430 BufferSize
= sizeof(BOOL
);
2435 /* These guys go directly to the helper */
2438 case SO_CONDITIONAL_ACCEPT
:
2439 BoolBuffer
= (Socket
->SharedData
->UseDelayedAcceptance
!= 0);
2440 Buffer
= &BoolBuffer
;
2441 BufferSize
= sizeof(BOOL
);
2445 BoolBuffer
= (Socket
->SharedData
->ReuseAddresses
!= 0);
2446 Buffer
= &BoolBuffer
;
2447 BufferSize
= sizeof(BOOL
);
2450 case SO_EXCLUSIVEADDRUSE
:
2451 BoolBuffer
= (Socket
->SharedData
->ExclusiveAddressUse
!= 0);
2452 Buffer
= &BoolBuffer
;
2453 BufferSize
= sizeof(BOOL
);
2457 /* HACK: This needs to be properly tracked */
2459 DbgPrint("MSAFD: Hacked SO_ERROR returning error %d\n", IntBuffer
);
2461 Buffer
= &IntBuffer
;
2462 BufferSize
= sizeof(INT
);
2465 Buffer
= &Socket
->SharedData
->SendTimeout
;
2466 BufferSize
= sizeof(DWORD
);
2469 Buffer
= &Socket
->SharedData
->RecvTimeout
;
2470 BufferSize
= sizeof(DWORD
);
2472 case SO_PROTOCOL_INFOW
:
2473 Buffer
= &Socket
->ProtocolInfo
;
2474 BufferSize
= sizeof(Socket
->ProtocolInfo
);
2478 case SO_GROUP_PRIORITY
:
2479 case SO_MAX_MSG_SIZE
:
2482 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2483 *lpErrno
= WSAENOPROTOOPT
;
2484 return SOCKET_ERROR
;
2487 if (*OptionLength
< BufferSize
)
2489 *lpErrno
= WSAEFAULT
;
2490 *OptionLength
= BufferSize
;
2491 return SOCKET_ERROR
;
2493 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2498 *lpErrno
= WSAEINVAL
;
2499 return SOCKET_ERROR
;
2503 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2505 Socket
->TdiAddressHandle
,
2506 Socket
->TdiConnectionHandle
,
2510 (LPINT
)OptionLength
);
2511 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2520 IN CONST CHAR FAR
* optval
,
2524 PSOCKET_INFORMATION Socket
;
2526 /* Get the Socket Structure associate to this Socket*/
2527 Socket
= GetSocketStructure(s
);
2530 *lpErrno
= WSAENOTSOCK
;
2531 return SOCKET_ERROR
;
2535 /* FIXME: We should handle some more cases here */
2536 if (level
== SOL_SOCKET
)
2541 if (optlen
< sizeof(BOOL
))
2543 *lpErrno
= WSAEFAULT
;
2544 return SOCKET_ERROR
;
2546 Socket
->SharedData
->Broadcast
= (*optval
!= 0) ? 1 : 0;
2550 if (optlen
< sizeof(BOOL
))
2552 *lpErrno
= WSAEFAULT
;
2553 return SOCKET_ERROR
;
2555 Socket
->SharedData
->LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2559 if (optlen
< sizeof(BOOL
))
2561 *lpErrno
= WSAEFAULT
;
2562 return SOCKET_ERROR
;
2564 Socket
->SharedData
->ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2567 case SO_EXCLUSIVEADDRUSE
:
2568 if (optlen
< sizeof(BOOL
))
2570 *lpErrno
= WSAEFAULT
;
2571 return SOCKET_ERROR
;
2573 Socket
->SharedData
->ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2577 if (optlen
< sizeof(struct linger
))
2579 *lpErrno
= WSAEFAULT
;
2580 return SOCKET_ERROR
;
2582 RtlCopyMemory(&Socket
->SharedData
->LingerData
,
2584 sizeof(struct linger
));
2588 if (optlen
< sizeof(DWORD
))
2590 *lpErrno
= WSAEFAULT
;
2591 return SOCKET_ERROR
;
2594 /* TODO: The total per-socket buffer space reserved for sends */
2595 ERR("Setting send buf to %x is not implemented yet\n", optval
);
2599 if (optlen
< sizeof(DWORD
))
2601 *lpErrno
= WSAEFAULT
;
2602 return SOCKET_ERROR
;
2605 RtlCopyMemory(&Socket
->SharedData
->SendTimeout
,
2611 if (optlen
< sizeof(DWORD
))
2613 *lpErrno
= WSAEFAULT
;
2614 return SOCKET_ERROR
;
2617 RtlCopyMemory(&Socket
->SharedData
->RecvTimeout
,
2624 /* These go directly to the helper dll */
2628 /* Obviously this is a hack */
2629 ERR("MSAFD: Set unknown optname %x\n", optname
);
2635 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2637 Socket
->TdiAddressHandle
,
2638 Socket
->TdiConnectionHandle
,
2643 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2647 * FUNCTION: Initialize service provider for a client
2649 * wVersionRequested = Highest WinSock SPI version that the caller can use
2650 * lpWSPData = Address of WSPDATA structure to initialize
2651 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2652 * UpcallTable = Pointer to upcall table of the WinSock DLL
2653 * lpProcTable = Address of procedure table to initialize
2655 * Status of operation
2659 WSPStartup(IN WORD wVersionRequested
,
2660 OUT LPWSPDATA lpWSPData
,
2661 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2662 IN WSPUPCALLTABLE UpcallTable
,
2663 OUT LPWSPPROC_TABLE lpProcTable
)
2668 if (((LOBYTE(wVersionRequested
) == 2) && (HIBYTE(wVersionRequested
) < 2)) ||
2669 (LOBYTE(wVersionRequested
) < 2))
2671 ERR("WSPStartup NOT SUPPORTED for version 0x%X\n", wVersionRequested
);
2672 return WSAVERNOTSUPPORTED
;
2676 /* FIXME: Enable all cases of WSPStartup status */
2677 Upcalls
= UpcallTable
;
2679 if (Status
== NO_ERROR
)
2681 lpProcTable
->lpWSPAccept
= WSPAccept
;
2682 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2683 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2684 lpProcTable
->lpWSPBind
= WSPBind
;
2685 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2686 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2687 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2688 lpProcTable
->lpWSPConnect
= WSPConnect
;
2689 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2690 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2691 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2692 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2693 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2694 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2695 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2696 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2697 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2698 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2699 lpProcTable
->lpWSPListen
= WSPListen
;
2700 lpProcTable
->lpWSPRecv
= WSPRecv
;
2701 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2702 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2703 lpProcTable
->lpWSPSelect
= WSPSelect
;
2704 lpProcTable
->lpWSPSend
= WSPSend
;
2705 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2706 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2707 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2708 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2709 lpProcTable
->lpWSPSocket
= WSPSocket
;
2710 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2711 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2712 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2713 /* Save CatalogEntryId for all upcalls */
2714 CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
2717 TRACE("Status (%d).\n", Status
);
2724 WSPAddressToString(IN LPSOCKADDR lpsaAddress
,
2725 IN DWORD dwAddressLength
,
2726 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2727 OUT LPWSTR lpszAddressString
,
2728 IN OUT LPDWORD lpdwAddressStringLength
,
2732 WCHAR buffer
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2735 if (!lpsaAddress
|| !lpszAddressString
|| !lpdwAddressStringLength
)
2737 *lpErrno
= WSAEFAULT
;
2738 return SOCKET_ERROR
;
2741 switch (lpsaAddress
->sa_family
)
2744 if (dwAddressLength
< sizeof(SOCKADDR_IN
))
2746 *lpErrno
= WSAEINVAL
;
2747 return SOCKET_ERROR
;
2751 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 24 & 0xff),
2752 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 16 & 0xff),
2753 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 8 & 0xff),
2754 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) & 0xff),
2755 ntohs(((SOCKADDR_IN
*)lpsaAddress
)->sin_port
));
2757 p
= wcschr(buffer
, L
':');
2758 if (!((SOCKADDR_IN
*)lpsaAddress
)->sin_port
)
2764 *lpErrno
= WSAEINVAL
;
2765 return SOCKET_ERROR
;
2768 size
= wcslen(buffer
) + 1;
2770 if (*lpdwAddressStringLength
< size
)
2772 *lpdwAddressStringLength
= size
;
2773 *lpErrno
= WSAEFAULT
;
2774 return SOCKET_ERROR
;
2777 *lpdwAddressStringLength
= size
;
2778 wcscpy(lpszAddressString
, buffer
);
2784 WSPStringToAddress(IN LPWSTR AddressString
,
2785 IN INT AddressFamily
,
2786 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2787 OUT LPSOCKADDR lpAddress
,
2788 IN OUT LPINT lpAddressLength
,
2794 SOCKADDR_IN
*sockaddr
;
2796 if (!lpAddressLength
|| !lpAddress
|| !AddressString
)
2798 *lpErrno
= WSAEINVAL
;
2799 return SOCKET_ERROR
;
2802 sockaddr
= (SOCKADDR_IN
*)lpAddress
;
2804 /* Set right address family */
2805 if (lpProtocolInfo
!= NULL
)
2807 sockaddr
->sin_family
= lpProtocolInfo
->iAddressFamily
;
2811 sockaddr
->sin_family
= AddressFamily
;
2815 if (AddressFamily
== AF_INET
)
2817 if (*lpAddressLength
< (INT
)sizeof(SOCKADDR_IN
))
2819 *lpAddressLength
= sizeof(SOCKADDR_IN
);
2820 *lpErrno
= WSAEFAULT
;
2824 // translate ip string to ip
2826 /* rest sockaddr.sin_addr.s_addr
2827 for we need to be sure it is zero when we come to while */
2828 memset(lpAddress
, 0, sizeof(SOCKADDR_IN
));
2830 /* Set right adress family */
2831 sockaddr
->sin_family
= AF_INET
;
2833 /* Get port number */
2834 pos
= wcscspn(AddressString
, L
":") + 1;
2836 if (pos
< (int)wcslen(AddressString
))
2838 sockaddr
->sin_port
= wcstol(&AddressString
[pos
], bp
, 10);
2842 sockaddr
->sin_port
= 0;
2849 while (pos
< (int)wcslen(AddressString
))
2851 inetaddr
= (inetaddr
<< 8) +
2852 ((UCHAR
)wcstol(&AddressString
[pos
], bp
, 10));
2854 pos
+= wcscspn(&AddressString
[pos
], L
".") + 1;
2858 sockaddr
->sin_addr
.s_addr
= inetaddr
;
2868 return SOCKET_ERROR
;
2872 * FUNCTION: Cleans up service provider for a client
2874 * lpErrno = Address of buffer for error information
2876 * 0 if successful, or SOCKET_ERROR if not
2880 WSPCleanup(OUT LPINT lpErrno
)
2883 TRACE("Leaving.\n");
2884 *lpErrno
= NO_ERROR
;
2891 AfdInfoAPC(PVOID ApcContext
,
2892 PIO_STATUS_BLOCK IoStatusBlock
,
2895 PAFDAPCCONTEXT Context
= ApcContext
;
2897 Context
->lpCompletionRoutine(IoStatusBlock
->Status
, IoStatusBlock
->Information
, Context
->lpOverlapped
, 0);
2898 HeapFree(GlobalHeap
, 0, ApcContext
);
2902 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2903 ULONG AfdInformationClass
,
2904 PBOOLEAN Boolean OPTIONAL
,
2905 PULONG Ulong OPTIONAL
,
2906 PLARGE_INTEGER LargeInteger OPTIONAL
,
2907 LPWSAOVERLAPPED Overlapped OPTIONAL
,
2908 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
2910 PIO_STATUS_BLOCK IOSB
;
2911 IO_STATUS_BLOCK DummyIOSB
;
2915 PIO_APC_ROUTINE APCFunction
;
2916 HANDLE Event
= NULL
;
2919 Status
= NtCreateEvent(&SockEvent
,
2925 if( !NT_SUCCESS(Status
) )
2928 /* Set Info Class */
2929 InfoData
.InformationClass
= AfdInformationClass
;
2931 /* Verify if we should use APC */
2932 if (Overlapped
== NULL
)
2934 /* Not using Overlapped structure, so use normal blocking on event */
2942 /* Overlapped request for non overlapped opened socket */
2943 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
2945 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
2948 if (CompletionRoutine
== NULL
)
2950 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
2951 APCContext
= Overlapped
;
2953 Event
= Overlapped
->hEvent
;
2957 /* Using Overlapped Structure and a Completition Routine, so use an APC */
2958 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
2959 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
2962 ERR("Not enough memory for APC Context\n");
2965 ((PAFDAPCCONTEXT
)APCContext
)->lpCompletionRoutine
= CompletionRoutine
;
2966 ((PAFDAPCCONTEXT
)APCContext
)->lpOverlapped
= Overlapped
;
2967 ((PAFDAPCCONTEXT
)APCContext
)->lpSocket
= Socket
;
2970 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
2973 IOSB
->Status
= STATUS_PENDING
;
2976 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2987 /* Wait for return */
2988 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
2990 WaitForSingleObject(SockEvent
, INFINITE
);
2991 Status
= IOSB
->Status
;
2994 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
2996 if (Status
== STATUS_PENDING
)
2998 TRACE("Leaving (Pending)\n");
2999 return WSA_IO_PENDING
;
3002 if (Status
!= STATUS_SUCCESS
)
3005 /* Return Information */
3008 *Ulong
= InfoData
.Information
.Ulong
;
3010 if (LargeInteger
!= NULL
)
3012 *LargeInteger
= InfoData
.Information
.LargeInteger
;
3014 if (Boolean
!= NULL
)
3016 *Boolean
= InfoData
.Information
.Boolean
;
3019 NtClose( SockEvent
);
3027 SetSocketInformation(PSOCKET_INFORMATION Socket
,
3028 ULONG AfdInformationClass
,
3029 PBOOLEAN Boolean OPTIONAL
,
3030 PULONG Ulong OPTIONAL
,
3031 PLARGE_INTEGER LargeInteger OPTIONAL
,
3032 LPWSAOVERLAPPED Overlapped OPTIONAL
,
3033 LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL
)
3035 PIO_STATUS_BLOCK IOSB
;
3036 IO_STATUS_BLOCK DummyIOSB
;
3040 PIO_APC_ROUTINE APCFunction
;
3041 HANDLE Event
= NULL
;
3044 Status
= NtCreateEvent(&SockEvent
,
3050 if( !NT_SUCCESS(Status
) )
3053 /* Set Info Class */
3054 InfoData
.InformationClass
= AfdInformationClass
;
3056 /* Set Information */
3059 InfoData
.Information
.Ulong
= *Ulong
;
3061 if (LargeInteger
!= NULL
)
3063 InfoData
.Information
.LargeInteger
= *LargeInteger
;
3065 if (Boolean
!= NULL
)
3067 InfoData
.Information
.Boolean
= *Boolean
;
3070 /* Verify if we should use APC */
3071 if (Overlapped
== NULL
)
3073 /* Not using Overlapped structure, so use normal blocking on event */
3081 /* Overlapped request for non overlapped opened socket */
3082 if ((Socket
->SharedData
->CreateFlags
& SO_SYNCHRONOUS_NONALERT
) != 0)
3084 TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3087 if (CompletionRoutine
== NULL
)
3089 /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3090 APCContext
= Overlapped
;
3092 Event
= Overlapped
->hEvent
;
3096 /* Using Overlapped Structure and a Completition Routine, so use an APC */
3097 APCFunction
= &AfdInfoAPC
; // should be a private io completition function inside us
3098 APCContext
= HeapAlloc(GlobalHeap
, 0, sizeof(AFDAPCCONTEXT
));
3101 ERR("Not enough memory for APC Context\n");
3104 ((PAFDAPCCONTEXT
)APCContext
)->lpCompletionRoutine
= CompletionRoutine
;
3105 ((PAFDAPCCONTEXT
)APCContext
)->lpOverlapped
= Overlapped
;
3106 ((PAFDAPCCONTEXT
)APCContext
)->lpSocket
= Socket
;
3109 IOSB
= (PIO_STATUS_BLOCK
)&Overlapped
->Internal
;
3112 IOSB
->Status
= STATUS_PENDING
;
3115 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3126 /* Wait for return */
3127 if (Status
== STATUS_PENDING
&& Overlapped
== NULL
)
3129 WaitForSingleObject(SockEvent
, INFINITE
);
3130 Status
= IOSB
->Status
;
3133 NtClose( SockEvent
);
3135 TRACE("Status %x Information %d\n", Status
, IOSB
->Information
);
3137 if (Status
== STATUS_PENDING
)
3139 TRACE("Leaving (Pending)\n");
3140 return WSA_IO_PENDING
;
3143 return Status
== STATUS_SUCCESS
? 0 : -1;
3148 GetSocketStructure(SOCKET Handle
)
3150 PSOCKET_INFORMATION CurrentSocket
;
3152 EnterCriticalSection(&SocketListLock
);
3154 CurrentSocket
= SocketListHead
;
3155 while (CurrentSocket
)
3157 if (CurrentSocket
->Handle
== Handle
)
3159 LeaveCriticalSection(&SocketListLock
);
3160 return CurrentSocket
;
3163 CurrentSocket
= CurrentSocket
->NextSocket
;
3166 LeaveCriticalSection(&SocketListLock
);
3171 int CreateContext(PSOCKET_INFORMATION Socket
)
3173 IO_STATUS_BLOCK IOSB
;
3174 SOCKET_CONTEXT ContextData
;
3178 Status
= NtCreateEvent(&SockEvent
,
3184 if( !NT_SUCCESS(Status
) )
3187 /* Create Context */
3188 ContextData
.SharedData
= *Socket
->SharedData
;
3189 ContextData
.SizeOfHelperData
= 0;
3190 RtlCopyMemory (&ContextData
.LocalAddress
,
3191 Socket
->LocalAddress
,
3192 Socket
->SharedData
->SizeOfLocalAddress
);
3193 RtlCopyMemory (&ContextData
.RemoteAddress
,
3194 Socket
->RemoteAddress
,
3195 Socket
->SharedData
->SizeOfRemoteAddress
);
3198 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3203 IOCTL_AFD_SET_CONTEXT
,
3205 sizeof(ContextData
),
3209 /* Wait for Completition */
3210 if (Status
== STATUS_PENDING
)
3212 WaitForSingleObject(SockEvent
, INFINITE
);
3213 Status
= IOSB
.Status
;
3216 NtClose( SockEvent
);
3218 return Status
== STATUS_SUCCESS
? 0 : -1;
3221 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
3223 HANDLE hAsyncThread
;
3224 DWORD AsyncThreadId
;
3226 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3229 /* Check if the Thread Already Exists */
3230 if (SockAsyncThreadRefCount
)
3232 ASSERT(SockAsyncCompletionPort
);
3236 /* Create the Completion Port */
3237 if (!SockAsyncCompletionPort
)
3239 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
3240 IO_COMPLETION_ALL_ACCESS
,
3242 2); // Allow 2 threads only
3243 if (!NT_SUCCESS(Status
))
3245 ERR("Failed to create completion port: 0x%08x\n", Status
);
3248 /* Protect Handle */
3249 HandleFlags
.ProtectFromClose
= TRUE
;
3250 HandleFlags
.Inherit
= FALSE
;
3251 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
3252 ObjectHandleFlagInformation
,
3254 sizeof(HandleFlags
));
3257 /* Create the Async Event */
3258 Status
= NtCreateEvent(&AsyncEvent
,
3264 /* Create the Async Thread */
3265 hAsyncThread
= CreateThread(NULL
,
3267 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
3272 /* Close the Handle */
3273 NtClose(hAsyncThread
);
3275 /* Increase the Reference Count */
3276 SockAsyncThreadRefCount
++;
3280 int SockAsyncThread(PVOID ThreadParam
)
3283 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
3284 IO_STATUS_BLOCK IOSB
;
3287 /* Make the Thread Higher Priority */
3288 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
3290 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3293 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
3294 (PVOID
*)&AsyncCompletionRoutine
,
3298 /* Call the Async Function */
3299 if (NT_SUCCESS(Status
))
3301 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
3305 /* It Failed, sleep for a second */
3308 } while ((Status
!= STATUS_TIMEOUT
));
3310 /* The Thread has Ended */
3314 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
3316 UNICODE_STRING AfdHelper
;
3317 OBJECT_ATTRIBUTES ObjectAttributes
;
3318 IO_STATUS_BLOCK IoSb
;
3319 FILE_COMPLETION_INFORMATION CompletionInfo
;
3320 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3322 /* First, make sure we're not already intialized */
3323 if (SockAsyncHelperAfdHandle
)
3328 /* Set up Handle Name and Object */
3329 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
3330 InitializeObjectAttributes(&ObjectAttributes
,
3332 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
3336 /* Open the Handle to AFD */
3337 NtCreateFile(&SockAsyncHelperAfdHandle
,
3338 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
3343 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3350 * Now Set up the Completion Port Information
3351 * This means that whenever a Poll is finished, the routine will be executed
3353 CompletionInfo
.Port
= SockAsyncCompletionPort
;
3354 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
3355 NtSetInformationFile(SockAsyncHelperAfdHandle
,
3358 sizeof(CompletionInfo
),
3359 FileCompletionInformation
);
3362 /* Protect the Handle */
3363 HandleFlags
.ProtectFromClose
= TRUE
;
3364 HandleFlags
.Inherit
= FALSE
;
3365 NtSetInformationObject(SockAsyncCompletionPort
,
3366 ObjectHandleFlagInformation
,
3368 sizeof(HandleFlags
));
3371 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
3372 SockAsyncSelectCalled
= TRUE
;
3376 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3379 PASYNC_DATA AsyncData
= Context
;
3380 PSOCKET_INFORMATION Socket
;
3383 /* Get the Socket */
3384 Socket
= AsyncData
->ParentSocket
;
3386 /* Check if the Sequence Number Changed behind our back */
3387 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
->SequenceNumber
)
3392 /* Check we were manually called b/c of a failure */
3393 if (!NT_SUCCESS(IoStatusBlock
->Status
))
3395 /* FIXME: Perform Upcall */
3399 for (x
= 1; x
; x
<<=1)
3401 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
3403 case AFD_EVENT_RECEIVE
:
3404 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_READ
) &&
3405 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_READ
))
3407 /* Make the Notifcation */
3408 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3409 Socket
->SharedData
->wMsg
,
3411 WSAMAKESELECTREPLY(FD_READ
, 0));
3412 /* Disable this event until the next read(); */
3413 Socket
->SharedData
->AsyncDisabledEvents
|= FD_READ
;
3417 case AFD_EVENT_OOB_RECEIVE
:
3418 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_OOB
) &&
3419 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_OOB
))
3421 /* Make the Notifcation */
3422 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3423 Socket
->SharedData
->wMsg
,
3425 WSAMAKESELECTREPLY(FD_OOB
, 0));
3426 /* Disable this event until the next read(); */
3427 Socket
->SharedData
->AsyncDisabledEvents
|= FD_OOB
;
3431 case AFD_EVENT_SEND
:
3432 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_WRITE
) &&
3433 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_WRITE
))
3435 /* Make the Notifcation */
3436 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3437 Socket
->SharedData
->wMsg
,
3439 WSAMAKESELECTREPLY(FD_WRITE
, 0));
3440 /* Disable this event until the next write(); */
3441 Socket
->SharedData
->AsyncDisabledEvents
|= FD_WRITE
;
3445 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3446 case AFD_EVENT_CONNECT
:
3447 case AFD_EVENT_CONNECT_FAIL
:
3448 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
) &&
3449 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CONNECT
))
3451 /* Make the Notifcation */
3452 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3453 Socket
->SharedData
->wMsg
,
3455 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
3456 /* Disable this event forever; */
3457 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
;
3461 case AFD_EVENT_ACCEPT
:
3462 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_ACCEPT
) &&
3463 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_ACCEPT
))
3465 /* Make the Notifcation */
3466 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3467 Socket
->SharedData
->wMsg
,
3469 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
3470 /* Disable this event until the next accept(); */
3471 Socket
->SharedData
->AsyncDisabledEvents
|= FD_ACCEPT
;
3475 case AFD_EVENT_DISCONNECT
:
3476 case AFD_EVENT_ABORT
:
3477 case AFD_EVENT_CLOSE
:
3478 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CLOSE
) &&
3479 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CLOSE
))
3481 /* Make the Notifcation */
3482 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3483 Socket
->SharedData
->wMsg
,
3485 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
3486 /* Disable this event forever; */
3487 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CLOSE
;
3490 /* FIXME: Support QOS */
3494 /* Check if there are any events left for us to check */
3495 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3501 SockProcessAsyncSelect(Socket
, AsyncData
);
3505 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
3508 ULONG lNetworkEvents
;
3511 /* Set up the Async Data Event Info */
3512 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
3513 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
3514 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
3515 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
3516 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
3517 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
3519 /* Remove unwanted events */
3520 lNetworkEvents
= Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
);
3522 /* Set Events to wait for */
3523 if (lNetworkEvents
& FD_READ
)
3525 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
3528 if (lNetworkEvents
& FD_WRITE
)
3530 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
3533 if (lNetworkEvents
& FD_OOB
)
3535 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
3538 if (lNetworkEvents
& FD_ACCEPT
)
3540 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
3543 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3544 if (lNetworkEvents
& FD_CONNECT
)
3546 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
3549 if (lNetworkEvents
& FD_CLOSE
)
3551 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
3554 if (lNetworkEvents
& FD_QOS
)
3556 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
3559 if (lNetworkEvents
& FD_GROUP_QOS
)
3561 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
3565 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
3569 &AsyncData
->IoStatusBlock
,
3571 &AsyncData
->AsyncSelectInfo
,
3572 sizeof(AsyncData
->AsyncSelectInfo
),
3573 &AsyncData
->AsyncSelectInfo
,
3574 sizeof(AsyncData
->AsyncSelectInfo
));
3576 /* I/O Manager Won't call the completion routine, let's do it manually */
3577 if (NT_SUCCESS(Status
))
3583 AsyncData
->IoStatusBlock
.Status
= Status
;
3584 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3588 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3590 PASYNC_DATA AsyncData
= Context
;
3591 BOOL FreeContext
= TRUE
;
3592 PSOCKET_INFORMATION Socket
;
3594 /* Get the Socket */
3595 Socket
= AsyncData
->ParentSocket
;
3597 /* If someone closed it, stop the function */
3598 if (Socket
->SharedData
->State
!= SocketClosed
)
3600 /* Check if the Sequence Number changed by now, in which case quit */
3601 if (AsyncData
->SequenceNumber
== Socket
->SharedData
->SequenceNumber
)
3603 /* Do the actuall select, if needed */
3604 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)))
3606 SockProcessAsyncSelect(Socket
, AsyncData
);
3607 FreeContext
= FALSE
;
3612 /* Free the Context */
3615 HeapFree(GetProcessHeap(), 0, AsyncData
);
3622 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3625 PASYNC_DATA AsyncData
;
3627 /* Make sure the event is actually disabled */
3628 if (!(Socket
->SharedData
->AsyncDisabledEvents
& Event
))
3634 Socket
->SharedData
->AsyncDisabledEvents
&= ~Event
;
3636 /* Return if no more events are being polled */
3637 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3642 /* Wait on new events */
3643 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
3644 if (!AsyncData
) return;
3646 /* Create the Asynch Thread if Needed */
3647 SockCreateOrReferenceAsyncThread();
3649 /* Increase the sequence number to stop anything else */
3650 Socket
->SharedData
->SequenceNumber
++;
3652 /* Set up the Async Data */
3653 AsyncData
->ParentSocket
= Socket
;
3654 AsyncData
->SequenceNumber
= Socket
->SharedData
->SequenceNumber
;
3656 /* Begin Async Select by using I/O Completion */
3657 NtSetIoCompletion(SockAsyncCompletionPort
,
3658 (PVOID
)&SockProcessQueuedAsyncSelect
,
3669 DllMain(HANDLE hInstDll
,
3676 case DLL_PROCESS_ATTACH
:
3678 TRACE("Loading MSAFD.DLL \n");
3680 /* Don't need thread attach notifications
3681 so disable them to improve performance */
3682 DisableThreadLibraryCalls(hInstDll
);
3684 /* List of DLL Helpers */
3685 InitializeListHead(&SockHelpersListHead
);
3687 /* Heap to use when allocating */
3688 GlobalHeap
= GetProcessHeap();
3690 /* Initialize the lock that protects our socket list */
3691 InitializeCriticalSection(&SocketListLock
);
3693 TRACE("MSAFD.DLL has been loaded\n");
3697 case DLL_THREAD_ATTACH
:
3700 case DLL_THREAD_DETACH
:
3703 case DLL_PROCESS_DETACH
:
3705 /* Delete the socket list lock */
3706 DeleteCriticalSection(&SocketListLock
);
3711 TRACE("DllMain of msafd.dll (leaving)\n");