ReactOS  0.4.14-dev-77-gd9e7c48
dllmain.c File Reference
#include <msafd.h>
#include <winuser.h>
#include <wchar.h>
Include dependency graph for dllmain.c:

Go to the source code of this file.

Functions

SOCKET WSPAPI WSPSocket (int AddressFamily, int SocketType, int Protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags, LPINT lpErrno)
 
INT WSPAPI WSPDuplicateSocket (IN SOCKET Handle, IN DWORD dwProcessId, OUT LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPINT lpErrno)
 
INT TranslateNtStatusError (NTSTATUS Status)
 
INT WSPAPI WSPCloseSocket (IN SOCKET Handle, OUT LPINT lpErrno)
 
INT WSPAPI WSPBind (SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPINT lpErrno)
 
int WSPAPI WSPListen (SOCKET Handle, int Backlog, LPINT lpErrno)
 
int WSPAPI 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)
 
DWORD GetCurrentTimeInSeconds (VOID)
 
_Must_inspect_result_ SOCKET WSPAPI 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)
 
int WSPAPI WSPConnect (SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS, LPINT lpErrno)
 
int WSPAPI WSPShutdown (SOCKET Handle, int HowTo, LPINT lpErrno)
 
INT WSPAPI WSPGetSockName (IN SOCKET Handle, OUT LPSOCKADDR Name, IN OUT LPINT NameLength, OUT LPINT lpErrno)
 
INT WSPAPI WSPGetPeerName (IN SOCKET s, OUT LPSOCKADDR Name, IN OUT LPINT NameLength, OUT LPINT lpErrno)
 
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)
 
INT WSPAPI WSPGetSockOpt (IN SOCKET Handle, IN INT Level, IN INT OptionName, OUT CHAR FAR *OptionValue, IN OUT LPINT OptionLength, OUT LPINT lpErrno)
 
INT WSPAPI WSPSetSockOpt (IN SOCKET s, IN INT level, IN INT optname, IN CONST CHAR FAR *optval, IN INT optlen, OUT LPINT lpErrno)
 
_Must_inspect_result_ int WSPAPI WSPStartup (_In_ WORD wVersionRequested, _In_ LPWSPDATA lpWSPData, _In_ LPWSAPROTOCOL_INFOW lpProtocolInfo, _In_ WSPUPCALLTABLE UpcallTable, _Out_ LPWSPPROC_TABLE lpProcTable)
 
INT WSPAPI WSPAddressToString (IN LPSOCKADDR lpsaAddress, IN DWORD dwAddressLength, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPWSTR lpszAddressString, IN OUT LPDWORD lpdwAddressStringLength, OUT LPINT lpErrno)
 
INT WSPAPI WSPStringToAddress (IN LPWSTR AddressString, IN INT AddressFamily, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPSOCKADDR lpAddress, IN OUT LPINT lpAddressLength, OUT LPINT lpErrno)
 
INT WSPAPI WSPCleanup (OUT LPINT lpErrno)
 
VOID NTAPI AfdInfoAPC (PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved)
 
int GetSocketInformation (PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
 
int SetSocketInformation (PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
 
PSOCKET_INFORMATION GetSocketStructure (SOCKET Handle)
 
int CreateContext (PSOCKET_INFORMATION Socket)
 
BOOLEAN SockCreateOrReferenceAsyncThread (VOID)
 
ULONG NTAPI SockAsyncThread (PVOID ThreadParam)
 
BOOLEAN SockGetAsyncSelectHelperAfdHandle (VOID)
 
VOID SockAsyncSelectCompletionRoutine (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
 
VOID SockProcessAsyncSelect (PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
 
VOID SockProcessQueuedAsyncSelect (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
 
VOID SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket, IN ULONG Event)
 
BOOL WINAPI DllMain (HANDLE hInstDll, ULONG dwReason, PVOID Reserved)
 

Variables

HANDLE GlobalHeap
 
WSPUPCALLTABLE Upcalls
 
DWORD CatalogEntryId
 
LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest
 
PSOCKET_INFORMATION SocketListHead = NULL
 
CRITICAL_SECTION SocketListLock
 
LIST_ENTRY SockHelpersListHead = { NULL, NULL }
 
ULONG SockAsyncThreadRefCount
 
HANDLE SockAsyncHelperAfdHandle
 
HANDLE SockAsyncCompletionPort = NULL
 
BOOLEAN SockAsyncSelectCalled
 

Function Documentation

◆ AfdInfoAPC()

VOID NTAPI AfdInfoAPC ( PVOID  ApcContext,
PIO_STATUS_BLOCK  IoStatusBlock,
ULONG  Reserved 
)

Definition at line 3246 of file dllmain.c.

3249 {
3251 
3252  Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, Context->lpOverlapped, 0);
3254 }
_In_opt_ HANDLE _In_opt_ PIO_APC_ROUTINE _In_opt_ PVOID ApcContext
Definition: iofuncs.h:719
HANDLE GlobalHeap
Definition: dllmain.c:19
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by GetSocketInformation(), and SetSocketInformation().

◆ CreateContext()

int CreateContext ( PSOCKET_INFORMATION  Socket)

Definition at line 3530 of file dllmain.c.

3531 {
3532  IO_STATUS_BLOCK IOSB;
3533  SOCKET_CONTEXT ContextData;
3534  NTSTATUS Status;
3535  HANDLE SockEvent;
3536 
3539  NULL,
3541  FALSE);
3542 
3543  if( !NT_SUCCESS(Status) )
3544  return SOCKET_ERROR;
3545 
3546  /* Create Context */
3547  ContextData.SharedData = *Socket->SharedData;
3548  ContextData.SizeOfHelperData = 0;
3549  RtlCopyMemory (&ContextData.LocalAddress,
3550  Socket->LocalAddress,
3551  Socket->SharedData->SizeOfLocalAddress);
3552  RtlCopyMemory (&ContextData.RemoteAddress,
3553  Socket->RemoteAddress,
3554  Socket->SharedData->SizeOfRemoteAddress);
3555 
3556  /* Send IOCTL */
3558  SockEvent,
3559  NULL,
3560  NULL,
3561  &IOSB,
3563  &ContextData,
3564  sizeof(ContextData),
3565  NULL,
3566  0);
3567 
3568  /* Wait for Completion */
3569  if (Status == STATUS_PENDING)
3570  {
3572  Status = IOSB.Status;
3573  }
3574 
3575  NtClose( SockEvent );
3576 
3578 }
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define NO_ERROR
Definition: dderror.h:5
ULONG SizeOfHelperData
Definition: msafd.h:122
PSOCKADDR RemoteAddress
Definition: msafd.h:106
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
INT SizeOfRemoteAddress
Definition: msafd.h:60
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
INT SizeOfLocalAddress
Definition: msafd.h:59
Status
Definition: gdiplustypes.h:24
SOCKADDR RemoteAddress
Definition: msafd.h:125
PSOCKADDR LocalAddress
Definition: msafd.h:105
SOCK_SHARED_INFO SharedData
Definition: msafd.h:121
SOCKADDR LocalAddress
Definition: msafd.h:124
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define IOCTL_AFD_SET_CONTEXT
Definition: shared.h:301

Referenced by WSPSocket().

◆ DllMain()

BOOL WINAPI DllMain ( HANDLE  hInstDll,
ULONG  dwReason,
PVOID  Reserved 
)

Definition at line 4030 of file dllmain.c.

4033 {
4034 
4035  switch (dwReason)
4036  {
4037  case DLL_PROCESS_ATTACH:
4038 
4039  TRACE("Loading MSAFD.DLL \n");
4040 
4041  /* Don't need thread attach notifications
4042  so disable them to improve performance */
4043  DisableThreadLibraryCalls(hInstDll);
4044 
4045  /* List of DLL Helpers */
4047 
4048  /* Heap to use when allocating */
4050 
4051  /* Initialize the lock that protects our socket list */
4053 
4054  TRACE("MSAFD.DLL has been loaded\n");
4055 
4056  break;
4057 
4058  case DLL_THREAD_ATTACH:
4059  break;
4060 
4061  case DLL_THREAD_DETACH:
4062  break;
4063 
4064  case DLL_PROCESS_DETACH:
4065 
4066  /* Delete the socket list lock */
4068 
4069  break;
4070  }
4071 
4072  TRACE("DllMain of msafd.dll (leaving)\n");
4073 
4074  return TRUE;
4075 }
#define TRUE
Definition: types.h:120
#define DLL_THREAD_ATTACH
Definition: compat.h:121
BOOL WINAPI DisableThreadLibraryCalls(IN HMODULE hLibModule)
Definition: loader.c:85
#define DLL_PROCESS_ATTACH
Definition: compat.h:120
#define DLL_THREAD_DETACH
Definition: compat.h:122
DWORD dwReason
Definition: misc.cpp:154
VOID WINAPI InitializeCriticalSection(OUT LPCRITICAL_SECTION lpCriticalSection)
Definition: synch.c:751
#define DLL_PROCESS_DETACH
Definition: compat.h:119
#define TRACE(s)
Definition: solgame.cpp:4
#define GetProcessHeap()
Definition: compat.h:395
void WINAPI DeleteCriticalSection(PCRITICAL_SECTION)
LIST_ENTRY SockHelpersListHead
Definition: dllmain.c:25
HANDLE GlobalHeap
Definition: dllmain.c:19
#define InitializeListHead(ListHead)
Definition: env_spec_w32.h:944
CRITICAL_SECTION SocketListLock
Definition: dllmain.c:24

◆ GetCurrentTimeInSeconds()

DWORD GetCurrentTimeInSeconds ( VOID  )

Definition at line 1417 of file dllmain.c.

1418 {
1419  SYSTEMTIME st1970 = { 1970, 1, 0, 1, 0, 0, 0, 0 };
1420  union
1421  {
1422  FILETIME ft;
1423  ULONGLONG ll;
1424  } u1970, Time;
1425 
1427  SystemTimeToFileTime(&st1970, &u1970.ft);
1428  return (DWORD)((Time.ll - u1970.ll) / 10000000ULL);
1429 }
VOID WINAPI GetSystemTimeAsFileTime(OUT PFILETIME lpFileTime)
Definition: time.c:128
#define ULL(a, b)
Definition: format_msg.c:27
uint64_t ULONGLONG
Definition: typedefs.h:65
unsigned long DWORD
Definition: ntddk_ex.h:95
BOOL WINAPI SystemTimeToFileTime(IN CONST SYSTEMTIME *lpSystemTime, OUT LPFILETIME lpFileTime)
Definition: time.c:148
w ll
Definition: byte_order.h:166
static PLARGE_INTEGER Time
Definition: time.c:105

Referenced by WSPAccept(), WSPConnect(), and WSPGetSockOpt().

◆ GetSocketInformation()

int GetSocketInformation ( PSOCKET_INFORMATION  Socket,
ULONG  AfdInformationClass,
PBOOLEAN Boolean  OPTIONAL,
PULONG Ulong  OPTIONAL,
PLARGE_INTEGER LargeInteger  OPTIONAL,
LPWSAOVERLAPPED Overlapped  OPTIONAL,
LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine  OPTIONAL 
)

Definition at line 3257 of file dllmain.c.

3264 {
3265  PIO_STATUS_BLOCK IOSB;
3266  IO_STATUS_BLOCK DummyIOSB;
3267  AFD_INFO InfoData;
3268  NTSTATUS Status;
3269  PAFDAPCCONTEXT APCContext;
3270  PIO_APC_ROUTINE APCFunction;
3271  HANDLE Event = NULL;
3272  HANDLE SockEvent;
3273 
3276  NULL,
3278  FALSE);
3279 
3280  if( !NT_SUCCESS(Status) )
3281  return SOCKET_ERROR;
3282 
3283  /* Set Info Class */
3284  InfoData.InformationClass = AfdInformationClass;
3285 
3286  /* Verify if we should use APC */
3287  if (Overlapped == NULL)
3288  {
3289  /* Not using Overlapped structure, so use normal blocking on event */
3290  APCContext = NULL;
3291  APCFunction = NULL;
3292  Event = SockEvent;
3293  IOSB = &DummyIOSB;
3294  }
3295  else
3296  {
3297  /* Overlapped request for non overlapped opened socket */
3298  if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
3299  {
3300  TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3301  NtClose( SockEvent );
3302  return 0;
3303  }
3304  if (CompletionRoutine == NULL)
3305  {
3306  /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3307  APCContext = (PAFDAPCCONTEXT)Overlapped;
3308  APCFunction = NULL;
3309  Event = Overlapped->hEvent;
3310  }
3311  else
3312  {
3313  /* Using Overlapped Structure and a Completition Routine, so use an APC */
3314  APCFunction = &AfdInfoAPC; // should be a private io completition function inside us
3315  APCContext = HeapAlloc(GlobalHeap, 0, sizeof(AFDAPCCONTEXT));
3316  if (!APCContext)
3317  {
3318  ERR("Not enough memory for APC Context\n");
3319  NtClose( SockEvent );
3320  return WSAEFAULT;
3321  }
3322  APCContext->lpCompletionRoutine = CompletionRoutine;
3323  APCContext->lpOverlapped = Overlapped;
3324  APCContext->lpSocket = Socket;
3325  }
3326 
3327  IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3328  }
3329 
3330  IOSB->Status = STATUS_PENDING;
3331 
3332  /* Send IOCTL */
3334  Event,
3335  APCFunction,
3336  APCContext,
3337  IOSB,
3339  &InfoData,
3340  sizeof(InfoData),
3341  &InfoData,
3342  sizeof(InfoData));
3343 
3344  /* Wait for return */
3345  if (Status == STATUS_PENDING && Overlapped == NULL)
3346  {
3348  Status = IOSB->Status;
3349  }
3350 
3351  NtClose( SockEvent );
3352 
3353  TRACE("Status %x Information %d\n", Status, IOSB->Information);
3354 
3355  if (Status == STATUS_PENDING)
3356  {
3357  TRACE("Leaving (Pending)\n");
3358  return WSA_IO_PENDING;
3359  }
3360 
3361  if (Status != STATUS_SUCCESS)
3362  return SOCKET_ERROR;
3363 
3364  /* Return Information */
3365  if (Ulong != NULL)
3366  {
3367  *Ulong = InfoData.Information.Ulong;
3368  }
3369  if (LargeInteger != NULL)
3370  {
3371  *LargeInteger = InfoData.Information.LargeInteger;
3372  }
3373  if (Boolean != NULL)
3374  {
3375  *Boolean = InfoData.Information.Boolean;
3376  }
3377 
3378  return NO_ERROR;
3379 
3380 }
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
VOID(* PIO_APC_ROUTINE)(IN PVOID ApcContext, IN PIO_STATUS_BLOCK IoStatusBlock, IN ULONG Reserved)
Definition: nt_native.h:877
#define WSAEFAULT
Definition: winerror.h:1945
BOOLEAN Boolean
Definition: shared.h:33
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
struct _AFDAPCCONTEXT * PAFDAPCCONTEXT
union _AFD_INFO::@3259 Information
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define NO_ERROR
Definition: dderror.h:5
DWORD CreateFlags
Definition: msafd.h:81
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
LARGE_INTEGER LargeInteger
Definition: shared.h:32
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
#define WSA_IO_PENDING
Definition: winsock2.h:589
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
ULONG InformationClass
Definition: shared.h:29
LPWSAOVERLAPPED lpOverlapped
Definition: msafd.h:138
struct _IO_STATUS_BLOCK * PIO_STATUS_BLOCK
Definition: change.c:34
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
HANDLE GlobalHeap
Definition: dllmain.c:19
#define SO_SYNCHRONOUS_NONALERT
Definition: ws2_32.h:41
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
#define IOCTL_AFD_GET_INFO
Definition: shared.h:327
VOID NTAPI AfdInfoAPC(PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved)
Definition: dllmain.c:3246
PSOCKET_INFORMATION lpSocket
Definition: msafd.h:140
LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
Definition: msafd.h:139
_In_ PIRP _In_opt_ PVOID _In_opt_ POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine
Definition: fsrtlfuncs.h:673
#define INFINITE
Definition: serial.h:102
unsigned long Ulong
Definition: utypes.h:42
return STATUS_SUCCESS
Definition: btrfs.c:2966
ULONG Ulong
Definition: shared.h:31

Referenced by WSPCloseSocket(), WSPIoctl(), WSPSetSockOpt(), and WSPSocket().

◆ GetSocketStructure()

PSOCKET_INFORMATION GetSocketStructure ( SOCKET  Handle)

Definition at line 3507 of file dllmain.c.

