2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Ancillary Function Driver DLL
5 * PURPOSE: DLL entry point
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Alex Ionescu (alex@relsoft.net)
9 * CSH 01/09-2000 Created
10 * Alex 16/07/2004 - Complete Rewrite
18 //DWORD DebugTraceLevel = DEBUG_ULTRA;
19 DWORD DebugTraceLevel
= 0;
23 WSPUPCALLTABLE Upcalls
;
24 LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
;
25 PSOCKET_INFORMATION SocketListHead
= NULL
;
26 CRITICAL_SECTION SocketListLock
;
27 LIST_ENTRY SockHelpersListHead
= { NULL
, NULL
};
28 ULONG SockAsyncThreadRefCount
;
29 HANDLE SockAsyncHelperAfdHandle
;
30 HANDLE SockAsyncCompletionPort
= NULL
;
31 BOOLEAN SockAsyncSelectCalled
;
36 * FUNCTION: Creates a new socket
40 * protocol = Protocol type
41 * lpProtocolInfo = Pointer to protocol information
43 * dwFlags = Socket flags
44 * lpErrno = Address of buffer for error information
46 * Created socket, or INVALID_SOCKET if it could not be created
50 WSPSocket(int AddressFamily
,
53 LPWSAPROTOCOL_INFOW lpProtocolInfo
,
58 OBJECT_ATTRIBUTES Object
;
62 PAFD_CREATE_PACKET AfdPacket
;
64 PSOCKET_INFORMATION Socket
= NULL
;
65 PFILE_FULL_EA_INFORMATION EABuffer
= NULL
;
66 PHELPER_DATA HelperData
;
67 PVOID HelperDLLContext
;
69 UNICODE_STRING TransportName
;
70 UNICODE_STRING DevName
;
71 LARGE_INTEGER GroupData
;
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 /* Save Group Info */
267 GetSocketInformation(Socket
, AFD_INFO_GROUP_ID_TYPE
, NULL
, NULL
, &GroupData
);
268 Socket
->SharedData
.GroupID
= GroupData
.u
.LowPart
;
269 Socket
->SharedData
.GroupType
= GroupData
.u
.HighPart
;
272 /* Get Window Sizes and Save them */
273 GetSocketInformation (Socket
,
274 AFD_INFO_SEND_WINDOW_SIZE
,
276 &Socket
->SharedData
.SizeOfSendBuffer
,
279 GetSocketInformation (Socket
,
280 AFD_INFO_RECEIVE_WINDOW_SIZE
,
282 &Socket
->SharedData
.SizeOfRecvBuffer
,
285 /* Save in Process Sockets List */
286 EnterCriticalSection(&SocketListLock
);
287 Socket
->NextSocket
= SocketListHead
;
288 SocketListHead
= Socket
;
289 LeaveCriticalSection(&SocketListLock
);
291 /* Create the Socket Context */
292 CreateContext(Socket
);
295 Upcalls
.lpWPUModifyIFSHandle(1, (SOCKET
)Sock
, lpErrno
);
297 /* Return Socket Handle */
298 AFD_DbgPrint(MID_TRACE
,("Success %x\n", Sock
));
303 AFD_DbgPrint(MID_TRACE
,("Ending %x\n", Status
));
306 HeapFree(GlobalHeap
, 0, Socket
);
311 return INVALID_SOCKET
;
315 TranslateNtStatusError(NTSTATUS Status
)
319 case STATUS_CANT_WAIT
:
320 return WSAEWOULDBLOCK
;
328 case STATUS_FILE_CLOSED
:
329 case STATUS_END_OF_FILE
:
333 return WSA_IO_PENDING
;
335 case STATUS_BUFFER_TOO_SMALL
:
336 case STATUS_BUFFER_OVERFLOW
:
337 DbgPrint("MSAFD: STATUS_BUFFER_TOO_SMALL/STATUS_BUFFER_OVERFLOW\n");
340 case STATUS_NO_MEMORY
:
341 case STATUS_INSUFFICIENT_RESOURCES
:
342 DbgPrint("MSAFD: STATUS_NO_MEMORY/STATUS_INSUFFICIENT_RESOURCES\n");
345 case STATUS_INVALID_CONNECTION
:
346 DbgPrint("MSAFD: STATUS_INVALID_CONNECTION\n");
347 return WSAEAFNOSUPPORT
;
349 case STATUS_INVALID_ADDRESS
:
350 DbgPrint("MSAFD: STATUS_INVALID_ADDRESS\n");
351 return WSAEADDRNOTAVAIL
;
353 case STATUS_REMOTE_NOT_LISTENING
:
354 DbgPrint("MSAFD: STATUS_REMOTE_NOT_LISTENING\n");
355 return WSAECONNREFUSED
;
357 case STATUS_NETWORK_UNREACHABLE
:
358 DbgPrint("MSAFD: STATUS_NETWORK_UNREACHABLE\n");
359 return WSAENETUNREACH
;
361 case STATUS_INVALID_PARAMETER
:
362 DbgPrint("MSAFD: STATUS_INVALID_PARAMETER\n");
365 case STATUS_CANCELLED
:
366 DbgPrint("MSAFD: STATUS_CANCELLED\n");
367 return WSA_OPERATION_ABORTED
;
369 case STATUS_ADDRESS_ALREADY_EXISTS
:
370 DbgPrint("MSAFD: STATUS_ADDRESS_ALREADY_EXISTS\n");
371 return WSAEADDRINUSE
;
373 case STATUS_LOCAL_DISCONNECT
:
374 DbgPrint("MSAFD: STATUS_LOCAL_DISCONNECT\n");
375 return WSAECONNABORTED
;
377 case STATUS_REMOTE_DISCONNECT
:
378 DbgPrint("MSAFD: STATUS_REMOTE_DISCONNECT\n");
379 return WSAECONNRESET
;
381 case STATUS_ACCESS_VIOLATION
:
382 DbgPrint("MSAFD: STATUS_ACCESS_VIOLATION\n");
386 DbgPrint("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status
);
392 * FUNCTION: Closes an open socket
394 * s = Socket descriptor
395 * lpErrno = Address of buffer for error information
397 * NO_ERROR, or SOCKET_ERROR if the socket could not be closed
401 WSPCloseSocket(IN SOCKET Handle
,
404 IO_STATUS_BLOCK IoStatusBlock
;
405 PSOCKET_INFORMATION Socket
= NULL
, CurrentSocket
;
408 AFD_DISCONNECT_INFO DisconnectInfo
;
409 SOCKET_STATE OldState
;
410 LONG LingerWait
= -1;
412 /* Create the Wait Event */
413 Status
= NtCreateEvent(&SockEvent
,
419 if(!NT_SUCCESS(Status
))
422 /* Get the Socket Structure associate to this Socket*/
423 Socket
= GetSocketStructure(Handle
);
427 *lpErrno
= WSAENOTSOCK
;
431 if (Socket
->HelperEvents
& WSH_NOTIFY_CLOSE
)
433 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
435 Socket
->TdiAddressHandle
,
436 Socket
->TdiConnectionHandle
,
441 if (lpErrno
) *lpErrno
= Status
;
447 /* If a Close is already in Process, give up */
448 if (Socket
->SharedData
.State
== SocketClosed
)
451 *lpErrno
= WSAENOTSOCK
;
455 /* Set the state to close */
456 OldState
= Socket
->SharedData
.State
;
457 Socket
->SharedData
.State
= SocketClosed
;
459 /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
460 /* FIXME: Should we do this on Datagram Sockets too? */
461 if ((OldState
== SocketConnected
) && (Socket
->SharedData
.LingerData
.l_onoff
))
463 ULONG SendsInProgress
;
466 /* We need to respect the timeout */
468 LingerWait
= Socket
->SharedData
.LingerData
.l_linger
* 1000;
470 /* Loop until no more sends are pending, within the timeout */
473 /* Find out how many Sends are in Progress */
474 if (GetSocketInformation(Socket
,
475 AFD_INFO_SENDS_IN_PROGRESS
,
480 /* Bail out if anything but NO_ERROR */
485 /* Bail out if no more sends are pending */
486 if (!SendsInProgress
)
493 * We have to execute a sleep, so it's kind of like
494 * a block. If the socket is Nonblock, we cannot
495 * go on since asyncronous operation is expected
496 * and we cannot offer it
498 if (Socket
->SharedData
.NonBlocking
)
501 Socket
->SharedData
.State
= OldState
;
502 *lpErrno
= WSAEWOULDBLOCK
;
506 /* Now we can sleep, and decrement the linger wait */
508 * FIXME: It seems Windows does some funky acceleration
509 * since the waiting seems to be longer and longer. I
510 * don't think this improves performance so much, so we
511 * wait a fixed time instead.
514 LingerWait
-= SleepWait
;
518 if (OldState
== SocketConnected
)
522 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(0);
523 DisconnectInfo
.DisconnectType
= LingerWait
< 0 ? AFD_DISCONNECT_SEND
: AFD_DISCONNECT_ABORT
;
525 if (((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_SEND
) && (!Socket
->SharedData
.SendShutdown
)) ||
526 ((DisconnectInfo
.DisconnectType
& AFD_DISCONNECT_ABORT
) && (!Socket
->SharedData
.ReceiveShutdown
)))
529 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
534 IOCTL_AFD_DISCONNECT
,
536 sizeof(DisconnectInfo
),
540 /* Wait for return */
541 if (Status
== STATUS_PENDING
)
543 WaitForSingleObject(SockEvent
, INFINITE
);
544 Status
= IoStatusBlock
.Status
;
551 Socket
->HelperContext
= NULL
;
552 Socket
->SharedData
.AsyncDisabledEvents
= -1;
553 NtClose(Socket
->TdiAddressHandle
);
554 Socket
->TdiAddressHandle
= NULL
;
555 NtClose(Socket
->TdiConnectionHandle
);
556 Socket
->TdiConnectionHandle
= NULL
;
558 EnterCriticalSection(&SocketListLock
);
559 if (SocketListHead
== Socket
)
561 SocketListHead
= SocketListHead
->NextSocket
;
565 CurrentSocket
= SocketListHead
;
566 while (CurrentSocket
->NextSocket
)
568 if (CurrentSocket
->NextSocket
== Socket
)
570 CurrentSocket
->NextSocket
= CurrentSocket
->NextSocket
->NextSocket
;
574 CurrentSocket
= CurrentSocket
->NextSocket
;
577 LeaveCriticalSection(&SocketListLock
);
579 /* Close the handle */
580 NtClose((HANDLE
)Handle
);
583 HeapFree(GlobalHeap
, 0, Socket
);
584 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
589 * FUNCTION: Associates a local address with a socket
591 * s = Socket descriptor
592 * name = Pointer to local address
593 * namelen = Length of name
594 * lpErrno = Address of buffer for error information
596 * 0, or SOCKET_ERROR if the socket could not be bound
600 WSPBind(SOCKET Handle
,
601 const struct sockaddr
*SocketAddress
,
602 int SocketAddressLength
,
605 IO_STATUS_BLOCK IOSB
;
606 PAFD_BIND_DATA BindData
;
607 PSOCKET_INFORMATION Socket
= NULL
;
609 SOCKADDR_INFO SocketInfo
;
613 BindData
= HeapAlloc(GlobalHeap
, 0, 0xA + SocketAddressLength
);
616 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
619 Status
= NtCreateEvent(&SockEvent
,
625 if (!NT_SUCCESS(Status
))
627 HeapFree(GlobalHeap
, 0, BindData
);
631 /* Get the Socket Structure associate to this Socket*/
632 Socket
= GetSocketStructure(Handle
);
635 HeapFree(GlobalHeap
, 0, BindData
);
636 *lpErrno
= WSAENOTSOCK
;
640 /* Set up Address in TDI Format */
641 BindData
->Address
.TAAddressCount
= 1;
642 BindData
->Address
.Address
[0].AddressLength
= SocketAddressLength
- sizeof(SocketAddress
->sa_family
);
643 BindData
->Address
.Address
[0].AddressType
= SocketAddress
->sa_family
;
644 RtlCopyMemory (BindData
->Address
.Address
[0].Address
,
645 SocketAddress
->sa_data
,
646 SocketAddressLength
- sizeof(SocketAddress
->sa_family
));
648 /* Get Address Information */
649 Socket
->HelperData
->WSHGetSockaddrType ((PSOCKADDR
)SocketAddress
,
653 /* Set the Share Type */
654 if (Socket
->SharedData
.ExclusiveAddressUse
)
656 BindData
->ShareType
= AFD_SHARE_EXCLUSIVE
;
658 else if (SocketInfo
.EndpointInfo
== SockaddrEndpointInfoWildcard
)
660 BindData
->ShareType
= AFD_SHARE_WILDCARD
;
662 else if (Socket
->SharedData
.ReuseAddresses
)
664 BindData
->ShareType
= AFD_SHARE_REUSE
;
668 BindData
->ShareType
= AFD_SHARE_UNIQUE
;
672 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
679 0xA + Socket
->SharedData
.SizeOfLocalAddress
, /* Can't figure out a way to calculate this in C*/
681 0xA + Socket
->SharedData
.SizeOfLocalAddress
); /* Can't figure out a way to calculate this C */
683 /* Wait for return */
684 if (Status
== STATUS_PENDING
)
686 WaitForSingleObject(SockEvent
, INFINITE
);
687 Status
= IOSB
.Status
;
690 NtClose( SockEvent
);
691 HeapFree(GlobalHeap
, 0, BindData
);
693 if (Status
!= STATUS_SUCCESS
)
694 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
696 /* Set up Socket Data */
697 Socket
->SharedData
.State
= SocketBound
;
698 Socket
->TdiAddressHandle
= (HANDLE
)IOSB
.Information
;
700 if (Socket
->HelperEvents
& WSH_NOTIFY_BIND
)
702 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
704 Socket
->TdiAddressHandle
,
705 Socket
->TdiConnectionHandle
,
710 if (lpErrno
) *lpErrno
= Status
;
715 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
720 WSPListen(SOCKET Handle
,
724 IO_STATUS_BLOCK IOSB
;
725 AFD_LISTEN_DATA ListenData
;
726 PSOCKET_INFORMATION Socket
= NULL
;
730 /* Get the Socket Structure associate to this Socket*/
731 Socket
= GetSocketStructure(Handle
);
734 *lpErrno
= WSAENOTSOCK
;
738 if (Socket
->SharedData
.Listening
)
741 Status
= NtCreateEvent(&SockEvent
,
747 if( !NT_SUCCESS(Status
) )
750 /* Set Up Listen Structure */
751 ListenData
.UseSAN
= FALSE
;
752 ListenData
.UseDelayedAcceptance
= Socket
->SharedData
.UseDelayedAcceptance
;
753 ListenData
.Backlog
= Backlog
;
756 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
761 IOCTL_AFD_START_LISTEN
,
767 /* Wait for return */
768 if (Status
== STATUS_PENDING
)
770 WaitForSingleObject(SockEvent
, INFINITE
);
771 Status
= IOSB
.Status
;
774 NtClose( SockEvent
);
776 if (Status
!= STATUS_SUCCESS
)
777 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
779 /* Set to Listening */
780 Socket
->SharedData
.Listening
= TRUE
;
782 if (Socket
->HelperEvents
& WSH_NOTIFY_LISTEN
)
784 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
786 Socket
->TdiAddressHandle
,
787 Socket
->TdiConnectionHandle
,
792 if (lpErrno
) *lpErrno
= Status
;
797 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
803 WSPSelect(IN
int nfds
,
804 IN OUT fd_set
*readfds OPTIONAL
,
805 IN OUT fd_set
*writefds OPTIONAL
,
806 IN OUT fd_set
*exceptfds OPTIONAL
,
807 IN
const struct timeval
*timeout OPTIONAL
,
810 IO_STATUS_BLOCK IOSB
;
811 PAFD_POLL_INFO PollInfo
;
815 ULONG PollBufferSize
;
820 LARGE_INTEGER Timeout
;
822 /* Find out how many sockets we have, and how large the buffer needs
825 HandleCount
= ( readfds
? readfds
->fd_count
: 0 ) +
826 ( writefds
? writefds
->fd_count
: 0 ) +
827 ( exceptfds
? exceptfds
->fd_count
: 0 );
829 if ( HandleCount
== 0 )
831 AFD_DbgPrint(MAX_TRACE
,("HandleCount: %u. Return SOCKET_ERROR\n",
833 if (lpErrno
) *lpErrno
= WSAEINVAL
;
837 PollBufferSize
= sizeof(*PollInfo
) + ((HandleCount
- 1) * sizeof(AFD_HANDLE
));
839 AFD_DbgPrint(MID_TRACE
,("HandleCount: %u BufferSize: %u\n",
840 HandleCount
, PollBufferSize
));
842 /* Convert Timeout to NT Format */
845 Timeout
.u
.LowPart
= -1;
846 Timeout
.u
.HighPart
= 0x7FFFFFFF;
847 AFD_DbgPrint(MAX_TRACE
,("Infinite timeout\n"));
851 Timeout
= RtlEnlargedIntegerMultiply
852 ((timeout
->tv_sec
* 1000) + (timeout
->tv_usec
/ 1000), -10000);
853 /* Negative timeouts are illegal. Since the kernel represents an
854 * incremental timeout as a negative number, we check for a positive
857 if (Timeout
.QuadPart
> 0)
859 if (lpErrno
) *lpErrno
= WSAEINVAL
;
862 AFD_DbgPrint(MAX_TRACE
,("Timeout: Orig %d.%06d kernel %d\n",
863 timeout
->tv_sec
, timeout
->tv_usec
,
867 Status
= NtCreateEvent(&SockEvent
,
873 if( !NT_SUCCESS(Status
) )
877 PollBuffer
= HeapAlloc(GlobalHeap
, 0, PollBufferSize
);
882 *lpErrno
= WSAEFAULT
;
887 PollInfo
= (PAFD_POLL_INFO
)PollBuffer
;
889 RtlZeroMemory( PollInfo
, PollBufferSize
);
891 /* Number of handles for AFD to Check */
892 PollInfo
->Exclusive
= FALSE
;
893 PollInfo
->Timeout
= Timeout
;
895 if (readfds
!= NULL
) {
896 for (i
= 0; i
< readfds
->fd_count
; i
++, j
++)
898 PollInfo
->Handles
[j
].Handle
= readfds
->fd_array
[i
];
899 PollInfo
->Handles
[j
].Events
= AFD_EVENT_RECEIVE
|
900 AFD_EVENT_DISCONNECT
|
906 if (writefds
!= NULL
)
908 for (i
= 0; i
< writefds
->fd_count
; i
++, j
++)
910 PollInfo
->Handles
[j
].Handle
= writefds
->fd_array
[i
];
911 PollInfo
->Handles
[j
].Events
= AFD_EVENT_SEND
| AFD_EVENT_CONNECT
;
914 if (exceptfds
!= NULL
)
916 for (i
= 0; i
< exceptfds
->fd_count
; i
++, j
++)
918 PollInfo
->Handles
[j
].Handle
= exceptfds
->fd_array
[i
];
919 PollInfo
->Handles
[j
].Events
= AFD_EVENT_OOB_RECEIVE
| AFD_EVENT_CONNECT_FAIL
;
923 PollInfo
->HandleCount
= j
;
924 PollBufferSize
= FIELD_OFFSET(AFD_POLL_INFO
, Handles
) + PollInfo
->HandleCount
* sizeof(AFD_HANDLE
);
927 Status
= NtDeviceIoControlFile((HANDLE
)PollInfo
->Handles
[0].Handle
,
938 AFD_DbgPrint(MID_TRACE
,("DeviceIoControlFile => %x\n", Status
));
940 /* Wait for Completition */
941 if (Status
== STATUS_PENDING
)
943 WaitForSingleObject(SockEvent
, INFINITE
);
944 Status
= IOSB
.Status
;
947 /* Clear the Structures */
955 /* Loop through return structure */
956 HandleCount
= PollInfo
->HandleCount
;
958 /* Return in FDSET Format */
959 for (i
= 0; i
< HandleCount
; i
++)
961 HandleCounted
= FALSE
;
964 switch (PollInfo
->Handles
[i
].Events
& x
)
966 case AFD_EVENT_RECEIVE
:
967 case AFD_EVENT_DISCONNECT
:
968 case AFD_EVENT_ABORT
:
969 case AFD_EVENT_ACCEPT
:
970 case AFD_EVENT_CLOSE
:
971 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
972 PollInfo
->Handles
[i
].Events
,
973 PollInfo
->Handles
[i
].Handle
));
977 HandleCounted
= TRUE
;
980 FD_SET(PollInfo
->Handles
[i
].Handle
, readfds
);
983 case AFD_EVENT_CONNECT
:
984 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
985 PollInfo
->Handles
[i
].Events
,
986 PollInfo
->Handles
[i
].Handle
));
990 HandleCounted
= TRUE
;
993 FD_SET(PollInfo
->Handles
[i
].Handle
, writefds
);
995 case AFD_EVENT_OOB_RECEIVE
:
996 case AFD_EVENT_CONNECT_FAIL
:
997 AFD_DbgPrint(MID_TRACE
,("Event %x on handle %x\n",
998 PollInfo
->Handles
[i
].Events
,
999 PollInfo
->Handles
[i
].Handle
));
1000 if (! HandleCounted
)
1003 HandleCounted
= TRUE
;
1006 FD_SET(PollInfo
->Handles
[i
].Handle
, exceptfds
);
1012 HeapFree( GlobalHeap
, 0, PollBuffer
);
1013 NtClose( SockEvent
);
1017 switch( IOSB
.Status
)
1019 case STATUS_SUCCESS
:
1020 case STATUS_TIMEOUT
:
1024 *lpErrno
= WSAEINVAL
;
1027 AFD_DbgPrint(MID_TRACE
,("*lpErrno = %x\n", *lpErrno
));
1030 AFD_DbgPrint(MID_TRACE
,("%d events\n", OutCount
));
1037 WSPAccept(SOCKET Handle
,
1038 struct sockaddr
*SocketAddress
,
1039 int *SocketAddressLength
,
1040 LPCONDITIONPROC lpfnCondition
,
1041 DWORD dwCallbackData
,
1044 IO_STATUS_BLOCK IOSB
;
1045 PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData
;
1046 AFD_ACCEPT_DATA AcceptData
;
1047 AFD_DEFER_ACCEPT_DATA DeferData
;
1048 AFD_PENDING_ACCEPT_DATA PendingAcceptData
;
1049 PSOCKET_INFORMATION Socket
= NULL
;
1051 struct fd_set ReadSet
;
1052 struct timeval Timeout
;
1053 PVOID PendingData
= NULL
;
1054 ULONG PendingDataLength
= 0;
1055 PVOID CalleeDataBuffer
;
1056 WSABUF CallerData
, CalleeID
, CallerID
, CalleeData
;
1057 PSOCKADDR RemoteAddress
= NULL
;
1060 WSAPROTOCOL_INFOW ProtocolInfo
;
1061 SOCKET AcceptSocket
;
1062 PSOCKET_INFORMATION AcceptSocketInfo
;
1063 UCHAR ReceiveBuffer
[0x1A];
1066 Status
= NtCreateEvent(&SockEvent
,
1072 if( !NT_SUCCESS(Status
) )
1074 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1075 return INVALID_SOCKET
;
1078 /* Dynamic Structure...ugh */
1079 ListenReceiveData
= (PAFD_RECEIVED_ACCEPT_DATA
)ReceiveBuffer
;
1081 /* Get the Socket Structure associate to this Socket*/
1082 Socket
= GetSocketStructure(Handle
);
1086 *lpErrno
= WSAENOTSOCK
;
1087 return INVALID_SOCKET
;
1090 /* If this is non-blocking, make sure there's something for us to accept */
1092 FD_SET(Socket
->Handle
, &ReadSet
);
1096 if (WSPSelect(0, &ReadSet
, NULL
, NULL
, &Timeout
, lpErrno
) == SOCKET_ERROR
)
1099 return INVALID_SOCKET
;
1102 if (ReadSet
.fd_array
[0] != Socket
->Handle
)
1105 *lpErrno
= WSAEWOULDBLOCK
;
1106 return INVALID_SOCKET
;
1110 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1115 IOCTL_AFD_WAIT_FOR_LISTEN
,
1119 0xA + sizeof(*ListenReceiveData
));
1121 /* Wait for return */
1122 if (Status
== STATUS_PENDING
)
1124 WaitForSingleObject(SockEvent
, INFINITE
);
1125 Status
= IOSB
.Status
;
1128 if (!NT_SUCCESS(Status
))
1130 NtClose( SockEvent
);
1131 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1132 return INVALID_SOCKET
;
1135 if (lpfnCondition
!= NULL
)
1137 if ((Socket
->SharedData
.ServiceFlags1
& XP1_CONNECT_DATA
) != 0)
1139 /* Find out how much data is pending */
1140 PendingAcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1141 PendingAcceptData
.ReturnSize
= TRUE
;
1144 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1149 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1151 sizeof(PendingAcceptData
),
1153 sizeof(PendingAcceptData
));
1155 /* Wait for return */
1156 if (Status
== STATUS_PENDING
)
1158 WaitForSingleObject(SockEvent
, INFINITE
);
1159 Status
= IOSB
.Status
;
1162 if (!NT_SUCCESS(Status
))
1164 NtClose( SockEvent
);
1165 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1166 return INVALID_SOCKET
;
1169 /* How much data to allocate */
1170 PendingDataLength
= IOSB
.Information
;
1172 if (PendingDataLength
)
1174 /* Allocate needed space */
1175 PendingData
= HeapAlloc(GlobalHeap
, 0, PendingDataLength
);
1178 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1179 return INVALID_SOCKET
;
1182 /* We want the data now */
1183 PendingAcceptData
.ReturnSize
= FALSE
;
1186 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1191 IOCTL_AFD_GET_PENDING_CONNECT_DATA
,
1193 sizeof(PendingAcceptData
),
1197 /* Wait for return */
1198 if (Status
== STATUS_PENDING
)
1200 WaitForSingleObject(SockEvent
, INFINITE
);
1201 Status
= IOSB
.Status
;
1204 if (!NT_SUCCESS(Status
))
1206 NtClose( SockEvent
);
1207 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1208 return INVALID_SOCKET
;
1213 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1215 /* I don't support this yet */
1218 /* Build Callee ID */
1219 CalleeID
.buf
= (PVOID
)Socket
->LocalAddress
;
1220 CalleeID
.len
= Socket
->SharedData
.SizeOfLocalAddress
;
1222 RemoteAddress
= HeapAlloc(GlobalHeap
, 0, sizeof(*RemoteAddress
));
1225 MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1226 return INVALID_SOCKET
;
1229 /* Set up Address in SOCKADDR Format */
1230 RtlCopyMemory (RemoteAddress
,
1231 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1232 sizeof(*RemoteAddress
));
1234 /* Build Caller ID */
1235 CallerID
.buf
= (PVOID
)RemoteAddress
;
1236 CallerID
.len
= sizeof(*RemoteAddress
);
1238 /* Build Caller Data */
1239 CallerData
.buf
= PendingData
;
1240 CallerData
.len
= PendingDataLength
;
1242 /* Check if socket supports Conditional Accept */
1243 if (Socket
->SharedData
.UseDelayedAcceptance
!= 0)
1245 /* Allocate Buffer for Callee Data */
1246 CalleeDataBuffer
= HeapAlloc(GlobalHeap
, 0, 4096);
1247 if (!CalleeDataBuffer
) {
1248 MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1249 return INVALID_SOCKET
;
1251 CalleeData
.buf
= CalleeDataBuffer
;
1252 CalleeData
.len
= 4096;
1261 /* Call the Condition Function */
1262 CallBack
= (lpfnCondition
)(&CallerID
,
1263 CallerData
.buf
== NULL
? NULL
: &CallerData
,
1267 CalleeData
.buf
== NULL
? NULL
: &CalleeData
,
1271 if (((CallBack
== CF_ACCEPT
) && GroupID
) != 0)
1273 /* TBD: Check for Validity */
1276 if (CallBack
== CF_ACCEPT
)
1278 if ((Socket
->SharedData
.ServiceFlags1
& XP1_QOS_SUPPORTED
) != 0)
1280 /* I don't support this yet */
1284 // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1289 /* Callback rejected. Build Defer Structure */
1290 DeferData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1291 DeferData
.RejectConnection
= (CallBack
== CF_REJECT
);
1294 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1299 IOCTL_AFD_DEFER_ACCEPT
,
1305 /* Wait for return */
1306 if (Status
== STATUS_PENDING
)
1308 WaitForSingleObject(SockEvent
, INFINITE
);
1309 Status
= IOSB
.Status
;
1312 NtClose( SockEvent
);
1314 if (!NT_SUCCESS(Status
))
1316 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1317 return INVALID_SOCKET
;
1320 if (CallBack
== CF_REJECT
)
1322 *lpErrno
= WSAECONNREFUSED
;
1323 return INVALID_SOCKET
;
1327 *lpErrno
= WSAECONNREFUSED
;
1328 return INVALID_SOCKET
;
1333 /* Create a new Socket */
1334 ProtocolInfo
.dwCatalogEntryId
= Socket
->SharedData
.CatalogEntryId
;
1335 ProtocolInfo
.dwServiceFlags1
= Socket
->SharedData
.ServiceFlags1
;
1336 ProtocolInfo
.dwProviderFlags
= Socket
->SharedData
.ProviderFlags
;
1338 AcceptSocket
= WSPSocket (Socket
->SharedData
.AddressFamily
,
1339 Socket
->SharedData
.SocketType
,
1340 Socket
->SharedData
.Protocol
,
1343 Socket
->SharedData
.CreateFlags
,
1345 if (AcceptSocket
== INVALID_SOCKET
)
1346 return INVALID_SOCKET
;
1348 /* Set up the Accept Structure */
1349 AcceptData
.ListenHandle
= (HANDLE
)AcceptSocket
;
1350 AcceptData
.SequenceNumber
= ListenReceiveData
->SequenceNumber
;
1352 /* Send IOCTL to Accept */
1353 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1364 /* Wait for return */
1365 if (Status
== STATUS_PENDING
)
1367 WaitForSingleObject(SockEvent
, INFINITE
);
1368 Status
= IOSB
.Status
;
1371 if (!NT_SUCCESS(Status
))
1374 WSPCloseSocket( AcceptSocket
, lpErrno
);
1375 MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1376 return INVALID_SOCKET
;
1379 AcceptSocketInfo
= GetSocketStructure(AcceptSocket
);
1380 if (!AcceptSocketInfo
)
1383 WSPCloseSocket( AcceptSocket
, lpErrno
);
1384 MsafdReturnWithErrno( STATUS_INVALID_CONNECTION
, lpErrno
, 0, NULL
);
1385 return INVALID_SOCKET
;
1388 AcceptSocketInfo
->SharedData
.State
= SocketConnected
;
1390 /* Return Address in SOCKADDR FORMAT */
1393 RtlCopyMemory (SocketAddress
,
1394 &ListenReceiveData
->Address
.Address
[0].AddressType
,
1395 sizeof(*RemoteAddress
));
1396 if( SocketAddressLength
)
1397 *SocketAddressLength
= ListenReceiveData
->Address
.Address
[0].AddressLength
;
1400 NtClose( SockEvent
);
1402 /* Re-enable Async Event */
1403 SockReenableAsyncSelectEvent(Socket
, FD_ACCEPT
);
1405 AFD_DbgPrint(MID_TRACE
,("Socket %x\n", AcceptSocket
));
1407 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_ACCEPT
))
1409 Status
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1411 Socket
->TdiAddressHandle
,
1412 Socket
->TdiConnectionHandle
,
1417 if (lpErrno
) *lpErrno
= Status
;
1418 return INVALID_SOCKET
;
1425 return AcceptSocket
;
1430 WSPConnect(SOCKET Handle
,
1431 const struct sockaddr
* SocketAddress
,
1432 int SocketAddressLength
,
1433 LPWSABUF lpCallerData
,
1434 LPWSABUF lpCalleeData
,
1439 IO_STATUS_BLOCK IOSB
;
1440 PAFD_CONNECT_INFO ConnectInfo
= NULL
;
1441 PSOCKET_INFORMATION Socket
;
1444 ULONG ConnectDataLength
;
1445 ULONG InConnectDataLength
;
1446 INT BindAddressLength
;
1447 PSOCKADDR BindAddress
;
1449 int SocketDataLength
;
1451 Status
= NtCreateEvent(&SockEvent
,
1457 if (!NT_SUCCESS(Status
))
1458 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1460 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1462 /* Get the Socket Structure associate to this Socket*/
1463 Socket
= GetSocketStructure(Handle
);
1467 if (lpErrno
) *lpErrno
= WSAENOTSOCK
;
1468 return SOCKET_ERROR
;
1472 if (Socket
->SharedData
.State
== SocketOpen
)
1474 /* Get the Wildcard Address */
1475 BindAddressLength
= Socket
->HelperData
->MaxWSAddressLength
;
1476 BindAddress
= HeapAlloc(GetProcessHeap(), 0, BindAddressLength
);
1480 return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES
, lpErrno
, 0, NULL
);
1482 Socket
->HelperData
->WSHGetWildcardSockaddr (Socket
->HelperContext
,
1484 &BindAddressLength
);
1486 if (WSPBind(Handle
, BindAddress
, BindAddressLength
, lpErrno
) == SOCKET_ERROR
)
1487 return SOCKET_ERROR
;
1490 /* Set the Connect Data */
1491 if (lpCallerData
!= NULL
)
1493 ConnectDataLength
= lpCallerData
->len
;
1494 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1499 IOCTL_AFD_SET_CONNECT_DATA
,
1504 /* Wait for return */
1505 if (Status
== STATUS_PENDING
)
1507 WaitForSingleObject(SockEvent
, INFINITE
);
1508 Status
= IOSB
.Status
;
1511 if (Status
!= STATUS_SUCCESS
)
1515 /* Calculate the size of SocketAddress->sa_data */
1516 SocketDataLength
= SocketAddressLength
- FIELD_OFFSET(struct sockaddr
, sa_data
);
1518 /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1519 ConnectInfo
= HeapAlloc(GetProcessHeap(), 0,
1520 FIELD_OFFSET(AFD_CONNECT_INFO
,
1521 RemoteAddress
.Address
[0].Address
[SocketDataLength
]));
1524 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1528 /* Set up Address in TDI Format */
1529 ConnectInfo
->RemoteAddress
.TAAddressCount
= 1;
1530 ConnectInfo
->RemoteAddress
.Address
[0].AddressLength
= SocketDataLength
;
1531 ConnectInfo
->RemoteAddress
.Address
[0].AddressType
= SocketAddress
->sa_family
;
1532 RtlCopyMemory(ConnectInfo
->RemoteAddress
.Address
[0].Address
,
1533 SocketAddress
->sa_data
,
1537 * Disable FD_WRITE and FD_CONNECT
1538 * The latter fixes a race condition where the FD_CONNECT is re-enabled
1539 * at the end of this function right after the Async Thread disables it.
1540 * This should only happen at the *next* WSPConnect
1542 if (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
)
1544 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
| FD_WRITE
;
1547 /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1548 if (lpCalleeData
!= NULL
)
1550 InConnectDataLength
= lpCalleeData
->len
;
1551 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1556 IOCTL_AFD_SET_CONNECT_DATA_SIZE
,
1557 &InConnectDataLength
,
1558 sizeof(InConnectDataLength
),
1562 /* Wait for return */
1563 if (Status
== STATUS_PENDING
)
1565 WaitForSingleObject(SockEvent
, INFINITE
);
1566 Status
= IOSB
.Status
;
1569 if (Status
!= STATUS_SUCCESS
)
1573 /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1574 ConnectInfo
->Root
= 0;
1575 ConnectInfo
->UseSAN
= FALSE
;
1576 ConnectInfo
->Unknown
= 0;
1578 /* FIXME: Handle Async Connect */
1579 if (Socket
->SharedData
.NonBlocking
)
1581 AFD_DbgPrint(MIN_TRACE
, ("Async Connect UNIMPLEMENTED!\n"));
1585 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1595 /* Wait for return */
1596 if (Status
== STATUS_PENDING
)
1598 WaitForSingleObject(SockEvent
, INFINITE
);
1599 Status
= IOSB
.Status
;
1602 if (Status
!= STATUS_SUCCESS
)
1605 Socket
->SharedData
.State
= SocketConnected
;
1606 Socket
->TdiConnectionHandle
= (HANDLE
)IOSB
.Information
;
1608 /* Get any pending connect data */
1609 if (lpCalleeData
!= NULL
)
1611 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1616 IOCTL_AFD_GET_CONNECT_DATA
,
1621 /* Wait for return */
1622 if (Status
== STATUS_PENDING
)
1624 WaitForSingleObject(SockEvent
, INFINITE
);
1625 Status
= IOSB
.Status
;
1629 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1632 if (ConnectInfo
) HeapFree(GetProcessHeap(), 0, ConnectInfo
);
1634 /* Re-enable Async Event */
1635 SockReenableAsyncSelectEvent(Socket
, FD_WRITE
);
1637 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
1638 SockReenableAsyncSelectEvent(Socket
, FD_CONNECT
);
1642 if (Status
== STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT
))
1644 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1646 Socket
->TdiAddressHandle
,
1647 Socket
->TdiConnectionHandle
,
1648 WSH_NOTIFY_CONNECT
);
1652 if (lpErrno
) *lpErrno
= Errno
;
1653 return SOCKET_ERROR
;
1656 else if (Status
!= STATUS_SUCCESS
&& (Socket
->HelperEvents
& WSH_NOTIFY_CONNECT_ERROR
))
1658 Errno
= Socket
->HelperData
->WSHNotify(Socket
->HelperContext
,
1660 Socket
->TdiAddressHandle
,
1661 Socket
->TdiConnectionHandle
,
1662 WSH_NOTIFY_CONNECT_ERROR
);
1666 if (lpErrno
) *lpErrno
= Errno
;
1667 return SOCKET_ERROR
;
1671 return MsafdReturnWithErrno(Status
, lpErrno
, 0, NULL
);
1675 WSPShutdown(SOCKET Handle
,
1680 IO_STATUS_BLOCK IOSB
;
1681 AFD_DISCONNECT_INFO DisconnectInfo
;
1682 PSOCKET_INFORMATION Socket
= NULL
;
1686 Status
= NtCreateEvent(&SockEvent
,
1692 if( !NT_SUCCESS(Status
) )
1695 AFD_DbgPrint(MID_TRACE
,("Called\n"));
1697 /* Get the Socket Structure associate to this Socket*/
1698 Socket
= GetSocketStructure(Handle
);
1702 *lpErrno
= WSAENOTSOCK
;
1703 return SOCKET_ERROR
;
1706 /* Set AFD Disconnect Type */
1710 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
;
1711 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1714 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_SEND
;
1715 Socket
->SharedData
.SendShutdown
= TRUE
;
1718 DisconnectInfo
.DisconnectType
= AFD_DISCONNECT_RECV
| AFD_DISCONNECT_SEND
;
1719 Socket
->SharedData
.ReceiveShutdown
= TRUE
;
1720 Socket
->SharedData
.SendShutdown
= TRUE
;
1724 DisconnectInfo
.Timeout
= RtlConvertLongToLargeInteger(-1000000);
1727 Status
= NtDeviceIoControlFile((HANDLE
)Handle
,
1732 IOCTL_AFD_DISCONNECT
,
1734 sizeof(DisconnectInfo
),
1738 /* Wait for return */
1739 if (Status
== STATUS_PENDING
)
1741 WaitForSingleObject(SockEvent
, INFINITE
);
1742 Status
= IOSB
.Status
;
1745 AFD_DbgPrint(MID_TRACE
,("Ending\n"));
1747 NtClose( SockEvent
);
1749 return MsafdReturnWithErrno( Status
, lpErrno
, 0, NULL
);
1755 WSPGetSockName(IN SOCKET Handle
,
1756 OUT LPSOCKADDR Name
,
1757 IN OUT LPINT NameLength
,
1760 IO_STATUS_BLOCK IOSB
;
1761 ULONG TdiAddressSize
;
1762 PTDI_ADDRESS_INFO TdiAddress
;
1763 PTRANSPORT_ADDRESS SocketAddress
;
1764 PSOCKET_INFORMATION Socket
= NULL
;
1768 Status
= NtCreateEvent(&SockEvent
,
1774 if( !NT_SUCCESS(Status
) )
1775 return SOCKET_ERROR
;
1777 /* Get the Socket Structure associate to this Socket*/
1778 Socket
= GetSocketStructure(Handle
);
1782 *lpErrno
= WSAENOTSOCK
;
1783 return SOCKET_ERROR
;
1786 if (!Name
|| !NameLength
)
1789 *lpErrno
= WSAEFAULT
;
1790 return SOCKET_ERROR
;
1793 /* Allocate a buffer for the address */
1795 sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfLocalAddress
;
1796 TdiAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1798 if ( TdiAddress
== NULL
)
1800 NtClose( SockEvent
);
1801 *lpErrno
= WSAENOBUFS
;
1802 return SOCKET_ERROR
;
1805 SocketAddress
= &TdiAddress
->Address
;
1808 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1813 IOCTL_AFD_GET_SOCK_NAME
,
1819 /* Wait for return */
1820 if (Status
== STATUS_PENDING
)
1822 WaitForSingleObject(SockEvent
, INFINITE
);
1823 Status
= IOSB
.Status
;
1826 NtClose( SockEvent
);
1828 if (NT_SUCCESS(Status
))
1830 if (*NameLength
>= Socket
->SharedData
.SizeOfLocalAddress
)
1832 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1833 RtlCopyMemory (Name
->sa_data
,
1834 SocketAddress
->Address
[0].Address
,
1835 SocketAddress
->Address
[0].AddressLength
);
1836 *NameLength
= Socket
->SharedData
.SizeOfLocalAddress
;
1837 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1838 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1839 ((struct sockaddr_in
*)Name
)->sin_port
));
1840 HeapFree(GlobalHeap
, 0, TdiAddress
);
1845 HeapFree(GlobalHeap
, 0, TdiAddress
);
1846 *lpErrno
= WSAEFAULT
;
1847 return SOCKET_ERROR
;
1851 HeapFree(GlobalHeap
, 0, TdiAddress
);
1853 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1859 WSPGetPeerName(IN SOCKET s
,
1860 OUT LPSOCKADDR Name
,
1861 IN OUT LPINT NameLength
,
1864 IO_STATUS_BLOCK IOSB
;
1865 ULONG TdiAddressSize
;
1866 PTRANSPORT_ADDRESS SocketAddress
;
1867 PSOCKET_INFORMATION Socket
= NULL
;
1871 Status
= NtCreateEvent(&SockEvent
,
1877 if( !NT_SUCCESS(Status
) )
1878 return SOCKET_ERROR
;
1880 /* Get the Socket Structure associate to this Socket*/
1881 Socket
= GetSocketStructure(s
);
1885 *lpErrno
= WSAENOTSOCK
;
1886 return SOCKET_ERROR
;
1889 if (Socket
->SharedData
.State
!= SocketConnected
)
1892 *lpErrno
= WSAENOTCONN
;
1893 return SOCKET_ERROR
;
1896 if (!Name
|| !NameLength
)
1899 *lpErrno
= WSAEFAULT
;
1900 return SOCKET_ERROR
;
1903 /* Allocate a buffer for the address */
1904 TdiAddressSize
= sizeof(TRANSPORT_ADDRESS
) + Socket
->SharedData
.SizeOfRemoteAddress
;
1905 SocketAddress
= HeapAlloc(GlobalHeap
, 0, TdiAddressSize
);
1907 if ( SocketAddress
== NULL
)
1909 NtClose( SockEvent
);
1910 *lpErrno
= WSAENOBUFS
;
1911 return SOCKET_ERROR
;
1915 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
1920 IOCTL_AFD_GET_PEER_NAME
,
1926 /* Wait for return */
1927 if (Status
== STATUS_PENDING
)
1929 WaitForSingleObject(SockEvent
, INFINITE
);
1930 Status
= IOSB
.Status
;
1933 NtClose( SockEvent
);
1935 if (NT_SUCCESS(Status
))
1937 if (*NameLength
>= Socket
->SharedData
.SizeOfRemoteAddress
)
1939 Name
->sa_family
= SocketAddress
->Address
[0].AddressType
;
1940 RtlCopyMemory (Name
->sa_data
,
1941 SocketAddress
->Address
[0].Address
,
1942 SocketAddress
->Address
[0].AddressLength
);
1943 *NameLength
= Socket
->SharedData
.SizeOfRemoteAddress
;
1944 AFD_DbgPrint (MID_TRACE
, ("NameLength %d Address: %x Port %x\n",
1945 *NameLength
, ((struct sockaddr_in
*)Name
)->sin_addr
.s_addr
,
1946 ((struct sockaddr_in
*)Name
)->sin_port
));
1947 HeapFree(GlobalHeap
, 0, SocketAddress
);
1952 HeapFree(GlobalHeap
, 0, SocketAddress
);
1953 *lpErrno
= WSAEFAULT
;
1954 return SOCKET_ERROR
;
1958 HeapFree(GlobalHeap
, 0, SocketAddress
);
1960 return MsafdReturnWithErrno ( Status
, lpErrno
, 0, NULL
);
1965 WSPIoctl(IN SOCKET Handle
,
1966 IN DWORD dwIoControlCode
,
1967 IN LPVOID lpvInBuffer
,
1968 IN DWORD cbInBuffer
,
1969 OUT LPVOID lpvOutBuffer
,
1970 IN DWORD cbOutBuffer
,
1971 OUT LPDWORD lpcbBytesReturned
,
1972 IN LPWSAOVERLAPPED lpOverlapped
,
1973 IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
,
1974 IN LPWSATHREADID lpThreadId
,
1977 PSOCKET_INFORMATION Socket
= NULL
;
1978 BOOLEAN NeedsCompletion
;
1979 BOOLEAN NonBlocking
;
1981 if (!lpcbBytesReturned
)
1983 *lpErrno
= WSAEFAULT
;
1984 return SOCKET_ERROR
;
1987 /* Get the Socket Structure associate to this Socket*/
1988 Socket
= GetSocketStructure(Handle
);
1991 *lpErrno
= WSAENOTSOCK
;
1992 return SOCKET_ERROR
;
1995 *lpcbBytesReturned
= 0;
1997 switch( dwIoControlCode
)
2000 if( cbInBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvInBuffer
) )
2002 *lpErrno
= WSAEFAULT
;
2003 return SOCKET_ERROR
;
2005 NonBlocking
= *((PULONG
)lpvInBuffer
) ? TRUE
: FALSE
;
2006 Socket
->SharedData
.NonBlocking
= NonBlocking
? 1 : 0;
2007 *lpErrno
= SetSocketInformation(Socket
, AFD_INFO_BLOCKING_MODE
, &NonBlocking
, NULL
, NULL
);
2008 if (*lpErrno
!= NO_ERROR
)
2009 return SOCKET_ERROR
;
2013 if( cbOutBuffer
< sizeof(INT
) || IS_INTRESOURCE(lpvOutBuffer
) )
2015 *lpErrno
= WSAEFAULT
;
2016 return SOCKET_ERROR
;
2018 *lpErrno
= GetSocketInformation(Socket
, AFD_INFO_RECEIVE_CONTENT_SIZE
, NULL
, (PULONG
)lpvOutBuffer
, NULL
);
2019 if (*lpErrno
!= NO_ERROR
)
2020 return SOCKET_ERROR
;
2023 *lpcbBytesReturned
= sizeof(ULONG
);
2027 if (cbOutBuffer
< sizeof(BOOL
) || IS_INTRESOURCE(lpvOutBuffer
))
2029 *lpErrno
= WSAEFAULT
;
2030 return SOCKET_ERROR
;
2033 /* FIXME: Return false for now */
2034 *(BOOL
*)lpvOutBuffer
= FALSE
;
2036 *lpcbBytesReturned
= sizeof(BOOL
);
2037 *lpErrno
= NO_ERROR
;
2039 case SIO_GET_EXTENSION_FUNCTION_POINTER
:
2040 *lpErrno
= WSAEINVAL
;
2041 return SOCKET_ERROR
;
2043 *lpErrno
= Socket
->HelperData
->WSHIoctl(Socket
->HelperContext
,
2045 Socket
->TdiAddressHandle
,
2046 Socket
->TdiConnectionHandle
,
2054 lpCompletionRoutine
,
2055 (LPBOOL
)&NeedsCompletion
);
2057 if (*lpErrno
!= NO_ERROR
)
2058 return SOCKET_ERROR
;
2067 WSPGetSockOpt(IN SOCKET Handle
,
2070 OUT CHAR FAR
* OptionValue
,
2071 IN OUT LPINT OptionLength
,
2074 PSOCKET_INFORMATION Socket
= NULL
;
2080 /* Get the Socket Structure associate to this Socket*/
2081 Socket
= GetSocketStructure(Handle
);
2084 *lpErrno
= WSAENOTSOCK
;
2085 return SOCKET_ERROR
;
2088 AFD_DbgPrint(MID_TRACE
, ("Called\n"));
2096 Buffer
= &Socket
->SharedData
.SocketType
;
2097 BufferSize
= sizeof(INT
);
2101 Buffer
= &Socket
->SharedData
.SizeOfRecvBuffer
;
2102 BufferSize
= sizeof(INT
);
2106 Buffer
= &Socket
->SharedData
.SizeOfSendBuffer
;
2107 BufferSize
= sizeof(INT
);
2111 BoolBuffer
= Socket
->SharedData
.Listening
;
2112 Buffer
= &BoolBuffer
;
2113 BufferSize
= sizeof(BOOL
);
2117 BoolBuffer
= Socket
->SharedData
.Broadcast
;
2118 Buffer
= &BoolBuffer
;
2119 BufferSize
= sizeof(BOOL
);
2123 BoolBuffer
= Socket
->SharedData
.Debug
;
2124 Buffer
= &BoolBuffer
;
2125 BufferSize
= sizeof(BOOL
);
2129 BoolBuffer
= (Socket
->SharedData
.LingerData
.l_onoff
== 0);
2130 Buffer
= &BoolBuffer
;
2131 BufferSize
= sizeof(BOOL
);
2135 Buffer
= &Socket
->SharedData
.LingerData
;
2136 BufferSize
= sizeof(struct linger
);
2140 BoolBuffer
= (Socket
->SharedData
.OobInline
!= 0);
2141 Buffer
= &BoolBuffer
;
2142 BufferSize
= sizeof(BOOL
);
2147 /* These guys go directly to the helper */
2150 case SO_CONDITIONAL_ACCEPT
:
2151 BoolBuffer
= (Socket
->SharedData
.UseDelayedAcceptance
!= 0);
2152 Buffer
= &BoolBuffer
;
2153 BufferSize
= sizeof(BOOL
);
2157 BoolBuffer
= (Socket
->SharedData
.ReuseAddresses
!= 0);
2158 Buffer
= &BoolBuffer
;
2159 BufferSize
= sizeof(BOOL
);
2162 case SO_EXCLUSIVEADDRUSE
:
2163 BoolBuffer
= (Socket
->SharedData
.ExclusiveAddressUse
!= 0);
2164 Buffer
= &BoolBuffer
;
2165 BufferSize
= sizeof(BOOL
);
2169 /* HACK: This needs to be properly tracked */
2171 DbgPrint("MSAFD: Hacked SO_ERROR returning error %d\n", IntBuffer
);
2173 Buffer
= &IntBuffer
;
2174 BufferSize
= sizeof(INT
);
2178 case SO_GROUP_PRIORITY
:
2179 case SO_MAX_MSG_SIZE
:
2180 case SO_PROTOCOL_INFO
:
2183 DbgPrint("MSAFD: Get unknown optname %x\n", OptionName
);
2184 *lpErrno
= WSAENOPROTOOPT
;
2185 return SOCKET_ERROR
;
2188 if (*OptionLength
< BufferSize
)
2190 *lpErrno
= WSAEFAULT
;
2191 *OptionLength
= BufferSize
;
2192 return SOCKET_ERROR
;
2194 RtlCopyMemory(OptionValue
, Buffer
, BufferSize
);
2203 *lpErrno
= Socket
->HelperData
->WSHGetSocketInformation(Socket
->HelperContext
,
2205 Socket
->TdiAddressHandle
,
2206 Socket
->TdiConnectionHandle
,
2210 (LPINT
)OptionLength
);
2211 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2220 IN CONST CHAR FAR
* optval
,
2224 PSOCKET_INFORMATION Socket
;
2226 /* Get the Socket Structure associate to this Socket*/
2227 Socket
= GetSocketStructure(s
);
2230 *lpErrno
= WSAENOTSOCK
;
2231 return SOCKET_ERROR
;
2235 /* FIXME: We should handle some more cases here */
2236 if (level
== SOL_SOCKET
)
2241 if (optlen
< sizeof(BOOL
))
2243 *lpErrno
= WSAEFAULT
;
2244 return SOCKET_ERROR
;
2246 Socket
->SharedData
.Broadcast
= (*optval
!= 0) ? 1 : 0;
2250 if (optlen
< sizeof(BOOL
))
2252 *lpErrno
= WSAEFAULT
;
2253 return SOCKET_ERROR
;
2255 Socket
->SharedData
.LingerData
.l_onoff
= (*optval
!= 0) ? 0 : 1;
2259 if (optlen
< sizeof(BOOL
))
2261 *lpErrno
= WSAEFAULT
;
2262 return SOCKET_ERROR
;
2264 Socket
->SharedData
.ReuseAddresses
= (*optval
!= 0) ? 1 : 0;
2267 case SO_EXCLUSIVEADDRUSE
:
2268 if (optlen
< sizeof(BOOL
))
2270 *lpErrno
= WSAEFAULT
;
2271 return SOCKET_ERROR
;
2273 Socket
->SharedData
.ExclusiveAddressUse
= (*optval
!= 0) ? 1 : 0;
2277 if (optlen
< sizeof(struct linger
))
2279 *lpErrno
= WSAEFAULT
;
2280 return SOCKET_ERROR
;
2282 RtlCopyMemory(&Socket
->SharedData
.LingerData
,
2284 sizeof(struct linger
));
2288 if (optlen
< sizeof(DWORD
))
2290 *lpErrno
= WSAEFAULT
;
2291 return SOCKET_ERROR
;
2294 /* TODO: The total per-socket buffer space reserved for sends */
2295 AFD_DbgPrint(MIN_TRACE
,("Setting send buf to %x is not implemented yet\n", optval
));
2299 if (optlen
< sizeof(DWORD
))
2301 *lpErrno
= WSAEFAULT
;
2302 return SOCKET_ERROR
;
2305 RtlCopyMemory(&Socket
->SharedData
.SendTimeout
,
2311 if (optlen
< sizeof(DWORD
))
2313 *lpErrno
= WSAEFAULT
;
2314 return SOCKET_ERROR
;
2317 RtlCopyMemory(&Socket
->SharedData
.RecvTimeout
,
2324 /* These go directly to the helper dll */
2328 /* Obviously this is a hack */
2329 DbgPrint("MSAFD: Set unknown optname %x\n", optname
);
2335 *lpErrno
= Socket
->HelperData
->WSHSetSocketInformation(Socket
->HelperContext
,
2337 Socket
->TdiAddressHandle
,
2338 Socket
->TdiConnectionHandle
,
2343 return (*lpErrno
== 0) ? 0 : SOCKET_ERROR
;
2347 * FUNCTION: Initialize service provider for a client
2349 * wVersionRequested = Highest WinSock SPI version that the caller can use
2350 * lpWSPData = Address of WSPDATA structure to initialize
2351 * lpProtocolInfo = Pointer to structure that defines the desired protocol
2352 * UpcallTable = Pointer to upcall table of the WinSock DLL
2353 * lpProcTable = Address of procedure table to initialize
2355 * Status of operation
2359 WSPStartup(IN WORD wVersionRequested
,
2360 OUT LPWSPDATA lpWSPData
,
2361 IN LPWSAPROTOCOL_INFOW lpProtocolInfo
,
2362 IN WSPUPCALLTABLE UpcallTable
,
2363 OUT LPWSPPROC_TABLE lpProcTable
)
2368 AFD_DbgPrint(MAX_TRACE
, ("wVersionRequested (0x%X) \n", wVersionRequested
));
2370 Upcalls
= UpcallTable
;
2372 if (Status
== NO_ERROR
)
2374 lpProcTable
->lpWSPAccept
= WSPAccept
;
2375 lpProcTable
->lpWSPAddressToString
= WSPAddressToString
;
2376 lpProcTable
->lpWSPAsyncSelect
= WSPAsyncSelect
;
2377 lpProcTable
->lpWSPBind
= WSPBind
;
2378 lpProcTable
->lpWSPCancelBlockingCall
= WSPCancelBlockingCall
;
2379 lpProcTable
->lpWSPCleanup
= WSPCleanup
;
2380 lpProcTable
->lpWSPCloseSocket
= WSPCloseSocket
;
2381 lpProcTable
->lpWSPConnect
= WSPConnect
;
2382 lpProcTable
->lpWSPDuplicateSocket
= WSPDuplicateSocket
;
2383 lpProcTable
->lpWSPEnumNetworkEvents
= WSPEnumNetworkEvents
;
2384 lpProcTable
->lpWSPEventSelect
= WSPEventSelect
;
2385 lpProcTable
->lpWSPGetOverlappedResult
= WSPGetOverlappedResult
;
2386 lpProcTable
->lpWSPGetPeerName
= WSPGetPeerName
;
2387 lpProcTable
->lpWSPGetSockName
= WSPGetSockName
;
2388 lpProcTable
->lpWSPGetSockOpt
= WSPGetSockOpt
;
2389 lpProcTable
->lpWSPGetQOSByName
= WSPGetQOSByName
;
2390 lpProcTable
->lpWSPIoctl
= WSPIoctl
;
2391 lpProcTable
->lpWSPJoinLeaf
= WSPJoinLeaf
;
2392 lpProcTable
->lpWSPListen
= WSPListen
;
2393 lpProcTable
->lpWSPRecv
= WSPRecv
;
2394 lpProcTable
->lpWSPRecvDisconnect
= WSPRecvDisconnect
;
2395 lpProcTable
->lpWSPRecvFrom
= WSPRecvFrom
;
2396 lpProcTable
->lpWSPSelect
= WSPSelect
;
2397 lpProcTable
->lpWSPSend
= WSPSend
;
2398 lpProcTable
->lpWSPSendDisconnect
= WSPSendDisconnect
;
2399 lpProcTable
->lpWSPSendTo
= WSPSendTo
;
2400 lpProcTable
->lpWSPSetSockOpt
= WSPSetSockOpt
;
2401 lpProcTable
->lpWSPShutdown
= WSPShutdown
;
2402 lpProcTable
->lpWSPSocket
= WSPSocket
;
2403 lpProcTable
->lpWSPStringToAddress
= WSPStringToAddress
;
2404 lpWSPData
->wVersion
= MAKEWORD(2, 2);
2405 lpWSPData
->wHighVersion
= MAKEWORD(2, 2);
2408 AFD_DbgPrint(MAX_TRACE
, ("Status (%d).\n", Status
));
2415 * FUNCTION: Cleans up service provider for a client
2417 * lpErrno = Address of buffer for error information
2419 * 0 if successful, or SOCKET_ERROR if not
2423 WSPCleanup(OUT LPINT lpErrno
)
2426 AFD_DbgPrint(MAX_TRACE
, ("\n"));
2427 AFD_DbgPrint(MAX_TRACE
, ("Leaving.\n"));
2428 *lpErrno
= NO_ERROR
;
2436 GetSocketInformation(PSOCKET_INFORMATION Socket
,
2437 ULONG AfdInformationClass
,
2438 PBOOLEAN Boolean OPTIONAL
,
2439 PULONG Ulong OPTIONAL
,
2440 PLARGE_INTEGER LargeInteger OPTIONAL
)
2442 IO_STATUS_BLOCK IOSB
;
2447 Status
= NtCreateEvent(&SockEvent
,
2453 if( !NT_SUCCESS(Status
) )
2456 /* Set Info Class */
2457 InfoData
.InformationClass
= AfdInformationClass
;
2460 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2471 /* Wait for return */
2472 if (Status
== STATUS_PENDING
)
2474 WaitForSingleObject(SockEvent
, INFINITE
);
2475 Status
= IOSB
.Status
;
2478 if (Status
!= STATUS_SUCCESS
)
2481 /* Return Information */
2484 *Ulong
= InfoData
.Information
.Ulong
;
2486 if (LargeInteger
!= NULL
)
2488 *LargeInteger
= InfoData
.Information
.LargeInteger
;
2490 if (Boolean
!= NULL
)
2492 *Boolean
= InfoData
.Information
.Boolean
;
2495 NtClose( SockEvent
);
2503 SetSocketInformation(PSOCKET_INFORMATION Socket
,
2504 ULONG AfdInformationClass
,
2505 PBOOLEAN Boolean OPTIONAL
,
2506 PULONG Ulong OPTIONAL
,
2507 PLARGE_INTEGER LargeInteger OPTIONAL
)
2509 IO_STATUS_BLOCK IOSB
;
2514 Status
= NtCreateEvent(&SockEvent
,
2520 if( !NT_SUCCESS(Status
) )
2523 /* Set Info Class */
2524 InfoData
.InformationClass
= AfdInformationClass
;
2526 /* Set Information */
2529 InfoData
.Information
.Ulong
= *Ulong
;
2531 if (LargeInteger
!= NULL
)
2533 InfoData
.Information
.LargeInteger
= *LargeInteger
;
2535 if (Boolean
!= NULL
)
2537 InfoData
.Information
.Boolean
= *Boolean
;
2541 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2552 /* Wait for return */
2553 if (Status
== STATUS_PENDING
)
2555 WaitForSingleObject(SockEvent
, INFINITE
);
2556 Status
= IOSB
.Status
;
2559 NtClose( SockEvent
);
2561 return Status
== STATUS_SUCCESS
? 0 : -1;
2566 GetSocketStructure(SOCKET Handle
)
2568 PSOCKET_INFORMATION CurrentSocket
;
2570 EnterCriticalSection(&SocketListLock
);
2572 CurrentSocket
= SocketListHead
;
2573 while (CurrentSocket
)
2575 if (CurrentSocket
->Handle
== Handle
)
2577 LeaveCriticalSection(&SocketListLock
);
2578 return CurrentSocket
;
2581 CurrentSocket
= CurrentSocket
->NextSocket
;
2584 LeaveCriticalSection(&SocketListLock
);
2589 int CreateContext(PSOCKET_INFORMATION Socket
)
2591 IO_STATUS_BLOCK IOSB
;
2592 SOCKET_CONTEXT ContextData
;
2596 Status
= NtCreateEvent(&SockEvent
,
2602 if( !NT_SUCCESS(Status
) )
2605 /* Create Context */
2606 ContextData
.SharedData
= Socket
->SharedData
;
2607 ContextData
.SizeOfHelperData
= 0;
2608 RtlCopyMemory (&ContextData
.LocalAddress
,
2609 Socket
->LocalAddress
,
2610 Socket
->SharedData
.SizeOfLocalAddress
);
2611 RtlCopyMemory (&ContextData
.RemoteAddress
,
2612 Socket
->RemoteAddress
,
2613 Socket
->SharedData
.SizeOfRemoteAddress
);
2616 Status
= NtDeviceIoControlFile((HANDLE
)Socket
->Handle
,
2621 IOCTL_AFD_SET_CONTEXT
,
2623 sizeof(ContextData
),
2627 /* Wait for Completition */
2628 if (Status
== STATUS_PENDING
)
2630 WaitForSingleObject(SockEvent
, INFINITE
);
2631 Status
= IOSB
.Status
;
2634 NtClose( SockEvent
);
2636 return Status
== STATUS_SUCCESS
? 0 : -1;
2639 BOOLEAN
SockCreateOrReferenceAsyncThread(VOID
)
2641 HANDLE hAsyncThread
;
2642 DWORD AsyncThreadId
;
2644 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2647 /* Check if the Thread Already Exists */
2648 if (SockAsyncThreadRefCount
)
2650 ASSERT(SockAsyncCompletionPort
);
2654 /* Create the Completion Port */
2655 if (!SockAsyncCompletionPort
)
2657 Status
= NtCreateIoCompletion(&SockAsyncCompletionPort
,
2658 IO_COMPLETION_ALL_ACCESS
,
2660 2); // Allow 2 threads only
2661 if (!NT_SUCCESS(Status
))
2663 AFD_DbgPrint(MID_TRACE
,("Failed to create completion port\n"));
2666 /* Protect Handle */
2667 HandleFlags
.ProtectFromClose
= TRUE
;
2668 HandleFlags
.Inherit
= FALSE
;
2669 Status
= NtSetInformationObject(SockAsyncCompletionPort
,
2670 ObjectHandleFlagInformation
,
2672 sizeof(HandleFlags
));
2675 /* Create the Async Event */
2676 Status
= NtCreateEvent(&AsyncEvent
,
2682 /* Create the Async Thread */
2683 hAsyncThread
= CreateThread(NULL
,
2685 (LPTHREAD_START_ROUTINE
)SockAsyncThread
,
2690 /* Close the Handle */
2691 NtClose(hAsyncThread
);
2693 /* Increase the Reference Count */
2694 SockAsyncThreadRefCount
++;
2698 int SockAsyncThread(PVOID ThreadParam
)
2701 PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine
;
2702 IO_STATUS_BLOCK IOSB
;
2705 /* Make the Thread Higher Priority */
2706 SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL
);
2708 /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
2711 Status
= NtRemoveIoCompletion (SockAsyncCompletionPort
,
2712 (PVOID
*)&AsyncCompletionRoutine
,
2716 /* Call the Async Function */
2717 if (NT_SUCCESS(Status
))
2719 (*AsyncCompletionRoutine
)(AsyncContext
, &IOSB
);
2723 /* It Failed, sleep for a second */
2726 } while ((Status
!= STATUS_TIMEOUT
));
2728 /* The Thread has Ended */
2732 BOOLEAN
SockGetAsyncSelectHelperAfdHandle(VOID
)
2734 UNICODE_STRING AfdHelper
;
2735 OBJECT_ATTRIBUTES ObjectAttributes
;
2736 IO_STATUS_BLOCK IoSb
;
2737 FILE_COMPLETION_INFORMATION CompletionInfo
;
2738 OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags
;
2740 /* First, make sure we're not already intialized */
2741 if (SockAsyncHelperAfdHandle
)
2746 /* Set up Handle Name and Object */
2747 RtlInitUnicodeString(&AfdHelper
, L
"\\Device\\Afd\\AsyncSelectHlp" );
2748 InitializeObjectAttributes(&ObjectAttributes
,
2750 OBJ_INHERIT
| OBJ_CASE_INSENSITIVE
,
2754 /* Open the Handle to AFD */
2755 NtCreateFile(&SockAsyncHelperAfdHandle
,
2756 GENERIC_READ
| GENERIC_WRITE
| SYNCHRONIZE
,
2761 FILE_SHARE_READ
| FILE_SHARE_WRITE
,
2768 * Now Set up the Completion Port Information
2769 * This means that whenever a Poll is finished, the routine will be executed
2771 CompletionInfo
.Port
= SockAsyncCompletionPort
;
2772 CompletionInfo
.Key
= SockAsyncSelectCompletionRoutine
;
2773 NtSetInformationFile(SockAsyncHelperAfdHandle
,
2776 sizeof(CompletionInfo
),
2777 FileCompletionInformation
);
2780 /* Protect the Handle */
2781 HandleFlags
.ProtectFromClose
= TRUE
;
2782 HandleFlags
.Inherit
= FALSE
;
2783 NtSetInformationObject(SockAsyncCompletionPort
,
2784 ObjectHandleFlagInformation
,
2786 sizeof(HandleFlags
));
2789 /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
2790 SockAsyncSelectCalled
= TRUE
;
2794 VOID
SockAsyncSelectCompletionRoutine(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
2797 PASYNC_DATA AsyncData
= Context
;
2798 PSOCKET_INFORMATION Socket
;
2801 /* Get the Socket */
2802 Socket
= AsyncData
->ParentSocket
;
2804 /* Check if the Sequence Number Changed behind our back */
2805 if (AsyncData
->SequenceNumber
!= Socket
->SharedData
.SequenceNumber
)
2810 /* Check we were manually called b/c of a failure */
2811 if (!NT_SUCCESS(IoStatusBlock
->Status
))
2813 /* FIXME: Perform Upcall */
2817 for (x
= 1; x
; x
<<=1)
2819 switch (AsyncData
->AsyncSelectInfo
.Handles
[0].Events
& x
)
2821 case AFD_EVENT_RECEIVE
:
2822 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_READ
) &&
2823 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_READ
))
2825 /* Make the Notifcation */
2826 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2827 Socket
->SharedData
.wMsg
,
2829 WSAMAKESELECTREPLY(FD_READ
, 0));
2830 /* Disable this event until the next read(); */
2831 Socket
->SharedData
.AsyncDisabledEvents
|= FD_READ
;
2835 case AFD_EVENT_OOB_RECEIVE
:
2836 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_OOB
) &&
2837 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_OOB
))
2839 /* Make the Notifcation */
2840 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2841 Socket
->SharedData
.wMsg
,
2843 WSAMAKESELECTREPLY(FD_OOB
, 0));
2844 /* Disable this event until the next read(); */
2845 Socket
->SharedData
.AsyncDisabledEvents
|= FD_OOB
;
2849 case AFD_EVENT_SEND
:
2850 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_WRITE
) &&
2851 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_WRITE
))
2853 /* Make the Notifcation */
2854 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2855 Socket
->SharedData
.wMsg
,
2857 WSAMAKESELECTREPLY(FD_WRITE
, 0));
2858 /* Disable this event until the next write(); */
2859 Socket
->SharedData
.AsyncDisabledEvents
|= FD_WRITE
;
2863 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2864 case AFD_EVENT_CONNECT
:
2865 case AFD_EVENT_CONNECT_FAIL
:
2866 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CONNECT
) &&
2867 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CONNECT
))
2869 /* Make the Notifcation */
2870 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2871 Socket
->SharedData
.wMsg
,
2873 WSAMAKESELECTREPLY(FD_CONNECT
, 0));
2874 /* Disable this event forever; */
2875 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CONNECT
;
2879 case AFD_EVENT_ACCEPT
:
2880 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_ACCEPT
) &&
2881 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_ACCEPT
))
2883 /* Make the Notifcation */
2884 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2885 Socket
->SharedData
.wMsg
,
2887 WSAMAKESELECTREPLY(FD_ACCEPT
, 0));
2888 /* Disable this event until the next accept(); */
2889 Socket
->SharedData
.AsyncDisabledEvents
|= FD_ACCEPT
;
2893 case AFD_EVENT_DISCONNECT
:
2894 case AFD_EVENT_ABORT
:
2895 case AFD_EVENT_CLOSE
:
2896 if (0 != (Socket
->SharedData
.AsyncEvents
& FD_CLOSE
) &&
2897 0 == (Socket
->SharedData
.AsyncDisabledEvents
& FD_CLOSE
))
2899 /* Make the Notifcation */
2900 (Upcalls
.lpWPUPostMessage
)(Socket
->SharedData
.hWnd
,
2901 Socket
->SharedData
.wMsg
,
2903 WSAMAKESELECTREPLY(FD_CLOSE
, 0));
2904 /* Disable this event forever; */
2905 Socket
->SharedData
.AsyncDisabledEvents
|= FD_CLOSE
;
2908 /* FIXME: Support QOS */
2912 /* Check if there are any events left for us to check */
2913 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
2919 SockProcessAsyncSelect(Socket
, AsyncData
);
2923 VOID
SockProcessAsyncSelect(PSOCKET_INFORMATION Socket
, PASYNC_DATA AsyncData
)
2926 ULONG lNetworkEvents
;
2929 /* Set up the Async Data Event Info */
2930 AsyncData
->AsyncSelectInfo
.Timeout
.HighPart
= 0x7FFFFFFF;
2931 AsyncData
->AsyncSelectInfo
.Timeout
.LowPart
= 0xFFFFFFFF;
2932 AsyncData
->AsyncSelectInfo
.HandleCount
= 1;
2933 AsyncData
->AsyncSelectInfo
.Exclusive
= TRUE
;
2934 AsyncData
->AsyncSelectInfo
.Handles
[0].Handle
= Socket
->Handle
;
2935 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
= 0;
2937 /* Remove unwanted events */
2938 lNetworkEvents
= Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
);
2940 /* Set Events to wait for */
2941 if (lNetworkEvents
& FD_READ
)
2943 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_RECEIVE
;
2946 if (lNetworkEvents
& FD_WRITE
)
2948 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_SEND
;
2951 if (lNetworkEvents
& FD_OOB
)
2953 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_OOB_RECEIVE
;
2956 if (lNetworkEvents
& FD_ACCEPT
)
2958 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_ACCEPT
;
2961 /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2962 if (lNetworkEvents
& FD_CONNECT
)
2964 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_CONNECT
| AFD_EVENT_CONNECT_FAIL
;
2967 if (lNetworkEvents
& FD_CLOSE
)
2969 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_DISCONNECT
| AFD_EVENT_ABORT
| AFD_EVENT_CLOSE
;
2972 if (lNetworkEvents
& FD_QOS
)
2974 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_QOS
;
2977 if (lNetworkEvents
& FD_GROUP_QOS
)
2979 AsyncData
->AsyncSelectInfo
.Handles
[0].Events
|= AFD_EVENT_GROUP_QOS
;
2983 Status
= NtDeviceIoControlFile (SockAsyncHelperAfdHandle
,
2987 &AsyncData
->IoStatusBlock
,
2989 &AsyncData
->AsyncSelectInfo
,
2990 sizeof(AsyncData
->AsyncSelectInfo
),
2991 &AsyncData
->AsyncSelectInfo
,
2992 sizeof(AsyncData
->AsyncSelectInfo
));
2994 /* I/O Manager Won't call the completion routine, let's do it manually */
2995 if (NT_SUCCESS(Status
))
3001 AsyncData
->IoStatusBlock
.Status
= Status
;
3002 SockAsyncSelectCompletionRoutine(AsyncData
, &AsyncData
->IoStatusBlock
);
3006 VOID
SockProcessQueuedAsyncSelect(PVOID Context
, PIO_STATUS_BLOCK IoStatusBlock
)
3008 PASYNC_DATA AsyncData
= Context
;
3009 BOOL FreeContext
= TRUE
;
3010 PSOCKET_INFORMATION Socket
;
3012 /* Get the Socket */
3013 Socket
= AsyncData
->ParentSocket
;
3015 /* If someone closed it, stop the function */
3016 if (Socket
->SharedData
.State
!= SocketClosed
)
3018 /* Check if the Sequence Number changed by now, in which case quit */
3019 if (AsyncData
->SequenceNumber
== Socket
->SharedData
.SequenceNumber
)
3021 /* Do the actuall select, if needed */
3022 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)))
3024 SockProcessAsyncSelect(Socket
, AsyncData
);
3025 FreeContext
= FALSE
;
3030 /* Free the Context */
3033 HeapFree(GetProcessHeap(), 0, AsyncData
);
3040 SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket
,
3043 PASYNC_DATA AsyncData
;
3045 /* Make sure the event is actually disabled */
3046 if (!(Socket
->SharedData
.AsyncDisabledEvents
& Event
))
3052 Socket
->SharedData
.AsyncDisabledEvents
&= ~Event
;
3054 /* Return if no more events are being polled */
3055 if ((Socket
->SharedData
.AsyncEvents
& (~Socket
->SharedData
.AsyncDisabledEvents
)) == 0 )
3060 /* Wait on new events */
3061 AsyncData
= HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA
));
3062 if (!AsyncData
) return;
3064 /* Create the Asynch Thread if Needed */
3065 SockCreateOrReferenceAsyncThread();
3067 /* Increase the sequence number to stop anything else */
3068 Socket
->SharedData
.SequenceNumber
++;
3070 /* Set up the Async Data */
3071 AsyncData
->ParentSocket
= Socket
;
3072 AsyncData
->SequenceNumber
= Socket
->SharedData
.SequenceNumber
;
3074 /* Begin Async Select by using I/O Completion */
3075 NtSetIoCompletion(SockAsyncCompletionPort
,
3076 (PVOID
)&SockProcessQueuedAsyncSelect
,
3087 DllMain(HANDLE hInstDll
,
3094 case DLL_PROCESS_ATTACH
:
3096 AFD_DbgPrint(MAX_TRACE
, ("Loading MSAFD.DLL \n"));
3098 /* Don't need thread attach notifications
3099 so disable them to improve performance */
3100 DisableThreadLibraryCalls(hInstDll
);
3102 /* List of DLL Helpers */
3103 InitializeListHead(&SockHelpersListHead
);
3105 /* Heap to use when allocating */
3106 GlobalHeap
= GetProcessHeap();
3108 /* Initialize the lock that protects our socket list */
3109 InitializeCriticalSection(&SocketListLock
);
3111 AFD_DbgPrint(MAX_TRACE
, ("MSAFD.DLL has been loaded\n"));
3115 case DLL_THREAD_ATTACH
:
3118 case DLL_THREAD_DETACH
:
3121 case DLL_PROCESS_DETACH
:
3123 /* Delete the socket list lock */
3124 DeleteCriticalSection(&SocketListLock
);
3129 AFD_DbgPrint(MAX_TRACE
, ("DllMain of msafd.dll (leaving)\n"));