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
, AFD_INFO_GROUP_ID_TYPE
, NULL
, NULL
, &GroupData
);
356 Socket
->SharedData
->GroupID
= GroupData
.u
.LowPart
;
357 Socket
->SharedData
->GroupType
= GroupData
.u
.HighPart
;
360 /* Get Window Sizes and Save them */
361 GetSocketInformation (Socket
,
362 AFD_INFO_SEND_WINDOW_SIZE
,
364 &Socket
->SharedData
->SizeOfSendBuffer
,
367 GetSocketInformation (Socket
,
368 AFD_INFO_RECEIVE_WINDOW_SIZE
,
370 &Socket
->SharedData
->SizeOfRecvBuffer
,
374 /* Save in Process Sockets List */
375 EnterCriticalSection(&SocketListLock
);
376 Socket
->NextSocket
= SocketListHead
;
377 SocketListHead
= Socket
;
378 LeaveCriticalSection(&SocketListLock
);
380 /* Create the Socket Context */
381 CreateContext(Socket
);
384 Upcalls
.lpWPUModifyIFSHandle(Socket
->ProtocolInfo
.dwCatalogEntryId
, (SOCKET
)Sock
, lpErrno
);
386 /* Return Socket Handle */
387 TRACE("Success %x\n", Sock
);
392 ERR("Ending %x\n", Status
);
396 UnmapViewOfFile(SharedData
);
397 NtClose((HANDLE
)lpProtocolInfo
->dwServiceFlags3
);
401 if( Socket
&& Socket
->SharedData
)
402 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
406 HeapFree(GlobalHeap
, 0, Socket
);
409 HeapFree(GlobalHeap
, 0, EABuffer
);
414 return INVALID_SOCKET
;
422 IN DWORD dwProcessId
,
423 OUT LPWSAPROTOCOL_INFOW lpProtocolInfo
,
426 HANDLE hProcess
, hDuplicatedSharedData
, hDuplicatedHandle
;
427 PSOCKET_INFORMATION Socket
;
428 PSOCK_SHARED_INFO pSharedData
, pOldSharedData
;
431 if (Handle
== INVALID_SOCKET
)
432 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
433 Socket
= GetSocketStructure(Handle
);
437 *lpErrno
= WSAENOTSOCK
;
440 if ( !(hProcess
= OpenProcess(PROCESS_DUP_HANDLE
, FALSE
, dwProcessId
)) )
441 return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER
, lpErrno
, 0, NULL
);
443 /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
444 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
446 Socket
->SharedDataHandle
= CreateFileMapping(INVALID_HANDLE_VALUE
,
448 PAGE_READWRITE
| SEC_COMMIT
,
450 (sizeof(SOCK_SHARED_INFO
) + PAGE_SIZE
- 1) & ~(PAGE_SIZE
- 1),
452 if( Socket
->SharedDataHandle
== INVALID_HANDLE_VALUE
)
453 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
454 pSharedData
= MapViewOfFile(Socket
->SharedDataHandle
,
458 sizeof(SOCK_SHARED_INFO
));
460 RtlCopyMemory(pSharedData
, Socket
->SharedData
, sizeof(SOCK_SHARED_INFO
));
461 pOldSharedData
= Socket
->SharedData
;
462 Socket
->SharedData
= pSharedData
;
463 HeapFree(GlobalHeap
, 0, pOldSharedData
);
465 /* Duplicate the handles for the new process */
466 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
467 Socket
->SharedDataHandle
,
469 (LPHANDLE
)&hDuplicatedSharedData
,
472 DUPLICATE_SAME_ACCESS
);
476 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
478 bDuplicated
= DuplicateHandle(GetCurrentProcess(),
479 (HANDLE
)Socket
->Handle
,
481 (LPHANDLE
)&hDuplicatedHandle
,
484 DUPLICATE_SAME_ACCESS
);
487 return MsafdReturnWithErrno(STATUS_ACCESS_DENIED
, lpErrno
, 0, NULL
);
491 return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION
, lpErrno
, 0, NULL
);
493 RtlCopyMemory(lpProtocolInfo
, &Socket
->ProtocolInfo
, sizeof(*lpProtocolInfo
));
495 lpProtocolInfo
->iAddressFamily
= Socket
->SharedData
->AddressFamily
;
496 lpProtocolInfo
->iProtocol
= Socket
->SharedData
->Protocol
;
497 lpProtocolInfo
->iSocketType
= Socket
->SharedData
->SocketType
;
498 lpProtocolInfo
->dwServiceFlags3
= (DWORD
)hDuplicatedSharedData
;
499 lpProtocolInfo
->dwServiceFlags4
= (DWORD
)hDuplicatedHandle
;
508 TranslateNtStatusError(NTSTATUS Status
)
512 case STATUS_CANT_WAIT
:
513 return WSAEWOULDBLOCK
;
521 case STATUS_FILE_CLOSED
:
522 return WSAECONNRESET
;
524 case STATUS_END_OF_FILE
:
528 return WSA_IO_PENDING
;
530 case STATUS_BUFFER_TOO_SMALL
:
531 case STATUS_BUFFER_OVERFLOW
:
534 case STATUS_NO_MEMORY
:
535 case STATUS_INSUFFICIENT_RESOURCES
:
538 case STATUS_INVALID_CONNECTION
:
541 case STATUS_PROTOCOL_NOT_SUPPORTED
:
542 return WSAEAFNOSUPPORT
;
544 case STATUS_INVALID_ADDRESS
:
545 return WSAEADDRNOTAVAIL
;
547 case STATUS_REMOTE_NOT_LISTENING
:
548 case STATUS_REMOTE_DISCONNECT
:
549 return WSAECONNREFUSED
;
551 case STATUS_NETWORK_UNREACHABLE
:
552 return WSAENETUNREACH
;
554 case STATUS_INVALID_PARAMETER
:
557 case STATUS_CANCELLED
:
558 return WSA_OPERATION_ABORTED
;
560 case STATUS_ADDRESS_ALREADY_EXISTS
:
561 return WSAEADDRINUSE
;
563 case STATUS_LOCAL_DISCONNECT
:
564 return WSAECONNABORTED
;
566 case STATUS_ACCESS_VIOLATION
:
569 case STATUS_ACCESS_DENIED
:
573 ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
579 * FUNCTION: Closes an open socket
581 * s = Socket descriptor
582 * lpErrno = Address of buffer for error information
584 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
588 WSPCloseSocket(IN SOCKET Handle
,
591 IO_STATUS_BLOCK IoStatusBlock
;
592 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
595 AFD_DISCONNECT_INFO DisconnectInfo
;
596 SOCKET_STATE OldState
;
597 LONG LingerWait
= -1;
600 /* Create the Wait Event */
601 Status
= NtCreateEvent(&SockEvent
,
607 if(!NT_SUCCESS(Status
))
609 ERR("NtCreateEvent failed: 0x%08x", Status
);
612 /* Get the Socket Structure associate to this Socket*/
613 Socket
= GetSocketStructure(Handle
);
617 *lpErrno
= WSAENOTSOCK
;
621 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
623 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
625 Socket
->TdiAddressHandle
,
626 Socket
->TdiConnectionHandle
,
631 if (lpErrno
) *lpErrno
= Status
;
632 ERR("WSHNotify failed. Error 0x%#x", Status
);
638 /* If a Close is already in Process, give up */
639 if (Socket
->SharedData
->State
== SocketClosed
)
641 WARN("Socket is closing.\n");
643 *lpErrno
= WSAENOTSOCK
;
646 /* Set the state to close */
647 OldState
= Socket
->SharedData
->State
;
648 Socket
->SharedData
->State
= SocketClosed
;
650 /* Decrement reference count on SharedData */
651 References
= InterlockedDecrement(&Socket
->SharedData
->RefCount
);
655 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
656 /* FIXME: Should we do this on Datagram Sockets too? */
657 if ((OldState
== SocketConnected
) && (Socket
->SharedData
->LingerData
.l_onoff
))
659 ULONG SendsInProgress
;
662 /* We need to respect the timeout */
664 LingerWait
= Socket
->SharedData
->LingerData
.l_linger
* 1000;
666 /* Loop until no more sends are pending, within the timeout */
669 /* Find out how many Sends are in Progress */
670 if (GetSocketInformation(Socket
,
671 AFD_INFO_SENDS_IN_PROGRESS
,
676 /* Bail out if anything but NO_ERROR */
681 /* Bail out if no more sends are pending */
682 if (!SendsInProgress
)
689 * We have to execute a sleep, so it's kind of like
690 * a block. If the socket is Nonblock, we cannot
691 * go on since asyncronous operation is expected
692 * and we cannot offer it
694 if (Socket
->SharedData
->NonBlocking
)
696 WARN("Would block!\n");
698 Socket
->SharedData
->State
= OldState
;
699 *lpErrno
= WSAEWOULDBLOCK
;
703 /* Now we can sleep, and decrement the linger wait */
705 * FIXME: It seems Windows does some funky acceleration
706 * since the waiting seems to be longer and longer. I
707 * don't think this improves performance so much, so we
708 * wait a fixed time instead.
711 LingerWait
-= SleepWait
;
715 if (OldState
== SocketConnected
)
719 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
720 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
722 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
->SendShutdown
)) ||
723 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
->ReceiveShutdown
)))
726 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
731 IOCTL_AFD_DISCONNECT
,
733 sizeof(DisconnectInfo
),
737 /* Wait for return */
738 if (Status
== STATUS_PENDING
)
740 WaitForSingleObject(SockEvent
, INFINITE
);
741 Status
= IoStatusBlock
.Status
;
748 Socket
->HelperContext
= NULL
;
749 Socket
->SharedData
->AsyncDisabledEvents
= -1;
750 NtClose(Socket
->TdiAddressHandle
);
751 Socket
->TdiAddressHandle
= NULL
;
752 NtClose(Socket
->TdiConnectionHandle
);
753 Socket
->TdiConnectionHandle
= NULL
;
755 EnterCriticalSection(&SocketListLock
);
756 if (SocketListHead
== Socket
)
758 SocketListHead
= SocketListHead
->NextSocket
;
762 CurrentSocket
= SocketListHead
;
763 while (CurrentSocket
->NextSocket
)
765 if (CurrentSocket
->NextSocket
== Socket
)
767 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
771 CurrentSocket
= CurrentSocket
->NextSocket
;
774 LeaveCriticalSection(&SocketListLock
);
776 /* Close the handle */
777 NtClose((HANDLE
)Handle
);
780 if( Socket
->SharedDataHandle
!= INVALID_HANDLE_VALUE
)
782 /* It is a duplicated socket, so unmap the memory */
783 UnmapViewOfFile(Socket
->SharedData
);
784 NtClose(Socket
->SharedDataHandle
);
785 Socket
->SharedData
= NULL
;
787 if( !References
&& Socket
->SharedData
)
789 HeapFree(GlobalHeap
, 0, Socket
->SharedData
);
791 HeapFree(GlobalHeap
, 0, Socket
);
792 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
797 * FUNCTION: Associates a local address with a socket
799 * s = Socket descriptor
800 * name = Pointer to local address
801 * namelen = Length of name
802 * lpErrno = Address of buffer for error information
804 * 0, or SOCKET_ERROR if the socket could not be bound
808 WSPBind(SOCKET Handle
,
809 const struct sockaddr
*SocketAddress
,
810 int SocketAddressLength
,
813 IO_STATUS_BLOCK IOSB
;
814 PAFD_BIND_DATA BindData
;
815 PSOCKET_INFORMATION Socket
= NULL
;
817 SOCKADDR_INFO SocketInfo
;
821 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
824 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
827 Status
= NtCreateEvent(&SockEvent
,
833 if (!NT_SUCCESS(Status
))
835 HeapFree(GlobalHeap
, 0, BindData
);
839 /* Get the Socket Structure associate to this Socket*/
840 Socket
= GetSocketStructure(Handle
);
843 HeapFree(GlobalHeap
, 0, BindData
);
844 *lpErrno
= WSAENOTSOCK
;
848 /* Set up Address in TDI Format */
849 BindData
->Address
.TAAddressCount
= 1;
850 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
851 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
852 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
853 SocketAddress
->sa_data
,
854 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
856 /* Get Address Information */
857 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
861 /* Set the Share Type */
862 if (Socket
->SharedData
->ExclusiveAddressUse
)
864 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
866 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
868 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
870 else if (Socket
->SharedData
->ReuseAddresses
)
872 BindData
->ShareType
= AFD_SHARE_REUSE
;
876 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
880 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
887 0xA + Socket
->SharedData
->SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
889 0xA + Socket
->SharedData
->SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
891 /* Wait for return */
892 if (Status
== STATUS_PENDING
)
894 WaitForSingleObject(SockEvent
, INFINITE
);
895 Status
= IOSB
.Status
;
898 NtClose( SockEvent
);
899 HeapFree(GlobalHeap
, 0, BindData
);
901 if (Status
!= STATUS_SUCCESS
)
902 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
904 /* Set up Socket Data */
905 Socket
->SharedData
->State
= SocketBound
;
906 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
908 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
910 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
912 Socket
->TdiAddressHandle
,
913 Socket
->TdiConnectionHandle
,
918 if (lpErrno
) *lpErrno
= Status
;
923 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
928 WSPListen(SOCKET Handle
,
932 IO_STATUS_BLOCK IOSB
;
933 AFD_LISTEN_DATA ListenData
;
934 PSOCKET_INFORMATION Socket
= NULL
;
938 /* Get the Socket Structure associate to this Socket*/
939 Socket
= GetSocketStructure(Handle
);
942 *lpErrno
= WSAENOTSOCK
;
946 if (Socket
->SharedData
->Listening
)
949 Status
= NtCreateEvent(&SockEvent
,
955 if( !NT_SUCCESS(Status
) )
958 /* Set Up Listen Structure */
959 ListenData
.UseSAN
= FALSE
;
960 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
->UseDelayedAcceptance
;
961 ListenData
.Backlog
= Backlog
;
964 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
969 IOCTL_AFD_START_LISTEN
,
975 /* Wait for return */
976 if (Status
== STATUS_PENDING
)
978 WaitForSingleObject(SockEvent
, INFINITE
);
979 Status
= IOSB
.Status
;
982 NtClose( SockEvent
);
984 if (Status
!= STATUS_SUCCESS
)
985 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
987 /* Set to Listening */
988 Socket
->SharedData
->Listening
= TRUE
;
990 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
992 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
994 Socket
->TdiAddressHandle
,
995 Socket
->TdiConnectionHandle
,
1000 if (lpErrno
) *lpErrno
= Status
;
1001 return SOCKET_ERROR
;
1005 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1011 WSPSelect(IN
int nfds
,
1012 IN OUT fd_set
*readfds OPTIONAL
,
1013 IN OUT fd_set
*writefds OPTIONAL
,
1014 IN OUT fd_set
*exceptfds OPTIONAL
,
1015 IN
const struct timeval
*timeout OPTIONAL
,
1018 IO_STATUS_BLOCK IOSB
;
1019 PAFD_POLL_INFO PollInfo
;
1023 ULONG PollBufferSize
;
1028 LARGE_INTEGER Timeout
;
1030 /* Find out how many sockets we have, and how large the buffer needs
1033 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
1034 ( writefds
? writefds
->fd_count
: 0 ) +
1035 ( exceptfds
? exceptfds
->fd_count
: 0 );
1037 if ( HandleCount
== 0 )
1039 WARN("No handles! Returning SOCKET_ERROR\n", HandleCount
);
1040 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1041 return SOCKET_ERROR
;
1044 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
1046 TRACE("HandleCount: %u BufferSize: %u\n", HandleCount
, PollBufferSize
);
1048 /* Convert Timeout to NT Format */
1049 if (timeout
== NULL
)
1051 Timeout
.u
.LowPart
= -1;
1052 Timeout
.u
.HighPart
= 0x7FFFFFFF;
1053 TRACE("Infinite timeout\n");
1057 Timeout
= RtlEnlargedIntegerMultiply
1058 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
1059 /* Negative timeouts are illegal. Since the kernel represents an
1060 * incremental timeout as a negative number, we check for a positive
1063 if (Timeout
.QuadPart
> 0)
1065 if (lpErrno
) *lpErrno
= WSAEINVAL
;
1066 return SOCKET_ERROR
;
1068 TRACE("Timeout: Orig %d.%06d kernel %d\n",
1069 timeout
->tv_sec
, timeout
->tv_usec
,
1073 Status
= NtCreateEvent(&SockEvent
,
1079 if(!NT_SUCCESS(Status
))
1082 *lpErrno
= WSAEFAULT
;
1084 ERR("NtCreateEvent failed, 0x%08x\n", Status
);
1085 return SOCKET_ERROR
;
1089 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
1094 *lpErrno
= WSAEFAULT
;
1096 return SOCKET_ERROR
;
1099 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
1101 RtlZeroMemory( PollInfo
, PollBufferSize
);
1103 /* Number of handles for AFD to Check */
1104 PollInfo
->Exclusive
= FALSE
;
1105 PollInfo
->Timeout
= Timeout
;
1107 if (readfds
!= NULL
) {
1108 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
1110 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
1111 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
1112 AFD_EVENT_DISCONNECT
|
1118 if (writefds
!= NULL
)
1120 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
1122 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
1123 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
1126 if (exceptfds
!= NULL
)
1128 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
1130 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
1131 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
1135 PollInfo
->HandleCount
= j
;
1136 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
1139 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
1150 TRACE("DeviceIoControlFile => %x\n", Status
);
1152 /* Wait for Completition */
1153 if (Status
== STATUS_PENDING
)
1155 WaitForSingleObject(SockEvent
, INFINITE
);
1156 Status
= IOSB
.Status
;
1159 /* Clear the Structures */
1167 /* Loop through return structure */
1168 HandleCount
= PollInfo
->HandleCount
;
1170 /* Return in FDSET Format */
1171 for (i
= 0; i
< HandleCount
; i
++)
1173 HandleCounted
= FALSE
;
1174 for(x
= 1; x
; x
<<=1)
1176 switch (PollInfo
->Handles
[i
].Events
& x
)
1178 case AFD_EVENT_RECEIVE
:
1179 case AFD_EVENT_DISCONNECT
:
1180 case AFD_EVENT_ABORT
:
1181 case AFD_EVENT_ACCEPT
:
1182 case AFD_EVENT_CLOSE
:
1183 TRACE("Event %x on handle %x\n",
1184 PollInfo
->Handles
[i
].Events
,
1185 PollInfo
->Handles
[i
].Handle
);
1186 if (! HandleCounted
)
1189 HandleCounted
= TRUE
;
1192 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
1194 case AFD_EVENT_SEND
:
1195 case AFD_EVENT_CONNECT
:
1196 TRACE("Event %x on handle %x\n",
1197 PollInfo
->Handles
[i
].Events
,
1198 PollInfo
->Handles
[i
].Handle
);
1199 if (! HandleCounted
)
1202 HandleCounted
= TRUE
;
1205 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
1207 case AFD_EVENT_OOB_RECEIVE
:
1208 case AFD_EVENT_CONNECT_FAIL
:
1209 TRACE("Event %x on handle %x\n",
1210 PollInfo
->Handles
[i
].Events
,
1211 PollInfo
->Handles
[i
].Handle
);
1212 if (! HandleCounted
)
1215 HandleCounted
= TRUE
;
1218 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1224 HeapFree( GlobalHeap
, 0, PollBuffer
);
1225 NtClose( SockEvent
);
1229 switch( IOSB
.Status
)
1231 case STATUS_SUCCESS
:
1232 case STATUS_TIMEOUT
:
1236 *lpErrno
= WSAEINVAL
;
1239 TRACE("*lpErrno = %x\n", *lpErrno
);
1242 TRACE("%d events\n", OutCount
);
1249 WSPAccept(SOCKET Handle
,
1250 struct sockaddr
*SocketAddress
,
1251 int *SocketAddressLength
,
1252 LPCONDITIONPROC lpfnCondition
,
1253 DWORD dwCallbackData
,
1256 IO_STATUS_BLOCK IOSB
;
1257 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1258 AFD_ACCEPT_DATA AcceptData
;
1259 AFD_DEFER_ACCEPT_DATA DeferData
;
1260 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1261 PSOCKET_INFORMATION Socket
= NULL
;
1263 struct fd_set ReadSet
;
1264 struct timeval Timeout
;
1265 PVOID PendingData
= NULL
;
1266 ULONG PendingDataLength
= 0;
1267 PVOID CalleeDataBuffer
;
1268 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1269 PSOCKADDR RemoteAddress
= NULL
;
1272 SOCKET AcceptSocket
;
1273 PSOCKET_INFORMATION AcceptSocketInfo
;
1274 UCHAR ReceiveBuffer
[0x1A];
1277 Status
= NtCreateEvent(&SockEvent
,
1283 if( !NT_SUCCESS(Status
) )
1285 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1286 return INVALID_SOCKET
;
1289 /* Dynamic Structure...ugh */
1290 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1292 /* Get the Socket Structure associate to this Socket*/
1293 Socket
= GetSocketStructure(Handle
);
1297 *lpErrno
= WSAENOTSOCK
;
1298 return INVALID_SOCKET
;
1301 /* If this is non-blocking, make sure there's something for us to accept */
1303 FD_SET(Socket
->Handle
, &ReadSet
);
1307 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1310 return INVALID_SOCKET
;
1313 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1316 *lpErrno
= WSAEWOULDBLOCK
;
1317 return INVALID_SOCKET
;
1321 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1326 IOCTL_AFD_WAIT_FOR_LISTEN
,
1330 0xA + sizeof(*ListenReceiveData
));
1332 /* Wait for return */
1333 if (Status
== STATUS_PENDING
)
1335 WaitForSingleObject(SockEvent
, INFINITE
);
1336 Status
= IOSB
.Status
;
1339 if (!NT_SUCCESS(Status
))
1341 NtClose( SockEvent
);
1342 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1343 return INVALID_SOCKET
;
1346 if (lpfnCondition
!= NULL
)
1348 if ((Socket
->SharedData
->ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1350 /* Find out how much data is pending */
1351 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1352 PendingAcceptData
.ReturnSize
= TRUE
;
1355 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1360 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1362 sizeof(PendingAcceptData
),
1364 sizeof(PendingAcceptData
));
1366 /* Wait for return */
1367 if (Status
== STATUS_PENDING
)
1369 WaitForSingleObject(SockEvent
, INFINITE
);
1370 Status
= IOSB
.Status
;
1373 if (!NT_SUCCESS(Status
))
1375 NtClose( SockEvent
);
1376 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1377 return INVALID_SOCKET
;
1380 /* How much data to allocate */
1381 PendingDataLength
= IOSB
.Information
;
1383 if (PendingDataLength
)
1385 /* Allocate needed space */
1386 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1389 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1390 return INVALID_SOCKET
;
1393 /* We want the data now */
1394 PendingAcceptData
.ReturnSize
= FALSE
;
1397 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1402 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1404 sizeof(PendingAcceptData
),
1408 /* Wait for return */
1409 if (Status
== STATUS_PENDING
)
1411 WaitForSingleObject(SockEvent
, INFINITE
);
1412 Status
= IOSB
.Status
;
1415 if (!NT_SUCCESS(Status
))
1417 NtClose( SockEvent
);
1418 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1419 return INVALID_SOCKET
;
1424 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1426 /* I don't support this yet */
1429 /* Build Callee ID */
1430 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1431 CalleeID
.len
= Socket
->SharedData
->SizeOfLocalAddress
;
1433 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1436 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1437 return INVALID_SOCKET
;
1440 /* Set up Address in SOCKADDR Format */
1441 RtlCopyMemory (RemoteAddress
,
1442 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1443 sizeof(*RemoteAddress
));
1445 /* Build Caller ID */
1446 CallerID
.buf
= (PVOID
)RemoteAddress
;
1447 CallerID
.len
= sizeof(*RemoteAddress
);
1449 /* Build Caller Data */
1450 CallerData
.buf
= PendingData
;
1451 CallerData
.len
= PendingDataLength
;
1453 /* Check if socket supports Conditional Accept */
1454 if (Socket
->SharedData
->UseDelayedAcceptance
!= 0)
1456 /* Allocate Buffer for Callee Data */
1457 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1458 if (!CalleeDataBuffer
) {
1459 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1460 return INVALID_SOCKET
;
1462 CalleeData
.buf
= CalleeDataBuffer
;
1463 CalleeData
.len
= 4096;
1472 /* Call the Condition Function */
1473 CallBack
= (lpfnCondition
)(&CallerID
,
1474 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1478 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1482 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1484 /* TBD: Check for Validity */
1487 if (CallBack
== CF_ACCEPT
)
1489 if ((Socket
->SharedData
->ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1491 /* I don't support this yet */
1495 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1500 /* Callback rejected. Build Defer Structure */
1501 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1502 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1505 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1510 IOCTL_AFD_DEFER_ACCEPT
,
1516 /* Wait for return */
1517 if (Status
== STATUS_PENDING
)
1519 WaitForSingleObject(SockEvent
, INFINITE
);
1520 Status
= IOSB
.Status
;
1523 NtClose( SockEvent
);
1525 if (!NT_SUCCESS(Status
))
1527 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1528 return INVALID_SOCKET
;
1531 if (CallBack
== CF_REJECT
)
1533 *lpErrno
= WSAECONNREFUSED
;
1534 return INVALID_SOCKET
;
1538 *lpErrno
= WSAECONNREFUSED
;
1539 return INVALID_SOCKET
;
1544 /* Create a new Socket */
1545 AcceptSocket
= WSPSocket (Socket
->SharedData
->AddressFamily
,
1546 Socket
->SharedData
->SocketType
,
1547 Socket
->SharedData
->Protocol
,
1548 &Socket
->ProtocolInfo
,
1550 Socket
->SharedData
->CreateFlags
,
1552 if (AcceptSocket
== INVALID_SOCKET
)
1553 return INVALID_SOCKET
;
1555 /* Set up the Accept Structure */
1556 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1557 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1559 /* Send IOCTL to Accept */
1560 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1571 /* Wait for return */
1572 if (Status
== STATUS_PENDING
)
1574 WaitForSingleObject(SockEvent
, INFINITE
);
1575 Status
= IOSB
.Status
;
1578 if (!NT_SUCCESS(Status
))
1581 WSPCloseSocket( AcceptSocket
, lpErrno
);
1582 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1583 return INVALID_SOCKET
;
1586 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1587 if (!AcceptSocketInfo
)
1590 WSPCloseSocket( AcceptSocket
, lpErrno
);
1591 MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED
, lpErrno
, 0, NULL
);
1592 return INVALID_SOCKET
;
1595 AcceptSocketInfo
->SharedData
->State
= SocketConnected
;
1597 /* Return Address in SOCKADDR FORMAT */
1600 RtlCopyMemory (SocketAddress
,
1601 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1602 sizeof(*RemoteAddress
));
1603 if( SocketAddressLength
)
1604 *SocketAddressLength
= sizeof(*RemoteAddress
);
1607 NtClose( SockEvent
);
1609 /* Re-enable Async Event */
1610 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1612 TRACE("Socket %x\n", AcceptSocket
);
1614 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1616 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1618 Socket
->TdiAddressHandle
,
1619 Socket
->TdiConnectionHandle
,
1624 if (lpErrno
) *lpErrno
= Status
;
1625 return INVALID_SOCKET
;
1632 return AcceptSocket
;
1637 WSPConnect(SOCKET Handle
,
1638 const struct sockaddr
* SocketAddress
,
1639 int SocketAddressLength
,
1640 LPWSABUF lpCallerData
,
1641 LPWSABUF lpCalleeData
,
1646 IO_STATUS_BLOCK IOSB
;
1647 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1648 PSOCKET_INFORMATION Socket
;
1651 ULONG ConnectDataLength
;
1652 ULONG InConnectDataLength
;
1653 INT BindAddressLength
;
1654 PSOCKADDR BindAddress
;
1656 int SocketDataLength
;
1658 Status
= NtCreateEvent(&SockEvent
,
1664 if (!NT_SUCCESS(Status
))
1665 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1669 /* Get the Socket Structure associate to this Socket*/
1670 Socket
= GetSocketStructure(Handle
);
1674 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1675 return SOCKET_ERROR
;
1679 if (Socket
->SharedData
->State
== SocketOpen
)
1681 /* Get the Wildcard Address */
1682 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1683 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1687 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1689 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1691 &BindAddressLength
);
1693 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1694 return SOCKET_ERROR
;
1697 /* Set the Connect Data */
1698 if (lpCallerData
!= NULL
)
1700 ConnectDataLength
= lpCallerData
->len
;
1701 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1706 IOCTL_AFD_SET_CONNECT_DATA
,
1711 /* Wait for return */
1712 if (Status
== STATUS_PENDING
)
1714 WaitForSingleObject(SockEvent
, INFINITE
);
1715 Status
= IOSB
.Status
;
1718 if (Status
!= STATUS_SUCCESS
)
1722 /* Calculate the size of SocketAddress->sa_data */
1723 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1725 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1726 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1727 FIELD_OFFSET(AFD_CONNECT_INFO
,
1728 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1731 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1735 /* Set up Address in TDI Format */
1736 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1737 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1738 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1739 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1740 SocketAddress
->sa_data
,
1744 * Disable FD_WRITE and FD_CONNECT
1745 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1746 * at the end of this function right after the Async Thread disables it.
1747 * This should only happen at the *next* WSPConnect
1749 if (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
)
1751 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1754 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1755 if (lpCalleeData
!= NULL
)
1757 InConnectDataLength
= lpCalleeData
->len
;
1758 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1763 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1764 &InConnectDataLength
,
1765 sizeof(InConnectDataLength
),
1769 /* Wait for return */
1770 if (Status
== STATUS_PENDING
)
1772 WaitForSingleObject(SockEvent
, INFINITE
);
1773 Status
= IOSB
.Status
;
1776 if (Status
!= STATUS_SUCCESS
)
1780 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1781 ConnectInfo
->Root
= 0;
1782 ConnectInfo
->UseSAN
= FALSE
;
1783 ConnectInfo
->Unknown
= 0;
1785 /* FIXME: Handle Async Connect */
1786 if (Socket
->SharedData
->NonBlocking
)
1788 ERR("Async Connect UNIMPLEMENTED!\n");
1792 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1802 /* Wait for return */
1803 if (Status
== STATUS_PENDING
)
1805 WaitForSingleObject(SockEvent
, INFINITE
);
1806 Status
= IOSB
.Status
;
1809 if (Status
!= STATUS_SUCCESS
)
1812 Socket
->SharedData
->State
= SocketConnected
;
1813 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1815 /* Get any pending connect data */
1816 if (lpCalleeData
!= NULL
)
1818 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1823 IOCTL_AFD_GET_CONNECT_DATA
,
1828 /* Wait for return */
1829 if (Status
== STATUS_PENDING
)
1831 WaitForSingleObject(SockEvent
, INFINITE
);
1832 Status
= IOSB
.Status
;
1839 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
1841 /* Re-enable Async Event */
1842 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1844 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1845 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1849 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1851 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1853 Socket
->TdiAddressHandle
,
1854 Socket
->TdiConnectionHandle
,
1855 WSH_NOTIFY_CONNECT
);
1859 if (lpErrno
) *lpErrno
= Errno
;
1860 return SOCKET_ERROR
;
1863 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1865 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1867 Socket
->TdiAddressHandle
,
1868 Socket
->TdiConnectionHandle
,
1869 WSH_NOTIFY_CONNECT_ERROR
);
1873 if (lpErrno
) *lpErrno
= Errno
;
1874 return SOCKET_ERROR
;
1878 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1882 WSPShutdown(SOCKET Handle
,
1887 IO_STATUS_BLOCK IOSB
;
1888 AFD_DISCONNECT_INFO DisconnectInfo
;
1889 PSOCKET_INFORMATION Socket
= NULL
;
1893 Status
= NtCreateEvent(&SockEvent
,
1899 if( !NT_SUCCESS(Status
) )
1904 /* Get the Socket Structure associate to this Socket*/
1905 Socket
= GetSocketStructure(Handle
);
1909 *lpErrno
= WSAENOTSOCK
;
1910 return SOCKET_ERROR
;
1913 /* Set AFD Disconnect Type */
1917 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1918 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
1921 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1922 Socket
->SharedData
->SendShutdown
= TRUE
;
1925 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1926 Socket
->SharedData
->ReceiveShutdown
= TRUE
;
1927 Socket
->SharedData
->SendShutdown
= TRUE
;
1931 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
1934 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1939 IOCTL_AFD_DISCONNECT
,
1941 sizeof(DisconnectInfo
),
1945 /* Wait for return */
1946 if (Status
== STATUS_PENDING
)
1948 WaitForSingleObject(SockEvent
, INFINITE
);
1949 Status
= IOSB
.Status
;
1954 NtClose( SockEvent
);
1956 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1962 WSPGetSockName(IN SOCKET Handle
,
1963 OUT LPSOCKADDR Name
,
1964 IN OUT LPINT NameLength
,
1967 IO_STATUS_BLOCK IOSB
;
1968 ULONG TdiAddressSize
;
1969 PTDI_ADDRESS_INFO TdiAddress
;
1970 PTRANSPORT_ADDRESS SocketAddress
;
1971 PSOCKET_INFORMATION Socket
= NULL
;
1975 Status
= NtCreateEvent(&SockEvent
,
1981 if( !NT_SUCCESS(Status
) )
1982 return SOCKET_ERROR
;
1984 /* Get the Socket Structure associate to this Socket*/
1985 Socket
= GetSocketStructure(Handle
);
1989 *lpErrno
= WSAENOTSOCK
;
1990 return SOCKET_ERROR
;
1993 if (!Name
|| !NameLength
)
1996 *lpErrno
= WSAEFAULT
;
1997 return SOCKET_ERROR
;
2000 /* Allocate a buffer for the address */
2002 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfLocalAddress
;
2003 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2005 if ( TdiAddress
== NULL
)
2007 NtClose( SockEvent
);
2008 *lpErrno
= WSAENOBUFS
;
2009 return SOCKET_ERROR
;
2012 SocketAddress
= &TdiAddress
->Address
;
2015 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2020 IOCTL_AFD_GET_SOCK_NAME
,
2026 /* Wait for return */
2027 if (Status
== STATUS_PENDING
)
2029 WaitForSingleObject(SockEvent
, INFINITE
);
2030 Status
= IOSB
.Status
;
2033 NtClose( SockEvent
);
2035 if (NT_SUCCESS(Status
))
2037 if (*NameLength
>= Socket
->SharedData
->SizeOfLocalAddress
)
2039 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2040 RtlCopyMemory (Name
->sa_data
,
2041 SocketAddress
->Address
[0].Address
,
2042 SocketAddress
->Address
[0].AddressLength
);
2043 *NameLength
= Socket
->SharedData
->SizeOfLocalAddress
;
2044 TRACE("NameLength %d Address: %x Port %x\n",
2045 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2046 ((struct sockaddr_in
*)Name
)->sin_port
);
2047 HeapFree(GlobalHeap
, 0, TdiAddress
);
2052 HeapFree(GlobalHeap
, 0, TdiAddress
);
2053 *lpErrno
= WSAEFAULT
;
2054 return SOCKET_ERROR
;
2058 HeapFree(GlobalHeap
, 0, TdiAddress
);
2060 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2066 WSPGetPeerName(IN SOCKET s
,
2067 OUT LPSOCKADDR Name
,
2068 IN OUT LPINT NameLength
,
2071 IO_STATUS_BLOCK IOSB
;
2072 ULONG TdiAddressSize
;
2073 PTRANSPORT_ADDRESS SocketAddress
;
2074 PSOCKET_INFORMATION Socket
= NULL
;
2078 Status
= NtCreateEvent(&SockEvent
,
2084 if( !NT_SUCCESS(Status
) )
2085 return SOCKET_ERROR
;
2087 /* Get the Socket Structure associate to this Socket*/
2088 Socket
= GetSocketStructure(s
);
2092 *lpErrno
= WSAENOTSOCK
;
2093 return SOCKET_ERROR
;
2096 if (Socket
->SharedData
->State
!= SocketConnected
)
2099 *lpErrno
= WSAENOTCONN
;
2100 return SOCKET_ERROR
;
2103 if (!Name
|| !NameLength
)
2106 *lpErrno
= WSAEFAULT
;
2107 return SOCKET_ERROR
;
2110 /* Allocate a buffer for the address */
2111 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
->SizeOfRemoteAddress
;
2112 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
2114 if ( SocketAddress
== NULL
)
2116 NtClose( SockEvent
);
2117 *lpErrno
= WSAENOBUFS
;
2118 return SOCKET_ERROR
;
2122 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2127 IOCTL_AFD_GET_PEER_NAME
,
2133 /* Wait for return */
2134 if (Status
== STATUS_PENDING
)
2136 WaitForSingleObject(SockEvent
, INFINITE
);
2137 Status
= IOSB
.Status
;
2140 NtClose( SockEvent
);
2142 if (NT_SUCCESS(Status
))
2144 if (*NameLength
>= Socket
->SharedData
->SizeOfRemoteAddress
)
2146 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
2147 RtlCopyMemory (Name
->sa_data
,
2148 SocketAddress
->Address
[0].Address
,
2149 SocketAddress
->Address
[0].AddressLength
);
2150 *NameLength
= Socket
->SharedData
->SizeOfRemoteAddress
;
2151 TRACE("NameLength %d Address: %x Port %x\n",
2152 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
2153 ((struct sockaddr_in
*)Name
)->sin_port
);
2154 HeapFree(GlobalHeap
, 0, SocketAddress
);
2159 HeapFree(GlobalHeap
, 0, SocketAddress
);
2160 *lpErrno
= WSAEFAULT
;
2161 return SOCKET_ERROR
;
2165 HeapFree(GlobalHeap
, 0, SocketAddress
);
2167 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
2172 WSPIoctl(IN SOCKET Handle
,
2173 IN DWORD dwIoControlCode
,
2174 IN LPVOID lpvInBuffer
,
2175 IN DWORD cbInBuffer
,
2176 OUT LPVOID lpvOutBuffer
,
2177 IN DWORD cbOutBuffer
,
2178 OUT LPDWORD lpcbBytesReturned
,
2179 IN LPWSAOVERLAPPED lpOverlapped
,
2180 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
2181 IN LPWSATHREADID lpThreadId
,
2184 PSOCKET_INFORMATION Socket
= NULL
;
2185 BOOLEAN NeedsCompletion
;
2186 BOOLEAN NonBlocking
;
2188 if (!lpcbBytesReturned
)
2190 *lpErrno
= WSAEFAULT
;
2191 return SOCKET_ERROR
;
2194 /* Get the Socket Structure associate to this Socket*/
2195 Socket
= GetSocketStructure(Handle
);
2198 *lpErrno
= WSAENOTSOCK
;
2199 return SOCKET_ERROR
;
2202 *lpcbBytesReturned
= 0;
2204 switch( dwIoControlCode
)
2207 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2209 *lpErrno
= WSAEFAULT
;
2210 return SOCKET_ERROR
;
2212 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2213 Socket
->SharedData
->NonBlocking
= NonBlocking
? 1 : 0;
2214 *lpErrno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
);
2215 if (*lpErrno
!= NO_ERROR
)
2216 return SOCKET_ERROR
;
2220 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2222 *lpcbBytesReturned
= sizeof(ULONG
);
2223 *lpErrno
= WSAEFAULT
;
2224 return SOCKET_ERROR
;
2226 if (cbOutBuffer
< sizeof(ULONG
))
2228 *lpErrno
= WSAEINVAL
;
2229 return SOCKET_ERROR
;
2231 *lpErrno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
);
2232 if (*lpErrno
!= NO_ERROR
)
2233 return SOCKET_ERROR
;
2236 *lpcbBytesReturned
= sizeof(ULONG
);
2240 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2242 *lpcbBytesReturned
= sizeof(BOOL
);
2243 *lpErrno
= WSAEFAULT
;
2244 return SOCKET_ERROR
;
2246 if (cbOutBuffer
< sizeof(BOOL
))
2248 *lpErrno
= WSAEINVAL
;
2249 return SOCKET_ERROR
;
2252 /* FIXME: Return false for now */
2253 *(BOOL
*)lpvOutBuffer
= FALSE
;
2255 *lpcbBytesReturned
= sizeof(BOOL
);
2256 *lpErrno
= NO_ERROR
;
2258 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2259 *lpErrno
= WSAEINVAL
;
2260 return SOCKET_ERROR
;
2262 case SIO_ADDRESS_LIST_QUERY
:
2263 if (IS_INTRESOURCE(lpvOutBuffer
) || cbOutBuffer
== 0)
2265 *lpcbBytesReturned
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2266 *lpErrno
= WSAEFAULT
;
2267 return SOCKET_ERROR
;
2269 if (cbOutBuffer
< sizeof(INT
))
2271 *lpErrno
= WSAEINVAL
;
2272 return SOCKET_ERROR
;
2275 *lpcbBytesReturned
= sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
);
2277 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->iAddressCount
= 1;
2279 if (cbOutBuffer
< (sizeof(SOCKET_ADDRESS_LIST
) + sizeof(Socket
->SharedData
->WSLocalAddress
)))
2281 *lpErrno
= WSAEFAULT
;
2282 return SOCKET_ERROR
;
2285 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].iSockaddrLength
= sizeof(Socket
->SharedData
->WSLocalAddress
);
2286 ((SOCKET_ADDRESS_LIST
*)lpvOutBuffer
)->Address
[0].lpSockaddr
= &Socket
->SharedData
->WSLocalAddress
;
2288 *lpErrno
= NO_ERROR
;
2292 *lpErrno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2294 Socket
->TdiAddressHandle
,
2295 Socket
->TdiConnectionHandle
,
2303 lpCompletionRoutine
,
2304 (LPBOOL
)&NeedsCompletion
);
2306 if (*lpErrno
!= NO_ERROR
)
2307 return SOCKET_ERROR
;
2316 WSPGetSockOpt(IN SOCKET Handle
,
2319 OUT CHAR FAR
* OptionValue
,
2320 IN OUT LPINT OptionLength
,
2323 PSOCKET_INFORMATION Socket
= NULL
;
2329 /* Get the Socket Structure associate to this Socket*/
2330 Socket
= GetSocketStructure(Handle
);
2333 *lpErrno
= WSAENOTSOCK
;
2334 return SOCKET_ERROR
;
2345 Buffer
= &Socket
->SharedData
->SocketType
;
2346 BufferSize
= sizeof(INT
);
2350 Buffer
= &Socket
->SharedData
->SizeOfRecvBuffer
;
2351 BufferSize
= sizeof(INT
);
2355 Buffer
= &Socket
->SharedData
->SizeOfSendBuffer
;
2356 BufferSize
= sizeof(INT
);
2360 BoolBuffer
= Socket
->SharedData
->Listening
;
2361 Buffer
= &BoolBuffer
;
2362 BufferSize
= sizeof(BOOL
);
2366 BoolBuffer
= Socket
->SharedData
->Broadcast
;
2367 Buffer
= &BoolBuffer
;
2368 BufferSize
= sizeof(BOOL
);
2372 BoolBuffer
= Socket
->SharedData
->Debug
;
2373 Buffer
= &BoolBuffer
;
2374 BufferSize
= sizeof(BOOL
);
2378 BoolBuffer
= (Socket
->SharedData
->LingerData
.l_onoff
== 0);
2379 Buffer
= &BoolBuffer
;
2380 BufferSize
= sizeof(BOOL
);
2384 if (Socket
->SharedData
->SocketType
== SOCK_DGRAM
)
2386 *lpErrno
= WSAENOPROTOOPT
;
2387 return SOCKET_ERROR
;
2389 Buffer
= &Socket
->SharedData
->LingerData
;
2390 BufferSize
= sizeof(struct linger
);
2394 BoolBuffer
= (Socket
->SharedData
->OobInline
!= 0);
2395 Buffer
= &BoolBuffer
;
2396 BufferSize
= sizeof(BOOL
);
2401 /* These guys go directly to the helper */
2404 case SO_CONDITIONAL_ACCEPT
:
2405 BoolBuffer
= (Socket
->SharedData
->UseDelayedAcceptance
!= 0);
2406 Buffer
= &BoolBuffer
;
2407 BufferSize
= sizeof(BOOL
);
2411 BoolBuffer
= (Socket
->SharedData
->ReuseAddresses
!= 0);
2412 Buffer
= &BoolBuffer
;
2413 BufferSize
= sizeof(BOOL
);
2416 case SO_EXCLUSIVEADDRUSE
:
2417 BoolBuffer
= (Socket
->SharedData
->ExclusiveAddressUse
!= 0);
2418 Buffer
= &BoolBuffer
;
2419 BufferSize
= sizeof(BOOL
);
2423 /* HACK: This needs to be properly tracked */
2425 DbgPrint("MSAFD: Hacked SO_ERROR returning error %d\n", IntBuffer
);
2427 Buffer
= &IntBuffer
;
2428 BufferSize
= sizeof(INT
);
2431 Buffer
= &Socket
->SharedData
->SendTimeout
;
2432 BufferSize
= sizeof(DWORD
);
2435 Buffer
= &Socket
->SharedData
->RecvTimeout
;
2436 BufferSize
= sizeof(DWORD
);
2438 case SO_PROTOCOL_INFOW
:
2439 Buffer
= &Socket
->ProtocolInfo
;
2440 BufferSize
= sizeof(Socket
->ProtocolInfo
);
2444 case SO_GROUP_PRIORITY
:
2445 case SO_MAX_MSG_SIZE
:
2448 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2449 *lpErrno
= WSAENOPROTOOPT
;
2450 return SOCKET_ERROR
;
2453 if (*OptionLength
< BufferSize
)
2455 *lpErrno
= WSAEFAULT
;
2456 *OptionLength
= BufferSize
;
2457 return SOCKET_ERROR
;
2459 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2464 *lpErrno
= WSAEINVAL
;
2465 return SOCKET_ERROR
;
2469 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2471 Socket
->TdiAddressHandle
,
2472 Socket
->TdiConnectionHandle
,
2476 (LPINT
)OptionLength
);
2477 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2486 IN CONST CHAR FAR
* optval
,
2490 PSOCKET_INFORMATION Socket
;
2492 /* Get the Socket Structure associate to this Socket*/
2493 Socket
= GetSocketStructure(s
);
2496 *lpErrno
= WSAENOTSOCK
;
2497 return SOCKET_ERROR
;
2501 /* FIXME: We should handle some more cases here */
2502 if (level
== SOL_SOCKET
)
2507 if (optlen
< sizeof(BOOL
))
2509 *lpErrno
= WSAEFAULT
;
2510 return SOCKET_ERROR
;
2512 Socket
->SharedData
->Broadcast
= (*optval
!= 0) ? 1 : 0;
2516 if (optlen
< sizeof(BOOL
))
2518 *lpErrno
= WSAEFAULT
;
2519 return SOCKET_ERROR
;
2521 Socket
->SharedData
->LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2525 if (optlen
< sizeof(BOOL
))
2527 *lpErrno
= WSAEFAULT
;
2528 return SOCKET_ERROR
;
2530 Socket
->SharedData
->ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2533 case SO_EXCLUSIVEADDRUSE
:
2534 if (optlen
< sizeof(BOOL
))
2536 *lpErrno
= WSAEFAULT
;
2537 return SOCKET_ERROR
;
2539 Socket
->SharedData
->ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2543 if (optlen
< sizeof(struct linger
))
2545 *lpErrno
= WSAEFAULT
;
2546 return SOCKET_ERROR
;
2548 RtlCopyMemory(&Socket
->SharedData
->LingerData
,
2550 sizeof(struct linger
));
2554 if (optlen
< sizeof(DWORD
))
2556 *lpErrno
= WSAEFAULT
;
2557 return SOCKET_ERROR
;
2560 /* TODO: The total per-socket buffer space reserved for sends */
2561 ERR("Setting send buf to %x is not implemented yet\n", optval
);
2565 if (optlen
< sizeof(DWORD
))
2567 *lpErrno
= WSAEFAULT
;
2568 return SOCKET_ERROR
;
2571 RtlCopyMemory(&Socket
->SharedData
->SendTimeout
,
2577 if (optlen
< sizeof(DWORD
))
2579 *lpErrno
= WSAEFAULT
;
2580 return SOCKET_ERROR
;
2583 RtlCopyMemory(&Socket
->SharedData
->RecvTimeout
,
2590 /* These go directly to the helper dll */
2594 /* Obviously this is a hack */
2595 ERR("MSAFD: Set unknown optname %x\n", optname
);
2601 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2603 Socket
->TdiAddressHandle
,
2604 Socket
->TdiConnectionHandle
,
2609 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2613 * FUNCTION: Initialize service provider for a client
2615 * wVersionRequested = Highest WinSock SPI version that the caller can use
2616 * lpWSPData = Address of WSPDATA structure to initialize
2617 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2618 * UpcallTable = Pointer to upcall table of the WinSock DLL
2619 * lpProcTable = Address of procedure table to initialize
2621 * Status of operation
2625 WSPStartup(IN WORD wVersionRequested
,
2626 OUT LPWSPDATA lpWSPData
,
2627 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2628 IN WSPUPCALLTABLE UpcallTable
,
2629 OUT LPWSPPROC_TABLE lpProcTable
)
2634 if (((LOBYTE(wVersionRequested
) == 2) && (HIBYTE(wVersionRequested
) < 2)) ||
2635 (LOBYTE(wVersionRequested
) < 2))
2637 ERR("WSPStartup NOT SUPPORTED for version 0x%X\n", wVersionRequested
);
2638 return WSAVERNOTSUPPORTED
;
2642 /* FIXME: Enable all cases of WSPStartup status */
2643 Upcalls
= UpcallTable
;
2645 if (Status
== NO_ERROR
)
2647 lpProcTable
->lpWSPAccept
= WSPAccept
;
2648 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2649 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2650 lpProcTable
->lpWSPBind
= WSPBind
;
2651 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2652 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2653 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2654 lpProcTable
->lpWSPConnect
= WSPConnect
;
2655 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2656 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2657 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2658 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2659 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2660 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2661 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2662 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2663 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2664 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2665 lpProcTable
->lpWSPListen
= WSPListen
;
2666 lpProcTable
->lpWSPRecv
= WSPRecv
;
2667 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2668 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2669 lpProcTable
->lpWSPSelect
= WSPSelect
;
2670 lpProcTable
->lpWSPSend
= WSPSend
;
2671 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2672 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2673 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2674 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2675 lpProcTable
->lpWSPSocket
= WSPSocket
;
2676 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2677 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2678 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2679 /* Save CatalogEntryId for all upcalls */
2680 CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
2683 TRACE("Status (%d).\n", Status
);
2690 WSPAddressToString(IN LPSOCKADDR lpsaAddress
,
2691 IN DWORD dwAddressLength
,
2692 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2693 OUT LPWSTR lpszAddressString
,
2694 IN OUT LPDWORD lpdwAddressStringLength
,
2698 WCHAR buffer
[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
2701 if (!lpsaAddress
|| !lpszAddressString
|| !lpdwAddressStringLength
)
2703 *lpErrno
= WSAEFAULT
;
2704 return SOCKET_ERROR
;
2707 switch (lpsaAddress
->sa_family
)
2710 if (dwAddressLength
< sizeof(SOCKADDR_IN
))
2712 *lpErrno
= WSAEINVAL
;
2713 return SOCKET_ERROR
;
2717 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 24 & 0xff),
2718 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 16 & 0xff),
2719 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) >> 8 & 0xff),
2720 (unsigned int)(ntohl(((SOCKADDR_IN
*)lpsaAddress
)->sin_addr
.s_addr
) & 0xff),
2721 ntohs(((SOCKADDR_IN
*)lpsaAddress
)->sin_port
));
2723 p
= wcschr(buffer
, L
':');
2724 if (!((SOCKADDR_IN
*)lpsaAddress
)->sin_port
)
2730 *lpErrno
= WSAEINVAL
;
2731 return SOCKET_ERROR
;
2734 size
= wcslen(buffer
) + 1;
2736 if (*lpdwAddressStringLength
< size
)
2738 *lpdwAddressStringLength
= size
;
2739 *lpErrno
= WSAEFAULT
;
2740 return SOCKET_ERROR
;
2743 *lpdwAddressStringLength
= size
;
2744 wcscpy(lpszAddressString
, buffer
);
2750 WSPStringToAddress(IN LPWSTR AddressString
,
2751 IN INT AddressFamily
,
2752 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2753 OUT LPSOCKADDR lpAddress
,
2754 IN OUT LPINT lpAddressLength
,
2760 SOCKADDR_IN
*sockaddr
;
2762 if (!lpAddressLength
|| !lpAddress
|| !AddressString
)
2764 *lpErrno
= WSAEINVAL
;
2765 return SOCKET_ERROR
;
2768 sockaddr
= (SOCKADDR_IN
*)lpAddress
;
2770 /* Set right address family */
2771 if (lpProtocolInfo
!= NULL
)
2773 sockaddr
->sin_family
= lpProtocolInfo
->iAddressFamily
;
2777 sockaddr
->sin_family
= AddressFamily
;
2781 if (AddressFamily
== AF_INET
)
2783 if (*lpAddressLength
< (INT
)sizeof(SOCKADDR_IN
))
2785 *lpAddressLength
= sizeof(SOCKADDR_IN
);
2786 *lpErrno
= WSAEFAULT
;
2790 // translate ip string to ip
2792 /* rest sockaddr.sin_addr.s_addr
2793 for we need to be sure it is zero when we come to while */
2794 memset(lpAddress
, 0, sizeof(SOCKADDR_IN
));
2796 /* Set right adress family */
2797 sockaddr
->sin_family
= AF_INET
;
2799 /* Get port number */
2800 pos
= wcscspn(AddressString
, L
":") + 1;
2802 if (pos
< (int)wcslen(AddressString
))
2804 sockaddr
->sin_port
= wcstol(&AddressString
[pos
], bp
, 10);
2808 sockaddr
->sin_port
= 0;
2815 while (pos
< (int)wcslen(AddressString
))
2817 inetaddr
= (inetaddr
<< 8) +
2818 ((UCHAR
)wcstol(&AddressString
[pos
], bp
, 10));
2820 pos
+= wcscspn(&AddressString
[pos
], L
".") + 1;
2824 sockaddr
->sin_addr
.s_addr
= inetaddr
;
2834 return SOCKET_ERROR
;
2838 * FUNCTION: Cleans up service provider for a client
2840 * lpErrno = Address of buffer for error information
2842 * 0 if successful, or SOCKET_ERROR if not
2846 WSPCleanup(OUT LPINT lpErrno
)
2849 TRACE("Leaving.\n");
2850 *lpErrno
= NO_ERROR
;
2858 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2859 ULONG AfdInformationClass
,
2860 PBOOLEAN Boolean OPTIONAL
,
2861 PULONG Ulong OPTIONAL
,
2862 PLARGE_INTEGER LargeInteger OPTIONAL
)
2864 IO_STATUS_BLOCK IOSB
;
2869 Status
= NtCreateEvent(&SockEvent
,
2875 if( !NT_SUCCESS(Status
) )
2878 /* Set Info Class */
2879 InfoData
.InformationClass
= AfdInformationClass
;
2882 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2893 /* Wait for return */
2894 if (Status
== STATUS_PENDING
)
2896 WaitForSingleObject(SockEvent
, INFINITE
);
2897 Status
= IOSB
.Status
;
2900 if (Status
!= STATUS_SUCCESS
)
2903 /* Return Information */
2906 *Ulong
= InfoData
.Information
.Ulong
;
2908 if (LargeInteger
!= NULL
)
2910 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2912 if (Boolean
!= NULL
)
2914 *Boolean
= InfoData
.Information
.Boolean
;
2917 NtClose( SockEvent
);
2925 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2926 ULONG AfdInformationClass
,
2927 PBOOLEAN Boolean OPTIONAL
,
2928 PULONG Ulong OPTIONAL
,
2929 PLARGE_INTEGER LargeInteger OPTIONAL
)
2931 IO_STATUS_BLOCK IOSB
;
2936 Status
= NtCreateEvent(&SockEvent
,
2942 if( !NT_SUCCESS(Status
) )
2945 /* Set Info Class */
2946 InfoData
.InformationClass
= AfdInformationClass
;
2948 /* Set Information */
2951 InfoData
.Information
.Ulong
= *Ulong
;
2953 if (LargeInteger
!= NULL
)
2955 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2957 if (Boolean
!= NULL
)
2959 InfoData
.Information
.Boolean
= *Boolean
;
2963 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2974 /* Wait for return */
2975 if (Status
== STATUS_PENDING
)
2977 WaitForSingleObject(SockEvent
, INFINITE
);
2978 Status
= IOSB
.Status
;
2981 NtClose( SockEvent
);
2983 return Status
== STATUS_SUCCESS
? 0 : -1;
2988 GetSocketStructure(SOCKET Handle
)
2990 PSOCKET_INFORMATION CurrentSocket
;
2992 EnterCriticalSection(&SocketListLock
);
2994 CurrentSocket
= SocketListHead
;
2995 while (CurrentSocket
)
2997 if (CurrentSocket
->Handle
== Handle
)
2999 LeaveCriticalSection(&SocketListLock
);
3000 return CurrentSocket
;
3003 CurrentSocket
= CurrentSocket
->NextSocket
;
3006 LeaveCriticalSection(&SocketListLock
);
3011 int CreateContext(PSOCKET_INFORMATION Socket
)
3013 IO_STATUS_BLOCK IOSB
;
3014 SOCKET_CONTEXT ContextData
;
3018 Status
= NtCreateEvent(&SockEvent
,
3024 if( !NT_SUCCESS(Status
) )
3027 /* Create Context */
3028 ContextData
.SharedData
= *Socket
->SharedData
;
3029 ContextData
.SizeOfHelperData
= 0;
3030 RtlCopyMemory (&ContextData
.LocalAddress
,
3031 Socket
->LocalAddress
,
3032 Socket
->SharedData
->SizeOfLocalAddress
);
3033 RtlCopyMemory (&ContextData
.RemoteAddress
,
3034 Socket
->RemoteAddress
,
3035 Socket
->SharedData
->SizeOfRemoteAddress
);
3038 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
3043 IOCTL_AFD_SET_CONTEXT
,
3045 sizeof(ContextData
),
3049 /* Wait for Completition */
3050 if (Status
== STATUS_PENDING
)
3052 WaitForSingleObject(SockEvent
, INFINITE
);
3053 Status
= IOSB
.Status
;
3056 NtClose( SockEvent
);
3058 return Status
== STATUS_SUCCESS
? 0 : -1;
3061 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
3063 HANDLE hAsyncThread
;
3064 DWORD AsyncThreadId
;
3066 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3069 /* Check if the Thread Already Exists */
3070 if (SockAsyncThreadRefCount
)
3072 ASSERT(SockAsyncCompletionPort
);
3076 /* Create the Completion Port */
3077 if (!SockAsyncCompletionPort
)
3079 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
3080 IO_COMPLETION_ALL_ACCESS
,
3082 2); // Allow 2 threads only
3083 if (!NT_SUCCESS(Status
))
3085 ERR("Failed to create completion port: 0x%08x\n", Status
);
3088 /* Protect Handle */
3089 HandleFlags
.ProtectFromClose
= TRUE
;
3090 HandleFlags
.Inherit
= FALSE
;
3091 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
3092 ObjectHandleFlagInformation
,
3094 sizeof(HandleFlags
));
3097 /* Create the Async Event */
3098 Status
= NtCreateEvent(&AsyncEvent
,
3104 /* Create the Async Thread */
3105 hAsyncThread
= CreateThread(NULL
,
3107 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
3112 /* Close the Handle */
3113 NtClose(hAsyncThread
);
3115 /* Increase the Reference Count */
3116 SockAsyncThreadRefCount
++;
3120 int SockAsyncThread(PVOID ThreadParam
)
3123 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
3124 IO_STATUS_BLOCK IOSB
;
3127 /* Make the Thread Higher Priority */
3128 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
3130 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3133 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
3134 (PVOID
*)&AsyncCompletionRoutine
,
3138 /* Call the Async Function */
3139 if (NT_SUCCESS(Status
))
3141 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
3145 /* It Failed, sleep for a second */
3148 } while ((Status
!= STATUS_TIMEOUT
));
3150 /* The Thread has Ended */
3154 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
3156 UNICODE_STRING AfdHelper
;
3157 OBJECT_ATTRIBUTES ObjectAttributes
;
3158 IO_STATUS_BLOCK IoSb
;
3159 FILE_COMPLETION_INFORMATION CompletionInfo
;
3160 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
3162 /* First, make sure we're not already intialized */
3163 if (SockAsyncHelperAfdHandle
)
3168 /* Set up Handle Name and Object */
3169 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
3170 InitializeObjectAttributes(&ObjectAttributes
,
3172 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
3176 /* Open the Handle to AFD */
3177 NtCreateFile(&SockAsyncHelperAfdHandle
,
3178 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
3183 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
3190 * Now Set up the Completion Port Information
3191 * This means that whenever a Poll is finished, the routine will be executed
3193 CompletionInfo
.Port
= SockAsyncCompletionPort
;
3194 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
3195 NtSetInformationFile(SockAsyncHelperAfdHandle
,
3198 sizeof(CompletionInfo
),
3199 FileCompletionInformation
);
3202 /* Protect the Handle */
3203 HandleFlags
.ProtectFromClose
= TRUE
;
3204 HandleFlags
.Inherit
= FALSE
;
3205 NtSetInformationObject(SockAsyncCompletionPort
,
3206 ObjectHandleFlagInformation
,
3208 sizeof(HandleFlags
));
3211 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
3212 SockAsyncSelectCalled
= TRUE
;
3216 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3219 PASYNC_DATA AsyncData
= Context
;
3220 PSOCKET_INFORMATION Socket
;
3223 /* Get the Socket */
3224 Socket
= AsyncData
->ParentSocket
;
3226 /* Check if the Sequence Number Changed behind our back */
3227 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
->SequenceNumber
)
3232 /* Check we were manually called b/c of a failure */
3233 if (!NT_SUCCESS(IoStatusBlock
->Status
))
3235 /* FIXME: Perform Upcall */
3239 for (x
= 1; x
; x
<<=1)
3241 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
3243 case AFD_EVENT_RECEIVE
:
3244 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_READ
) &&
3245 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_READ
))
3247 /* Make the Notifcation */
3248 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3249 Socket
->SharedData
->wMsg
,
3251 WSAMAKESELECTREPLY(FD_READ
, 0));
3252 /* Disable this event until the next read(); */
3253 Socket
->SharedData
->AsyncDisabledEvents
|= FD_READ
;
3257 case AFD_EVENT_OOB_RECEIVE
:
3258 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_OOB
) &&
3259 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_OOB
))
3261 /* Make the Notifcation */
3262 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3263 Socket
->SharedData
->wMsg
,
3265 WSAMAKESELECTREPLY(FD_OOB
, 0));
3266 /* Disable this event until the next read(); */
3267 Socket
->SharedData
->AsyncDisabledEvents
|= FD_OOB
;
3271 case AFD_EVENT_SEND
:
3272 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_WRITE
) &&
3273 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_WRITE
))
3275 /* Make the Notifcation */
3276 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3277 Socket
->SharedData
->wMsg
,
3279 WSAMAKESELECTREPLY(FD_WRITE
, 0));
3280 /* Disable this event until the next write(); */
3281 Socket
->SharedData
->AsyncDisabledEvents
|= FD_WRITE
;
3285 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3286 case AFD_EVENT_CONNECT
:
3287 case AFD_EVENT_CONNECT_FAIL
:
3288 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CONNECT
) &&
3289 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CONNECT
))
3291 /* Make the Notifcation */
3292 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3293 Socket
->SharedData
->wMsg
,
3295 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
3296 /* Disable this event forever; */
3297 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CONNECT
;
3301 case AFD_EVENT_ACCEPT
:
3302 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_ACCEPT
) &&
3303 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_ACCEPT
))
3305 /* Make the Notifcation */
3306 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3307 Socket
->SharedData
->wMsg
,
3309 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
3310 /* Disable this event until the next accept(); */
3311 Socket
->SharedData
->AsyncDisabledEvents
|= FD_ACCEPT
;
3315 case AFD_EVENT_DISCONNECT
:
3316 case AFD_EVENT_ABORT
:
3317 case AFD_EVENT_CLOSE
:
3318 if (0 != (Socket
->SharedData
->AsyncEvents
& FD_CLOSE
) &&
3319 0 == (Socket
->SharedData
->AsyncDisabledEvents
& FD_CLOSE
))
3321 /* Make the Notifcation */
3322 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
->hWnd
,
3323 Socket
->SharedData
->wMsg
,
3325 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
3326 /* Disable this event forever; */
3327 Socket
->SharedData
->AsyncDisabledEvents
|= FD_CLOSE
;
3330 /* FIXME: Support QOS */
3334 /* Check if there are any events left for us to check */
3335 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3341 SockProcessAsyncSelect(Socket
, AsyncData
);
3345 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
3348 ULONG lNetworkEvents
;
3351 /* Set up the Async Data Event Info */
3352 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
3353 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
3354 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
3355 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
3356 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
3357 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
3359 /* Remove unwanted events */
3360 lNetworkEvents
= Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
);
3362 /* Set Events to wait for */
3363 if (lNetworkEvents
& FD_READ
)
3365 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
3368 if (lNetworkEvents
& FD_WRITE
)
3370 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
3373 if (lNetworkEvents
& FD_OOB
)
3375 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
3378 if (lNetworkEvents
& FD_ACCEPT
)
3380 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
3383 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3384 if (lNetworkEvents
& FD_CONNECT
)
3386 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
3389 if (lNetworkEvents
& FD_CLOSE
)
3391 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
3394 if (lNetworkEvents
& FD_QOS
)
3396 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
3399 if (lNetworkEvents
& FD_GROUP_QOS
)
3401 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
3405 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
3409 &AsyncData
->IoStatusBlock
,
3411 &AsyncData
->AsyncSelectInfo
,
3412 sizeof(AsyncData
->AsyncSelectInfo
),
3413 &AsyncData
->AsyncSelectInfo
,
3414 sizeof(AsyncData
->AsyncSelectInfo
));
3416 /* I/O Manager Won't call the completion routine, let's do it manually */
3417 if (NT_SUCCESS(Status
))
3423 AsyncData
->IoStatusBlock
.Status
= Status
;
3424 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3428 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3430 PASYNC_DATA AsyncData
= Context
;
3431 BOOL FreeContext
= TRUE
;
3432 PSOCKET_INFORMATION Socket
;
3434 /* Get the Socket */
3435 Socket
= AsyncData
->ParentSocket
;
3437 /* If someone closed it, stop the function */
3438 if (Socket
->SharedData
->State
!= SocketClosed
)
3440 /* Check if the Sequence Number changed by now, in which case quit */
3441 if (AsyncData
->SequenceNumber
== Socket
->SharedData
->SequenceNumber
)
3443 /* Do the actuall select, if needed */
3444 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)))
3446 SockProcessAsyncSelect(Socket
, AsyncData
);
3447 FreeContext
= FALSE
;
3452 /* Free the Context */
3455 HeapFree(GetProcessHeap(), 0, AsyncData
);
3462 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3465 PASYNC_DATA AsyncData
;
3467 /* Make sure the event is actually disabled */
3468 if (!(Socket
->SharedData
->AsyncDisabledEvents
& Event
))
3474 Socket
->SharedData
->AsyncDisabledEvents
&= ~Event
;
3476 /* Return if no more events are being polled */
3477 if ((Socket
->SharedData
->AsyncEvents
& (~Socket
->SharedData
->AsyncDisabledEvents
)) == 0 )
3482 /* Wait on new events */
3483 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
3484 if (!AsyncData
) return;
3486 /* Create the Asynch Thread if Needed */
3487 SockCreateOrReferenceAsyncThread();
3489 /* Increase the sequence number to stop anything else */
3490 Socket
->SharedData
->SequenceNumber
++;
3492 /* Set up the Async Data */
3493 AsyncData
->ParentSocket
= Socket
;
3494 AsyncData
->SequenceNumber
= Socket
->SharedData
->SequenceNumber
;
3496 /* Begin Async Select by using I/O Completion */
3497 NtSetIoCompletion(SockAsyncCompletionPort
,
3498 (PVOID
)&SockProcessQueuedAsyncSelect
,
3509 DllMain(HANDLE hInstDll
,
3516 case DLL_PROCESS_ATTACH
:
3518 TRACE("Loading MSAFD.DLL \n");
3520 /* Don't need thread attach notifications
3521 so disable them to improve performance */
3522 DisableThreadLibraryCalls(hInstDll
);
3524 /* List of DLL Helpers */
3525 InitializeListHead(&SockHelpersListHead
);
3527 /* Heap to use when allocating */
3528 GlobalHeap
= GetProcessHeap();
3530 /* Initialize the lock that protects our socket list */
3531 InitializeCriticalSection(&SocketListLock
);
3533 TRACE("MSAFD.DLL has been loaded\n");
3537 case DLL_THREAD_ATTACH
:
3540 case DLL_THREAD_DETACH
:
3543 case DLL_PROCESS_DETACH
:
3545 /* Delete the socket list lock */
3546 DeleteCriticalSection(&SocketListLock
);
3551 TRACE("DllMain of msafd.dll (leaving)\n");