3508 {
3509  PSOCKET_INFORMATION CurrentSocket;
3510 
3512 
3513  CurrentSocket = SocketListHead;
3514  while (CurrentSocket)
3515  {
3516  if (CurrentSocket->Handle == Handle)
3517  {
3519  return CurrentSocket;
3520  }
3521 
3522  CurrentSocket = CurrentSocket->NextSocket;
3523  }
3524 
3526 
3527  return NULL;
3528 }
SOCKET Handle
Definition: msafd.h:99
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
struct _SOCKET_INFORMATION * NextSocket
Definition: msafd.h:116
smooth NULL
Definition: ftsmooth.c:416
_In_ HANDLE Handle
Definition: extypes.h:390
CRITICAL_SECTION SocketListLock
Definition: dllmain.c:24
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
PSOCKET_INFORMATION SocketListHead
Definition: dllmain.c:23

Referenced by WSPAccept(), WSPAsyncSelect(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPDuplicateSocket(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetOverlappedResult(), WSPGetPeerName(), WSPGetSockName(), WSPGetSockOpt(), WSPIoctl(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), WSPSetSockOpt(), and WSPShutdown().

◆ SetSocketInformation()

int SetSocketInformation ( PSOCKET_INFORMATION  Socket,
ULONG  AfdInformationClass,
PBOOLEAN Boolean  OPTIONAL,
PULONG Ulong  OPTIONAL,
PLARGE_INTEGER LargeInteger  OPTIONAL,
LPWSAOVERLAPPED Overlapped  OPTIONAL,
LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine  OPTIONAL 
)

Definition at line 3384 of file dllmain.c.

3391 {
3392  PIO_STATUS_BLOCK IOSB;
3393  IO_STATUS_BLOCK DummyIOSB;
3394  AFD_INFO InfoData;
3395  NTSTATUS Status;
3396  PAFDAPCCONTEXT APCContext;
3397  PIO_APC_ROUTINE APCFunction;
3398  HANDLE Event = NULL;
3399  HANDLE SockEvent;
3400 
3403  NULL,
3405  FALSE);
3406 
3407  if( !NT_SUCCESS(Status) )
3408  return SOCKET_ERROR;
3409 
3410  /* Set Info Class */
3411  InfoData.InformationClass = AfdInformationClass;
3412 
3413  /* Set Information */
3414  if (Ulong != NULL)
3415  {
3416  InfoData.Information.Ulong = *Ulong;
3417  }
3418  if (LargeInteger != NULL)
3419  {
3420  InfoData.Information.LargeInteger = *LargeInteger;
3421  }
3422  if (Boolean != NULL)
3423  {
3424  InfoData.Information.Boolean = *Boolean;
3425  }
3426 
3427  /* Verify if we should use APC */
3428  if (Overlapped == NULL)
3429  {
3430  /* Not using Overlapped structure, so use normal blocking on event */
3431  APCContext = NULL;
3432  APCFunction = NULL;
3433  Event = SockEvent;
3434  IOSB = &DummyIOSB;
3435  }
3436  else
3437  {
3438  /* Overlapped request for non overlapped opened socket */
3439  if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
3440  {
3441  TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
3442  NtClose( SockEvent );
3443  return 0;
3444  }
3445  if (CompletionRoutine == NULL)
3446  {
3447  /* Using Overlapped Structure, but no Completition Routine, so no need for APC */
3448  APCContext = (PAFDAPCCONTEXT)Overlapped;
3449  APCFunction = NULL;
3450  Event = Overlapped->hEvent;
3451  }
3452  else
3453  {
3454  /* Using Overlapped Structure and a Completition Routine, so use an APC */
3455  APCFunction = &AfdInfoAPC; // should be a private io completition function inside us
3456  APCContext = HeapAlloc(GlobalHeap, 0, sizeof(AFDAPCCONTEXT));
3457  if (!APCContext)
3458  {
3459  ERR("Not enough memory for APC Context\n");
3460  NtClose( SockEvent );
3461  return WSAEFAULT;
3462  }
3463  APCContext->lpCompletionRoutine = CompletionRoutine;
3464  APCContext->lpOverlapped = Overlapped;
3465  APCContext->lpSocket = Socket;
3466  }
3467 
3468  IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
3469  }
3470 
3471  IOSB->Status = STATUS_PENDING;
3472 
3473  /* Send IOCTL */
3475  Event,
3476  APCFunction,
3477  APCContext,
3478  IOSB,
3480  &InfoData,
3481  sizeof(InfoData),
3482  NULL,
3483  0);
3484 
3485  /* Wait for return */
3486  if (Status == STATUS_PENDING && Overlapped == NULL)
3487  {
3489  Status = IOSB->Status;
3490  }
3491 
3492  NtClose( SockEvent );
3493 
3494  TRACE("Status %x Information %d\n", Status, IOSB->Information);
3495 
3496  if (Status == STATUS_PENDING)
3497  {
3498  TRACE("Leaving (Pending)\n");
3499  return WSA_IO_PENDING;
3500  }
3501 
3503 
3504 }
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
VOID(* PIO_APC_ROUTINE)(IN PVOID ApcContext, IN PIO_STATUS_BLOCK IoStatusBlock, IN ULONG Reserved)
Definition: nt_native.h:877
#define WSAEFAULT
Definition: winerror.h:1945
BOOLEAN Boolean
Definition: shared.h:33
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
struct _AFDAPCCONTEXT * PAFDAPCCONTEXT
union _AFD_INFO::@3259 Information
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define NO_ERROR
Definition: dderror.h:5
DWORD CreateFlags
Definition: msafd.h:81
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
LARGE_INTEGER LargeInteger
Definition: shared.h:32
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
#define WSA_IO_PENDING
Definition: winsock2.h:589
#define IOCTL_AFD_SET_INFO
Definition: shared.h:295
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
ULONG InformationClass
Definition: shared.h:29
LPWSAOVERLAPPED lpOverlapped
Definition: msafd.h:138
struct _IO_STATUS_BLOCK * PIO_STATUS_BLOCK
Definition: change.c:34
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
HANDLE GlobalHeap
Definition: dllmain.c:19
#define SO_SYNCHRONOUS_NONALERT
Definition: ws2_32.h:41
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
VOID NTAPI AfdInfoAPC(PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved)
Definition: dllmain.c:3246
PSOCKET_INFORMATION lpSocket
Definition: msafd.h:140
LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine
Definition: msafd.h:139
_In_ PIRP _In_opt_ PVOID _In_opt_ POPLOCK_WAIT_COMPLETE_ROUTINE CompletionRoutine
Definition: fsrtlfuncs.h:673
#define INFINITE
Definition: serial.h:102
unsigned long Ulong
Definition: utypes.h:42
return STATUS_SUCCESS
Definition: btrfs.c:2966
ULONG Ulong
Definition: shared.h:31

Referenced by WSPAsyncSelect(), WSPEventSelect(), WSPIoctl(), and WSPSetSockOpt().

◆ SockAsyncSelectCompletionRoutine()

VOID SockAsyncSelectCompletionRoutine ( PVOID  Context,
PIO_STATUS_BLOCK  IoStatusBlock 
)

Definition at line 3737 of file dllmain.c.

