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
16 //DWORD DebugTraceLevel = DEBUG_ULTRA;
17 DWORD DebugTraceLevel
= 0;
21 WSPUPCALLTABLE Upcalls
;
22 LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
;
23 PSOCKET_INFORMATION SocketListHead
= NULL
;
24 CRITICAL_SECTION SocketListLock
;
25 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
26 ULONG SockAsyncThreadRefCount
;
27 HANDLE SockAsyncHelperAfdHandle
;
28 HANDLE SockAsyncCompletionPort
= NULL
;
29 BOOLEAN SockAsyncSelectCalled
;
34 * FUNCTION: Creates a new socket
38 * protocol = Protocol type
39 * lpProtocolInfo = Pointer to protocol information
41 * dwFlags = Socket flags
42 * lpErrno = Address of buffer for error information
44 * Created socket, or INVALID_SOCKET if it could not be created
48 WSPSocket(int AddressFamily
,
51 LPWSAPROTOCOL_INFOW lpProtocolInfo
,
56 OBJECT_ATTRIBUTES Object
;
60 PAFD_CREATE_PACKET AfdPacket
;
62 PSOCKET_INFORMATION Socket
= NULL
;
63 PFILE_FULL_EA_INFORMATION EABuffer
= NULL
;
64 PHELPER_DATA HelperData
;
65 PVOID HelperDLLContext
;
67 UNICODE_STRING TransportName
;
68 UNICODE_STRING DevName
;
69 LARGE_INTEGER GroupData
;
72 AFD_DbgPrint(MAX_TRACE
, ("Creating Socket, getting TDI Name\n"));
73 AFD_DbgPrint(MAX_TRACE
, ("AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
74 AddressFamily
, SocketType
, Protocol
));
76 /* Get Helper Data and Transport */
77 Status
= SockGetTdiName (&AddressFamily
,
88 if (Status
!= NO_ERROR
)
90 AFD_DbgPrint(MID_TRACE
,("SockGetTdiName: Status %x\n", Status
));
95 RtlInitUnicodeString(&DevName
, L
"\\Device\\Afd\\Endpoint");
98 Socket
= HeapAlloc(GlobalHeap
, 0, sizeof(*Socket
));
100 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
102 RtlZeroMemory(Socket
, sizeof(*Socket
));
103 Socket
->RefCount
= 2;
105 Socket
->SharedData
.Listening
= FALSE
;
106 Socket
->SharedData
.State
= SocketOpen
;
107 Socket
->SharedData
.AddressFamily
= AddressFamily
;
108 Socket
->SharedData
.SocketType
= SocketType
;
109 Socket
->SharedData
.Protocol
= Protocol
;
110 Socket
->HelperContext
= HelperDLLContext
;
111 Socket
->HelperData
= HelperData
;
112 Socket
->HelperEvents
= HelperEvents
;
113 Socket
->LocalAddress
= &Socket
->WSLocalAddress
;
114 Socket
->SharedData
.SizeOfLocalAddress
= HelperData
->MaxWSAddressLength
;
115 Socket
->RemoteAddress
= &Socket
->WSRemoteAddress
;
116 Socket
->SharedData
.SizeOfRemoteAddress
= HelperData
->MaxWSAddressLength
;
117 Socket
->SharedData
.UseDelayedAcceptance
= HelperData
->UseDelayedAcceptance
;
118 Socket
->SharedData
.CreateFlags
= dwFlags
;
119 Socket
->SharedData
.CatalogEntryId
= lpProtocolInfo
->dwCatalogEntryId
;
120 Socket
->SharedData
.ServiceFlags1
= lpProtocolInfo
->dwServiceFlags1
;
121 Socket
->SharedData
.ProviderFlags
= lpProtocolInfo
->dwProviderFlags
;
122 Socket
->SharedData
.GroupID
= g
;
123 Socket
->SharedData
.GroupType
= 0;
124 Socket
->SharedData
.UseSAN
= FALSE
;
125 Socket
->SharedData
.NonBlocking
= FALSE
; /* Sockets start blocking */
126 Socket
->SanData
= NULL
;
128 /* Ask alex about this */
129 if( Socket
->SharedData
.SocketType
== SOCK_DGRAM
||
130 Socket
->SharedData
.SocketType
== SOCK_RAW
)
132 AFD_DbgPrint(MID_TRACE
,("Connectionless socket\n"));
133 Socket
->SharedData
.ServiceFlags1
|= XP1_CONNECTIONLESS
;
137 SizeOfPacket
= TransportName
.Length
+ sizeof(AFD_CREATE_PACKET
) + sizeof(WCHAR
);
140 SizeOfEA
= SizeOfPacket
+ sizeof(FILE_FULL_EA_INFORMATION
) + AFD_PACKET_COMMAND_LENGTH
;
142 /* Set up EA Buffer */
143 EABuffer
= HeapAlloc(GlobalHeap
, 0, SizeOfEA
);
145 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
147 RtlZeroMemory(EABuffer
, SizeOfEA
);
148 EABuffer
->NextEntryOffset
= 0;
150 EABuffer
->EaNameLength
= AFD_PACKET_COMMAND_LENGTH
;
151 RtlCopyMemory (EABuffer
->EaName
,
153 AFD_PACKET_COMMAND_LENGTH
+ 1);
154 EABuffer
->EaValueLength
= SizeOfPacket
;
156 /* Set up AFD Packet */
157 AfdPacket
= (PAFD_CREATE_PACKET
)(EABuffer
->EaName
+ EABuffer
->EaNameLength
+ 1);
158 AfdPacket
->SizeOfTransportName
= TransportName
.Length
;
159 RtlCopyMemory (AfdPacket
->TransportName
,
160 TransportName
.Buffer
,
161 TransportName
.Length
+ sizeof(WCHAR
));
162 AfdPacket
->GroupID
= g
;
164 /* Set up Endpoint Flags */
165 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECTIONLESS
) != 0)
167 if ((SocketType
!= SOCK_DGRAM
) && (SocketType
!= SOCK_RAW
))
169 /* Only RAW or UDP can be Connectionless */
172 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_CONNECTIONLESS
;
175 if ((Socket
->SharedData
.ServiceFlags1
& XP1_MESSAGE_ORIENTED
) != 0)
177 if (SocketType
== SOCK_STREAM
)
179 if ((Socket
->SharedData
.ServiceFlags1
& XP1_PSEUDO_STREAM
) == 0)
181 /* The Provider doesn't actually support Message Oriented Streams */
185 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MESSAGE_ORIENTED
;
188 if (SocketType
== SOCK_RAW
) AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_RAW
;
190 if (dwFlags
& (WSA_FLAG_MULTIPOINT_C_ROOT
|
191 WSA_FLAG_MULTIPOINT_C_LEAF
|
192 WSA_FLAG_MULTIPOINT_D_ROOT
|
193 WSA_FLAG_MULTIPOINT_D_LEAF
))
195 if ((Socket
->SharedData
.ServiceFlags1
& XP1_SUPPORT_MULTIPOINT
) == 0)
197 /* The Provider doesn't actually support Multipoint */
200 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_MULTIPOINT
;
202 if (dwFlags
& WSA_FLAG_MULTIPOINT_C_ROOT
)
204 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_CONTROL_PLANE
) == 0)
205 || ((dwFlags
& WSA_FLAG_MULTIPOINT_C_LEAF
) != 0))
207 /* The Provider doesn't support Control Planes, or you already gave a leaf */
210 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_C_ROOT
;
213 if (dwFlags
& WSA_FLAG_MULTIPOINT_D_ROOT
)
215 if (((Socket
->SharedData
.ServiceFlags1
& XP1_MULTIPOINT_DATA_PLANE
) == 0)
216 || ((dwFlags
& WSA_FLAG_MULTIPOINT_D_LEAF
) != 0))
218 /* The Provider doesn't support Data Planes, or you already gave a leaf */
221 AfdPacket
->EndpointFlags
|= AFD_ENDPOINT_D_ROOT
;
225 /* Set up Object Attributes */
226 InitializeObjectAttributes (&Object
,
228 OBJ_CASE_INSENSITIVE
| OBJ_INHERIT
,
232 /* Create the Socket as asynchronous. That means we have to block
233 ourselves after every call to NtDeviceIoControlFile. This is
234 because the kernel doesn't support overlapping synchronous I/O
235 requests (made from multiple threads) at this time (Sep 2005) */
236 Status
= NtCreateFile(&Sock
,
237 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
242 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
248 HeapFree(GlobalHeap
, 0, EABuffer
);
250 if (Status
!= STATUS_SUCCESS
)
252 AFD_DbgPrint(MIN_TRACE
, ("Failed to open socket\n"));
254 HeapFree(GlobalHeap
, 0, Socket
);
256 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
260 Socket
->Handle
= (SOCKET
)Sock
;
262 /* Save Group Info */
265 GetSocketInformation(Socket
, AFD_INFO_GROUP_ID_TYPE
, NULL
, NULL
, &GroupData
);
266 Socket
->SharedData
.GroupID
= GroupData
.u
.LowPart
;
267 Socket
->SharedData
.GroupType
= GroupData
.u
.HighPart
;
270 /* Get Window Sizes and Save them */
271 GetSocketInformation (Socket
,
272 AFD_INFO_SEND_WINDOW_SIZE
,
274 &Socket
->SharedData
.SizeOfSendBuffer
,
277 GetSocketInformation (Socket
,
278 AFD_INFO_RECEIVE_WINDOW_SIZE
,
280 &Socket
->SharedData
.SizeOfRecvBuffer
,
283 /* Save in Process Sockets List */
284 EnterCriticalSection(&SocketListLock
);
285 Socket
->NextSocket
= SocketListHead
;
286 SocketListHead
= Socket
;
287 LeaveCriticalSection(&SocketListLock
);
289 /* Create the Socket Context */
290 CreateContext(Socket
);
293 Upcalls
.lpWPUModifyIFSHandle(1, (SOCKET
)Sock
, lpErrno
);
295 /* Return Socket Handle */
296 AFD_DbgPrint(MID_TRACE
,("Success %x\n", Sock
));
301 AFD_DbgPrint(MID_TRACE
,("Ending %x\n", Status
));
304 HeapFree(GlobalHeap
, 0, Socket
);
309 return INVALID_SOCKET
;
313 TranslateNtStatusError(NTSTATUS Status
)
317 case STATUS_CANT_WAIT
:
318 return WSAEWOULDBLOCK
;
326 case STATUS_FILE_CLOSED
:
327 case STATUS_END_OF_FILE
:
331 return WSA_IO_PENDING
;
333 case STATUS_BUFFER_TOO_SMALL
:
334 case STATUS_BUFFER_OVERFLOW
:
335 DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
338 case STATUS_NO_MEMORY
:
339 case STATUS_INSUFFICIENT_RESOURCES
:
340 DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
343 case STATUS_INVALID_CONNECTION
:
344 DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
345 return WSAEAFNOSUPPORT
;
347 case STATUS_INVALID_ADDRESS
:
348 DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
349 return WSAEADDRNOTAVAIL
;
351 case STATUS_REMOTE_NOT_LISTENING
:
352 DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
353 return WSAECONNREFUSED
;
355 case STATUS_NETWORK_UNREACHABLE
:
356 DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
357 return WSAENETUNREACH
;
359 case STATUS_INVALID_PARAMETER
:
360 DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
363 case STATUS_CANCELLED
:
364 DbgPrint("MSAFD: STATUS_CANCELLED\n");
365 return WSA_OPERATION_ABORTED
;
367 case STATUS_ADDRESS_ALREADY_EXISTS
:
368 DbgPrint("MSAFD: STATUS_ADDRESS_ALREADY_EXISTS\n");
369 return WSAEADDRINUSE
;
371 case STATUS_LOCAL_DISCONNECT
:
372 DbgPrint("MSAFD: STATUS_LOCAL_DISCONNECT\n");
373 return WSAECONNABORTED
;
375 case STATUS_REMOTE_DISCONNECT
:
376 DbgPrint("MSAFD: STATUS_REMOTE_DISCONNECT\n");
377 return WSAECONNRESET
;
379 case STATUS_ACCESS_VIOLATION
:
380 DbgPrint("MSAFD: STATUS_ACCESS_VIOLATION\n");
384 DbgPrint("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
390 * FUNCTION: Closes an open socket
392 * s = Socket descriptor
393 * lpErrno = Address of buffer for error information
395 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
399 WSPCloseSocket(IN SOCKET Handle
,
402 IO_STATUS_BLOCK IoStatusBlock
;
403 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
406 AFD_DISCONNECT_INFO DisconnectInfo
;
407 SOCKET_STATE OldState
;
408 LONG LingerWait
= -1;
410 /* Create the Wait Event */
411 Status
= NtCreateEvent(&SockEvent
,
417 if(!NT_SUCCESS(Status
))
420 /* Get the Socket Structure associate to this Socket*/
421 Socket
= GetSocketStructure(Handle
);
425 *lpErrno
= WSAENOTSOCK
;
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
))
461 ULONG SendsInProgress
;
464 /* We need to respect the timeout */
466 LingerWait
= Socket
->SharedData
.LingerData
.l_linger
* 1000;
468 /* Loop until no more sends are pending, within the timeout */
471 /* Find out how many Sends are in Progress */
472 if (GetSocketInformation(Socket
,
473 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
)
491 * We have to execute a sleep, so it's kind of like
492 * a block. If the socket is Nonblock, we cannot
493 * go on since asyncronous operation is expected
494 * and we cannot offer it
496 if (Socket
->SharedData
.NonBlocking
)
499 Socket
->SharedData
.State
= OldState
;
500 *lpErrno
= WSAEWOULDBLOCK
;
504 /* Now we can sleep, and decrement the linger wait */
506 * FIXME: It seems Windows does some funky acceleration
507 * since the waiting seems to be longer and longer. I
508 * don't think this improves performance so much, so we
509 * wait a fixed time instead.
512 LingerWait
-= SleepWait
;
516 if (OldState
== SocketConnected
)
520 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
521 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
523 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
.SendShutdown
)) ||
524 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
.ReceiveShutdown
)))
527 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
532 IOCTL_AFD_DISCONNECT
,
534 sizeof(DisconnectInfo
),
538 /* Wait for return */
539 if (Status
== STATUS_PENDING
)
541 WaitForSingleObject(SockEvent
, INFINITE
);
542 Status
= IoStatusBlock
.Status
;
549 Socket
->HelperContext
= NULL
;
550 Socket
->SharedData
.AsyncDisabledEvents
= -1;
551 NtClose(Socket
->TdiAddressHandle
);
552 Socket
->TdiAddressHandle
= NULL
;
553 NtClose(Socket
->TdiConnectionHandle
);
554 Socket
->TdiConnectionHandle
= NULL
;
556 EnterCriticalSection(&SocketListLock
);
557 if (SocketListHead
== Socket
)
559 SocketListHead
= SocketListHead
->NextSocket
;
563 CurrentSocket
= SocketListHead
;
564 while (CurrentSocket
->NextSocket
)
566 if (CurrentSocket
->NextSocket
== Socket
)
568 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
572 CurrentSocket
= CurrentSocket
->NextSocket
;
575 LeaveCriticalSection(&SocketListLock
);
577 /* Close the handle */
578 NtClose((HANDLE
)Handle
);
581 HeapFree(GlobalHeap
, 0, Socket
);
582 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
587 * FUNCTION: Associates a local address with a socket
589 * s = Socket descriptor
590 * name = Pointer to local address
591 * namelen = Length of name
592 * lpErrno = Address of buffer for error information
594 * 0, or SOCKET_ERROR if the socket could not be bound
598 WSPBind(SOCKET Handle
,
599 const struct sockaddr
*SocketAddress
,
600 int SocketAddressLength
,
603 IO_STATUS_BLOCK IOSB
;
604 PAFD_BIND_DATA BindData
;
605 PSOCKET_INFORMATION Socket
= NULL
;
607 SOCKADDR_INFO SocketInfo
;
611 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
614 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
617 Status
= NtCreateEvent(&SockEvent
,
623 if (!NT_SUCCESS(Status
))
625 HeapFree(GlobalHeap
, 0, BindData
);
629 /* Get the Socket Structure associate to this Socket*/
630 Socket
= GetSocketStructure(Handle
);
633 HeapFree(GlobalHeap
, 0, BindData
);
634 *lpErrno
= WSAENOTSOCK
;
638 /* Set up Address in TDI Format */
639 BindData
->Address
.TAAddressCount
= 1;
640 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
641 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
642 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
643 SocketAddress
->sa_data
,
644 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
646 /* Get Address Information */
647 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
651 /* Set the Share Type */
652 if (Socket
->SharedData
.ExclusiveAddressUse
)
654 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
656 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
658 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
660 else if (Socket
->SharedData
.ReuseAddresses
)
662 BindData
->ShareType
= AFD_SHARE_REUSE
;
666 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
670 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
677 0xA + Socket
->SharedData
.SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
679 0xA + Socket
->SharedData
.SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
681 /* Wait for return */
682 if (Status
== STATUS_PENDING
)
684 WaitForSingleObject(SockEvent
, INFINITE
);
685 Status
= IOSB
.Status
;
688 NtClose( SockEvent
);
689 HeapFree(GlobalHeap
, 0, BindData
);
691 if (Status
!= STATUS_SUCCESS
)
692 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
694 /* Set up Socket Data */
695 Socket
->SharedData
.State
= SocketBound
;
696 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
698 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
700 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
702 Socket
->TdiAddressHandle
,
703 Socket
->TdiConnectionHandle
,
708 if (lpErrno
) *lpErrno
= Status
;
713 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
718 WSPListen(SOCKET Handle
,
722 IO_STATUS_BLOCK IOSB
;
723 AFD_LISTEN_DATA ListenData
;
724 PSOCKET_INFORMATION Socket
= NULL
;
728 /* Get the Socket Structure associate to this Socket*/
729 Socket
= GetSocketStructure(Handle
);
732 *lpErrno
= WSAENOTSOCK
;
736 if (Socket
->SharedData
.Listening
)
739 Status
= NtCreateEvent(&SockEvent
,
745 if( !NT_SUCCESS(Status
) )
748 /* Set Up Listen Structure */
749 ListenData
.UseSAN
= FALSE
;
750 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
.UseDelayedAcceptance
;
751 ListenData
.Backlog
= Backlog
;
754 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
759 IOCTL_AFD_START_LISTEN
,
765 /* Wait for return */
766 if (Status
== STATUS_PENDING
)
768 WaitForSingleObject(SockEvent
, INFINITE
);
769 Status
= IOSB
.Status
;
772 NtClose( SockEvent
);
774 if (Status
!= STATUS_SUCCESS
)
775 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
777 /* Set to Listening */
778 Socket
->SharedData
.Listening
= TRUE
;
780 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
782 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
784 Socket
->TdiAddressHandle
,
785 Socket
->TdiConnectionHandle
,
790 if (lpErrno
) *lpErrno
= Status
;
795 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
801 WSPSelect(IN
int nfds
,
802 IN OUT fd_set
*readfds OPTIONAL
,
803 IN OUT fd_set
*writefds OPTIONAL
,
804 IN OUT fd_set
*exceptfds OPTIONAL
,
805 IN
const struct timeval
*timeout OPTIONAL
,
808 IO_STATUS_BLOCK IOSB
;
809 PAFD_POLL_INFO PollInfo
;
813 ULONG PollBufferSize
;
818 LARGE_INTEGER Timeout
;
820 /* Find out how many sockets we have, and how large the buffer needs
823 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
824 ( writefds
? writefds
->fd_count
: 0 ) +
825 ( exceptfds
? exceptfds
->fd_count
: 0 );
827 if ( HandleCount
== 0 )
829 AFD_DbgPrint(MAX_TRACE
,("HandleCount: %u. Return SOCKET_ERROR\n",
831 if (lpErrno
) *lpErrno
= WSAEINVAL
;
835 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
837 AFD_DbgPrint(MID_TRACE
,("HandleCount: %u BufferSize: %u\n",
838 HandleCount
, PollBufferSize
));
840 /* Convert Timeout to NT Format */
843 Timeout
.u
.LowPart
= -1;
844 Timeout
.u
.HighPart
= 0x7FFFFFFF;
845 AFD_DbgPrint(MAX_TRACE
,("Infinite timeout\n"));
849 Timeout
= RtlEnlargedIntegerMultiply
850 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
851 /* Negative timeouts are illegal. Since the kernel represents an
852 * incremental timeout as a negative number, we check for a positive
855 if (Timeout
.QuadPart
> 0)
857 if (lpErrno
) *lpErrno
= WSAEINVAL
;
860 AFD_DbgPrint(MAX_TRACE
,("Timeout: Orig %d.%06d kernel %d\n",
861 timeout
->tv_sec
, timeout
->tv_usec
,
865 Status
= NtCreateEvent(&SockEvent
,
871 if( !NT_SUCCESS(Status
) )
875 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
880 *lpErrno
= WSAEFAULT
;
885 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
887 RtlZeroMemory( PollInfo
, PollBufferSize
);
889 /* Number of handles for AFD to Check */
890 PollInfo
->Exclusive
= FALSE
;
891 PollInfo
->Timeout
= Timeout
;
893 if (readfds
!= NULL
) {
894 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
896 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
897 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
898 AFD_EVENT_DISCONNECT
|
904 if (writefds
!= NULL
)
906 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
908 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
909 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
912 if (exceptfds
!= NULL
)
914 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
916 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
917 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
921 PollInfo
->HandleCount
= j
;
922 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
925 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
936 AFD_DbgPrint(MID_TRACE
,("DeviceIoControlFile => %x\n", Status
));
938 /* Wait for Completition */
939 if (Status
== STATUS_PENDING
)
941 WaitForSingleObject(SockEvent
, INFINITE
);
942 Status
= IOSB
.Status
;
945 /* Clear the Structures */
953 /* Loop through return structure */
954 HandleCount
= PollInfo
->HandleCount
;
956 /* Return in FDSET Format */
957 for (i
= 0; i
< HandleCount
; i
++)
959 HandleCounted
= FALSE
;
962 switch (PollInfo
->Handles
[i
].Events
& x
)
964 case AFD_EVENT_RECEIVE
:
965 case AFD_EVENT_DISCONNECT
:
966 case AFD_EVENT_ABORT
:
967 case AFD_EVENT_ACCEPT
:
968 case AFD_EVENT_CLOSE
:
969 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
970 PollInfo
->Handles
[i
].Events
,
971 PollInfo
->Handles
[i
].Handle
));
975 HandleCounted
= TRUE
;
978 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
981 case AFD_EVENT_CONNECT
:
982 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
983 PollInfo
->Handles
[i
].Events
,
984 PollInfo
->Handles
[i
].Handle
));
988 HandleCounted
= TRUE
;
991 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
993 case AFD_EVENT_OOB_RECEIVE
:
994 case AFD_EVENT_CONNECT_FAIL
:
995 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
996 PollInfo
->Handles
[i
].Events
,
997 PollInfo
->Handles
[i
].Handle
));
1001 HandleCounted
= TRUE
;
1004 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1010 HeapFree( GlobalHeap
, 0, PollBuffer
);
1011 NtClose( SockEvent
);
1015 switch( IOSB
.Status
)
1017 case STATUS_SUCCESS
:
1018 case STATUS_TIMEOUT
:
1022 *lpErrno
= WSAEINVAL
;
1025 AFD_DbgPrint(MID_TRACE
,("*lpErrno = %x\n", *lpErrno
));
1028 AFD_DbgPrint(MID_TRACE
,("%d events\n", OutCount
));
1035 WSPAccept(SOCKET Handle
,
1036 struct sockaddr
*SocketAddress
,
1037 int *SocketAddressLength
,
1038 LPCONDITIONPROC lpfnCondition
,
1039 DWORD dwCallbackData
,
1042 IO_STATUS_BLOCK IOSB
;
1043 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1044 AFD_ACCEPT_DATA AcceptData
;
1045 AFD_DEFER_ACCEPT_DATA DeferData
;
1046 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1047 PSOCKET_INFORMATION Socket
= NULL
;
1049 struct fd_set ReadSet
;
1050 struct timeval Timeout
;
1051 PVOID PendingData
= NULL
;
1052 ULONG PendingDataLength
= 0;
1053 PVOID CalleeDataBuffer
;
1054 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1055 PSOCKADDR RemoteAddress
= NULL
;
1058 WSAPROTOCOL_INFOW ProtocolInfo
;
1059 SOCKET AcceptSocket
;
1060 PSOCKET_INFORMATION AcceptSocketInfo
;
1061 UCHAR ReceiveBuffer
[0x1A];
1064 Status
= NtCreateEvent(&SockEvent
,
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 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1378 if (!AcceptSocketInfo
)
1381 WSPCloseSocket( AcceptSocket
, lpErrno
);
1382 MsafdReturnWithErrno( STATUS_INVALID_CONNECTION
, lpErrno
, 0, NULL
);
1383 return INVALID_SOCKET
;
1386 AcceptSocketInfo
->SharedData
.State
= SocketConnected
;
1388 /* Return Address in SOCKADDR FORMAT */
1391 RtlCopyMemory (SocketAddress
,
1392 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1393 sizeof(*RemoteAddress
));
1394 if( SocketAddressLength
)
1395 *SocketAddressLength
= ListenReceiveData
->Address
.Address
[0].AddressLength
;
1398 NtClose( SockEvent
);
1400 /* Re-enable Async Event */
1401 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1403 AFD_DbgPrint(MID_TRACE
,("Socket %x\n", AcceptSocket
));
1405 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1407 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1409 Socket
->TdiAddressHandle
,
1410 Socket
->TdiConnectionHandle
,
1415 if (lpErrno
) *lpErrno
= Status
;
1416 return INVALID_SOCKET
;
1423 return AcceptSocket
;
1428 WSPConnect(SOCKET Handle
,
1429 const struct sockaddr
* SocketAddress
,
1430 int SocketAddressLength
,
1431 LPWSABUF lpCallerData
,
1432 LPWSABUF lpCalleeData
,
1437 IO_STATUS_BLOCK IOSB
;
1438 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1439 PSOCKET_INFORMATION Socket
;
1442 ULONG ConnectDataLength
;
1443 ULONG InConnectDataLength
;
1444 INT BindAddressLength
;
1445 PSOCKADDR BindAddress
;
1447 int SocketDataLength
;
1449 Status
= NtCreateEvent(&SockEvent
,
1455 if (!NT_SUCCESS(Status
))
1456 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1458 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1460 /* Get the Socket Structure associate to this Socket*/
1461 Socket
= GetSocketStructure(Handle
);
1465 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1466 return SOCKET_ERROR
;
1470 if (Socket
->SharedData
.State
== SocketOpen
)
1472 /* Get the Wildcard Address */
1473 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1474 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1478 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1480 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1482 &BindAddressLength
);
1484 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1485 return SOCKET_ERROR
;
1488 /* Set the Connect Data */
1489 if (lpCallerData
!= NULL
)
1491 ConnectDataLength
= lpCallerData
->len
;
1492 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1497 IOCTL_AFD_SET_CONNECT_DATA
,
1502 /* Wait for return */
1503 if (Status
== STATUS_PENDING
)
1505 WaitForSingleObject(SockEvent
, INFINITE
);
1506 Status
= IOSB
.Status
;
1509 if (Status
!= STATUS_SUCCESS
)
1513 /* Calculate the size of SocketAddress->sa_data */
1514 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1516 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1517 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1518 FIELD_OFFSET(AFD_CONNECT_INFO
,
1519 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1522 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1526 /* Set up Address in TDI Format */
1527 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1528 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1529 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1530 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1531 SocketAddress
->sa_data
,
1535 * Disable FD_WRITE and FD_CONNECT
1536 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1537 * at the end of this function right after the Async Thread disables it.
1538 * This should only happen at the *next* WSPConnect
1540 if (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
)
1542 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1545 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1546 if (lpCalleeData
!= NULL
)
1548 InConnectDataLength
= lpCalleeData
->len
;
1549 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1554 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1555 &InConnectDataLength
,
1556 sizeof(InConnectDataLength
),
1560 /* Wait for return */
1561 if (Status
== STATUS_PENDING
)
1563 WaitForSingleObject(SockEvent
, INFINITE
);
1564 Status
= IOSB
.Status
;
1567 if (Status
!= STATUS_SUCCESS
)
1571 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1572 ConnectInfo
->Root
= 0;
1573 ConnectInfo
->UseSAN
= FALSE
;
1574 ConnectInfo
->Unknown
= 0;
1576 /* FIXME: Handle Async Connect */
1577 if (Socket
->SharedData
.NonBlocking
)
1579 AFD_DbgPrint(MIN_TRACE
, ("Async Connect UNIMPLEMENTED!\n"));
1583 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1593 /* Wait for return */
1594 if (Status
== STATUS_PENDING
)
1596 WaitForSingleObject(SockEvent
, INFINITE
);
1597 Status
= IOSB
.Status
;
1600 if (Status
!= STATUS_SUCCESS
)
1603 Socket
->SharedData
.State
= SocketConnected
;
1604 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1606 /* Get any pending connect data */
1607 if (lpCalleeData
!= NULL
)
1609 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1614 IOCTL_AFD_GET_CONNECT_DATA
,
1619 /* Wait for return */
1620 if (Status
== STATUS_PENDING
)
1622 WaitForSingleObject(SockEvent
, INFINITE
);
1623 Status
= IOSB
.Status
;
1627 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1630 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
1632 /* Re-enable Async Event */
1633 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1635 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1636 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1640 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1642 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1644 Socket
->TdiAddressHandle
,
1645 Socket
->TdiConnectionHandle
,
1646 WSH_NOTIFY_CONNECT
);
1650 if (lpErrno
) *lpErrno
= Errno
;
1651 return SOCKET_ERROR
;
1654 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1656 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1658 Socket
->TdiAddressHandle
,
1659 Socket
->TdiConnectionHandle
,
1660 WSH_NOTIFY_CONNECT_ERROR
);
1664 if (lpErrno
) *lpErrno
= Errno
;
1665 return SOCKET_ERROR
;
1669 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1673 WSPShutdown(SOCKET Handle
,
1678 IO_STATUS_BLOCK IOSB
;
1679 AFD_DISCONNECT_INFO DisconnectInfo
;
1680 PSOCKET_INFORMATION Socket
= NULL
;
1684 Status
= NtCreateEvent(&SockEvent
,
1690 if( !NT_SUCCESS(Status
) )
1693 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1695 /* Get the Socket Structure associate to this Socket*/
1696 Socket
= GetSocketStructure(Handle
);
1700 *lpErrno
= WSAENOTSOCK
;
1701 return SOCKET_ERROR
;
1704 /* Set AFD Disconnect Type */
1708 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1709 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1712 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1713 Socket
->SharedData
.SendShutdown
= TRUE
;
1716 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1717 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1718 Socket
->SharedData
.SendShutdown
= TRUE
;
1722 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
1725 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1730 IOCTL_AFD_DISCONNECT
,
1732 sizeof(DisconnectInfo
),
1736 /* Wait for return */
1737 if (Status
== STATUS_PENDING
)
1739 WaitForSingleObject(SockEvent
, INFINITE
);
1740 Status
= IOSB
.Status
;
1743 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1745 NtClose( SockEvent
);
1747 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1753 WSPGetSockName(IN SOCKET Handle
,
1754 OUT LPSOCKADDR Name
,
1755 IN OUT LPINT NameLength
,
1758 IO_STATUS_BLOCK IOSB
;
1759 ULONG TdiAddressSize
;
1760 PTDI_ADDRESS_INFO TdiAddress
;
1761 PTRANSPORT_ADDRESS SocketAddress
;
1762 PSOCKET_INFORMATION Socket
= NULL
;
1766 Status
= NtCreateEvent(&SockEvent
,
1772 if( !NT_SUCCESS(Status
) )
1773 return SOCKET_ERROR
;
1775 /* Get the Socket Structure associate to this Socket*/
1776 Socket
= GetSocketStructure(Handle
);
1780 *lpErrno
= WSAENOTSOCK
;
1781 return SOCKET_ERROR
;
1784 if (!Name
|| !NameLength
)
1787 *lpErrno
= WSAEFAULT
;
1788 return SOCKET_ERROR
;
1791 /* Allocate a buffer for the address */
1793 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfLocalAddress
;
1794 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1796 if ( TdiAddress
== NULL
)
1798 NtClose( SockEvent
);
1799 *lpErrno
= WSAENOBUFS
;
1800 return SOCKET_ERROR
;
1803 SocketAddress
= &TdiAddress
->Address
;
1806 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1811 IOCTL_AFD_GET_SOCK_NAME
,
1817 /* Wait for return */
1818 if (Status
== STATUS_PENDING
)
1820 WaitForSingleObject(SockEvent
, INFINITE
);
1821 Status
= IOSB
.Status
;
1824 NtClose( SockEvent
);
1826 if (NT_SUCCESS(Status
))
1828 if (*NameLength
>= Socket
->SharedData
.SizeOfLocalAddress
)
1830 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1831 RtlCopyMemory (Name
->sa_data
,
1832 SocketAddress
->Address
[0].Address
,
1833 SocketAddress
->Address
[0].AddressLength
);
1834 *NameLength
= Socket
->SharedData
.SizeOfLocalAddress
;
1835 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1836 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1837 ((struct sockaddr_in
*)Name
)->sin_port
));
1838 HeapFree(GlobalHeap
, 0, TdiAddress
);
1843 HeapFree(GlobalHeap
, 0, TdiAddress
);
1844 *lpErrno
= WSAEFAULT
;
1845 return SOCKET_ERROR
;
1849 HeapFree(GlobalHeap
, 0, TdiAddress
);
1851 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1857 WSPGetPeerName(IN SOCKET s
,
1858 OUT LPSOCKADDR Name
,
1859 IN OUT LPINT NameLength
,
1862 IO_STATUS_BLOCK IOSB
;
1863 ULONG TdiAddressSize
;
1864 PTRANSPORT_ADDRESS SocketAddress
;
1865 PSOCKET_INFORMATION Socket
= NULL
;
1869 Status
= NtCreateEvent(&SockEvent
,
1875 if( !NT_SUCCESS(Status
) )
1876 return SOCKET_ERROR
;
1878 /* Get the Socket Structure associate to this Socket*/
1879 Socket
= GetSocketStructure(s
);
1883 *lpErrno
= WSAENOTSOCK
;
1884 return SOCKET_ERROR
;
1887 if (Socket
->SharedData
.State
!= SocketConnected
)
1890 *lpErrno
= WSAENOTCONN
;
1891 return SOCKET_ERROR
;
1894 if (!Name
|| !NameLength
)
1897 *lpErrno
= WSAEFAULT
;
1898 return SOCKET_ERROR
;
1901 /* Allocate a buffer for the address */
1902 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfRemoteAddress
;
1903 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1905 if ( SocketAddress
== NULL
)
1907 NtClose( SockEvent
);
1908 *lpErrno
= WSAENOBUFS
;
1909 return SOCKET_ERROR
;
1913 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1918 IOCTL_AFD_GET_PEER_NAME
,
1924 /* Wait for return */
1925 if (Status
== STATUS_PENDING
)
1927 WaitForSingleObject(SockEvent
, INFINITE
);
1928 Status
= IOSB
.Status
;
1931 NtClose( SockEvent
);
1933 if (NT_SUCCESS(Status
))
1935 if (*NameLength
>= Socket
->SharedData
.SizeOfRemoteAddress
)
1937 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1938 RtlCopyMemory (Name
->sa_data
,
1939 SocketAddress
->Address
[0].Address
,
1940 SocketAddress
->Address
[0].AddressLength
);
1941 *NameLength
= Socket
->SharedData
.SizeOfRemoteAddress
;
1942 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1943 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1944 ((struct sockaddr_in
*)Name
)->sin_port
));
1945 HeapFree(GlobalHeap
, 0, SocketAddress
);
1950 HeapFree(GlobalHeap
, 0, SocketAddress
);
1951 *lpErrno
= WSAEFAULT
;
1952 return SOCKET_ERROR
;
1956 HeapFree(GlobalHeap
, 0, SocketAddress
);
1958 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1963 WSPIoctl(IN SOCKET Handle
,
1964 IN DWORD dwIoControlCode
,
1965 IN LPVOID lpvInBuffer
,
1966 IN DWORD cbInBuffer
,
1967 OUT LPVOID lpvOutBuffer
,
1968 IN DWORD cbOutBuffer
,
1969 OUT LPDWORD lpcbBytesReturned
,
1970 IN LPWSAOVERLAPPED lpOverlapped
,
1971 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
1972 IN LPWSATHREADID lpThreadId
,
1975 PSOCKET_INFORMATION Socket
= NULL
;
1976 BOOLEAN NeedsCompletion
;
1977 BOOLEAN NonBlocking
;
1979 if (!lpcbBytesReturned
)
1981 *lpErrno
= WSAEFAULT
;
1982 return SOCKET_ERROR
;
1985 /* Get the Socket Structure associate to this Socket*/
1986 Socket
= GetSocketStructure(Handle
);
1989 *lpErrno
= WSAENOTSOCK
;
1990 return SOCKET_ERROR
;
1993 *lpcbBytesReturned
= 0;
1995 switch( dwIoControlCode
)
1998 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2000 *lpErrno
= WSAEFAULT
;
2001 return SOCKET_ERROR
;
2003 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2004 Socket
->SharedData
.NonBlocking
= NonBlocking
? 1 : 0;
2005 *lpErrno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
);
2006 if (*lpErrno
!= NO_ERROR
)
2007 return SOCKET_ERROR
;
2011 if( cbOutBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvOutBuffer
) )
2013 *lpErrno
= WSAEFAULT
;
2014 return SOCKET_ERROR
;
2016 *lpErrno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
);
2017 if (*lpErrno
!= NO_ERROR
)
2018 return SOCKET_ERROR
;
2021 *lpcbBytesReturned
= sizeof(ULONG
);
2025 if (cbOutBuffer
< sizeof(BOOL
) || IS_INTRESOURCE(lpvOutBuffer
))
2027 *lpErrno
= WSAEFAULT
;
2028 return SOCKET_ERROR
;
2031 /* FIXME: Return false for now */
2032 *(BOOL
*)lpvOutBuffer
= FALSE
;
2034 *lpcbBytesReturned
= sizeof(BOOL
);
2035 *lpErrno
= NO_ERROR
;
2037 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2038 *lpErrno
= WSAEINVAL
;
2039 return SOCKET_ERROR
;
2041 *lpErrno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2043 Socket
->TdiAddressHandle
,
2044 Socket
->TdiConnectionHandle
,
2052 lpCompletionRoutine
,
2053 (LPBOOL
)&NeedsCompletion
);
2055 if (*lpErrno
!= NO_ERROR
)
2056 return SOCKET_ERROR
;
2065 WSPGetSockOpt(IN SOCKET Handle
,
2068 OUT CHAR FAR
* OptionValue
,
2069 IN OUT LPINT OptionLength
,
2072 PSOCKET_INFORMATION Socket
= NULL
;
2078 /* Get the Socket Structure associate to this Socket*/
2079 Socket
= GetSocketStructure(Handle
);
2082 *lpErrno
= WSAENOTSOCK
;
2083 return SOCKET_ERROR
;
2086 AFD_DbgPrint(MID_TRACE
, ("Called\n"));
2094 Buffer
= &Socket
->SharedData
.SocketType
;
2095 BufferSize
= sizeof(INT
);
2099 Buffer
= &Socket
->SharedData
.SizeOfRecvBuffer
;
2100 BufferSize
= sizeof(INT
);
2104 Buffer
= &Socket
->SharedData
.SizeOfSendBuffer
;
2105 BufferSize
= sizeof(INT
);
2109 BoolBuffer
= Socket
->SharedData
.Listening
;
2110 Buffer
= &BoolBuffer
;
2111 BufferSize
= sizeof(BOOL
);
2115 BoolBuffer
= Socket
->SharedData
.Broadcast
;
2116 Buffer
= &BoolBuffer
;
2117 BufferSize
= sizeof(BOOL
);
2121 BoolBuffer
= Socket
->SharedData
.Debug
;
2122 Buffer
= &BoolBuffer
;
2123 BufferSize
= sizeof(BOOL
);
2127 BoolBuffer
= (Socket
->SharedData
.LingerData
.l_onoff
== 0);
2128 Buffer
= &BoolBuffer
;
2129 BufferSize
= sizeof(BOOL
);
2133 Buffer
= &Socket
->SharedData
.LingerData
;
2134 BufferSize
= sizeof(struct linger
);
2138 BoolBuffer
= (Socket
->SharedData
.OobInline
!= 0);
2139 Buffer
= &BoolBuffer
;
2140 BufferSize
= sizeof(BOOL
);
2145 /* These guys go directly to the helper */
2148 case SO_CONDITIONAL_ACCEPT
:
2149 BoolBuffer
= (Socket
->SharedData
.UseDelayedAcceptance
!= 0);
2150 Buffer
= &BoolBuffer
;
2151 BufferSize
= sizeof(BOOL
);
2155 BoolBuffer
= (Socket
->SharedData
.ReuseAddresses
!= 0);
2156 Buffer
= &BoolBuffer
;
2157 BufferSize
= sizeof(BOOL
);
2160 case SO_EXCLUSIVEADDRUSE
:
2161 BoolBuffer
= (Socket
->SharedData
.ExclusiveAddressUse
!= 0);
2162 Buffer
= &BoolBuffer
;
2163 BufferSize
= sizeof(BOOL
);
2167 /* HACK: This needs to be properly tracked */
2169 DbgPrint("MSAFD: Hacked SO_ERROR returning error %d\n", IntBuffer
);
2171 Buffer
= &IntBuffer
;
2172 BufferSize
= sizeof(INT
);
2176 case SO_GROUP_PRIORITY
:
2177 case SO_MAX_MSG_SIZE
:
2178 case SO_PROTOCOL_INFO
:
2181 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2182 *lpErrno
= WSAENOPROTOOPT
;
2183 return SOCKET_ERROR
;
2186 if (*OptionLength
< BufferSize
)
2188 *lpErrno
= WSAEFAULT
;
2189 *OptionLength
= BufferSize
;
2190 return SOCKET_ERROR
;
2192 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2201 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2203 Socket
->TdiAddressHandle
,
2204 Socket
->TdiConnectionHandle
,
2208 (LPINT
)OptionLength
);
2209 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2218 IN CONST CHAR FAR
* optval
,
2222 PSOCKET_INFORMATION Socket
;
2224 /* Get the Socket Structure associate to this Socket*/
2225 Socket
= GetSocketStructure(s
);
2228 *lpErrno
= WSAENOTSOCK
;
2229 return SOCKET_ERROR
;
2233 /* FIXME: We should handle some more cases here */
2234 if (level
== SOL_SOCKET
)
2239 if (optlen
< sizeof(BOOL
))
2241 *lpErrno
= WSAEFAULT
;
2242 return SOCKET_ERROR
;
2244 Socket
->SharedData
.Broadcast
= (*optval
!= 0) ? 1 : 0;
2248 if (optlen
< sizeof(BOOL
))
2250 *lpErrno
= WSAEFAULT
;
2251 return SOCKET_ERROR
;
2253 Socket
->SharedData
.LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2257 if (optlen
< sizeof(BOOL
))
2259 *lpErrno
= WSAEFAULT
;
2260 return SOCKET_ERROR
;
2262 Socket
->SharedData
.ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2265 case SO_EXCLUSIVEADDRUSE
:
2266 if (optlen
< sizeof(BOOL
))
2268 *lpErrno
= WSAEFAULT
;
2269 return SOCKET_ERROR
;
2271 Socket
->SharedData
.ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2275 if (optlen
< sizeof(struct linger
))
2277 *lpErrno
= WSAEFAULT
;
2278 return SOCKET_ERROR
;
2280 RtlCopyMemory(&Socket
->SharedData
.LingerData
,
2282 sizeof(struct linger
));
2286 if (optlen
< sizeof(DWORD
))
2288 *lpErrno
= WSAEFAULT
;
2289 return SOCKET_ERROR
;
2292 /* TODO: The total per-socket buffer space reserved for sends */
2293 AFD_DbgPrint(MIN_TRACE
,("Setting send buf to %x is not implemented yet\n", optval
));
2297 if (optlen
< sizeof(DWORD
))
2299 *lpErrno
= WSAEFAULT
;
2300 return SOCKET_ERROR
;
2303 RtlCopyMemory(&Socket
->SharedData
.SendTimeout
,
2309 if (optlen
< sizeof(DWORD
))
2311 *lpErrno
= WSAEFAULT
;
2312 return SOCKET_ERROR
;
2315 RtlCopyMemory(&Socket
->SharedData
.RecvTimeout
,
2322 /* These go directly to the helper dll */
2326 /* Obviously this is a hack */
2327 DbgPrint("MSAFD: Set unknown optname %x\n", optname
);
2333 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2335 Socket
->TdiAddressHandle
,
2336 Socket
->TdiConnectionHandle
,
2341 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2345 * FUNCTION: Initialize service provider for a client
2347 * wVersionRequested = Highest WinSock SPI version that the caller can use
2348 * lpWSPData = Address of WSPDATA structure to initialize
2349 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2350 * UpcallTable = Pointer to upcall table of the WinSock DLL
2351 * lpProcTable = Address of procedure table to initialize
2353 * Status of operation
2357 WSPStartup(IN WORD wVersionRequested
,
2358 OUT LPWSPDATA lpWSPData
,
2359 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2360 IN WSPUPCALLTABLE UpcallTable
,
2361 OUT LPWSPPROC_TABLE lpProcTable
)
2366 AFD_DbgPrint(MAX_TRACE
, ("wVersionRequested (0x%X) \n", wVersionRequested
));
2368 Upcalls
= UpcallTable
;
2370 if (Status
== NO_ERROR
)
2372 lpProcTable
->lpWSPAccept
= WSPAccept
;
2373 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2374 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2375 lpProcTable
->lpWSPBind
= WSPBind
;
2376 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2377 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2378 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2379 lpProcTable
->lpWSPConnect
= WSPConnect
;
2380 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2381 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2382 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2383 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2384 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2385 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2386 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2387 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2388 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2389 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2390 lpProcTable
->lpWSPListen
= WSPListen
;
2391 lpProcTable
->lpWSPRecv
= WSPRecv
;
2392 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2393 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2394 lpProcTable
->lpWSPSelect
= WSPSelect
;
2395 lpProcTable
->lpWSPSend
= WSPSend
;
2396 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2397 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2398 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2399 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2400 lpProcTable
->lpWSPSocket
= WSPSocket
;
2401 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2402 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2403 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2406 AFD_DbgPrint(MAX_TRACE
, ("Status (%d).\n", Status
));
2413 * FUNCTION: Cleans up service provider for a client
2415 * lpErrno = Address of buffer for error information
2417 * 0 if successful, or SOCKET_ERROR if not
2421 WSPCleanup(OUT LPINT lpErrno
)
2424 AFD_DbgPrint(MAX_TRACE
, ("\n"));
2425 AFD_DbgPrint(MAX_TRACE
, ("Leaving.\n"));
2426 *lpErrno
= NO_ERROR
;
2434 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2435 ULONG AfdInformationClass
,
2436 PBOOLEAN Boolean OPTIONAL
,
2437 PULONG Ulong OPTIONAL
,
2438 PLARGE_INTEGER LargeInteger OPTIONAL
)
2440 IO_STATUS_BLOCK IOSB
;
2445 Status
= NtCreateEvent(&SockEvent
,
2451 if( !NT_SUCCESS(Status
) )
2454 /* Set Info Class */
2455 InfoData
.InformationClass
= AfdInformationClass
;
2458 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2469 /* Wait for return */
2470 if (Status
== STATUS_PENDING
)
2472 WaitForSingleObject(SockEvent
, INFINITE
);
2473 Status
= IOSB
.Status
;
2476 if (Status
!= STATUS_SUCCESS
)
2479 /* Return Information */
2482 *Ulong
= InfoData
.Information
.Ulong
;
2484 if (LargeInteger
!= NULL
)
2486 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2488 if (Boolean
!= NULL
)
2490 *Boolean
= InfoData
.Information
.Boolean
;
2493 NtClose( SockEvent
);
2501 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2502 ULONG AfdInformationClass
,
2503 PBOOLEAN Boolean OPTIONAL
,
2504 PULONG Ulong OPTIONAL
,
2505 PLARGE_INTEGER LargeInteger OPTIONAL
)
2507 IO_STATUS_BLOCK IOSB
;
2512 Status
= NtCreateEvent(&SockEvent
,
2518 if( !NT_SUCCESS(Status
) )
2521 /* Set Info Class */
2522 InfoData
.InformationClass
= AfdInformationClass
;
2524 /* Set Information */
2527 InfoData
.Information
.Ulong
= *Ulong
;
2529 if (LargeInteger
!= NULL
)
2531 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2533 if (Boolean
!= NULL
)
2535 InfoData
.Information
.Boolean
= *Boolean
;
2539 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2550 /* Wait for return */
2551 if (Status
== STATUS_PENDING
)
2553 WaitForSingleObject(SockEvent
, INFINITE
);
2554 Status
= IOSB
.Status
;
2557 NtClose( SockEvent
);
2559 return Status
== STATUS_SUCCESS
? 0 : -1;
2564 GetSocketStructure(SOCKET Handle
)
2566 PSOCKET_INFORMATION CurrentSocket
;
2568 EnterCriticalSection(&SocketListLock
);
2570 CurrentSocket
= SocketListHead
;
2571 while (CurrentSocket
)
2573 if (CurrentSocket
->Handle
== Handle
)
2575 LeaveCriticalSection(&SocketListLock
);
2576 return CurrentSocket
;
2579 CurrentSocket
= CurrentSocket
->NextSocket
;
2582 LeaveCriticalSection(&SocketListLock
);
2587 int CreateContext(PSOCKET_INFORMATION Socket
)
2589 IO_STATUS_BLOCK IOSB
;
2590 SOCKET_CONTEXT ContextData
;
2594 Status
= NtCreateEvent(&SockEvent
,
2600 if( !NT_SUCCESS(Status
) )
2603 /* Create Context */
2604 ContextData
.SharedData
= Socket
->SharedData
;
2605 ContextData
.SizeOfHelperData
= 0;
2606 RtlCopyMemory (&ContextData
.LocalAddress
,
2607 Socket
->LocalAddress
,
2608 Socket
->SharedData
.SizeOfLocalAddress
);
2609 RtlCopyMemory (&ContextData
.RemoteAddress
,
2610 Socket
->RemoteAddress
,
2611 Socket
->SharedData
.SizeOfRemoteAddress
);
2614 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2619 IOCTL_AFD_SET_CONTEXT
,
2621 sizeof(ContextData
),
2625 /* Wait for Completition */
2626 if (Status
== STATUS_PENDING
)
2628 WaitForSingleObject(SockEvent
, INFINITE
);
2629 Status
= IOSB
.Status
;
2632 NtClose( SockEvent
);
2634 return Status
== STATUS_SUCCESS
? 0 : -1;
2637 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
2639 HANDLE hAsyncThread
;
2640 DWORD AsyncThreadId
;
2642 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2645 /* Check if the Thread Already Exists */
2646 if (SockAsyncThreadRefCount
)
2648 ASSERT(SockAsyncCompletionPort
);
2652 /* Create the Completion Port */
2653 if (!SockAsyncCompletionPort
)
2655 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
2656 IO_COMPLETION_ALL_ACCESS
,
2658 2); // Allow 2 threads only
2659 if (!NT_SUCCESS(Status
))
2661 AFD_DbgPrint(MID_TRACE
,("Failed to create completion port\n"));
2664 /* Protect Handle */
2665 HandleFlags
.ProtectFromClose
= TRUE
;
2666 HandleFlags
.Inherit
= FALSE
;
2667 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2668 ObjectHandleFlagInformation
,
2670 sizeof(HandleFlags
));
2673 /* Create the Async Event */
2674 Status
= NtCreateEvent(&AsyncEvent
,
2680 /* Create the Async Thread */
2681 hAsyncThread
= CreateThread(NULL
,
2683 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
2688 /* Close the Handle */
2689 NtClose(hAsyncThread
);
2691 /* Increase the Reference Count */
2692 SockAsyncThreadRefCount
++;
2696 int SockAsyncThread(PVOID ThreadParam
)
2699 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
2700 IO_STATUS_BLOCK IOSB
;
2703 /* Make the Thread Higher Priority */
2704 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
2706 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
2709 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
2710 (PVOID
*)&AsyncCompletionRoutine
,
2714 /* Call the Async Function */
2715 if (NT_SUCCESS(Status
))
2717 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
2721 /* It Failed, sleep for a second */
2724 } while ((Status
!= STATUS_TIMEOUT
));
2726 /* The Thread has Ended */
2730 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
2732 UNICODE_STRING AfdHelper
;
2733 OBJECT_ATTRIBUTES ObjectAttributes
;
2734 IO_STATUS_BLOCK IoSb
;
2735 FILE_COMPLETION_INFORMATION CompletionInfo
;
2736 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2738 /* First, make sure we're not already intialized */
2739 if (SockAsyncHelperAfdHandle
)
2744 /* Set up Handle Name and Object */
2745 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
2746 InitializeObjectAttributes(&ObjectAttributes
,
2748 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
2752 /* Open the Handle to AFD */
2753 NtCreateFile(&SockAsyncHelperAfdHandle
,
2754 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
2759 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2766 * Now Set up the Completion Port Information
2767 * This means that whenever a Poll is finished, the routine will be executed
2769 CompletionInfo
.Port
= SockAsyncCompletionPort
;
2770 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
2771 NtSetInformationFile(SockAsyncHelperAfdHandle
,
2774 sizeof(CompletionInfo
),
2775 FileCompletionInformation
);
2778 /* Protect the Handle */
2779 HandleFlags
.ProtectFromClose
= TRUE
;
2780 HandleFlags
.Inherit
= FALSE
;
2781 NtSetInformationObject(SockAsyncCompletionPort
,
2782 ObjectHandleFlagInformation
,
2784 sizeof(HandleFlags
));
2787 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
2788 SockAsyncSelectCalled
= TRUE
;
2792 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2795 PASYNC_DATA AsyncData
= Context
;
2796 PSOCKET_INFORMATION Socket
;
2799 /* Get the Socket */
2800 Socket
= AsyncData
->ParentSocket
;
2802 /* Check if the Sequence Number Changed behind our back */
2803 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
.SequenceNumber
)
2808 /* Check we were manually called b/c of a failure */
2809 if (!NT_SUCCESS(IoStatusBlock
->Status
))
2811 /* FIXME: Perform Upcall */
2815 for (x
= 1; x
; x
<<=1)
2817 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
2819 case AFD_EVENT_RECEIVE
:
2820 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_READ
) &&
2821 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_READ
))
2823 /* Make the Notifcation */
2824 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2825 Socket
->SharedData
.wMsg
,
2827 WSAMAKESELECTREPLY(FD_READ
, 0));
2828 /* Disable this event until the next read(); */
2829 Socket
->SharedData
.AsyncDisabledEvents
|= FD_READ
;
2833 case AFD_EVENT_OOB_RECEIVE
:
2834 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_OOB
) &&
2835 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_OOB
))
2837 /* Make the Notifcation */
2838 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2839 Socket
->SharedData
.wMsg
,
2841 WSAMAKESELECTREPLY(FD_OOB
, 0));
2842 /* Disable this event until the next read(); */
2843 Socket
->SharedData
.AsyncDisabledEvents
|= FD_OOB
;
2847 case AFD_EVENT_SEND
:
2848 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_WRITE
) &&
2849 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_WRITE
))
2851 /* Make the Notifcation */
2852 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2853 Socket
->SharedData
.wMsg
,
2855 WSAMAKESELECTREPLY(FD_WRITE
, 0));
2856 /* Disable this event until the next write(); */
2857 Socket
->SharedData
.AsyncDisabledEvents
|= FD_WRITE
;
2861 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2862 case AFD_EVENT_CONNECT
:
2863 case AFD_EVENT_CONNECT_FAIL
:
2864 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
) &&
2865 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CONNECT
))
2867 /* Make the Notifcation */
2868 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2869 Socket
->SharedData
.wMsg
,
2871 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
2872 /* Disable this event forever; */
2873 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
;
2877 case AFD_EVENT_ACCEPT
:
2878 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_ACCEPT
) &&
2879 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_ACCEPT
))
2881 /* Make the Notifcation */
2882 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2883 Socket
->SharedData
.wMsg
,
2885 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
2886 /* Disable this event until the next accept(); */
2887 Socket
->SharedData
.AsyncDisabledEvents
|= FD_ACCEPT
;
2891 case AFD_EVENT_DISCONNECT
:
2892 case AFD_EVENT_ABORT
:
2893 case AFD_EVENT_CLOSE
:
2894 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CLOSE
) &&
2895 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CLOSE
))
2897 /* Make the Notifcation */
2898 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2899 Socket
->SharedData
.wMsg
,
2901 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
2902 /* Disable this event forever; */
2903 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CLOSE
;
2906 /* FIXME: Support QOS */
2910 /* Check if there are any events left for us to check */
2911 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2917 SockProcessAsyncSelect(Socket
, AsyncData
);
2921 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
2924 ULONG lNetworkEvents
;
2927 /* Set up the Async Data Event Info */
2928 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
2929 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
2930 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
2931 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
2932 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
2933 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
2935 /* Remove unwanted events */
2936 lNetworkEvents
= Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
);
2938 /* Set Events to wait for */
2939 if (lNetworkEvents
& FD_READ
)
2941 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
2944 if (lNetworkEvents
& FD_WRITE
)
2946 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
2949 if (lNetworkEvents
& FD_OOB
)
2951 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
2954 if (lNetworkEvents
& FD_ACCEPT
)
2956 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
2959 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2960 if (lNetworkEvents
& FD_CONNECT
)
2962 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
2965 if (lNetworkEvents
& FD_CLOSE
)
2967 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
2970 if (lNetworkEvents
& FD_QOS
)
2972 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
2975 if (lNetworkEvents
& FD_GROUP_QOS
)
2977 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
2981 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
2985 &AsyncData
->IoStatusBlock
,
2987 &AsyncData
->AsyncSelectInfo
,
2988 sizeof(AsyncData
->AsyncSelectInfo
),
2989 &AsyncData
->AsyncSelectInfo
,
2990 sizeof(AsyncData
->AsyncSelectInfo
));
2992 /* I/O Manager Won't call the completion routine, let's do it manually */
2993 if (NT_SUCCESS(Status
))
2999 AsyncData
->IoStatusBlock
.Status
= Status
;
3000 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3004 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3006 PASYNC_DATA AsyncData
= Context
;
3007 BOOL FreeContext
= TRUE
;
3008 PSOCKET_INFORMATION Socket
;
3010 /* Get the Socket */
3011 Socket
= AsyncData
->ParentSocket
;
3013 /* If someone closed it, stop the function */
3014 if (Socket
->SharedData
.State
!= SocketClosed
)
3016 /* Check if the Sequence Number changed by now, in which case quit */
3017 if (AsyncData
->SequenceNumber
== Socket
->SharedData
.SequenceNumber
)
3019 /* Do the actuall select, if needed */
3020 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)))
3022 SockProcessAsyncSelect(Socket
, AsyncData
);
3023 FreeContext
= FALSE
;
3028 /* Free the Context */
3031 HeapFree(GetProcessHeap(), 0, AsyncData
);
3038 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3041 PASYNC_DATA AsyncData
;
3043 /* Make sure the event is actually disabled */
3044 if (!(Socket
->SharedData
.AsyncDisabledEvents
& Event
))
3050 Socket
->SharedData
.AsyncDisabledEvents
&= ~Event
;
3052 /* Return if no more events are being polled */
3053 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
3058 /* Wait on new events */
3059 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
3060 if (!AsyncData
) return;
3062 /* Create the Asynch Thread if Needed */
3063 SockCreateOrReferenceAsyncThread();
3065 /* Increase the sequence number to stop anything else */
3066 Socket
->SharedData
.SequenceNumber
++;
3068 /* Set up the Async Data */
3069 AsyncData
->ParentSocket
= Socket
;
3070 AsyncData
->SequenceNumber
= Socket
->SharedData
.SequenceNumber
;
3072 /* Begin Async Select by using I/O Completion */
3073 NtSetIoCompletion(SockAsyncCompletionPort
,
3074 (PVOID
)&SockProcessQueuedAsyncSelect
,
3085 DllMain(HANDLE hInstDll
,
3092 case DLL_PROCESS_ATTACH
:
3094 AFD_DbgPrint(MAX_TRACE
, ("Loading MSAFD.DLL \n"));
3096 /* Don't need thread attach notifications
3097 so disable them to improve performance */
3098 DisableThreadLibraryCalls(hInstDll
);
3100 /* List of DLL Helpers */
3101 InitializeListHead(&SockHelpersListHead
);
3103 /* Heap to use when allocating */
3104 GlobalHeap
= GetProcessHeap();
3106 /* Initialize the lock that protects our socket list */
3107 InitializeCriticalSection(&SocketListLock
);
3109 AFD_DbgPrint(MAX_TRACE
, ("MSAFD.DLL has been loaded\n"));
3113 case DLL_THREAD_ATTACH
:
3116 case DLL_THREAD_DETACH
:
3119 case DLL_PROCESS_DETACH
:
3121 /* Delete the socket list lock */
3122 DeleteCriticalSection(&SocketListLock
);
3127 AFD_DbgPrint(MAX_TRACE
, ("DllMain of msafd.dll (leaving)\n"));