2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Ancillary Function Driver DLL
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 //DWORD DebugTraceLevel = DEBUG_ULTRA;
19 DWORD DebugTraceLevel
= 0;
23 WSPUPCALLTABLE Upcalls
;
24 LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
;
25 ULONG SocketCount
= 0;
26 PSOCKET_INFORMATION SocketListHead
= NULL
;
27 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
28 ULONG SockAsyncThreadRefCount
;
29 HANDLE SockAsyncHelperAfdHandle
;
30 HANDLE SockAsyncCompletionPort
;
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
, PrevSocket
= 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
;
74 AFD_DbgPrint(MAX_TRACE
, ("Creating Socket, getting TDI Name\n"));
75 AFD_DbgPrint(MAX_TRACE
, ("AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
76 AddressFamily
, SocketType
, Protocol
));
78 /* Get Helper Data and Transport */
79 Status
= SockGetTdiName (&AddressFamily
,
90 if (Status
!= NO_ERROR
)
92 AFD_DbgPrint(MID_TRACE
,("SockGetTdiName: Status %x\n", Status
));
97 RtlInitUnicodeString(&DevName
, L
"\\Device\\Afd\\Endpoint");
100 Socket
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
));
102 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
104 RtlZeroMemory(Socket
, sizeof(*Socket
));
105 Socket
->RefCount
= 2;
107 Socket
->SharedData
.Listening
= FALSE
;
108 Socket
->SharedData
.State
= SocketOpen
;
109 Socket
->SharedData
.AddressFamily
= AddressFamily
;
110 Socket
->SharedData
.SocketType
= SocketType
;
111 Socket
->SharedData
.Protocol
= Protocol
;
112 Socket
->HelperContext
= HelperDLLContext
;
113 Socket
->HelperData
= HelperData
;
114 Socket
->HelperEvents
= HelperEvents
;
115 Socket
->LocalAddress
= &Socket
->WSLocalAddress
;
116 Socket
->SharedData
.SizeOfLocalAddress
= HelperData
->MaxWSAddressLength
;
117 Socket
->RemoteAddress
= &Socket
->WSRemoteAddress
;
118 Socket
->SharedData
.SizeOfRemoteAddress
= HelperData
->MaxWSAddressLength
;
119 Socket
->SharedData
.UseDelayedAcceptance
= HelperData
->UseDelayedAcceptance
;
120 Socket
->SharedData
.CreateFlags
= dwFlags
;
121 Socket
->SharedData
.CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
122 Socket
->SharedData
.ServiceFlags1
= lpProtocolInfo
->dwServiceFlags1
;
123 Socket
->SharedData
.ProviderFlags
= lpProtocolInfo
->dwProviderFlags
;
124 Socket
->SharedData
.GroupID
= g
;
125 Socket
->SharedData
.GroupType
= 0;
126 Socket
->SharedData
.UseSAN
= FALSE
;
127 Socket
->SharedData
.NonBlocking
= FALSE
; /* Sockets start blocking */
128 Socket
->SanData
= NULL
;
130 /* Ask alex about this */
131 if( Socket
->SharedData
.SocketType
== SOCK_DGRAM
||
132 Socket
->SharedData
.SocketType
== SOCK_RAW
)
134 AFD_DbgPrint(MID_TRACE
,("Connectionless socket\n"));
135 Socket
->SharedData
.ServiceFlags1
|= XP1_CONNECTIONLESS
;
139 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
142 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
144 /* Set up EA Buffer */
145 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
147 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
149 RtlZeroMemory(EABuffer
, SizeOfEA
);
150 EABuffer
->NextEntryOffset
= 0;
152 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
153 RtlCopyMemory (EABuffer
->EaName
,
155 AFD_PACKET_COMMAND_LENGTH
+ 1);
156 EABuffer
->EaValueLength
= SizeOfPacket
;
158 /* Set up AFD Packet */
159 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
160 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
161 RtlCopyMemory (AfdPacket
->TransportName
,
162 TransportName
.Buffer
,
163 TransportName
.Length
+ sizeof(WCHAR
));
164 AfdPacket
->GroupID
= g
;
166 /* Set up Endpoint Flags */
167 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
169 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
171 /* Only RAW or UDP can be Connectionless */
174 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
177 if ((Socket
->SharedData
.ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
179 if (SocketType
== SOCK_STREAM
)
181 if ((Socket
->SharedData
.ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
183 /* The Provider doesn't actually support Message Oriented Streams */
187 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
190 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
192 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
193 WSA_FLAG_MULTIPOINT_C_LEAF
|
194 WSA_FLAG_MULTIPOINT_D_ROOT
|
195 WSA_FLAG_MULTIPOINT_D_LEAF
))
197 if ((Socket
->SharedData
.ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
199 /* The Provider doesn't actually support Multipoint */
202 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
204 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
206 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
207 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
209 /* The Provider doesn't support Control Planes, or you already gave a leaf */
212 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
215 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
217 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
218 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
220 /* The Provider doesn't support Data Planes, or you already gave a leaf */
223 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
227 /* Set up Object Attributes */
228 InitializeObjectAttributes (&Object
,
230 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
234 /* Create the Socket as asynchronous. That means we have to block
235 ourselves after every call to NtDeviceIoControlFile. This is
236 because the kernel doesn't support overlapping synchronous I/O
237 requests (made from multiple threads) at this time (Sep 2005) */
238 Status
= NtCreateFile(&Sock
,
239 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
244 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
250 HeapFree(GlobalHeap
, 0, EABuffer
);
252 if (Status
!= STATUS_SUCCESS
)
254 AFD_DbgPrint(MIN_TRACE
, ("Failed to open socket\n"));
256 HeapFree(GlobalHeap
, 0, Socket
);
258 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
262 Socket
->Handle
= (SOCKET
)Sock
;
264 /* XXX See if there's a structure we can reuse -- We need to do this
266 PrevSocket
= GetSocketStructure( (SOCKET
)Sock
);
270 RtlCopyMemory( PrevSocket
, Socket
, sizeof(*Socket
) );
271 RtlFreeHeap( GlobalHeap
, 0, Socket
);
275 /* Save Group Info */
278 GetSocketInformation(Socket
, AFD_INFO_GROUP_ID_TYPE
, 0, &GroupData
);
279 Socket
->SharedData
.GroupID
= GroupData
.u
.LowPart
;
280 Socket
->SharedData
.GroupType
= GroupData
.u
.HighPart
;
283 /* Get Window Sizes and Save them */
284 GetSocketInformation (Socket
,
285 AFD_INFO_SEND_WINDOW_SIZE
,
286 &Socket
->SharedData
.SizeOfSendBuffer
,
289 GetSocketInformation (Socket
,
290 AFD_INFO_RECEIVE_WINDOW_SIZE
,
291 &Socket
->SharedData
.SizeOfRecvBuffer
,
294 /* Save in Process Sockets List */
295 Socket
->NextSocket
= SocketListHead
;
296 SocketListHead
= Socket
;
298 /* Create the Socket Context */
299 CreateContext(Socket
);
302 Upcalls
.lpWPUModifyIFSHandle(1, (SOCKET
)Sock
, lpErrno
);
304 /* Return Socket Handle */
305 AFD_DbgPrint(MID_TRACE
,("Success %x\n", Sock
));
310 AFD_DbgPrint(MID_TRACE
,("Ending %x\n", Status
));
313 HeapFree(GlobalHeap
, 0, Socket
);
318 return INVALID_SOCKET
;
322 TranslateNtStatusError(NTSTATUS Status
)
326 case STATUS_CANT_WAIT
:
327 return WSAEWOULDBLOCK
;
335 case STATUS_FILE_CLOSED
:
336 case STATUS_END_OF_FILE
:
340 return WSA_IO_PENDING
;
342 case STATUS_BUFFER_TOO_SMALL
:
343 case STATUS_BUFFER_OVERFLOW
:
344 DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
347 case STATUS_NO_MEMORY
:
348 case STATUS_INSUFFICIENT_RESOURCES
:
349 DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
352 case STATUS_INVALID_CONNECTION
:
353 DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
354 return WSAEAFNOSUPPORT
;
356 case STATUS_INVALID_ADDRESS
:
357 DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
358 return WSAEADDRNOTAVAIL
;
360 case STATUS_REMOTE_NOT_LISTENING
:
361 DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
362 return WSAECONNREFUSED
;
364 case STATUS_NETWORK_UNREACHABLE
:
365 DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
366 return WSAENETUNREACH
;
368 case STATUS_INVALID_PARAMETER
:
369 DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
372 case STATUS_CANCELLED
:
373 DbgPrint("MSAFD: STATUS_CANCELLED\n");
374 return WSA_OPERATION_ABORTED
;
376 case STATUS_ADDRESS_ALREADY_EXISTS
:
377 DbgPrint("MSAFD: STATUS_ADDRESS_ALREADY_EXISTS\n");
378 return WSAEADDRINUSE
;
380 case STATUS_LOCAL_DISCONNECT
:
381 DbgPrint("MSAFD: STATUS_LOCAL_DISCONNECT\n");
382 return WSAECONNABORTED
;
384 case STATUS_REMOTE_DISCONNECT
:
385 DbgPrint("MSAFD: STATUS_REMOTE_DISCONNECT\n");
386 return WSAECONNRESET
;
389 DbgPrint("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
394 DWORD
MsafdReturnWithErrno(NTSTATUS Status
,
397 LPDWORD ReturnedBytes
)
399 *Errno
= TranslateNtStatusError(Status
);
404 *ReturnedBytes
= Received
;
409 return *Errno
? SOCKET_ERROR
: 0;
413 * FUNCTION: Closes an open socket
415 * s = Socket descriptor
416 * lpErrno = Address of buffer for error information
418 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
422 WSPCloseSocket(IN SOCKET Handle
,
425 IO_STATUS_BLOCK IoStatusBlock
;
426 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
429 AFD_DISCONNECT_INFO DisconnectInfo
;
430 SOCKET_STATE OldState
;
432 /* Create the Wait Event */
433 Status
= NtCreateEvent(&SockEvent
,
434 GENERIC_READ
| GENERIC_WRITE
,
439 if(!NT_SUCCESS(Status
))
442 /* Get the Socket Structure associate to this Socket*/
443 Socket
= GetSocketStructure(Handle
);
445 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
447 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
449 Socket
->TdiAddressHandle
,
450 Socket
->TdiConnectionHandle
,
455 if (lpErrno
) *lpErrno
= Status
;
461 /* If a Close is already in Process, give up */
462 if (Socket
->SharedData
.State
== SocketClosed
)
465 *lpErrno
= WSAENOTSOCK
;
469 /* Set the state to close */
470 OldState
= Socket
->SharedData
.State
;
471 Socket
->SharedData
.State
= SocketClosed
;
473 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
474 /* FIXME: Should we do this on Datagram Sockets too? */
475 if ((OldState
== SocketConnected
) && (Socket
->SharedData
.LingerData
.l_onoff
))
478 ULONG SendsInProgress
;
481 /* We need to respect the timeout */
483 LingerWait
= Socket
->SharedData
.LingerData
.l_linger
* 1000;
485 /* Loop until no more sends are pending, within the timeout */
488 /* Find out how many Sends are in Progress */
489 if (GetSocketInformation(Socket
,
490 AFD_INFO_SENDS_IN_PROGRESS
,
494 /* Bail out if anything but NO_ERROR */
499 /* Bail out if no more sends are pending */
500 if (!SendsInProgress
)
503 * We have to execute a sleep, so it's kind of like
504 * a block. If the socket is Nonblock, we cannot
505 * go on since asyncronous operation is expected
506 * and we cannot offer it
508 if (Socket
->SharedData
.NonBlocking
)
511 Socket
->SharedData
.State
= OldState
;
512 *lpErrno
= WSAEWOULDBLOCK
;
516 /* Now we can sleep, and decrement the linger wait */
518 * FIXME: It seems Windows does some funky acceleration
519 * since the waiting seems to be longer and longer. I
520 * don't think this improves performance so much, so we
521 * wait a fixed time instead.
524 LingerWait
-= SleepWait
;
528 * We have reached the timeout or sends are over.
529 * Disconnect if the timeout has been reached.
533 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
534 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_ABORT
;
537 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
542 IOCTL_AFD_DISCONNECT
,
544 sizeof(DisconnectInfo
),
548 /* Wait for return */
549 if (Status
== STATUS_PENDING
)
551 WaitForSingleObject(SockEvent
, INFINITE
);
552 Status
= IoStatusBlock
.Status
;
558 Socket
->HelperContext
= NULL
;
559 Socket
->SharedData
.AsyncDisabledEvents
= -1;
560 NtClose(Socket
->TdiAddressHandle
);
561 Socket
->TdiAddressHandle
= NULL
;
562 NtClose(Socket
->TdiConnectionHandle
);
563 Socket
->TdiConnectionHandle
= NULL
;
565 if (SocketListHead
== Socket
)
567 SocketListHead
= SocketListHead
->NextSocket
;
571 CurrentSocket
= SocketListHead
;
572 while (CurrentSocket
->NextSocket
)
574 if (CurrentSocket
->NextSocket
== Socket
)
576 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
580 CurrentSocket
= CurrentSocket
->NextSocket
;
584 HeapFree(GlobalHeap
, 0, Socket
);
586 /* Close the handle */
587 NtClose((HANDLE
)Handle
);
590 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
595 * FUNCTION: Associates a local address with a socket
597 * s = Socket descriptor
598 * name = Pointer to local address
599 * namelen = Length of name
600 * lpErrno = Address of buffer for error information
602 * 0, or SOCKET_ERROR if the socket could not be bound
606 WSPBind(SOCKET Handle
,
607 const struct sockaddr
*SocketAddress
,
608 int SocketAddressLength
,
611 IO_STATUS_BLOCK IOSB
;
612 PAFD_BIND_DATA BindData
;
613 PSOCKET_INFORMATION Socket
= NULL
;
615 SOCKADDR_INFO SocketInfo
;
619 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
622 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
625 Status
= NtCreateEvent(&SockEvent
,
626 GENERIC_READ
| GENERIC_WRITE
,
631 if (!NT_SUCCESS(Status
))
633 HeapFree(GlobalHeap
, 0, BindData
);
637 /* Get the Socket Structure associate to this Socket*/
638 Socket
= GetSocketStructure(Handle
);
640 /* Set up Address in TDI Format */
641 BindData
->Address
.TAAddressCount
= 1;
642 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
643 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
644 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
645 SocketAddress
->sa_data
,
646 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
648 /* Get Address Information */
649 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
653 /* Set the Share Type */
654 if (Socket
->SharedData
.ExclusiveAddressUse
)
656 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
658 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
660 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
662 else if (Socket
->SharedData
.ReuseAddresses
)
664 BindData
->ShareType
= AFD_SHARE_REUSE
;
668 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
672 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
679 0xA + Socket
->SharedData
.SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
681 0xA + Socket
->SharedData
.SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
683 /* Wait for return */
684 if (Status
== STATUS_PENDING
)
686 WaitForSingleObject(SockEvent
, INFINITE
);
687 Status
= IOSB
.Status
;
690 NtClose( SockEvent
);
691 HeapFree(GlobalHeap
, 0, BindData
);
693 if (Status
!= STATUS_SUCCESS
)
694 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
696 /* Set up Socket Data */
697 Socket
->SharedData
.State
= SocketBound
;
698 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
700 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
702 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
704 Socket
->TdiAddressHandle
,
705 Socket
->TdiConnectionHandle
,
710 if (lpErrno
) *lpErrno
= Status
;
715 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
720 WSPListen(SOCKET Handle
,
724 IO_STATUS_BLOCK IOSB
;
725 AFD_LISTEN_DATA ListenData
;
726 PSOCKET_INFORMATION Socket
= NULL
;
730 /* Get the Socket Structure associate to this Socket*/
731 Socket
= GetSocketStructure(Handle
);
733 if (Socket
->SharedData
.Listening
)
736 Status
= NtCreateEvent(&SockEvent
,
737 GENERIC_READ
| GENERIC_WRITE
,
742 if( !NT_SUCCESS(Status
) )
745 /* Set Up Listen Structure */
746 ListenData
.UseSAN
= FALSE
;
747 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
.UseDelayedAcceptance
;
748 ListenData
.Backlog
= Backlog
;
751 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
756 IOCTL_AFD_START_LISTEN
,
762 /* Wait for return */
763 if (Status
== STATUS_PENDING
)
765 WaitForSingleObject(SockEvent
, INFINITE
);
766 Status
= IOSB
.Status
;
769 NtClose( SockEvent
);
771 if (Status
!= STATUS_SUCCESS
)
772 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
774 /* Set to Listening */
775 Socket
->SharedData
.Listening
= TRUE
;
777 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
779 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
781 Socket
->TdiAddressHandle
,
782 Socket
->TdiConnectionHandle
,
787 if (lpErrno
) *lpErrno
= Status
;
792 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
802 const LPTIMEVAL timeout
,
805 IO_STATUS_BLOCK IOSB
;
806 PAFD_POLL_INFO PollInfo
;
808 LONG HandleCount
, OutCount
= 0;
809 ULONG PollBufferSize
;
814 LARGE_INTEGER Timeout
;
816 /* Find out how many sockets we have, and how large the buffer needs
819 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
820 ( writefds
? writefds
->fd_count
: 0 ) +
821 ( exceptfds
? exceptfds
->fd_count
: 0 );
823 if ( HandleCount
== 0 )
825 AFD_DbgPrint(MAX_TRACE
,("HandleCount: %d. Return SOCKET_ERROR\n",
827 if (lpErrno
) *lpErrno
= WSAEINVAL
;
831 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
833 AFD_DbgPrint(MID_TRACE
,("HandleCount: %d BufferSize: %d\n",
834 HandleCount
, PollBufferSize
));
836 /* Convert Timeout to NT Format */
839 Timeout
.u
.LowPart
= -1;
840 Timeout
.u
.HighPart
= 0x7FFFFFFF;
841 AFD_DbgPrint(MAX_TRACE
,("Infinite timeout\n"));
845 Timeout
= RtlEnlargedIntegerMultiply
846 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
847 /* Negative timeouts are illegal. Since the kernel represents an
848 * incremental timeout as a negative number, we check for a positive
851 if (Timeout
.QuadPart
> 0)
853 if (lpErrno
) *lpErrno
= WSAEINVAL
;
856 AFD_DbgPrint(MAX_TRACE
,("Timeout: Orig %d.%06d kernel %d\n",
857 timeout
->tv_sec
, timeout
->tv_usec
,
861 Status
= NtCreateEvent(&SockEvent
,
862 GENERIC_READ
| GENERIC_WRITE
,
867 if( !NT_SUCCESS(Status
) )
871 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
876 *lpErrno
= WSAEFAULT
;
881 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
883 RtlZeroMemory( PollInfo
, PollBufferSize
);
885 /* Number of handles for AFD to Check */
886 PollInfo
->Exclusive
= FALSE
;
887 PollInfo
->Timeout
= Timeout
;
889 if (readfds
!= NULL
) {
890 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
892 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
893 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
894 AFD_EVENT_DISCONNECT
|
900 if (writefds
!= NULL
)
902 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
904 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
905 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
908 if (exceptfds
!= NULL
)
910 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
912 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
913 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
917 PollInfo
->HandleCount
= j
;
918 PollBufferSize
= ((PCHAR
)&PollInfo
->Handles
[j
+1]) - ((PCHAR
)PollInfo
);
921 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
932 AFD_DbgPrint(MID_TRACE
,("DeviceIoControlFile => %x\n", Status
));
934 /* Wait for Completition */
935 if (Status
== STATUS_PENDING
)
937 WaitForSingleObject(SockEvent
, INFINITE
);
938 Status
= IOSB
.Status
;
941 /* Clear the Structures */
949 /* Loop through return structure */
950 HandleCount
= PollInfo
->HandleCount
;
952 /* Return in FDSET Format */
953 for (i
= 0; i
< HandleCount
; i
++)
955 HandleCounted
= FALSE
;
958 switch (PollInfo
->Handles
[i
].Events
& x
)
960 case AFD_EVENT_RECEIVE
:
961 case AFD_EVENT_DISCONNECT
:
962 case AFD_EVENT_ABORT
:
963 case AFD_EVENT_ACCEPT
:
964 case AFD_EVENT_CLOSE
:
965 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
966 PollInfo
->Handles
[i
].Events
,
967 PollInfo
->Handles
[i
].Handle
));
971 HandleCounted
= TRUE
;
974 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
977 case AFD_EVENT_CONNECT
:
978 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
979 PollInfo
->Handles
[i
].Events
,
980 PollInfo
->Handles
[i
].Handle
));
984 HandleCounted
= TRUE
;
987 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
989 case AFD_EVENT_OOB_RECEIVE
:
990 case AFD_EVENT_CONNECT_FAIL
:
991 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
992 PollInfo
->Handles
[i
].Events
,
993 PollInfo
->Handles
[i
].Handle
));
997 HandleCounted
= TRUE
;
1000 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1006 HeapFree( GlobalHeap
, 0, PollBuffer
);
1007 NtClose( SockEvent
);
1011 switch( IOSB
.Status
)
1013 case STATUS_SUCCESS
:
1014 case STATUS_TIMEOUT
:
1018 *lpErrno
= WSAEINVAL
;
1021 AFD_DbgPrint(MID_TRACE
,("*lpErrno = %x\n", *lpErrno
));
1024 AFD_DbgPrint(MID_TRACE
,("%d events\n", OutCount
));
1031 WSPAccept(SOCKET Handle
,
1032 struct sockaddr
*SocketAddress
,
1033 int *SocketAddressLength
,
1034 LPCONDITIONPROC lpfnCondition
,
1035 DWORD dwCallbackData
,
1038 IO_STATUS_BLOCK IOSB
;
1039 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1040 AFD_ACCEPT_DATA AcceptData
;
1041 AFD_DEFER_ACCEPT_DATA DeferData
;
1042 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1043 PSOCKET_INFORMATION Socket
= NULL
;
1045 struct fd_set ReadSet
;
1046 struct timeval Timeout
;
1047 PVOID PendingData
= NULL
;
1048 ULONG PendingDataLength
= 0;
1049 PVOID CalleeDataBuffer
;
1050 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1051 PSOCKADDR RemoteAddress
= NULL
;
1054 WSAPROTOCOL_INFOW ProtocolInfo
;
1055 SOCKET AcceptSocket
;
1056 UCHAR ReceiveBuffer
[0x1A];
1059 Status
= NtCreateEvent(&SockEvent
,
1060 GENERIC_READ
| GENERIC_WRITE
,
1065 if( !NT_SUCCESS(Status
) )
1067 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1068 return INVALID_SOCKET
;
1071 /* Dynamic Structure...ugh */
1072 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1074 /* Get the Socket Structure associate to this Socket*/
1075 Socket
= GetSocketStructure(Handle
);
1077 /* If this is non-blocking, make sure there's something for us to accept */
1079 FD_SET(Socket
->Handle
, &ReadSet
);
1083 WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, NULL
);
1085 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1092 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1097 IOCTL_AFD_WAIT_FOR_LISTEN
,
1101 0xA + sizeof(*ListenReceiveData
));
1103 /* Wait for return */
1104 if (Status
== STATUS_PENDING
)
1106 WaitForSingleObject(SockEvent
, INFINITE
);
1107 Status
= IOSB
.Status
;
1110 if (!NT_SUCCESS(Status
))
1112 NtClose( SockEvent
);
1113 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1114 return INVALID_SOCKET
;
1117 if (lpfnCondition
!= NULL
)
1119 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1121 /* Find out how much data is pending */
1122 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1123 PendingAcceptData
.ReturnSize
= TRUE
;
1126 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1131 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1133 sizeof(PendingAcceptData
),
1135 sizeof(PendingAcceptData
));
1137 /* Wait for return */
1138 if (Status
== STATUS_PENDING
)
1140 WaitForSingleObject(SockEvent
, INFINITE
);
1141 Status
= IOSB
.Status
;
1144 if (!NT_SUCCESS(Status
))
1146 NtClose( SockEvent
);
1147 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1148 return INVALID_SOCKET
;
1151 /* How much data to allocate */
1152 PendingDataLength
= IOSB
.Information
;
1154 if (PendingDataLength
)
1156 /* Allocate needed space */
1157 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1160 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1161 return INVALID_SOCKET
;
1164 /* We want the data now */
1165 PendingAcceptData
.ReturnSize
= FALSE
;
1168 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1173 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1175 sizeof(PendingAcceptData
),
1179 /* Wait for return */
1180 if (Status
== STATUS_PENDING
)
1182 WaitForSingleObject(SockEvent
, INFINITE
);
1183 Status
= IOSB
.Status
;
1186 if (!NT_SUCCESS(Status
))
1188 NtClose( SockEvent
);
1189 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1190 return INVALID_SOCKET
;
1195 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1197 /* I don't support this yet */
1200 /* Build Callee ID */
1201 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1202 CalleeID
.len
= Socket
->SharedData
.SizeOfLocalAddress
;
1204 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1207 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1208 return INVALID_SOCKET
;
1211 /* Set up Address in SOCKADDR Format */
1212 RtlCopyMemory (RemoteAddress
,
1213 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1214 sizeof(*RemoteAddress
));
1216 /* Build Caller ID */
1217 CallerID
.buf
= (PVOID
)RemoteAddress
;
1218 CallerID
.len
= sizeof(*RemoteAddress
);
1220 /* Build Caller Data */
1221 CallerData
.buf
= PendingData
;
1222 CallerData
.len
= PendingDataLength
;
1224 /* Check if socket supports Conditional Accept */
1225 if (Socket
->SharedData
.UseDelayedAcceptance
!= 0)
1227 /* Allocate Buffer for Callee Data */
1228 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1229 if (!CalleeDataBuffer
) {
1230 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1231 return INVALID_SOCKET
;
1233 CalleeData
.buf
= CalleeDataBuffer
;
1234 CalleeData
.len
= 4096;
1243 /* Call the Condition Function */
1244 CallBack
= (lpfnCondition
)(&CallerID
,
1245 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1249 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1253 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1255 /* TBD: Check for Validity */
1258 if (CallBack
== CF_ACCEPT
)
1260 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1262 /* I don't support this yet */
1266 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1271 /* Callback rejected. Build Defer Structure */
1272 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1273 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1276 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1281 IOCTL_AFD_DEFER_ACCEPT
,
1287 /* Wait for return */
1288 if (Status
== STATUS_PENDING
)
1290 WaitForSingleObject(SockEvent
, INFINITE
);
1291 Status
= IOSB
.Status
;
1294 NtClose( SockEvent
);
1296 if (!NT_SUCCESS(Status
))
1298 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1299 return INVALID_SOCKET
;
1302 if (CallBack
== CF_REJECT
)
1304 *lpErrno
= WSAECONNREFUSED
;
1305 return INVALID_SOCKET
;
1309 *lpErrno
= WSAECONNREFUSED
;
1310 return INVALID_SOCKET
;
1315 /* Create a new Socket */
1316 ProtocolInfo
.dwCatalogEntryId
= Socket
->SharedData
.CatalogEntryId
;
1317 ProtocolInfo
.dwServiceFlags1
= Socket
->SharedData
.ServiceFlags1
;
1318 ProtocolInfo
.dwProviderFlags
= Socket
->SharedData
.ProviderFlags
;
1320 AcceptSocket
= WSPSocket (Socket
->SharedData
.AddressFamily
,
1321 Socket
->SharedData
.SocketType
,
1322 Socket
->SharedData
.Protocol
,
1325 Socket
->SharedData
.CreateFlags
,
1328 /* Set up the Accept Structure */
1329 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1330 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1332 /* Send IOCTL to Accept */
1333 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1344 /* Wait for return */
1345 if (Status
== STATUS_PENDING
)
1347 WaitForSingleObject(SockEvent
, INFINITE
);
1348 Status
= IOSB
.Status
;
1351 if (!NT_SUCCESS(Status
))
1354 WSPCloseSocket( AcceptSocket
, lpErrno
);
1355 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1356 return INVALID_SOCKET
;
1359 /* Return Address in SOCKADDR FORMAT */
1362 RtlCopyMemory (SocketAddress
,
1363 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1364 sizeof(*RemoteAddress
));
1365 if( SocketAddressLength
)
1366 *SocketAddressLength
= ListenReceiveData
->Address
.Address
[0].AddressLength
;
1369 NtClose( SockEvent
);
1371 /* Re-enable Async Event */
1372 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1374 AFD_DbgPrint(MID_TRACE
,("Socket %x\n", AcceptSocket
));
1376 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1378 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1380 Socket
->TdiAddressHandle
,
1381 Socket
->TdiConnectionHandle
,
1386 if (lpErrno
) *lpErrno
= Status
;
1387 return INVALID_SOCKET
;
1394 return AcceptSocket
;
1399 WSPConnect(SOCKET Handle
,
1400 const struct sockaddr
* SocketAddress
,
1401 int SocketAddressLength
,
1402 LPWSABUF lpCallerData
,
1403 LPWSABUF lpCalleeData
,
1408 IO_STATUS_BLOCK IOSB
;
1409 PAFD_CONNECT_INFO ConnectInfo
;
1410 PSOCKET_INFORMATION Socket
= NULL
;
1412 UCHAR ConnectBuffer
[0x22];
1413 ULONG ConnectDataLength
;
1414 ULONG InConnectDataLength
;
1415 INT BindAddressLength
;
1416 PSOCKADDR BindAddress
;
1419 Status
= NtCreateEvent(&SockEvent
,
1420 GENERIC_READ
| GENERIC_WRITE
,
1425 if( !NT_SUCCESS(Status
) )
1428 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1430 /* Get the Socket Structure associate to this Socket*/
1431 Socket
= GetSocketStructure(Handle
);
1434 if (Socket
->SharedData
.State
== SocketOpen
)
1436 /* Get the Wildcard Address */
1437 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1438 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1441 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1442 return INVALID_SOCKET
;
1444 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1446 &BindAddressLength
);
1448 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1449 return INVALID_SOCKET
;
1452 /* Set the Connect Data */
1453 if (lpCallerData
!= NULL
)
1455 ConnectDataLength
= lpCallerData
->len
;
1456 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1461 IOCTL_AFD_SET_CONNECT_DATA
,
1466 /* Wait for return */
1467 if (Status
== STATUS_PENDING
)
1469 WaitForSingleObject(SockEvent
, INFINITE
);
1470 Status
= IOSB
.Status
;
1473 if (Status
!= STATUS_SUCCESS
)
1477 /* Dynamic Structure...ugh */
1478 ConnectInfo
= (PAFD_CONNECT_INFO
)ConnectBuffer
;
1480 /* Set up Address in TDI Format */
1481 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1482 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
1483 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1484 RtlCopyMemory (ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1485 SocketAddress
->sa_data
,
1486 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
1489 * Disable FD_WRITE and FD_CONNECT
1490 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1491 * at the end of this function right after the Async Thread disables it.
1492 * This should only happen at the *next* WSPConnect
1494 if (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
)
1496 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1499 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1500 if (lpCalleeData
!= NULL
)
1502 InConnectDataLength
= lpCalleeData
->len
;
1503 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1508 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1509 &InConnectDataLength
,
1510 sizeof(InConnectDataLength
),
1514 /* Wait for return */
1515 if (Status
== STATUS_PENDING
)
1517 WaitForSingleObject(SockEvent
, INFINITE
);
1518 Status
= IOSB
.Status
;
1521 if (Status
!= STATUS_SUCCESS
)
1525 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1526 ConnectInfo
->Root
= 0;
1527 ConnectInfo
->UseSAN
= FALSE
;
1528 ConnectInfo
->Unknown
= 0;
1530 /* FIXME: Handle Async Connect */
1531 if (Socket
->SharedData
.NonBlocking
)
1533 AFD_DbgPrint(MIN_TRACE
, ("Async Connect UNIMPLEMENTED!\n"));
1537 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1547 /* Wait for return */
1548 if (Status
== STATUS_PENDING
)
1550 WaitForSingleObject(SockEvent
, INFINITE
);
1551 Status
= IOSB
.Status
;
1554 if (Status
!= STATUS_SUCCESS
)
1557 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1559 /* Get any pending connect data */
1560 if (lpCalleeData
!= NULL
)
1562 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1567 IOCTL_AFD_GET_CONNECT_DATA
,
1572 /* Wait for return */
1573 if (Status
== STATUS_PENDING
)
1575 WaitForSingleObject(SockEvent
, INFINITE
);
1576 Status
= IOSB
.Status
;
1580 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1583 /* Re-enable Async Event */
1584 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1586 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1587 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1589 NtClose( SockEvent
);
1591 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1593 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1595 Socket
->TdiAddressHandle
,
1596 Socket
->TdiConnectionHandle
,
1597 WSH_NOTIFY_CONNECT
);
1601 if (lpErrno
) *lpErrno
= Status
;
1602 return SOCKET_ERROR
;
1605 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1607 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1609 Socket
->TdiAddressHandle
,
1610 Socket
->TdiConnectionHandle
,
1611 WSH_NOTIFY_CONNECT_ERROR
);
1615 if (lpErrno
) *lpErrno
= Status
;
1616 return SOCKET_ERROR
;
1620 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1624 WSPShutdown(SOCKET Handle
,
1629 IO_STATUS_BLOCK IOSB
;
1630 AFD_DISCONNECT_INFO DisconnectInfo
;
1631 PSOCKET_INFORMATION Socket
= NULL
;
1635 Status
= NtCreateEvent(&SockEvent
,
1636 GENERIC_READ
| GENERIC_WRITE
,
1641 if( !NT_SUCCESS(Status
) )
1644 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1646 /* Get the Socket Structure associate to this Socket*/
1647 Socket
= GetSocketStructure(Handle
);
1649 /* Set AFD Disconnect Type */
1653 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1654 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1657 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1658 Socket
->SharedData
.SendShutdown
= TRUE
;
1661 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1662 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1663 Socket
->SharedData
.SendShutdown
= TRUE
;
1667 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1);
1670 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1675 IOCTL_AFD_DISCONNECT
,
1677 sizeof(DisconnectInfo
),
1681 /* Wait for return */
1682 if (Status
== STATUS_PENDING
)
1684 WaitForSingleObject(SockEvent
, INFINITE
);
1685 Status
= IOSB
.Status
;
1688 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1690 NtClose( SockEvent
);
1692 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1698 WSPGetSockName(IN SOCKET Handle
,
1699 OUT LPSOCKADDR Name
,
1700 IN OUT LPINT NameLength
,
1703 IO_STATUS_BLOCK IOSB
;
1704 ULONG TdiAddressSize
;
1705 PTDI_ADDRESS_INFO TdiAddress
;
1706 PTRANSPORT_ADDRESS SocketAddress
;
1707 PSOCKET_INFORMATION Socket
= NULL
;
1711 Status
= NtCreateEvent(&SockEvent
,
1712 GENERIC_READ
| GENERIC_WRITE
,
1717 if( !NT_SUCCESS(Status
) )
1718 return SOCKET_ERROR
;
1720 /* Get the Socket Structure associate to this Socket*/
1721 Socket
= GetSocketStructure(Handle
);
1723 /* Allocate a buffer for the address */
1725 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfLocalAddress
;
1726 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1728 if ( TdiAddress
== NULL
)
1730 NtClose( SockEvent
);
1731 *lpErrno
= WSAENOBUFS
;
1732 return SOCKET_ERROR
;
1735 SocketAddress
= &TdiAddress
->Address
;
1738 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1743 IOCTL_AFD_GET_SOCK_NAME
,
1749 /* Wait for return */
1750 if (Status
== STATUS_PENDING
)
1752 WaitForSingleObject(SockEvent
, INFINITE
);
1753 Status
= IOSB
.Status
;
1756 NtClose( SockEvent
);
1758 if (NT_SUCCESS(Status
))
1760 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1762 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1763 RtlCopyMemory (Name
->sa_data
,
1764 SocketAddress
->Address
[0].Address
,
1765 SocketAddress
->Address
[0].AddressLength
);
1766 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1767 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1768 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1769 ((struct sockaddr_in
*)Name
)->sin_port
));
1770 HeapFree(GlobalHeap
, 0, TdiAddress
);
1775 HeapFree(GlobalHeap
, 0, TdiAddress
);
1776 *lpErrno
= WSAEFAULT
;
1777 return SOCKET_ERROR
;
1781 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1787 WSPGetPeerName(IN SOCKET s
,
1788 OUT LPSOCKADDR Name
,
1789 IN OUT LPINT NameLength
,
1792 IO_STATUS_BLOCK IOSB
;
1793 ULONG TdiAddressSize
;
1794 PTRANSPORT_ADDRESS SocketAddress
;
1795 PSOCKET_INFORMATION Socket
= NULL
;
1799 Status
= NtCreateEvent(&SockEvent
,
1800 GENERIC_READ
| GENERIC_WRITE
,
1805 if( !NT_SUCCESS(Status
) )
1806 return SOCKET_ERROR
;
1808 /* Get the Socket Structure associate to this Socket*/
1809 Socket
= GetSocketStructure(s
);
1811 /* Allocate a buffer for the address */
1812 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + *NameLength
;
1813 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1815 if ( SocketAddress
== NULL
)
1817 NtClose( SockEvent
);
1818 *lpErrno
= WSAENOBUFS
;
1819 return SOCKET_ERROR
;
1823 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1828 IOCTL_AFD_GET_PEER_NAME
,
1834 /* Wait for return */
1835 if (Status
== STATUS_PENDING
)
1837 WaitForSingleObject(SockEvent
, INFINITE
);
1838 Status
= IOSB
.Status
;
1841 NtClose( SockEvent
);
1843 if (NT_SUCCESS(Status
))
1845 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1847 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1848 RtlCopyMemory (Name
->sa_data
,
1849 SocketAddress
->Address
[0].Address
,
1850 SocketAddress
->Address
[0].AddressLength
);
1851 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1852 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %s Port %x\n",
1853 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1854 ((struct sockaddr_in
*)Name
)->sin_port
));
1855 HeapFree(GlobalHeap
, 0, SocketAddress
);
1860 HeapFree(GlobalHeap
, 0, SocketAddress
);
1861 *lpErrno
= WSAEFAULT
;
1862 return SOCKET_ERROR
;
1866 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1871 WSPIoctl(IN SOCKET Handle
,
1872 IN DWORD dwIoControlCode
,
1873 IN LPVOID lpvInBuffer
,
1874 IN DWORD cbInBuffer
,
1875 OUT LPVOID lpvOutBuffer
,
1876 IN DWORD cbOutBuffer
,
1877 OUT LPDWORD lpcbBytesReturned
,
1878 IN LPWSAOVERLAPPED lpOverlapped
,
1879 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
1880 IN LPWSATHREADID lpThreadId
,
1883 PSOCKET_INFORMATION Socket
= NULL
;
1885 /* Get the Socket Structure associate to this Socket*/
1886 Socket
= GetSocketStructure(Handle
);
1888 switch( dwIoControlCode
)
1891 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
1893 *lpErrno
= WSAEFAULT
;
1894 return SOCKET_ERROR
;
1896 Socket
->SharedData
.NonBlocking
= *((PULONG
)lpvInBuffer
) ? 1 : 0;
1897 return SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, (PULONG
)lpvInBuffer
, NULL
);
1899 if( cbOutBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvOutBuffer
) )
1901 *lpErrno
= WSAEFAULT
;
1902 return SOCKET_ERROR
;
1904 return GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, (PULONG
)lpvOutBuffer
, NULL
);
1906 *lpErrno
= WSAEINVAL
;
1907 return SOCKET_ERROR
;
1914 WSPGetSockOpt(IN SOCKET Handle
,
1917 OUT CHAR FAR
* OptionValue
,
1918 IN OUT LPINT OptionLength
,
1921 PSOCKET_INFORMATION Socket
= NULL
;
1926 /* Get the Socket Structure associate to this Socket*/
1927 Socket
= GetSocketStructure(Handle
);
1930 *lpErrno
= WSAENOTSOCK
;
1931 return SOCKET_ERROR
;
1934 AFD_DbgPrint(MID_TRACE
, ("Called\n"));
1942 Buffer
= &Socket
->SharedData
.SocketType
;
1943 BufferSize
= sizeof(INT
);
1947 Buffer
= &Socket
->SharedData
.SizeOfRecvBuffer
;
1948 BufferSize
= sizeof(INT
);
1952 Buffer
= &Socket
->SharedData
.SizeOfSendBuffer
;
1953 BufferSize
= sizeof(INT
);
1957 BoolBuffer
= Socket
->SharedData
.Listening
;
1958 Buffer
= &BoolBuffer
;
1959 BufferSize
= sizeof(BOOLEAN
);
1963 BoolBuffer
= Socket
->SharedData
.Broadcast
;
1964 Buffer
= &BoolBuffer
;
1965 BufferSize
= sizeof(BOOLEAN
);
1969 BoolBuffer
= Socket
->SharedData
.Debug
;
1970 Buffer
= &BoolBuffer
;
1971 BufferSize
= sizeof(BOOLEAN
);
1974 /* case SO_CONDITIONAL_ACCEPT: */
1979 case SO_GROUP_PRIORITY
:
1982 case SO_MAX_MSG_SIZE
:
1984 case SO_PROTOCOL_INFO
:
1986 AFD_DbgPrint(MID_TRACE
, ("Unimplemented option (%x)\n",
1990 *lpErrno
= WSAEINVAL
;
1991 return SOCKET_ERROR
;
1994 if (*OptionLength
< BufferSize
)
1996 *lpErrno
= WSAEFAULT
;
1997 *OptionLength
= BufferSize
;
1998 return SOCKET_ERROR
;
2000 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2004 case IPPROTO_TCP
: /* FIXME */
2006 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2008 Socket
->TdiAddressHandle
,
2009 Socket
->TdiConnectionHandle
,
2013 (LPINT
)OptionLength
);
2014 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2024 IN CONST CHAR FAR
* optval
,
2028 PSOCKET_INFORMATION Socket
;
2030 /* Get the Socket Structure associate to this Socket*/
2031 Socket
= GetSocketStructure(s
);
2034 *lpErrno
= WSAENOTSOCK
;
2035 return SOCKET_ERROR
;
2039 /* FIXME: We should handle some cases here */
2042 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2044 Socket
->TdiAddressHandle
,
2045 Socket
->TdiConnectionHandle
,
2050 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2054 * FUNCTION: Initialize service provider for a client
2056 * wVersionRequested = Highest WinSock SPI version that the caller can use
2057 * lpWSPData = Address of WSPDATA structure to initialize
2058 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2059 * UpcallTable = Pointer to upcall table of the WinSock DLL
2060 * lpProcTable = Address of procedure table to initialize
2062 * Status of operation
2066 WSPStartup(IN WORD wVersionRequested
,
2067 OUT LPWSPDATA lpWSPData
,
2068 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2069 IN WSPUPCALLTABLE UpcallTable
,
2070 OUT LPWSPPROC_TABLE lpProcTable
)
2075 AFD_DbgPrint(MAX_TRACE
, ("wVersionRequested (0x%X) \n", wVersionRequested
));
2077 Upcalls
= UpcallTable
;
2079 if (Status
== NO_ERROR
)
2081 lpProcTable
->lpWSPAccept
= WSPAccept
;
2082 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2083 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2084 lpProcTable
->lpWSPBind
= WSPBind
;
2085 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2086 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2087 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2088 lpProcTable
->lpWSPConnect
= WSPConnect
;
2089 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2090 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2091 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2092 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2093 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2094 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2095 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2096 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2097 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2098 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2099 lpProcTable
->lpWSPListen
= WSPListen
;
2100 lpProcTable
->lpWSPRecv
= WSPRecv
;
2101 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2102 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2103 lpProcTable
->lpWSPSelect
= WSPSelect
;
2104 lpProcTable
->lpWSPSend
= WSPSend
;
2105 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2106 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2107 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2108 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2109 lpProcTable
->lpWSPSocket
= WSPSocket
;
2110 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2111 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2112 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2115 AFD_DbgPrint(MAX_TRACE
, ("Status (%d).\n", Status
));
2122 * FUNCTION: Cleans up service provider for a client
2124 * lpErrno = Address of buffer for error information
2126 * 0 if successful, or SOCKET_ERROR if not
2130 WSPCleanup(OUT LPINT lpErrno
)
2133 AFD_DbgPrint(MAX_TRACE
, ("\n"));
2134 AFD_DbgPrint(MAX_TRACE
, ("Leaving.\n"));
2135 *lpErrno
= NO_ERROR
;
2143 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2144 ULONG AfdInformationClass
,
2145 PULONG Ulong OPTIONAL
,
2146 PLARGE_INTEGER LargeInteger OPTIONAL
)
2148 IO_STATUS_BLOCK IOSB
;
2153 Status
= NtCreateEvent(&SockEvent
,
2154 GENERIC_READ
| GENERIC_WRITE
,
2159 if( !NT_SUCCESS(Status
) )
2162 /* Set Info Class */
2163 InfoData
.InformationClass
= AfdInformationClass
;
2166 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2177 /* Wait for return */
2178 if (Status
== STATUS_PENDING
)
2180 WaitForSingleObject(SockEvent
, INFINITE
);
2181 Status
= IOSB
.Status
;
2184 if (Status
!= STATUS_SUCCESS
)
2187 /* Return Information */
2190 *Ulong
= InfoData
.Information
.Ulong
;
2192 if (LargeInteger
!= NULL
)
2194 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2197 NtClose( SockEvent
);
2205 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2206 ULONG AfdInformationClass
,
2207 PULONG Ulong OPTIONAL
,
2208 PLARGE_INTEGER LargeInteger OPTIONAL
)
2210 IO_STATUS_BLOCK IOSB
;
2215 Status
= NtCreateEvent(&SockEvent
,
2216 GENERIC_READ
| GENERIC_WRITE
,
2221 if( !NT_SUCCESS(Status
) )
2224 /* Set Info Class */
2225 InfoData
.InformationClass
= AfdInformationClass
;
2227 /* Set Information */
2230 InfoData
.Information
.Ulong
= *Ulong
;
2232 if (LargeInteger
!= NULL
)
2234 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2237 AFD_DbgPrint(MID_TRACE
,("XXX Info %x (Data %x)\n",
2238 AfdInformationClass
, *Ulong
));
2241 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2252 /* Wait for return */
2253 if (Status
== STATUS_PENDING
)
2255 WaitForSingleObject(SockEvent
, INFINITE
);
2256 Status
= IOSB
.Status
;
2259 NtClose( SockEvent
);
2261 return Status
== STATUS_SUCCESS
? 0 : -1;
2266 GetSocketStructure(SOCKET Handle
)
2268 PSOCKET_INFORMATION CurrentSocket
;
2270 /* This is a special case */
2271 if (SocketListHead
->Handle
== Handle
)
2272 return SocketListHead
;
2274 CurrentSocket
= SocketListHead
;
2275 while (CurrentSocket
->NextSocket
)
2277 if (CurrentSocket
->Handle
== Handle
)
2278 return CurrentSocket
;
2280 CurrentSocket
= CurrentSocket
->NextSocket
;
2286 int CreateContext(PSOCKET_INFORMATION Socket
)
2288 IO_STATUS_BLOCK IOSB
;
2289 SOCKET_CONTEXT ContextData
;
2293 Status
= NtCreateEvent(&SockEvent
,
2294 GENERIC_READ
| GENERIC_WRITE
,
2299 if( !NT_SUCCESS(Status
) )
2302 /* Create Context */
2303 ContextData
.SharedData
= Socket
->SharedData
;
2304 ContextData
.SizeOfHelperData
= 0;
2305 RtlCopyMemory (&ContextData
.LocalAddress
,
2306 Socket
->LocalAddress
,
2307 Socket
->SharedData
.SizeOfLocalAddress
);
2308 RtlCopyMemory (&ContextData
.RemoteAddress
,
2309 Socket
->RemoteAddress
,
2310 Socket
->SharedData
.SizeOfRemoteAddress
);
2313 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2318 IOCTL_AFD_SET_CONTEXT
,
2320 sizeof(ContextData
),
2324 /* Wait for Completition */
2325 if (Status
== STATUS_PENDING
)
2327 WaitForSingleObject(SockEvent
, INFINITE
);
2328 Status
= IOSB
.Status
;
2331 NtClose( SockEvent
);
2333 return Status
== STATUS_SUCCESS
? 0 : -1;
2336 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
2338 HANDLE hAsyncThread
;
2339 DWORD AsyncThreadId
;
2341 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2344 /* Check if the Thread Already Exists */
2345 if (SockAsyncThreadRefCount
)
2350 /* Create the Completion Port */
2351 if (!SockAsyncCompletionPort
)
2353 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
2354 IO_COMPLETION_ALL_ACCESS
,
2356 2); // Allow 2 threads only
2358 /* Protect Handle */
2359 HandleFlags
.ProtectFromClose
= TRUE
;
2360 HandleFlags
.Inherit
= FALSE
;
2361 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2362 ObjectHandleFlagInformation
,
2364 sizeof(HandleFlags
));
2367 /* Create the Async Event */
2368 Status
= NtCreateEvent(&AsyncEvent
,
2374 /* Create the Async Thread */
2375 hAsyncThread
= CreateThread(NULL
,
2377 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
2382 /* Close the Handle */
2383 NtClose(hAsyncThread
);
2385 /* Increase the Reference Count */
2386 SockAsyncThreadRefCount
++;
2390 int SockAsyncThread(PVOID ThreadParam
)
2393 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
2394 IO_STATUS_BLOCK IOSB
;
2397 /* Make the Thread Higher Priority */
2398 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
2400 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
2403 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
2404 (PVOID
*)&AsyncCompletionRoutine
,
2408 /* Call the Async Function */
2409 if (NT_SUCCESS(Status
))
2411 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
2415 /* It Failed, sleep for a second */
2418 } while ((Status
!= STATUS_TIMEOUT
));
2420 /* The Thread has Ended */
2424 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
2426 UNICODE_STRING AfdHelper
;
2427 OBJECT_ATTRIBUTES ObjectAttributes
;
2428 IO_STATUS_BLOCK IoSb
;
2430 FILE_COMPLETION_INFORMATION CompletionInfo
;
2431 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2433 /* First, make sure we're not already intialized */
2434 if (SockAsyncHelperAfdHandle
)
2439 /* Set up Handle Name and Object */
2440 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
2441 InitializeObjectAttributes(&ObjectAttributes
,
2443 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
2447 /* Open the Handle to AFD */
2448 Status
= NtCreateFile(&SockAsyncHelperAfdHandle
,
2449 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
2454 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2461 * Now Set up the Completion Port Information
2462 * This means that whenever a Poll is finished, the routine will be executed
2464 CompletionInfo
.Port
= SockAsyncCompletionPort
;
2465 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
2466 Status
= NtSetInformationFile(SockAsyncHelperAfdHandle
,
2469 sizeof(CompletionInfo
),
2470 FileCompletionInformation
);
2473 /* Protect the Handle */
2474 HandleFlags
.ProtectFromClose
= TRUE
;
2475 HandleFlags
.Inherit
= FALSE
;
2476 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2477 ObjectHandleFlagInformation
,
2479 sizeof(HandleFlags
));
2482 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
2483 SockAsyncSelectCalled
= TRUE
;
2487 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2490 PASYNC_DATA AsyncData
= Context
;
2491 PSOCKET_INFORMATION Socket
;
2494 /* Get the Socket */
2495 Socket
= AsyncData
->ParentSocket
;
2497 /* Check if the Sequence Number Changed behind our back */
2498 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
.SequenceNumber
)
2503 /* Check we were manually called b/c of a failure */
2504 if (!NT_SUCCESS(IoStatusBlock
->Status
))
2506 /* FIXME: Perform Upcall */
2510 for (x
= 1; x
; x
<<=1)
2512 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
2514 case AFD_EVENT_RECEIVE
:
2515 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_READ
) &&
2516 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_READ
))
2518 /* Make the Notifcation */
2519 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2520 Socket
->SharedData
.wMsg
,
2522 WSAMAKESELECTREPLY(FD_READ
, 0));
2523 /* Disable this event until the next read(); */
2524 Socket
->SharedData
.AsyncDisabledEvents
|= FD_READ
;
2528 case AFD_EVENT_OOB_RECEIVE
:
2529 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_OOB
) &&
2530 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_OOB
))
2532 /* Make the Notifcation */
2533 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2534 Socket
->SharedData
.wMsg
,
2536 WSAMAKESELECTREPLY(FD_OOB
, 0));
2537 /* Disable this event until the next read(); */
2538 Socket
->SharedData
.AsyncDisabledEvents
|= FD_OOB
;
2542 case AFD_EVENT_SEND
:
2543 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_WRITE
) &&
2544 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_WRITE
))
2546 /* Make the Notifcation */
2547 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2548 Socket
->SharedData
.wMsg
,
2550 WSAMAKESELECTREPLY(FD_WRITE
, 0));
2551 /* Disable this event until the next write(); */
2552 Socket
->SharedData
.AsyncDisabledEvents
|= FD_WRITE
;
2556 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2557 case AFD_EVENT_CONNECT
:
2558 case AFD_EVENT_CONNECT_FAIL
:
2559 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
) &&
2560 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CONNECT
))
2562 /* Make the Notifcation */
2563 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2564 Socket
->SharedData
.wMsg
,
2566 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
2567 /* Disable this event forever; */
2568 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
;
2572 case AFD_EVENT_ACCEPT
:
2573 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_ACCEPT
) &&
2574 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_ACCEPT
))
2576 /* Make the Notifcation */
2577 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2578 Socket
->SharedData
.wMsg
,
2580 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
2581 /* Disable this event until the next accept(); */
2582 Socket
->SharedData
.AsyncDisabledEvents
|= FD_ACCEPT
;
2586 case AFD_EVENT_DISCONNECT
:
2587 case AFD_EVENT_ABORT
:
2588 case AFD_EVENT_CLOSE
:
2589 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CLOSE
) &&
2590 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CLOSE
))
2592 /* Make the Notifcation */
2593 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2594 Socket
->SharedData
.wMsg
,
2596 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
2597 /* Disable this event forever; */
2598 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CLOSE
;
2601 /* FIXME: Support QOS */
2605 /* Check if there are any events left for us to check */
2606 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2612 SockProcessAsyncSelect(Socket
, AsyncData
);
2616 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
2619 ULONG lNetworkEvents
;
2622 /* Set up the Async Data Event Info */
2623 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
2624 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
2625 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
2626 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
2627 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
2628 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
2630 /* Remove unwanted events */
2631 lNetworkEvents
= Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
);
2633 /* Set Events to wait for */
2634 if (lNetworkEvents
& FD_READ
)
2636 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
2639 if (lNetworkEvents
& FD_WRITE
)
2641 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
2644 if (lNetworkEvents
& FD_OOB
)
2646 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
2649 if (lNetworkEvents
& FD_ACCEPT
)
2651 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
2654 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2655 if (lNetworkEvents
& FD_CONNECT
)
2657 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
2660 if (lNetworkEvents
& FD_CLOSE
)
2662 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
2665 if (lNetworkEvents
& FD_QOS
)
2667 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
2670 if (lNetworkEvents
& FD_GROUP_QOS
)
2672 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
2676 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
2680 &AsyncData
->IoStatusBlock
,
2682 &AsyncData
->AsyncSelectInfo
,
2683 sizeof(AsyncData
->AsyncSelectInfo
),
2684 &AsyncData
->AsyncSelectInfo
,
2685 sizeof(AsyncData
->AsyncSelectInfo
));
2687 /* I/O Manager Won't call the completion routine, let's do it manually */
2688 if (NT_SUCCESS(Status
))
2694 AsyncData
->IoStatusBlock
.Status
= Status
;
2695 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
2699 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2701 PASYNC_DATA AsyncData
= Context
;
2702 BOOL FreeContext
= TRUE
;
2703 PSOCKET_INFORMATION Socket
;
2705 /* Get the Socket */
2706 Socket
= AsyncData
->ParentSocket
;
2708 /* If someone closed it, stop the function */
2709 if (Socket
->SharedData
.State
!= SocketClosed
)
2711 /* Check if the Sequence Number changed by now, in which case quit */
2712 if (AsyncData
->SequenceNumber
== Socket
->SharedData
.SequenceNumber
)
2714 /* Do the actuall select, if needed */
2715 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)))
2717 SockProcessAsyncSelect(Socket
, AsyncData
);
2718 FreeContext
= FALSE
;
2723 /* Free the Context */
2726 HeapFree(GetProcessHeap(), 0, AsyncData
);
2733 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
2736 PASYNC_DATA AsyncData
;
2738 /* Make sure the event is actually disabled */
2739 if (!(Socket
->SharedData
.AsyncDisabledEvents
& Event
))
2745 Socket
->SharedData
.AsyncDisabledEvents
&= ~Event
;
2747 /* Return if no more events are being polled */
2748 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2753 /* Wait on new events */
2754 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
2755 if (!AsyncData
) return;
2757 /* Create the Asynch Thread if Needed */
2758 SockCreateOrReferenceAsyncThread();
2760 /* Increase the sequence number to stop anything else */
2761 Socket
->SharedData
.SequenceNumber
++;
2763 /* Set up the Async Data */
2764 AsyncData
->ParentSocket
= Socket
;
2765 AsyncData
->SequenceNumber
= Socket
->SharedData
.SequenceNumber
;
2767 /* Begin Async Select by using I/O Completion */
2768 NtSetIoCompletion(SockAsyncCompletionPort
,
2769 (PVOID
)&SockProcessQueuedAsyncSelect
,
2780 DllMain(HANDLE hInstDll
,
2787 case DLL_PROCESS_ATTACH
:
2789 AFD_DbgPrint(MAX_TRACE
, ("Loading MSAFD.DLL \n"));
2791 /* Don't need thread attach notifications
2792 so disable them to improve performance */
2793 DisableThreadLibraryCalls(hInstDll
);
2795 /* List of DLL Helpers */
2796 InitializeListHead(&SockHelpersListHead
);
2798 /* Heap to use when allocating */
2799 GlobalHeap
= GetProcessHeap();
2801 AFD_DbgPrint(MAX_TRACE
, ("MSAFD.DLL has been loaded\n"));
2805 case DLL_THREAD_ATTACH
:
2808 case DLL_THREAD_DETACH
:
2811 case DLL_PROCESS_DETACH
:
2815 AFD_DbgPrint(MAX_TRACE
, ("DllMain of msafd.dll (leaving)\n"));