3738 {
3739 
3740  PASYNC_DATA AsyncData = Context;
3741  PSOCKET_INFORMATION Socket;
3742  ULONG x;
3743 
3744  /* Get the Socket */
3745  Socket = AsyncData->ParentSocket;
3746 
3747  /* Check if the Sequence Number Changed behind our back */
3748  if (AsyncData->SequenceNumber != Socket->SharedData->SequenceNumber )
3749  {
3750  return;
3751  }
3752 
3753  /* Check we were manually called b/c of a failure */
3755  {
3756  /* FIXME: Perform Upcall */
3757  return;
3758  }
3759 
3760  for (x = 1; x; x<<=1)
3761  {
3762  switch (AsyncData->AsyncSelectInfo.Handles[0].Events & x)
3763  {
3764  case AFD_EVENT_RECEIVE:
3765  if (0 != (Socket->SharedData->AsyncEvents & FD_READ) &&
3766  0 == (Socket->SharedData->AsyncDisabledEvents & FD_READ))
3767  {
3768  /* Make the Notification */
3770  Socket->SharedData->wMsg,
3771  Socket->Handle,
3773  /* Disable this event until the next read(); */
3775  }
3776  break;
3777 
3778  case AFD_EVENT_OOB_RECEIVE:
3779  if (0 != (Socket->SharedData->AsyncEvents & FD_OOB) &&
3780  0 == (Socket->SharedData->AsyncDisabledEvents & FD_OOB))
3781  {
3782  /* Make the Notification */
3784  Socket->SharedData->wMsg,
3785  Socket->Handle,
3787  /* Disable this event until the next read(); */
3789  }
3790  break;
3791 
3792  case AFD_EVENT_SEND:
3793  if (0 != (Socket->SharedData->AsyncEvents & FD_WRITE) &&
3794  0 == (Socket->SharedData->AsyncDisabledEvents & FD_WRITE))
3795  {
3796  /* Make the Notification */
3798  Socket->SharedData->wMsg,
3799  Socket->Handle,
3801  /* Disable this event until the next write(); */
3803  }
3804  break;
3805 
3806  /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3807  case AFD_EVENT_CONNECT:
3809  if (0 != (Socket->SharedData->AsyncEvents & FD_CONNECT) &&
3810  0 == (Socket->SharedData->AsyncDisabledEvents & FD_CONNECT))
3811  {
3812  /* Make the Notification */
3814  Socket->SharedData->wMsg,
3815  Socket->Handle,
3817  /* Disable this event forever; */
3819  }
3820  break;
3821 
3822  case AFD_EVENT_ACCEPT:
3823  if (0 != (Socket->SharedData->AsyncEvents & FD_ACCEPT) &&
3824  0 == (Socket->SharedData->AsyncDisabledEvents & FD_ACCEPT))
3825  {
3826  /* Make the Notification */
3828  Socket->SharedData->wMsg,
3829  Socket->Handle,
3831  /* Disable this event until the next accept(); */
3833  }
3834  break;
3835 
3836  case AFD_EVENT_DISCONNECT:
3837  case AFD_EVENT_ABORT:
3838  case AFD_EVENT_CLOSE:
3839  if (0 != (Socket->SharedData->AsyncEvents & FD_CLOSE) &&
3840  0 == (Socket->SharedData->AsyncDisabledEvents & FD_CLOSE))
3841  {
3842  /* Make the Notification */
3844  Socket->SharedData->wMsg,
3845  Socket->Handle,
3847  /* Disable this event forever; */
3849  }
3850  break;
3851  /* FIXME: Support QOS */
3852  }
3853  }
3854 
3855  /* Check if there are any events left for us to check */
3856  if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
3857  {
3858  return;
3859  }
3860 
3861  /* Keep Polling */
3862  SockProcessAsyncSelect(Socket, AsyncData);
3863  return;
3864 }
DWORD SequenceNumber
Definition: msafd.h:131
VOID SockProcessAsyncSelect(PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
Definition: dllmain.c:3866
#define AFD_EVENT_CONNECT_FAIL
Definition: shared.h:211
#define FD_ACCEPT
Definition: winsock.h:408
#define FD_CONNECT
Definition: winsock.h:409
#define AFD_EVENT_DISCONNECT
Definition: shared.h:206
SOCKET Handle
Definition: msafd.h:99
#define AFD_EVENT_ABORT
Definition: shared.h:207
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
DWORD SequenceNumber
Definition: msafd.h:90
#define FD_READ
Definition: winsock.h:405
#define FD_OOB
Definition: winsock.h:407
#define FD_WRITE
Definition: winsock.h:406
#define AFD_EVENT_CLOSE
Definition: shared.h:208
#define WSAMAKESELECTREPLY(e, error)
Definition: winsock.h:478
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
ULONG Events
Definition: shared.h:51
#define AFD_EVENT_RECEIVE
Definition: shared.h:203
#define AFD_EVENT_CONNECT
Definition: shared.h:209
AFD_POLL_INFO AsyncSelectInfo
Definition: msafd.h:133
#define AFD_EVENT_SEND
Definition: shared.h:205
#define AFD_EVENT_ACCEPT
Definition: shared.h:210
#define FD_CLOSE
Definition: winsock.h:410
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
PSOCKET_INFORMATION ParentSocket
Definition: msafd.h:130
#define AFD_EVENT_OOB_RECEIVE
Definition: shared.h:204
LONG AsyncDisabledEvents
Definition: msafd.h:93
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
AFD_HANDLE Handles[1]
Definition: shared.h:59
struct tagContext Context
Definition: acpixf.h:1024
unsigned int ULONG
Definition: retypes.h:1
WSPUPCALLTABLE Upcalls
Definition: dllmain.c:20
LPWPUPOSTMESSAGE lpWPUPostMessage
Definition: ws2spi.h:609
LONG AsyncEvents
Definition: msafd.h:92

Referenced by SockGetAsyncSelectHelperAfdHandle(), and SockProcessAsyncSelect().

◆ SockAsyncThread()

ULONG NTAPI SockAsyncThread ( PVOID  ThreadParam)

Definition at line 3641 of file dllmain.c.

3642 {
3643  PVOID AsyncContext;
3644  PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine;
3645  IO_STATUS_BLOCK IOSB;
3646  NTSTATUS Status;
3647 
3648  /* Make the Thread Higher Priority */
3650 
3651  /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
3652  do
3653  {
3655  (PVOID*)&AsyncCompletionRoutine,
3656  &AsyncContext,
3657  &IOSB,
3658  NULL);
3659  /* Call the Async Function */
3660  if (NT_SUCCESS(Status))
3661  {
3662  (*AsyncCompletionRoutine)(AsyncContext, &IOSB);
3663  }
3664  else
3665  {
3666  /* It Failed, sleep for a second */
3667  Sleep(1000);
3668  }
3669  } while ((Status != STATUS_TIMEOUT));
3670 
3671  /* The Thread has Ended */
3672  return 0;
3673 }
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
LONG NTSTATUS
Definition: precomp.h:26
HANDLE SockAsyncCompletionPort
Definition: dllmain.c:28
#define STATUS_TIMEOUT
Definition: ntstatus.h:81
#define THREAD_PRIORITY_ABOVE_NORMAL
Definition: winbase.h:272
HANDLE WINAPI GetCurrentThread(VOID)
Definition: proc.c:1148
smooth NULL
Definition: ftsmooth.c:416
BOOL WINAPI SetThreadPriority(IN HANDLE hThread, IN int nPriority)
Definition: thread.c:699
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
Status
Definition: gdiplustypes.h:24
VOID(* PASYNC_COMPLETION_ROUTINE)(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: msafd.h:542
NTSTATUS NTAPI NtRemoveIoCompletion(IN HANDLE IoCompletionHandle, OUT PVOID *KeyContext, OUT PVOID *ApcContext, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER Timeout OPTIONAL)
Definition: iocomp.c:444

Referenced by SockCreateOrReferenceAsyncThread().

◆ SockCreateOrReferenceAsyncThread()

BOOLEAN SockCreateOrReferenceAsyncThread ( VOID  )

Definition at line 3580 of file dllmain.c.

3581 {
3582  HANDLE hAsyncThread;
3583  DWORD AsyncThreadId;
3584  HANDLE AsyncEvent;
3586  NTSTATUS Status;
3587 
3588  /* Check if the Thread Already Exists */
3590  {
3592  return TRUE;
3593  }
3594 
3595  /* Create the Completion Port */
3597  {
3600  NULL,
3601  2); // Allow 2 threads only
3602  if (!NT_SUCCESS(Status))
3603  {
3604  ERR("Failed to create completion port: 0x%08x\n", Status);
3605  return FALSE;
3606  }
3607  /* Protect Handle */
3608  HandleFlags.ProtectFromClose = TRUE;
3609  HandleFlags.Inherit = FALSE;
3611  ObjectHandleFlagInformation,
3612  &HandleFlags,
3613  sizeof(HandleFlags));
3614  }
3615 
3616  /* Create the Async Event */
3617  Status = NtCreateEvent(&AsyncEvent,
3619  NULL,
3621  FALSE);
3622 
3623  /* Create the Async Thread */
3624  hAsyncThread = CreateThread(NULL,
3625  0,
3627  NULL,
3628  0,
3629  &AsyncThreadId);
3630 
3631  /* Close the Handle */
3632  NtClose(hAsyncThread);
3633 
3634  /* Increase the Reference Count */
3636  return TRUE;
3637 }
#define TRUE
Definition: types.h:120
#define IO_COMPLETION_ALL_ACCESS
Definition: file.c:72
LONG NTSTATUS
Definition: precomp.h:26
HANDLE SockAsyncCompletionPort
Definition: dllmain.c:28
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
NTSTATUS NTAPI NtSetInformationObject(IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, IN PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1735
HANDLE WINAPI DECLSPEC_HOTPATCH CreateThread(IN LPSECURITY_ATTRIBUTES lpThreadAttributes, IN DWORD dwStackSize, IN LPTHREAD_START_ROUTINE lpStartAddress, IN LPVOID lpParameter, IN DWORD dwCreationFlags, OUT LPDWORD lpThreadId)
Definition: thread.c:136
smooth NULL
Definition: ftsmooth.c:416
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
unsigned long DWORD
Definition: ntddk_ex.h:95
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
ULONG SockAsyncThreadRefCount
Definition: dllmain.c:26
NTSTATUS NTAPI NtCreateIoCompletion(OUT PHANDLE IoCompletionHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, IN ULONG NumberOfConcurrentThreads)
Definition: iocomp.c:253
ULONG NTAPI SockAsyncThread(PVOID ThreadParam)
Definition: dllmain.c:3641

Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

◆ SockGetAsyncSelectHelperAfdHandle()

BOOLEAN SockGetAsyncSelectHelperAfdHandle ( VOID  )

Definition at line 3675 of file dllmain.c.

3676 {
3677  UNICODE_STRING AfdHelper;
3679  IO_STATUS_BLOCK IoSb;
3680  FILE_COMPLETION_INFORMATION CompletionInfo;
3682 
3683  /* First, make sure we're not already initialized */
3685  {
3686  return TRUE;
3687  }
3688 
3689  /* Set up Handle Name and Object */
3690  RtlInitUnicodeString(&AfdHelper, L"\\Device\\Afd\\AsyncSelectHlp" );
3692  &AfdHelper,
3694  NULL,
3695  NULL);
3696 
3697  /* Open the Handle to AFD */
3701  &IoSb,
3702  NULL,
3703  0,
3705  FILE_OPEN_IF,
3706  0,
3707  NULL,
3708  0);
3709 
3710  /*
3711  * Now Set up the Completion Port Information
3712  * This means that whenever a Poll is finished, the routine will be executed
3713  */
3714  CompletionInfo.Port = SockAsyncCompletionPort;
3715  CompletionInfo.Key = SockAsyncSelectCompletionRoutine;
3717  &IoSb,
3718  &CompletionInfo,
3719  sizeof(CompletionInfo),
3721 
3722 
3723  /* Protect the Handle */
3724  HandleFlags.ProtectFromClose = TRUE;
3725  HandleFlags.Inherit = FALSE;
3727  ObjectHandleFlagInformation,
3728  &HandleFlags,
3729  sizeof(HandleFlags));
3730 
3731 
3732  /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
3734  return TRUE;
3735 }
IN PUNICODE_STRING IN POBJECT_ATTRIBUTES ObjectAttributes
Definition: conport.c:35
#define TRUE
Definition: types.h:120
#define FILE_OPEN_IF
Definition: from_kernel.h:56
HANDLE SockAsyncCompletionPort
Definition: dllmain.c:28
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define FILE_SHARE_READ
Definition: compat.h:125
#define GENERIC_WRITE
Definition: nt_native.h:90
NTSTATUS NTAPI NtSetInformationObject(IN HANDLE ObjectHandle, IN OBJECT_INFORMATION_CLASS ObjectInformationClass, IN PVOID ObjectInformation, IN ULONG Length)
Definition: oblife.c:1735
smooth NULL
Definition: ftsmooth.c:416
NTSTATUS NTAPI NtCreateFile(OUT PHANDLE FileHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes, OUT PIO_STATUS_BLOCK IoStatusBlock, IN PLARGE_INTEGER AllocationSize OPTIONAL, IN ULONG FileAttributes, IN ULONG ShareAccess, IN ULONG CreateDisposition, IN ULONG CreateOptions, IN PVOID EaBuffer OPTIONAL, IN ULONG EaLength)
#define OBJ_INHERIT
Definition: winternl.h:225
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
static const WCHAR L[]
Definition: oid.c:1250
#define GENERIC_READ
Definition: compat.h:124
#define SYNCHRONIZE
Definition: nt_native.h:61
BOOLEAN SockAsyncSelectCalled
Definition: dllmain.c:29
NTSYSAPI VOID NTAPI RtlInitUnicodeString(PUNICODE_STRING DestinationString, PCWSTR SourceString)
#define InitializeObjectAttributes(p, n, a, r, s)
Definition: reg.c:106
VOID SockAsyncSelectCompletionRoutine(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:3737
HANDLE SockAsyncHelperAfdHandle
Definition: dllmain.c:27
NTSYSAPI NTSTATUS NTAPI NtSetInformationFile(IN HANDLE hFile, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN PVOID FileInformationBuffer, IN ULONG FileInformationBufferLength, IN FILE_INFORMATION_CLASS FileInfoClass)
Definition: iofunc.c:3042

Referenced by WSPAsyncSelect().

◆ SockProcessAsyncSelect()

VOID SockProcessAsyncSelect ( PSOCKET_INFORMATION  Socket,
PASYNC_DATA  AsyncData 
)

Definition at line 3866 of file dllmain.c.

3867 {
3868 
3869  ULONG lNetworkEvents;
3870  NTSTATUS Status;
3871 
3872  /* Set up the Async Data Event Info */
3873  AsyncData->AsyncSelectInfo.Timeout.HighPart = 0x7FFFFFFF;
3874  AsyncData->AsyncSelectInfo.Timeout.LowPart = 0xFFFFFFFF;
3875  AsyncData->AsyncSelectInfo.HandleCount = 1;
3876  AsyncData->AsyncSelectInfo.Exclusive = TRUE;
3877  AsyncData->AsyncSelectInfo.Handles[0].Handle = Socket->Handle;
3878  AsyncData->AsyncSelectInfo.Handles[0].Events = 0;
3879 
3880  /* Remove unwanted events */
3881  lNetworkEvents = Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents);
3882 
3883  /* Set Events to wait for */
3884  if (lNetworkEvents & FD_READ)
3885  {
3887  }
3888 
3889  if (lNetworkEvents & FD_WRITE)
3890  {
3891  AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_SEND;
3892  }
3893 
3894  if (lNetworkEvents & FD_OOB)
3895  {
3897  }
3898 
3899  if (lNetworkEvents & FD_ACCEPT)
3900  {
3902  }
3903 
3904  /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
3905  if (lNetworkEvents & FD_CONNECT)
3906  {
3908  }
3909 
3910  if (lNetworkEvents & FD_CLOSE)
3911  {
3913  }
3914 
3915  if (lNetworkEvents & FD_QOS)
3916  {
3917  AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_QOS;
3918  }
3919 
3920  if (lNetworkEvents & FD_GROUP_QOS)
3921  {
3923  }
3924 
3925  /* Send IOCTL */
3927  NULL,
3928  NULL,
3929  AsyncData,
3930  &AsyncData->IoStatusBlock,
3932  &AsyncData->AsyncSelectInfo,
3933  sizeof(AsyncData->AsyncSelectInfo),
3934  &AsyncData->AsyncSelectInfo,
3935  sizeof(AsyncData->AsyncSelectInfo));
3936 
3937  /* I/O Manager Won't call the completion routine, let's do it manually */
3938  if (NT_SUCCESS(Status))
3939  {
3940  return;
3941  }
3942  else
3943  {
3944  AsyncData->IoStatusBlock.Status = Status;
3945  SockAsyncSelectCompletionRoutine(AsyncData, &AsyncData->IoStatusBlock);
3946  }
3947 }
#define TRUE
Definition: types.h:120
#define AFD_EVENT_CONNECT_FAIL
Definition: shared.h:211
#define FD_ACCEPT
Definition: winsock.h:408
#define FD_CONNECT
Definition: winsock.h:409
#define AFD_EVENT_DISCONNECT
Definition: shared.h:206
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
#define AFD_EVENT_ABORT
Definition: shared.h:207
#define FD_READ
Definition: winsock.h:405
LARGE_INTEGER Timeout
Definition: shared.h:56
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define FD_OOB
Definition: winsock.h:407
#define FD_WRITE
Definition: winsock.h:406
#define AFD_EVENT_CLOSE
Definition: shared.h:208
#define FD_GROUP_QOS
Definition: winsock2.h:308
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
ULONG Events
Definition: shared.h:51
#define IOCTL_AFD_SELECT
Definition: shared.h:285
smooth NULL
Definition: ftsmooth.c:416
#define AFD_EVENT_RECEIVE
Definition: shared.h:203
#define AFD_EVENT_CONNECT
Definition: shared.h:209
AFD_POLL_INFO AsyncSelectInfo
Definition: msafd.h:133
#define AFD_EVENT_SEND
Definition: shared.h:205
#define AFD_EVENT_ACCEPT
Definition: shared.h:210
#define FD_CLOSE
Definition: winsock.h:410
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
ULONG LowPart
Definition: typedefs.h:104
ULONG_PTR Exclusive
Definition: shared.h:58
#define AFD_EVENT_OOB_RECEIVE
Definition: shared.h:204
Status
Definition: gdiplustypes.h:24
IO_STATUS_BLOCK IoStatusBlock
Definition: msafd.h:132
#define AFD_EVENT_QOS
Definition: shared.h:212
LONG AsyncDisabledEvents
Definition: msafd.h:93
ULONG HandleCount
Definition: shared.h:57
AFD_HANDLE Handles[1]
Definition: shared.h:59
unsigned int ULONG
Definition: retypes.h:1
SOCKET Handle
Definition: shared.h:50
VOID SockAsyncSelectCompletionRoutine(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:3737
HANDLE SockAsyncHelperAfdHandle
Definition: dllmain.c:27
LONG AsyncEvents
Definition: msafd.h:92
#define AFD_EVENT_GROUP_QOS
Definition: shared.h:213
#define FD_QOS
Definition: winsock2.h:306

Referenced by SockAsyncSelectCompletionRoutine(), and SockProcessQueuedAsyncSelect().

◆ SockProcessQueuedAsyncSelect()

VOID SockProcessQueuedAsyncSelect ( PVOID  Context,
PIO_STATUS_BLOCK  IoStatusBlock 
)

Definition at line 3949 of file dllmain.c.

3950 {
3951  PASYNC_DATA AsyncData = Context;
3952  BOOL FreeContext = TRUE;
3953  PSOCKET_INFORMATION Socket;
3954 
3955  /* Get the Socket */
3956  Socket = AsyncData->ParentSocket;
3957 
3958  /* If someone closed it, stop the function */
3959  if (Socket->SharedData->State != SocketClosed)
3960  {
3961  /* Check if the Sequence Number changed by now, in which case quit */
3962  if (AsyncData->SequenceNumber == Socket->SharedData->SequenceNumber)
3963  {
3964  /* Do the actual select, if needed */
3965  if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)))
3966  {
3967  SockProcessAsyncSelect(Socket, AsyncData);
3968  FreeContext = FALSE;
3969  }
3970  }
3971  }
3972 
3973  /* Free the Context */
3974  if (FreeContext)
3975  {
3976  HeapFree(GetProcessHeap(), 0, AsyncData);
3977  }
3978 
3979  return;
3980 }
DWORD SequenceNumber
Definition: msafd.h:131
VOID SockProcessAsyncSelect(PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
Definition: dllmain.c:3866
#define TRUE
Definition: types.h:120
DWORD SequenceNumber
Definition: msafd.h:90
unsigned int BOOL
Definition: ntddk_ex.h:94
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
#define GetProcessHeap()
Definition: compat.h:395
PSOCKET_INFORMATION ParentSocket
Definition: msafd.h:130
LONG AsyncDisabledEvents
Definition: msafd.h:93
SOCKET_STATE State
Definition: msafd.h:54
struct tagContext Context
Definition: acpixf.h:1024
LONG AsyncEvents
Definition: msafd.h:92
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

◆ SockReenableAsyncSelectEvent()

VOID SockReenableAsyncSelectEvent ( IN PSOCKET_INFORMATION  Socket,
IN ULONG  Event 
)

Definition at line 3983 of file dllmain.c.

3985 {
3986  PASYNC_DATA AsyncData;
3987 
3988  /* Make sure the event is actually disabled */
3989  if (!(Socket->SharedData->AsyncDisabledEvents & Event))
3990  {
3991  return;
3992  }
3993 
3994  /* Re-enable it */
3995  Socket->SharedData->AsyncDisabledEvents &= ~Event;
3996 
3997  /* Return if no more events are being polled */
3998  if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
3999  {
4000  return;
4001  }
4002 
4003  /* Wait on new events */
4004  AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA));
4005  if (!AsyncData) return;
4006 
4007  /* Create the Asynch Thread if Needed */
4009 
4010  /* Increase the sequence number to stop anything else */
4011  Socket->SharedData->SequenceNumber++;
4012 
4013  /* Set up the Async Data */
4014  AsyncData->ParentSocket = Socket;
4015  AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
4016 
4017  /* Begin Async Select by using I/O Completion */
4020  AsyncData,
4021  0,
4022  0);
4023 
4024  /* All done */
4025  return;
4026 }
DWORD SequenceNumber
Definition: msafd.h:131
HANDLE SockAsyncCompletionPort
Definition: dllmain.c:28
BOOLEAN SockCreateOrReferenceAsyncThread(VOID)
Definition: dllmain.c:3580
VOID SockProcessQueuedAsyncSelect(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:3949
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
NTSTATUS NTAPI NtSetIoCompletion(IN HANDLE IoCompletionPortHandle, IN PVOID CompletionKey, IN PVOID CompletionContext, IN NTSTATUS CompletionStatus, IN ULONG CompletionInformation)
Definition: iocomp.c:568
PSOCKET_INFORMATION ParentSocket
Definition: msafd.h:130

Referenced by AfdAPC(), WSPAccept(), WSPConnect(), WSPGetOverlappedResult(), WSPRecv(), WSPRecvFrom(), WSPSend(), and WSPSendTo().

◆ TranslateNtStatusError()

INT TranslateNtStatusError ( NTSTATUS  Status)

Definition at line 537 of file dllmain.c.

538 {
539  switch (Status)
540  {
541  case STATUS_CANT_WAIT:
542  return WSAEWOULDBLOCK;
543 
544  case STATUS_TIMEOUT:
545  return WSAETIMEDOUT;
546 
547  case STATUS_SUCCESS:
548  return NO_ERROR;
549 
550  case STATUS_FILE_CLOSED:
551  return WSAECONNRESET;
552 
553  case STATUS_END_OF_FILE:
554  return WSAESHUTDOWN;
555 
556  case STATUS_PENDING:
557  return WSA_IO_PENDING;
558 
561  return WSAEMSGSIZE;
562 
563  case STATUS_NO_MEMORY:
565  return WSAENOBUFS;
566 
568  return WSAENOTCONN;
569 
571  return WSAEAFNOSUPPORT;
572 
574  return WSAEADDRNOTAVAIL;
575 
578  return WSAECONNREFUSED;
579 
581  return WSAENETUNREACH;
582 
584  return WSAEHOSTUNREACH;
585 
587  return WSAEINVAL;
588 
589  case STATUS_CANCELLED:
590  return WSA_OPERATION_ABORTED;
591 
593  return WSAEADDRINUSE;
594 
596  return WSAECONNABORTED;
597 
599  return WSAEFAULT;
600 
602  return WSAEACCES;
603 
605  return WSAEOPNOTSUPP;
606 
607  default:
608  ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status);
609  return WSAENETDOWN;
610  }
611 }
#define STATUS_INVALID_CONNECTION
Definition: ntstatus.h:542
#define STATUS_PROTOCOL_NOT_SUPPORTED
Definition: ntstatus.h:958
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define WSAEFAULT
Definition: winerror.h:1945
#define STATUS_NOT_IMPLEMENTED
Definition: ntstatus.h:225
#define WSA_OPERATION_ABORTED
Definition: winsock2.h:594
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
#define WSAEINVAL
Definition: winerror.h:1946
#define WSAEAFNOSUPPORT
Definition: winerror.h:1960
#define WSAEWOULDBLOCK
Definition: winerror.h:1948
#define WSAEACCES
Definition: winerror.h:1944
#define NO_ERROR
Definition: dderror.h:5
#define STATUS_HOST_UNREACHABLE
Definition: ntstatus.h:691
#define STATUS_ADDRESS_ALREADY_EXISTS
Definition: ntstatus.h:640
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:64
#define WSAEOPNOTSUPP
Definition: winerror.h:1958
#define STATUS_END_OF_FILE
Definition: shellext.h:62
#define STATUS_TIMEOUT
Definition: ntstatus.h:81
#define STATUS_REMOTE_DISCONNECT
Definition: ntstatus.h:538
#define WSA_IO_PENDING
Definition: winsock2.h:589
#define WSAETIMEDOUT
Definition: winerror.h:1973
#define STATUS_PENDING
Definition: ntstatus.h:82
#define STATUS_CANCELLED
Definition: udferr_usr.h:170
#define WSAEHOSTUNREACH
Definition: winerror.h:1978
#define WSAENETDOWN
Definition: winerror.h:1963
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
#define WSAEMSGSIZE
Definition: winerror.h:1953
#define WSAENETUNREACH
Definition: winerror.h:1964
#define WSAENOTCONN
Definition: winerror.h:1970
Status
Definition: gdiplustypes.h:24
#define WSAEADDRNOTAVAIL
Definition: winerror.h:1962
#define ERR(fmt,...)
Definition: debug.h:109
#define WSAECONNABORTED
Definition: winerror.h:1966
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:61
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
#define STATUS_INVALID_ADDRESS
Definition: ntstatus.h:543
#define WSAESHUTDOWN
Definition: winerror.h:1971
#define STATUS_NO_MEMORY
Definition: ntstatus.h:246
#define WSAECONNRESET
Definition: winerror.h:1967
#define STATUS_REMOTE_NOT_LISTENING
Definition: ntstatus.h:410
#define STATUS_LOCAL_DISCONNECT
Definition: ntstatus.h:537
#define WSAECONNREFUSED
Definition: winerror.h:1974
#define WSAEADDRINUSE
Definition: winerror.h:1961
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define STATUS_NETWORK_UNREACHABLE
Definition: ntstatus.h:690
#define WSAENOBUFS
Definition: winerror.h:1968
#define STATUS_CANT_WAIT
Definition: ntstatus.h:438
#define STATUS_FILE_CLOSED
Definition: ntstatus.h:518

