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
*Sockets
= 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 Sockets
[SocketCount
] = 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 DWORD
MsafdReturnWithErrno(NTSTATUS Status
,
325 LPDWORD ReturnedBytes
)
333 case STATUS_CANT_WAIT
:
334 *Errno
= WSAEWOULDBLOCK
;
337 *Errno
= WSAETIMEDOUT
;
340 /* Return Number of bytes Read */
342 *ReturnedBytes
= Received
;
344 case STATUS_FILE_CLOSED
:
345 case STATUS_END_OF_FILE
:
346 *Errno
= WSAESHUTDOWN
;
349 *Errno
= WSA_IO_PENDING
;
351 case STATUS_BUFFER_TOO_SMALL
:
352 case STATUS_BUFFER_OVERFLOW
:
353 DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
354 *Errno
= WSAEMSGSIZE
;
356 case STATUS_NO_MEMORY
: /* Fall through to STATUS_INSUFFICIENT_RESOURCES */
357 case STATUS_INSUFFICIENT_RESOURCES
:
358 DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
361 case STATUS_INVALID_CONNECTION
:
362 DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
363 *Errno
= WSAEAFNOSUPPORT
;
365 case STATUS_INVALID_ADDRESS
:
366 DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
367 *Errno
= WSAEADDRNOTAVAIL
;
369 case STATUS_REMOTE_NOT_LISTENING
:
370 DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
371 *Errno
= WSAECONNREFUSED
;
373 case STATUS_NETWORK_UNREACHABLE
:
374 DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
375 *Errno
= WSAENETUNREACH
;
377 case STATUS_INVALID_PARAMETER
:
378 DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
381 case STATUS_CANCELLED
:
382 DbgPrint("MSAFD: STATUS_CANCELLED\n");
383 *Errno
= WSA_OPERATION_ABORTED
;
386 DbgPrint("MSAFD: Error %x is unknown\n", Status
);
393 return Status
== STATUS_SUCCESS
? 0 : SOCKET_ERROR
;
397 * FUNCTION: Closes an open socket
399 * s = Socket descriptor
400 * lpErrno = Address of buffer for error information
402 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
406 WSPCloseSocket(IN SOCKET Handle
,
409 IO_STATUS_BLOCK IoStatusBlock
;
410 PSOCKET_INFORMATION Socket
= NULL
;
413 AFD_DISCONNECT_INFO DisconnectInfo
;
414 SOCKET_STATE OldState
;
416 /* Create the Wait Event */
417 Status
= NtCreateEvent(&SockEvent
,
418 GENERIC_READ
| GENERIC_WRITE
,
423 if(!NT_SUCCESS(Status
))
426 /* Get the Socket Structure associate to this Socket*/
427 Socket
= GetSocketStructure(Handle
);
429 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
431 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
433 Socket
->TdiAddressHandle
,
434 Socket
->TdiConnectionHandle
,
439 if (lpErrno
) *lpErrno
= Status
;
445 /* If a Close is already in Process, give up */
446 if (Socket
->SharedData
.State
== SocketClosed
)
449 *lpErrno
= WSAENOTSOCK
;
453 /* Set the state to close */
454 OldState
= Socket
->SharedData
.State
;
455 Socket
->SharedData
.State
= SocketClosed
;
457 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
458 /* FIXME: Should we do this on Datagram Sockets too? */
459 if ((OldState
== SocketConnected
) && (Socket
->SharedData
.LingerData
.l_onoff
))
462 ULONG SendsInProgress
;
465 /* We need to respect the timeout */
467 LingerWait
= Socket
->SharedData
.LingerData
.l_linger
* 1000;
469 /* Loop until no more sends are pending, within the timeout */
472 /* Find out how many Sends are in Progress */
473 if (GetSocketInformation(Socket
,
474 AFD_INFO_SENDS_IN_PROGRESS
,
478 /* Bail out if anything but NO_ERROR */
483 /* Bail out if no more sends are pending */
484 if (!SendsInProgress
)
487 * We have to execute a sleep, so it's kind of like
488 * a block. If the socket is Nonblock, we cannot
489 * go on since asyncronous operation is expected
490 * and we cannot offer it
492 if (Socket
->SharedData
.NonBlocking
)
495 Socket
->SharedData
.State
= OldState
;
496 *lpErrno
= WSAEWOULDBLOCK
;
500 /* Now we can sleep, and decrement the linger wait */
502 * FIXME: It seems Windows does some funky acceleration
503 * since the waiting seems to be longer and longer. I
504 * don't think this improves performance so much, so we
505 * wait a fixed time instead.
508 LingerWait
-= SleepWait
;
512 * We have reached the timeout or sends are over.
513 * Disconnect if the timeout has been reached.
517 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
518 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_ABORT
;
521 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
526 IOCTL_AFD_DISCONNECT
,
528 sizeof(DisconnectInfo
),
532 /* Wait for return */
533 if (Status
== STATUS_PENDING
)
535 WaitForSingleObject(SockEvent
, INFINITE
);
536 Status
= IoStatusBlock
.Status
;
542 Socket
->HelperContext
= NULL
;
543 Socket
->SharedData
.AsyncDisabledEvents
= -1;
544 NtClose(Socket
->TdiAddressHandle
);
545 Socket
->TdiAddressHandle
= NULL
;
546 NtClose(Socket
->TdiConnectionHandle
);
547 Socket
->TdiConnectionHandle
= NULL
;
549 /* Close the handle */
550 NtClose((HANDLE
)Handle
);
558 * FUNCTION: Associates a local address with a socket
560 * s = Socket descriptor
561 * name = Pointer to local address
562 * namelen = Length of name
563 * lpErrno = Address of buffer for error information
565 * 0, or SOCKET_ERROR if the socket could not be bound
569 WSPBind(SOCKET Handle
,
570 const struct sockaddr
*SocketAddress
,
571 int SocketAddressLength
,
574 IO_STATUS_BLOCK IOSB
;
575 PAFD_BIND_DATA BindData
;
576 PSOCKET_INFORMATION Socket
= NULL
;
578 SOCKADDR_INFO SocketInfo
;
582 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
585 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
588 Status
= NtCreateEvent(&SockEvent
,
589 GENERIC_READ
| GENERIC_WRITE
,
594 if (!NT_SUCCESS(Status
))
596 HeapFree(GlobalHeap
, 0, BindData
);
600 /* Get the Socket Structure associate to this Socket*/
601 Socket
= GetSocketStructure(Handle
);
603 /* Set up Address in TDI Format */
604 BindData
->Address
.TAAddressCount
= 1;
605 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
606 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
607 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
608 SocketAddress
->sa_data
,
609 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
611 /* Get Address Information */
612 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
616 /* Set the Share Type */
617 if (Socket
->SharedData
.ExclusiveAddressUse
)
619 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
621 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
623 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
625 else if (Socket
->SharedData
.ReuseAddresses
)
627 BindData
->ShareType
= AFD_SHARE_REUSE
;
631 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
635 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
642 0xA + Socket
->SharedData
.SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
644 0xA + Socket
->SharedData
.SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
646 /* Wait for return */
647 if (Status
== STATUS_PENDING
)
649 WaitForSingleObject(SockEvent
, INFINITE
);
650 Status
= IOSB
.Status
;
653 /* Set up Socket Data */
654 Socket
->SharedData
.State
= SocketBound
;
655 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
657 NtClose( SockEvent
);
658 HeapFree(GlobalHeap
, 0, BindData
);
659 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_BIND
))
661 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
663 Socket
->TdiAddressHandle
,
664 Socket
->TdiConnectionHandle
,
669 if (lpErrno
) *lpErrno
= Status
;
674 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
679 WSPListen(SOCKET Handle
,
683 IO_STATUS_BLOCK IOSB
;
684 AFD_LISTEN_DATA ListenData
;
685 PSOCKET_INFORMATION Socket
= NULL
;
689 /* Get the Socket Structure associate to this Socket*/
690 Socket
= GetSocketStructure(Handle
);
692 if (Socket
->SharedData
.Listening
)
695 Status
= NtCreateEvent(&SockEvent
,
696 GENERIC_READ
| GENERIC_WRITE
,
701 if( !NT_SUCCESS(Status
) )
704 /* Set Up Listen Structure */
705 ListenData
.UseSAN
= FALSE
;
706 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
.UseDelayedAcceptance
;
707 ListenData
.Backlog
= Backlog
;
710 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
715 IOCTL_AFD_START_LISTEN
,
721 /* Wait for return */
722 if (Status
== STATUS_PENDING
)
724 WaitForSingleObject(SockEvent
, INFINITE
);
725 Status
= IOSB
.Status
;
728 /* Set to Listening */
729 Socket
->SharedData
.Listening
= TRUE
;
731 NtClose( SockEvent
);
733 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
))
735 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
737 Socket
->TdiAddressHandle
,
738 Socket
->TdiConnectionHandle
,
743 if (lpErrno
) *lpErrno
= Status
;
748 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
758 const LPTIMEVAL timeout
,
761 IO_STATUS_BLOCK IOSB
;
762 PAFD_POLL_INFO PollInfo
;
764 LONG HandleCount
, OutCount
= 0;
765 ULONG PollBufferSize
;
770 LARGE_INTEGER Timeout
;
772 /* Find out how many sockets we have, and how large the buffer needs
775 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
776 ( writefds
? writefds
->fd_count
: 0 ) +
777 ( exceptfds
? exceptfds
->fd_count
: 0 );
779 if ( HandleCount
== 0 )
781 AFD_DbgPrint(MAX_TRACE
,("HandleCount: %d. Return SOCKET_ERROR\n",
783 if (lpErrno
) *lpErrno
= WSAEINVAL
;
787 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
789 AFD_DbgPrint(MID_TRACE
,("HandleCount: %d BufferSize: %d\n",
790 HandleCount
, PollBufferSize
));
792 /* Convert Timeout to NT Format */
795 Timeout
.u
.LowPart
= -1;
796 Timeout
.u
.HighPart
= 0x7FFFFFFF;
797 AFD_DbgPrint(MAX_TRACE
,("Infinite timeout\n"));
801 Timeout
= RtlEnlargedIntegerMultiply
802 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
803 /* Negative timeouts are illegal. Since the kernel represents an
804 * incremental timeout as a negative number, we check for a positive
807 if (Timeout
.QuadPart
> 0)
809 if (lpErrno
) *lpErrno
= WSAEINVAL
;
812 AFD_DbgPrint(MAX_TRACE
,("Timeout: Orig %d.%06d kernel %d\n",
813 timeout
->tv_sec
, timeout
->tv_usec
,
817 Status
= NtCreateEvent(&SockEvent
,
818 GENERIC_READ
| GENERIC_WRITE
,
823 if( !NT_SUCCESS(Status
) )
827 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
832 *lpErrno
= WSAEFAULT
;
837 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
839 RtlZeroMemory( PollInfo
, PollBufferSize
);
841 /* Number of handles for AFD to Check */
842 PollInfo
->Exclusive
= FALSE
;
843 PollInfo
->Timeout
= Timeout
;
845 if (readfds
!= NULL
) {
846 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
848 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
849 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
850 AFD_EVENT_DISCONNECT
|
856 if (writefds
!= NULL
)
858 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
860 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
861 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
864 if (exceptfds
!= NULL
)
866 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
868 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
869 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
873 PollInfo
->HandleCount
= j
;
874 PollBufferSize
= ((PCHAR
)&PollInfo
->Handles
[j
+1]) - ((PCHAR
)PollInfo
);
877 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
888 AFD_DbgPrint(MID_TRACE
,("DeviceIoControlFile => %x\n", Status
));
890 /* Wait for Completition */
891 if (Status
== STATUS_PENDING
)
893 WaitForSingleObject(SockEvent
, INFINITE
);
896 /* Clear the Structures */
904 /* Loop through return structure */
905 HandleCount
= PollInfo
->HandleCount
;
907 /* Return in FDSET Format */
908 for (i
= 0; i
< HandleCount
; i
++)
910 HandleCounted
= FALSE
;
913 switch (PollInfo
->Handles
[i
].Events
& x
)
915 case AFD_EVENT_RECEIVE
:
916 case AFD_EVENT_DISCONNECT
:
917 case AFD_EVENT_ABORT
:
918 case AFD_EVENT_ACCEPT
:
919 case AFD_EVENT_CLOSE
:
920 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
921 PollInfo
->Handles
[i
].Events
,
922 PollInfo
->Handles
[i
].Handle
));
926 HandleCounted
= TRUE
;
929 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
932 case AFD_EVENT_CONNECT
:
933 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
934 PollInfo
->Handles
[i
].Events
,
935 PollInfo
->Handles
[i
].Handle
));
939 HandleCounted
= TRUE
;
942 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
944 case AFD_EVENT_OOB_RECEIVE
:
945 case AFD_EVENT_CONNECT_FAIL
:
946 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
947 PollInfo
->Handles
[i
].Events
,
948 PollInfo
->Handles
[i
].Handle
));
952 HandleCounted
= TRUE
;
955 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
961 HeapFree( GlobalHeap
, 0, PollBuffer
);
962 NtClose( SockEvent
);
966 switch( IOSB
.Status
)
973 *lpErrno
= WSAEINVAL
;
976 AFD_DbgPrint(MID_TRACE
,("*lpErrno = %x\n", *lpErrno
));
979 AFD_DbgPrint(MID_TRACE
,("%d events\n", OutCount
));
986 WSPAccept(SOCKET Handle
,
987 struct sockaddr
*SocketAddress
,
988 int *SocketAddressLength
,
989 LPCONDITIONPROC lpfnCondition
,
990 DWORD dwCallbackData
,
993 IO_STATUS_BLOCK IOSB
;
994 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
995 AFD_ACCEPT_DATA AcceptData
;
996 AFD_DEFER_ACCEPT_DATA DeferData
;
997 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
998 PSOCKET_INFORMATION Socket
= NULL
;
1000 struct fd_set ReadSet
;
1001 struct timeval Timeout
;
1002 PVOID PendingData
= NULL
;
1003 ULONG PendingDataLength
= 0;
1004 PVOID CalleeDataBuffer
;
1005 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1006 PSOCKADDR RemoteAddress
= NULL
;
1009 WSAPROTOCOL_INFOW ProtocolInfo
;
1010 SOCKET AcceptSocket
;
1011 UCHAR ReceiveBuffer
[0x1A];
1014 Status
= NtCreateEvent(&SockEvent
,
1015 GENERIC_READ
| GENERIC_WRITE
,
1020 if( !NT_SUCCESS(Status
) )
1022 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1023 return INVALID_SOCKET
;
1026 /* Dynamic Structure...ugh */
1027 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1029 /* Get the Socket Structure associate to this Socket*/
1030 Socket
= GetSocketStructure(Handle
);
1032 /* If this is non-blocking, make sure there's something for us to accept */
1034 FD_SET(Socket
->Handle
, &ReadSet
);
1038 WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, NULL
);
1040 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1047 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1052 IOCTL_AFD_WAIT_FOR_LISTEN
,
1056 0xA + sizeof(*ListenReceiveData
));
1058 /* Wait for return */
1059 if (Status
== STATUS_PENDING
)
1061 WaitForSingleObject(SockEvent
, INFINITE
);
1062 Status
= IOSB
.Status
;
1065 if (!NT_SUCCESS(Status
))
1067 NtClose( SockEvent
);
1068 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1069 return INVALID_SOCKET
;
1072 if (lpfnCondition
!= NULL
)
1074 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1076 /* Find out how much data is pending */
1077 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1078 PendingAcceptData
.ReturnSize
= TRUE
;
1081 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1086 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1088 sizeof(PendingAcceptData
),
1090 sizeof(PendingAcceptData
));
1092 /* Wait for return */
1093 if (Status
== STATUS_PENDING
)
1095 WaitForSingleObject(SockEvent
, INFINITE
);
1096 Status
= IOSB
.Status
;
1099 if (!NT_SUCCESS(Status
))
1101 NtClose( SockEvent
);
1102 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1103 return INVALID_SOCKET
;
1106 /* How much data to allocate */
1107 PendingDataLength
= IOSB
.Information
;
1109 if (PendingDataLength
)
1111 /* Allocate needed space */
1112 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1115 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1116 return INVALID_SOCKET
;
1119 /* We want the data now */
1120 PendingAcceptData
.ReturnSize
= FALSE
;
1123 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1128 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1130 sizeof(PendingAcceptData
),
1134 /* Wait for return */
1135 if (Status
== STATUS_PENDING
)
1137 WaitForSingleObject(SockEvent
, INFINITE
);
1138 Status
= IOSB
.Status
;
1141 if (!NT_SUCCESS(Status
))
1143 NtClose( SockEvent
);
1144 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1145 return INVALID_SOCKET
;
1150 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1152 /* I don't support this yet */
1155 /* Build Callee ID */
1156 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1157 CalleeID
.len
= Socket
->SharedData
.SizeOfLocalAddress
;
1159 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1162 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1163 return INVALID_SOCKET
;
1166 /* Set up Address in SOCKADDR Format */
1167 RtlCopyMemory (RemoteAddress
,
1168 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1169 sizeof(*RemoteAddress
));
1171 /* Build Caller ID */
1172 CallerID
.buf
= (PVOID
)RemoteAddress
;
1173 CallerID
.len
= sizeof(*RemoteAddress
);
1175 /* Build Caller Data */
1176 CallerData
.buf
= PendingData
;
1177 CallerData
.len
= PendingDataLength
;
1179 /* Check if socket supports Conditional Accept */
1180 if (Socket
->SharedData
.UseDelayedAcceptance
!= 0)
1182 /* Allocate Buffer for Callee Data */
1183 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1184 if (!CalleeDataBuffer
) {
1185 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1186 return INVALID_SOCKET
;
1188 CalleeData
.buf
= CalleeDataBuffer
;
1189 CalleeData
.len
= 4096;
1198 /* Call the Condition Function */
1199 CallBack
= (lpfnCondition
)(&CallerID
,
1200 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1204 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1208 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1210 /* TBD: Check for Validity */
1213 if (CallBack
== CF_ACCEPT
)
1215 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1217 /* I don't support this yet */
1221 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1226 /* Callback rejected. Build Defer Structure */
1227 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1228 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1231 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1236 IOCTL_AFD_DEFER_ACCEPT
,
1242 /* Wait for return */
1243 if (Status
== STATUS_PENDING
)
1245 WaitForSingleObject(SockEvent
, INFINITE
);
1246 Status
= IOSB
.Status
;
1249 NtClose( SockEvent
);
1251 if (!NT_SUCCESS(Status
))
1253 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1254 return INVALID_SOCKET
;
1257 if (CallBack
== CF_REJECT
)
1259 *lpErrno
= WSAECONNREFUSED
;
1260 return INVALID_SOCKET
;
1264 *lpErrno
= WSAECONNREFUSED
;
1265 return INVALID_SOCKET
;
1270 /* Create a new Socket */
1271 ProtocolInfo
.dwCatalogEntryId
= Socket
->SharedData
.CatalogEntryId
;
1272 ProtocolInfo
.dwServiceFlags1
= Socket
->SharedData
.ServiceFlags1
;
1273 ProtocolInfo
.dwProviderFlags
= Socket
->SharedData
.ProviderFlags
;
1275 AcceptSocket
= WSPSocket (Socket
->SharedData
.AddressFamily
,
1276 Socket
->SharedData
.SocketType
,
1277 Socket
->SharedData
.Protocol
,
1280 Socket
->SharedData
.CreateFlags
,
1283 /* Set up the Accept Structure */
1284 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1285 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1287 /* Send IOCTL to Accept */
1288 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1299 /* Wait for return */
1300 if (Status
== STATUS_PENDING
)
1302 WaitForSingleObject(SockEvent
, INFINITE
);
1303 Status
= IOSB
.Status
;
1306 if (!NT_SUCCESS(Status
))
1309 WSPCloseSocket( AcceptSocket
, lpErrno
);
1310 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1311 return INVALID_SOCKET
;
1314 /* Return Address in SOCKADDR FORMAT */
1317 RtlCopyMemory (SocketAddress
,
1318 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1319 sizeof(*RemoteAddress
));
1320 if( SocketAddressLength
)
1321 *SocketAddressLength
= ListenReceiveData
->Address
.Address
[0].AddressLength
;
1324 NtClose( SockEvent
);
1326 /* Re-enable Async Event */
1327 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1329 AFD_DbgPrint(MID_TRACE
,("Socket %x\n", AcceptSocket
));
1331 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1333 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1335 Socket
->TdiAddressHandle
,
1336 Socket
->TdiConnectionHandle
,
1341 if (lpErrno
) *lpErrno
= Status
;
1342 return INVALID_SOCKET
;
1349 return AcceptSocket
;
1354 WSPConnect(SOCKET Handle
,
1355 const struct sockaddr
* SocketAddress
,
1356 int SocketAddressLength
,
1357 LPWSABUF lpCallerData
,
1358 LPWSABUF lpCalleeData
,
1363 IO_STATUS_BLOCK IOSB
;
1364 PAFD_CONNECT_INFO ConnectInfo
;
1365 PSOCKET_INFORMATION Socket
= NULL
;
1367 UCHAR ConnectBuffer
[0x22];
1368 ULONG ConnectDataLength
;
1369 ULONG InConnectDataLength
;
1370 INT BindAddressLength
;
1371 PSOCKADDR BindAddress
;
1374 Status
= NtCreateEvent(&SockEvent
,
1375 GENERIC_READ
| GENERIC_WRITE
,
1380 if( !NT_SUCCESS(Status
) )
1383 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1385 /* Get the Socket Structure associate to this Socket*/
1386 Socket
= GetSocketStructure(Handle
);
1389 if (Socket
->SharedData
.State
== SocketOpen
)
1391 /* Get the Wildcard Address */
1392 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1393 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1396 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1397 return INVALID_SOCKET
;
1399 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1401 &BindAddressLength
);
1403 WSPBind(Handle
, BindAddress
, BindAddressLength
, NULL
);
1406 /* Set the Connect Data */
1407 if (lpCallerData
!= NULL
)
1409 ConnectDataLength
= lpCallerData
->len
;
1410 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1415 IOCTL_AFD_SET_CONNECT_DATA
,
1420 /* Wait for return */
1421 if (Status
== STATUS_PENDING
)
1423 WaitForSingleObject(SockEvent
, INFINITE
);
1424 Status
= IOSB
.Status
;
1428 /* Dynamic Structure...ugh */
1429 ConnectInfo
= (PAFD_CONNECT_INFO
)ConnectBuffer
;
1431 /* Set up Address in TDI Format */
1432 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1433 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
1434 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1435 RtlCopyMemory (ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1436 SocketAddress
->sa_data
,
1437 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
1440 * Disable FD_WRITE and FD_CONNECT
1441 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1442 * at the end of this function right after the Async Thread disables it.
1443 * This should only happen at the *next* WSPConnect
1445 if (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
)
1447 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1450 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1451 if (lpCalleeData
!= NULL
)
1453 InConnectDataLength
= lpCalleeData
->len
;
1454 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1459 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1460 &InConnectDataLength
,
1461 sizeof(InConnectDataLength
),
1465 /* Wait for return */
1466 if (Status
== STATUS_PENDING
)
1468 WaitForSingleObject(SockEvent
, INFINITE
);
1469 Status
= IOSB
.Status
;
1473 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1474 ConnectInfo
->Root
= 0;
1475 ConnectInfo
->UseSAN
= FALSE
;
1476 ConnectInfo
->Unknown
= 0;
1478 /* FIXME: Handle Async Connect */
1479 if (Socket
->SharedData
.NonBlocking
)
1481 AFD_DbgPrint(MIN_TRACE
, ("Async Connect UNIMPLEMENTED!\n"));
1485 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1495 /* Wait for return */
1496 if (Status
== STATUS_PENDING
)
1498 WaitForSingleObject(SockEvent
, INFINITE
);
1499 Status
= IOSB
.Status
;
1502 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1504 /* Get any pending connect data */
1505 if (lpCalleeData
!= NULL
)
1507 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1512 IOCTL_AFD_GET_CONNECT_DATA
,
1517 /* Wait for return */
1518 if (Status
== STATUS_PENDING
)
1520 WaitForSingleObject(SockEvent
, INFINITE
);
1521 Status
= IOSB
.Status
;
1525 /* Re-enable Async Event */
1526 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1528 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1529 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1531 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1533 NtClose( SockEvent
);
1535 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1537 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1539 Socket
->TdiAddressHandle
,
1540 Socket
->TdiConnectionHandle
,
1541 WSH_NOTIFY_CONNECT
);
1545 if (lpErrno
) *lpErrno
= Status
;
1546 return SOCKET_ERROR
;
1549 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1551 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1553 Socket
->TdiAddressHandle
,
1554 Socket
->TdiConnectionHandle
,
1555 WSH_NOTIFY_CONNECT_ERROR
);
1559 if (lpErrno
) *lpErrno
= Status
;
1560 return SOCKET_ERROR
;
1564 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1568 WSPShutdown(SOCKET Handle
,
1573 IO_STATUS_BLOCK IOSB
;
1574 AFD_DISCONNECT_INFO DisconnectInfo
;
1575 PSOCKET_INFORMATION Socket
= NULL
;
1579 Status
= NtCreateEvent(&SockEvent
,
1580 GENERIC_READ
| GENERIC_WRITE
,
1585 if( !NT_SUCCESS(Status
) )
1588 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1590 /* Get the Socket Structure associate to this Socket*/
1591 Socket
= GetSocketStructure(Handle
);
1593 /* Set AFD Disconnect Type */
1597 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1598 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1601 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1602 Socket
->SharedData
.SendShutdown
= TRUE
;
1605 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1606 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1607 Socket
->SharedData
.SendShutdown
= TRUE
;
1611 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1);
1614 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1619 IOCTL_AFD_DISCONNECT
,
1621 sizeof(DisconnectInfo
),
1625 /* Wait for return */
1626 if (Status
== STATUS_PENDING
)
1628 WaitForSingleObject(SockEvent
, INFINITE
);
1629 Status
= IOSB
.Status
;
1632 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1634 NtClose( SockEvent
);
1636 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1642 WSPGetSockName(IN SOCKET Handle
,
1643 OUT LPSOCKADDR Name
,
1644 IN OUT LPINT NameLength
,
1647 IO_STATUS_BLOCK IOSB
;
1648 ULONG TdiAddressSize
;
1649 PTDI_ADDRESS_INFO TdiAddress
;
1650 PTRANSPORT_ADDRESS SocketAddress
;
1651 PSOCKET_INFORMATION Socket
= NULL
;
1655 Status
= NtCreateEvent(&SockEvent
,
1656 GENERIC_READ
| GENERIC_WRITE
,
1661 if( !NT_SUCCESS(Status
) )
1662 return SOCKET_ERROR
;
1664 /* Get the Socket Structure associate to this Socket*/
1665 Socket
= GetSocketStructure(Handle
);
1667 /* Allocate a buffer for the address */
1669 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfLocalAddress
;
1670 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1672 if ( TdiAddress
== NULL
)
1674 NtClose( SockEvent
);
1675 *lpErrno
= WSAENOBUFS
;
1676 return SOCKET_ERROR
;
1679 SocketAddress
= &TdiAddress
->Address
;
1682 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1687 IOCTL_AFD_GET_SOCK_NAME
,
1693 /* Wait for return */
1694 if (Status
== STATUS_PENDING
)
1696 WaitForSingleObject(SockEvent
, INFINITE
);
1697 Status
= IOSB
.Status
;
1700 NtClose( SockEvent
);
1702 if (NT_SUCCESS(Status
))
1704 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1706 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1707 RtlCopyMemory (Name
->sa_data
,
1708 SocketAddress
->Address
[0].Address
,
1709 SocketAddress
->Address
[0].AddressLength
);
1710 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1711 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1712 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1713 ((struct sockaddr_in
*)Name
)->sin_port
));
1714 HeapFree(GlobalHeap
, 0, TdiAddress
);
1719 HeapFree(GlobalHeap
, 0, TdiAddress
);
1720 *lpErrno
= WSAEFAULT
;
1721 return SOCKET_ERROR
;
1725 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1731 WSPGetPeerName(IN SOCKET s
,
1732 OUT LPSOCKADDR Name
,
1733 IN OUT LPINT NameLength
,
1736 IO_STATUS_BLOCK IOSB
;
1737 ULONG TdiAddressSize
;
1738 PTRANSPORT_ADDRESS SocketAddress
;
1739 PSOCKET_INFORMATION Socket
= NULL
;
1743 Status
= NtCreateEvent(&SockEvent
,
1744 GENERIC_READ
| GENERIC_WRITE
,
1749 if( !NT_SUCCESS(Status
) )
1750 return SOCKET_ERROR
;
1752 /* Get the Socket Structure associate to this Socket*/
1753 Socket
= GetSocketStructure(s
);
1755 /* Allocate a buffer for the address */
1756 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + *NameLength
;
1757 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1759 if ( SocketAddress
== NULL
)
1761 NtClose( SockEvent
);
1762 *lpErrno
= WSAENOBUFS
;
1763 return SOCKET_ERROR
;
1767 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1772 IOCTL_AFD_GET_PEER_NAME
,
1778 /* Wait for return */
1779 if (Status
== STATUS_PENDING
)
1781 WaitForSingleObject(SockEvent
, INFINITE
);
1782 Status
= IOSB
.Status
;
1785 NtClose( SockEvent
);
1787 if (NT_SUCCESS(Status
))
1789 if (*NameLength
>= SocketAddress
->Address
[0].AddressLength
)
1791 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1792 RtlCopyMemory (Name
->sa_data
,
1793 SocketAddress
->Address
[0].Address
,
1794 SocketAddress
->Address
[0].AddressLength
);
1795 *NameLength
= 2 + SocketAddress
->Address
[0].AddressLength
;
1796 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %s Port %x\n",
1797 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1798 ((struct sockaddr_in
*)Name
)->sin_port
));
1799 HeapFree(GlobalHeap
, 0, SocketAddress
);
1804 HeapFree(GlobalHeap
, 0, SocketAddress
);
1805 *lpErrno
= WSAEFAULT
;
1806 return SOCKET_ERROR
;
1810 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1815 WSPIoctl(IN SOCKET Handle
,
1816 IN DWORD dwIoControlCode
,
1817 IN LPVOID lpvInBuffer
,
1818 IN DWORD cbInBuffer
,
1819 OUT LPVOID lpvOutBuffer
,
1820 IN DWORD cbOutBuffer
,
1821 OUT LPDWORD lpcbBytesReturned
,
1822 IN LPWSAOVERLAPPED lpOverlapped
,
1823 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
1824 IN LPWSATHREADID lpThreadId
,
1827 PSOCKET_INFORMATION Socket
= NULL
;
1829 /* Get the Socket Structure associate to this Socket*/
1830 Socket
= GetSocketStructure(Handle
);
1832 switch( dwIoControlCode
)
1835 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
1837 *lpErrno
= WSAEFAULT
;
1838 return SOCKET_ERROR
;
1840 Socket
->SharedData
.NonBlocking
= *((PULONG
)lpvInBuffer
) ? 1 : 0;
1841 return SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, (PULONG
)lpvInBuffer
, NULL
);
1843 if( cbOutBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvOutBuffer
) )
1845 *lpErrno
= WSAEFAULT
;
1846 return SOCKET_ERROR
;
1848 return GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, (PULONG
)lpvOutBuffer
, NULL
);
1850 *lpErrno
= WSAEINVAL
;
1851 return SOCKET_ERROR
;
1858 WSPGetSockOpt(IN SOCKET Handle
,
1861 OUT CHAR FAR
* OptionValue
,
1862 IN OUT LPINT OptionLength
,
1865 PSOCKET_INFORMATION Socket
= NULL
;
1870 /* Get the Socket Structure associate to this Socket*/
1871 Socket
= GetSocketStructure(Handle
);
1874 *lpErrno
= WSAENOTSOCK
;
1875 return SOCKET_ERROR
;
1878 AFD_DbgPrint(MID_TRACE
, ("Called\n"));
1886 Buffer
= &Socket
->SharedData
.SocketType
;
1887 BufferSize
= sizeof(INT
);
1891 Buffer
= &Socket
->SharedData
.SizeOfRecvBuffer
;
1892 BufferSize
= sizeof(INT
);
1896 Buffer
= &Socket
->SharedData
.SizeOfSendBuffer
;
1897 BufferSize
= sizeof(INT
);
1901 BoolBuffer
= Socket
->SharedData
.Listening
;
1902 Buffer
= &BoolBuffer
;
1903 BufferSize
= sizeof(BOOLEAN
);
1907 BoolBuffer
= Socket
->SharedData
.Broadcast
;
1908 Buffer
= &BoolBuffer
;
1909 BufferSize
= sizeof(BOOLEAN
);
1913 BoolBuffer
= Socket
->SharedData
.Debug
;
1914 Buffer
= &BoolBuffer
;
1915 BufferSize
= sizeof(BOOLEAN
);
1918 /* case SO_CONDITIONAL_ACCEPT: */
1923 case SO_GROUP_PRIORITY
:
1926 case SO_MAX_MSG_SIZE
:
1928 case SO_PROTOCOL_INFO
:
1930 AFD_DbgPrint(MID_TRACE
, ("Unimplemented option (%x)\n",
1934 *lpErrno
= WSAEINVAL
;
1935 return SOCKET_ERROR
;
1938 if (*OptionLength
< BufferSize
)
1940 *lpErrno
= WSAEFAULT
;
1941 *OptionLength
= BufferSize
;
1942 return SOCKET_ERROR
;
1944 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
1948 case IPPROTO_TCP
: /* FIXME */
1950 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
1952 Socket
->TdiAddressHandle
,
1953 Socket
->TdiConnectionHandle
,
1957 (LPINT
)OptionLength
);
1958 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
1968 IN CONST CHAR FAR
* optval
,
1972 PSOCKET_INFORMATION Socket
;
1974 /* Get the Socket Structure associate to this Socket*/
1975 Socket
= GetSocketStructure(s
);
1978 *lpErrno
= WSAENOTSOCK
;
1979 return SOCKET_ERROR
;
1983 /* FIXME: We should handle some cases here */
1986 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
1988 Socket
->TdiAddressHandle
,
1989 Socket
->TdiConnectionHandle
,
1994 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
1998 * FUNCTION: Initialize service provider for a client
2000 * wVersionRequested = Highest WinSock SPI version that the caller can use
2001 * lpWSPData = Address of WSPDATA structure to initialize
2002 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2003 * UpcallTable = Pointer to upcall table of the WinSock DLL
2004 * lpProcTable = Address of procedure table to initialize
2006 * Status of operation
2010 WSPStartup(IN WORD wVersionRequested
,
2011 OUT LPWSPDATA lpWSPData
,
2012 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2013 IN WSPUPCALLTABLE UpcallTable
,
2014 OUT LPWSPPROC_TABLE lpProcTable
)
2019 AFD_DbgPrint(MAX_TRACE
, ("wVersionRequested (0x%X) \n", wVersionRequested
));
2021 Upcalls
= UpcallTable
;
2023 if (Status
== NO_ERROR
)
2025 lpProcTable
->lpWSPAccept
= WSPAccept
;
2026 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2027 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2028 lpProcTable
->lpWSPBind
= WSPBind
;
2029 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2030 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2031 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2032 lpProcTable
->lpWSPConnect
= WSPConnect
;
2033 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2034 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2035 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2036 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2037 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2038 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2039 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2040 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2041 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2042 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2043 lpProcTable
->lpWSPListen
= WSPListen
;
2044 lpProcTable
->lpWSPRecv
= WSPRecv
;
2045 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2046 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2047 lpProcTable
->lpWSPSelect
= WSPSelect
;
2048 lpProcTable
->lpWSPSend
= WSPSend
;
2049 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2050 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2051 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2052 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2053 lpProcTable
->lpWSPSocket
= WSPSocket
;
2054 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2055 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2056 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2059 AFD_DbgPrint(MAX_TRACE
, ("Status (%d).\n", Status
));
2066 * FUNCTION: Cleans up service provider for a client
2068 * lpErrno = Address of buffer for error information
2070 * 0 if successful, or SOCKET_ERROR if not
2074 WSPCleanup(OUT LPINT lpErrno
)
2077 AFD_DbgPrint(MAX_TRACE
, ("\n"));
2078 AFD_DbgPrint(MAX_TRACE
, ("Leaving.\n"));
2079 *lpErrno
= NO_ERROR
;
2087 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2088 ULONG AfdInformationClass
,
2089 PULONG Ulong OPTIONAL
,
2090 PLARGE_INTEGER LargeInteger OPTIONAL
)
2092 IO_STATUS_BLOCK IOSB
;
2097 Status
= NtCreateEvent(&SockEvent
,
2098 GENERIC_READ
| GENERIC_WRITE
,
2103 if( !NT_SUCCESS(Status
) )
2106 /* Set Info Class */
2107 InfoData
.InformationClass
= AfdInformationClass
;
2110 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2121 /* Wait for return */
2122 if (Status
== STATUS_PENDING
)
2124 WaitForSingleObject(SockEvent
, INFINITE
);
2127 /* Return Information */
2130 *Ulong
= InfoData
.Information
.Ulong
;
2132 if (LargeInteger
!= NULL
)
2134 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2137 NtClose( SockEvent
);
2145 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2146 ULONG AfdInformationClass
,
2147 PULONG Ulong OPTIONAL
,
2148 PLARGE_INTEGER LargeInteger OPTIONAL
)
2150 IO_STATUS_BLOCK IOSB
;
2155 Status
= NtCreateEvent(&SockEvent
,
2156 GENERIC_READ
| GENERIC_WRITE
,
2161 if( !NT_SUCCESS(Status
) )
2164 /* Set Info Class */
2165 InfoData
.InformationClass
= AfdInformationClass
;
2167 /* Set Information */
2170 InfoData
.Information
.Ulong
= *Ulong
;
2172 if (LargeInteger
!= NULL
)
2174 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2177 AFD_DbgPrint(MID_TRACE
,("XXX Info %x (Data %x)\n",
2178 AfdInformationClass
, *Ulong
));
2181 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2192 /* Wait for return */
2193 if (Status
== STATUS_PENDING
)
2195 WaitForSingleObject(SockEvent
, INFINITE
);
2198 NtClose( SockEvent
);
2205 GetSocketStructure(SOCKET Handle
)
2209 for (i
=0; i
<SocketCount
; i
++)
2211 if (Sockets
[i
]->Handle
== Handle
)
2219 int CreateContext(PSOCKET_INFORMATION Socket
)
2221 IO_STATUS_BLOCK IOSB
;
2222 SOCKET_CONTEXT ContextData
;
2226 Status
= NtCreateEvent(&SockEvent
,
2227 GENERIC_READ
| GENERIC_WRITE
,
2232 if( !NT_SUCCESS(Status
) )
2235 /* Create Context */
2236 ContextData
.SharedData
= Socket
->SharedData
;
2237 ContextData
.SizeOfHelperData
= 0;
2238 RtlCopyMemory (&ContextData
.LocalAddress
,
2239 Socket
->LocalAddress
,
2240 Socket
->SharedData
.SizeOfLocalAddress
);
2241 RtlCopyMemory (&ContextData
.RemoteAddress
,
2242 Socket
->RemoteAddress
,
2243 Socket
->SharedData
.SizeOfRemoteAddress
);
2246 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2251 IOCTL_AFD_SET_CONTEXT
,
2253 sizeof(ContextData
),
2257 /* Wait for Completition */
2258 if (Status
== STATUS_PENDING
)
2260 WaitForSingleObject(SockEvent
, INFINITE
);
2263 NtClose( SockEvent
);
2268 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
2270 HANDLE hAsyncThread
;
2271 DWORD AsyncThreadId
;
2273 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2276 /* Check if the Thread Already Exists */
2277 if (SockAsyncThreadRefCount
)
2282 /* Create the Completion Port */
2283 if (!SockAsyncCompletionPort
)
2285 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
2286 IO_COMPLETION_ALL_ACCESS
,
2288 2); // Allow 2 threads only
2290 /* Protect Handle */
2291 HandleFlags
.ProtectFromClose
= TRUE
;
2292 HandleFlags
.Inherit
= FALSE
;
2293 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2294 ObjectHandleFlagInformation
,
2296 sizeof(HandleFlags
));
2299 /* Create the Async Event */
2300 Status
= NtCreateEvent(&AsyncEvent
,
2306 /* Create the Async Thread */
2307 hAsyncThread
= CreateThread(NULL
,
2309 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
2314 /* Close the Handle */
2315 NtClose(hAsyncThread
);
2317 /* Increase the Reference Count */
2318 SockAsyncThreadRefCount
++;
2322 int SockAsyncThread(PVOID ThreadParam
)
2325 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
2326 IO_STATUS_BLOCK IOSB
;
2329 /* Make the Thread Higher Priority */
2330 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
2332 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
2335 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
2336 (PVOID
*)&AsyncCompletionRoutine
,
2340 /* Call the Async Function */
2341 if (NT_SUCCESS(Status
))
2343 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
2347 /* It Failed, sleep for a second */
2350 } while ((Status
!= STATUS_TIMEOUT
));
2352 /* The Thread has Ended */
2356 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
2358 UNICODE_STRING AfdHelper
;
2359 OBJECT_ATTRIBUTES ObjectAttributes
;
2360 IO_STATUS_BLOCK IoSb
;
2362 FILE_COMPLETION_INFORMATION CompletionInfo
;
2363 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2365 /* First, make sure we're not already intialized */
2366 if (SockAsyncHelperAfdHandle
)
2371 /* Set up Handle Name and Object */
2372 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
2373 InitializeObjectAttributes(&ObjectAttributes
,
2375 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
2379 /* Open the Handle to AFD */
2380 Status
= NtCreateFile(&SockAsyncHelperAfdHandle
,
2381 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
2386 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2393 * Now Set up the Completion Port Information
2394 * This means that whenever a Poll is finished, the routine will be executed
2396 CompletionInfo
.Port
= SockAsyncCompletionPort
;
2397 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
2398 Status
= NtSetInformationFile(SockAsyncHelperAfdHandle
,
2401 sizeof(CompletionInfo
),
2402 FileCompletionInformation
);
2405 /* Protect the Handle */
2406 HandleFlags
.ProtectFromClose
= TRUE
;
2407 HandleFlags
.Inherit
= FALSE
;
2408 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2409 ObjectHandleFlagInformation
,
2411 sizeof(HandleFlags
));
2414 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
2415 SockAsyncSelectCalled
= TRUE
;
2419 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2422 PASYNC_DATA AsyncData
= Context
;
2423 PSOCKET_INFORMATION Socket
;
2426 /* Get the Socket */
2427 Socket
= AsyncData
->ParentSocket
;
2429 /* Check if the Sequence Number Changed behind our back */
2430 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
.SequenceNumber
)
2435 /* Check we were manually called b/c of a failure */
2436 if (!NT_SUCCESS(IoStatusBlock
->Status
))
2438 /* FIXME: Perform Upcall */
2442 for (x
= 1; x
; x
<<=1)
2444 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
2446 case AFD_EVENT_RECEIVE
:
2447 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_READ
) &&
2448 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_READ
))
2450 /* Make the Notifcation */
2451 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2452 Socket
->SharedData
.wMsg
,
2454 WSAMAKESELECTREPLY(FD_READ
, 0));
2455 /* Disable this event until the next read(); */
2456 Socket
->SharedData
.AsyncDisabledEvents
|= FD_READ
;
2460 case AFD_EVENT_OOB_RECEIVE
:
2461 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_OOB
) &&
2462 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_OOB
))
2464 /* Make the Notifcation */
2465 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2466 Socket
->SharedData
.wMsg
,
2468 WSAMAKESELECTREPLY(FD_OOB
, 0));
2469 /* Disable this event until the next read(); */
2470 Socket
->SharedData
.AsyncDisabledEvents
|= FD_OOB
;
2474 case AFD_EVENT_SEND
:
2475 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_WRITE
) &&
2476 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_WRITE
))
2478 /* Make the Notifcation */
2479 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2480 Socket
->SharedData
.wMsg
,
2482 WSAMAKESELECTREPLY(FD_WRITE
, 0));
2483 /* Disable this event until the next write(); */
2484 Socket
->SharedData
.AsyncDisabledEvents
|= FD_WRITE
;
2488 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2489 case AFD_EVENT_CONNECT
:
2490 case AFD_EVENT_CONNECT_FAIL
:
2491 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
) &&
2492 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CONNECT
))
2494 /* Make the Notifcation */
2495 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2496 Socket
->SharedData
.wMsg
,
2498 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
2499 /* Disable this event forever; */
2500 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
;
2504 case AFD_EVENT_ACCEPT
:
2505 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_ACCEPT
) &&
2506 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_ACCEPT
))
2508 /* Make the Notifcation */
2509 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2510 Socket
->SharedData
.wMsg
,
2512 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
2513 /* Disable this event until the next accept(); */
2514 Socket
->SharedData
.AsyncDisabledEvents
|= FD_ACCEPT
;
2518 case AFD_EVENT_DISCONNECT
:
2519 case AFD_EVENT_ABORT
:
2520 case AFD_EVENT_CLOSE
:
2521 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CLOSE
) &&
2522 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CLOSE
))
2524 /* Make the Notifcation */
2525 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2526 Socket
->SharedData
.wMsg
,
2528 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
2529 /* Disable this event forever; */
2530 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CLOSE
;
2533 /* FIXME: Support QOS */
2537 /* Check if there are any events left for us to check */
2538 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2544 SockProcessAsyncSelect(Socket
, AsyncData
);
2548 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
2551 ULONG lNetworkEvents
;
2554 /* Set up the Async Data Event Info */
2555 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
2556 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
2557 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
2558 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
2559 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
2560 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
2562 /* Remove unwanted events */
2563 lNetworkEvents
= Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
);
2565 /* Set Events to wait for */
2566 if (lNetworkEvents
& FD_READ
)
2568 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
2571 if (lNetworkEvents
& FD_WRITE
)
2573 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
2576 if (lNetworkEvents
& FD_OOB
)
2578 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
2581 if (lNetworkEvents
& FD_ACCEPT
)
2583 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
2586 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2587 if (lNetworkEvents
& FD_CONNECT
)
2589 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
2592 if (lNetworkEvents
& FD_CLOSE
)
2594 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
2597 if (lNetworkEvents
& FD_QOS
)
2599 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
2602 if (lNetworkEvents
& FD_GROUP_QOS
)
2604 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
2608 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
2612 &AsyncData
->IoStatusBlock
,
2614 &AsyncData
->AsyncSelectInfo
,
2615 sizeof(AsyncData
->AsyncSelectInfo
),
2616 &AsyncData
->AsyncSelectInfo
,
2617 sizeof(AsyncData
->AsyncSelectInfo
));
2619 /* I/O Manager Won't call the completion routine, let's do it manually */
2620 if (NT_SUCCESS(Status
))
2626 AsyncData
->IoStatusBlock
.Status
= Status
;
2627 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
2631 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2633 PASYNC_DATA AsyncData
= Context
;
2634 BOOL FreeContext
= TRUE
;
2635 PSOCKET_INFORMATION Socket
;
2637 /* Get the Socket */
2638 Socket
= AsyncData
->ParentSocket
;
2640 /* If someone closed it, stop the function */
2641 if (Socket
->SharedData
.State
!= SocketClosed
)
2643 /* Check if the Sequence Number changed by now, in which case quit */
2644 if (AsyncData
->SequenceNumber
== Socket
->SharedData
.SequenceNumber
)
2646 /* Do the actuall select, if needed */
2647 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)))
2649 SockProcessAsyncSelect(Socket
, AsyncData
);
2650 FreeContext
= FALSE
;
2655 /* Free the Context */
2658 HeapFree(GetProcessHeap(), 0, AsyncData
);
2665 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
2668 PASYNC_DATA AsyncData
;
2670 /* Make sure the event is actually disabled */
2671 if (!(Socket
->SharedData
.AsyncDisabledEvents
& Event
))
2677 Socket
->SharedData
.AsyncDisabledEvents
&= ~Event
;
2679 /* Return if no more events are being polled */
2680 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2685 /* Wait on new events */
2686 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
2687 if (!AsyncData
) return;
2689 /* Create the Asynch Thread if Needed */
2690 SockCreateOrReferenceAsyncThread();
2692 /* Increase the sequence number to stop anything else */
2693 Socket
->SharedData
.SequenceNumber
++;
2695 /* Set up the Async Data */
2696 AsyncData
->ParentSocket
= Socket
;
2697 AsyncData
->SequenceNumber
= Socket
->SharedData
.SequenceNumber
;
2699 /* Begin Async Select by using I/O Completion */
2700 NtSetIoCompletion(SockAsyncCompletionPort
,
2701 (PVOID
)&SockProcessQueuedAsyncSelect
,
2712 DllMain(HANDLE hInstDll
,
2719 case DLL_PROCESS_ATTACH
:
2721 AFD_DbgPrint(MAX_TRACE
, ("Loading MSAFD.DLL \n"));
2723 /* Don't need thread attach notifications
2724 so disable them to improve performance */
2725 DisableThreadLibraryCalls(hInstDll
);
2727 /* List of DLL Helpers */
2728 InitializeListHead(&SockHelpersListHead
);
2730 /* Heap to use when allocating */
2731 GlobalHeap
= GetProcessHeap();
2733 /* Allocate Heap for 1024 Sockets, can be expanded later */
2734 Sockets
= HeapAlloc(GetProcessHeap(), 0, sizeof(PSOCKET_INFORMATION
) * 1024);
2735 if (!Sockets
) return FALSE
;
2737 AFD_DbgPrint(MAX_TRACE
, ("MSAFD.DLL has been loaded\n"));
2741 case DLL_THREAD_ATTACH
:
2744 case DLL_THREAD_DETACH
:
2747 case DLL_PROCESS_DETACH
:
2751 AFD_DbgPrint(MAX_TRACE
, ("DllMain of msafd.dll (leaving)\n"));