2006-02-17 00:04:10 +00:00
|
|
|
/*
|
|
|
|
* COPYRIGHT: See COPYING in the top level directory
|
|
|
|
* PROJECT: ReactOS Ancillary Function Driver DLL
|
2015-11-02 17:35:58 +00:00
|
|
|
* FILE: dll/win32/msafd/misc/dllmain.c
|
2006-02-17 00:04:10 +00:00
|
|
|
* PURPOSE: DLL entry point
|
|
|
|
* PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
|
2009-01-14 14:41:25 +00:00
|
|
|
* Alex Ionescu (alex@relsoft.net)
|
2019-02-16 12:46:40 +00:00
|
|
|
* Pierre Schweitzer (pierre@reactos.org)
|
2006-02-17 00:04:10 +00:00
|
|
|
* REVISIONS:
|
2009-01-14 14:41:25 +00:00
|
|
|
* CSH 01/09-2000 Created
|
|
|
|
* Alex 16/07/2004 - Complete Rewrite
|
2006-02-17 00:04:10 +00:00
|
|
|
*/
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
#include <msafd.h>
|
|
|
|
|
2014-01-23 18:01:03 +00:00
|
|
|
#include <winuser.h>
|
2016-09-20 08:12:44 +00:00
|
|
|
#include <wchar.h>
|
2014-01-23 18:01:03 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
HANDLE GlobalHeap;
|
|
|
|
WSPUPCALLTABLE Upcalls;
|
2016-09-20 08:12:44 +00:00
|
|
|
DWORD CatalogEntryId; /* CatalogEntryId for upcalls */
|
2006-02-17 00:04:10 +00:00
|
|
|
LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest;
|
2010-06-07 00:24:27 +00:00
|
|
|
PSOCKET_INFORMATION SocketListHead = NULL;
|
2010-06-19 05:04:40 +00:00
|
|
|
CRITICAL_SECTION SocketListLock;
|
2008-12-07 21:52:22 +00:00
|
|
|
LIST_ENTRY SockHelpersListHead = { NULL, NULL };
|
2006-02-17 00:04:10 +00:00
|
|
|
ULONG SockAsyncThreadRefCount;
|
|
|
|
HANDLE SockAsyncHelperAfdHandle;
|
2011-03-14 12:48:28 +00:00
|
|
|
HANDLE SockAsyncCompletionPort = NULL;
|
2006-02-17 00:04:10 +00:00
|
|
|
BOOLEAN SockAsyncSelectCalled;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/*
|
|
|
|
* FUNCTION: Creates a new socket
|
|
|
|
* ARGUMENTS:
|
|
|
|
* af = Address family
|
|
|
|
* type = Socket type
|
|
|
|
* protocol = Protocol type
|
|
|
|
* lpProtocolInfo = Pointer to protocol information
|
|
|
|
* g = Reserved
|
|
|
|
* dwFlags = Socket flags
|
|
|
|
* lpErrno = Address of buffer for error information
|
|
|
|
* RETURNS:
|
|
|
|
* Created socket, or INVALID_SOCKET if it could not be created
|
|
|
|
*/
|
2011-10-03 14:40:39 +00:00
|
|
|
SOCKET
|
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPSocket(int AddressFamily,
|
|
|
|
int SocketType,
|
|
|
|
int Protocol,
|
|
|
|
LPWSAPROTOCOL_INFOW lpProtocolInfo,
|
|
|
|
GROUP g,
|
|
|
|
DWORD dwFlags,
|
|
|
|
LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
OBJECT_ATTRIBUTES Object;
|
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
USHORT SizeOfPacket;
|
|
|
|
ULONG SizeOfEA;
|
|
|
|
PAFD_CREATE_PACKET AfdPacket;
|
|
|
|
HANDLE Sock;
|
2010-06-07 05:40:08 +00:00
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
2009-01-14 14:41:25 +00:00
|
|
|
PFILE_FULL_EA_INFORMATION EABuffer = NULL;
|
|
|
|
PHELPER_DATA HelperData;
|
|
|
|
PVOID HelperDLLContext;
|
|
|
|
DWORD HelperEvents;
|
|
|
|
UNICODE_STRING TransportName;
|
|
|
|
UNICODE_STRING DevName;
|
|
|
|
LARGE_INTEGER GroupData;
|
|
|
|
INT Status;
|
2016-10-07 17:51:03 +00:00
|
|
|
PSOCK_SHARED_INFO SharedData = NULL;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Creating Socket, getting TDI Name - AddressFamily (%d) SocketType (%d) Protocol (%d).\n",
|
|
|
|
AddressFamily, SocketType, Protocol);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if (lpProtocolInfo && lpProtocolInfo->dwServiceFlags3 != 0 && lpProtocolInfo->dwServiceFlags4 != 0)
|
|
|
|
{
|
|
|
|
/* Duplpicating socket from different process */
|
2018-04-23 09:42:32 +00:00
|
|
|
if (UlongToPtr(lpProtocolInfo->dwServiceFlags3) == INVALID_HANDLE_VALUE)
|
2017-02-19 17:50:34 +00:00
|
|
|
{
|
|
|
|
Status = WSAEINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2018-04-23 09:42:32 +00:00
|
|
|
if (UlongToPtr(lpProtocolInfo->dwServiceFlags4) == INVALID_HANDLE_VALUE)
|
2017-02-19 17:50:34 +00:00
|
|
|
{
|
|
|
|
Status = WSAEINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2018-04-23 09:42:32 +00:00
|
|
|
SharedData = MapViewOfFile(UlongToPtr(lpProtocolInfo->dwServiceFlags3),
|
2016-10-07 17:51:03 +00:00
|
|
|
FILE_MAP_ALL_ACCESS,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
sizeof(SOCK_SHARED_INFO));
|
|
|
|
if (!SharedData)
|
2017-02-19 17:50:34 +00:00
|
|
|
{
|
|
|
|
Status = WSAEINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
InterlockedIncrement(&SharedData->RefCount);
|
|
|
|
AddressFamily = SharedData->AddressFamily;
|
|
|
|
SocketType = SharedData->SocketType;
|
|
|
|
Protocol = SharedData->Protocol;
|
|
|
|
}
|
|
|
|
|
2016-10-30 05:58:02 +00:00
|
|
|
if (AddressFamily == AF_UNSPEC && SocketType == 0 && Protocol == 0)
|
2017-02-19 17:50:34 +00:00
|
|
|
{
|
|
|
|
Status = WSAEINVAL;
|
|
|
|
goto error;
|
|
|
|
}
|
2016-09-20 08:12:44 +00:00
|
|
|
|
2016-10-29 18:22:22 +00:00
|
|
|
/* Set the defaults */
|
2016-10-30 05:58:02 +00:00
|
|
|
if (AddressFamily == AF_UNSPEC)
|
|
|
|
AddressFamily = AF_INET;
|
|
|
|
|
2016-09-20 08:12:44 +00:00
|
|
|
if (SocketType == 0)
|
2016-10-10 07:57:34 +00:00
|
|
|
{
|
|
|
|
switch (Protocol)
|
|
|
|
{
|
|
|
|
case IPPROTO_TCP:
|
|
|
|
SocketType = SOCK_STREAM;
|
|
|
|
break;
|
|
|
|
case IPPROTO_UDP:
|
|
|
|
SocketType = SOCK_DGRAM;
|
|
|
|
break;
|
|
|
|
case IPPROTO_RAW:
|
|
|
|
SocketType = SOCK_RAW;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
TRACE("Unknown Protocol (%d). We will try SOCK_STREAM.\n", Protocol);
|
2016-10-30 05:58:02 +00:00
|
|
|
SocketType = SOCK_STREAM;
|
|
|
|
break;
|
2016-10-10 07:57:34 +00:00
|
|
|
}
|
|
|
|
}
|
2016-09-20 08:12:44 +00:00
|
|
|
|
|
|
|
if (Protocol == 0)
|
|
|
|
{
|
2016-10-10 07:57:34 +00:00
|
|
|
switch (SocketType)
|
|
|
|
{
|
|
|
|
case SOCK_STREAM:
|
2016-09-20 08:12:44 +00:00
|
|
|
Protocol = IPPROTO_TCP;
|
2016-10-10 07:57:34 +00:00
|
|
|
break;
|
|
|
|
case SOCK_DGRAM:
|
2016-09-20 08:12:44 +00:00
|
|
|
Protocol = IPPROTO_UDP;
|
2016-10-10 07:57:34 +00:00
|
|
|
break;
|
|
|
|
case SOCK_RAW:
|
|
|
|
Protocol = IPPROTO_RAW;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
TRACE("Unknown SocketType (%d). We will try IPPROTO_TCP.\n", SocketType);
|
2016-10-30 05:58:02 +00:00
|
|
|
Protocol = IPPROTO_TCP;
|
|
|
|
break;
|
2016-10-10 07:57:34 +00:00
|
|
|
}
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Get Helper Data and Transport */
|
|
|
|
Status = SockGetTdiName (&AddressFamily,
|
|
|
|
&SocketType,
|
|
|
|
&Protocol,
|
|
|
|
g,
|
|
|
|
dwFlags,
|
|
|
|
&TransportName,
|
|
|
|
&HelperDLLContext,
|
|
|
|
&HelperData,
|
|
|
|
&HelperEvents);
|
|
|
|
|
|
|
|
/* Check for error */
|
|
|
|
if (Status != NO_ERROR)
|
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("SockGetTdiName: Status %x\n", Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* AFD Device Name */
|
|
|
|
RtlInitUnicodeString(&DevName, L"\\Device\\Afd\\Endpoint");
|
|
|
|
|
|
|
|
/* Set Socket Data */
|
|
|
|
Socket = HeapAlloc(GlobalHeap, 0, sizeof(*Socket));
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!Socket)
|
2016-10-07 17:51:03 +00:00
|
|
|
{
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAENOBUFS;
|
2016-10-07 17:51:03 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
RtlZeroMemory(Socket, sizeof(*Socket));
|
2016-10-07 17:51:03 +00:00
|
|
|
if (SharedData)
|
|
|
|
{
|
|
|
|
Socket->SharedData = SharedData;
|
2018-04-23 09:42:32 +00:00
|
|
|
Socket->SharedDataHandle = UlongToHandle(lpProtocolInfo->dwServiceFlags3);
|
|
|
|
Sock = UlongToHandle(lpProtocolInfo->dwServiceFlags4);
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->Handle = (SOCKET)lpProtocolInfo->dwServiceFlags4;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Socket->SharedDataHandle = INVALID_HANDLE_VALUE;
|
|
|
|
Socket->SharedData = HeapAlloc(GlobalHeap, 0, sizeof(*Socket->SharedData));
|
|
|
|
if (!Socket->SharedData)
|
|
|
|
{
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAENOBUFS;
|
2016-10-07 17:51:03 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
RtlZeroMemory(Socket->SharedData, sizeof(*Socket->SharedData));
|
|
|
|
Socket->SharedData->State = SocketOpen;
|
|
|
|
Socket->SharedData->RefCount = 1L;
|
|
|
|
Socket->SharedData->Listening = FALSE;
|
|
|
|
Socket->SharedData->AddressFamily = AddressFamily;
|
|
|
|
Socket->SharedData->SocketType = SocketType;
|
|
|
|
Socket->SharedData->Protocol = Protocol;
|
|
|
|
Socket->SharedData->SizeOfLocalAddress = HelperData->MaxWSAddressLength;
|
|
|
|
Socket->SharedData->SizeOfRemoteAddress = HelperData->MaxWSAddressLength;
|
|
|
|
Socket->SharedData->UseDelayedAcceptance = HelperData->UseDelayedAcceptance;
|
|
|
|
Socket->SharedData->CreateFlags = dwFlags;
|
|
|
|
Socket->SharedData->ServiceFlags1 = lpProtocolInfo->dwServiceFlags1;
|
|
|
|
Socket->SharedData->ProviderFlags = lpProtocolInfo->dwProviderFlags;
|
|
|
|
Socket->SharedData->UseSAN = FALSE;
|
|
|
|
Socket->SharedData->NonBlocking = FALSE; /* Sockets start blocking */
|
2016-11-02 15:36:26 +00:00
|
|
|
Socket->SharedData->RecvTimeout = INFINITE;
|
|
|
|
Socket->SharedData->SendTimeout = INFINITE;
|
|
|
|
Socket->SharedData->OobInline = FALSE;
|
2016-10-07 17:51:03 +00:00
|
|
|
|
|
|
|
/* Ask alex about this */
|
|
|
|
if( Socket->SharedData->SocketType == SOCK_DGRAM ||
|
|
|
|
Socket->SharedData->SocketType == SOCK_RAW )
|
|
|
|
{
|
|
|
|
TRACE("Connectionless socket\n");
|
|
|
|
Socket->SharedData->ServiceFlags1 |= XP1_CONNECTIONLESS;
|
|
|
|
}
|
2016-11-02 15:36:26 +00:00
|
|
|
Socket->Handle = INVALID_SOCKET;
|
2016-10-07 17:51:03 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->HelperContext = HelperDLLContext;
|
|
|
|
Socket->HelperData = HelperData;
|
|
|
|
Socket->HelperEvents = HelperEvents;
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->LocalAddress = &Socket->SharedData->WSLocalAddress;
|
|
|
|
Socket->RemoteAddress = &Socket->SharedData->WSRemoteAddress;
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->SanData = NULL;
|
2015-11-07 10:48:38 +00:00
|
|
|
RtlCopyMemory(&Socket->ProtocolInfo, lpProtocolInfo, sizeof(Socket->ProtocolInfo));
|
2016-10-07 17:51:03 +00:00
|
|
|
if (SharedData)
|
|
|
|
goto ok;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Packet Size */
|
|
|
|
SizeOfPacket = TransportName.Length + sizeof(AFD_CREATE_PACKET) + sizeof(WCHAR);
|
|
|
|
|
|
|
|
/* EA Size */
|
|
|
|
SizeOfEA = SizeOfPacket + sizeof(FILE_FULL_EA_INFORMATION) + AFD_PACKET_COMMAND_LENGTH;
|
|
|
|
|
|
|
|
/* Set up EA Buffer */
|
|
|
|
EABuffer = HeapAlloc(GlobalHeap, 0, SizeOfEA);
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!EABuffer)
|
2016-10-07 17:51:03 +00:00
|
|
|
{
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAENOBUFS;
|
2016-10-07 17:51:03 +00:00
|
|
|
goto error;
|
|
|
|
}
|
2009-08-18 18:53:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
RtlZeroMemory(EABuffer, SizeOfEA);
|
|
|
|
EABuffer->NextEntryOffset = 0;
|
|
|
|
EABuffer->Flags = 0;
|
|
|
|
EABuffer->EaNameLength = AFD_PACKET_COMMAND_LENGTH;
|
2011-10-03 14:40:39 +00:00
|
|
|
RtlCopyMemory (EABuffer->EaName,
|
|
|
|
AfdCommand,
|
2009-01-14 14:41:25 +00:00
|
|
|
AFD_PACKET_COMMAND_LENGTH + 1);
|
|
|
|
EABuffer->EaValueLength = SizeOfPacket;
|
|
|
|
|
|
|
|
/* Set up AFD Packet */
|
|
|
|
AfdPacket = (PAFD_CREATE_PACKET)(EABuffer->EaName + EABuffer->EaNameLength + 1);
|
|
|
|
AfdPacket->SizeOfTransportName = TransportName.Length;
|
|
|
|
RtlCopyMemory (AfdPacket->TransportName,
|
2011-10-03 14:40:39 +00:00
|
|
|
TransportName.Buffer,
|
2009-01-14 14:41:25 +00:00
|
|
|
TransportName.Length + sizeof(WCHAR));
|
|
|
|
AfdPacket->GroupID = g;
|
|
|
|
|
|
|
|
/* Set up Endpoint Flags */
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_CONNECTIONLESS) != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
if ((SocketType != SOCK_DGRAM) && (SocketType != SOCK_RAW))
|
|
|
|
{
|
|
|
|
/* Only RAW or UDP can be Connectionless */
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAEINVAL;
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
AfdPacket->EndpointFlags |= AFD_ENDPOINT_CONNECTIONLESS;
|
|
|
|
}
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_MESSAGE_ORIENTED) != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
if (SocketType == SOCK_STREAM)
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_PSEUDO_STREAM) == 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* The Provider doesn't actually support Message Oriented Streams */
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAEINVAL;
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
AfdPacket->EndpointFlags |= AFD_ENDPOINT_MESSAGE_ORIENTED;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (SocketType == SOCK_RAW) AfdPacket->EndpointFlags |= AFD_ENDPOINT_RAW;
|
|
|
|
|
|
|
|
if (dwFlags & (WSA_FLAG_MULTIPOINT_C_ROOT |
|
|
|
|
WSA_FLAG_MULTIPOINT_C_LEAF |
|
|
|
|
WSA_FLAG_MULTIPOINT_D_ROOT |
|
|
|
|
WSA_FLAG_MULTIPOINT_D_LEAF))
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_SUPPORT_MULTIPOINT) == 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* The Provider doesn't actually support Multipoint */
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAEINVAL;
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
AfdPacket->EndpointFlags |= AFD_ENDPOINT_MULTIPOINT;
|
|
|
|
|
|
|
|
if (dwFlags & WSA_FLAG_MULTIPOINT_C_ROOT)
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if (((Socket->SharedData->ServiceFlags1 & XP1_MULTIPOINT_CONTROL_PLANE) == 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
|| ((dwFlags & WSA_FLAG_MULTIPOINT_C_LEAF) != 0))
|
|
|
|
{
|
|
|
|
/* The Provider doesn't support Control Planes, or you already gave a leaf */
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAEINVAL;
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
AfdPacket->EndpointFlags |= AFD_ENDPOINT_C_ROOT;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (dwFlags & WSA_FLAG_MULTIPOINT_D_ROOT)
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if (((Socket->SharedData->ServiceFlags1 & XP1_MULTIPOINT_DATA_PLANE) == 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
|| ((dwFlags & WSA_FLAG_MULTIPOINT_D_LEAF) != 0))
|
|
|
|
{
|
|
|
|
/* The Provider doesn't support Data Planes, or you already gave a leaf */
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = WSAEINVAL;
|
2009-01-14 14:41:25 +00:00
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
AfdPacket->EndpointFlags |= AFD_ENDPOINT_D_ROOT;
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* Set up Object Attributes */
|
|
|
|
InitializeObjectAttributes (&Object,
|
2009-01-14 14:41:25 +00:00
|
|
|
&DevName,
|
|
|
|
OBJ_CASE_INSENSITIVE | OBJ_INHERIT,
|
|
|
|
0,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Create the Socket as asynchronous. That means we have to block
|
|
|
|
ourselves after every call to NtDeviceIoControlFile. This is
|
|
|
|
because the kernel doesn't support overlapping synchronous I/O
|
|
|
|
requests (made from multiple threads) at this time (Sep 2005) */
|
2009-08-27 22:25:59 +00:00
|
|
|
Status = NtCreateFile(&Sock,
|
|
|
|
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
|
|
|
|
&Object,
|
|
|
|
&IOSB,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
FILE_OPEN_IF,
|
|
|
|
0,
|
|
|
|
EABuffer,
|
|
|
|
SizeOfEA);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2009-08-18 18:53:10 +00:00
|
|
|
HeapFree(GlobalHeap, 0, EABuffer);
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
2009-08-27 22:25:59 +00:00
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("Failed to open socket. Status 0x%08x\n", Status);
|
2017-02-19 17:50:34 +00:00
|
|
|
Status = TranslateNtStatusError(Status);
|
2016-10-07 17:51:03 +00:00
|
|
|
goto error;
|
2009-08-27 22:25:59 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Save Handle */
|
|
|
|
Socket->Handle = (SOCKET)Sock;
|
|
|
|
|
|
|
|
/* Save Group Info */
|
|
|
|
if (g != 0)
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
GetSocketInformation(Socket,
|
|
|
|
AFD_INFO_GROUP_ID_TYPE,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&GroupData,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->GroupID = GroupData.u.LowPart;
|
|
|
|
Socket->SharedData->GroupType = GroupData.u.HighPart;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Get Window Sizes and Save them */
|
|
|
|
GetSocketInformation (Socket,
|
|
|
|
AFD_INFO_SEND_WINDOW_SIZE,
|
2011-07-04 17:37:45 +00:00
|
|
|
NULL,
|
2016-10-07 17:51:03 +00:00
|
|
|
&Socket->SharedData->SizeOfSendBuffer,
|
2016-10-25 07:54:00 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
GetSocketInformation (Socket,
|
|
|
|
AFD_INFO_RECEIVE_WINDOW_SIZE,
|
2011-07-04 17:37:45 +00:00
|
|
|
NULL,
|
2016-10-07 17:51:03 +00:00
|
|
|
&Socket->SharedData->SizeOfRecvBuffer,
|
2016-10-25 07:54:00 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL);
|
2016-10-07 17:51:03 +00:00
|
|
|
ok:
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Save in Process Sockets List */
|
2010-06-19 05:04:40 +00:00
|
|
|
EnterCriticalSection(&SocketListLock);
|
2010-06-07 00:24:27 +00:00
|
|
|
Socket->NextSocket = SocketListHead;
|
|
|
|
SocketListHead = Socket;
|
2010-06-19 05:04:40 +00:00
|
|
|
LeaveCriticalSection(&SocketListLock);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Create the Socket Context */
|
|
|
|
CreateContext(Socket);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Notify Winsock */
|
2015-11-07 10:48:38 +00:00
|
|
|
Upcalls.lpWPUModifyIFSHandle(Socket->ProtocolInfo.dwCatalogEntryId, (SOCKET)Sock, lpErrno);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Return Socket Handle */
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Success %x\n", Sock);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return (SOCKET)Sock;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
error:
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("Ending %x\n", Status);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if( SharedData )
|
|
|
|
{
|
|
|
|
UnmapViewOfFile(SharedData);
|
2018-04-23 09:42:32 +00:00
|
|
|
NtClose(UlongToHandle(lpProtocolInfo->dwServiceFlags3));
|
2016-10-07 17:51:03 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if( Socket && Socket->SharedData )
|
|
|
|
HeapFree(GlobalHeap, 0, Socket->SharedData);
|
|
|
|
}
|
|
|
|
|
2009-08-18 18:53:10 +00:00
|
|
|
if( Socket )
|
|
|
|
HeapFree(GlobalHeap, 0, Socket);
|
|
|
|
|
2014-11-15 12:28:03 +00:00
|
|
|
if( EABuffer )
|
|
|
|
HeapFree(GlobalHeap, 0, EABuffer);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if( lpErrno )
|
|
|
|
*lpErrno = Status;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return INVALID_SOCKET;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPDuplicateSocket(
|
|
|
|
IN SOCKET Handle,
|
|
|
|
IN DWORD dwProcessId,
|
|
|
|
OUT LPWSAPROTOCOL_INFOW lpProtocolInfo,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
|
|
|
HANDLE hProcess, hDuplicatedSharedData, hDuplicatedHandle;
|
|
|
|
PSOCKET_INFORMATION Socket;
|
|
|
|
PSOCK_SHARED_INFO pSharedData, pOldSharedData;
|
|
|
|
BOOL bDuplicated;
|
|
|
|
|
|
|
|
if (Handle == INVALID_SOCKET)
|
|
|
|
return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER, lpErrno, 0, NULL);
|
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if( !Socket )
|
|
|
|
{
|
|
|
|
if( lpErrno )
|
|
|
|
*lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
if ( !(hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId)) )
|
|
|
|
return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER, lpErrno, 0, NULL);
|
|
|
|
|
|
|
|
/* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
|
|
|
|
if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
|
|
|
|
{
|
|
|
|
Socket->SharedDataHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
|
|
|
|
NULL,
|
|
|
|
PAGE_READWRITE | SEC_COMMIT,
|
|
|
|
0,
|
|
|
|
(sizeof(SOCK_SHARED_INFO) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1),
|
|
|
|
NULL);
|
|
|
|
if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
|
|
|
|
return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
|
|
|
|
pSharedData = MapViewOfFile(Socket->SharedDataHandle,
|
|
|
|
FILE_MAP_ALL_ACCESS,
|
|
|
|
0,
|
|
|
|
0,
|
|
|
|
sizeof(SOCK_SHARED_INFO));
|
|
|
|
|
|
|
|
RtlCopyMemory(pSharedData, Socket->SharedData, sizeof(SOCK_SHARED_INFO));
|
|
|
|
pOldSharedData = Socket->SharedData;
|
|
|
|
Socket->SharedData = pSharedData;
|
|
|
|
HeapFree(GlobalHeap, 0, pOldSharedData);
|
|
|
|
}
|
|
|
|
/* Duplicate the handles for the new process */
|
|
|
|
bDuplicated = DuplicateHandle(GetCurrentProcess(),
|
|
|
|
Socket->SharedDataHandle,
|
|
|
|
hProcess,
|
|
|
|
(LPHANDLE)&hDuplicatedSharedData,
|
|
|
|
0,
|
|
|
|
FALSE,
|
|
|
|
DUPLICATE_SAME_ACCESS);
|
|
|
|
if (!bDuplicated)
|
|
|
|
{
|
|
|
|
NtClose(hProcess);
|
|
|
|
return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
|
|
|
|
}
|
|
|
|
bDuplicated = DuplicateHandle(GetCurrentProcess(),
|
|
|
|
(HANDLE)Socket->Handle,
|
|
|
|
hProcess,
|
|
|
|
(LPHANDLE)&hDuplicatedHandle,
|
|
|
|
0,
|
|
|
|
FALSE,
|
|
|
|
DUPLICATE_SAME_ACCESS);
|
|
|
|
NtClose(hProcess);
|
|
|
|
if( !bDuplicated )
|
|
|
|
return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
|
|
|
|
|
|
|
|
|
|
|
|
if (!lpProtocolInfo)
|
|
|
|
return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION, lpErrno, 0, NULL);
|
|
|
|
|
|
|
|
RtlCopyMemory(lpProtocolInfo, &Socket->ProtocolInfo, sizeof(*lpProtocolInfo));
|
|
|
|
|
|
|
|
lpProtocolInfo->iAddressFamily = Socket->SharedData->AddressFamily;
|
|
|
|
lpProtocolInfo->iProtocol = Socket->SharedData->Protocol;
|
|
|
|
lpProtocolInfo->iSocketType = Socket->SharedData->SocketType;
|
2018-04-23 09:42:32 +00:00
|
|
|
lpProtocolInfo->dwServiceFlags3 = HandleToUlong(hDuplicatedSharedData);
|
|
|
|
lpProtocolInfo->dwServiceFlags4 = HandleToUlong(hDuplicatedHandle);
|
2016-10-07 17:51:03 +00:00
|
|
|
|
|
|
|
if( lpErrno )
|
|
|
|
*lpErrno = NO_ERROR;
|
|
|
|
|
|
|
|
return NO_ERROR;
|
|
|
|
}
|
|
|
|
|
2010-05-28 03:55:50 +00:00
|
|
|
INT
|
|
|
|
TranslateNtStatusError(NTSTATUS Status)
|
|
|
|
{
|
|
|
|
switch (Status)
|
|
|
|
{
|
|
|
|
case STATUS_CANT_WAIT:
|
|
|
|
return WSAEWOULDBLOCK;
|
|
|
|
|
|
|
|
case STATUS_TIMEOUT:
|
|
|
|
return WSAETIMEDOUT;
|
|
|
|
|
|
|
|
case STATUS_SUCCESS:
|
|
|
|
return NO_ERROR;
|
|
|
|
|
|
|
|
case STATUS_FILE_CLOSED:
|
2016-10-04 18:36:00 +00:00
|
|
|
return WSAECONNRESET;
|
|
|
|
|
2010-05-28 03:55:50 +00:00
|
|
|
case STATUS_END_OF_FILE:
|
|
|
|
return WSAESHUTDOWN;
|
|
|
|
|
|
|
|
case STATUS_PENDING:
|
|
|
|
return WSA_IO_PENDING;
|
|
|
|
|
|
|
|
case STATUS_BUFFER_TOO_SMALL:
|
|
|
|
case STATUS_BUFFER_OVERFLOW:
|
|
|
|
return WSAEMSGSIZE;
|
|
|
|
|
|
|
|
case STATUS_NO_MEMORY:
|
|
|
|
case STATUS_INSUFFICIENT_RESOURCES:
|
|
|
|
return WSAENOBUFS;
|
|
|
|
|
|
|
|
case STATUS_INVALID_CONNECTION:
|
2015-06-14 08:03:15 +00:00
|
|
|
return WSAENOTCONN;
|
|
|
|
|
|
|
|
case STATUS_PROTOCOL_NOT_SUPPORTED:
|
2010-05-28 03:55:50 +00:00
|
|
|
return WSAEAFNOSUPPORT;
|
|
|
|
|
|
|
|
case STATUS_INVALID_ADDRESS:
|
|
|
|
return WSAEADDRNOTAVAIL;
|
|
|
|
|
|
|
|
case STATUS_REMOTE_NOT_LISTENING:
|
2016-10-04 18:36:00 +00:00
|
|
|
case STATUS_REMOTE_DISCONNECT:
|
2010-05-28 03:55:50 +00:00
|
|
|
return WSAECONNREFUSED;
|
|
|
|
|
|
|
|
case STATUS_NETWORK_UNREACHABLE:
|
|
|
|
return WSAENETUNREACH;
|
|
|
|
|
2018-01-23 21:28:55 +00:00
|
|
|
case STATUS_HOST_UNREACHABLE:
|
|
|
|
return WSAEHOSTUNREACH;
|
|
|
|
|
2010-05-28 03:55:50 +00:00
|
|
|
case STATUS_INVALID_PARAMETER:
|
|
|
|
return WSAEINVAL;
|
|
|
|
|
|
|
|
case STATUS_CANCELLED:
|
|
|
|
return WSA_OPERATION_ABORTED;
|
|
|
|
|
2010-05-28 04:39:49 +00:00
|
|
|
case STATUS_ADDRESS_ALREADY_EXISTS:
|
|
|
|
return WSAEADDRINUSE;
|
|
|
|
|
|
|
|
case STATUS_LOCAL_DISCONNECT:
|
|
|
|
return WSAECONNABORTED;
|
|
|
|
|
2012-08-27 06:34:21 +00:00
|
|
|
case STATUS_ACCESS_VIOLATION:
|
|
|
|
return WSAEFAULT;
|
|
|
|
|
2015-10-18 12:45:49 +00:00
|
|
|
case STATUS_ACCESS_DENIED:
|
|
|
|
return WSAEACCES;
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
case STATUS_NOT_IMPLEMENTED:
|
|
|
|
return WSAEOPNOTSUPP;
|
|
|
|
|
2010-05-28 03:55:50 +00:00
|
|
|
default:
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status);
|
2010-05-28 03:55:50 +00:00
|
|
|
return WSAENETDOWN;
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FUNCTION: Closes an open socket
|
|
|
|
* ARGUMENTS:
|
|
|
|
* s = Socket descriptor
|
|
|
|
* lpErrno = Address of buffer for error information
|
|
|
|
* RETURNS:
|
|
|
|
* NO_ERROR, or SOCKET_ERROR if the socket could not be closed
|
|
|
|
*/
|
2009-01-14 14:41:25 +00:00
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPCloseSocket(IN SOCKET Handle,
|
|
|
|
OUT LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK IoStatusBlock;
|
2010-06-07 00:24:27 +00:00
|
|
|
PSOCKET_INFORMATION Socket = NULL, CurrentSocket;
|
2006-02-17 00:04:10 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
AFD_DISCONNECT_INFO DisconnectInfo;
|
|
|
|
SOCKET_STATE OldState;
|
2011-06-11 17:49:30 +00:00
|
|
|
LONG LingerWait = -1;
|
2016-10-07 17:51:03 +00:00
|
|
|
DWORD References;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Create the Wait Event */
|
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2006-02-17 00:04:10 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if(!NT_SUCCESS(Status))
|
2014-11-10 13:06:48 +00:00
|
|
|
{
|
|
|
|
ERR("NtCreateEvent failed: 0x%08x", Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
2014-11-10 13:06:48 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-01-16 00:05:15 +00:00
|
|
|
if (Socket->HelperEvents & WSH_NOTIFY_CLOSE)
|
|
|
|
{
|
|
|
|
Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_CLOSE);
|
|
|
|
|
|
|
|
if (Status)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = Status;
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("WSHNotify failed. Error 0x%#x", Status);
|
2010-01-16 00:05:15 +00:00
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* If a Close is already in Process, give up */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->State == SocketClosed)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
WARN("Socket is closing.\n");
|
2009-03-27 03:21:21 +00:00
|
|
|
NtClose(SockEvent);
|
2016-10-25 07:54:00 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2006-02-17 00:04:10 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
|
|
|
|
/* Decrement reference count on SharedData */
|
|
|
|
References = InterlockedDecrement(&Socket->SharedData->RefCount);
|
|
|
|
if (References)
|
|
|
|
goto ok;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2017-05-26 15:27:45 +00:00
|
|
|
/* Set the state to close */
|
|
|
|
OldState = Socket->SharedData->State;
|
|
|
|
Socket->SharedData->State = SocketClosed;
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
|
|
|
|
/* FIXME: Should we do this on Datagram Sockets too? */
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((OldState == SocketConnected) && (Socket->SharedData->LingerData.l_onoff))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
ULONG SendsInProgress;
|
|
|
|
ULONG SleepWait;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* We need to respect the timeout */
|
|
|
|
SleepWait = 100;
|
2016-10-07 17:51:03 +00:00
|
|
|
LingerWait = Socket->SharedData->LingerData.l_linger * 1000;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Loop until no more sends are pending, within the timeout */
|
2009-01-14 14:41:25 +00:00
|
|
|
while (LingerWait)
|
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Find out how many Sends are in Progress */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (GetSocketInformation(Socket,
|
2006-02-17 00:04:10 +00:00
|
|
|
AFD_INFO_SENDS_IN_PROGRESS,
|
2011-07-04 17:37:45 +00:00
|
|
|
NULL,
|
2006-02-17 00:04:10 +00:00
|
|
|
&SendsInProgress,
|
2016-10-25 07:54:00 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL))
|
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Bail out if anything but NO_ERROR */
|
|
|
|
LingerWait = 0;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Bail out if no more sends are pending */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (!SendsInProgress)
|
2011-06-11 17:49:30 +00:00
|
|
|
{
|
|
|
|
LingerWait = -1;
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
2011-06-11 17:49:30 +00:00
|
|
|
}
|
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/*
|
2006-02-17 00:04:10 +00:00
|
|
|
* We have to execute a sleep, so it's kind of like
|
|
|
|
* a block. If the socket is Nonblock, we cannot
|
2016-11-12 21:53:33 +00:00
|
|
|
* go on since asynchronous operation is expected
|
2006-02-17 00:04:10 +00:00
|
|
|
* and we cannot offer it
|
|
|
|
*/
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->NonBlocking)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
WARN("Would block!\n");
|
2009-03-27 03:21:21 +00:00
|
|
|
NtClose(SockEvent);
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->State = OldState;
|
2016-10-25 07:54:00 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
|
2006-02-17 00:04:10 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Now we can sleep, and decrement the linger wait */
|
2011-10-03 14:40:39 +00:00
|
|
|
/*
|
2009-01-14 14:41:25 +00:00
|
|
|
* FIXME: It seems Windows does some funky acceleration
|
|
|
|
* since the waiting seems to be longer and longer. I
|
|
|
|
* don't think this improves performance so much, so we
|
|
|
|
* wait a fixed time instead.
|
|
|
|
*/
|
2006-02-17 00:04:10 +00:00
|
|
|
Sleep(SleepWait);
|
|
|
|
LingerWait -= SleepWait;
|
|
|
|
}
|
2011-06-11 17:49:30 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2011-06-11 17:49:30 +00:00
|
|
|
if (OldState == SocketConnected)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
if (LingerWait <= 0)
|
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
DisconnectInfo.Timeout = RtlConvertLongToLargeInteger(0);
|
2011-06-11 17:49:30 +00:00
|
|
|
DisconnectInfo.DisconnectType = LingerWait < 0 ? AFD_DISCONNECT_SEND : AFD_DISCONNECT_ABORT;
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if (((DisconnectInfo.DisconnectType & AFD_DISCONNECT_SEND) && (!Socket->SharedData->SendShutdown)) ||
|
|
|
|
((DisconnectInfo.DisconnectType & AFD_DISCONNECT_ABORT) && (!Socket->SharedData->ReceiveShutdown)))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2011-07-03 16:24:19 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IoStatusBlock,
|
|
|
|
IOCTL_AFD_DISCONNECT,
|
|
|
|
&DisconnectInfo,
|
|
|
|
sizeof(DisconnectInfo),
|
|
|
|
NULL,
|
|
|
|
0);
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2011-07-03 16:24:19 +00:00
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IoStatusBlock.Status;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Cleanup Time! */
|
|
|
|
Socket->HelperContext = NULL;
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents = -1;
|
2006-02-17 00:04:10 +00:00
|
|
|
NtClose(Socket->TdiAddressHandle);
|
|
|
|
Socket->TdiAddressHandle = NULL;
|
|
|
|
NtClose(Socket->TdiConnectionHandle);
|
|
|
|
Socket->TdiConnectionHandle = NULL;
|
2016-10-07 17:51:03 +00:00
|
|
|
ok:
|
2010-06-19 05:04:40 +00:00
|
|
|
EnterCriticalSection(&SocketListLock);
|
2010-06-07 00:24:27 +00:00
|
|
|
if (SocketListHead == Socket)
|
|
|
|
{
|
|
|
|
SocketListHead = SocketListHead->NextSocket;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
CurrentSocket = SocketListHead;
|
|
|
|
while (CurrentSocket->NextSocket)
|
|
|
|
{
|
|
|
|
if (CurrentSocket->NextSocket == Socket)
|
|
|
|
{
|
|
|
|
CurrentSocket->NextSocket = CurrentSocket->NextSocket->NextSocket;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
CurrentSocket = CurrentSocket->NextSocket;
|
|
|
|
}
|
|
|
|
}
|
2010-06-19 05:04:40 +00:00
|
|
|
LeaveCriticalSection(&SocketListLock);
|
2010-06-07 00:24:27 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Close the handle */
|
|
|
|
NtClose((HANDLE)Handle);
|
2009-03-27 03:21:21 +00:00
|
|
|
NtClose(SockEvent);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if( Socket->SharedDataHandle != INVALID_HANDLE_VALUE )
|
|
|
|
{
|
|
|
|
/* It is a duplicated socket, so unmap the memory */
|
|
|
|
UnmapViewOfFile(Socket->SharedData);
|
|
|
|
NtClose(Socket->SharedDataHandle);
|
|
|
|
Socket->SharedData = NULL;
|
|
|
|
}
|
|
|
|
if( !References && Socket->SharedData )
|
|
|
|
{
|
|
|
|
HeapFree(GlobalHeap, 0, Socket->SharedData);
|
|
|
|
}
|
2011-03-14 12:48:28 +00:00
|
|
|
HeapFree(GlobalHeap, 0, Socket);
|
2010-06-06 23:07:26 +00:00
|
|
|
return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/*
|
|
|
|
* FUNCTION: Associates a local address with a socket
|
|
|
|
* ARGUMENTS:
|
|
|
|
* s = Socket descriptor
|
|
|
|
* name = Pointer to local address
|
|
|
|
* namelen = Length of name
|
|
|
|
* lpErrno = Address of buffer for error information
|
|
|
|
* RETURNS:
|
|
|
|
* 0, or SOCKET_ERROR if the socket could not be bound
|
|
|
|
*/
|
2009-01-14 14:41:25 +00:00
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPBind(SOCKET Handle,
|
|
|
|
const struct sockaddr *SocketAddress,
|
|
|
|
int SocketAddressLength,
|
|
|
|
LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
PAFD_BIND_DATA BindData;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
NTSTATUS Status;
|
|
|
|
SOCKADDR_INFO SocketInfo;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if (!Socket)
|
2009-12-07 01:30:32 +00:00
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
2009-12-07 01:30:32 +00:00
|
|
|
}
|
2017-05-26 10:32:01 +00:00
|
|
|
if (Socket->SharedData->State != SocketOpen)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
if (!SocketAddress || SocketAddressLength < Socket->SharedData->SizeOfLocalAddress)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Get Address Information */
|
|
|
|
Socket->HelperData->WSHGetSockaddrType ((PSOCKADDR)SocketAddress,
|
|
|
|
SocketAddressLength,
|
|
|
|
&SocketInfo);
|
|
|
|
|
|
|
|
if (SocketInfo.AddressInfo == SockaddrAddressInfoBroadcast && !Socket->SharedData->Broadcast)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEADDRNOTAVAIL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-12-07 01:30:32 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
|
|
|
|
2009-12-07 01:30:32 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
/* See below */
|
|
|
|
BindData = HeapAlloc(GlobalHeap, 0, 0xA + SocketAddressLength);
|
|
|
|
if (!BindData)
|
2010-06-07 01:24:15 +00:00
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
|
2010-06-07 01:24:15 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set up Address in TDI Format */
|
|
|
|
BindData->Address.TAAddressCount = 1;
|
2018-04-23 09:42:32 +00:00
|
|
|
BindData->Address.Address[0].AddressLength = (USHORT)(SocketAddressLength - sizeof(SocketAddress->sa_family));
|
2009-01-14 14:41:25 +00:00
|
|
|
BindData->Address.Address[0].AddressType = SocketAddress->sa_family;
|
|
|
|
RtlCopyMemory (BindData->Address.Address[0].Address,
|
|
|
|
SocketAddress->sa_data,
|
|
|
|
SocketAddressLength - sizeof(SocketAddress->sa_family));
|
|
|
|
|
|
|
|
/* Set the Share Type */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->ExclusiveAddressUse)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
BindData->ShareType = AFD_SHARE_EXCLUSIVE;
|
|
|
|
}
|
|
|
|
else if (SocketInfo.EndpointInfo == SockaddrEndpointInfoWildcard)
|
|
|
|
{
|
|
|
|
BindData->ShareType = AFD_SHARE_WILDCARD;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
else if (Socket->SharedData->ReuseAddresses)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
BindData->ShareType = AFD_SHARE_REUSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
BindData->ShareType = AFD_SHARE_UNIQUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_BIND,
|
|
|
|
BindData,
|
2016-10-07 17:51:03 +00:00
|
|
|
0xA + Socket->SharedData->SizeOfLocalAddress, /* Can't figure out a way to calculate this in C*/
|
2009-01-14 14:41:25 +00:00
|
|
|
BindData,
|
2016-10-07 17:51:03 +00:00
|
|
|
0xA + Socket->SharedData->SizeOfLocalAddress); /* Can't figure out a way to calculate this C */
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
2010-06-06 23:07:26 +00:00
|
|
|
NtClose( SockEvent );
|
|
|
|
HeapFree(GlobalHeap, 0, BindData);
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Status != STATUS_SUCCESS)
|
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Set up Socket Data */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->State = SocketBound;
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->TdiAddressHandle = (HANDLE)IOSB.Information;
|
|
|
|
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Socket->HelperEvents & WSH_NOTIFY_BIND)
|
2010-01-16 00:05:15 +00:00
|
|
|
{
|
|
|
|
Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_BIND);
|
|
|
|
|
|
|
|
if (Status)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = Status;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
int
|
2006-02-17 00:04:10 +00:00
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPListen(SOCKET Handle,
|
|
|
|
int Backlog,
|
|
|
|
LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
AFD_LISTEN_DATA ListenData;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
NTSTATUS Status;
|
|
|
|
|
2009-02-07 01:20:25 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2010-06-07 01:24:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-02-07 01:20:25 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->Listening)
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2009-02-07 01:20:25 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set Up Listen Structure */
|
|
|
|
ListenData.UseSAN = FALSE;
|
2016-10-07 17:51:03 +00:00
|
|
|
ListenData.UseDelayedAcceptance = Socket->SharedData->UseDelayedAcceptance;
|
2009-01-14 14:41:25 +00:00
|
|
|
ListenData.Backlog = Backlog;
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_START_LISTEN,
|
|
|
|
&ListenData,
|
|
|
|
sizeof(ListenData),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
2010-06-06 23:07:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Status != STATUS_SUCCESS)
|
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set to Listening */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->Listening = TRUE;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Socket->HelperEvents & WSH_NOTIFY_LISTEN)
|
2010-01-16 00:05:15 +00:00
|
|
|
{
|
|
|
|
Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_LISTEN);
|
|
|
|
|
|
|
|
if (Status)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = Status;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
int
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPAPI
|
2010-04-07 15:16:21 +00:00
|
|
|
WSPSelect(IN int nfds,
|
|
|
|
IN OUT fd_set *readfds OPTIONAL,
|
|
|
|
IN OUT fd_set *writefds OPTIONAL,
|
|
|
|
IN OUT fd_set *exceptfds OPTIONAL,
|
|
|
|
IN const struct timeval *timeout OPTIONAL,
|
|
|
|
OUT LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
PAFD_POLL_INFO PollInfo;
|
|
|
|
NTSTATUS Status;
|
2011-07-05 12:21:17 +00:00
|
|
|
ULONG HandleCount;
|
2009-01-14 14:41:25 +00:00
|
|
|
ULONG PollBufferSize;
|
|
|
|
PVOID PollBuffer;
|
|
|
|
ULONG i, j = 0, x;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
LARGE_INTEGER Timeout;
|
2016-10-28 16:37:39 +00:00
|
|
|
PSOCKET_INFORMATION Socket;
|
|
|
|
SOCKET Handle;
|
|
|
|
ULONG Events;
|
2016-11-17 12:57:32 +00:00
|
|
|
fd_set selectfds;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/* Find out how many sockets we have, and how large the buffer needs
|
2006-02-17 00:04:10 +00:00
|
|
|
* to be */
|
2016-11-17 12:57:32 +00:00
|
|
|
FD_ZERO(&selectfds);
|
|
|
|
if (readfds != NULL)
|
|
|
|
{
|
|
|
|
for (i = 0; i < readfds->fd_count; i++)
|
|
|
|
{
|
|
|
|
FD_SET(readfds->fd_array[i], &selectfds);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (writefds != NULL)
|
|
|
|
{
|
|
|
|
for (i = 0; i < writefds->fd_count; i++)
|
|
|
|
{
|
|
|
|
FD_SET(writefds->fd_array[i], &selectfds);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (exceptfds != NULL)
|
|
|
|
{
|
|
|
|
for (i = 0; i < exceptfds->fd_count; i++)
|
|
|
|
{
|
|
|
|
FD_SET(exceptfds->fd_array[i], &selectfds);
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-11-17 12:57:32 +00:00
|
|
|
HandleCount = selectfds.fd_count;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2009-06-06 07:54:54 +00:00
|
|
|
if ( HandleCount == 0 )
|
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
WARN("No handles! Returning SOCKET_ERROR\n", HandleCount);
|
2009-06-06 07:54:54 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-06-06 07:54:54 +00:00
|
|
|
PollBufferSize = sizeof(*PollInfo) + ((HandleCount - 1) * sizeof(AFD_HANDLE));
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("HandleCount: %u BufferSize: %u\n", HandleCount, PollBufferSize);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* Convert Timeout to NT Format */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (timeout == NULL)
|
|
|
|
{
|
|
|
|
Timeout.u.LowPart = -1;
|
|
|
|
Timeout.u.HighPart = 0x7FFFFFFF;
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Infinite timeout\n");
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Timeout = RtlEnlargedIntegerMultiply
|
|
|
|
((timeout->tv_sec * 1000) + (timeout->tv_usec / 1000), -10000);
|
2011-10-03 14:40:39 +00:00
|
|
|
/* Negative timeouts are illegal. Since the kernel represents an
|
2009-01-14 14:41:25 +00:00
|
|
|
* incremental timeout as a negative number, we check for a positive
|
|
|
|
* result.
|
|
|
|
*/
|
|
|
|
if (Timeout.QuadPart > 0)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
2016-11-17 12:57:32 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Timeout: Orig %d.%06d kernel %d\n",
|
2009-01-14 14:41:25 +00:00
|
|
|
timeout->tv_sec, timeout->tv_usec,
|
2014-11-10 13:06:48 +00:00
|
|
|
Timeout.u.LowPart);
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
if(!NT_SUCCESS(Status))
|
|
|
|
{
|
2016-10-04 18:27:17 +00:00
|
|
|
if (lpErrno)
|
|
|
|
*lpErrno = WSAEFAULT;
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("NtCreateEvent failed, 0x%08x\n", Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
2014-11-10 13:06:48 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-08-21 03:59:02 +00:00
|
|
|
/* Allocate */
|
|
|
|
PollBuffer = HeapAlloc(GlobalHeap, 0, PollBufferSize);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (!PollBuffer)
|
|
|
|
{
|
|
|
|
if (lpErrno)
|
|
|
|
*lpErrno = WSAEFAULT;
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
2006-08-21 03:59:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
PollInfo = (PAFD_POLL_INFO)PollBuffer;
|
|
|
|
|
|
|
|
RtlZeroMemory( PollInfo, PollBufferSize );
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Number of handles for AFD to Check */
|
|
|
|
PollInfo->Exclusive = FALSE;
|
2006-08-21 03:59:02 +00:00
|
|
|
PollInfo->Timeout = Timeout;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-17 12:57:32 +00:00
|
|
|
for (i = 0; i < selectfds.fd_count; i++)
|
|
|
|
{
|
|
|
|
PollInfo->Handles[i].Handle = selectfds.fd_array[i];
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
if (readfds != NULL) {
|
2016-11-17 12:57:32 +00:00
|
|
|
for (i = 0; i < readfds->fd_count; i++)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-17 12:57:32 +00:00
|
|
|
for (j = 0; j < HandleCount; j++)
|
|
|
|
{
|
|
|
|
if (PollInfo->Handles[j].Handle == readfds->fd_array[i])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (j >= HandleCount)
|
|
|
|
{
|
|
|
|
ERR("Error while counting readfds %ld > %ld\n", j, HandleCount);
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-28 16:37:39 +00:00
|
|
|
Socket = GetSocketStructure(readfds->fd_array[i]);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
ERR("Invalid socket handle provided in readfds %d\n", readfds->fd_array[i]);
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-11-17 12:57:32 +00:00
|
|
|
PollInfo->Handles[j].Events |= AFD_EVENT_RECEIVE |
|
|
|
|
AFD_EVENT_DISCONNECT |
|
|
|
|
AFD_EVENT_ABORT |
|
|
|
|
AFD_EVENT_CLOSE |
|
|
|
|
AFD_EVENT_ACCEPT;
|
|
|
|
//if (Socket->SharedData->OobInline != 0)
|
|
|
|
// PollInfo->Handles[j].Events |= AFD_EVENT_OOB_RECEIVE;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (writefds != NULL)
|
|
|
|
{
|
2016-11-17 12:57:32 +00:00
|
|
|
for (i = 0; i < writefds->fd_count; i++)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-17 12:57:32 +00:00
|
|
|
for (j = 0; j < HandleCount; j++)
|
|
|
|
{
|
|
|
|
if (PollInfo->Handles[j].Handle == writefds->fd_array[i])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (j >= HandleCount)
|
|
|
|
{
|
|
|
|
ERR("Error while counting writefds %ld > %ld\n", j, HandleCount);
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-28 16:37:39 +00:00
|
|
|
Socket = GetSocketStructure(writefds->fd_array[i]);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
ERR("Invalid socket handle provided in writefds %d\n", writefds->fd_array[i]);
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
PollInfo->Handles[j].Handle = writefds->fd_array[i];
|
2016-11-17 12:57:32 +00:00
|
|
|
PollInfo->Handles[j].Events |= AFD_EVENT_SEND;
|
2016-10-28 16:37:39 +00:00
|
|
|
if (Socket->SharedData->NonBlocking != 0)
|
|
|
|
PollInfo->Handles[j].Events |= AFD_EVENT_CONNECT;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
if (exceptfds != NULL)
|
|
|
|
{
|
2016-11-17 12:57:32 +00:00
|
|
|
for (i = 0; i < exceptfds->fd_count; i++)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-17 12:57:32 +00:00
|
|
|
for (j = 0; j < HandleCount; j++)
|
|
|
|
{
|
|
|
|
if (PollInfo->Handles[j].Handle == exceptfds->fd_array[i])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (j > HandleCount)
|
|
|
|
{
|
|
|
|
ERR("Error while counting exceptfds %ld > %ld\n", j, HandleCount);
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-28 16:37:39 +00:00
|
|
|
Socket = GetSocketStructure(exceptfds->fd_array[i]);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
TRACE("Invalid socket handle provided in exceptfds %d\n", exceptfds->fd_array[i]);
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
PollInfo->Handles[j].Handle = exceptfds->fd_array[i];
|
2016-10-28 16:37:39 +00:00
|
|
|
if (Socket->SharedData->OobInline == 0)
|
|
|
|
PollInfo->Handles[j].Events |= AFD_EVENT_OOB_RECEIVE;
|
|
|
|
if (Socket->SharedData->NonBlocking != 0)
|
|
|
|
PollInfo->Handles[j].Events |= AFD_EVENT_CONNECT_FAIL;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-17 12:57:32 +00:00
|
|
|
PollInfo->HandleCount = HandleCount;
|
2011-03-10 14:07:55 +00:00
|
|
|
PollBufferSize = FIELD_OFFSET(AFD_POLL_INFO, Handles) + PollInfo->HandleCount * sizeof(AFD_HANDLE);
|
2008-08-23 09:01:29 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Send IOCTL */
|
2009-01-14 14:41:25 +00:00
|
|
|
Status = NtDeviceIoControlFile((HANDLE)PollInfo->Handles[0].Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_SELECT,
|
|
|
|
PollInfo,
|
|
|
|
PollBufferSize,
|
|
|
|
PollInfo,
|
|
|
|
PollBufferSize);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("DeviceIoControlFile => %x\n", Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Wait for Completion */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
2010-06-06 23:07:26 +00:00
|
|
|
Status = IOSB.Status;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Clear the Structures */
|
2009-01-14 14:41:25 +00:00
|
|
|
if( readfds )
|
|
|
|
FD_ZERO(readfds);
|
|
|
|
if( writefds )
|
|
|
|
FD_ZERO(writefds);
|
|
|
|
if( exceptfds )
|
|
|
|
FD_ZERO(exceptfds);
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Loop through return structure */
|
|
|
|
HandleCount = PollInfo->HandleCount;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Return in FDSET Format */
|
2009-01-14 14:41:25 +00:00
|
|
|
for (i = 0; i < HandleCount; i++)
|
|
|
|
{
|
2016-10-28 16:37:39 +00:00
|
|
|
Events = PollInfo->Handles[i].Events;
|
|
|
|
Handle = PollInfo->Handles[i].Handle;
|
2009-01-14 14:41:25 +00:00
|
|
|
for(x = 1; x; x<<=1)
|
|
|
|
{
|
2016-10-28 16:37:39 +00:00
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
TRACE("Invalid socket handle found %d\n", Handle);
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
HeapFree(GlobalHeap, 0, PollBuffer);
|
|
|
|
NtClose(SockEvent);
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
switch (Events & x)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
case AFD_EVENT_RECEIVE:
|
|
|
|
case AFD_EVENT_DISCONNECT:
|
|
|
|
case AFD_EVENT_ABORT:
|
|
|
|
case AFD_EVENT_ACCEPT:
|
|
|
|
case AFD_EVENT_CLOSE:
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Event %x on handle %x\n",
|
2016-10-28 16:37:39 +00:00
|
|
|
Events,
|
|
|
|
Handle);
|
2016-11-07 08:50:31 +00:00
|
|
|
if ((Events & x) == AFD_EVENT_DISCONNECT || (Events & x) == AFD_EVENT_CLOSE)
|
|
|
|
Socket->SharedData->SocketLastError = WSAECONNRESET;
|
|
|
|
if ((Events & x) == AFD_EVENT_ABORT)
|
|
|
|
Socket->SharedData->SocketLastError = WSAECONNABORTED;
|
2009-01-14 14:41:25 +00:00
|
|
|
if( readfds )
|
2016-10-28 16:37:39 +00:00
|
|
|
FD_SET(Handle, readfds);
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
case AFD_EVENT_SEND:
|
2016-10-28 16:37:39 +00:00
|
|
|
TRACE("Event %x on handle %x\n",
|
|
|
|
Events,
|
|
|
|
Handle);
|
|
|
|
if (writefds)
|
|
|
|
FD_SET(Handle, writefds);
|
|
|
|
break;
|
2009-01-14 14:41:25 +00:00
|
|
|
case AFD_EVENT_CONNECT:
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Event %x on handle %x\n",
|
2016-10-28 16:37:39 +00:00
|
|
|
Events,
|
|
|
|
Handle);
|
|
|
|
if( writefds && Socket->SharedData->NonBlocking != 0 )
|
|
|
|
FD_SET(Handle, writefds);
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
case AFD_EVENT_OOB_RECEIVE:
|
2016-10-28 16:37:39 +00:00
|
|
|
TRACE("Event %x on handle %x\n",
|
|
|
|
Events,
|
|
|
|
Handle);
|
|
|
|
if( readfds && Socket->SharedData->OobInline != 0 )
|
|
|
|
FD_SET(Handle, readfds);
|
|
|
|
if( exceptfds && Socket->SharedData->OobInline == 0 )
|
|
|
|
FD_SET(Handle, exceptfds);
|
|
|
|
break;
|
2009-01-14 14:41:25 +00:00
|
|
|
case AFD_EVENT_CONNECT_FAIL:
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Event %x on handle %x\n",
|
2016-10-28 16:37:39 +00:00
|
|
|
Events,
|
|
|
|
Handle);
|
|
|
|
if( exceptfds && Socket->SharedData->NonBlocking != 0 )
|
|
|
|
FD_SET(Handle, exceptfds);
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2006-08-21 03:59:02 +00:00
|
|
|
HeapFree( GlobalHeap, 0, PollBuffer );
|
2006-02-17 00:04:10 +00:00
|
|
|
NtClose( SockEvent );
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if( lpErrno )
|
|
|
|
{
|
|
|
|
switch( IOSB.Status )
|
|
|
|
{
|
2011-10-03 14:40:39 +00:00
|
|
|
case STATUS_SUCCESS:
|
2009-01-14 14:41:25 +00:00
|
|
|
case STATUS_TIMEOUT:
|
|
|
|
*lpErrno = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
*lpErrno = WSAEINVAL;
|
|
|
|
break;
|
2007-12-16 14:44:01 +00:00
|
|
|
}
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("*lpErrno = %x\n", *lpErrno);
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2016-10-28 16:37:39 +00:00
|
|
|
HandleCount = (readfds ? readfds->fd_count : 0) +
|
|
|
|
(writefds && writefds != readfds ? writefds->fd_count : 0) +
|
|
|
|
(exceptfds && exceptfds != readfds && exceptfds != writefds ? exceptfds->fd_count : 0);
|
|
|
|
|
|
|
|
TRACE("%d events\n", HandleCount);
|
2007-12-16 14:44:01 +00:00
|
|
|
|
2016-10-28 16:37:39 +00:00
|
|
|
return HandleCount;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 17:55:00 +00:00
|
|
|
DWORD
|
2016-11-11 21:37:09 +00:00
|
|
|
GetCurrentTimeInSeconds(VOID)
|
2016-11-10 17:55:00 +00:00
|
|
|
{
|
2016-11-11 21:37:09 +00:00
|
|
|
SYSTEMTIME st1970 = { 1970, 1, 0, 1, 0, 0, 0, 0 };
|
|
|
|
union
|
|
|
|
{
|
|
|
|
FILETIME ft;
|
|
|
|
ULONGLONG ll;
|
|
|
|
} u1970, Time;
|
|
|
|
|
|
|
|
GetSystemTimeAsFileTime(&Time.ft);
|
|
|
|
SystemTimeToFileTime(&st1970, &u1970.ft);
|
|
|
|
return (DWORD)((Time.ll - u1970.ll) / 10000000ULL);
|
2016-11-10 17:55:00 +00:00
|
|
|
}
|
|
|
|
|
2018-04-23 09:42:32 +00:00
|
|
|
_Must_inspect_result_
|
2006-02-17 00:04:10 +00:00
|
|
|
SOCKET
|
2011-10-03 14:40:39 +00:00
|
|
|
WSPAPI
|
2018-04-23 09:42:32 +00:00
|
|
|
WSPAccept(
|
|
|
|
_In_ SOCKET Handle,
|
|
|
|
_Out_writes_bytes_to_opt_(*addrlen, *addrlen) struct sockaddr FAR *SocketAddress,
|
|
|
|
_Inout_opt_ LPINT SocketAddressLength,
|
|
|
|
_In_opt_ LPCONDITIONPROC lpfnCondition,
|
|
|
|
_In_opt_ DWORD_PTR dwCallbackData,
|
|
|
|
_Out_ LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData;
|
|
|
|
AFD_ACCEPT_DATA AcceptData;
|
|
|
|
AFD_DEFER_ACCEPT_DATA DeferData;
|
|
|
|
AFD_PENDING_ACCEPT_DATA PendingAcceptData;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
NTSTATUS Status;
|
|
|
|
struct fd_set ReadSet;
|
|
|
|
struct timeval Timeout;
|
|
|
|
PVOID PendingData = NULL;
|
|
|
|
ULONG PendingDataLength = 0;
|
|
|
|
PVOID CalleeDataBuffer;
|
|
|
|
WSABUF CallerData, CalleeID, CallerID, CalleeData;
|
|
|
|
PSOCKADDR RemoteAddress = NULL;
|
|
|
|
GROUP GroupID = 0;
|
|
|
|
ULONG CallBack;
|
|
|
|
SOCKET AcceptSocket;
|
2011-06-20 17:35:02 +00:00
|
|
|
PSOCKET_INFORMATION AcceptSocketInfo;
|
2009-01-14 14:41:25 +00:00
|
|
|
UCHAR ReceiveBuffer[0x1A];
|
|
|
|
HANDLE SockEvent;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if (!Socket)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2017-06-01 09:41:19 +00:00
|
|
|
if (!Socket->SharedData->Listening)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-11-04 18:03:15 +00:00
|
|
|
if ((SocketAddress && !SocketAddressLength) ||
|
|
|
|
(SocketAddressLength && !SocketAddress) ||
|
|
|
|
(SocketAddressLength && *SocketAddressLength < sizeof(SOCKADDR)))
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return INVALID_SOCKET;
|
|
|
|
}
|
2016-11-02 15:36:26 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if( !NT_SUCCESS(Status) )
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Dynamic Structure...ugh */
|
|
|
|
ListenReceiveData = (PAFD_RECEIVED_ACCEPT_DATA)ReceiveBuffer;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* If this is non-blocking, make sure there's something for us to accept */
|
|
|
|
FD_ZERO(&ReadSet);
|
|
|
|
FD_SET(Socket->Handle, &ReadSet);
|
|
|
|
Timeout.tv_sec=0;
|
|
|
|
Timeout.tv_usec=0;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2010-06-07 01:50:26 +00:00
|
|
|
if (WSPSelect(0, &ReadSet, NULL, NULL, &Timeout, lpErrno) == SOCKET_ERROR)
|
|
|
|
{
|
|
|
|
NtClose(SockEvent);
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2010-06-07 01:50:26 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (ReadSet.fd_array[0] != Socket->Handle)
|
2009-03-27 03:21:21 +00:00
|
|
|
{
|
|
|
|
NtClose(SockEvent);
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
|
|
|
|
return SOCKET_ERROR;
|
2009-03-27 03:21:21 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_WAIT_FOR_LISTEN,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
ListenReceiveData,
|
|
|
|
0xA + sizeof(*ListenReceiveData));
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
NtClose( SockEvent );
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (lpfnCondition != NULL)
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_CONNECT_DATA) != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* Find out how much data is pending */
|
|
|
|
PendingAcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
|
|
|
|
PendingAcceptData.ReturnSize = TRUE;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_GET_PENDING_CONNECT_DATA,
|
|
|
|
&PendingAcceptData,
|
|
|
|
sizeof(PendingAcceptData),
|
|
|
|
&PendingAcceptData,
|
|
|
|
sizeof(PendingAcceptData));
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
NtClose( SockEvent );
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* How much data to allocate */
|
|
|
|
PendingDataLength = IOSB.Information;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (PendingDataLength)
|
|
|
|
{
|
|
|
|
/* Allocate needed space */
|
|
|
|
PendingData = HeapAlloc(GlobalHeap, 0, PendingDataLength);
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!PendingData)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL );
|
2009-08-18 18:53:10 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* We want the data now */
|
|
|
|
PendingAcceptData.ReturnSize = FALSE;
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_GET_PENDING_CONNECT_DATA,
|
|
|
|
&PendingAcceptData,
|
|
|
|
sizeof(PendingAcceptData),
|
|
|
|
PendingData,
|
|
|
|
PendingDataLength);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
NtClose( SockEvent );
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* I don't support this yet */
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Build Callee ID */
|
|
|
|
CalleeID.buf = (PVOID)Socket->LocalAddress;
|
2016-10-07 17:51:03 +00:00
|
|
|
CalleeID.len = Socket->SharedData->SizeOfLocalAddress;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2009-08-18 18:53:10 +00:00
|
|
|
RemoteAddress = HeapAlloc(GlobalHeap, 0, sizeof(*RemoteAddress));
|
|
|
|
if (!RemoteAddress)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
|
2009-08-18 18:53:10 +00:00
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Set up Address in SOCKADDR Format */
|
2011-10-03 14:40:39 +00:00
|
|
|
RtlCopyMemory (RemoteAddress,
|
|
|
|
&ListenReceiveData->Address.Address[0].AddressType,
|
2009-01-14 14:41:25 +00:00
|
|
|
sizeof(*RemoteAddress));
|
|
|
|
|
|
|
|
/* Build Caller ID */
|
|
|
|
CallerID.buf = (PVOID)RemoteAddress;
|
|
|
|
CallerID.len = sizeof(*RemoteAddress);
|
|
|
|
|
|
|
|
/* Build Caller Data */
|
|
|
|
CallerData.buf = PendingData;
|
|
|
|
CallerData.len = PendingDataLength;
|
|
|
|
|
|
|
|
/* Check if socket supports Conditional Accept */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->UseDelayedAcceptance != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* Allocate Buffer for Callee Data */
|
|
|
|
CalleeDataBuffer = HeapAlloc(GlobalHeap, 0, 4096);
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!CalleeDataBuffer) {
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL );
|
2009-08-18 18:53:10 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
CalleeData.buf = CalleeDataBuffer;
|
|
|
|
CalleeData.len = 4096;
|
2011-10-03 14:40:39 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Nothing */
|
|
|
|
CalleeData.buf = 0;
|
|
|
|
CalleeData.len = 0;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Call the Condition Function */
|
|
|
|
CallBack = (lpfnCondition)(&CallerID,
|
|
|
|
CallerData.buf == NULL ? NULL : &CallerData,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&CalleeID,
|
|
|
|
CalleeData.buf == NULL ? NULL : &CalleeData,
|
|
|
|
&GroupID,
|
|
|
|
dwCallbackData);
|
|
|
|
|
|
|
|
if (((CallBack == CF_ACCEPT) && GroupID) != 0)
|
|
|
|
{
|
|
|
|
/* TBD: Check for Validity */
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if (CallBack == CF_ACCEPT)
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* I don't support this yet */
|
|
|
|
}
|
|
|
|
if (CalleeData.buf)
|
|
|
|
{
|
|
|
|
// SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Callback rejected. Build Defer Structure */
|
|
|
|
DeferData.SequenceNumber = ListenReceiveData->SequenceNumber;
|
|
|
|
DeferData.RejectConnection = (CallBack == CF_REJECT);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_DEFER_ACCEPT,
|
|
|
|
&DeferData,
|
|
|
|
sizeof(DeferData),
|
|
|
|
NULL,
|
|
|
|
0);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (CallBack == CF_REJECT )
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAECONNREFUSED;
|
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAECONNREFUSED;
|
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create a new Socket */
|
2016-10-07 17:51:03 +00:00
|
|
|
AcceptSocket = WSPSocket (Socket->SharedData->AddressFamily,
|
|
|
|
Socket->SharedData->SocketType,
|
|
|
|
Socket->SharedData->Protocol,
|
2015-11-07 10:48:38 +00:00
|
|
|
&Socket->ProtocolInfo,
|
2009-01-14 14:41:25 +00:00
|
|
|
GroupID,
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->CreateFlags,
|
2010-06-07 01:50:26 +00:00
|
|
|
lpErrno);
|
|
|
|
if (AcceptSocket == INVALID_SOCKET)
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set up the Accept Structure */
|
2009-10-26 03:11:44 +00:00
|
|
|
AcceptData.ListenHandle = (HANDLE)AcceptSocket;
|
2009-01-14 14:41:25 +00:00
|
|
|
AcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
|
|
|
|
|
|
|
|
/* Send IOCTL to Accept */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_ACCEPT,
|
|
|
|
&AcceptData,
|
|
|
|
sizeof(AcceptData),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
2009-03-27 03:21:21 +00:00
|
|
|
NtClose(SockEvent);
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPCloseSocket( AcceptSocket, lpErrno );
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2011-06-20 17:35:02 +00:00
|
|
|
AcceptSocketInfo = GetSocketStructure(AcceptSocket);
|
|
|
|
if (!AcceptSocketInfo)
|
|
|
|
{
|
|
|
|
NtClose(SockEvent);
|
|
|
|
WSPCloseSocket( AcceptSocket, lpErrno );
|
2016-11-02 15:36:26 +00:00
|
|
|
return MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED, lpErrno, 0, NULL );
|
2011-06-20 17:35:02 +00:00
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
AcceptSocketInfo->SharedData->State = SocketConnected;
|
2016-11-10 17:55:00 +00:00
|
|
|
AcceptSocketInfo->SharedData->ConnectTime = GetCurrentTimeInSeconds();
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Return Address in SOCKADDR FORMAT */
|
|
|
|
if( SocketAddress )
|
|
|
|
{
|
|
|
|
RtlCopyMemory (SocketAddress,
|
|
|
|
&ListenReceiveData->Address.Address[0].AddressType,
|
|
|
|
sizeof(*RemoteAddress));
|
|
|
|
if( SocketAddressLength )
|
2016-10-05 09:39:12 +00:00
|
|
|
*SocketAddressLength = sizeof(*RemoteAddress);
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
|
|
|
/* Re-enable Async Event */
|
|
|
|
SockReenableAsyncSelectEvent(Socket, FD_ACCEPT);
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Socket %x\n", AcceptSocket);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2010-01-16 00:05:15 +00:00
|
|
|
if (Status == STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_ACCEPT))
|
|
|
|
{
|
|
|
|
Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_ACCEPT);
|
|
|
|
|
|
|
|
if (Status)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = Status;
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2010-01-16 00:05:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = NO_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Return Socket */
|
|
|
|
return AcceptSocket;
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
2011-10-03 14:40:39 +00:00
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPConnect(SOCKET Handle,
|
|
|
|
const struct sockaddr * SocketAddress,
|
|
|
|
int SocketAddressLength,
|
|
|
|
LPWSABUF lpCallerData,
|
|
|
|
LPWSABUF lpCalleeData,
|
|
|
|
LPQOS lpSQOS,
|
|
|
|
LPQOS lpGQOS,
|
|
|
|
LPINT lpErrno)
|
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK IOSB;
|
2011-10-03 15:23:51 +00:00
|
|
|
PAFD_CONNECT_INFO ConnectInfo = NULL;
|
|
|
|
PSOCKET_INFORMATION Socket;
|
2009-01-14 14:41:25 +00:00
|
|
|
NTSTATUS Status;
|
2011-10-03 15:01:48 +00:00
|
|
|
INT Errno;
|
2009-01-14 14:41:25 +00:00
|
|
|
ULONG ConnectDataLength;
|
|
|
|
ULONG InConnectDataLength;
|
|
|
|
INT BindAddressLength;
|
|
|
|
PSOCKADDR BindAddress;
|
|
|
|
HANDLE SockEvent;
|
2011-10-03 15:23:51 +00:00
|
|
|
int SocketDataLength;
|
2016-10-30 05:58:02 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
TRACE("Called (%lx) %lx:%d\n", Handle, ((const struct sockaddr_in *)SocketAddress)->sin_addr, ((const struct sockaddr_in *)SocketAddress)->sin_port);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
2010-06-07 01:24:15 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
|
|
|
EVENT_ALL_ACCESS,
|
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2016-11-02 15:36:26 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Bind us First */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->State == SocketOpen)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* Get the Wildcard Address */
|
|
|
|
BindAddressLength = Socket->HelperData->MaxWSAddressLength;
|
|
|
|
BindAddress = HeapAlloc(GetProcessHeap(), 0, BindAddressLength);
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!BindAddress)
|
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
NtClose(SockEvent);
|
|
|
|
return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
|
2009-08-18 18:53:10 +00:00
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
Socket->HelperData->WSHGetWildcardSockaddr (Socket->HelperContext,
|
|
|
|
BindAddress,
|
2009-01-14 14:41:25 +00:00
|
|
|
&BindAddressLength);
|
|
|
|
/* Bind it */
|
2010-05-28 05:15:42 +00:00
|
|
|
if (WSPBind(Handle, BindAddress, BindAddressLength, lpErrno) == SOCKET_ERROR)
|
2011-10-03 15:01:48 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Set the Connect Data */
|
|
|
|
if (lpCallerData != NULL)
|
|
|
|
{
|
|
|
|
ConnectDataLength = lpCallerData->len;
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_SET_CONNECT_DATA,
|
|
|
|
lpCallerData->buf,
|
|
|
|
ConnectDataLength,
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
2010-06-06 23:07:26 +00:00
|
|
|
|
|
|
|
if (Status != STATUS_SUCCESS)
|
|
|
|
goto notify;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
2011-10-03 15:23:51 +00:00
|
|
|
/* Calculate the size of SocketAddress->sa_data */
|
|
|
|
SocketDataLength = SocketAddressLength - FIELD_OFFSET(struct sockaddr, sa_data);
|
|
|
|
|
|
|
|
/* Allocate a connection info buffer with SocketDataLength bytes of payload */
|
|
|
|
ConnectInfo = HeapAlloc(GetProcessHeap(), 0,
|
|
|
|
FIELD_OFFSET(AFD_CONNECT_INFO,
|
|
|
|
RemoteAddress.Address[0].Address[SocketDataLength]));
|
|
|
|
if (!ConnectInfo)
|
|
|
|
{
|
|
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
|
|
goto notify;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set up Address in TDI Format */
|
|
|
|
ConnectInfo->RemoteAddress.TAAddressCount = 1;
|
2011-10-03 15:23:51 +00:00
|
|
|
ConnectInfo->RemoteAddress.Address[0].AddressLength = SocketDataLength;
|
2009-01-14 14:41:25 +00:00
|
|
|
ConnectInfo->RemoteAddress.Address[0].AddressType = SocketAddress->sa_family;
|
2011-10-03 15:23:51 +00:00
|
|
|
RtlCopyMemory(ConnectInfo->RemoteAddress.Address[0].Address,
|
|
|
|
SocketAddress->sa_data,
|
|
|
|
SocketDataLength);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/*
|
|
|
|
* Disable FD_WRITE and FD_CONNECT
|
2009-01-14 14:41:25 +00:00
|
|
|
* The latter fixes a race condition where the FD_CONNECT is re-enabled
|
|
|
|
* at the end of this function right after the Async Thread disables it.
|
|
|
|
* This should only happen at the *next* WSPConnect
|
|
|
|
*/
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->AsyncEvents & FD_CONNECT)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_CONNECT | FD_WRITE;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Tell AFD that we want Connection Data back, have it allocate a buffer */
|
|
|
|
if (lpCalleeData != NULL)
|
|
|
|
{
|
|
|
|
InConnectDataLength = lpCalleeData->len;
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_SET_CONNECT_DATA_SIZE,
|
|
|
|
&InConnectDataLength,
|
|
|
|
sizeof(InConnectDataLength),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
2010-06-06 23:07:26 +00:00
|
|
|
|
|
|
|
if (Status != STATUS_SUCCESS)
|
|
|
|
goto notify;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
|
|
|
|
ConnectInfo->Root = 0;
|
|
|
|
ConnectInfo->UseSAN = FALSE;
|
|
|
|
ConnectInfo->Unknown = 0;
|
|
|
|
|
|
|
|
/* FIXME: Handle Async Connect */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->NonBlocking)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-10-30 05:58:02 +00:00
|
|
|
ERR("Async Connect UNIMPLEMENTED!\n");
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
2016-10-30 05:58:02 +00:00
|
|
|
NULL,
|
|
|
|
NULL,
|
2009-01-14 14:41:25 +00:00
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_CONNECT,
|
|
|
|
ConnectInfo,
|
|
|
|
0x22,
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
/* Wait for return */
|
2016-10-30 05:58:02 +00:00
|
|
|
if (Status == STATUS_PENDING)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Status != STATUS_SUCCESS)
|
|
|
|
goto notify;
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->State = SocketConnected;
|
2010-01-16 00:05:15 +00:00
|
|
|
Socket->TdiConnectionHandle = (HANDLE)IOSB.Information;
|
2016-11-10 17:55:00 +00:00
|
|
|
Socket->SharedData->ConnectTime = GetCurrentTimeInSeconds();
|
2010-01-16 00:05:15 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Get any pending connect data */
|
|
|
|
if (lpCalleeData != NULL)
|
|
|
|
{
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_GET_CONNECT_DATA,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
lpCalleeData->buf,
|
|
|
|
lpCalleeData->len);
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
TRACE("Ending %lx\n", IOSB.Status);
|
2010-06-06 23:07:26 +00:00
|
|
|
|
|
|
|
notify:
|
2011-10-03 15:23:51 +00:00
|
|
|
if (ConnectInfo) HeapFree(GetProcessHeap(), 0, ConnectInfo);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Re-enable Async Event */
|
|
|
|
SockReenableAsyncSelectEvent(Socket, FD_WRITE);
|
|
|
|
|
|
|
|
/* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
|
|
|
|
SockReenableAsyncSelectEvent(Socket, FD_CONNECT);
|
|
|
|
|
2011-10-03 15:01:48 +00:00
|
|
|
NtClose(SockEvent);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2010-01-16 00:05:15 +00:00
|
|
|
if (Status == STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT))
|
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
Errno = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_CONNECT);
|
2010-01-16 00:05:15 +00:00
|
|
|
|
2011-10-03 15:01:48 +00:00
|
|
|
if (Errno)
|
2010-01-16 00:05:15 +00:00
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
if (lpErrno) *lpErrno = Errno;
|
2010-01-16 00:05:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (Status != STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT_ERROR))
|
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
Errno = Socket->HelperData->WSHNotify(Socket->HelperContext,
|
|
|
|
Socket->Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
WSH_NOTIFY_CONNECT_ERROR);
|
2010-01-16 00:05:15 +00:00
|
|
|
|
2011-10-03 15:01:48 +00:00
|
|
|
if (Errno)
|
2010-01-16 00:05:15 +00:00
|
|
|
{
|
2011-10-03 15:01:48 +00:00
|
|
|
if (lpErrno) *lpErrno = Errno;
|
2010-01-16 00:05:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-03 15:01:48 +00:00
|
|
|
return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
int
|
2011-10-03 14:40:39 +00:00
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPShutdown(SOCKET Handle,
|
|
|
|
int HowTo,
|
|
|
|
LPINT lpErrno)
|
|
|
|
|
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
AFD_DISCONNECT_INFO DisconnectInfo;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
NTSTATUS Status;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Called\n");
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2010-06-07 01:24:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
|
|
|
EVENT_ALL_ACCESS,
|
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2016-11-02 15:36:26 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Set AFD Disconnect Type */
|
|
|
|
switch (HowTo)
|
|
|
|
{
|
|
|
|
case SD_RECEIVE:
|
|
|
|
DisconnectInfo.DisconnectType = AFD_DISCONNECT_RECV;
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->ReceiveShutdown = TRUE;
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
case SD_SEND:
|
|
|
|
DisconnectInfo.DisconnectType= AFD_DISCONNECT_SEND;
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->SendShutdown = TRUE;
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
case SD_BOTH:
|
|
|
|
DisconnectInfo.DisconnectType = AFD_DISCONNECT_RECV | AFD_DISCONNECT_SEND;
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->ReceiveShutdown = TRUE;
|
|
|
|
Socket->SharedData->SendShutdown = TRUE;
|
2009-01-14 14:41:25 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-07-02 20:36:35 +00:00
|
|
|
DisconnectInfo.Timeout = RtlConvertLongToLargeInteger(-1000000);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_DISCONNECT,
|
|
|
|
&DisconnectInfo,
|
|
|
|
sizeof(DisconnectInfo),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Ending\n");
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPGetSockName(IN SOCKET Handle,
|
|
|
|
OUT LPSOCKADDR Name,
|
|
|
|
IN OUT LPINT NameLength,
|
|
|
|
OUT LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
ULONG TdiAddressSize;
|
2016-11-11 21:25:02 +00:00
|
|
|
PTDI_ADDRESS_INFO TdiAddress;
|
2009-01-14 14:41:25 +00:00
|
|
|
PTRANSPORT_ADDRESS SocketAddress;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
NTSTATUS Status;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2010-06-07 01:24:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2011-06-11 17:49:30 +00:00
|
|
|
if (!Name || !NameLength)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-06-11 17:49:30 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
|
|
|
EVENT_ALL_ACCESS,
|
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2016-11-02 15:36:26 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Allocate a buffer for the address */
|
2011-10-03 14:40:39 +00:00
|
|
|
TdiAddressSize =
|
2016-11-11 21:25:02 +00:00
|
|
|
sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfLocalAddress;
|
2009-01-14 14:41:25 +00:00
|
|
|
TdiAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
|
2008-05-31 12:53:55 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if ( TdiAddress == NULL )
|
|
|
|
{
|
|
|
|
NtClose( SockEvent );
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOBUFS;
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
SocketAddress = &TdiAddress->Address;
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_GET_SOCK_NAME,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
TdiAddress,
|
|
|
|
TdiAddressSize);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
|
|
|
if (NT_SUCCESS(Status))
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if (*NameLength >= Socket->SharedData->SizeOfLocalAddress)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
Name->sa_family = SocketAddress->Address[0].AddressType;
|
|
|
|
RtlCopyMemory (Name->sa_data,
|
2011-10-03 14:40:39 +00:00
|
|
|
SocketAddress->Address[0].Address,
|
2009-01-14 14:41:25 +00:00
|
|
|
SocketAddress->Address[0].AddressLength);
|
2016-10-07 17:51:03 +00:00
|
|
|
*NameLength = Socket->SharedData->SizeOfLocalAddress;
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("NameLength %d Address: %x Port %x\n",
|
2009-01-14 14:41:25 +00:00
|
|
|
*NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
|
2014-11-10 13:06:48 +00:00
|
|
|
((struct sockaddr_in *)Name)->sin_port);
|
2009-01-14 14:41:25 +00:00
|
|
|
HeapFree(GlobalHeap, 0, TdiAddress);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
HeapFree(GlobalHeap, 0, TdiAddress);
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2012-08-18 16:36:05 +00:00
|
|
|
HeapFree(GlobalHeap, 0, TdiAddress);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPGetPeerName(IN SOCKET s,
|
|
|
|
OUT LPSOCKADDR Name,
|
|
|
|
IN OUT LPINT NameLength,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
ULONG TdiAddressSize;
|
|
|
|
PTRANSPORT_ADDRESS SocketAddress;
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
NTSTATUS Status;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
|
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(s);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
2010-06-07 01:24:15 +00:00
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->State != SocketConnected)
|
2011-06-11 17:49:30 +00:00
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTCONN;
|
2011-06-11 17:49:30 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Name || !NameLength)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-06-11 17:49:30 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
|
|
|
EVENT_ALL_ACCESS,
|
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2016-11-02 15:36:26 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Allocate a buffer for the address */
|
2016-10-07 17:51:03 +00:00
|
|
|
TdiAddressSize = sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfRemoteAddress;
|
2009-03-16 20:59:05 +00:00
|
|
|
SocketAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2009-03-16 20:59:05 +00:00
|
|
|
if ( SocketAddress == NULL )
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
NtClose( SockEvent );
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOBUFS;
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_GET_PEER_NAME,
|
|
|
|
NULL,
|
|
|
|
0,
|
2009-03-16 20:59:05 +00:00
|
|
|
SocketAddress,
|
2009-01-14 14:41:25 +00:00
|
|
|
TdiAddressSize);
|
|
|
|
|
|
|
|
/* Wait for return */
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
|
|
|
Status = IOSB.Status;
|
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
|
|
|
if (NT_SUCCESS(Status))
|
|
|
|
{
|
2016-10-07 17:51:03 +00:00
|
|
|
if (*NameLength >= Socket->SharedData->SizeOfRemoteAddress)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
Name->sa_family = SocketAddress->Address[0].AddressType;
|
|
|
|
RtlCopyMemory (Name->sa_data,
|
2011-10-03 14:40:39 +00:00
|
|
|
SocketAddress->Address[0].Address,
|
2009-01-14 14:41:25 +00:00
|
|
|
SocketAddress->Address[0].AddressLength);
|
2016-10-07 17:51:03 +00:00
|
|
|
*NameLength = Socket->SharedData->SizeOfRemoteAddress;
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("NameLength %d Address: %x Port %x\n",
|
2009-01-14 14:41:25 +00:00
|
|
|
*NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
|
2014-11-10 13:06:48 +00:00
|
|
|
((struct sockaddr_in *)Name)->sin_port);
|
2009-03-16 20:59:05 +00:00
|
|
|
HeapFree(GlobalHeap, 0, SocketAddress);
|
2009-01-14 14:41:25 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2009-03-16 20:59:05 +00:00
|
|
|
HeapFree(GlobalHeap, 0, SocketAddress);
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2009-01-14 14:41:25 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-08-18 16:36:05 +00:00
|
|
|
HeapFree(GlobalHeap, 0, SocketAddress);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
|
|
|
|
}
|
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPIoctl(IN SOCKET Handle,
|
|
|
|
IN DWORD dwIoControlCode,
|
|
|
|
IN LPVOID lpvInBuffer,
|
|
|
|
IN DWORD cbInBuffer,
|
|
|
|
OUT LPVOID lpvOutBuffer,
|
|
|
|
IN DWORD cbOutBuffer,
|
|
|
|
OUT LPDWORD lpcbBytesReturned,
|
|
|
|
IN LPWSAOVERLAPPED lpOverlapped,
|
|
|
|
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
|
|
|
|
IN LPWSATHREADID lpThreadId,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
2016-11-09 12:05:48 +00:00
|
|
|
BOOL NeedsCompletion = lpOverlapped != NULL;
|
2011-07-04 17:37:45 +00:00
|
|
|
BOOLEAN NonBlocking;
|
2016-10-25 07:54:00 +00:00
|
|
|
INT Errno = NO_ERROR, Ret = SOCKET_ERROR;
|
|
|
|
DWORD cbRet = 0;
|
2012-06-21 23:43:24 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
2010-06-07 01:24:15 +00:00
|
|
|
if (!Socket)
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
if(lpErrno)
|
|
|
|
*lpErrno = WSAENOTSOCK;
|
|
|
|
return SOCKET_ERROR;
|
2010-06-07 01:24:15 +00:00
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
if (!lpcbBytesReturned && !lpOverlapped)
|
|
|
|
{
|
|
|
|
if(lpErrno)
|
|
|
|
*lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
switch( dwIoControlCode )
|
|
|
|
{
|
|
|
|
case FIONBIO:
|
2009-10-03 18:21:14 +00:00
|
|
|
if( cbInBuffer < sizeof(INT) || IS_INTRESOURCE(lpvInBuffer) )
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
2009-10-03 18:21:14 +00:00
|
|
|
}
|
2011-07-04 17:37:45 +00:00
|
|
|
NonBlocking = *((PULONG)lpvInBuffer) ? TRUE : FALSE;
|
2016-11-04 09:38:21 +00:00
|
|
|
/* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
|
|
|
|
if (!NonBlocking)
|
|
|
|
{
|
|
|
|
/* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
|
|
|
|
if (Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents))
|
|
|
|
{
|
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* If there is an WSPEventSelect pending, fail with WSAEINVAL */
|
|
|
|
if (Socket->NetworkEvents)
|
|
|
|
{
|
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->NonBlocking = NonBlocking ? 1 : 0;
|
2016-10-25 07:54:00 +00:00
|
|
|
NeedsCompletion = FALSE;
|
|
|
|
Errno = SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &NonBlocking, NULL, NULL, lpOverlapped, lpCompletionRoutine);
|
|
|
|
if (Errno == NO_ERROR)
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
break;
|
2009-01-14 14:41:25 +00:00
|
|
|
case FIONREAD:
|
2016-10-10 06:38:52 +00:00
|
|
|
if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
|
2009-10-03 18:21:14 +00:00
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
cbRet = sizeof(ULONG);
|
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
2009-10-03 18:21:14 +00:00
|
|
|
}
|
2016-10-10 06:38:52 +00:00
|
|
|
if (cbOutBuffer < sizeof(ULONG))
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
2016-10-10 06:38:52 +00:00
|
|
|
}
|
2016-10-25 07:54:00 +00:00
|
|
|
NeedsCompletion = FALSE;
|
|
|
|
Errno = GetSocketInformation(Socket, AFD_INFO_RECEIVE_CONTENT_SIZE, NULL, (PULONG)lpvOutBuffer, NULL, lpOverlapped, lpCompletionRoutine);
|
|
|
|
if (Errno == NO_ERROR)
|
|
|
|
{
|
|
|
|
cbRet = sizeof(ULONG);
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
}
|
|
|
|
break;
|
2012-08-24 06:23:45 +00:00
|
|
|
case SIOCATMARK:
|
2016-10-10 06:38:52 +00:00
|
|
|
if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
|
2012-08-24 06:23:45 +00:00
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
cbRet = sizeof(BOOL);
|
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
2012-08-24 06:23:45 +00:00
|
|
|
}
|
2016-10-10 06:38:52 +00:00
|
|
|
if (cbOutBuffer < sizeof(BOOL))
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
2016-10-10 06:38:52 +00:00
|
|
|
}
|
2016-11-02 15:36:26 +00:00
|
|
|
if (Socket->SharedData->SocketType != SOCK_STREAM)
|
|
|
|
{
|
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
|
|
|
}
|
2012-08-24 06:23:45 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
/* FIXME: Return false if OOBINLINE is true for now
|
|
|
|
We should MSG_PEEK|MSG_OOB check with driver
|
|
|
|
*/
|
|
|
|
*(BOOL*)lpvOutBuffer = !Socket->SharedData->OobInline;
|
2012-08-24 06:23:45 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
cbRet = sizeof(BOOL);
|
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
break;
|
2011-06-24 04:31:31 +00:00
|
|
|
case SIO_GET_EXTENSION_FUNCTION_POINTER:
|
2019-02-16 12:46:40 +00:00
|
|
|
if (cbOutBuffer == 0)
|
|
|
|
{
|
|
|
|
cbRet = sizeof(PVOID);
|
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cbInBuffer < sizeof(GUID) ||
|
|
|
|
cbOutBuffer < sizeof(PVOID))
|
|
|
|
{
|
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
GUID AcceptExGUID = WSAID_ACCEPTEX;
|
|
|
|
GUID ConnectExGUID = WSAID_CONNECTEX;
|
|
|
|
GUID DisconnectExGUID = WSAID_DISCONNECTEX;
|
|
|
|
GUID GetAcceptExSockaddrsGUID = WSAID_GETACCEPTEXSOCKADDRS;
|
|
|
|
|
|
|
|
if (IsEqualGUID(&AcceptExGUID, lpvInBuffer))
|
|
|
|
{
|
|
|
|
*((PVOID *)lpvOutBuffer) = WSPAcceptEx;
|
|
|
|
cbRet = sizeof(PVOID);
|
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
}
|
|
|
|
else if (IsEqualGUID(&ConnectExGUID, lpvInBuffer))
|
|
|
|
{
|
|
|
|
*((PVOID *)lpvOutBuffer) = WSPConnectEx;
|
|
|
|
cbRet = sizeof(PVOID);
|
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
}
|
|
|
|
else if (IsEqualGUID(&DisconnectExGUID, lpvInBuffer))
|
|
|
|
{
|
|
|
|
*((PVOID *)lpvOutBuffer) = WSPDisconnectEx;
|
|
|
|
cbRet = sizeof(PVOID);
|
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
}
|
|
|
|
else if (IsEqualGUID(&GetAcceptExSockaddrsGUID, lpvInBuffer))
|
|
|
|
{
|
|
|
|
*((PVOID *)lpvOutBuffer) = WSPGetAcceptExSockaddrs;
|
|
|
|
cbRet = sizeof(PVOID);
|
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
ERR("Querying unknown extension function: %x\n", ((GUID*)lpvInBuffer)->Data1);
|
|
|
|
Errno = WSAEOPNOTSUPP;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
break;
|
2016-10-04 18:27:17 +00:00
|
|
|
case SIO_ADDRESS_LIST_QUERY:
|
2016-10-10 06:38:52 +00:00
|
|
|
if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
|
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
2016-10-10 06:38:52 +00:00
|
|
|
}
|
|
|
|
if (cbOutBuffer < sizeof(INT))
|
2016-10-04 18:27:17 +00:00
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = WSAEINVAL;
|
|
|
|
break;
|
2016-10-04 18:27:17 +00:00
|
|
|
}
|
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
|
2016-10-04 18:27:17 +00:00
|
|
|
|
|
|
|
((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->iAddressCount = 1;
|
2016-10-10 06:38:52 +00:00
|
|
|
|
|
|
|
if (cbOutBuffer < (sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress)))
|
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = WSAEFAULT;
|
|
|
|
break;
|
2016-10-10 06:38:52 +00:00
|
|
|
}
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].iSockaddrLength = sizeof(Socket->SharedData->WSLocalAddress);
|
|
|
|
((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].lpSockaddr = &Socket->SharedData->WSLocalAddress;
|
2016-10-04 18:27:17 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = NO_ERROR;
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
break;
|
2009-01-14 14:41:25 +00:00
|
|
|
default:
|
2016-10-25 07:54:00 +00:00
|
|
|
Errno = Socket->HelperData->WSHIoctl(Socket->HelperContext,
|
|
|
|
Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
dwIoControlCode,
|
|
|
|
lpvInBuffer,
|
|
|
|
cbInBuffer,
|
|
|
|
lpvOutBuffer,
|
|
|
|
cbOutBuffer,
|
|
|
|
&cbRet,
|
|
|
|
lpOverlapped,
|
|
|
|
lpCompletionRoutine,
|
2016-11-09 12:05:48 +00:00
|
|
|
&NeedsCompletion);
|
2016-10-25 07:54:00 +00:00
|
|
|
|
|
|
|
if (Errno == NO_ERROR)
|
|
|
|
Ret = NO_ERROR;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (lpOverlapped && NeedsCompletion)
|
|
|
|
{
|
|
|
|
lpOverlapped->Internal = Errno;
|
|
|
|
lpOverlapped->InternalHigh = cbRet;
|
|
|
|
if (lpCompletionRoutine != NULL)
|
|
|
|
{
|
|
|
|
lpCompletionRoutine(Errno, cbRet, lpOverlapped, 0);
|
|
|
|
}
|
|
|
|
if (lpOverlapped->hEvent)
|
|
|
|
SetEvent(lpOverlapped->hEvent);
|
|
|
|
if (!PostQueuedCompletionStatus((HANDLE)Handle, cbRet, 0, lpOverlapped))
|
|
|
|
{
|
|
|
|
ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
|
|
|
|
}
|
|
|
|
return NO_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2016-10-25 07:54:00 +00:00
|
|
|
if (lpErrno)
|
|
|
|
*lpErrno = Errno;
|
|
|
|
if (lpcbBytesReturned)
|
|
|
|
*lpcbBytesReturned = cbRet;
|
|
|
|
return Ret;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPGetSockOpt(IN SOCKET Handle,
|
|
|
|
IN INT Level,
|
|
|
|
IN INT OptionName,
|
|
|
|
OUT CHAR FAR* OptionValue,
|
|
|
|
IN OUT LPINT OptionLength,
|
|
|
|
OUT LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
|
|
|
PSOCKET_INFORMATION Socket = NULL;
|
|
|
|
PVOID Buffer;
|
|
|
|
INT BufferSize;
|
2011-08-11 07:08:16 +00:00
|
|
|
BOOL BoolBuffer;
|
2016-11-10 17:55:00 +00:00
|
|
|
DWORD DwordBuffer;
|
2016-11-02 15:36:26 +00:00
|
|
|
INT Errno;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
TRACE("Called\n");
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(Handle);
|
|
|
|
if (Socket == NULL)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2006-02-17 00:04:10 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-11-07 08:50:31 +00:00
|
|
|
if (!OptionLength || !OptionValue)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
switch (Level)
|
|
|
|
{
|
|
|
|
case SOL_SOCKET:
|
|
|
|
switch (OptionName)
|
|
|
|
{
|
|
|
|
case SO_TYPE:
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->SocketType;
|
2006-02-17 00:04:10 +00:00
|
|
|
BufferSize = sizeof(INT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_RCVBUF:
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->SizeOfRecvBuffer;
|
2006-02-17 00:04:10 +00:00
|
|
|
BufferSize = sizeof(INT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_SNDBUF:
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->SizeOfSendBuffer;
|
2006-02-17 00:04:10 +00:00
|
|
|
BufferSize = sizeof(INT);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_ACCEPTCONN:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = Socket->SharedData->Listening;
|
2006-02-17 00:04:10 +00:00
|
|
|
Buffer = &BoolBuffer;
|
2011-08-11 07:08:16 +00:00
|
|
|
BufferSize = sizeof(BOOL);
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_BROADCAST:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = Socket->SharedData->Broadcast;
|
2006-02-17 00:04:10 +00:00
|
|
|
Buffer = &BoolBuffer;
|
2011-08-11 07:08:16 +00:00
|
|
|
BufferSize = sizeof(BOOL);
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_DEBUG:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = Socket->SharedData->Debug;
|
2006-02-17 00:04:10 +00:00
|
|
|
Buffer = &BoolBuffer;
|
2011-08-11 07:08:16 +00:00
|
|
|
BufferSize = sizeof(BOOL);
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_DONTLINGER:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = (Socket->SharedData->LingerData.l_onoff == 0);
|
2011-08-11 07:08:16 +00:00
|
|
|
Buffer = &BoolBuffer;
|
|
|
|
BufferSize = sizeof(BOOL);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_LINGER:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->SocketType == SOCK_DGRAM)
|
2015-11-09 17:00:26 +00:00
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOPROTOOPT;
|
2015-11-09 17:00:26 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->LingerData;
|
2011-08-11 07:08:16 +00:00
|
|
|
BufferSize = sizeof(struct linger);
|
|
|
|
break;
|
|
|
|
|
2012-08-18 09:57:27 +00:00
|
|
|
case SO_OOBINLINE:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = (Socket->SharedData->OobInline != 0);
|
2012-08-18 09:57:27 +00:00
|
|
|
Buffer = &BoolBuffer;
|
|
|
|
BufferSize = sizeof(BOOL);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_KEEPALIVE:
|
2006-02-17 00:04:10 +00:00
|
|
|
case SO_DONTROUTE:
|
2012-08-18 09:57:27 +00:00
|
|
|
/* These guys go directly to the helper */
|
|
|
|
goto SendToHelper;
|
|
|
|
|
|
|
|
case SO_CONDITIONAL_ACCEPT:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = (Socket->SharedData->UseDelayedAcceptance != 0);
|
2012-08-18 09:57:27 +00:00
|
|
|
Buffer = &BoolBuffer;
|
|
|
|
BufferSize = sizeof(BOOL);
|
|
|
|
break;
|
|
|
|
|
|
|
|
case SO_REUSEADDR:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = (Socket->SharedData->ReuseAddresses != 0);
|
2012-08-18 09:57:27 +00:00
|
|
|
Buffer = &BoolBuffer;
|
|
|
|
BufferSize = sizeof(BOOL);
|
|
|
|
break;
|
|
|
|
|
2012-08-20 05:48:52 +00:00
|
|
|
case SO_EXCLUSIVEADDRUSE:
|
2016-10-07 17:51:03 +00:00
|
|
|
BoolBuffer = (Socket->SharedData->ExclusiveAddressUse != 0);
|
2012-08-20 05:48:52 +00:00
|
|
|
Buffer = &BoolBuffer;
|
|
|
|
BufferSize = sizeof(BOOL);
|
|
|
|
break;
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
case SO_ERROR:
|
2016-11-07 08:50:31 +00:00
|
|
|
Buffer = &Socket->SharedData->SocketLastError;
|
2012-08-18 09:57:27 +00:00
|
|
|
BufferSize = sizeof(INT);
|
|
|
|
break;
|
2016-11-07 08:50:31 +00:00
|
|
|
|
2016-11-10 17:55:00 +00:00
|
|
|
case SO_CONNECT_TIME:
|
|
|
|
DwordBuffer = GetCurrentTimeInSeconds() - Socket->SharedData->ConnectTime;
|
|
|
|
Buffer = &DwordBuffer;
|
|
|
|
BufferSize = sizeof(DWORD);
|
|
|
|
break;
|
|
|
|
|
2015-11-02 18:12:23 +00:00
|
|
|
case SO_SNDTIMEO:
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->SendTimeout;
|
2015-11-02 18:12:23 +00:00
|
|
|
BufferSize = sizeof(DWORD);
|
|
|
|
break;
|
|
|
|
case SO_RCVTIMEO:
|
2016-10-07 17:51:03 +00:00
|
|
|
Buffer = &Socket->SharedData->RecvTimeout;
|
2015-11-02 18:12:23 +00:00
|
|
|
BufferSize = sizeof(DWORD);
|
|
|
|
break;
|
2015-11-07 10:48:38 +00:00
|
|
|
case SO_PROTOCOL_INFOW:
|
|
|
|
Buffer = &Socket->ProtocolInfo;
|
|
|
|
BufferSize = sizeof(Socket->ProtocolInfo);
|
|
|
|
break;
|
2012-08-18 09:57:27 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
case SO_GROUP_ID:
|
|
|
|
case SO_GROUP_PRIORITY:
|
|
|
|
case SO_MAX_MSG_SIZE:
|
|
|
|
|
|
|
|
default:
|
2012-08-18 09:57:27 +00:00
|
|
|
DbgPrint("MSAFD: Get unknown optname %x\n", OptionName);
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOPROTOOPT;
|
2006-02-17 00:04:10 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
if (*OptionLength < BufferSize)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2006-02-17 00:04:10 +00:00
|
|
|
*OptionLength = BufferSize;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
RtlCopyMemory(OptionValue, Buffer, BufferSize);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
default:
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
2012-08-18 09:57:27 +00:00
|
|
|
|
|
|
|
SendToHelper:
|
2016-11-02 15:36:26 +00:00
|
|
|
Errno = Socket->HelperData->WSHGetSocketInformation(Socket->HelperContext,
|
|
|
|
Handle,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
Level,
|
|
|
|
OptionName,
|
|
|
|
OptionValue,
|
|
|
|
(LPINT)OptionLength);
|
|
|
|
if (lpErrno) *lpErrno = Errno;
|
|
|
|
return (Errno == NO_ERROR) ? NO_ERROR : SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2010-01-16 00:05:15 +00:00
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPSetSockOpt(
|
|
|
|
IN SOCKET s,
|
|
|
|
IN INT level,
|
|
|
|
IN INT optname,
|
|
|
|
IN CONST CHAR FAR* optval,
|
|
|
|
IN INT optlen,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
|
|
|
PSOCKET_INFORMATION Socket;
|
2016-11-02 15:36:26 +00:00
|
|
|
INT Errno;
|
2010-01-16 00:05:15 +00:00
|
|
|
|
|
|
|
/* Get the Socket Structure associate to this Socket*/
|
|
|
|
Socket = GetSocketStructure(s);
|
|
|
|
if (Socket == NULL)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAENOTSOCK;
|
2010-01-16 00:05:15 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-11-07 08:50:31 +00:00
|
|
|
if (!optval)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2010-01-16 00:05:15 +00:00
|
|
|
|
|
|
|
|
2010-06-27 17:21:03 +00:00
|
|
|
/* FIXME: We should handle some more cases here */
|
2016-09-20 16:31:53 +00:00
|
|
|
if (level == SOL_SOCKET)
|
2010-06-27 17:21:03 +00:00
|
|
|
{
|
|
|
|
switch (optname)
|
|
|
|
{
|
|
|
|
case SO_BROADCAST:
|
2011-08-11 07:08:16 +00:00
|
|
|
if (optlen < sizeof(BOOL))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-08-11 07:08:16 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->Broadcast = (*optval != 0) ? 1 : 0;
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
|
|
|
|
|
|
|
case SO_OOBINLINE:
|
|
|
|
if (optlen < sizeof(BOOL))
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
Socket->SharedData->OobInline = (*optval != 0) ? 1 : 0;
|
|
|
|
return NO_ERROR;
|
2011-08-11 07:08:16 +00:00
|
|
|
|
|
|
|
case SO_DONTLINGER:
|
|
|
|
if (optlen < sizeof(BOOL))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-08-11 07:08:16 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->LingerData.l_onoff = (*optval != 0) ? 0 : 1;
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2011-08-11 07:08:16 +00:00
|
|
|
|
2012-08-20 05:48:52 +00:00
|
|
|
case SO_REUSEADDR:
|
|
|
|
if (optlen < sizeof(BOOL))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2012-08-20 05:48:52 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->ReuseAddresses = (*optval != 0) ? 1 : 0;
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2012-08-20 05:48:52 +00:00
|
|
|
|
|
|
|
case SO_EXCLUSIVEADDRUSE:
|
|
|
|
if (optlen < sizeof(BOOL))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2012-08-20 05:48:52 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->ExclusiveAddressUse = (*optval != 0) ? 1 : 0;
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2012-08-20 05:48:52 +00:00
|
|
|
|
2011-08-11 07:08:16 +00:00
|
|
|
case SO_LINGER:
|
|
|
|
if (optlen < sizeof(struct linger))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-08-11 07:08:16 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
2016-10-07 17:51:03 +00:00
|
|
|
RtlCopyMemory(&Socket->SharedData->LingerData,
|
2011-08-11 07:08:16 +00:00
|
|
|
optval,
|
|
|
|
sizeof(struct linger));
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2011-08-11 07:08:16 +00:00
|
|
|
|
2011-12-12 22:31:09 +00:00
|
|
|
case SO_SNDBUF:
|
|
|
|
if (optlen < sizeof(DWORD))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2011-12-12 22:31:09 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2019-02-25 21:30:01 +00:00
|
|
|
SetSocketInformation(Socket,
|
|
|
|
AFD_INFO_SEND_WINDOW_SIZE,
|
|
|
|
NULL,
|
|
|
|
(PULONG)optval,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
|
|
|
GetSocketInformation(Socket,
|
|
|
|
AFD_INFO_SEND_WINDOW_SIZE,
|
|
|
|
NULL,
|
|
|
|
&Socket->SharedData->SizeOfSendBuffer,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2011-12-12 22:31:09 +00:00
|
|
|
|
2019-02-24 20:25:39 +00:00
|
|
|
case SO_RCVBUF:
|
|
|
|
if (optlen < sizeof(DWORD))
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2019-02-25 21:30:01 +00:00
|
|
|
SetSocketInformation(Socket,
|
|
|
|
AFD_INFO_RECEIVE_WINDOW_SIZE,
|
|
|
|
NULL,
|
|
|
|
(PULONG)optval,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
|
|
|
GetSocketInformation(Socket,
|
|
|
|
AFD_INFO_RECEIVE_WINDOW_SIZE,
|
|
|
|
NULL,
|
|
|
|
&Socket->SharedData->SizeOfSendBuffer,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
|
|
|
|
2019-02-24 20:25:39 +00:00
|
|
|
return NO_ERROR;
|
|
|
|
|
2016-11-07 08:50:31 +00:00
|
|
|
case SO_ERROR:
|
|
|
|
if (optlen < sizeof(INT))
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
RtlCopyMemory(&Socket->SharedData->SocketLastError,
|
|
|
|
optval,
|
|
|
|
sizeof(INT));
|
|
|
|
return NO_ERROR;
|
|
|
|
|
2012-08-18 09:57:27 +00:00
|
|
|
case SO_SNDTIMEO:
|
|
|
|
if (optlen < sizeof(DWORD))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2012-08-18 09:57:27 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
RtlCopyMemory(&Socket->SharedData->SendTimeout,
|
2012-08-18 09:57:27 +00:00
|
|
|
optval,
|
|
|
|
sizeof(DWORD));
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2012-08-18 09:57:27 +00:00
|
|
|
|
|
|
|
case SO_RCVTIMEO:
|
|
|
|
if (optlen < sizeof(DWORD))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2012-08-18 09:57:27 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2016-10-07 17:51:03 +00:00
|
|
|
RtlCopyMemory(&Socket->SharedData->RecvTimeout,
|
2012-08-18 09:57:27 +00:00
|
|
|
optval,
|
|
|
|
sizeof(DWORD));
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2012-08-18 09:57:27 +00:00
|
|
|
|
|
|
|
case SO_KEEPALIVE:
|
|
|
|
case SO_DONTROUTE:
|
|
|
|
/* These go directly to the helper dll */
|
|
|
|
goto SendToHelper;
|
|
|
|
|
2011-08-11 07:08:16 +00:00
|
|
|
default:
|
2012-08-18 09:57:27 +00:00
|
|
|
/* Obviously this is a hack */
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("MSAFD: Set unknown optname %x\n", optname);
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2010-06-27 17:21:03 +00:00
|
|
|
}
|
|
|
|
}
|
2010-01-16 00:05:15 +00:00
|
|
|
|
2012-08-18 09:57:27 +00:00
|
|
|
SendToHelper:
|
2016-11-02 15:36:26 +00:00
|
|
|
Errno = Socket->HelperData->WSHSetSocketInformation(Socket->HelperContext,
|
|
|
|
s,
|
|
|
|
Socket->TdiAddressHandle,
|
|
|
|
Socket->TdiConnectionHandle,
|
|
|
|
level,
|
|
|
|
optname,
|
|
|
|
(PCHAR)optval,
|
|
|
|
optlen);
|
|
|
|
if (lpErrno) *lpErrno = Errno;
|
|
|
|
return (Errno == NO_ERROR) ? NO_ERROR : SOCKET_ERROR;
|
2010-01-16 00:05:15 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* FUNCTION: Initialize service provider for a client
|
|
|
|
* ARGUMENTS:
|
|
|
|
* wVersionRequested = Highest WinSock SPI version that the caller can use
|
|
|
|
* lpWSPData = Address of WSPDATA structure to initialize
|
|
|
|
* lpProtocolInfo = Pointer to structure that defines the desired protocol
|
|
|
|
* UpcallTable = Pointer to upcall table of the WinSock DLL
|
|
|
|
* lpProcTable = Address of procedure table to initialize
|
|
|
|
* RETURNS:
|
|
|
|
* Status of operation
|
|
|
|
*/
|
2018-04-23 09:42:32 +00:00
|
|
|
_Must_inspect_result_
|
|
|
|
int
|
2009-01-14 14:41:25 +00:00
|
|
|
WSPAPI
|
2018-04-23 09:42:32 +00:00
|
|
|
WSPStartup(
|
|
|
|
_In_ WORD wVersionRequested,
|
|
|
|
_In_ LPWSPDATA lpWSPData,
|
|
|
|
_In_ LPWSAPROTOCOL_INFOW lpProtocolInfo,
|
|
|
|
_In_ WSPUPCALLTABLE UpcallTable,
|
|
|
|
_Out_ LPWSPPROC_TABLE lpProcTable)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
NTSTATUS Status;
|
|
|
|
|
2016-09-20 08:12:44 +00:00
|
|
|
if (((LOBYTE(wVersionRequested) == 2) && (HIBYTE(wVersionRequested) < 2)) ||
|
|
|
|
(LOBYTE(wVersionRequested) < 2))
|
|
|
|
{
|
|
|
|
ERR("WSPStartup NOT SUPPORTED for version 0x%X\n", wVersionRequested);
|
|
|
|
return WSAVERNOTSUPPORTED;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
Status = NO_ERROR;
|
|
|
|
/* FIXME: Enable all cases of WSPStartup status */
|
2009-01-14 14:41:25 +00:00
|
|
|
Upcalls = UpcallTable;
|
|
|
|
|
|
|
|
if (Status == NO_ERROR)
|
|
|
|
{
|
|
|
|
lpProcTable->lpWSPAccept = WSPAccept;
|
|
|
|
lpProcTable->lpWSPAddressToString = WSPAddressToString;
|
|
|
|
lpProcTable->lpWSPAsyncSelect = WSPAsyncSelect;
|
|
|
|
lpProcTable->lpWSPBind = WSPBind;
|
|
|
|
lpProcTable->lpWSPCancelBlockingCall = WSPCancelBlockingCall;
|
|
|
|
lpProcTable->lpWSPCleanup = WSPCleanup;
|
|
|
|
lpProcTable->lpWSPCloseSocket = WSPCloseSocket;
|
|
|
|
lpProcTable->lpWSPConnect = WSPConnect;
|
|
|
|
lpProcTable->lpWSPDuplicateSocket = WSPDuplicateSocket;
|
|
|
|
lpProcTable->lpWSPEnumNetworkEvents = WSPEnumNetworkEvents;
|
|
|
|
lpProcTable->lpWSPEventSelect = WSPEventSelect;
|
|
|
|
lpProcTable->lpWSPGetOverlappedResult = WSPGetOverlappedResult;
|
|
|
|
lpProcTable->lpWSPGetPeerName = WSPGetPeerName;
|
|
|
|
lpProcTable->lpWSPGetSockName = WSPGetSockName;
|
|
|
|
lpProcTable->lpWSPGetSockOpt = WSPGetSockOpt;
|
|
|
|
lpProcTable->lpWSPGetQOSByName = WSPGetQOSByName;
|
|
|
|
lpProcTable->lpWSPIoctl = WSPIoctl;
|
|
|
|
lpProcTable->lpWSPJoinLeaf = WSPJoinLeaf;
|
|
|
|
lpProcTable->lpWSPListen = WSPListen;
|
|
|
|
lpProcTable->lpWSPRecv = WSPRecv;
|
|
|
|
lpProcTable->lpWSPRecvDisconnect = WSPRecvDisconnect;
|
|
|
|
lpProcTable->lpWSPRecvFrom = WSPRecvFrom;
|
|
|
|
lpProcTable->lpWSPSelect = WSPSelect;
|
|
|
|
lpProcTable->lpWSPSend = WSPSend;
|
|
|
|
lpProcTable->lpWSPSendDisconnect = WSPSendDisconnect;
|
|
|
|
lpProcTable->lpWSPSendTo = WSPSendTo;
|
|
|
|
lpProcTable->lpWSPSetSockOpt = WSPSetSockOpt;
|
|
|
|
lpProcTable->lpWSPShutdown = WSPShutdown;
|
|
|
|
lpProcTable->lpWSPSocket = WSPSocket;
|
|
|
|
lpProcTable->lpWSPStringToAddress = WSPStringToAddress;
|
|
|
|
lpWSPData->wVersion = MAKEWORD(2, 2);
|
|
|
|
lpWSPData->wHighVersion = MAKEWORD(2, 2);
|
2016-09-20 08:12:44 +00:00
|
|
|
/* Save CatalogEntryId for all upcalls */
|
|
|
|
CatalogEntryId = lpProtocolInfo->dwCatalogEntryId;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Status (%d).\n", Status);
|
2009-01-14 14:41:25 +00:00
|
|
|
return Status;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2016-09-20 08:12:44 +00:00
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPAddressToString(IN LPSOCKADDR lpsaAddress,
|
|
|
|
IN DWORD dwAddressLength,
|
|
|
|
IN LPWSAPROTOCOL_INFOW lpProtocolInfo,
|
|
|
|
OUT LPWSTR lpszAddressString,
|
|
|
|
IN OUT LPDWORD lpdwAddressStringLength,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
2018-04-23 09:42:32 +00:00
|
|
|
SIZE_T size;
|
2016-09-20 08:12:44 +00:00
|
|
|
WCHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
|
|
|
|
WCHAR *p;
|
|
|
|
|
|
|
|
if (!lpsaAddress || !lpszAddressString || !lpdwAddressStringLength)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (lpsaAddress->sa_family)
|
|
|
|
{
|
|
|
|
case AF_INET:
|
|
|
|
if (dwAddressLength < sizeof(SOCKADDR_IN))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
swprintf(buffer,
|
|
|
|
L"%u.%u.%u.%u:%u",
|
|
|
|
(unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 24 & 0xff),
|
|
|
|
(unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 16 & 0xff),
|
|
|
|
(unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 8 & 0xff),
|
|
|
|
(unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) & 0xff),
|
|
|
|
ntohs(((SOCKADDR_IN *)lpsaAddress)->sin_port));
|
|
|
|
|
|
|
|
p = wcschr(buffer, L':');
|
|
|
|
if (!((SOCKADDR_IN *)lpsaAddress)->sin_port)
|
|
|
|
{
|
|
|
|
*p = 0;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
size = wcslen(buffer) + 1;
|
|
|
|
|
|
|
|
if (*lpdwAddressStringLength < size)
|
|
|
|
{
|
|
|
|
*lpdwAddressStringLength = size;
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
*lpdwAddressStringLength = size;
|
|
|
|
wcscpy(lpszAddressString, buffer);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPStringToAddress(IN LPWSTR AddressString,
|
|
|
|
IN INT AddressFamily,
|
|
|
|
IN LPWSAPROTOCOL_INFOW lpProtocolInfo,
|
|
|
|
OUT LPSOCKADDR lpAddress,
|
|
|
|
IN OUT LPINT lpAddressLength,
|
|
|
|
OUT LPINT lpErrno)
|
|
|
|
{
|
2016-11-10 11:15:14 +00:00
|
|
|
int numdots = 0;
|
|
|
|
USHORT port;
|
|
|
|
LONG inetaddr = 0, ip_part;
|
2016-09-20 08:12:44 +00:00
|
|
|
LPWSTR *bp = NULL;
|
|
|
|
SOCKADDR_IN *sockaddr;
|
|
|
|
|
|
|
|
if (!lpAddressLength || !lpAddress || !AddressString)
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
2016-09-20 08:12:44 +00:00
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
|
|
|
sockaddr = (SOCKADDR_IN *)lpAddress;
|
|
|
|
|
|
|
|
/* Set right address family */
|
|
|
|
if (lpProtocolInfo != NULL)
|
|
|
|
{
|
|
|
|
sockaddr->sin_family = lpProtocolInfo->iAddressFamily;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
sockaddr->sin_family = AddressFamily;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Report size */
|
|
|
|
if (AddressFamily == AF_INET)
|
|
|
|
{
|
|
|
|
if (*lpAddressLength < (INT)sizeof(SOCKADDR_IN))
|
|
|
|
{
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEFAULT;
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// translate ip string to ip
|
|
|
|
|
2016-11-10 11:15:14 +00:00
|
|
|
/* Get ip number */
|
|
|
|
bp = &AddressString;
|
|
|
|
inetaddr = 0;
|
2016-09-20 08:12:44 +00:00
|
|
|
|
2016-11-10 11:15:14 +00:00
|
|
|
while (*bp < &AddressString[wcslen(AddressString)])
|
2016-09-20 08:12:44 +00:00
|
|
|
{
|
2016-11-10 11:15:14 +00:00
|
|
|
ip_part = wcstol(*bp, bp, 10);
|
|
|
|
/* ip part number should be in range 0-255 */
|
|
|
|
if (ip_part < 0 || ip_part > 255)
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
inetaddr = (inetaddr << 8) + ip_part;
|
|
|
|
/* we end on string end or port separator */
|
|
|
|
if ((*bp)[0] == 0 || (*bp)[0] == L':')
|
|
|
|
break;
|
|
|
|
/* ip parts are dot separated. verify it */
|
|
|
|
if ((*bp)[0] != L'.')
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
/* count the dots */
|
|
|
|
numdots++;
|
|
|
|
/* move over the dot to next ip part */
|
|
|
|
(*bp)++;
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
2016-11-10 11:15:14 +00:00
|
|
|
|
|
|
|
/* check dots count */
|
|
|
|
if (numdots != 3)
|
2016-09-20 08:12:44 +00:00
|
|
|
{
|
2016-11-10 11:15:14 +00:00
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
|
|
|
|
2016-11-10 11:15:14 +00:00
|
|
|
/* Get port number */
|
|
|
|
if ((*bp)[0] == L':')
|
2016-09-20 08:12:44 +00:00
|
|
|
{
|
2016-11-10 11:15:14 +00:00
|
|
|
/* move over the column to port part */
|
|
|
|
(*bp)++;
|
|
|
|
/* next char should be numeric */
|
|
|
|
if ((*bp)[0] < L'0' || (*bp)[0] > L'9')
|
|
|
|
{
|
|
|
|
if (lpErrno) *lpErrno = WSAEINVAL;
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
port = wcstol(*bp, bp, 10);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
port = 0;
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno) *lpErrno = NO_ERROR;
|
2016-11-10 11:15:14 +00:00
|
|
|
/* rest sockaddr.sin_addr.s_addr
|
|
|
|
for we need to be sure it is zero when we come to while */
|
|
|
|
*lpAddressLength = sizeof(*sockaddr);
|
|
|
|
memset(lpAddress, 0, sizeof(*sockaddr));
|
|
|
|
sockaddr->sin_family = AF_INET;
|
2016-09-20 08:12:44 +00:00
|
|
|
sockaddr->sin_addr.s_addr = inetaddr;
|
2016-11-10 11:15:14 +00:00
|
|
|
sockaddr->sin_port = port;
|
2016-09-20 08:12:44 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
if (lpErrno && !*lpErrno)
|
2016-09-20 08:12:44 +00:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return SOCKET_ERROR;
|
|
|
|
}
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/*
|
|
|
|
* FUNCTION: Cleans up service provider for a client
|
|
|
|
* ARGUMENTS:
|
|
|
|
* lpErrno = Address of buffer for error information
|
|
|
|
* RETURNS:
|
|
|
|
* 0 if successful, or SOCKET_ERROR if not
|
|
|
|
*/
|
2009-01-14 14:41:25 +00:00
|
|
|
INT
|
|
|
|
WSPAPI
|
|
|
|
WSPCleanup(OUT LPINT lpErrno)
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Leaving.\n");
|
2016-11-02 15:36:26 +00:00
|
|
|
|
|
|
|
if (lpErrno) *lpErrno = NO_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
return 0;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
VOID
|
|
|
|
NTAPI
|
|
|
|
AfdInfoAPC(PVOID ApcContext,
|
|
|
|
PIO_STATUS_BLOCK IoStatusBlock,
|
|
|
|
ULONG Reserved)
|
|
|
|
{
|
|
|
|
PAFDAPCCONTEXT Context = ApcContext;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, Context->lpOverlapped, 0);
|
|
|
|
HeapFree(GlobalHeap, 0, ApcContext);
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
int
|
|
|
|
GetSocketInformation(PSOCKET_INFORMATION Socket,
|
|
|
|
ULONG AfdInformationClass,
|
2011-07-04 17:37:45 +00:00
|
|
|
PBOOLEAN Boolean OPTIONAL,
|
2011-10-03 14:40:39 +00:00
|
|
|
PULONG Ulong OPTIONAL,
|
2016-10-25 07:54:00 +00:00
|
|
|
PLARGE_INTEGER LargeInteger OPTIONAL,
|
|
|
|
LPWSAOVERLAPPED Overlapped OPTIONAL,
|
|
|
|
LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
PIO_STATUS_BLOCK IOSB;
|
|
|
|
IO_STATUS_BLOCK DummyIOSB;
|
2009-01-14 14:41:25 +00:00
|
|
|
AFD_INFO InfoData;
|
|
|
|
NTSTATUS Status;
|
2016-11-02 15:36:26 +00:00
|
|
|
PAFDAPCCONTEXT APCContext;
|
2016-10-25 07:54:00 +00:00
|
|
|
PIO_APC_ROUTINE APCFunction;
|
|
|
|
HANDLE Event = NULL;
|
2009-01-14 14:41:25 +00:00
|
|
|
HANDLE SockEvent;
|
|
|
|
|
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set Info Class */
|
|
|
|
InfoData.InformationClass = AfdInformationClass;
|
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
/* Verify if we should use APC */
|
|
|
|
if (Overlapped == NULL)
|
|
|
|
{
|
|
|
|
/* Not using Overlapped structure, so use normal blocking on event */
|
|
|
|
APCContext = NULL;
|
|
|
|
APCFunction = NULL;
|
|
|
|
Event = SockEvent;
|
|
|
|
IOSB = &DummyIOSB;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Overlapped request for non overlapped opened socket */
|
|
|
|
if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
|
|
|
|
{
|
|
|
|
TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
|
2019-02-25 21:33:31 +00:00
|
|
|
NtClose( SockEvent );
|
2016-10-25 07:54:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (CompletionRoutine == NULL)
|
|
|
|
{
|
|
|
|
/* Using Overlapped Structure, but no Completition Routine, so no need for APC */
|
2016-11-02 15:36:26 +00:00
|
|
|
APCContext = (PAFDAPCCONTEXT)Overlapped;
|
2016-10-25 07:54:00 +00:00
|
|
|
APCFunction = NULL;
|
|
|
|
Event = Overlapped->hEvent;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Using Overlapped Structure and a Completition Routine, so use an APC */
|
|
|
|
APCFunction = &AfdInfoAPC; // should be a private io completition function inside us
|
|
|
|
APCContext = HeapAlloc(GlobalHeap, 0, sizeof(AFDAPCCONTEXT));
|
|
|
|
if (!APCContext)
|
|
|
|
{
|
|
|
|
ERR("Not enough memory for APC Context\n");
|
2019-02-25 21:33:31 +00:00
|
|
|
NtClose( SockEvent );
|
2016-10-25 07:54:00 +00:00
|
|
|
return WSAEFAULT;
|
|
|
|
}
|
2016-11-02 15:36:26 +00:00
|
|
|
APCContext->lpCompletionRoutine = CompletionRoutine;
|
|
|
|
APCContext->lpOverlapped = Overlapped;
|
|
|
|
APCContext->lpSocket = Socket;
|
2016-10-25 07:54:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
|
|
|
|
}
|
|
|
|
|
|
|
|
IOSB->Status = STATUS_PENDING;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
2016-10-25 07:54:00 +00:00
|
|
|
Event,
|
|
|
|
APCFunction,
|
|
|
|
APCContext,
|
|
|
|
IOSB,
|
2009-01-14 14:41:25 +00:00
|
|
|
IOCTL_AFD_GET_INFO,
|
|
|
|
&InfoData,
|
|
|
|
sizeof(InfoData),
|
|
|
|
&InfoData,
|
|
|
|
sizeof(InfoData));
|
|
|
|
|
|
|
|
/* Wait for return */
|
2016-10-25 07:54:00 +00:00
|
|
|
if (Status == STATUS_PENDING && Overlapped == NULL)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
2016-10-25 07:54:00 +00:00
|
|
|
Status = IOSB->Status;
|
|
|
|
}
|
|
|
|
|
2019-02-25 21:33:31 +00:00
|
|
|
NtClose( SockEvent );
|
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
TRACE("Status %x Information %d\n", Status, IOSB->Information);
|
|
|
|
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
TRACE("Leaving (Pending)\n");
|
|
|
|
return WSA_IO_PENDING;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
2010-06-06 23:07:26 +00:00
|
|
|
if (Status != STATUS_SUCCESS)
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2010-06-06 23:07:26 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Return Information */
|
2009-08-18 18:53:10 +00:00
|
|
|
if (Ulong != NULL)
|
|
|
|
{
|
|
|
|
*Ulong = InfoData.Information.Ulong;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
if (LargeInteger != NULL)
|
|
|
|
{
|
|
|
|
*LargeInteger = InfoData.Information.LargeInteger;
|
|
|
|
}
|
2011-07-04 17:37:45 +00:00
|
|
|
if (Boolean != NULL)
|
|
|
|
{
|
|
|
|
*Boolean = InfoData.Information.Boolean;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
return NO_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
int
|
|
|
|
SetSocketInformation(PSOCKET_INFORMATION Socket,
|
2011-07-04 17:37:45 +00:00
|
|
|
ULONG AfdInformationClass,
|
|
|
|
PBOOLEAN Boolean OPTIONAL,
|
2011-10-03 14:40:39 +00:00
|
|
|
PULONG Ulong OPTIONAL,
|
2016-10-25 07:54:00 +00:00
|
|
|
PLARGE_INTEGER LargeInteger OPTIONAL,
|
|
|
|
LPWSAOVERLAPPED Overlapped OPTIONAL,
|
|
|
|
LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2016-10-25 07:54:00 +00:00
|
|
|
PIO_STATUS_BLOCK IOSB;
|
|
|
|
IO_STATUS_BLOCK DummyIOSB;
|
2009-01-14 14:41:25 +00:00
|
|
|
AFD_INFO InfoData;
|
|
|
|
NTSTATUS Status;
|
2016-11-02 15:36:26 +00:00
|
|
|
PAFDAPCCONTEXT APCContext;
|
2016-10-25 07:54:00 +00:00
|
|
|
PIO_APC_ROUTINE APCFunction;
|
|
|
|
HANDLE Event = NULL;
|
2009-01-14 14:41:25 +00:00
|
|
|
HANDLE SockEvent;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
if( !NT_SUCCESS(Status) )
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Set Info Class */
|
|
|
|
InfoData.InformationClass = AfdInformationClass;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Set Information */
|
2009-08-18 18:53:10 +00:00
|
|
|
if (Ulong != NULL)
|
|
|
|
{
|
|
|
|
InfoData.Information.Ulong = *Ulong;
|
|
|
|
}
|
2009-01-14 14:41:25 +00:00
|
|
|
if (LargeInteger != NULL)
|
|
|
|
{
|
|
|
|
InfoData.Information.LargeInteger = *LargeInteger;
|
|
|
|
}
|
2011-07-04 17:37:45 +00:00
|
|
|
if (Boolean != NULL)
|
|
|
|
{
|
|
|
|
InfoData.Information.Boolean = *Boolean;
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
/* Verify if we should use APC */
|
|
|
|
if (Overlapped == NULL)
|
|
|
|
{
|
|
|
|
/* Not using Overlapped structure, so use normal blocking on event */
|
|
|
|
APCContext = NULL;
|
|
|
|
APCFunction = NULL;
|
|
|
|
Event = SockEvent;
|
|
|
|
IOSB = &DummyIOSB;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Overlapped request for non overlapped opened socket */
|
|
|
|
if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
|
|
|
|
{
|
|
|
|
TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
|
2019-02-25 21:33:31 +00:00
|
|
|
NtClose( SockEvent );
|
2016-10-25 07:54:00 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
if (CompletionRoutine == NULL)
|
|
|
|
{
|
|
|
|
/* Using Overlapped Structure, but no Completition Routine, so no need for APC */
|
2016-11-02 15:36:26 +00:00
|
|
|
APCContext = (PAFDAPCCONTEXT)Overlapped;
|
2016-10-25 07:54:00 +00:00
|
|
|
APCFunction = NULL;
|
|
|
|
Event = Overlapped->hEvent;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* Using Overlapped Structure and a Completition Routine, so use an APC */
|
|
|
|
APCFunction = &AfdInfoAPC; // should be a private io completition function inside us
|
|
|
|
APCContext = HeapAlloc(GlobalHeap, 0, sizeof(AFDAPCCONTEXT));
|
|
|
|
if (!APCContext)
|
|
|
|
{
|
|
|
|
ERR("Not enough memory for APC Context\n");
|
2019-02-25 21:33:31 +00:00
|
|
|
NtClose( SockEvent );
|
2016-10-25 07:54:00 +00:00
|
|
|
return WSAEFAULT;
|
|
|
|
}
|
2016-11-02 15:36:26 +00:00
|
|
|
APCContext->lpCompletionRoutine = CompletionRoutine;
|
|
|
|
APCContext->lpOverlapped = Overlapped;
|
|
|
|
APCContext->lpSocket = Socket;
|
2016-10-25 07:54:00 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
|
|
|
|
}
|
|
|
|
|
|
|
|
IOSB->Status = STATUS_PENDING;
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
2016-10-25 07:54:00 +00:00
|
|
|
Event,
|
|
|
|
APCFunction,
|
|
|
|
APCContext,
|
|
|
|
IOSB,
|
2009-05-16 14:12:09 +00:00
|
|
|
IOCTL_AFD_SET_INFO,
|
2009-01-14 14:41:25 +00:00
|
|
|
&InfoData,
|
|
|
|
sizeof(InfoData),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
|
|
|
/* Wait for return */
|
2016-10-25 07:54:00 +00:00
|
|
|
if (Status == STATUS_PENDING && Overlapped == NULL)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
2016-10-25 07:54:00 +00:00
|
|
|
Status = IOSB->Status;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
NtClose( SockEvent );
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2016-10-25 07:54:00 +00:00
|
|
|
TRACE("Status %x Information %d\n", Status, IOSB->Information);
|
|
|
|
|
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
TRACE("Leaving (Pending)\n");
|
|
|
|
return WSA_IO_PENDING;
|
|
|
|
}
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
return Status == STATUS_SUCCESS ? NO_ERROR : SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
}
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
PSOCKET_INFORMATION
|
|
|
|
GetSocketStructure(SOCKET Handle)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2010-06-07 00:24:27 +00:00
|
|
|
PSOCKET_INFORMATION CurrentSocket;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2010-06-19 05:04:40 +00:00
|
|
|
EnterCriticalSection(&SocketListLock);
|
|
|
|
|
2010-06-07 00:24:27 +00:00
|
|
|
CurrentSocket = SocketListHead;
|
2010-06-07 05:40:08 +00:00
|
|
|
while (CurrentSocket)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2010-06-07 00:24:27 +00:00
|
|
|
if (CurrentSocket->Handle == Handle)
|
2010-06-19 05:04:40 +00:00
|
|
|
{
|
|
|
|
LeaveCriticalSection(&SocketListLock);
|
2010-06-07 00:24:27 +00:00
|
|
|
return CurrentSocket;
|
2010-06-19 05:04:40 +00:00
|
|
|
}
|
2010-06-07 00:24:27 +00:00
|
|
|
|
|
|
|
CurrentSocket = CurrentSocket->NextSocket;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
2010-06-07 00:24:27 +00:00
|
|
|
|
2010-06-19 05:04:40 +00:00
|
|
|
LeaveCriticalSection(&SocketListLock);
|
|
|
|
|
2010-06-07 00:24:27 +00:00
|
|
|
return NULL;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
int CreateContext(PSOCKET_INFORMATION Socket)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
SOCKET_CONTEXT ContextData;
|
|
|
|
NTSTATUS Status;
|
|
|
|
HANDLE SockEvent;
|
|
|
|
|
|
|
|
Status = NtCreateEvent(&SockEvent,
|
2012-09-03 22:00:16 +00:00
|
|
|
EVENT_ALL_ACCESS,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
2018-01-06 17:11:18 +00:00
|
|
|
SynchronizationEvent,
|
2009-01-14 14:41:25 +00:00
|
|
|
FALSE);
|
|
|
|
|
|
|
|
if( !NT_SUCCESS(Status) )
|
2016-11-02 15:36:26 +00:00
|
|
|
return SOCKET_ERROR;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Create Context */
|
2016-10-07 17:51:03 +00:00
|
|
|
ContextData.SharedData = *Socket->SharedData;
|
2009-01-14 14:41:25 +00:00
|
|
|
ContextData.SizeOfHelperData = 0;
|
2011-10-03 14:40:39 +00:00
|
|
|
RtlCopyMemory (&ContextData.LocalAddress,
|
|
|
|
Socket->LocalAddress,
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->SizeOfLocalAddress);
|
2011-10-03 14:40:39 +00:00
|
|
|
RtlCopyMemory (&ContextData.RemoteAddress,
|
|
|
|
Socket->RemoteAddress,
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->SizeOfRemoteAddress);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
|
|
|
|
SockEvent,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
&IOSB,
|
|
|
|
IOCTL_AFD_SET_CONTEXT,
|
|
|
|
&ContextData,
|
|
|
|
sizeof(ContextData),
|
|
|
|
NULL,
|
|
|
|
0);
|
|
|
|
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Wait for Completion */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (Status == STATUS_PENDING)
|
|
|
|
{
|
|
|
|
WaitForSingleObject(SockEvent, INFINITE);
|
2010-06-06 23:07:26 +00:00
|
|
|
Status = IOSB.Status;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NtClose( SockEvent );
|
|
|
|
|
2016-11-02 15:36:26 +00:00
|
|
|
return Status == STATUS_SUCCESS ? NO_ERROR : SOCKET_ERROR;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN SockCreateOrReferenceAsyncThread(VOID)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
HANDLE hAsyncThread;
|
|
|
|
DWORD AsyncThreadId;
|
|
|
|
HANDLE AsyncEvent;
|
|
|
|
OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
|
|
|
|
NTSTATUS Status;
|
|
|
|
|
|
|
|
/* Check if the Thread Already Exists */
|
|
|
|
if (SockAsyncThreadRefCount)
|
|
|
|
{
|
2011-03-14 12:48:28 +00:00
|
|
|
ASSERT(SockAsyncCompletionPort);
|
2009-01-14 14:41:25 +00:00
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the Completion Port */
|
|
|
|
if (!SockAsyncCompletionPort)
|
|
|
|
{
|
|
|
|
Status = NtCreateIoCompletion(&SockAsyncCompletionPort,
|
|
|
|
IO_COMPLETION_ALL_ACCESS,
|
|
|
|
NULL,
|
|
|
|
2); // Allow 2 threads only
|
2011-03-14 12:48:28 +00:00
|
|
|
if (!NT_SUCCESS(Status))
|
|
|
|
{
|
2014-11-10 13:06:48 +00:00
|
|
|
ERR("Failed to create completion port: 0x%08x\n", Status);
|
2011-03-14 12:48:28 +00:00
|
|
|
return FALSE;
|
|
|
|
}
|
2011-10-03 14:40:39 +00:00
|
|
|
/* Protect Handle */
|
2009-01-14 14:41:25 +00:00
|
|
|
HandleFlags.ProtectFromClose = TRUE;
|
|
|
|
HandleFlags.Inherit = FALSE;
|
|
|
|
Status = NtSetInformationObject(SockAsyncCompletionPort,
|
|
|
|
ObjectHandleFlagInformation,
|
|
|
|
&HandleFlags,
|
|
|
|
sizeof(HandleFlags));
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Create the Async Event */
|
|
|
|
Status = NtCreateEvent(&AsyncEvent,
|
|
|
|
EVENT_ALL_ACCESS,
|
|
|
|
NULL,
|
|
|
|
NotificationEvent,
|
|
|
|
FALSE);
|
|
|
|
|
|
|
|
/* Create the Async Thread */
|
|
|
|
hAsyncThread = CreateThread(NULL,
|
|
|
|
0,
|
2017-10-27 22:47:30 +00:00
|
|
|
SockAsyncThread,
|
2009-01-14 14:41:25 +00:00
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
&AsyncThreadId);
|
|
|
|
|
|
|
|
/* Close the Handle */
|
|
|
|
NtClose(hAsyncThread);
|
|
|
|
|
|
|
|
/* Increase the Reference Count */
|
|
|
|
SockAsyncThreadRefCount++;
|
|
|
|
return TRUE;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
2017-10-27 22:47:30 +00:00
|
|
|
ULONG
|
|
|
|
NTAPI
|
|
|
|
SockAsyncThread(PVOID ThreadParam)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
PVOID AsyncContext;
|
|
|
|
PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine;
|
|
|
|
IO_STATUS_BLOCK IOSB;
|
|
|
|
NTSTATUS Status;
|
|
|
|
|
|
|
|
/* Make the Thread Higher Priority */
|
|
|
|
SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
|
|
|
|
|
|
|
|
/* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
|
2011-10-03 14:40:39 +00:00
|
|
|
do
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
Status = NtRemoveIoCompletion (SockAsyncCompletionPort,
|
|
|
|
(PVOID*)&AsyncCompletionRoutine,
|
|
|
|
&AsyncContext,
|
|
|
|
&IOSB,
|
|
|
|
NULL);
|
|
|
|
/* Call the Async Function */
|
|
|
|
if (NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
(*AsyncCompletionRoutine)(AsyncContext, &IOSB);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
/* It Failed, sleep for a second */
|
|
|
|
Sleep(1000);
|
|
|
|
}
|
|
|
|
} while ((Status != STATUS_TIMEOUT));
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* The Thread has Ended */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOLEAN SockGetAsyncSelectHelperAfdHandle(VOID)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
UNICODE_STRING AfdHelper;
|
|
|
|
OBJECT_ATTRIBUTES ObjectAttributes;
|
|
|
|
IO_STATUS_BLOCK IoSb;
|
|
|
|
FILE_COMPLETION_INFORMATION CompletionInfo;
|
|
|
|
OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
|
|
|
|
|
2016-11-12 21:53:33 +00:00
|
|
|
/* First, make sure we're not already initialized */
|
2009-01-14 14:41:25 +00:00
|
|
|
if (SockAsyncHelperAfdHandle)
|
|
|
|
{
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Set up Handle Name and Object */
|
|
|
|
RtlInitUnicodeString(&AfdHelper, L"\\Device\\Afd\\AsyncSelectHlp" );
|
|
|
|
InitializeObjectAttributes(&ObjectAttributes,
|
|
|
|
&AfdHelper,
|
|
|
|
OBJ_INHERIT | OBJ_CASE_INSENSITIVE,
|
|
|
|
NULL,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
/* Open the Handle to AFD */
|
2011-09-10 23:54:02 +00:00
|
|
|
NtCreateFile(&SockAsyncHelperAfdHandle,
|
|
|
|
GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
|
|
|
|
&ObjectAttributes,
|
|
|
|
&IoSb,
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
FILE_SHARE_READ | FILE_SHARE_WRITE,
|
|
|
|
FILE_OPEN_IF,
|
|
|
|
0,
|
|
|
|
NULL,
|
|
|
|
0);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/*
|
|
|
|
* Now Set up the Completion Port Information
|
2009-01-14 14:41:25 +00:00
|
|
|
* This means that whenever a Poll is finished, the routine will be executed
|
|
|
|
*/
|
|
|
|
CompletionInfo.Port = SockAsyncCompletionPort;
|
|
|
|
CompletionInfo.Key = SockAsyncSelectCompletionRoutine;
|
2011-09-10 23:54:02 +00:00
|
|
|
NtSetInformationFile(SockAsyncHelperAfdHandle,
|
|
|
|
&IoSb,
|
|
|
|
&CompletionInfo,
|
|
|
|
sizeof(CompletionInfo),
|
|
|
|
FileCompletionInformation);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Protect the Handle */
|
|
|
|
HandleFlags.ProtectFromClose = TRUE;
|
|
|
|
HandleFlags.Inherit = FALSE;
|
2011-09-10 23:54:02 +00:00
|
|
|
NtSetInformationObject(SockAsyncCompletionPort,
|
|
|
|
ObjectHandleFlagInformation,
|
|
|
|
&HandleFlags,
|
|
|
|
sizeof(HandleFlags));
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
|
|
|
|
SockAsyncSelectCalled = TRUE;
|
|
|
|
return TRUE;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VOID SockAsyncSelectCompletionRoutine(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
|
|
|
|
{
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
PASYNC_DATA AsyncData = Context;
|
|
|
|
PSOCKET_INFORMATION Socket;
|
|
|
|
ULONG x;
|
|
|
|
|
|
|
|
/* Get the Socket */
|
|
|
|
Socket = AsyncData->ParentSocket;
|
|
|
|
|
|
|
|
/* Check if the Sequence Number Changed behind our back */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (AsyncData->SequenceNumber != Socket->SharedData->SequenceNumber )
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check we were manually called b/c of a failure */
|
|
|
|
if (!NT_SUCCESS(IoStatusBlock->Status))
|
|
|
|
{
|
|
|
|
/* FIXME: Perform Upcall */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (x = 1; x; x<<=1)
|
|
|
|
{
|
|
|
|
switch (AsyncData->AsyncSelectInfo.Handles[0].Events & x)
|
|
|
|
{
|
|
|
|
case AFD_EVENT_RECEIVE:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_READ) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_READ))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_READ, 0));
|
|
|
|
/* Disable this event until the next read(); */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_READ;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFD_EVENT_OOB_RECEIVE:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_OOB) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_OOB))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_OOB, 0));
|
|
|
|
/* Disable this event until the next read(); */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_OOB;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFD_EVENT_SEND:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_WRITE) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_WRITE))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_WRITE, 0));
|
|
|
|
/* Disable this event until the next write(); */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_WRITE;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
/* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
|
|
|
|
case AFD_EVENT_CONNECT:
|
2009-07-20 18:30:30 +00:00
|
|
|
case AFD_EVENT_CONNECT_FAIL:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_CONNECT) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_CONNECT))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_CONNECT, 0));
|
|
|
|
/* Disable this event forever; */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_CONNECT;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFD_EVENT_ACCEPT:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_ACCEPT) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_ACCEPT))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_ACCEPT, 0));
|
|
|
|
/* Disable this event until the next accept(); */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_ACCEPT;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
case AFD_EVENT_DISCONNECT:
|
|
|
|
case AFD_EVENT_ABORT:
|
|
|
|
case AFD_EVENT_CLOSE:
|
2016-10-07 17:51:03 +00:00
|
|
|
if (0 != (Socket->SharedData->AsyncEvents & FD_CLOSE) &&
|
|
|
|
0 == (Socket->SharedData->AsyncDisabledEvents & FD_CLOSE))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Make the Notification */
|
2016-10-07 17:51:03 +00:00
|
|
|
(Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
|
|
|
|
Socket->SharedData->wMsg,
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket->Handle,
|
|
|
|
WSAMAKESELECTREPLY(FD_CLOSE, 0));
|
|
|
|
/* Disable this event forever; */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents |= FD_CLOSE;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
/* FIXME: Support QOS */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check if there are any events left for us to check */
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Keep Polling */
|
|
|
|
SockProcessAsyncSelect(Socket, AsyncData);
|
|
|
|
return;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VOID SockProcessAsyncSelect(PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
|
|
|
|
{
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
ULONG lNetworkEvents;
|
|
|
|
NTSTATUS Status;
|
|
|
|
|
|
|
|
/* Set up the Async Data Event Info */
|
|
|
|
AsyncData->AsyncSelectInfo.Timeout.HighPart = 0x7FFFFFFF;
|
|
|
|
AsyncData->AsyncSelectInfo.Timeout.LowPart = 0xFFFFFFFF;
|
|
|
|
AsyncData->AsyncSelectInfo.HandleCount = 1;
|
|
|
|
AsyncData->AsyncSelectInfo.Exclusive = TRUE;
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Handle = Socket->Handle;
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events = 0;
|
|
|
|
|
|
|
|
/* Remove unwanted events */
|
2016-10-07 17:51:03 +00:00
|
|
|
lNetworkEvents = Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents);
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
/* Set Events to wait for */
|
|
|
|
if (lNetworkEvents & FD_READ)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_RECEIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_WRITE)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_SEND;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_OOB)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_OOB_RECEIVE;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_ACCEPT)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_ACCEPT;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
|
|
|
|
if (lNetworkEvents & FD_CONNECT)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_CLOSE)
|
|
|
|
{
|
2009-08-14 00:09:59 +00:00
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE;
|
2009-01-14 14:41:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_QOS)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_QOS;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (lNetworkEvents & FD_GROUP_QOS)
|
|
|
|
{
|
|
|
|
AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_GROUP_QOS;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send IOCTL */
|
|
|
|
Status = NtDeviceIoControlFile (SockAsyncHelperAfdHandle,
|
|
|
|
NULL,
|
|
|
|
NULL,
|
|
|
|
AsyncData,
|
|
|
|
&AsyncData->IoStatusBlock,
|
|
|
|
IOCTL_AFD_SELECT,
|
|
|
|
&AsyncData->AsyncSelectInfo,
|
|
|
|
sizeof(AsyncData->AsyncSelectInfo),
|
|
|
|
&AsyncData->AsyncSelectInfo,
|
|
|
|
sizeof(AsyncData->AsyncSelectInfo));
|
|
|
|
|
|
|
|
/* I/O Manager Won't call the completion routine, let's do it manually */
|
|
|
|
if (NT_SUCCESS(Status))
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
AsyncData->IoStatusBlock.Status = Status;
|
|
|
|
SockAsyncSelectCompletionRoutine(AsyncData, &AsyncData->IoStatusBlock);
|
|
|
|
}
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VOID SockProcessQueuedAsyncSelect(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
PASYNC_DATA AsyncData = Context;
|
|
|
|
BOOL FreeContext = TRUE;
|
|
|
|
PSOCKET_INFORMATION Socket;
|
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/* Get the Socket */
|
2009-01-14 14:41:25 +00:00
|
|
|
Socket = AsyncData->ParentSocket;
|
|
|
|
|
|
|
|
/* If someone closed it, stop the function */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (Socket->SharedData->State != SocketClosed)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
/* Check if the Sequence Number changed by now, in which case quit */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (AsyncData->SequenceNumber == Socket->SharedData->SequenceNumber)
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2016-11-12 21:53:33 +00:00
|
|
|
/* Do the actual select, if needed */
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
|
|
|
SockProcessAsyncSelect(Socket, AsyncData);
|
|
|
|
FreeContext = FALSE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Free the Context */
|
|
|
|
if (FreeContext)
|
|
|
|
{
|
|
|
|
HeapFree(GetProcessHeap(), 0, AsyncData);
|
|
|
|
}
|
|
|
|
|
|
|
|
return;
|
2006-02-17 00:04:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
VOID
|
2009-01-14 14:41:25 +00:00
|
|
|
SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket,
|
|
|
|
IN ULONG Event)
|
2006-02-17 00:04:10 +00:00
|
|
|
{
|
|
|
|
PASYNC_DATA AsyncData;
|
|
|
|
|
|
|
|
/* Make sure the event is actually disabled */
|
2016-10-07 17:51:03 +00:00
|
|
|
if (!(Socket->SharedData->AsyncDisabledEvents & Event))
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Re-enable it */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->AsyncDisabledEvents &= ~Event;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* Return if no more events are being polled */
|
2016-10-07 17:51:03 +00:00
|
|
|
if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
|
2009-01-14 14:41:25 +00:00
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Wait on new events */
|
|
|
|
AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA));
|
2009-08-18 18:53:10 +00:00
|
|
|
if (!AsyncData) return;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
2011-10-03 14:40:39 +00:00
|
|
|
/* Create the Asynch Thread if Needed */
|
2006-02-17 00:04:10 +00:00
|
|
|
SockCreateOrReferenceAsyncThread();
|
|
|
|
|
|
|
|
/* Increase the sequence number to stop anything else */
|
2016-10-07 17:51:03 +00:00
|
|
|
Socket->SharedData->SequenceNumber++;
|
2009-01-14 14:41:25 +00:00
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* Set up the Async Data */
|
|
|
|
AsyncData->ParentSocket = Socket;
|
2016-10-07 17:51:03 +00:00
|
|
|
AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* Begin Async Select by using I/O Completion */
|
|
|
|
NtSetIoCompletion(SockAsyncCompletionPort,
|
2009-01-14 14:41:25 +00:00
|
|
|
(PVOID)&SockProcessQueuedAsyncSelect,
|
|
|
|
AsyncData,
|
|
|
|
0,
|
|
|
|
0);
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
/* All done */
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOL
|
2008-11-30 11:42:05 +00:00
|
|
|
WINAPI
|
2006-02-17 00:04:10 +00:00
|
|
|
DllMain(HANDLE hInstDll,
|
|
|
|
ULONG dwReason,
|
|
|
|
PVOID Reserved)
|
|
|
|
{
|
2009-01-14 14:41:25 +00:00
|
|
|
|
|
|
|
switch (dwReason)
|
|
|
|
{
|
2006-02-17 00:04:10 +00:00
|
|
|
case DLL_PROCESS_ATTACH:
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("Loading MSAFD.DLL \n");
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
/* Don't need thread attach notifications
|
2009-01-14 14:41:25 +00:00
|
|
|
so disable them to improve performance */
|
2006-02-17 00:04:10 +00:00
|
|
|
DisableThreadLibraryCalls(hInstDll);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* List of DLL Helpers */
|
2006-02-17 00:04:10 +00:00
|
|
|
InitializeListHead(&SockHelpersListHead);
|
|
|
|
|
2009-01-14 14:41:25 +00:00
|
|
|
/* Heap to use when allocating */
|
2006-02-17 00:04:10 +00:00
|
|
|
GlobalHeap = GetProcessHeap();
|
|
|
|
|
2010-06-19 05:04:40 +00:00
|
|
|
/* Initialize the lock that protects our socket list */
|
|
|
|
InitializeCriticalSection(&SocketListLock);
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("MSAFD.DLL has been loaded\n");
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DLL_THREAD_ATTACH:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DLL_THREAD_DETACH:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case DLL_PROCESS_DETACH:
|
2010-06-19 05:04:40 +00:00
|
|
|
|
|
|
|
/* Delete the socket list lock */
|
|
|
|
DeleteCriticalSection(&SocketListLock);
|
|
|
|
|
2006-02-17 00:04:10 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2014-11-10 13:06:48 +00:00
|
|
|
TRACE("DllMain of msafd.dll (leaving)\n");
|
2006-02-17 00:04:10 +00:00
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* EOF */
|