Referenced by MsafdReturnWithErrno(), WSPAccept(), WSPBind(), WSPConnect(), WSPEnumNetworkEvents(), WSPListen(), WSPShutdown(), and WSPSocket().

◆ WSPAccept()

_Must_inspect_result_ SOCKET WSPAPI WSPAccept ( _In_ SOCKET  Handle,
_Out_writes_bytes_to_opt_ *, *addrlen struct sockaddr FAR SocketAddress,
_Inout_opt_ LPINT  SocketAddressLength,
_In_opt_ LPCONDITIONPROC  lpfnCondition,
_In_opt_ DWORD_PTR  dwCallbackData,
_Out_ LPINT  lpErrno 
)

Definition at line 1434 of file dllmain.c.

1441 {
1442  IO_STATUS_BLOCK IOSB;
1443  PAFD_RECEIVED_ACCEPT_DATA ListenReceiveData;
1444  AFD_ACCEPT_DATA AcceptData;
1445  AFD_DEFER_ACCEPT_DATA DeferData;
1446  AFD_PENDING_ACCEPT_DATA PendingAcceptData;
1447  PSOCKET_INFORMATION Socket = NULL;
1448  NTSTATUS Status;
1449  struct fd_set ReadSet;
1450  struct timeval Timeout;
1451  PVOID PendingData = NULL;
1452  ULONG PendingDataLength = 0;
1453  PVOID CalleeDataBuffer;
1454  WSABUF CallerData, CalleeID, CallerID, CalleeData;
1456  GROUP GroupID = 0;
1457  ULONG CallBack;
1459  PSOCKET_INFORMATION AcceptSocketInfo;
1460  UCHAR ReceiveBuffer[0x1A];
1461  HANDLE SockEvent;
1462 
1463  /* Get the Socket Structure associate to this Socket*/
1464  Socket = GetSocketStructure(Handle);
1465  if (!Socket)
1466  {
1467  if (lpErrno) *lpErrno = WSAENOTSOCK;
1468  return SOCKET_ERROR;
1469  }
1470  if (!Socket->SharedData->Listening)
1471  {
1472  if (lpErrno) *lpErrno = WSAEINVAL;
1473  return SOCKET_ERROR;
1474  }
1475  if ((SocketAddress && !SocketAddressLength) ||
1476  (SocketAddressLength && !SocketAddress) ||
1477  (SocketAddressLength && *SocketAddressLength < sizeof(SOCKADDR)))
1478  {
1479  if (lpErrno) *lpErrno = WSAEFAULT;
1480  return INVALID_SOCKET;
1481  }
1482 
1485  NULL,
1487  FALSE);
1488 
1489  if( !NT_SUCCESS(Status) )
1490  {
1491  return SOCKET_ERROR;
1492  }
1493 
1494  /* Dynamic Structure...ugh */
1495  ListenReceiveData = (PAFD_RECEIVED_ACCEPT_DATA)ReceiveBuffer;
1496 
1497  /* If this is non-blocking, make sure there's something for us to accept */
1498  FD_ZERO(&ReadSet);
1499  FD_SET(Socket->Handle, &ReadSet);
1500  Timeout.tv_sec=0;
1501  Timeout.tv_usec=0;
1502 
1503  if (WSPSelect(0, &ReadSet, NULL, NULL, &Timeout, lpErrno) == SOCKET_ERROR)
1504  {
1505  NtClose(SockEvent);
1506  return SOCKET_ERROR;
1507  }
1508 
1509  if (ReadSet.fd_array[0] != Socket->Handle)
1510  {
1511  NtClose(SockEvent);
1512  if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
1513  return SOCKET_ERROR;
1514  }
1515 
1516  /* Send IOCTL */
1518  SockEvent,
1519  NULL,
1520  NULL,
1521  &IOSB,
1523  NULL,
1524  0,
1525  ListenReceiveData,
1526  0xA + sizeof(*ListenReceiveData));
1527 
1528  /* Wait for return */
1529  if (Status == STATUS_PENDING)
1530  {
1532  Status = IOSB.Status;
1533  }
1534 
1535  if (!NT_SUCCESS(Status))
1536  {
1537  NtClose( SockEvent );
1538  return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
1539  }
1540 
1541  if (lpfnCondition != NULL)
1542  {
1543  if ((Socket->SharedData->ServiceFlags1 & XP1_CONNECT_DATA) != 0)
1544  {
1545  /* Find out how much data is pending */
1546  PendingAcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
1547  PendingAcceptData.ReturnSize = TRUE;
1548 
1549  /* Send IOCTL */
1551  SockEvent,
1552  NULL,
1553  NULL,
1554  &IOSB,
1556  &PendingAcceptData,
1557  sizeof(PendingAcceptData),
1558  &PendingAcceptData,
1559  sizeof(PendingAcceptData));
1560 
1561  /* Wait for return */
1562  if (Status == STATUS_PENDING)
1563  {
1565  Status = IOSB.Status;
1566  }
1567 
1568  if (!NT_SUCCESS(Status))
1569  {
1570  NtClose( SockEvent );
1571  return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
1572  }
1573 
1574  /* How much data to allocate */
1575  PendingDataLength = IOSB.Information;
1576 
1577  if (PendingDataLength)
1578  {
1579  /* Allocate needed space */
1580  PendingData = HeapAlloc(GlobalHeap, 0, PendingDataLength);
1581  if (!PendingData)
1582  {
1584  }
1585 
1586  /* We want the data now */
1587  PendingAcceptData.ReturnSize = FALSE;
1588 
1589  /* Send IOCTL */
1591  SockEvent,
1592  NULL,
1593  NULL,
1594  &IOSB,
1596  &PendingAcceptData,
1597  sizeof(PendingAcceptData),
1598  PendingData,
1599  PendingDataLength);
1600 
1601  /* Wait for return */
1602  if (Status == STATUS_PENDING)
1603  {
1605  Status = IOSB.Status;
1606  }
1607 
1608  if (!NT_SUCCESS(Status))
1609  {
1610  NtClose( SockEvent );
1611  return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
1612  }
1613  }
1614  }
1615 
1616  if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
1617  {
1618  /* I don't support this yet */
1619  }
1620 
1621  /* Build Callee ID */
1622  CalleeID.buf = (PVOID)Socket->LocalAddress;
1623  CalleeID.len = Socket->SharedData->SizeOfLocalAddress;
1624 
1626  if (!RemoteAddress)
1627  {
1629  }
1630 
1631  /* Set up Address in SOCKADDR Format */
1633  &ListenReceiveData->Address.Address[0].AddressType,
1634  sizeof(*RemoteAddress));
1635 
1636  /* Build Caller ID */
1637  CallerID.buf = (PVOID)RemoteAddress;
1638  CallerID.len = sizeof(*RemoteAddress);
1639 
1640  /* Build Caller Data */
1641  CallerData.buf = PendingData;
1642  CallerData.len = PendingDataLength;
1643 
1644  /* Check if socket supports Conditional Accept */
1645  if (Socket->SharedData->UseDelayedAcceptance != 0)
1646  {
1647  /* Allocate Buffer for Callee Data */
1648  CalleeDataBuffer = HeapAlloc(GlobalHeap, 0, 4096);
1649  if (!CalleeDataBuffer) {
1651  }
1652  CalleeData.buf = CalleeDataBuffer;
1653  CalleeData.len = 4096;
1654  }
1655  else
1656  {
1657  /* Nothing */
1658  CalleeData.buf = 0;
1659  CalleeData.len = 0;
1660  }
1661 
1662  /* Call the Condition Function */
1663  CallBack = (lpfnCondition)(&CallerID,
1664  CallerData.buf == NULL ? NULL : &CallerData,
1665  NULL,
1666  NULL,
1667  &CalleeID,
1668  CalleeData.buf == NULL ? NULL : &CalleeData,
1669  &GroupID,
1670  dwCallbackData);
1671 
1672  if (((CallBack == CF_ACCEPT) && GroupID) != 0)
1673  {
1674  /* TBD: Check for Validity */
1675  }
1676 
1677  if (CallBack == CF_ACCEPT)
1678  {
1679  if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
1680  {
1681  /* I don't support this yet */
1682  }
1683  if (CalleeData.buf)
1684  {
1685  // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
1686  }
1687  }
1688  else
1689  {
1690  /* Callback rejected. Build Defer Structure */
1691  DeferData.SequenceNumber = ListenReceiveData->SequenceNumber;
1692  DeferData.RejectConnection = (CallBack == CF_REJECT);
1693 
1694  /* Send IOCTL */
1696  SockEvent,
1697  NULL,
1698  NULL,
1699  &IOSB,
1701  &DeferData,
1702  sizeof(DeferData),
1703  NULL,
1704  0);
1705 
1706  /* Wait for return */
1707  if (Status == STATUS_PENDING)
1708  {
1710  Status = IOSB.Status;
1711  }
1712 
1713  NtClose( SockEvent );
1714 
1715  if (!NT_SUCCESS(Status))
1716  {
1717  return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
1718  }
1719 
1720  if (CallBack == CF_REJECT )
1721  {
1722  if (lpErrno) *lpErrno = WSAECONNREFUSED;
1723  return SOCKET_ERROR;
1724  }
1725  else
1726  {
1727  if (lpErrno) *lpErrno = WSAECONNREFUSED;
1728  return SOCKET_ERROR;
1729  }
1730  }
1731  }
1732 
1733  /* Create a new Socket */
1735  Socket->SharedData->SocketType,
1736  Socket->SharedData->Protocol,
1737  &Socket->ProtocolInfo,
1738  GroupID,
1739  Socket->SharedData->CreateFlags,
1740  lpErrno);
1742  return SOCKET_ERROR;
1743 
1744  /* Set up the Accept Structure */
1745  AcceptData.ListenHandle = (HANDLE)AcceptSocket;
1746  AcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
1747 
1748  /* Send IOCTL to Accept */
1750  SockEvent,
1751  NULL,
1752  NULL,
1753  &IOSB,
1755  &AcceptData,
1756  sizeof(AcceptData),
1757  NULL,
1758  0);
1759 
1760  /* Wait for return */
1761  if (Status == STATUS_PENDING)
1762  {
1764  Status = IOSB.Status;
1765  }
1766 
1768  if (!NT_SUCCESS(Status))
1769  {
1770  NtClose(SockEvent);
1771  WSPCloseSocket( AcceptSocket, lpErrno );
1772  return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
1773  }
1774 
1775  AcceptSocketInfo = GetSocketStructure(AcceptSocket);
1776  if (!AcceptSocketInfo)
1777  {
1778  NtClose(SockEvent);
1779  WSPCloseSocket( AcceptSocket, lpErrno );
1781  }
1782 
1783  AcceptSocketInfo->SharedData->State = SocketConnected;
1784  AcceptSocketInfo->SharedData->ConnectTime = GetCurrentTimeInSeconds();
1785 
1786  /* Return Address in SOCKADDR FORMAT */
1787  if( SocketAddress )
1788  {
1789  RtlCopyMemory (SocketAddress,
1790  &ListenReceiveData->Address.Address[0].AddressType,
1791  sizeof(*RemoteAddress));
1792  if( SocketAddressLength )
1793  *SocketAddressLength = sizeof(*RemoteAddress);
1794  }
1795 
1796  NtClose( SockEvent );
1797 
1798  /* Re-enable Async Event */
1800 
1801  TRACE("Socket %x\n", AcceptSocket);
1802 
1803  if (Status == STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_ACCEPT))
1804  {
1805  Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
1806  Socket->Handle,
1807  Socket->TdiAddressHandle,
1808  Socket->TdiConnectionHandle,
1810 
1811  if (Status)
1812  {
1813  if (lpErrno) *lpErrno = Status;
1814  return SOCKET_ERROR;
1815  }
1816  }
1817 
1818  if (lpErrno) *lpErrno = NO_ERROR;
1819 
1820  /* Return Socket */
1821  return AcceptSocket;
1822 }
Definition: winsock.h:66
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
INT WSPAPI WSPCloseSocket(IN SOCKET Handle, OUT LPINT lpErrno)
Definition: dllmain.c:623
#define STATUS_PROTOCOL_NOT_SUPPORTED
Definition: ntstatus.h:958
INT AddressFamily
Definition: msafd.h:56
HANDLE SockEvent
TRANSPORT_ADDRESS Address
Definition: shared.h:70
BOOLEAN Listening
Definition: msafd.h:68
#define TRUE
Definition: types.h:120
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
BOOLEAN RejectConnection
Definition: shared.h:81
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define WSAEFAULT
Definition: winerror.h:1945
#define FD_ACCEPT
Definition: winsock.h:408
VOID SockReenableAsyncSelectEvent(IN PSOCKET_INFORMATION Socket, IN ULONG Event)
Definition: dllmain.c:3983
#define WSAEINVAL
Definition: winerror.h:1946
ULONG ConnectTime
Definition: msafd.h:66
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
struct _AFD_RECEIVED_ACCEPT_DATA * PAFD_RECEIVED_ACCEPT_DATA
#define WSAEWOULDBLOCK
Definition: winerror.h:1948
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
#define CF_REJECT
Definition: winsock2.h:414
#define XP1_QOS_SUPPORTED
Definition: winsock2.h:449
BOOLEAN UseDelayedAcceptance
Definition: msafd.h:78
#define WSH_NOTIFY_ACCEPT
Definition: wsahelp.h:13
#define IOCTL_AFD_GET_PENDING_CONNECT_DATA
Definition: shared.h:333
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
#define FD_ZERO(set)
Definition: winsock.h:96
#define FD_SET(fd, set)
Definition: winsock.h:89
#define IOCTL_AFD_WAIT_FOR_LISTEN
Definition: shared.h:273
#define NO_ERROR
Definition: dderror.h:5
DWORD GetCurrentTimeInSeconds(VOID)
Definition: dllmain.c:1417
WSAPROTOCOL_INFOW ProtocolInfo
Definition: msafd.h:115
DWORD CreateFlags
Definition: msafd.h:81
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
ULONG SequenceNumber
Definition: shared.h:64
smooth NULL
Definition: ftsmooth.c:416
PHELPER_DATA HelperData
Definition: msafd.h:103
#define CF_ACCEPT
Definition: winsock2.h:413
void * PVOID
Definition: retypes.h:9
_In_ HANDLE Handle
Definition: extypes.h:390
DWORD ServiceFlags1
Definition: msafd.h:82
#define TRACE(s)
Definition: solgame.cpp:4
DWORD HelperEvents
Definition: msafd.h:102
#define IOCTL_AFD_DEFER_ACCEPT
Definition: shared.h:331
INT SocketType
Definition: msafd.h:57
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define INVALID_SOCKET
Definition: winsock.h:332
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
SOCKET WSPAPI WSPSocket(int AddressFamily, int SocketType, int Protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags, LPINT lpErrno)
Definition: dllmain.c:48
ULONG len
Definition: ws2def.h:519
unsigned int GROUP
Definition: winsock2.h:640
PWSH_NOTIFY WSHNotify
Definition: helpers.h:25
PVOID HANDLE
Definition: typedefs.h:71
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
unsigned char UCHAR
Definition: xmlstorage.h:181
#define IOCTL_AFD_ACCEPT
Definition: shared.h:275
INT SizeOfLocalAddress
Definition: msafd.h:59
#define XP1_CONNECT_DATA
Definition: winsock2.h:443
USHORT AddressType
Definition: tdi.h:339
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
HANDLE GlobalHeap
Definition: dllmain.c:19
CHAR FAR * buf
Definition: ws2def.h:520
Status
Definition: gdiplustypes.h:24
TA_ADDRESS Address[1]
Definition: tdi.h:377
int WSPAPI 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)
Definition: dllmain.c:1065
static ULONG Timeout
Definition: ping.c:61
PSOCKADDR LocalAddress
Definition: msafd.h:105
INT TranslateNtStatusError(NTSTATUS Status)
Definition: dllmain.c:537
INT SocketLastError
Definition: msafd.h:87
HANDLE ListenHandle
Definition: shared.h:65
SOCKET_STATE State
Definition: msafd.h:54
#define WSAECONNREFUSED
Definition: winerror.h:1974
unsigned int ULONG
Definition: retypes.h:1
UINT_PTR SOCKET
Definition: winsock.h:47
PVOID HelperContext
Definition: msafd.h:104
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR _In_opt_ PWSK_SOCKET AcceptSocket
Definition: wsk.h:170
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2966
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR RemoteAddress
Definition: wsk.h:170

