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 PSOCKET_INFORMATION SocketListHead
= NULL
;
26 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
27 ULONG SockAsyncThreadRefCount
;
28 HANDLE SockAsyncHelperAfdHandle
;
29 HANDLE SockAsyncCompletionPort
;
30 BOOLEAN SockAsyncSelectCalled
;
35 * FUNCTION: Creates a new socket
39 * protocol = Protocol type
40 * lpProtocolInfo = Pointer to protocol information
42 * dwFlags = Socket flags
43 * lpErrno = Address of buffer for error information
45 * Created socket, or INVALID_SOCKET if it could not be created
49 WSPSocket(int AddressFamily
,
52 LPWSAPROTOCOL_INFOW lpProtocolInfo
,
57 OBJECT_ATTRIBUTES Object
;
61 PAFD_CREATE_PACKET AfdPacket
;
63 PSOCKET_INFORMATION Socket
= NULL
;
64 PFILE_FULL_EA_INFORMATION EABuffer
= NULL
;
65 PHELPER_DATA HelperData
;
66 PVOID HelperDLLContext
;
68 UNICODE_STRING TransportName
;
69 UNICODE_STRING DevName
;
70 LARGE_INTEGER GroupData
;
73 AFD_DbgPrint(MAX_TRACE
, ("Creating Socket, getting TDI Name\n"));
74 AFD_DbgPrint(MAX_TRACE
, ("AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
75 AddressFamily
, SocketType
, Protocol
));
77 /* Get Helper Data and Transport */
78 Status
= SockGetTdiName (&AddressFamily
,
89 if (Status
!= NO_ERROR
)
91 AFD_DbgPrint(MID_TRACE
,("SockGetTdiName: Status %x\n", Status
));
96 RtlInitUnicodeString(&DevName
, L
"\\Device\\Afd\\Endpoint");
99 Socket
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
));
101 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
103 RtlZeroMemory(Socket
, sizeof(*Socket
));
104 Socket
->RefCount
= 2;
106 Socket
->SharedData
.Listening
= FALSE
;
107 Socket
->SharedData
.State
= SocketOpen
;
108 Socket
->SharedData
.AddressFamily
= AddressFamily
;
109 Socket
->SharedData
.SocketType
= SocketType
;
110 Socket
->SharedData
.Protocol
= Protocol
;
111 Socket
->HelperContext
= HelperDLLContext
;
112 Socket
->HelperData
= HelperData
;
113 Socket
->HelperEvents
= HelperEvents
;
114 Socket
->LocalAddress
= &Socket
->WSLocalAddress
;
115 Socket
->SharedData
.SizeOfLocalAddress
= HelperData
->MaxWSAddressLength
;
116 Socket
->RemoteAddress
= &Socket
->WSRemoteAddress
;
117 Socket
->SharedData
.SizeOfRemoteAddress
= HelperData
->MaxWSAddressLength
;
118 Socket
->SharedData
.UseDelayedAcceptance
= HelperData
->UseDelayedAcceptance
;
119 Socket
->SharedData
.CreateFlags
= dwFlags
;
120 Socket
->SharedData
.CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
121 Socket
->SharedData
.ServiceFlags1
= lpProtocolInfo
->dwServiceFlags1
;
122 Socket
->SharedData
.ProviderFlags
= lpProtocolInfo
->dwProviderFlags
;
123 Socket
->SharedData
.GroupID
= g
;
124 Socket
->SharedData
.GroupType
= 0;
125 Socket
->SharedData
.UseSAN
= FALSE
;
126 Socket
->SharedData
.NonBlocking
= FALSE
; /* Sockets start blocking */
127 Socket
->SanData
= NULL
;
129 /* Ask alex about this */
130 if( Socket
->SharedData
.SocketType
== SOCK_DGRAM
||
131 Socket
->SharedData
.SocketType
== SOCK_RAW
)
133 AFD_DbgPrint(MID_TRACE
,("Connectionless socket\n"));
134 Socket
->SharedData
.ServiceFlags1
|= XP1_CONNECTIONLESS
;
138 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
141 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
143 /* Set up EA Buffer */
144 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
146 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
148 RtlZeroMemory(EABuffer
, SizeOfEA
);
149 EABuffer
->NextEntryOffset
= 0;
151 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
152 RtlCopyMemory (EABuffer
->EaName
,
154 AFD_PACKET_COMMAND_LENGTH
+ 1);
155 EABuffer
->EaValueLength
= SizeOfPacket
;
157 /* Set up AFD Packet */
158 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
159 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
160 RtlCopyMemory (AfdPacket
->TransportName
,
161 TransportName
.Buffer
,
162 TransportName
.Length
+ sizeof(WCHAR
));
163 AfdPacket
->GroupID
= g
;
165 /* Set up Endpoint Flags */
166 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
168 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
170 /* Only RAW or UDP can be Connectionless */
173 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
176 if ((Socket
->SharedData
.ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
178 if (SocketType
== SOCK_STREAM
)
180 if ((Socket
->SharedData
.ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
182 /* The Provider doesn't actually support Message Oriented Streams */
186 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
189 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
191 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
192 WSA_FLAG_MULTIPOINT_C_LEAF
|
193 WSA_FLAG_MULTIPOINT_D_ROOT
|
194 WSA_FLAG_MULTIPOINT_D_LEAF
))
196 if ((Socket
->SharedData
.ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
198 /* The Provider doesn't actually support Multipoint */
201 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
203 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
205 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
206 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
208 /* The Provider doesn't support Control Planes, or you already gave a leaf */
211 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
214 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
216 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
217 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
219 /* The Provider doesn't support Data Planes, or you already gave a leaf */
222 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
226 /* Set up Object Attributes */
227 InitializeObjectAttributes (&Object
,
229 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
233 /* Create the Socket as asynchronous. That means we have to block
234 ourselves after every call to NtDeviceIoControlFile. This is
235 because the kernel doesn't support overlapping synchronous I/O
236 requests (made from multiple threads) at this time (Sep 2005) */
237 Status
= NtCreateFile(&Sock
,
238 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
243 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
249 HeapFree(GlobalHeap
, 0, EABuffer
);
251 if (Status
!= STATUS_SUCCESS
)
253 AFD_DbgPrint(MIN_TRACE
, ("Failed to open socket\n"));
255 HeapFree(GlobalHeap
, 0, Socket
);
257 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
261 Socket
->Handle
= (SOCKET
)Sock
;
263 /* Save Group Info */
266 GetSocketInformation(Socket
, AFD_INFO_GROUP_ID_TYPE
, 0, &GroupData
);
267 Socket
->SharedData
.GroupID
= GroupData
.u
.LowPart
;
268 Socket
->SharedData
.GroupType
= GroupData
.u
.HighPart
;
271 /* Get Window Sizes and Save them */
272 GetSocketInformation (Socket
,
273 AFD_INFO_SEND_WINDOW_SIZE
,
274 &Socket
->SharedData
.SizeOfSendBuffer
,
277 GetSocketInformation (Socket
,
278 AFD_INFO_RECEIVE_WINDOW_SIZE
,
279 &Socket
->SharedData
.SizeOfRecvBuffer
,
282 /* Save in Process Sockets List */
283 Socket
->NextSocket
= SocketListHead
;
284 SocketListHead
= Socket
;
286 /* Create the Socket Context */
287 CreateContext(Socket
);
290 Upcalls
.lpWPUModifyIFSHandle(1, (SOCKET
)Sock
, lpErrno
);
292 /* Return Socket Handle */
293 AFD_DbgPrint(MID_TRACE
,("Success %x\n", Sock
));
298 AFD_DbgPrint(MID_TRACE
,("Ending %x\n", Status
));
301 HeapFree(GlobalHeap
, 0, Socket
);
306 return INVALID_SOCKET
;
310 TranslateNtStatusError(NTSTATUS Status
)
314 case STATUS_CANT_WAIT
:
315 return WSAEWOULDBLOCK
;
323 case STATUS_FILE_CLOSED
:
324 case STATUS_END_OF_FILE
:
328 return WSA_IO_PENDING
;
330 case STATUS_BUFFER_TOO_SMALL
:
331 case STATUS_BUFFER_OVERFLOW
:
332 DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
335 case STATUS_NO_MEMORY
:
336 case STATUS_INSUFFICIENT_RESOURCES
:
337 DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
340 case STATUS_INVALID_CONNECTION
:
341 DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
342 return WSAEAFNOSUPPORT
;
344 case STATUS_INVALID_ADDRESS
:
345 DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
346 return WSAEADDRNOTAVAIL
;
348 case STATUS_REMOTE_NOT_LISTENING
:
349 DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
350 return WSAECONNREFUSED
;
352 case STATUS_NETWORK_UNREACHABLE
:
353 DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
354 return WSAENETUNREACH
;
356 case STATUS_INVALID_PARAMETER
:
357 DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
360 case STATUS_CANCELLED
:
361 DbgPrint("MSAFD: STATUS_CANCELLED\n");
362 return WSA_OPERATION_ABORTED
;
364 case STATUS_ADDRESS_ALREADY_EXISTS
:
365 DbgPrint("MSAFD: STATUS_ADDRESS_ALREADY_EXISTS\n");
366 return WSAEADDRINUSE
;
368 case STATUS_LOCAL_DISCONNECT
:
369 DbgPrint("MSAFD: STATUS_LOCAL_DISCONNECT\n");
370 return WSAECONNABORTED
;
372 case STATUS_REMOTE_DISCONNECT
:
373 DbgPrint("MSAFD: STATUS_REMOTE_DISCONNECT\n");
374 return WSAECONNRESET
;
377 DbgPrint("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
382 DWORD
MsafdReturnWithErrno(NTSTATUS Status
,
385 LPDWORD ReturnedBytes
)
387 *Errno
= TranslateNtStatusError(Status
);
392 *ReturnedBytes
= Received
;
397 return *Errno
? SOCKET_ERROR
: 0;
401 * FUNCTION: Closes an open socket
403 * s = Socket descriptor
404 * lpErrno = Address of buffer for error information
406 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
410 WSPCloseSocket(IN SOCKET Handle
,
413 IO_STATUS_BLOCK IoStatusBlock
;
414 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
417 AFD_DISCONNECT_INFO DisconnectInfo
;
418 SOCKET_STATE OldState
;
420 /* Create the Wait Event */
421 Status
= NtCreateEvent(&SockEvent
,
422 GENERIC_READ
| GENERIC_WRITE
,
427 if(!NT_SUCCESS(Status
))
430 /* Get the Socket Structure associate to this Socket*/
431 Socket
= GetSocketStructure(Handle
);
435 *lpErrno
= WSAENOTSOCK
;
439 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
441 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
443 Socket
->TdiAddressHandle
,
444 Socket
->TdiConnectionHandle
,
449 if (lpErrno
) *lpErrno
= Status
;
455 /* If a Close is already in Process, give up */
456 if (Socket
->SharedData
.State
== SocketClosed
)
459 *lpErrno
= WSAENOTSOCK
;
463 /* Set the state to close */
464 OldState
= Socket
->SharedData
.State
;
465 Socket
->SharedData
.State
= SocketClosed
;
467 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
468 /* FIXME: Should we do this on Datagram Sockets too? */
469 if ((OldState
== SocketConnected
) && (Socket
->SharedData
.LingerData
.l_onoff
))
472 ULONG SendsInProgress
;
475 /* We need to respect the timeout */
477 LingerWait
= Socket
->SharedData
.LingerData
.l_linger
* 1000;
479 /* Loop until no more sends are pending, within the timeout */
482 /* Find out how many Sends are in Progress */
483 if (GetSocketInformation(Socket
,
484 AFD_INFO_SENDS_IN_PROGRESS
,
488 /* Bail out if anything but NO_ERROR */
493 /* Bail out if no more sends are pending */
494 if (!SendsInProgress
)
497 * We have to execute a sleep, so it's kind of like
498 * a block. If the socket is Nonblock, we cannot
499 * go on since asyncronous operation is expected
500 * and we cannot offer it
502 if (Socket
->SharedData
.NonBlocking
)
505 Socket
->SharedData
.State
= OldState
;
506 *lpErrno
= WSAEWOULDBLOCK
;
510 /* Now we can sleep, and decrement the linger wait */
512 * FIXME: It seems Windows does some funky acceleration
513 * since the waiting seems to be longer and longer. I
514 * don't think this improves performance so much, so we
515 * wait a fixed time instead.
518 LingerWait
-= SleepWait
;
522 * We have reached the timeout or sends are over.
523 * Disconnect if the timeout has been reached.
527 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
528 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_ABORT
;
531 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
536 IOCTL_AFD_DISCONNECT
,
538 sizeof(DisconnectInfo
),
542 /* Wait for return */
543 if (Status
== STATUS_PENDING
)
545 WaitForSingleObject(SockEvent
, INFINITE
);
546 Status
= IoStatusBlock
.Status
;
552 Socket
->HelperContext
= NULL
;
553 Socket
->SharedData
.AsyncDisabledEvents
= -1;
554 NtClose(Socket
->TdiAddressHandle
);
555 Socket
->TdiAddressHandle
= NULL
;
556 NtClose(Socket
->TdiConnectionHandle
);
557 Socket
->TdiConnectionHandle
= NULL
;
559 if (SocketListHead
== Socket
)
561 SocketListHead
= SocketListHead
->NextSocket
;
565 CurrentSocket
= SocketListHead
;
566 while (CurrentSocket
->NextSocket
)
568 if (CurrentSocket
->NextSocket
== Socket
)
570 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
574 CurrentSocket
= CurrentSocket
->NextSocket
;
578 HeapFree(GlobalHeap
, 0, Socket
);
580 /* Close the handle */
581 NtClose((HANDLE
)Handle
);
584 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
589 * FUNCTION: Associates a local address with a socket
591 * s = Socket descriptor
592 * name = Pointer to local address
593 * namelen = Length of name
594 * lpErrno = Address of buffer for error information
596 * 0, or SOCKET_ERROR if the socket could not be bound
600 WSPBind(SOCKET Handle
,
601 const struct sockaddr
*SocketAddress
,
602 int SocketAddressLength
,
605 IO_STATUS_BLOCK IOSB
;
606 PAFD_BIND_DATA BindData
;
607 PSOCKET_INFORMATION Socket
= NULL
;
609 SOCKADDR_INFO SocketInfo
;
613 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
616 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
619 Status
= NtCreateEvent(&SockEvent
,
620 GENERIC_READ
| GENERIC_WRITE
,
625 if (!NT_SUCCESS(Status
))
627 HeapFree(GlobalHeap
, 0, BindData
);
631 /* Get the Socket Structure associate to this Socket*/
632 Socket
= GetSocketStructure(Handle
);
635 HeapFree(GlobalHeap
, 0, BindData
);
636 *lpErrno
= WSAENOTSOCK
;
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
);
734 *lpErrno
= WSAENOTSOCK
;
738 if (Socket
->SharedData
.Listening
)
741 Status
= NtCreateEvent(&SockEvent
,
742 GENERIC_READ
| GENERIC_WRITE
,
747 if( !NT_SUCCESS(Status
) )
750 /* Set Up Listen Structure */
751 ListenData
.UseSAN
= FALSE
;
752 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
.UseDelayedAcceptance
;
753 ListenData
.Backlog
= Backlog
;
756 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
761 IOCTL_AFD_START_LISTEN
,
767 /* Wait for return */
768 if (Status
== STATUS_PENDING
)
770 WaitForSingleObject(SockEvent
, INFINITE
);
771 Status
= IOSB
.Status
;
774 NtClose( SockEvent
);
776 if (Status
!= STATUS_SUCCESS
)
777 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
779 /* Set to Listening */
780 Socket
->SharedData
.Listening
= TRUE
;
782 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
784 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
786 Socket
->TdiAddressHandle
,
787 Socket
->TdiConnectionHandle
,
792 if (lpErrno
) *lpErrno
= Status
;
797 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
803 WSPSelect(IN
int nfds
,
804 IN OUT fd_set
*readfds OPTIONAL
,
805 IN OUT fd_set
*writefds OPTIONAL
,
806 IN OUT fd_set
*exceptfds OPTIONAL
,
807 IN
const struct timeval
*timeout OPTIONAL
,
810 IO_STATUS_BLOCK IOSB
;
811 PAFD_POLL_INFO PollInfo
;
813 LONG HandleCount
, OutCount
= 0;
814 ULONG PollBufferSize
;
819 LARGE_INTEGER Timeout
;
821 /* Find out how many sockets we have, and how large the buffer needs
824 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
825 ( writefds
? writefds
->fd_count
: 0 ) +
826 ( exceptfds
? exceptfds
->fd_count
: 0 );
828 if ( HandleCount
== 0 )
830 AFD_DbgPrint(MAX_TRACE
,("HandleCount: %d. Return SOCKET_ERROR\n",
832 if (lpErrno
) *lpErrno
= WSAEINVAL
;
836 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
838 AFD_DbgPrint(MID_TRACE
,("HandleCount: %d BufferSize: %d\n",
839 HandleCount
, PollBufferSize
));
841 /* Convert Timeout to NT Format */
844 Timeout
.u
.LowPart
= -1;
845 Timeout
.u
.HighPart
= 0x7FFFFFFF;
846 AFD_DbgPrint(MAX_TRACE
,("Infinite timeout\n"));
850 Timeout
= RtlEnlargedIntegerMultiply
851 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
852 /* Negative timeouts are illegal. Since the kernel represents an
853 * incremental timeout as a negative number, we check for a positive
856 if (Timeout
.QuadPart
> 0)
858 if (lpErrno
) *lpErrno
= WSAEINVAL
;
861 AFD_DbgPrint(MAX_TRACE
,("Timeout: Orig %d.%06d kernel %d\n",
862 timeout
->tv_sec
, timeout
->tv_usec
,
866 Status
= NtCreateEvent(&SockEvent
,
867 GENERIC_READ
| GENERIC_WRITE
,
872 if( !NT_SUCCESS(Status
) )
876 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
881 *lpErrno
= WSAEFAULT
;
886 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
888 RtlZeroMemory( PollInfo
, PollBufferSize
);
890 /* Number of handles for AFD to Check */
891 PollInfo
->Exclusive
= FALSE
;
892 PollInfo
->Timeout
= Timeout
;
894 if (readfds
!= NULL
) {
895 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
897 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
898 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
899 AFD_EVENT_DISCONNECT
|
905 if (writefds
!= NULL
)
907 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
909 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
910 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
913 if (exceptfds
!= NULL
)
915 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
917 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
918 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
922 PollInfo
->HandleCount
= j
;
923 PollBufferSize
= ((PCHAR
)&PollInfo
->Handles
[j
+1]) - ((PCHAR
)PollInfo
);
926 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
937 AFD_DbgPrint(MID_TRACE
,("DeviceIoControlFile => %x\n", Status
));
939 /* Wait for Completition */
940 if (Status
== STATUS_PENDING
)
942 WaitForSingleObject(SockEvent
, INFINITE
);
943 Status
= IOSB
.Status
;
946 /* Clear the Structures */
954 /* Loop through return structure */
955 HandleCount
= PollInfo
->HandleCount
;
957 /* Return in FDSET Format */
958 for (i
= 0; i
< HandleCount
; i
++)
960 HandleCounted
= FALSE
;
963 switch (PollInfo
->Handles
[i
].Events
& x
)
965 case AFD_EVENT_RECEIVE
:
966 case AFD_EVENT_DISCONNECT
:
967 case AFD_EVENT_ABORT
:
968 case AFD_EVENT_ACCEPT
:
969 case AFD_EVENT_CLOSE
:
970 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
971 PollInfo
->Handles
[i
].Events
,
972 PollInfo
->Handles
[i
].Handle
));
976 HandleCounted
= TRUE
;
979 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
982 case AFD_EVENT_CONNECT
:
983 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
984 PollInfo
->Handles
[i
].Events
,
985 PollInfo
->Handles
[i
].Handle
));
989 HandleCounted
= TRUE
;
992 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
994 case AFD_EVENT_OOB_RECEIVE
:
995 case AFD_EVENT_CONNECT_FAIL
:
996 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
997 PollInfo
->Handles
[i
].Events
,
998 PollInfo
->Handles
[i
].Handle
));
1002 HandleCounted
= TRUE
;
1005 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1011 HeapFree( GlobalHeap
, 0, PollBuffer
);
1012 NtClose( SockEvent
);
1016 switch( IOSB
.Status
)
1018 case STATUS_SUCCESS
:
1019 case STATUS_TIMEOUT
:
1023 *lpErrno
= WSAEINVAL
;
1026 AFD_DbgPrint(MID_TRACE
,("*lpErrno = %x\n", *lpErrno
));
1029 AFD_DbgPrint(MID_TRACE
,("%d events\n", OutCount
));
1036 WSPAccept(SOCKET Handle
,
1037 struct sockaddr
*SocketAddress
,
1038 int *SocketAddressLength
,
1039 LPCONDITIONPROC lpfnCondition
,
1040 DWORD dwCallbackData
,
1043 IO_STATUS_BLOCK IOSB
;
1044 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1045 AFD_ACCEPT_DATA AcceptData
;
1046 AFD_DEFER_ACCEPT_DATA DeferData
;
1047 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1048 PSOCKET_INFORMATION Socket
= NULL
;
1050 struct fd_set ReadSet
;
1051 struct timeval Timeout
;
1052 PVOID PendingData
= NULL
;
1053 ULONG PendingDataLength
= 0;
1054 PVOID CalleeDataBuffer
;
1055 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1056 PSOCKADDR RemoteAddress
= NULL
;
1059 WSAPROTOCOL_INFOW ProtocolInfo
;
1060 SOCKET AcceptSocket
;
1061 UCHAR ReceiveBuffer
[0x1A];
1064 Status
= NtCreateEvent(&SockEvent
,
1065 GENERIC_READ
| GENERIC_WRITE
,
1070 if( !NT_SUCCESS(Status
) )
1072 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1073 return INVALID_SOCKET
;
1076 /* Dynamic Structure...ugh */
1077 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1079 /* Get the Socket Structure associate to this Socket*/
1080 Socket
= GetSocketStructure(Handle
);
1084 *lpErrno
= WSAENOTSOCK
;
1085 return INVALID_SOCKET
;
1088 /* If this is non-blocking, make sure there's something for us to accept */
1090 FD_SET(Socket
->Handle
, &ReadSet
);
1094 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1097 return INVALID_SOCKET
;
1100 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1103 *lpErrno
= WSAEWOULDBLOCK
;
1104 return INVALID_SOCKET
;
1108 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1113 IOCTL_AFD_WAIT_FOR_LISTEN
,
1117 0xA + sizeof(*ListenReceiveData
));
1119 /* Wait for return */
1120 if (Status
== STATUS_PENDING
)
1122 WaitForSingleObject(SockEvent
, INFINITE
);
1123 Status
= IOSB
.Status
;
1126 if (!NT_SUCCESS(Status
))
1128 NtClose( SockEvent
);
1129 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1130 return INVALID_SOCKET
;
1133 if (lpfnCondition
!= NULL
)
1135 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1137 /* Find out how much data is pending */
1138 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1139 PendingAcceptData
.ReturnSize
= TRUE
;
1142 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1147 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1149 sizeof(PendingAcceptData
),
1151 sizeof(PendingAcceptData
));
1153 /* Wait for return */
1154 if (Status
== STATUS_PENDING
)
1156 WaitForSingleObject(SockEvent
, INFINITE
);
1157 Status
= IOSB
.Status
;
1160 if (!NT_SUCCESS(Status
))
1162 NtClose( SockEvent
);
1163 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1164 return INVALID_SOCKET
;
1167 /* How much data to allocate */
1168 PendingDataLength
= IOSB
.Information
;
1170 if (PendingDataLength
)
1172 /* Allocate needed space */
1173 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1176 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1177 return INVALID_SOCKET
;
1180 /* We want the data now */
1181 PendingAcceptData
.ReturnSize
= FALSE
;
1184 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1189 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1191 sizeof(PendingAcceptData
),
1195 /* Wait for return */
1196 if (Status
== STATUS_PENDING
)
1198 WaitForSingleObject(SockEvent
, INFINITE
);
1199 Status
= IOSB
.Status
;
1202 if (!NT_SUCCESS(Status
))
1204 NtClose( SockEvent
);
1205 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1206 return INVALID_SOCKET
;
1211 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1213 /* I don't support this yet */
1216 /* Build Callee ID */
1217 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1218 CalleeID
.len
= Socket
->SharedData
.SizeOfLocalAddress
;
1220 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1223 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1224 return INVALID_SOCKET
;
1227 /* Set up Address in SOCKADDR Format */
1228 RtlCopyMemory (RemoteAddress
,
1229 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1230 sizeof(*RemoteAddress
));
1232 /* Build Caller ID */
1233 CallerID
.buf
= (PVOID
)RemoteAddress
;
1234 CallerID
.len
= sizeof(*RemoteAddress
);
1236 /* Build Caller Data */
1237 CallerData
.buf
= PendingData
;
1238 CallerData
.len
= PendingDataLength
;
1240 /* Check if socket supports Conditional Accept */
1241 if (Socket
->SharedData
.UseDelayedAcceptance
!= 0)
1243 /* Allocate Buffer for Callee Data */
1244 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1245 if (!CalleeDataBuffer
) {
1246 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1247 return INVALID_SOCKET
;
1249 CalleeData
.buf
= CalleeDataBuffer
;
1250 CalleeData
.len
= 4096;
1259 /* Call the Condition Function */
1260 CallBack
= (lpfnCondition
)(&CallerID
,
1261 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1265 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1269 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1271 /* TBD: Check for Validity */
1274 if (CallBack
== CF_ACCEPT
)
1276 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1278 /* I don't support this yet */
1282 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1287 /* Callback rejected. Build Defer Structure */
1288 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1289 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1292 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1297 IOCTL_AFD_DEFER_ACCEPT
,
1303 /* Wait for return */
1304 if (Status
== STATUS_PENDING
)
1306 WaitForSingleObject(SockEvent
, INFINITE
);
1307 Status
= IOSB
.Status
;
1310 NtClose( SockEvent
);
1312 if (!NT_SUCCESS(Status
))
1314 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1315 return INVALID_SOCKET
;
1318 if (CallBack
== CF_REJECT
)
1320 *lpErrno
= WSAECONNREFUSED
;
1321 return INVALID_SOCKET
;
1325 *lpErrno
= WSAECONNREFUSED
;
1326 return INVALID_SOCKET
;
1331 /* Create a new Socket */
1332 ProtocolInfo
.dwCatalogEntryId
= Socket
->SharedData
.CatalogEntryId
;
1333 ProtocolInfo
.dwServiceFlags1
= Socket
->SharedData
.ServiceFlags1
;
1334 ProtocolInfo
.dwProviderFlags
= Socket
->SharedData
.ProviderFlags
;
1336 AcceptSocket
= WSPSocket (Socket
->SharedData
.AddressFamily
,
1337 Socket
->SharedData
.SocketType
,
1338 Socket
->SharedData
.Protocol
,
1341 Socket
->SharedData
.CreateFlags
,
1343 if (AcceptSocket
== INVALID_SOCKET
)
1344 return INVALID_SOCKET
;
1346 /* Set up the Accept Structure */
1347 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1348 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1350 /* Send IOCTL to Accept */
1351 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1362 /* Wait for return */
1363 if (Status
== STATUS_PENDING
)
1365 WaitForSingleObject(SockEvent
, INFINITE
);
1366 Status
= IOSB
.Status
;
1369 if (!NT_SUCCESS(Status
))
1372 WSPCloseSocket( AcceptSocket
, lpErrno
);
1373 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1374 return INVALID_SOCKET
;
1377 /* Return Address in SOCKADDR FORMAT */
1380 RtlCopyMemory (SocketAddress
,
1381 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1382 sizeof(*RemoteAddress
));
1383 if( SocketAddressLength
)
1384 *SocketAddressLength
= ListenReceiveData
->Address
.Address
[0].AddressLength
;
1387 NtClose( SockEvent
);
1389 /* Re-enable Async Event */
1390 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1392 AFD_DbgPrint(MID_TRACE
,("Socket %x\n", AcceptSocket
));
1394 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1396 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1398 Socket
->TdiAddressHandle
,
1399 Socket
->TdiConnectionHandle
,
1404 if (lpErrno
) *lpErrno
= Status
;
1405 return INVALID_SOCKET
;
1412 return AcceptSocket
;
1417 WSPConnect(SOCKET Handle
,
1418 const struct sockaddr
* SocketAddress
,
1419 int SocketAddressLength
,
1420 LPWSABUF lpCallerData
,
1421 LPWSABUF lpCalleeData
,
1426 IO_STATUS_BLOCK IOSB
;
1427 PAFD_CONNECT_INFO ConnectInfo
;
1428 PSOCKET_INFORMATION Socket
= NULL
;
1430 UCHAR ConnectBuffer
[0x22];
1431 ULONG ConnectDataLength
;
1432 ULONG InConnectDataLength
;
1433 INT BindAddressLength
;
1434 PSOCKADDR BindAddress
;
1437 Status
= NtCreateEvent(&SockEvent
,
1438 GENERIC_READ
| GENERIC_WRITE
,
1443 if( !NT_SUCCESS(Status
) )
1446 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1448 /* Get the Socket Structure associate to this Socket*/
1449 Socket
= GetSocketStructure(Handle
);
1453 *lpErrno
= WSAENOTSOCK
;
1454 return SOCKET_ERROR
;
1458 if (Socket
->SharedData
.State
== SocketOpen
)
1460 /* Get the Wildcard Address */
1461 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1462 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1465 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1466 return INVALID_SOCKET
;
1468 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1470 &BindAddressLength
);
1472 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1473 return INVALID_SOCKET
;
1476 /* Set the Connect Data */
1477 if (lpCallerData
!= NULL
)
1479 ConnectDataLength
= lpCallerData
->len
;
1480 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1485 IOCTL_AFD_SET_CONNECT_DATA
,
1490 /* Wait for return */
1491 if (Status
== STATUS_PENDING
)
1493 WaitForSingleObject(SockEvent
, INFINITE
);
1494 Status
= IOSB
.Status
;
1497 if (Status
!= STATUS_SUCCESS
)
1501 /* Dynamic Structure...ugh */
1502 ConnectInfo
= (PAFD_CONNECT_INFO
)ConnectBuffer
;
1504 /* Set up Address in TDI Format */
1505 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1506 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
1507 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1508 RtlCopyMemory (ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1509 SocketAddress
->sa_data
,
1510 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
1513 * Disable FD_WRITE and FD_CONNECT
1514 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1515 * at the end of this function right after the Async Thread disables it.
1516 * This should only happen at the *next* WSPConnect
1518 if (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
)
1520 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1523 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1524 if (lpCalleeData
!= NULL
)
1526 InConnectDataLength
= lpCalleeData
->len
;
1527 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1532 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1533 &InConnectDataLength
,
1534 sizeof(InConnectDataLength
),
1538 /* Wait for return */
1539 if (Status
== STATUS_PENDING
)
1541 WaitForSingleObject(SockEvent
, INFINITE
);
1542 Status
= IOSB
.Status
;
1545 if (Status
!= STATUS_SUCCESS
)
1549 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1550 ConnectInfo
->Root
= 0;
1551 ConnectInfo
->UseSAN
= FALSE
;
1552 ConnectInfo
->Unknown
= 0;
1554 /* FIXME: Handle Async Connect */
1555 if (Socket
->SharedData
.NonBlocking
)
1557 AFD_DbgPrint(MIN_TRACE
, ("Async Connect UNIMPLEMENTED!\n"));
1561 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1571 /* Wait for return */
1572 if (Status
== STATUS_PENDING
)
1574 WaitForSingleObject(SockEvent
, INFINITE
);
1575 Status
= IOSB
.Status
;
1578 if (Status
!= STATUS_SUCCESS
)
1581 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1583 /* Get any pending connect data */
1584 if (lpCalleeData
!= NULL
)
1586 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1591 IOCTL_AFD_GET_CONNECT_DATA
,
1596 /* Wait for return */
1597 if (Status
== STATUS_PENDING
)
1599 WaitForSingleObject(SockEvent
, INFINITE
);
1600 Status
= IOSB
.Status
;
1604 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1607 /* Re-enable Async Event */
1608 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1610 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1611 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1613 NtClose( SockEvent
);
1615 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1617 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1619 Socket
->TdiAddressHandle
,
1620 Socket
->TdiConnectionHandle
,
1621 WSH_NOTIFY_CONNECT
);
1625 if (lpErrno
) *lpErrno
= Status
;
1626 return SOCKET_ERROR
;
1629 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1631 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1633 Socket
->TdiAddressHandle
,
1634 Socket
->TdiConnectionHandle
,
1635 WSH_NOTIFY_CONNECT_ERROR
);
1639 if (lpErrno
) *lpErrno
= Status
;
1640 return SOCKET_ERROR
;
1644 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1648 WSPShutdown(SOCKET Handle
,
1653 IO_STATUS_BLOCK IOSB
;
1654 AFD_DISCONNECT_INFO DisconnectInfo
;
1655 PSOCKET_INFORMATION Socket
= NULL
;
1659 Status
= NtCreateEvent(&SockEvent
,
1660 GENERIC_READ
| GENERIC_WRITE
,
1665 if( !NT_SUCCESS(Status
) )
1668 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1670 /* Get the Socket Structure associate to this Socket*/
1671 Socket
= GetSocketStructure(Handle
);
1675 *lpErrno
= WSAENOTSOCK
;
1676 return SOCKET_ERROR
;
1679 /* Set AFD Disconnect Type */
1683 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1684 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1687 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1688 Socket
->SharedData
.SendShutdown
= TRUE
;
1691 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1692 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1693 Socket
->SharedData
.SendShutdown
= TRUE
;
1697 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1);
1700 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1705 IOCTL_AFD_DISCONNECT
,
1707 sizeof(DisconnectInfo
),
1711 /* Wait for return */
1712 if (Status
== STATUS_PENDING
)
1714 WaitForSingleObject(SockEvent
, INFINITE
);
1715 Status
= IOSB
.Status
;
1718 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1720 NtClose( SockEvent
);
1722 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1728 WSPGetSockName(IN SOCKET Handle
,
1729 OUT LPSOCKADDR Name
,
1730 IN OUT LPINT NameLength
,
1733 IO_STATUS_BLOCK IOSB
;
1734 ULONG TdiAddressSize
;
1735 PTDI_ADDRESS_INFO TdiAddress
;
1736 PTRANSPORT_ADDRESS SocketAddress
;
1737 PSOCKET_INFORMATION Socket
= NULL
;
1741 Status
= NtCreateEvent(&SockEvent
,
1742 GENERIC_READ
| GENERIC_WRITE
,
1747 if( !NT_SUCCESS(Status
) )
1748 return SOCKET_ERROR
;
1750 /* Get the Socket Structure associate to this Socket*/
1751 Socket
= GetSocketStructure(Handle
);
1755 *lpErrno
= WSAENOTSOCK
;
1756 return SOCKET_ERROR
;
1759 /* Allocate a buffer for the address */
1761 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfLocalAddress
;
1762 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1764 if ( TdiAddress
== NULL
)
1766 NtClose( SockEvent
);
1767 *lpErrno
= WSAENOBUFS
;
1768 return SOCKET_ERROR
;
1771 SocketAddress
= &TdiAddress
->Address
;
1774 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1779 IOCTL_AFD_GET_SOCK_NAME
,
1785 /* Wait for return */
1786 if (Status
== STATUS_PENDING
)
1788 WaitForSingleObject(SockEvent
, INFINITE
);
1789 Status
= IOSB
.Status
;
1792 NtClose( SockEvent
);
1794 if (NT_SUCCESS(Status
))
1796 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1798 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1799 RtlCopyMemory (Name
->sa_data
,
1800 SocketAddress
->Address
[0].Address
,
1801 SocketAddress
->Address
[0].AddressLength
);
1802 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1803 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1804 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1805 ((struct sockaddr_in
*)Name
)->sin_port
));
1806 HeapFree(GlobalHeap
, 0, TdiAddress
);
1811 HeapFree(GlobalHeap
, 0, TdiAddress
);
1812 *lpErrno
= WSAEFAULT
;
1813 return SOCKET_ERROR
;
1817 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1823 WSPGetPeerName(IN SOCKET s
,
1824 OUT LPSOCKADDR Name
,
1825 IN OUT LPINT NameLength
,
1828 IO_STATUS_BLOCK IOSB
;
1829 ULONG TdiAddressSize
;
1830 PTRANSPORT_ADDRESS SocketAddress
;
1831 PSOCKET_INFORMATION Socket
= NULL
;
1835 Status
= NtCreateEvent(&SockEvent
,
1836 GENERIC_READ
| GENERIC_WRITE
,
1841 if( !NT_SUCCESS(Status
) )
1842 return SOCKET_ERROR
;
1844 /* Get the Socket Structure associate to this Socket*/
1845 Socket
= GetSocketStructure(s
);
1849 *lpErrno
= WSAENOTSOCK
;
1850 return SOCKET_ERROR
;
1853 /* Allocate a buffer for the address */
1854 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + *NameLength
;
1855 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1857 if ( SocketAddress
== NULL
)
1859 NtClose( SockEvent
);
1860 *lpErrno
= WSAENOBUFS
;
1861 return SOCKET_ERROR
;
1865 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1870 IOCTL_AFD_GET_PEER_NAME
,
1876 /* Wait for return */
1877 if (Status
== STATUS_PENDING
)
1879 WaitForSingleObject(SockEvent
, INFINITE
);
1880 Status
= IOSB
.Status
;
1883 NtClose( SockEvent
);
1885 if (NT_SUCCESS(Status
))
1887 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1889 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1890 RtlCopyMemory (Name
->sa_data
,
1891 SocketAddress
->Address
[0].Address
,
1892 SocketAddress
->Address
[0].AddressLength
);
1893 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1894 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %s Port %x\n",
1895 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1896 ((struct sockaddr_in
*)Name
)->sin_port
));
1897 HeapFree(GlobalHeap
, 0, SocketAddress
);
1902 HeapFree(GlobalHeap
, 0, SocketAddress
);
1903 *lpErrno
= WSAEFAULT
;
1904 return SOCKET_ERROR
;
1908 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1913 WSPIoctl(IN SOCKET Handle
,
1914 IN DWORD dwIoControlCode
,
1915 IN LPVOID lpvInBuffer
,
1916 IN DWORD cbInBuffer
,
1917 OUT LPVOID lpvOutBuffer
,
1918 IN DWORD cbOutBuffer
,
1919 OUT LPDWORD lpcbBytesReturned
,
1920 IN LPWSAOVERLAPPED lpOverlapped
,
1921 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
1922 IN LPWSATHREADID lpThreadId
,
1925 PSOCKET_INFORMATION Socket
= NULL
;
1927 /* Get the Socket Structure associate to this Socket*/
1928 Socket
= GetSocketStructure(Handle
);
1931 *lpErrno
= WSAENOTSOCK
;
1932 return SOCKET_ERROR
;
1935 switch( dwIoControlCode
)
1938 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
1940 *lpErrno
= WSAEFAULT
;
1941 return SOCKET_ERROR
;
1943 Socket
->SharedData
.NonBlocking
= *((PULONG
)lpvInBuffer
) ? 1 : 0;
1944 return SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, (PULONG
)lpvInBuffer
, NULL
);
1946 if( cbOutBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvOutBuffer
) )
1948 *lpErrno
= WSAEFAULT
;
1949 return SOCKET_ERROR
;
1951 return GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, (PULONG
)lpvOutBuffer
, NULL
);
1953 *lpErrno
= WSAEINVAL
;
1954 return SOCKET_ERROR
;
1961 WSPGetSockOpt(IN SOCKET Handle
,
1964 OUT CHAR FAR
* OptionValue
,
1965 IN OUT LPINT OptionLength
,
1968 PSOCKET_INFORMATION Socket
= NULL
;
1973 /* Get the Socket Structure associate to this Socket*/
1974 Socket
= GetSocketStructure(Handle
);
1977 *lpErrno
= WSAENOTSOCK
;
1978 return SOCKET_ERROR
;
1981 AFD_DbgPrint(MID_TRACE
, ("Called\n"));
1989 Buffer
= &Socket
->SharedData
.SocketType
;
1990 BufferSize
= sizeof(INT
);
1994 Buffer
= &Socket
->SharedData
.SizeOfRecvBuffer
;
1995 BufferSize
= sizeof(INT
);
1999 Buffer
= &Socket
->SharedData
.SizeOfSendBuffer
;
2000 BufferSize
= sizeof(INT
);
2004 BoolBuffer
= Socket
->SharedData
.Listening
;
2005 Buffer
= &BoolBuffer
;
2006 BufferSize
= sizeof(BOOLEAN
);
2010 BoolBuffer
= Socket
->SharedData
.Broadcast
;
2011 Buffer
= &BoolBuffer
;
2012 BufferSize
= sizeof(BOOLEAN
);
2016 BoolBuffer
= Socket
->SharedData
.Debug
;
2017 Buffer
= &BoolBuffer
;
2018 BufferSize
= sizeof(BOOLEAN
);
2021 /* case SO_CONDITIONAL_ACCEPT: */
2026 case SO_GROUP_PRIORITY
:
2029 case SO_MAX_MSG_SIZE
:
2031 case SO_PROTOCOL_INFO
:
2033 AFD_DbgPrint(MID_TRACE
, ("Unimplemented option (%x)\n",
2037 *lpErrno
= WSAEINVAL
;
2038 return SOCKET_ERROR
;
2041 if (*OptionLength
< BufferSize
)
2043 *lpErrno
= WSAEFAULT
;
2044 *OptionLength
= BufferSize
;
2045 return SOCKET_ERROR
;
2047 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2051 case IPPROTO_TCP
: /* FIXME */
2053 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2055 Socket
->TdiAddressHandle
,
2056 Socket
->TdiConnectionHandle
,
2060 (LPINT
)OptionLength
);
2061 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2071 IN CONST CHAR FAR
* optval
,
2075 PSOCKET_INFORMATION Socket
;
2077 /* Get the Socket Structure associate to this Socket*/
2078 Socket
= GetSocketStructure(s
);
2081 *lpErrno
= WSAENOTSOCK
;
2082 return SOCKET_ERROR
;
2086 /* FIXME: We should handle some cases here */
2089 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2091 Socket
->TdiAddressHandle
,
2092 Socket
->TdiConnectionHandle
,
2097 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2101 * FUNCTION: Initialize service provider for a client
2103 * wVersionRequested = Highest WinSock SPI version that the caller can use
2104 * lpWSPData = Address of WSPDATA structure to initialize
2105 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2106 * UpcallTable = Pointer to upcall table of the WinSock DLL
2107 * lpProcTable = Address of procedure table to initialize
2109 * Status of operation
2113 WSPStartup(IN WORD wVersionRequested
,
2114 OUT LPWSPDATA lpWSPData
,
2115 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2116 IN WSPUPCALLTABLE UpcallTable
,
2117 OUT LPWSPPROC_TABLE lpProcTable
)
2122 AFD_DbgPrint(MAX_TRACE
, ("wVersionRequested (0x%X) \n", wVersionRequested
));
2124 Upcalls
= UpcallTable
;
2126 if (Status
== NO_ERROR
)
2128 lpProcTable
->lpWSPAccept
= WSPAccept
;
2129 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2130 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2131 lpProcTable
->lpWSPBind
= WSPBind
;
2132 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2133 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2134 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2135 lpProcTable
->lpWSPConnect
= WSPConnect
;
2136 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2137 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2138 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2139 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2140 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2141 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2142 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2143 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2144 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2145 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2146 lpProcTable
->lpWSPListen
= WSPListen
;
2147 lpProcTable
->lpWSPRecv
= WSPRecv
;
2148 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2149 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2150 lpProcTable
->lpWSPSelect
= WSPSelect
;
2151 lpProcTable
->lpWSPSend
= WSPSend
;
2152 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2153 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2154 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2155 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2156 lpProcTable
->lpWSPSocket
= WSPSocket
;
2157 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2158 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2159 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2162 AFD_DbgPrint(MAX_TRACE
, ("Status (%d).\n", Status
));
2169 * FUNCTION: Cleans up service provider for a client
2171 * lpErrno = Address of buffer for error information
2173 * 0 if successful, or SOCKET_ERROR if not
2177 WSPCleanup(OUT LPINT lpErrno
)
2180 AFD_DbgPrint(MAX_TRACE
, ("\n"));
2181 AFD_DbgPrint(MAX_TRACE
, ("Leaving.\n"));
2182 *lpErrno
= NO_ERROR
;
2190 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2191 ULONG AfdInformationClass
,
2192 PULONG Ulong OPTIONAL
,
2193 PLARGE_INTEGER LargeInteger OPTIONAL
)
2195 IO_STATUS_BLOCK IOSB
;
2200 Status
= NtCreateEvent(&SockEvent
,
2201 GENERIC_READ
| GENERIC_WRITE
,
2206 if( !NT_SUCCESS(Status
) )
2209 /* Set Info Class */
2210 InfoData
.InformationClass
= AfdInformationClass
;
2213 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2224 /* Wait for return */
2225 if (Status
== STATUS_PENDING
)
2227 WaitForSingleObject(SockEvent
, INFINITE
);
2228 Status
= IOSB
.Status
;
2231 if (Status
!= STATUS_SUCCESS
)
2234 /* Return Information */
2237 *Ulong
= InfoData
.Information
.Ulong
;
2239 if (LargeInteger
!= NULL
)
2241 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2244 NtClose( SockEvent
);
2252 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2253 ULONG AfdInformationClass
,
2254 PULONG Ulong OPTIONAL
,
2255 PLARGE_INTEGER LargeInteger OPTIONAL
)
2257 IO_STATUS_BLOCK IOSB
;
2262 Status
= NtCreateEvent(&SockEvent
,
2263 GENERIC_READ
| GENERIC_WRITE
,
2268 if( !NT_SUCCESS(Status
) )
2271 /* Set Info Class */
2272 InfoData
.InformationClass
= AfdInformationClass
;
2274 /* Set Information */
2277 InfoData
.Information
.Ulong
= *Ulong
;
2279 if (LargeInteger
!= NULL
)
2281 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2284 AFD_DbgPrint(MID_TRACE
,("XXX Info %x (Data %x)\n",
2285 AfdInformationClass
, *Ulong
));
2288 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2299 /* Wait for return */
2300 if (Status
== STATUS_PENDING
)
2302 WaitForSingleObject(SockEvent
, INFINITE
);
2303 Status
= IOSB
.Status
;
2306 NtClose( SockEvent
);
2308 return Status
== STATUS_SUCCESS
? 0 : -1;
2313 GetSocketStructure(SOCKET Handle
)
2315 PSOCKET_INFORMATION CurrentSocket
;
2317 CurrentSocket
= SocketListHead
;
2318 while (CurrentSocket
)
2320 if (CurrentSocket
->Handle
== Handle
)
2321 return CurrentSocket
;
2323 CurrentSocket
= CurrentSocket
->NextSocket
;
2329 int CreateContext(PSOCKET_INFORMATION Socket
)
2331 IO_STATUS_BLOCK IOSB
;
2332 SOCKET_CONTEXT ContextData
;
2336 Status
= NtCreateEvent(&SockEvent
,
2337 GENERIC_READ
| GENERIC_WRITE
,
2342 if( !NT_SUCCESS(Status
) )
2345 /* Create Context */
2346 ContextData
.SharedData
= Socket
->SharedData
;
2347 ContextData
.SizeOfHelperData
= 0;
2348 RtlCopyMemory (&ContextData
.LocalAddress
,
2349 Socket
->LocalAddress
,
2350 Socket
->SharedData
.SizeOfLocalAddress
);
2351 RtlCopyMemory (&ContextData
.RemoteAddress
,
2352 Socket
->RemoteAddress
,
2353 Socket
->SharedData
.SizeOfRemoteAddress
);
2356 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2361 IOCTL_AFD_SET_CONTEXT
,
2363 sizeof(ContextData
),
2367 /* Wait for Completition */
2368 if (Status
== STATUS_PENDING
)
2370 WaitForSingleObject(SockEvent
, INFINITE
);
2371 Status
= IOSB
.Status
;
2374 NtClose( SockEvent
);
2376 return Status
== STATUS_SUCCESS
? 0 : -1;
2379 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
2381 HANDLE hAsyncThread
;
2382 DWORD AsyncThreadId
;
2384 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2387 /* Check if the Thread Already Exists */
2388 if (SockAsyncThreadRefCount
)
2393 /* Create the Completion Port */
2394 if (!SockAsyncCompletionPort
)
2396 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
2397 IO_COMPLETION_ALL_ACCESS
,
2399 2); // Allow 2 threads only
2401 /* Protect Handle */
2402 HandleFlags
.ProtectFromClose
= TRUE
;
2403 HandleFlags
.Inherit
= FALSE
;
2404 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2405 ObjectHandleFlagInformation
,
2407 sizeof(HandleFlags
));
2410 /* Create the Async Event */
2411 Status
= NtCreateEvent(&AsyncEvent
,
2417 /* Create the Async Thread */
2418 hAsyncThread
= CreateThread(NULL
,
2420 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
2425 /* Close the Handle */
2426 NtClose(hAsyncThread
);
2428 /* Increase the Reference Count */
2429 SockAsyncThreadRefCount
++;
2433 int SockAsyncThread(PVOID ThreadParam
)
2436 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
2437 IO_STATUS_BLOCK IOSB
;
2440 /* Make the Thread Higher Priority */
2441 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
2443 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
2446 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
2447 (PVOID
*)&AsyncCompletionRoutine
,
2451 /* Call the Async Function */
2452 if (NT_SUCCESS(Status
))
2454 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
2458 /* It Failed, sleep for a second */
2461 } while ((Status
!= STATUS_TIMEOUT
));
2463 /* The Thread has Ended */
2467 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
2469 UNICODE_STRING AfdHelper
;
2470 OBJECT_ATTRIBUTES ObjectAttributes
;
2471 IO_STATUS_BLOCK IoSb
;
2473 FILE_COMPLETION_INFORMATION CompletionInfo
;
2474 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2476 /* First, make sure we're not already intialized */
2477 if (SockAsyncHelperAfdHandle
)
2482 /* Set up Handle Name and Object */
2483 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
2484 InitializeObjectAttributes(&ObjectAttributes
,
2486 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
2490 /* Open the Handle to AFD */
2491 Status
= NtCreateFile(&SockAsyncHelperAfdHandle
,
2492 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
2497 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2504 * Now Set up the Completion Port Information
2505 * This means that whenever a Poll is finished, the routine will be executed
2507 CompletionInfo
.Port
= SockAsyncCompletionPort
;
2508 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
2509 Status
= NtSetInformationFile(SockAsyncHelperAfdHandle
,
2512 sizeof(CompletionInfo
),
2513 FileCompletionInformation
);
2516 /* Protect the Handle */
2517 HandleFlags
.ProtectFromClose
= TRUE
;
2518 HandleFlags
.Inherit
= FALSE
;
2519 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2520 ObjectHandleFlagInformation
,
2522 sizeof(HandleFlags
));
2525 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
2526 SockAsyncSelectCalled
= TRUE
;
2530 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2533 PASYNC_DATA AsyncData
= Context
;
2534 PSOCKET_INFORMATION Socket
;
2537 /* Get the Socket */
2538 Socket
= AsyncData
->ParentSocket
;
2540 /* Check if the Sequence Number Changed behind our back */
2541 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
.SequenceNumber
)
2546 /* Check we were manually called b/c of a failure */
2547 if (!NT_SUCCESS(IoStatusBlock
->Status
))
2549 /* FIXME: Perform Upcall */
2553 for (x
= 1; x
; x
<<=1)
2555 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
2557 case AFD_EVENT_RECEIVE
:
2558 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_READ
) &&
2559 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_READ
))
2561 /* Make the Notifcation */
2562 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2563 Socket
->SharedData
.wMsg
,
2565 WSAMAKESELECTREPLY(FD_READ
, 0));
2566 /* Disable this event until the next read(); */
2567 Socket
->SharedData
.AsyncDisabledEvents
|= FD_READ
;
2571 case AFD_EVENT_OOB_RECEIVE
:
2572 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_OOB
) &&
2573 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_OOB
))
2575 /* Make the Notifcation */
2576 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2577 Socket
->SharedData
.wMsg
,
2579 WSAMAKESELECTREPLY(FD_OOB
, 0));
2580 /* Disable this event until the next read(); */
2581 Socket
->SharedData
.AsyncDisabledEvents
|= FD_OOB
;
2585 case AFD_EVENT_SEND
:
2586 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_WRITE
) &&
2587 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_WRITE
))
2589 /* Make the Notifcation */
2590 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2591 Socket
->SharedData
.wMsg
,
2593 WSAMAKESELECTREPLY(FD_WRITE
, 0));
2594 /* Disable this event until the next write(); */
2595 Socket
->SharedData
.AsyncDisabledEvents
|= FD_WRITE
;
2599 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2600 case AFD_EVENT_CONNECT
:
2601 case AFD_EVENT_CONNECT_FAIL
:
2602 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
) &&
2603 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CONNECT
))
2605 /* Make the Notifcation */
2606 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2607 Socket
->SharedData
.wMsg
,
2609 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
2610 /* Disable this event forever; */
2611 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
;
2615 case AFD_EVENT_ACCEPT
:
2616 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_ACCEPT
) &&
2617 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_ACCEPT
))
2619 /* Make the Notifcation */
2620 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2621 Socket
->SharedData
.wMsg
,
2623 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
2624 /* Disable this event until the next accept(); */
2625 Socket
->SharedData
.AsyncDisabledEvents
|= FD_ACCEPT
;
2629 case AFD_EVENT_DISCONNECT
:
2630 case AFD_EVENT_ABORT
:
2631 case AFD_EVENT_CLOSE
:
2632 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CLOSE
) &&
2633 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CLOSE
))
2635 /* Make the Notifcation */
2636 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2637 Socket
->SharedData
.wMsg
,
2639 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
2640 /* Disable this event forever; */
2641 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CLOSE
;
2644 /* FIXME: Support QOS */
2648 /* Check if there are any events left for us to check */
2649 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2655 SockProcessAsyncSelect(Socket
, AsyncData
);
2659 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
2662 ULONG lNetworkEvents
;
2665 /* Set up the Async Data Event Info */
2666 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
2667 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
2668 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
2669 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
2670 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
2671 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
2673 /* Remove unwanted events */
2674 lNetworkEvents
= Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
);
2676 /* Set Events to wait for */
2677 if (lNetworkEvents
& FD_READ
)
2679 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
2682 if (lNetworkEvents
& FD_WRITE
)
2684 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
2687 if (lNetworkEvents
& FD_OOB
)
2689 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
2692 if (lNetworkEvents
& FD_ACCEPT
)
2694 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
2697 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2698 if (lNetworkEvents
& FD_CONNECT
)
2700 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
2703 if (lNetworkEvents
& FD_CLOSE
)
2705 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
2708 if (lNetworkEvents
& FD_QOS
)
2710 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
2713 if (lNetworkEvents
& FD_GROUP_QOS
)
2715 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
2719 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
2723 &AsyncData
->IoStatusBlock
,
2725 &AsyncData
->AsyncSelectInfo
,
2726 sizeof(AsyncData
->AsyncSelectInfo
),
2727 &AsyncData
->AsyncSelectInfo
,
2728 sizeof(AsyncData
->AsyncSelectInfo
));
2730 /* I/O Manager Won't call the completion routine, let's do it manually */
2731 if (NT_SUCCESS(Status
))
2737 AsyncData
->IoStatusBlock
.Status
= Status
;
2738 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
2742 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2744 PASYNC_DATA AsyncData
= Context
;
2745 BOOL FreeContext
= TRUE
;
2746 PSOCKET_INFORMATION Socket
;
2748 /* Get the Socket */
2749 Socket
= AsyncData
->ParentSocket
;
2751 /* If someone closed it, stop the function */
2752 if (Socket
->SharedData
.State
!= SocketClosed
)
2754 /* Check if the Sequence Number changed by now, in which case quit */
2755 if (AsyncData
->SequenceNumber
== Socket
->SharedData
.SequenceNumber
)
2757 /* Do the actuall select, if needed */
2758 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)))
2760 SockProcessAsyncSelect(Socket
, AsyncData
);
2761 FreeContext
= FALSE
;
2766 /* Free the Context */
2769 HeapFree(GetProcessHeap(), 0, AsyncData
);
2776 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
2779 PASYNC_DATA AsyncData
;
2781 /* Make sure the event is actually disabled */
2782 if (!(Socket
->SharedData
.AsyncDisabledEvents
& Event
))
2788 Socket
->SharedData
.AsyncDisabledEvents
&= ~Event
;
2790 /* Return if no more events are being polled */
2791 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2796 /* Wait on new events */
2797 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
2798 if (!AsyncData
) return;
2800 /* Create the Asynch Thread if Needed */
2801 SockCreateOrReferenceAsyncThread();
2803 /* Increase the sequence number to stop anything else */
2804 Socket
->SharedData
.SequenceNumber
++;
2806 /* Set up the Async Data */
2807 AsyncData
->ParentSocket
= Socket
;
2808 AsyncData
->SequenceNumber
= Socket
->SharedData
.SequenceNumber
;
2810 /* Begin Async Select by using I/O Completion */
2811 NtSetIoCompletion(SockAsyncCompletionPort
,
2812 (PVOID
)&SockProcessQueuedAsyncSelect
,
2823 DllMain(HANDLE hInstDll
,
2830 case DLL_PROCESS_ATTACH
:
2832 AFD_DbgPrint(MAX_TRACE
, ("Loading MSAFD.DLL \n"));
2834 /* Don't need thread attach notifications
2835 so disable them to improve performance */
2836 DisableThreadLibraryCalls(hInstDll
);
2838 /* List of DLL Helpers */
2839 InitializeListHead(&SockHelpersListHead
);
2841 /* Heap to use when allocating */
2842 GlobalHeap
= GetProcessHeap();
2844 AFD_DbgPrint(MAX_TRACE
, ("MSAFD.DLL has been loaded\n"));
2848 case DLL_THREAD_ATTACH
:
2851 case DLL_THREAD_DETACH
:
2854 case DLL_PROCESS_DETACH
:
2858 AFD_DbgPrint(MAX_TRACE
, ("DllMain of msafd.dll (leaving)\n"));