Referenced by WSPStartup().

◆ WSPAddressToString()

INT WSPAPI WSPAddressToString ( IN LPSOCKADDR  lpsaAddress,
IN DWORD  dwAddressLength,
IN LPWSAPROTOCOL_INFOW  lpProtocolInfo,
OUT LPWSTR  lpszAddressString,
IN OUT LPDWORD  lpdwAddressStringLength,
OUT LPINT  lpErrno 
)

Definition at line 3050 of file dllmain.c.

3056 {
3057  SIZE_T size;
3058  WCHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
3059  WCHAR *p;
3060 
3061  if (!lpsaAddress || !lpszAddressString || !lpdwAddressStringLength)
3062  {
3063  if (lpErrno) *lpErrno = WSAEFAULT;
3064  return SOCKET_ERROR;
3065  }
3066 
3067  switch (lpsaAddress->sa_family)
3068  {
3069  case AF_INET:
3070  if (dwAddressLength < sizeof(SOCKADDR_IN))
3071  {
3072  if (lpErrno) *lpErrno = WSAEINVAL;
3073  return SOCKET_ERROR;
3074  }
3075  swprintf(buffer,
3076  L"%u.%u.%u.%u:%u",
3077  (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 24 & 0xff),
3078  (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 16 & 0xff),
3079  (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 8 & 0xff),
3080  (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) & 0xff),
3081  ntohs(((SOCKADDR_IN *)lpsaAddress)->sin_port));
3082 
3083  p = wcschr(buffer, L':');
3084  if (!((SOCKADDR_IN *)lpsaAddress)->sin_port)
3085  {
3086  *p = 0;
3087  }
3088  break;
3089  default:
3090  if (lpErrno) *lpErrno = WSAEINVAL;
3091  return SOCKET_ERROR;
3092  }
3093 
3094  size = wcslen(buffer) + 1;
3095 
3096  if (*lpdwAddressStringLength < size)
3097  {
3098  *lpdwAddressStringLength = size;
3099  if (lpErrno) *lpErrno = WSAEFAULT;
3100  return SOCKET_ERROR;
3101  }
3102 
3103  *lpdwAddressStringLength = size;
3104  wcscpy(lpszAddressString, buffer);
3105  return 0;
3106 }
#define SOCKET_ERROR
Definition: winsock.h:333
#define WSAEFAULT
Definition: winerror.h:1945
#define WSAEINVAL
Definition: winerror.h:1946
GLuint buffer
Definition: glext.h:5915
#define ntohs(x)
Definition: module.h:208
GLsizeiptr size
Definition: glext.h:5919
_CONST_RETURN wchar_t *__cdecl wcschr(_In_z_ const wchar_t *_Str, wchar_t _Ch)
__wchar_t WCHAR
Definition: xmlstorage.h:180
#define swprintf(buf, format,...)
Definition: sprintf.c:56
_CRTIMP wchar_t *__cdecl wcscpy(_Out_writes_z_(_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
static const WCHAR L[]
Definition: oid.c:1250
ULONG_PTR SIZE_T
Definition: typedefs.h:78
#define AF_INET
Definition: tcpip.h:117
GLfloat GLfloat p
Definition: glext.h:8902
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define ntohl(x)
Definition: module.h:203

Referenced by WSPStartup().

◆ WSPBind()

INT WSPAPI WSPBind ( SOCKET  Handle,
const struct sockaddr SocketAddress,
int  SocketAddressLength,
LPINT  lpErrno 
)

Definition at line 846 of file dllmain.c.

850 {
851  IO_STATUS_BLOCK IOSB;
852  PAFD_BIND_DATA BindData;
853  PSOCKET_INFORMATION Socket = NULL;
855  SOCKADDR_INFO SocketInfo;
857 
858  /* Get the Socket Structure associate to this Socket*/
859  Socket = GetSocketStructure(Handle);
860  if (!Socket)
861  {
862  if (lpErrno) *lpErrno = WSAENOTSOCK;
863  return SOCKET_ERROR;
864  }
865  if (Socket->SharedData->State != SocketOpen)
866  {
867  if (lpErrno) *lpErrno = WSAEINVAL;
868  return SOCKET_ERROR;
869  }
870  if (!SocketAddress || SocketAddressLength < Socket->SharedData->SizeOfLocalAddress)
871  {
872  if (lpErrno) *lpErrno = WSAEINVAL;
873  return SOCKET_ERROR;
874  }
875 
876  /* Get Address Information */
877  Socket->HelperData->WSHGetSockaddrType ((PSOCKADDR)SocketAddress,
878  SocketAddressLength,
879  &SocketInfo);
880 
881  if (SocketInfo.AddressInfo == SockaddrAddressInfoBroadcast && !Socket->SharedData->Broadcast)
882  {
883  if (lpErrno) *lpErrno = WSAEADDRNOTAVAIL;
884  return SOCKET_ERROR;
885  }
886 
889  NULL,
891  FALSE);
892 
893  if (!NT_SUCCESS(Status))
894  {
895  return SOCKET_ERROR;
896  }
897 
898  /* See below */
899  BindData = HeapAlloc(GlobalHeap, 0, 0xA + SocketAddressLength);
900  if (!BindData)
901  {
903  }
904 
905  /* Set up Address in TDI Format */
906  BindData->Address.TAAddressCount = 1;
907  BindData->Address.Address[0].AddressLength = (USHORT)(SocketAddressLength - sizeof(SocketAddress->sa_family));
908  BindData->Address.Address[0].AddressType = SocketAddress->sa_family;
909  RtlCopyMemory (BindData->Address.Address[0].Address,
910  SocketAddress->sa_data,
911  SocketAddressLength - sizeof(SocketAddress->sa_family));
912 
913  /* Set the Share Type */
914  if (Socket->SharedData->ExclusiveAddressUse)
915  {
916  BindData->ShareType = AFD_SHARE_EXCLUSIVE;
917  }
918  else if (SocketInfo.EndpointInfo == SockaddrEndpointInfoWildcard)
919  {
920  BindData->ShareType = AFD_SHARE_WILDCARD;
921  }
922  else if (Socket->SharedData->ReuseAddresses)
923  {
924  BindData->ShareType = AFD_SHARE_REUSE;
925  }
926  else
927  {
928  BindData->ShareType = AFD_SHARE_UNIQUE;
929  }
930 
931  /* Send IOCTL */
933  SockEvent,
934  NULL,
935  NULL,
936  &IOSB,
938  BindData,
939  0xA + Socket->SharedData->SizeOfLocalAddress, /* Can't figure out a way to calculate this in C*/
940  BindData,
941  0xA + Socket->SharedData->SizeOfLocalAddress); /* Can't figure out a way to calculate this C */
942 
943  /* Wait for return */
944  if (Status == STATUS_PENDING)
945  {
947  Status = IOSB.Status;
948  }
949 
950  NtClose( SockEvent );
951  HeapFree(GlobalHeap, 0, BindData);
952 
954  if (Status != STATUS_SUCCESS)
955  return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
956 
957  /* Set up Socket Data */
958  Socket->SharedData->State = SocketBound;
959  Socket->TdiAddressHandle = (HANDLE)IOSB.Information;
960 
961  if (Socket->HelperEvents & WSH_NOTIFY_BIND)
962  {
963  Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
964  Socket->Handle,
965  Socket->TdiAddressHandle,
966  Socket->TdiConnectionHandle,
968 
969  if (Status)
970  {
971  if (lpErrno) *lpErrno = Status;
972  return SOCKET_ERROR;
973  }
974  }
975 
976  return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
977 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define AFD_SHARE_UNIQUE
Definition: shared.h:191
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define IOCTL_AFD_BIND
Definition: shared.h:267
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
BOOLEAN ExclusiveAddressUse
Definition: msafd.h:73
UCHAR Address[1]
Definition: tdi.h:340
#define WSAEINVAL
Definition: winerror.h:1946
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
#define WSH_NOTIFY_BIND
Definition: wsahelp.h:10
BOOLEAN Broadcast
Definition: msafd.h:69
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
char sa_data[14]
Definition: winsock.h:218
BOOLEAN ReuseAddresses
Definition: msafd.h:72
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define AFD_SHARE_WILDCARD
Definition: shared.h:193
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
SOCKADDR_ENDPOINT_INFO EndpointInfo
Definition: wsahelp.h:45
smooth NULL
Definition: ftsmooth.c:416
PWSH_GET_SOCKADDR_TYPE WSHGetSockaddrType
Definition: helpers.h:28
PHELPER_DATA HelperData
Definition: msafd.h:103
_In_ HANDLE Handle
Definition: extypes.h:390
DWORD HelperEvents
Definition: msafd.h:102
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
if(!(yy_init))
Definition: macro.lex.yy.c:714
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
PWSH_NOTIFY WSHNotify
Definition: helpers.h:25
PVOID HANDLE
Definition: typedefs.h:71
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
LONG TAAddressCount
Definition: tdi.h:376
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
INT SizeOfLocalAddress
Definition: msafd.h:59
USHORT AddressType
Definition: tdi.h:339
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
TA_ADDRESS Address[1]
Definition: tdi.h:377
#define WSAEADDRNOTAVAIL
Definition: winerror.h:1962
u_short sa_family
Definition: winsock.h:217
unsigned short USHORT
Definition: pedump.c:61
INT TranslateNtStatusError(NTSTATUS Status)
Definition: dllmain.c:537
ULONG ShareType
Definition: shared.h:39
SOCKADDR_ADDRESS_INFO AddressInfo
Definition: wsahelp.h:44
USHORT AddressLength
Definition: tdi.h:338
INT SocketLastError
Definition: msafd.h:87
SOCKET_STATE State
Definition: msafd.h:54
#define AFD_SHARE_EXCLUSIVE
Definition: shared.h:194
PVOID HelperContext
Definition: msafd.h:104
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2966
#define HeapFree(x, y, z)
Definition: compat.h:394
TRANSPORT_ADDRESS Address
Definition: shared.h:40
#define AFD_SHARE_REUSE
Definition: shared.h:192

Referenced by WSPConnect(), WSPRecvFrom(), WSPSendTo(), and WSPStartup().

◆ WSPCleanup()

INT WSPAPI WSPCleanup ( OUT LPINT  lpErrno)

Definition at line 3234 of file dllmain.c.

3236 {
3237  TRACE("Leaving.\n");
3238 
3239  if (lpErrno) *lpErrno = NO_ERROR;
3240 
3241  return 0;
3242 }
#define NO_ERROR
Definition: dderror.h:5
#define TRACE(s)
Definition: solgame.cpp:4

Referenced by WSPStartup(), and WsTpWSPCleanup().

◆ WSPCloseSocket()

INT WSPAPI WSPCloseSocket ( IN SOCKET  Handle,
OUT LPINT  lpErrno 
)

Definition at line 623 of file dllmain.c.

625 {
627  PSOCKET_INFORMATION Socket = NULL, CurrentSocket;
630  AFD_DISCONNECT_INFO DisconnectInfo;
631  SOCKET_STATE OldState;
632  LONG LingerWait = -1;
633  DWORD References;
634 
635  /* Get the Socket Structure associate to this Socket*/
636  Socket = GetSocketStructure(Handle);
637  if (!Socket)
638  {
639  if (lpErrno) *lpErrno = WSAENOTSOCK;
640  return SOCKET_ERROR;
641  }
642 
643  /* Create the Wait Event */
646  NULL,
648  FALSE);
649 
650  if(!NT_SUCCESS(Status))
651  {
652  ERR("NtCreateEvent failed: 0x%08x", Status);
653  return SOCKET_ERROR;
654  }
655 
656  if (Socket->HelperEvents & WSH_NOTIFY_CLOSE)
657  {
658  Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
659  Socket->Handle,
660  Socket->TdiAddressHandle,
661  Socket->TdiConnectionHandle,
663 
664  if (Status)
665  {
666  if (lpErrno) *lpErrno = Status;
667  ERR("WSHNotify failed. Error 0x%#x", Status);
669  return SOCKET_ERROR;
670  }
671  }
672 
673  /* If a Close is already in Process, give up */
674  if (Socket->SharedData->State == SocketClosed)
675  {
676  WARN("Socket is closing.\n");
678  if (lpErrno) *lpErrno = WSAENOTSOCK;
679  return SOCKET_ERROR;
680  }
681 
682  /* Decrement reference count on SharedData */
683  References = InterlockedDecrement(&Socket->SharedData->RefCount);
684  if (References)
685  goto ok;
686 
687  /* Set the state to close */
688  OldState = Socket->SharedData->State;
689  Socket->SharedData->State = SocketClosed;
690 
691  /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
692  /* FIXME: Should we do this on Datagram Sockets too? */
693  if ((OldState == SocketConnected) && (Socket->SharedData->LingerData.l_onoff))
694  {
695  ULONG SendsInProgress;
696  ULONG SleepWait;
697 
698  /* We need to respect the timeout */
699  SleepWait = 100;
700  LingerWait = Socket->SharedData->LingerData.l_linger * 1000;
701 
702  /* Loop until no more sends are pending, within the timeout */
703  while (LingerWait)
704  {
705  /* Find out how many Sends are in Progress */
706  if (GetSocketInformation(Socket,
708  NULL,
709  &SendsInProgress,
710  NULL,
711  NULL,
712  NULL))
713  {
714  /* Bail out if anything but NO_ERROR */
715  LingerWait = 0;
716  break;
717  }
718 
719  /* Bail out if no more sends are pending */
720  if (!SendsInProgress)
721  {
722  LingerWait = -1;
723  break;
724  }
725 
726  /*
727  * We have to execute a sleep, so it's kind of like
728  * a block. If the socket is Nonblock, we cannot
729  * go on since asynchronous operation is expected
730  * and we cannot offer it
731  */
732  if (Socket->SharedData->NonBlocking)
733  {
734  WARN("Would block!\n");
736  Socket->SharedData->State = OldState;
737  if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
738  return SOCKET_ERROR;
739  }
740 
741  /* Now we can sleep, and decrement the linger wait */
742  /*
743  * FIXME: It seems Windows does some funky acceleration
744  * since the waiting seems to be longer and longer. I
745  * don't think this improves performance so much, so we
746  * wait a fixed time instead.
747  */
748  Sleep(SleepWait);
749  LingerWait -= SleepWait;
750  }
751  }
752 
753  if (OldState == SocketConnected)
754  {
755  if (LingerWait <= 0)
756  {
757  DisconnectInfo.Timeout = RtlConvertLongToLargeInteger(0);
758  DisconnectInfo.DisconnectType = LingerWait < 0 ? AFD_DISCONNECT_SEND : AFD_DISCONNECT_ABORT;
759 
760  if (((DisconnectInfo.DisconnectType & AFD_DISCONNECT_SEND) && (!Socket->SharedData->SendShutdown)) ||
761  ((DisconnectInfo.DisconnectType & AFD_DISCONNECT_ABORT) && (!Socket->SharedData->ReceiveShutdown)))
762  {
763  /* Send IOCTL */
765  SockEvent,
766  NULL,
767  NULL,
768  &IoStatusBlock,
770  &DisconnectInfo,
771  sizeof(DisconnectInfo),
772  NULL,
773  0);
774 
775  /* Wait for return */
776  if (Status == STATUS_PENDING)
777  {
780  }
781  }
782  }
783  }
784 
785  /* Cleanup Time! */
786  Socket->HelperContext = NULL;
787  Socket->SharedData->AsyncDisabledEvents = -1;
788  NtClose(Socket->TdiAddressHandle);
789  Socket->TdiAddressHandle = NULL;
790  NtClose(Socket->TdiConnectionHandle);
791  Socket->TdiConnectionHandle = NULL;
792 ok:
794  if (SocketListHead == Socket)
795  {
797  }
798  else
799  {
800  CurrentSocket = SocketListHead;
801  while (CurrentSocket->NextSocket)
802  {
803  if (CurrentSocket->NextSocket == Socket)
804  {
805  CurrentSocket->NextSocket = CurrentSocket->NextSocket->NextSocket;
806  break;
807  }
808 
809  CurrentSocket = CurrentSocket->NextSocket;
810  }
811  }
813 
814  /* Close the handle */
817 
818  if( Socket->SharedDataHandle != INVALID_HANDLE_VALUE )
819  {
820  /* It is a duplicated socket, so unmap the memory */
821  UnmapViewOfFile(Socket->SharedData);
822  NtClose(Socket->SharedDataHandle);
823  Socket->SharedData = NULL;
824  }
825  if( !References && Socket->SharedData )
826  {
827  HeapFree(GlobalHeap, 0, Socket->SharedData);
828  }
829  HeapFree(GlobalHeap, 0, Socket);
830  return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
831 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
#define WARN(fmt,...)
Definition: debug.h:111
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
#define WSAEWOULDBLOCK
Definition: winerror.h:1948
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
BOOLEAN SendShutdown
Definition: msafd.h:77
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
void WINAPI EnterCriticalSection(LPCRITICAL_SECTION)
int GetSocketInformation(PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
Definition: dllmain.c:3257
struct _SOCKET_INFORMATION * NextSocket
Definition: msafd.h:116
#define IOCTL_AFD_DISCONNECT
Definition: shared.h:287
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
long LONG
Definition: pedump.c:60
enum _SOCKET_STATE SOCKET_STATE
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
LARGE_INTEGER Timeout
Definition: shared.h:137
PHELPER_DATA HelperData
Definition: msafd.h:103
#define AFD_DISCONNECT_SEND
Definition: shared.h:197
BOOLEAN ReceiveShutdown
Definition: msafd.h:76
LONG RefCount
Definition: msafd.h:55
BOOLEAN NonBlocking
Definition: msafd.h:74
_In_ HANDLE Handle
Definition: extypes.h:390
DWORD HelperEvents
Definition: msafd.h:102
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
PWSH_NOTIFY WSHNotify
Definition: helpers.h:25
unsigned long DWORD
Definition: ntddk_ex.h:95
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define AFD_DISCONNECT_ABORT
Definition: shared.h:199
#define InterlockedDecrement
Definition: armddk.h:52
NTSYSAPI LONGLONG WINAPI RtlConvertLongToLargeInteger(LONG)
Definition: largeint.c:31
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
#define AFD_INFO_SENDS_IN_PROGRESS
Definition: shared.h:184
struct linger LingerData
Definition: msafd.h:61
LONG AsyncDisabledEvents
Definition: msafd.h:93
#define ok(value,...)
Definition: atltest.h:57
#define WSH_NOTIFY_CLOSE
Definition: wsahelp.h:17
static OUT PIO_STATUS_BLOCK IoStatusBlock
Definition: pipe.c:75
ULONG DisconnectType
Definition: shared.h:136
SOCKET_STATE State
Definition: msafd.h:54
CRITICAL_SECTION SocketListLock
Definition: dllmain.c:24
unsigned int ULONG
Definition: retypes.h:1
void WINAPI LeaveCriticalSection(LPCRITICAL_SECTION)
PVOID HelperContext
Definition: msafd.h:104
#define INFINITE
Definition: serial.h:102
#define UnmapViewOfFile
Definition: compat.h:403
PSOCKET_INFORMATION SocketListHead
Definition: dllmain.c:23
HANDLE SharedDataHandle
Definition: msafd.h:101
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by WSPAccept(), and WSPStartup().

◆ WSPConnect()

int WSPAPI WSPConnect ( SOCKET  Handle,
const struct sockaddr SocketAddress,
int  SocketAddressLength,
LPWSABUF  lpCallerData,
LPWSABUF  lpCalleeData,
LPQOS  lpSQOS,
LPQOS  lpGQOS,
LPINT  lpErrno 
)

Definition at line 1826 of file dllmain.c.

1834 {
1835  IO_STATUS_BLOCK IOSB;
1836  PAFD_CONNECT_INFO ConnectInfo = NULL;
1837  PSOCKET_INFORMATION Socket;
1838  NTSTATUS Status;
1839  INT Errno;
1840  ULONG ConnectDataLength;
1841  ULONG InConnectDataLength;
1842  INT BindAddressLength;
1843  PSOCKADDR BindAddress;
1844  HANDLE SockEvent;
1845  int SocketDataLength;
1846 
1847  TRACE("Called (%lx) %lx:%d\n", Handle, ((const struct sockaddr_in *)SocketAddress)->sin_addr, ((const struct sockaddr_in *)SocketAddress)->sin_port);
1848 
1849  /* Get the Socket Structure associate to this Socket*/
1850  Socket = GetSocketStructure(Handle);
1851  if (!Socket)
1852  {
1853  if (lpErrno) *lpErrno = WSAENOTSOCK;
1854  return SOCKET_ERROR;
1855  }
1856 
1859  NULL,
1861  FALSE);
1862 
1863  if (!NT_SUCCESS(Status))
1864  return SOCKET_ERROR;
1865 
1866  /* Bind us First */
1867  if (Socket->SharedData->State == SocketOpen)
1868  {
1869  /* Get the Wildcard Address */
1870  BindAddressLength = Socket->HelperData->MaxWSAddressLength;
1871  BindAddress = HeapAlloc(GetProcessHeap(), 0, BindAddressLength);
1872  if (!BindAddress)
1873  {
1874  NtClose(SockEvent);
1876  }
1878  BindAddress,
1879  &BindAddressLength);
1880  /* Bind it */
1881  if (WSPBind(Handle, BindAddress, BindAddressLength, lpErrno) == SOCKET_ERROR)
1882  return SOCKET_ERROR;
1883  }
1884 
1885  /* Set the Connect Data */
1886  if (lpCallerData != NULL)
1887  {
1888  ConnectDataLength = lpCallerData->len;
1890  SockEvent,
1891  NULL,
1892  NULL,
1893  &IOSB,
1895  lpCallerData->buf,
1896  ConnectDataLength,
1897  NULL,
1898  0);
1899  /* Wait for return */
1900  if (Status == STATUS_PENDING)
1901  {
1903  Status = IOSB.Status;
1904  }
1905 
1906  if (Status != STATUS_SUCCESS)
1907  goto notify;
1908  }
1909 
1910  /* Calculate the size of SocketAddress->sa_data */
1911  SocketDataLength = SocketAddressLength - FIELD_OFFSET(struct sockaddr, sa_data);
1912 
1913  /* Allocate a connection info buffer with SocketDataLength bytes of payload */
1914  ConnectInfo = HeapAlloc(GetProcessHeap(), 0,
1916  RemoteAddress.Address[0].Address[SocketDataLength]));
1917  if (!ConnectInfo)
1918  {
1920  goto notify;
1921  }
1922 
1923  /* Set up Address in TDI Format */
1924  ConnectInfo->RemoteAddress.TAAddressCount = 1;
1925  ConnectInfo->RemoteAddress.Address[0].AddressLength = SocketDataLength;
1926  ConnectInfo->RemoteAddress.Address[0].AddressType = SocketAddress->sa_family;
1927  RtlCopyMemory(ConnectInfo->RemoteAddress.Address[0].Address,
1928  SocketAddress->sa_data,
1929  SocketDataLength);
1930 
1931  /*
1932  * Disable FD_WRITE and FD_CONNECT
1933  * The latter fixes a race condition where the FD_CONNECT is re-enabled
1934  * at the end of this function right after the Async Thread disables it.
1935  * This should only happen at the *next* WSPConnect
1936  */
1937  if (Socket->SharedData->AsyncEvents & FD_CONNECT)
1938  {
1940  }
1941 
1942  /* Tell AFD that we want Connection Data back, have it allocate a buffer */
1943  if (lpCalleeData != NULL)
1944  {
1945  InConnectDataLength = lpCalleeData->len;
1947  SockEvent,
1948  NULL,
1949  NULL,
1950  &IOSB,
1952  &InConnectDataLength,
1953  sizeof(InConnectDataLength),
1954  NULL,
1955  0);
1956 
1957  /* Wait for return */
1958  if (Status == STATUS_PENDING)
1959  {
1961  Status = IOSB.Status;
1962  }
1963 
1964  if (Status != STATUS_SUCCESS)
1965  goto notify;
1966  }
1967 
1968  /* AFD doesn't seem to care if these are invalid, but let's 0 them anyways */
1969  ConnectInfo->Root = 0;
1970  ConnectInfo->UseSAN = FALSE;
1971  ConnectInfo->Unknown = 0;
1972 
1973  /* FIXME: Handle Async Connect */
1974  if (Socket->SharedData->NonBlocking)
1975  {
1976  ERR("Async Connect UNIMPLEMENTED!\n");
1977  }
1978 
1979  /* Send IOCTL */
1981  SockEvent,
1982  NULL,
1983  NULL,
1984  &IOSB,
1986  ConnectInfo,
1987  0x22,
1988  NULL,
1989  0);
1990  /* Wait for return */
1991  if (Status == STATUS_PENDING)
1992  {
1994  Status = IOSB.Status;
1995  }
1996 
1998  if (Status != STATUS_SUCCESS)
1999  goto notify;
2000 
2001  Socket->SharedData->State = SocketConnected;
2002  Socket->TdiConnectionHandle = (HANDLE)IOSB.Information;
2004 
2005  /* Get any pending connect data */
2006  if (lpCalleeData != NULL)
2007  {
2009  SockEvent,
2010  NULL,
2011  NULL,
2012  &IOSB,
2014  NULL,
2015  0,
2016  lpCalleeData->buf,
2017  lpCalleeData->len);
2018  /* Wait for return */
2019  if (Status == STATUS_PENDING)
2020  {
2022  Status = IOSB.Status;
2023  }
2024  }
2025 
2026  TRACE("Ending %lx\n", IOSB.Status);
2027 
2028 notify:
2029  if (ConnectInfo) HeapFree(GetProcessHeap(), 0, ConnectInfo);
2030 
2031  /* Re-enable Async Event */
2033 
2034  /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
2036 
2037  NtClose(SockEvent);
2038 
2039  if (Status == STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT))
2040  {
2041  Errno = Socket->HelperData->WSHNotify(Socket->HelperContext,
2042  Socket->Handle,
2043  Socket->TdiAddressHandle,
2044  Socket->TdiConnectionHandle,
2046 
2047  if (Errno)
2048  {
2049  if (lpErrno) *lpErrno = Errno;
2050  return SOCKET_ERROR;
2051  }
2052  }
2053  else if (Status != STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_CONNECT_ERROR))
2054  {
2055  Errno = Socket->HelperData->WSHNotify(Socket->HelperContext,
2056  Socket->Handle,
2057  Socket->TdiAddressHandle,
2058  Socket->TdiConnectionHandle,
2060 
2061  if (Errno)
2062  {
2063  if (lpErrno) *lpErrno = Errno;
2064  return SOCKET_ERROR;
2065  }
2066  }
2067 
2068  return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
2069 }
PWSH_GET_WILDCARD_SOCKADDR WSHGetWildcardSockaddr
Definition: helpers.h:29
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
UCHAR Address[1]
Definition: tdi.h:340
VOID SockReenableAsyncSelectEvent(IN PSOCKET_INFORMATION Socket, IN ULONG Event)
Definition: dllmain.c:3983
#define FD_CONNECT
Definition: winsock.h:409
ULONG ConnectTime
Definition: msafd.h:66
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
int notify
Definition: msacm.c:1353
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
DWORD GetCurrentTimeInSeconds(VOID)
Definition: dllmain.c:1417
int32_t INT
Definition: typedefs.h:56
#define FD_WRITE
Definition: winsock.h:406
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
#define IOCTL_AFD_SET_CONNECT_DATA_SIZE
Definition: shared.h:319
INT MaxWSAddressLength
Definition: helpers.h:17
TRANSPORT_ADDRESS RemoteAddress
Definition: shared.h:121
#define WSH_NOTIFY_CONNECT_ERROR
Definition: wsahelp.h:18
smooth NULL
Definition: ftsmooth.c:416
#define IOCTL_AFD_SET_CONNECT_DATA
Definition: shared.h:303
PHELPER_DATA HelperData
Definition: msafd.h:103
#define IOCTL_AFD_CONNECT
Definition: shared.h:269
BOOLEAN NonBlocking
Definition: msafd.h:74
_In_ HANDLE Handle
Definition: extypes.h:390
#define TRACE(s)
Definition: solgame.cpp:4
DWORD HelperEvents
Definition: msafd.h:102
#define GetProcessHeap()
Definition: compat.h:395
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
ULONG len
Definition: ws2def.h:519
PWSH_NOTIFY WSHNotify
Definition: helpers.h:25
PVOID HANDLE
Definition: typedefs.h:71
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
LONG TAAddressCount
Definition: tdi.h:376
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
USHORT AddressType
Definition: tdi.h:339
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
INT WSPAPI WSPBind(SOCKET Handle, const struct sockaddr *SocketAddress, int SocketAddressLength, LPINT lpErrno)
Definition: dllmain.c:846
CHAR FAR * buf
Definition: ws2def.h:520
Status
Definition: gdiplustypes.h:24
TA_ADDRESS Address[1]
Definition: tdi.h:377
#define ERR(fmt,...)
Definition: debug.h:109
LONG AsyncDisabledEvents
Definition: msafd.h:93
INT TranslateNtStatusError(NTSTATUS Status)
Definition: dllmain.c:537
#define FIELD_OFFSET(t, f)
Definition: typedefs.h:254
#define IOCTL_AFD_GET_CONNECT_DATA
Definition: shared.h:311
USHORT AddressLength
Definition: tdi.h:338
INT SocketLastError
Definition: msafd.h:87
SOCKET_STATE State
Definition: msafd.h:54
unsigned int ULONG
Definition: retypes.h:1
BOOLEAN UseSAN
Definition: shared.h:118
PVOID HelperContext
Definition: msafd.h:104
#define WSH_NOTIFY_CONNECT
Definition: wsahelp.h:12
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2966
LONG AsyncEvents
Definition: msafd.h:92
#define HeapFree(x, y, z)
Definition: compat.h:394
_Must_inspect_result_ _In_ ULONG _In_ PSOCKADDR _In_ PSOCKADDR RemoteAddress
Definition: wsk.h:170

Referenced by WSPStartup().

◆ WSPDuplicateSocket()

INT WSPAPI WSPDuplicateSocket ( IN SOCKET  Handle,
IN DWORD  dwProcessId,
OUT LPWSAPROTOCOL_INFOW  lpProtocolInfo,
OUT LPINT  lpErrno 
)

Definition at line 449 of file dllmain.c.

454 {
455  HANDLE hProcess, hDuplicatedSharedData, hDuplicatedHandle;
456  PSOCKET_INFORMATION Socket;
457  PSOCK_SHARED_INFO pSharedData, pOldSharedData;
458  BOOL bDuplicated;
459 
460  if (Handle == INVALID_SOCKET)
462  Socket = GetSocketStructure(Handle);
463  if( !Socket )
464  {
465  if( lpErrno )
466  *lpErrno = WSAENOTSOCK;
467  return SOCKET_ERROR;
468  }
469  if ( !(hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId)) )
471 
472  /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
473  if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
474  {
476  NULL,
478  0,
479  (sizeof(SOCK_SHARED_INFO) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1),
480  NULL);
481  if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
483  pSharedData = MapViewOfFile(Socket->SharedDataHandle,
485  0,
486  0,
487  sizeof(SOCK_SHARED_INFO));
488 
489  RtlCopyMemory(pSharedData, Socket->SharedData, sizeof(SOCK_SHARED_INFO));
490  pOldSharedData = Socket->SharedData;
491  Socket->SharedData = pSharedData;
492  HeapFree(GlobalHeap, 0, pOldSharedData);
493  }
494  /* Duplicate the handles for the new process */
495  bDuplicated = DuplicateHandle(GetCurrentProcess(),
496  Socket->SharedDataHandle,
497  hProcess,
498  (LPHANDLE)&hDuplicatedSharedData,
499  0,
500  FALSE,
502  if (!bDuplicated)
503  {
504  NtClose(hProcess);
505  return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
506  }
507  bDuplicated = DuplicateHandle(GetCurrentProcess(),
508  (HANDLE)Socket->Handle,
509  hProcess,
510  (LPHANDLE)&hDuplicatedHandle,
511  0,
512  FALSE,
514  NtClose(hProcess);
515  if( !bDuplicated )
516  return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
517 
518 
519  if (!lpProtocolInfo)
521 
522  RtlCopyMemory(lpProtocolInfo, &Socket->ProtocolInfo, sizeof(*lpProtocolInfo));
523 
524  lpProtocolInfo->iAddressFamily = Socket->SharedData->AddressFamily;
525  lpProtocolInfo->iProtocol = Socket->SharedData->Protocol;
526  lpProtocolInfo->iSocketType = Socket->SharedData->SocketType;
527  lpProtocolInfo->dwServiceFlags3 = HandleToUlong(hDuplicatedSharedData);
528  lpProtocolInfo->dwServiceFlags4 = HandleToUlong(hDuplicatedHandle);
529 
530  if( lpErrno )
531  *lpErrno = NO_ERROR;
532 
533  return NO_ERROR;
534 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
INT AddressFamily
Definition: msafd.h:56
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define MapViewOfFile
Definition: compat.h:402
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKET Handle
Definition: msafd.h:99
#define HandleToUlong(h)
Definition: basetsd.h:79
#define CreateFileMapping
Definition: winbase.h:3567
#define INVALID_HANDLE_VALUE
Definition: compat.h:391
_In_ BOOL _In_ HANDLE hProcess
Definition: mapping.h:70
#define NO_ERROR
Definition: dderror.h:5
WSAPROTOCOL_INFOW ProtocolInfo
Definition: msafd.h:115
#define DUPLICATE_SAME_ACCESS
#define SEC_COMMIT
Definition: mmtypes.h:99
unsigned int BOOL
Definition: ntddk_ex.h:94
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
#define PROCESS_DUP_HANDLE
smooth NULL
Definition: ftsmooth.c:416
#define FILE_MAP_ALL_ACCESS
Definition: winbase.h:156
_In_ HANDLE Handle
Definition: extypes.h:390
INT SocketType
Definition: msafd.h:57
#define INVALID_SOCKET
Definition: winsock.h:332
HANDLE WINAPI GetCurrentProcess(VOID)
Definition: proc.c:1138
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
#define PAGE_SIZE
Definition: env_spec_w32.h:49
HANDLE GlobalHeap
Definition: dllmain.c:19
HANDLE WINAPI OpenProcess(IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwProcessId)
Definition: proc.c:1227
#define STATUS_ACCESS_VIOLATION
Definition: ntstatus.h:228
HANDLE SharedDataHandle
Definition: msafd.h:101
#define HeapFree(x, y, z)
Definition: compat.h:394
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
#define PAGE_READWRITE
Definition: nt_native.h:1304

Referenced by WSPStartup().

◆ WSPGetPeerName()

INT WSPAPI WSPGetPeerName ( IN SOCKET  s,
OUT LPSOCKADDR  Name,
IN OUT LPINT  NameLength,
OUT LPINT  lpErrno 
)

Definition at line 2254 of file dllmain.c.

2258 {
2259  IO_STATUS_BLOCK IOSB;
2260  ULONG TdiAddressSize;
2261  PTRANSPORT_ADDRESS SocketAddress;
2262  PSOCKET_INFORMATION Socket = NULL;
2263  NTSTATUS Status;
2264  HANDLE SockEvent;
2265 
2266  /* Get the Socket Structure associate to this Socket*/
2267  Socket = GetSocketStructure(s);
2268  if (!Socket)
2269  {
2270  if (lpErrno) *lpErrno = WSAENOTSOCK;
2271  return SOCKET_ERROR;
2272  }
2273 
2274  if (Socket->SharedData->State != SocketConnected)
2275  {
2276  if (lpErrno) *lpErrno = WSAENOTCONN;
2277  return SOCKET_ERROR;
2278  }
2279 
2280  if (!Name || !NameLength)
2281  {
2282  if (lpErrno) *lpErrno = WSAEFAULT;
2283  return SOCKET_ERROR;
2284  }
2285 
2288  NULL,
2290  FALSE);
2291 
2292  if( !NT_SUCCESS(Status) )
2293  return SOCKET_ERROR;
2294 
2295  /* Allocate a buffer for the address */
2296  TdiAddressSize = sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfRemoteAddress;
2297  SocketAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
2298 
2299  if ( SocketAddress == NULL )
2300  {
2301  NtClose( SockEvent );
2302  if (lpErrno) *lpErrno = WSAENOBUFS;
2303  return SOCKET_ERROR;
2304  }
2305 
2306  /* Send IOCTL */
2308  SockEvent,
2309  NULL,
2310  NULL,
2311  &IOSB,
2313  NULL,
2314  0,
2315  SocketAddress,
2316  TdiAddressSize);
2317 
2318  /* Wait for return */
2319  if (Status == STATUS_PENDING)
2320  {
2322  Status = IOSB.Status;
2323  }
2324 
2325  NtClose( SockEvent );
2326 
2327  if (NT_SUCCESS(Status))
2328  {
2329  if (*NameLength >= Socket->SharedData->SizeOfRemoteAddress)
2330  {
2331  Name->sa_family = SocketAddress->Address[0].AddressType;
2332  RtlCopyMemory (Name->sa_data,
2333  SocketAddress->Address[0].Address,
2334  SocketAddress->Address[0].AddressLength);
2335  *NameLength = Socket->SharedData->SizeOfRemoteAddress;
2336  TRACE("NameLength %d Address: %x Port %x\n",
2337  *NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
2338  ((struct sockaddr_in *)Name)->sin_port);
2339  HeapFree(GlobalHeap, 0, SocketAddress);
2340  return 0;
2341  }
2342  else
2343  {
2344  HeapFree(GlobalHeap, 0, SocketAddress);
2345  if (lpErrno) *lpErrno = WSAEFAULT;
2346  return SOCKET_ERROR;
2347  }
2348  }
2349 
2350  HeapFree(GlobalHeap, 0, SocketAddress);
2351 
2352  return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
2353 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define WSAEFAULT
Definition: winerror.h:1945
UCHAR Address[1]
Definition: tdi.h:340
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct _TRANSPORT_ADDRESS TRANSPORT_ADDRESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IOCTL_AFD_GET_PEER_NAME
Definition: shared.h:291
INT SizeOfRemoteAddress
Definition: msafd.h:60
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
GLdouble s
Definition: gl.h:2039
USHORT AddressType
Definition: tdi.h:339
#define WSAENOTCONN
Definition: winerror.h:1970
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
TA_ADDRESS Address[1]
Definition: tdi.h:377
USHORT AddressLength
Definition: tdi.h:338
SOCKET_STATE State
Definition: msafd.h:54
unsigned int ULONG
Definition: retypes.h:1
#define INFINITE
Definition: serial.h:102
#define WSAENOBUFS
Definition: winerror.h:1968
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by WSPStartup().

◆ WSPGetSockName()

INT WSPAPI WSPGetSockName ( IN SOCKET  Handle,
OUT LPSOCKADDR  Name,
IN OUT LPINT  NameLength,
OUT LPINT  lpErrno 
)

Definition at line 2152 of file dllmain.c.

2156 {
2157  IO_STATUS_BLOCK IOSB;
2158  ULONG TdiAddressSize;
2159  PTDI_ADDRESS_INFO TdiAddress;
2160  PTRANSPORT_ADDRESS SocketAddress;
2161  PSOCKET_INFORMATION Socket = NULL;
2162  NTSTATUS Status;
2163  HANDLE SockEvent;
2164 
2165  /* Get the Socket Structure associate to this Socket*/
2166  Socket = GetSocketStructure(Handle);
2167  if (!Socket)
2168  {
2169  if (lpErrno) *lpErrno = WSAENOTSOCK;
2170  return SOCKET_ERROR;
2171  }
2172 
2173  if (!Name || !NameLength)
2174  {
2175  if (lpErrno) *lpErrno = WSAEFAULT;
2176  return SOCKET_ERROR;
2177  }
2178 
2181  NULL,
2183  FALSE);
2184 
2185  if( !NT_SUCCESS(Status) )
2186  return SOCKET_ERROR;
2187 
2188  /* Allocate a buffer for the address */
2189  TdiAddressSize =
2190  sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfLocalAddress;
2191  TdiAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
2192 
2193  if ( TdiAddress == NULL )
2194  {
2195  NtClose( SockEvent );
2196  if (lpErrno) *lpErrno = WSAENOBUFS;
2197  return SOCKET_ERROR;
2198  }
2199 
2200  SocketAddress = &TdiAddress->Address;
2201 
2202  /* Send IOCTL */
2204  SockEvent,
2205  NULL,
2206  NULL,
2207  &IOSB,
2209  NULL,
2210  0,
2211  TdiAddress,
2212  TdiAddressSize);
2213 
2214  /* Wait for return */
2215  if (Status == STATUS_PENDING)
2216  {
2218  Status = IOSB.Status;
2219  }
2220 
2221  NtClose( SockEvent );
2222 
2223  if (NT_SUCCESS(Status))
2224  {
2225  if (*NameLength >= Socket->SharedData->SizeOfLocalAddress)
2226  {
2227  Name->sa_family = SocketAddress->Address[0].AddressType;
2228  RtlCopyMemory (Name->sa_data,
2229  SocketAddress->Address[0].Address,
2230  SocketAddress->Address[0].AddressLength);
2231  *NameLength = Socket->SharedData->SizeOfLocalAddress;
2232  TRACE("NameLength %d Address: %x Port %x\n",
2233  *NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
2234  ((struct sockaddr_in *)Name)->sin_port);
2235  HeapFree(GlobalHeap, 0, TdiAddress);
2236  return 0;
2237  }
2238  else
2239  {
2240  HeapFree(GlobalHeap, 0, TdiAddress);
2241  if (lpErrno) *lpErrno = WSAEFAULT;
2242  return SOCKET_ERROR;
2243  }
2244  }
2245 
2246  HeapFree(GlobalHeap, 0, TdiAddress);
2247 
2248  return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
2249 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define WSAEFAULT
Definition: winerror.h:1945
UCHAR Address[1]
Definition: tdi.h:340
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKET Handle
Definition: msafd.h:99
LONG NTSTATUS
Definition: precomp.h:26
NTSTATUS NTAPI NtCreateEvent(OUT PHANDLE EventHandle, IN ACCESS_MASK DesiredAccess, IN POBJECT_ATTRIBUTES ObjectAttributes OPTIONAL, IN EVENT_TYPE EventType, IN BOOLEAN InitialState)
Definition: event.c:100
NTSYSAPI NTSTATUS NTAPI NtDeviceIoControlFile(IN HANDLE hFile, IN HANDLE hEvent OPTIONAL, IN PIO_APC_ROUTINE IoApcRoutine OPTIONAL, IN PVOID IoApcContext OPTIONAL, OUT PIO_STATUS_BLOCK pIoStatusBlock, IN ULONG DeviceIoControlCode, IN PVOID InBuffer OPTIONAL, IN ULONG InBufferLength, OUT PVOID OutBuffer OPTIONAL, IN ULONG OutBufferLength)
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
smooth NULL
Definition: ftsmooth.c:416
_In_ HANDLE Handle
Definition: extypes.h:390
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
struct _TRANSPORT_ADDRESS TRANSPORT_ADDRESS
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IOCTL_AFD_GET_SOCK_NAME
Definition: shared.h:289
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
NTSTATUS NTAPI NtClose(IN HANDLE Handle)
Definition: obhandle.c:3399
TRANSPORT_ADDRESS Address
Definition: tdi.h:388
INT SizeOfLocalAddress
Definition: msafd.h:59
USHORT AddressType
Definition: tdi.h:339
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
TA_ADDRESS Address[1]
Definition: tdi.h:377
USHORT AddressLength
Definition: tdi.h:338
unsigned int ULONG
Definition: retypes.h:1
#define INFINITE
Definition: serial.h:102
#define WSAENOBUFS
Definition: winerror.h:1968
#define HeapFree(x, y, z)
Definition: compat.h:394

Referenced by WSPStartup().

◆ WSPGetSockOpt()

INT WSPAPI WSPGetSockOpt ( IN SOCKET  Handle,
IN INT  Level,
IN INT  OptionName,
OUT CHAR FAR OptionValue,
IN OUT LPINT  OptionLength,
OUT LPINT  lpErrno 
)

Definition at line 2600 of file dllmain.c.

2606 {
2607  PSOCKET_INFORMATION Socket = NULL;
2608  PVOID Buffer;
2609  INT BufferSize;
2610  BOOL BoolBuffer;
2611  DWORD DwordBuffer;
2612  INT Errno;
2613 
2614  TRACE("Called\n");
2615 
2616  /* Get the Socket Structure associate to this Socket*/
2617  Socket = GetSocketStructure(Handle);
2618  if (Socket == NULL)
2619  {
2620  if (lpErrno) *lpErrno = WSAENOTSOCK;
2621  return SOCKET_ERROR;
2622  }
2623  if (!OptionLength || !OptionValue)
2624  {
2625  if (lpErrno) *lpErrno = WSAEFAULT;
2626  return SOCKET_ERROR;
2627  }
2628 
2629  switch (Level)
2630  {
2631  case SOL_SOCKET:
2632  switch (OptionName)
2633  {
2634  case SO_TYPE:
2635  Buffer = &Socket->SharedData->SocketType;
2636  BufferSize = sizeof(INT);
2637  break;
2638 
2639  case SO_RCVBUF:
2640  Buffer = &Socket->SharedData->SizeOfRecvBuffer;
2641  BufferSize = sizeof(ULONG);
2642  break;
2643 
2644  case SO_SNDBUF:
2645  Buffer = &Socket->SharedData->SizeOfSendBuffer;
2646  BufferSize = sizeof(ULONG);
2647  break;
2648 
2649  case SO_ACCEPTCONN:
2650  BoolBuffer = Socket->SharedData->Listening;
2651  Buffer = &BoolBuffer;
2652  BufferSize = sizeof(BOOL);
2653  break;
2654 
2655  case SO_BROADCAST:
2656  BoolBuffer = Socket->SharedData->Broadcast;
2657  Buffer = &BoolBuffer;
2658  BufferSize = sizeof(BOOL);
2659  break;
2660 
2661  case SO_DEBUG:
2662  BoolBuffer = Socket->SharedData->Debug;
2663  Buffer = &BoolBuffer;
2664  BufferSize = sizeof(BOOL);
2665  break;
2666 
2667  case SO_DONTLINGER:
2668  BoolBuffer = (Socket->SharedData->LingerData.l_onoff == 0);
2669  Buffer = &BoolBuffer;
2670  BufferSize = sizeof(BOOL);
2671  break;
2672 
2673  case SO_LINGER:
2674  if (Socket->SharedData->SocketType == SOCK_DGRAM)
2675  {
2676  if (lpErrno) *lpErrno = WSAENOPROTOOPT;
2677  return SOCKET_ERROR;
2678  }
2679  Buffer = &Socket->SharedData->LingerData;
2680  BufferSize = sizeof(struct linger);
2681  break;
2682 
2683  case SO_OOBINLINE:
2684  BoolBuffer = (Socket->SharedData->OobInline != 0);
2685  Buffer = &BoolBuffer;
2686  BufferSize = sizeof(BOOL);
2687  break;
2688 
2689  case SO_KEEPALIVE:
2690  case SO_DONTROUTE:
2691  /* These guys go directly to the helper */
2692  goto SendToHelper;
2693 
2694  case SO_CONDITIONAL_ACCEPT:
2695  BoolBuffer = (Socket->SharedData->UseDelayedAcceptance != 0);
2696  Buffer = &BoolBuffer;
2697  BufferSize = sizeof(BOOL);
2698  break;
2699 
2700  case SO_REUSEADDR:
2701  BoolBuffer = (Socket->SharedData->ReuseAddresses != 0);
2702  Buffer = &BoolBuffer;
2703  BufferSize = sizeof(BOOL);
2704  break;
2705 
2706  case SO_EXCLUSIVEADDRUSE:
2707  BoolBuffer = (Socket->SharedData->ExclusiveAddressUse != 0);
2708  Buffer = &BoolBuffer;
2709  BufferSize = sizeof(BOOL);
2710  break;
2711 
2712  case SO_ERROR:
2713  Buffer = &Socket->SharedData->SocketLastError;
2714  BufferSize = sizeof(INT);
2715  break;
2716 
2717  case SO_CONNECT_TIME:
2718  DwordBuffer = GetCurrentTimeInSeconds() - Socket->SharedData->ConnectTime;
2719  Buffer = &DwordBuffer;
2720  BufferSize = sizeof(DWORD);
2721  break;
2722 
2723  case SO_SNDTIMEO:
2724  Buffer = &Socket->SharedData->SendTimeout;
2725  BufferSize = sizeof(DWORD);
2726  break;
2727  case SO_RCVTIMEO:
2728  Buffer = &Socket->SharedData->RecvTimeout;
2729  BufferSize = sizeof(DWORD);
2730  break;
2731  case SO_PROTOCOL_INFOW:
2732  Buffer = &Socket->ProtocolInfo;
2733  BufferSize = sizeof(Socket->ProtocolInfo);
2734  break;
2735 
2736  case SO_GROUP_ID:
2737  case SO_GROUP_PRIORITY:
2738  case SO_MAX_MSG_SIZE:
2739 
2740  default:
2741  DbgPrint("MSAFD: Get unknown optname %x\n", OptionName);
2742  if (lpErrno) *lpErrno = WSAENOPROTOOPT;
2743  return SOCKET_ERROR;
2744  }
2745 
2746  if (*OptionLength < BufferSize)
2747  {
2748  if (lpErrno) *lpErrno = WSAEFAULT;
2749  *OptionLength = BufferSize;
2750  return SOCKET_ERROR;
2751  }
2752  RtlCopyMemory(OptionValue, Buffer, BufferSize);
2753 
2754  return 0;
2755 
2756  default:
2757  if (lpErrno) *lpErrno = WSAEINVAL;
2758  return SOCKET_ERROR;
2759  }
2760 
2761 SendToHelper:
2762  Errno = Socket->HelperData->WSHGetSocketInformation(Socket->HelperContext,
2763  Handle,
2764  Socket->TdiAddressHandle,
2765  Socket->TdiConnectionHandle,
2766  Level,
2767  OptionName,
2768  OptionValue,
2769  (LPINT)OptionLength);
2770  if (lpErrno) *lpErrno = Errno;
2771  return (Errno == NO_ERROR) ? NO_ERROR : SOCKET_ERROR;
2772 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
BOOLEAN Listening
Definition: msafd.h:68
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define WSAEFAULT
Definition: winerror.h:1945
BOOLEAN ExclusiveAddressUse
Definition: msafd.h:73
#define DbgPrint
Definition: loader.c:25
#define WSAEINVAL
Definition: winerror.h:1946
ULONG ConnectTime
Definition: msafd.h:66
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
#define SO_OOBINLINE
Definition: winsock.h:186
#define INT
Definition: polytest.cpp:20
BOOLEAN Broadcast
Definition: msafd.h:69
#define SO_PROTOCOL_INFOW
Definition: winsock2.h:249
#define SO_KEEPALIVE
Definition: winsock.h:181
BOOLEAN OobInline
Definition: msafd.h:71
BOOLEAN UseDelayedAcceptance
Definition: msafd.h:78
_IRQL_requires_same_ typedef _In_ ULONG _In_ UCHAR Level
Definition: wmitypes.h:55
#define SO_CONDITIONAL_ACCEPT
Definition: ws2def.h:121
#define SOL_SOCKET
Definition: winsock.h:398
#define SO_LINGER
Definition: winsock.h:185
#define NO_ERROR
Definition: dderror.h:5
#define BOOL
Definition: nt_native.h:43
DWORD GetCurrentTimeInSeconds(VOID)
Definition: dllmain.c:1417
#define WSAENOPROTOOPT
Definition: winerror.h:1955
#define DWORD
Definition: nt_native.h:44
int32_t INT
Definition: typedefs.h:56
#define SO_CONNECT_TIME
Definition: mswsock.h:36
WSAPROTOCOL_INFOW ProtocolInfo
Definition: msafd.h:115
BOOLEAN ReuseAddresses
Definition: msafd.h:72
#define SO_EXCLUSIVEADDRUSE
Definition: ws2def.h:105
unsigned int BOOL
Definition: ntddk_ex.h:94
#define SO_GROUP_ID
Definition: ws2def.h:117
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
#define SO_BROADCAST
Definition: winsock.h:183
ULONG SizeOfSendBuffer
Definition: msafd.h:65
smooth NULL
Definition: ftsmooth.c:416
#define SO_REUSEADDR
Definition: winsock.h:180
#define SO_ERROR
Definition: winsock.h:194
PHELPER_DATA HelperData
Definition: msafd.h:103
Definition: bufpool.h:45
#define SO_MAX_MSG_SIZE
Definition: ws2def.h:119
BOOLEAN Debug
Definition: msafd.h:70
_In_ HANDLE Handle
Definition: extypes.h:390
#define SO_RCVTIMEO
Definition: winsock.h:193
#define TRACE(s)
Definition: solgame.cpp:4
INT SocketType
Definition: msafd.h:57
#define SO_RCVBUF
Definition: winsock.h:189
#define BufferSize
Definition: classpnp.h:419
#define SO_DONTLINGER
Definition: winsock.h:187
unsigned long DWORD
Definition: ntddk_ex.h:95
PWSH_GET_SOCKET_INFORMATION WSHGetSocketInformation
Definition: helpers.h:26
#define SO_TYPE
Definition: winsock.h:195
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
struct linger LingerData
Definition: msafd.h:61
ULONG SizeOfRecvBuffer
Definition: msafd.h:64
#define SO_GROUP_PRIORITY
Definition: ws2def.h:118
ULONG RecvTimeout
Definition: msafd.h:63
INT SocketLastError
Definition: msafd.h:87
#define SO_SNDTIMEO
Definition: winsock.h:192
#define SO_ACCEPTCONN
Definition: winsock.h:179
unsigned int ULONG
Definition: retypes.h:1
ULONG SendTimeout
Definition: msafd.h:62
PVOID HelperContext
Definition: msafd.h:104
IN BOOLEAN OUT PSTR Buffer
Definition: progress.h:34
#define SOCK_DGRAM
Definition: winsock.h:336
#define SO_SNDBUF
Definition: winsock.h:188
#define SO_DEBUG
Definition: winsock.h:178
#define SO_DONTROUTE
Definition: winsock.h:182
int * LPINT
Definition: windef.h:178

Referenced by WSPStartup().

◆ WSPIoctl()

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 
)

Definition at line 2357 of file dllmain.c.

2368 {
2369  PSOCKET_INFORMATION Socket = NULL;
2370  BOOL NeedsCompletion = lpOverlapped != NULL;
2371  BOOLEAN NonBlocking;
2372  INT Errno = NO_ERROR, Ret = SOCKET_ERROR;
2373  DWORD cbRet = 0;
2374 
2375  /* Get the Socket Structure associate to this Socket*/
2376  Socket = GetSocketStructure(Handle);
2377  if (!Socket)
2378  {
2379  if(lpErrno)
2380  *lpErrno = WSAENOTSOCK;
2381  return SOCKET_ERROR;
2382  }
2383 
2384  if (!lpcbBytesReturned && !lpOverlapped)
2385  {
2386  if(lpErrno)
2387  *lpErrno = WSAEFAULT;
2388  return SOCKET_ERROR;
2389  }
2390 
2391  switch( dwIoControlCode )
2392  {
2393  case FIONBIO:
2394  if( cbInBuffer < sizeof(INT) || IS_INTRESOURCE(lpvInBuffer) )
2395  {
2396  Errno = WSAEFAULT;
2397  break;
2398  }
2399  NonBlocking = *((PULONG)lpvInBuffer) ? TRUE : FALSE;
2400  /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
2401  if (!NonBlocking)
2402  {
2403  /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
2404  if (Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents))
2405  {
2406  Errno = WSAEINVAL;
2407  break;
2408  }
2409  /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
2410  if (Socket->NetworkEvents)
2411  {
2412  Errno = WSAEINVAL;
2413  break;
2414  }
2415  }
2416  Socket->SharedData->NonBlocking = NonBlocking ? 1 : 0;
2417  NeedsCompletion = FALSE;
2418  Errno = SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &NonBlocking, NULL, NULL, lpOverlapped, lpCompletionRoutine);
2419  if (Errno == NO_ERROR)
2420  Ret = NO_ERROR;
2421  break;
2422  case FIONREAD:
2423  if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
2424  {
2425  cbRet = sizeof(ULONG);
2426  Errno = WSAEFAULT;
2427  break;
2428  }
2429  if (cbOutBuffer < sizeof(ULONG))
2430  {
2431  Errno = WSAEINVAL;
2432  break;
2433  }
2434  NeedsCompletion = FALSE;
2435  Errno = GetSocketInformation(Socket, AFD_INFO_RECEIVE_CONTENT_SIZE, NULL, (PULONG)lpvOutBuffer, NULL, lpOverlapped, lpCompletionRoutine);
2436  if (Errno == NO_ERROR)
2437  {
2438  cbRet = sizeof(ULONG);
2439  Ret = NO_ERROR;
2440  }
2441  break;
2442  case SIOCATMARK:
2443  if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
2444  {
2445  cbRet = sizeof(BOOL);
2446  Errno = WSAEFAULT;
2447  break;
2448  }
2449  if (cbOutBuffer < sizeof(BOOL))
2450  {
2451  Errno = WSAEINVAL;
2452  break;
2453  }
2454  if (Socket->SharedData->SocketType != SOCK_STREAM)
2455  {
2456  Errno = WSAEINVAL;
2457  break;
2458  }
2459 
2460  /* FIXME: Return false if OOBINLINE is true for now
2461  We should MSG_PEEK|MSG_OOB check with driver
2462  */
2463  *(BOOL*)lpvOutBuffer = !Socket->SharedData->OobInline;
2464 
2465  cbRet = sizeof(BOOL);
2466  Errno = NO_ERROR;
2467  Ret = NO_ERROR;
2468  break;
2470  if (cbOutBuffer == 0)
2471  {
2472  cbRet = sizeof(PVOID);
2473  Errno = WSAEFAULT;
2474  break;
2475  }
2476 
2477  if (cbInBuffer < sizeof(GUID) ||
2478  cbOutBuffer < sizeof(PVOID))
2479  {
2480  Errno = WSAEINVAL;
2481  break;
2482  }
2483 
2484  {
2485  GUID AcceptExGUID = WSAID_ACCEPTEX;
2486  GUID ConnectExGUID = WSAID_CONNECTEX;
2487  GUID DisconnectExGUID = WSAID_DISCONNECTEX;
2488  GUID GetAcceptExSockaddrsGUID = WSAID_GETACCEPTEXSOCKADDRS;
2489 
2490  if (IsEqualGUID(&AcceptExGUID, lpvInBuffer))
2491  {
2492  *((PVOID *)lpvOutBuffer) = WSPAcceptEx;
2493  cbRet = sizeof(PVOID);
2494  Errno = NO_ERROR;
2495  Ret = NO_ERROR;
2496  }
2497  else if (IsEqualGUID(&ConnectExGUID, lpvInBuffer))
2498  {
2499  *((PVOID *)lpvOutBuffer) = WSPConnectEx;
2500  cbRet = sizeof(PVOID);
2501  Errno = NO_ERROR;
2502  Ret = NO_ERROR;
2503  }
2504  else if (IsEqualGUID(&DisconnectExGUID, lpvInBuffer))
2505  {
2506  *((PVOID *)lpvOutBuffer) = WSPDisconnectEx;
2507  cbRet = sizeof(PVOID);
2508  Errno = NO_ERROR;
2509  Ret = NO_ERROR;
2510  }
2511  else if (IsEqualGUID(&GetAcceptExSockaddrsGUID, lpvInBuffer))
2512  {
2513  *((PVOID *)lpvOutBuffer) = WSPGetAcceptExSockaddrs;
2514  cbRet = sizeof(PVOID);
2515  Errno = NO_ERROR;
2516  Ret = NO_ERROR;
2517  }
2518  else
2519  {
2520  ERR("Querying unknown extension function: %x\n", ((GUID*)lpvInBuffer)->Data1);
2521  Errno = WSAEOPNOTSUPP;
2522  }
2523  }
2524 
2525  break;
2527  if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
2528  {
2529  cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
2530  Errno = WSAEFAULT;
2531  break;
2532  }
2533  if (cbOutBuffer < sizeof(INT))
2534  {
2535  Errno = WSAEINVAL;
2536  break;
2537  }
2538 
2539  cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
2540 
2541  ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->iAddressCount = 1;
2542 
2543  if (cbOutBuffer < (sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress)))
2544  {
2545  Errno = WSAEFAULT;
2546  break;
2547  }
2548 
2549  ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].iSockaddrLength = sizeof(Socket->SharedData->WSLocalAddress);
2550  ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].lpSockaddr = &Socket->SharedData->WSLocalAddress;
2551 
2552  Errno = NO_ERROR;
2553  Ret = NO_ERROR;
2554  break;
2555  default:
2556  Errno = Socket->HelperData->WSHIoctl(Socket->HelperContext,
2557  Handle,
2558  Socket->TdiAddressHandle,
2559  Socket->TdiConnectionHandle,
2561  lpvInBuffer,
2562  cbInBuffer,
2563  lpvOutBuffer,
2564  cbOutBuffer,
2565  &cbRet,
2566  lpOverlapped,
2567  lpCompletionRoutine,
2568  &NeedsCompletion);
2569 
2570  if (Errno == NO_ERROR)
2571  Ret = NO_ERROR;
2572  break;
2573  }
2574  if (lpOverlapped && NeedsCompletion)
2575  {
2576  lpOverlapped->Internal = Errno;
2577  lpOverlapped->InternalHigh = cbRet;
2578  if (lpCompletionRoutine != NULL)
2579  {
2580  lpCompletionRoutine(Errno, cbRet, lpOverlapped, 0);
2581  }
2582  if (lpOverlapped->hEvent)
2583  SetEvent(lpOverlapped->hEvent);
2585  {
2586  ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
2587  }
2588  return NO_ERROR;
2589  }
2590  if (lpErrno)
2591  *lpErrno = Errno;
2592  if (lpcbBytesReturned)
2593  *lpcbBytesReturned = cbRet;
2594  return Ret;
2595 }
#define SIO_ADDRESS_LIST_QUERY
Definition: ws2def.h:177
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
#define SIOCATMARK
Definition: winsock.h:253
#define TRUE
Definition: types.h:120
BOOL WSPAPI WSPAcceptEx(IN SOCKET sListenSocket, IN SOCKET sAcceptSocket, OUT PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT LPDWORD lpdwBytesReceived, IN OUT LPOVERLAPPED lpOverlapped)
Definition: stubs.c:58
#define WSAEFAULT
Definition: winerror.h:1945
#define WSAEINVAL
Definition: winerror.h:1946
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
SOCKADDR WSLocalAddress
Definition: msafd.h:94
BOOLEAN OobInline
Definition: msafd.h:71
#define SIO_GET_EXTENSION_FUNCTION_POINTER
Definition: ws2def.h:167
BOOL WINAPI DECLSPEC_HOTPATCH SetEvent(IN HANDLE hEvent)
Definition: synch.c:733
DWORD WINAPI GetLastError(VOID)
Definition: except.c:1059
#define WSAID_GETACCEPTEXSOCKADDRS
Definition: mswsock.h:77
#define NO_ERROR
Definition: dderror.h:5
#define BOOL
Definition: nt_native.h:43
int GetSocketInformation(PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
Definition: dllmain.c:3257
int32_t INT
Definition: typedefs.h:56
#define WSAEOPNOTSUPP
Definition: winerror.h:1958
unsigned int BOOL
Definition: ntddk_ex.h:94