ReactOS  0.4.14-dev-599-g2d4d3f5
msafdlib.h File Reference
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes

struct  _SOCK_SHARED_INFO
 
struct  _HELPER_DATA
 
struct  _ASYNC_DATA
 
struct  _SOCKET_INFORMATION
 
struct  _SOCKET_CONTEXT
 
struct  _SOCK_RW_LOCK
 
struct  _WINSOCK_TEB_DATA
 
struct  _SOCK_ICF_DATA
 

Macros

#define NO_BLOCKING_HOOK   0
 
#define MAYBE_BLOCKING_HOOK   1
 
#define ALWAYS_BLOCKING_HOOK   2
 
#define NO_TIMEOUT   0
 
#define SEND_TIMEOUT   1
 
#define RECV_TIMEOUT   2
 
#define MAX_TDI_ADDRESS_LENGTH   32
 
#define WSA_FLAG_MULTIPOINT_ALL
 
#define MSAFD_IS_DGRAM_SOCK(s)   (s->SharedData.ServiceFlags1 & XP1_CONNECTIONLESS)
 

Typedefs

typedef enum _SOCKET_STATE SOCKET_STATE
 
typedef enum _SOCKET_STATEPSOCKET_STATE
 
typedef struct _SOCK_SHARED_INFO SOCK_SHARED_INFO
 
typedef struct _SOCK_SHARED_INFOPSOCK_SHARED_INFO
 
typedef struct _HELPER_DATA HELPER_DATA
 
typedef struct _HELPER_DATAPHELPER_DATA
 
typedef struct _ASYNC_DATA ASYNC_DATA
 
typedef struct _ASYNC_DATAPASYNC_DATA
 
typedef struct _SOCKET_INFORMATION SOCKET_INFORMATION
 
typedef struct _SOCKET_INFORMATIONPSOCKET_INFORMATION
 
typedef struct _SOCKET_CONTEXT SOCKET_CONTEXT
 
typedef struct _SOCKET_CONTEXTPSOCKET_CONTEXT
 
typedef struct _SOCK_RW_LOCK SOCK_RW_LOCK
 
typedef struct _SOCK_RW_LOCKPSOCK_RW_LOCK
 
typedef struct _WINSOCK_TEB_DATA WINSOCK_TEB_DATA
 
typedef struct _WINSOCK_TEB_DATAPWINSOCK_TEB_DATA
 
typedef INT(WINAPIPICF_CONNECT) (PVOID IcfData)
 
typedef struct _SOCK_ICF_DATA SOCK_ICF_DATA
 
typedef struct _SOCK_ICF_DATAPSOCK_ICF_DATA
 
typedef PVOID(NTAPIPRTL_HEAP_ALLOCATE) (IN HANDLE Heap, IN ULONG Flags, IN ULONG Size)
 
typedef VOID(WSPAPIPASYNC_COMPLETION_ROUTINE) (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
 

Enumerations

enum  _SOCKET_STATE {
  SocketOpen, SocketBound, SocketBoundUdp, SocketConnected,
  SocketClosed, SocketStateCreated, SocketStateBound, SocketStateListening,
  SocketStateConnected, SocketUndefined = -1, SocketOpen, SocketBound,
  SocketBoundUdp, SocketConnected, SocketClosed
}
 

Functions

BOOL WSPAPI MSWSOCK_Initialize (VOID)
 
BOOL WSPAPI MSAFD_SockThreadInitialize (VOID)
 
INT WSPAPI SockCreateAsyncQueuePort (VOID)
 
PVOID WSPAPI SockInitializeHeap (IN HANDLE Heap, IN ULONG Flags, IN ULONG Size)
 
NTSTATUS WSPAPI SockInitializeRwLockAndSpinCount (IN PSOCK_RW_LOCK Lock, IN ULONG SpinCount)
 
VOID WSPAPI SockAcquireRwLockExclusive (IN PSOCK_RW_LOCK Lock)
 
VOID WSPAPI SockAcquireRwLockShared (IN PSOCK_RW_LOCK Lock)
 
VOID WSPAPI SockReleaseRwLockExclusive (IN PSOCK_RW_LOCK Lock)
 
VOID WSPAPI SockReleaseRwLockShared (IN PSOCK_RW_LOCK Lock)
 
NTSTATUS WSPAPI SockDeleteRwLock (IN PSOCK_RW_LOCK Lock)
 
INT WSPAPI SockGetConnectData (IN PSOCKET_INFORMATION Socket, IN ULONG Ioctl, IN PVOID Buffer, IN ULONG BufferLength, OUT PULONG BufferReturned)
 
INT WSPAPI SockIsAddressConsistentWithConstrainedGroup (IN PSOCKET_INFORMATION Socket, IN GROUP Group, IN PSOCKADDR SocketAddress, IN INT SocketAddressLength)
 
BOOL WSPAPI SockWaitForSingleObject (IN HANDLE Handle, IN SOCKET SocketHandle, IN DWORD BlockingFlags, IN DWORD TimeoutFlags)
 
BOOLEAN WSPAPI SockIsSocketConnected (IN PSOCKET_INFORMATION Socket)
 
INT WSPAPI SockNotifyHelperDll (IN PSOCKET_INFORMATION Socket, IN DWORD Event)
 
INT WSPAPI SockUpdateWindowSizes (IN PSOCKET_INFORMATION Socket, IN BOOLEAN Force)
 
INT WSPAPI SockBuildTdiAddress (OUT PTRANSPORT_ADDRESS TdiAddress, IN PSOCKADDR Sockaddr, IN INT SockaddrLength)
 
INT WSPAPI SockBuildSockaddr (OUT PSOCKADDR Sockaddr, OUT PINT SockaddrLength, IN PTRANSPORT_ADDRESS TdiAddress)
 
INT WSPAPI SockGetTdiHandles (IN PSOCKET_INFORMATION Socket)
 
VOID WSPAPI SockIoCompletion (IN PVOID ApcContext, IN PIO_STATUS_BLOCK IoStatusBlock, DWORD Reserved)
 
VOID WSPAPI SockCancelIo (IN SOCKET Handle)
 
INT WSPAPI SockGetInformation (IN PSOCKET_INFORMATION Socket, IN ULONG AfdInformationClass, IN PVOID ExtraData OPTIONAL, IN ULONG ExtraDataSize, IN OUT PBOOLEAN Boolean OPTIONAL, IN OUT PULONG Ulong OPTIONAL, IN OUT PLARGE_INTEGER LargeInteger OPTIONAL)
 
INT WSPAPI SockSetInformation (IN PSOCKET_INFORMATION Socket, IN ULONG AfdInformationClass, IN PBOOLEAN Boolean OPTIONAL, IN PULONG Ulong OPTIONAL, IN PLARGE_INTEGER LargeInteger OPTIONAL)
 
INT WSPAPI SockSetHandleContext (IN PSOCKET_INFORMATION Socket)
 
VOID WSPAPI SockDereferenceSocket (IN PSOCKET_INFORMATION Socket)
 
VOID WSPAPI SockFreeHelperDll (IN PHELPER_DATA Helper)
 
PSOCKET_INFORMATION WSPAPI SockFindAndReferenceSocket (IN SOCKET Handle, IN BOOLEAN Import)
 
INT WSPAPI SockEnterApiSlow (OUT PWINSOCK_TEB_DATA *ThreadData)
 
VOID WSPAPI SockSanInitialize (VOID)
 
VOID WSPAPI SockSanGetTcpipCatalogId (VOID)
 
VOID WSPAPI CloseIcfConnection (IN PSOCK_ICF_DATA IcfData)
 
VOID WSPAPI InitializeIcfConnection (IN PSOCK_ICF_DATA IcfData)
 
VOID WSPAPI NewIcfConnection (IN PSOCK_ICF_DATA IcfData)
 
INT WSPAPI NtStatusToSocketError (IN NTSTATUS Status)
 
INT WSPAPI SockSocket (INT AddressFamily, INT SocketType, INT Protocol, LPGUID ProviderId, GROUP g, DWORD dwFlags, DWORD ProviderFlags, DWORD ServiceFlags, DWORD CatalogEntryId, PSOCKET_INFORMATION *NewSocket)
 
INT WSPAPI SockCloseSocket (IN PSOCKET_INFORMATION Socket)
 
FORCEINLINE INT WSPAPI SockEnterApiFast (OUT PWINSOCK_TEB_DATA *ThreadData)
 
FORCEINLINE VOID WSPAPI SockDereferenceHelperDll (IN PHELPER_DATA Helper)
 
INT WSPAPI SockLoadHelperDll (PWSTR TransportName, PWINSOCK_MAPPING Mapping, PHELPER_DATA *HelperDllData)
 
INT WSPAPI SockLoadTransportMapping (PWSTR TransportName, PWINSOCK_MAPPING *Mapping)
 
INT WSPAPI SockLoadTransportList (PWSTR *TransportList)
 
BOOL WSPAPI SockIsTripleInMapping (IN PWINSOCK_MAPPING Mapping, IN INT AddressFamily, OUT PBOOLEAN AfMatch, IN INT SocketType, OUT PBOOLEAN SockMatch, IN INT Protocol, OUT PBOOLEAN ProtoMatch)
 
INT WSPAPI SockAsyncSelectHelper (IN PSOCKET_INFORMATION Socket, IN HWND hWnd, IN UINT wMsg, IN LONG Events)
 
INT WSPAPI SockEventSelectHelper (IN PSOCKET_INFORMATION Socket, IN WSAEVENT EventObject, IN LONG Events)
 
BOOLEAN WSPAPI SockCheckAndReferenceAsyncThread (VOID)
 
BOOLEAN WSPAPI SockCheckAndInitAsyncSelectHelper (VOID)
 
INT WSPAPI SockGetTdiName (PINT AddressFamily, PINT SocketType, PINT Protocol, LPGUID ProviderId, GROUP Group, DWORD Flags, PUNICODE_STRING TransportName, PVOID *HelperDllContext, PHELPER_DATA *HelperDllData, PDWORD Events)
 
INT WSPAPI SockAsyncThread (PVOID ThreadParam)
 
VOID WSPAPI SockProcessAsyncSelect (PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
 
VOID WSPAPI SockHandleAsyncIndication (IN PASYNC_COMPLETION_ROUTINE Callback, IN PVOID Context, IN PIO_STATUS_BLOCK IoStatusBlock)
 
INT WSPAPI SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket, IN ULONG Event)
 
VOID WSPAPI SockProcessQueuedAsyncSelect (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
 
VOID WSPAPI SockAsyncSelectCompletion (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
 
SOCKET WSPAPI WSPAccept (IN SOCKET s, OUT LPSOCKADDR addr, IN OUT LPINT addrlen, IN LPCONDITIONPROC lpfnCondition, IN DWORD dwCallbackData, OUT LPINT lpErrno)
 
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 WSPAsyncSelect (IN SOCKET s, IN HWND hWnd, IN UINT wMsg, IN LONG lEvent, OUT LPINT lpErrno)
 
INT WSPAPI WSPBind (IN SOCKET s, IN CONST SOCKADDR *name, IN INT namelen, OUT LPINT lpErrno)
 
INT WSPAPI WSPCancelBlockingCall (OUT LPINT lpErrno)
 
INT WSPAPI WSPCleanup (OUT LPINT lpErrno)
 
INT WSPAPI WSPCloseSocket (IN SOCKET s, OUT LPINT lpErrno)
 
INT WSPAPI WSPConnect (IN SOCKET s, IN CONST SOCKADDR *name, IN INT namelen, IN LPWSABUF lpCallerData, OUT LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, OUT LPINT lpErrno)
 
INT WSPAPI WSPDuplicateSocket (IN SOCKET s, IN DWORD dwProcessId, OUT LPWSAPROTOCOL_INFOW lpProtocolInfo, OUT LPINT lpErrno)
 
INT WSPAPI WSPEnumNetworkEvents (IN SOCKET s, IN WSAEVENT hEventObject, OUT LPWSANETWORKEVENTS lpNetworkEvents, OUT LPINT lpErrno)
 
INT WSPAPI WSPEventSelect (IN SOCKET s, IN WSAEVENT hEventObject, IN LONG lNetworkEvents, OUT LPINT lpErrno)
 
BOOL WSPAPI WSPGetOverlappedResult (IN SOCKET s, IN LPWSAOVERLAPPED lpOverlapped, OUT LPDWORD lpcbTransfer, IN BOOL fWait, OUT LPDWORD lpdwFlags, OUT LPINT lpErrno)
 
INT WSPAPI WSPGetPeerName (IN SOCKET s, OUT LPSOCKADDR name, IN OUT LPINT namelen, OUT LPINT lpErrno)
 
BOOL WSPAPI WSPGetQOSByName (IN SOCKET s, IN OUT LPWSABUF lpQOSName, OUT LPQOS lpQOS, OUT LPINT lpErrno)
 
INT WSPAPI WSPGetSockName (IN SOCKET s, OUT LPSOCKADDR name, IN OUT LPINT namelen, OUT LPINT lpErrno)
 
INT WSPAPI WSPGetSockOpt (IN SOCKET s, IN INT level, IN INT optname, OUT CHAR FAR *optval, IN OUT LPINT optlen, OUT LPINT lpErrno)
 
INT WSPAPI WSPIoctl (IN SOCKET s, 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)
 
SOCKET WSPAPI WSPJoinLeaf (IN SOCKET s, IN CONST SOCKADDR *name, IN INT namelen, IN LPWSABUF lpCallerData, OUT LPWSABUF lpCalleeData, IN LPQOS lpSQOS, IN LPQOS lpGQOS, IN DWORD dwFlags, OUT LPINT lpErrno)
 
INT WSPAPI WSPListen (IN SOCKET s, IN INT backlog, OUT LPINT lpErrno)
 
INT WSPAPI WSPRecv (IN SOCKET s, IN OUT LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT LPINT lpErrno)
 
INT WSPAPI WSPRecvDisconnect (IN SOCKET s, OUT LPWSABUF lpInboundDisconnectData, OUT LPINT lpErrno)
 
INT WSPAPI WSPRecvFrom (IN SOCKET s, IN OUT LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesRecvd, IN OUT LPDWORD lpFlags, OUT LPSOCKADDR lpFrom, IN OUT LPINT lpFromlen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT LPINT lpErrno)
 
INT WSPAPI WSPSelect (IN INT nfds, IN OUT LPFD_SET readfds, IN OUT LPFD_SET writefds, IN OUT LPFD_SET exceptfds, IN CONST LPTIMEVAL timeout, OUT LPINT lpErrno)
 
INT WSPAPI WSPSend (IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, OUT LPINT lpErrno)
 
INT WSPAPI WSPSendDisconnect (IN SOCKET s, IN LPWSABUF lpOutboundDisconnectData, OUT LPINT lpErrno)
 
INT WSPAPI WSPSendTo (IN SOCKET s, IN LPWSABUF lpBuffers, IN DWORD dwBufferCount, OUT LPDWORD lpNumberOfBytesSent, IN DWORD dwFlags, IN CONST SOCKADDR *lpTo, IN INT iTolen, IN LPWSAOVERLAPPED lpOverlapped, IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, IN LPWSATHREADID lpThreadId, 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)
 
INT WSPAPI WSPShutdown (IN SOCKET s, IN INT how, OUT LPINT lpErrno)
 
SOCKET WSPAPI WSPSocket (IN INT af, IN INT type, IN INT protocol, IN LPWSAPROTOCOL_INFOW lpProtocolInfo, IN GROUP g, IN DWORD dwFlags, 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)
 

Variables

HANDLE SockPrivateHeap
 
PRTL_HEAP_ALLOCATE SockAllocateHeapRoutine
 
SOCK_RW_LOCK SocketGlobalLock
 
PWAH_HANDLE_TABLE SockContextTable
 
LPWSPUPCALLTABLE SockUpcallTable
 
BOOL SockProcessTerminating
 
LONG SockWspStartupCount
 
DWORD SockSendBufferWindow
 
DWORD SockReceiveBufferWindow
 
HANDLE SockAsyncQueuePort
 
BOOLEAN SockAsyncSelectCalled
 
LONG SockProcessPendingAPCCount
 
HINSTANCE SockModuleHandle
 
LONG gWSM_NSPStartupRef
 
LONG gWSM_NSPCallRef
 
LIST_ENTRY SockHelperDllListHead
 
CRITICAL_SECTION MSWSOCK_SocketLock
 
HINSTANCE NlsMsgSourcemModuleHandle
 
PVOID SockBufferKeyTable
 
ULONG SockBufferKeyTableSize
 
LONG SockAsyncThreadReferenceCount
 
BOOLEAN g_fRnrLockInit
 
CRITICAL_SECTION g_RnrLock
 
HANDLE SockSanCleanUpCompleteEvent
 
BOOLEAN SockSanEnabled
 
WSAPROTOCOL_INFOW SockTcpProviderInfo
 

Macro Definition Documentation

◆ ALWAYS_BLOCKING_HOOK

#define ALWAYS_BLOCKING_HOOK   2

Definition at line 10 of file msafdlib.h.

◆ MAX_TDI_ADDRESS_LENGTH

#define MAX_TDI_ADDRESS_LENGTH   32

Definition at line 16 of file msafdlib.h.

◆ MAYBE_BLOCKING_HOOK

#define MAYBE_BLOCKING_HOOK   1

Definition at line 9 of file msafdlib.h.

◆ MSAFD_IS_DGRAM_SOCK

#define MSAFD_IS_DGRAM_SOCK (   s)    (s->SharedData.ServiceFlags1 & XP1_CONNECTIONLESS)

Definition at line 430 of file msafdlib.h.

◆ NO_BLOCKING_HOOK

#define NO_BLOCKING_HOOK   0

Definition at line 8 of file msafdlib.h.

◆ NO_TIMEOUT

#define NO_TIMEOUT   0

Definition at line 12 of file msafdlib.h.

◆ RECV_TIMEOUT

#define RECV_TIMEOUT   2

Definition at line 14 of file msafdlib.h.

◆ SEND_TIMEOUT

#define SEND_TIMEOUT   1

Definition at line 13 of file msafdlib.h.

◆ WSA_FLAG_MULTIPOINT_ALL

#define WSA_FLAG_MULTIPOINT_ALL
Value:
WSA_FLAG_MULTIPOINT_C_LEAF |\
WSA_FLAG_MULTIPOINT_D_ROOT |\
WSA_FLAG_MULTIPOINT_D_LEAF)
#define WSA_FLAG_MULTIPOINT_C_ROOT
Definition: winsock2.h:467

Definition at line 18 of file msafdlib.h.

Typedef Documentation

◆ ASYNC_DATA

◆ HELPER_DATA

◆ PASYNC_COMPLETION_ROUTINE

typedef VOID(WSPAPI * PASYNC_COMPLETION_ROUTINE) (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)

Definition at line 439 of file msafdlib.h.

◆ PASYNC_DATA

◆ PHELPER_DATA

◆ PICF_CONNECT

typedef INT(WINAPI * PICF_CONNECT) (PVOID IcfData)

Definition at line 170 of file msafdlib.h.

◆ PRTL_HEAP_ALLOCATE

typedef PVOID(NTAPI * PRTL_HEAP_ALLOCATE) (IN HANDLE Heap, IN ULONG Flags, IN ULONG Size)

Definition at line 182 of file msafdlib.h.

◆ PSOCK_ICF_DATA

◆ PSOCK_RW_LOCK

◆ PSOCK_SHARED_INFO

◆ PSOCKET_CONTEXT

◆ PSOCKET_INFORMATION

◆ PSOCKET_STATE

◆ PWINSOCK_TEB_DATA

◆ SOCK_ICF_DATA

◆ SOCK_RW_LOCK

◆ SOCK_SHARED_INFO

◆ SOCKET_CONTEXT

◆ SOCKET_INFORMATION

◆ SOCKET_STATE

◆ WINSOCK_TEB_DATA

Enumeration Type Documentation

◆ _SOCKET_STATE

Enumerator
SocketOpen 
SocketBound 
SocketBoundUdp 
SocketConnected 
SocketClosed 
SocketStateCreated 
SocketStateBound 
SocketStateListening 
SocketStateConnected 
SocketUndefined 
SocketOpen 
SocketBound 
SocketBoundUdp 
SocketConnected 
SocketClosed 

Definition at line 25 of file msafdlib.h.

26 {
27  SocketUndefined = -1,
28  SocketOpen,
enum _SOCKET_STATE SOCKET_STATE
enum _SOCKET_STATE * PSOCKET_STATE

Function Documentation

◆ CloseIcfConnection()

VOID WSPAPI CloseIcfConnection ( IN PSOCK_ICF_DATA  IcfData)

◆ InitializeIcfConnection()

VOID WSPAPI InitializeIcfConnection ( IN PSOCK_ICF_DATA  IcfData)

◆ MSAFD_SockThreadInitialize()

BOOL WSPAPI MSAFD_SockThreadInitialize ( VOID  )

◆ MSWSOCK_Initialize()

BOOL WSPAPI MSWSOCK_Initialize ( VOID  )

◆ NewIcfConnection()

VOID WSPAPI NewIcfConnection ( IN PSOCK_ICF_DATA  IcfData)

◆ NtStatusToSocketError()

INT WSPAPI NtStatusToSocketError ( IN NTSTATUS  Status)

◆ SockAcquireRwLockExclusive()

VOID WSPAPI SockAcquireRwLockExclusive ( IN PSOCK_RW_LOCK  Lock)

◆ SockAcquireRwLockShared()

VOID WSPAPI SockAcquireRwLockShared ( IN PSOCK_RW_LOCK  Lock)

◆ SockAsyncSelectCompletion()

VOID WSPAPI SockAsyncSelectCompletion ( PVOID  Context,
PIO_STATUS_BLOCK  IoStatusBlock 
)

◆ SockAsyncSelectHelper()

INT WSPAPI SockAsyncSelectHelper ( IN PSOCKET_INFORMATION  Socket,
IN HWND  hWnd,
IN UINT  wMsg,
IN LONG  Events 
)

◆ SockAsyncThread()

INT WSPAPI 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().

◆ SockBuildSockaddr()

INT WSPAPI SockBuildSockaddr ( OUT PSOCKADDR  Sockaddr,
OUT PINT  SockaddrLength,
IN PTRANSPORT_ADDRESS  TdiAddress 
)

◆ SockBuildTdiAddress()

INT WSPAPI SockBuildTdiAddress ( OUT PTRANSPORT_ADDRESS  TdiAddress,
IN PSOCKADDR  Sockaddr,
IN INT  SockaddrLength 
)

◆ SockCancelIo()

VOID WSPAPI SockCancelIo ( IN SOCKET  Handle)

◆ SockCheckAndInitAsyncSelectHelper()

BOOLEAN WSPAPI SockCheckAndInitAsyncSelectHelper ( VOID  )

◆ SockCheckAndReferenceAsyncThread()

BOOLEAN WSPAPI SockCheckAndReferenceAsyncThread ( VOID  )

◆ SockCloseSocket()

INT WSPAPI SockCloseSocket ( IN PSOCKET_INFORMATION  Socket)

◆ SockCreateAsyncQueuePort()

INT WSPAPI SockCreateAsyncQueuePort ( VOID  )

◆ SockDeleteRwLock()

NTSTATUS WSPAPI SockDeleteRwLock ( IN PSOCK_RW_LOCK  Lock)

◆ SockDereferenceHelperDll()

FORCEINLINE VOID WSPAPI SockDereferenceHelperDll ( IN PHELPER_DATA  Helper)

Definition at line 420 of file msafdlib.h.

421 {
422  /* Dereference and see if it's the last count */
423  if (!InterlockedDecrement(&Helper->RefCount))
424  {
425  /* Destroy the Helper DLL */
426  SockFreeHelperDll(Helper);
427  }
428 }
VOID WSPAPI SockFreeHelperDll(IN PHELPER_DATA Helper)
#define InterlockedDecrement
Definition: armddk.h:52

◆ SockDereferenceSocket()

VOID WSPAPI SockDereferenceSocket ( IN PSOCKET_INFORMATION  Socket)

◆ SockEnterApiFast()

FORCEINLINE INT WSPAPI SockEnterApiFast ( OUT PWINSOCK_TEB_DATA ThreadData)

Definition at line 402 of file msafdlib.h.

403 {
404  /* Make sure we aren't terminating and get our thread data */
405  if (!(SockProcessTerminating) &&
406  (SockWspStartupCount > 0) &&
407  ((*ThreadData = NtCurrentTeb()->WinSockData)))
408  {
409  /* Everything is good, return */
410  return NO_ERROR;
411  }
412 
413  /* Something didn't work out, use the slow path */
415 }
#define NO_ERROR
Definition: dderror.h:5
INT WSPAPI SockEnterApiSlow(OUT PWINSOCK_TEB_DATA *ThreadData)
LONG SockWspStartupCount
BOOL SockProcessTerminating
FORCEINLINE struct _TEB * NtCurrentTeb(VOID)
Definition: psfuncs.h:420

◆ SockEnterApiSlow()

INT WSPAPI SockEnterApiSlow ( OUT PWINSOCK_TEB_DATA ThreadData)

Referenced by SockEnterApiFast().

◆ SockEventSelectHelper()

INT WSPAPI SockEventSelectHelper ( IN PSOCKET_INFORMATION  Socket,
IN WSAEVENT  EventObject,
IN LONG  Events 
)

◆ SockFindAndReferenceSocket()

PSOCKET_INFORMATION WSPAPI SockFindAndReferenceSocket ( IN SOCKET  Handle,
IN BOOLEAN  Import 
)

◆ SockFreeHelperDll()

VOID WSPAPI SockFreeHelperDll ( IN PHELPER_DATA  Helper)

◆ SockGetConnectData()

INT WSPAPI SockGetConnectData ( IN PSOCKET_INFORMATION  Socket,
IN ULONG  Ioctl,
IN PVOID  Buffer,
IN ULONG  BufferLength,
OUT PULONG  BufferReturned 
)

◆ SockGetInformation()

INT WSPAPI SockGetInformation ( IN PSOCKET_INFORMATION  Socket,
IN ULONG  AfdInformationClass,
IN PVOID ExtraData  OPTIONAL,
IN ULONG  ExtraDataSize,
IN OUT PBOOLEAN Boolean  OPTIONAL,
IN OUT PULONG Ulong  OPTIONAL,
IN OUT PLARGE_INTEGER LargeInteger  OPTIONAL 
)

◆ SockGetTdiHandles()

INT WSPAPI SockGetTdiHandles ( IN PSOCKET_INFORMATION  Socket)

◆ SockGetTdiName()

INT WSPAPI SockGetTdiName ( PINT  AddressFamily,
PINT  SocketType,
PINT  Protocol,
LPGUID  ProviderId,
GROUP  Group,
DWORD  Flags,
PUNICODE_STRING  TransportName,
PVOID HelperDllContext,
PHELPER_DATA HelperDllData,
PDWORD  Events 
)

◆ SockHandleAsyncIndication()

VOID WSPAPI SockHandleAsyncIndication ( IN PASYNC_COMPLETION_ROUTINE  Callback,
IN PVOID  Context,
IN PIO_STATUS_BLOCK  IoStatusBlock 
)

◆ SockInitializeHeap()

PVOID WSPAPI SockInitializeHeap ( IN HANDLE  Heap,
IN ULONG  Flags,
IN ULONG  Size 
)

◆ SockInitializeRwLockAndSpinCount()

NTSTATUS WSPAPI SockInitializeRwLockAndSpinCount ( IN PSOCK_RW_LOCK  Lock,
IN ULONG  SpinCount 
)

◆ SockIoCompletion()

VOID WSPAPI SockIoCompletion ( IN PVOID  ApcContext,
IN PIO_STATUS_BLOCK  IoStatusBlock,
DWORD  Reserved 
)

◆ SockIsAddressConsistentWithConstrainedGroup()

INT WSPAPI SockIsAddressConsistentWithConstrainedGroup ( IN PSOCKET_INFORMATION  Socket,
IN GROUP  Group,
IN PSOCKADDR  SocketAddress,
IN INT  SocketAddressLength 
)

◆ SockIsSocketConnected()

BOOLEAN WSPAPI SockIsSocketConnected ( IN PSOCKET_INFORMATION  Socket)

◆ SockIsTripleInMapping()

BOOL WSPAPI SockIsTripleInMapping ( IN PWINSOCK_MAPPING  Mapping,
IN INT  AddressFamily,
OUT PBOOLEAN  AfMatch,
IN INT  SocketType,
OUT PBOOLEAN  SockMatch,
IN INT  Protocol,
OUT PBOOLEAN  ProtoMatch 
)

◆ SockLoadHelperDll()

INT WSPAPI SockLoadHelperDll ( PWSTR  TransportName,
PWINSOCK_MAPPING  Mapping,
PHELPER_DATA HelperDllData 
)

Definition at line 298 of file helpers.c.

302 {
303  PHELPER_DATA HelperData;
304  PWSTR HelperDllName;
305  PWSTR FullHelperDllName;
306  PWSTR HelperKey;
307  HKEY KeyHandle;
308  ULONG DataSize;
309  LONG Status;
310 
311  /* Allocate space for the Helper Structure and TransportName */
312  HelperData = HeapAlloc(GlobalHeap, 0, sizeof(*HelperData) + (wcslen(TransportName) + 1) * sizeof(WCHAR));
313 
314  /* Check for error */
315  if (HelperData == NULL) {
316  ERR("Buffer allocation failed\n");
317  return WSAEINVAL;
318  }
319 
320  /* Allocate Space for the Helper DLL Key */
321  HelperKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
322 
323  /* Check for error */
324  if (HelperKey == NULL) {
325  ERR("Buffer allocation failed\n");
326  HeapFree(GlobalHeap, 0, HelperData);
327  return WSAEINVAL;
328  }
329 
330  /* Generate the right key name */
331  wcscpy(HelperKey, L"System\\CurrentControlSet\\Services\\");
332  wcscat(HelperKey, TransportName);
333  wcscat(HelperKey, L"\\Parameters\\Winsock");
334 
335  /* Open the Key */
337 
338  HeapFree(GlobalHeap, 0, HelperKey);
339 
340  /* Check for error */
341  if (Status) {
342  ERR("Error reading helper DLL parameters\n");
343  HeapFree(GlobalHeap, 0, HelperData);
344  return WSAEINVAL;
345  }
346 
347  /* Read Size of SockAddr Structures */
348  DataSize = sizeof(HelperData->MinWSAddressLength);
349  HelperData->MinWSAddressLength = 16;
351  L"MinSockaddrLength",
352  NULL,
353  NULL,
354  (LPBYTE)&HelperData->MinWSAddressLength,
355  &DataSize);
356  DataSize = sizeof(HelperData->MinWSAddressLength);
357  HelperData->MaxWSAddressLength = 16;
359  L"MaxSockaddrLength",
360  NULL,
361  NULL,
362  (LPBYTE)&HelperData->MaxWSAddressLength,
363  &DataSize);
364 
365  /* Size of TDI Structures */
366  HelperData->MinTDIAddressLength = HelperData->MinWSAddressLength + 6;
367  HelperData->MaxTDIAddressLength = HelperData->MaxWSAddressLength + 6;
368 
369  /* Read Delayed Acceptance Setting */
370  DataSize = sizeof(DWORD);
371  HelperData->UseDelayedAcceptance = FALSE;
373  L"UseDelayedAcceptance",
374  NULL,
375  NULL,
376  (LPBYTE)&HelperData->UseDelayedAcceptance,
377  &DataSize);
378 
379  /* Allocate Space for the Helper DLL Names */
380  HelperDllName = HeapAlloc(GlobalHeap, 0, 512);
381 
382  /* Check for error */
383  if (HelperDllName == NULL) {
384  ERR("Buffer allocation failed\n");
385  HeapFree(GlobalHeap, 0, HelperData);
386  return WSAEINVAL;
387  }
388 
389  FullHelperDllName = HeapAlloc(GlobalHeap, 0, 512);
390 
391  /* Check for error */
392  if (FullHelperDllName == NULL) {
393  ERR("Buffer allocation failed\n");
394  HeapFree(GlobalHeap, 0, HelperDllName);
395  HeapFree(GlobalHeap, 0, HelperData);
396  return WSAEINVAL;
397  }
398 
399  /* Get the name of the Helper DLL*/
400  DataSize = 512;
402  L"HelperDllName",
403  NULL,
404  NULL,
405  (LPBYTE)HelperDllName,
406  &DataSize);
407 
408  /* Check for error */
409  if (Status) {
410  ERR("Error reading helper DLL parameters\n");
411  HeapFree(GlobalHeap, 0, FullHelperDllName);
412  HeapFree(GlobalHeap, 0, HelperDllName);
413  HeapFree(GlobalHeap, 0, HelperData);
414  return WSAEINVAL;
415  }
416 
417  /* Get the Full name, expanding Environment Strings */
418  ExpandEnvironmentStringsW (HelperDllName,
419  FullHelperDllName,
420  256);
421 
422  /* Load the DLL */
423  HelperData->hInstance = LoadLibraryW(FullHelperDllName);
424 
425  HeapFree(GlobalHeap, 0, HelperDllName);
426  HeapFree(GlobalHeap, 0, FullHelperDllName);
427 
428  if (HelperData->hInstance == NULL) {
429  ERR("Error loading helper DLL\n");
430  HeapFree(GlobalHeap, 0, HelperData);
431  return WSAEINVAL;
432  }
433 
434  /* Close Key */
436 
437  /* Get the Pointers to the Helper Routines */
438  HelperData->WSHOpenSocket = (PWSH_OPEN_SOCKET)
439  GetProcAddress(HelperData->hInstance,
440  "WSHOpenSocket");
441  HelperData->WSHOpenSocket2 = (PWSH_OPEN_SOCKET2)
442  GetProcAddress(HelperData->hInstance,
443  "WSHOpenSocket2");
444  HelperData->WSHJoinLeaf = (PWSH_JOIN_LEAF)
445  GetProcAddress(HelperData->hInstance,
446  "WSHJoinLeaf");
447  HelperData->WSHNotify = (PWSH_NOTIFY)
448  GetProcAddress(HelperData->hInstance, "WSHNotify");
450  GetProcAddress(HelperData->hInstance,
451  "WSHGetSocketInformation");
453  GetProcAddress(HelperData->hInstance,
454  "WSHSetSocketInformation");
456  GetProcAddress(HelperData->hInstance,
457  "WSHGetSockaddrType");
459  GetProcAddress(HelperData->hInstance,
460  "WSHGetWildcardSockaddr");
462  GetProcAddress(HelperData->hInstance,
463  "WSHGetBroadcastSockaddr");
465  GetProcAddress(HelperData->hInstance,
466  "WSHAddressToString");
468  GetProcAddress(HelperData->hInstance,
469  "WSHStringToAddress");
470  HelperData->WSHIoctl = (PWSH_IOCTL)
471  GetProcAddress(HelperData->hInstance,
472  "WSHIoctl");
473 
474  /* Save the Mapping Structure and transport name */
475  HelperData->Mapping = Mapping;
476  wcscpy(HelperData->TransportName, TransportName);
477 
478  /* Increment Reference Count */
479  HelperData->RefCount = 1;
480 
481  /* Add it to our list */
483 
484  /* Return Pointers */
485  *HelperDllData = HelperData;
486  return 0;
487 }
PWSH_GET_WILDCARD_SOCKADDR WSHGetWildcardSockaddr
Definition: helpers.h:29
WCHAR TransportName[1]
Definition: helpers.h:34
INT(WINAPI * PWSH_ADDRESS_TO_STRING)(LPSOCKADDR, INT, LPWSAPROTOCOL_INFOW, LPWSTR, LPDWORD)
Definition: wsahelp.h:67
INT(WINAPI * PWSH_STRING_TO_ADDRESS)(LPWSTR, DWORD, LPWSAPROTOCOL_INFOW, LPSOCKADDR, LPDWORD)
Definition: wsahelp.h:84
PWSH_GET_BROADCAST_SOCKADDR WSHGetBroadcastSockaddr
Definition: helpers.h:30
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
PWSH_JOIN_LEAF WSHJoinLeaf
Definition: helpers.h:24
#define KEY_READ
Definition: nt_native.h:1023
uint16_t * PWSTR
Definition: typedefs.h:54
FORCEINLINE VOID InsertHeadList(_Inout_ PLIST_ENTRY ListHead, _Inout_ __drv_aliasesMem PLIST_ENTRY Entry)
Definition: rtlfuncs.h:201
#define WSAEINVAL
Definition: winerror.h:1946
static PVOID Mapping[EMS_PHYSICAL_PAGES]
Definition: emsdrv.c:41
INT(WINAPI * PWSH_IOCTL)(PVOID, SOCKET, HANDLE, HANDLE, DWORD, LPVOID, DWORD, LPVOID, DWORD, LPDWORD, LPWSAOVERLAPPED, LPWSAOVERLAPPED_COMPLETION_ROUTINE, LPBOOL)
Definition: wsahelp.h:76
INT(WINAPI * PWSH_OPEN_SOCKET)(PINT, PINT, PINT, PUNICODE_STRING, PVOID, PDWORD)
Definition: wsahelp.h:81
#define DWORD
Definition: nt_native.h:44
INT(WINAPI * PWSH_GET_SOCKET_INFORMATION)(PVOID, SOCKET, HANDLE, HANDLE, INT, INT, PCHAR, LPINT)
Definition: wsahelp.h:72
HANDLE hInstance
Definition: helpers.h:15
INT MinWSAddressLength
Definition: helpers.h:16
INT(WINAPI * PWSH_GET_BROADCAST_SOCKADDR)(PVOID, PSOCKADDR, PINT)
Definition: wsahelp.h:69
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
PWINSOCK_MAPPING Mapping
Definition: helpers.h:21
long LONG
Definition: pedump.c:60
PWSH_STRING_TO_ADDRESS WSHStringToAddress
Definition: helpers.h:32
INT MaxWSAddressLength
Definition: helpers.h:17
#define LoadLibraryW(x)
Definition: compat.h:412
smooth NULL
Definition: ftsmooth.c:416
LIST_ENTRY Helpers
Definition: helpers.h:13
PWSH_GET_SOCKADDR_TYPE WSHGetSockaddrType
Definition: helpers.h:28
BOOLEAN UseDelayedAcceptance
Definition: helpers.h:20
PWSH_OPEN_SOCKET WSHOpenSocket
Definition: helpers.h:22
PWSH_OPEN_SOCKET2 WSHOpenSocket2
Definition: helpers.h:23
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
PWSH_NOTIFY WSHNotify
Definition: helpers.h:25
PWSH_ADDRESS_TO_STRING WSHAddressToString
Definition: helpers.h:31
LIST_ENTRY SockHelpersListHead
Definition: dllmain.c:25
_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
PWSH_GET_SOCKET_INFORMATION WSHGetSocketInformation
Definition: helpers.h:26
INT MinTDIAddressLength
Definition: helpers.h:18
INT(WINAPI * PWSH_OPEN_SOCKET2)(PINT, PINT, PINT, GROUP, DWORD, PUNICODE_STRING, PVOID *, PDWORD)
Definition: wsahelp.h:82
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
PWSH_IOCTL WSHIoctl
Definition: helpers.h:33
PWSH_SET_SOCKET_INFORMATION WSHSetSocketInformation
Definition: helpers.h:27
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
DWORD WINAPI ExpandEnvironmentStringsW(IN LPCWSTR lpSrc, IN LPWSTR lpDst, IN DWORD nSize)
Definition: environ.c:519
INT(WINAPI * PWSH_JOIN_LEAF)(PVOID, SOCKET, HANDLE, HANDLE, PVOID, SOCKET, PSOCKADDR, DWORD, LPWSABUF, LPWSABUF, LPQOS, LPQOS, DWORD)
Definition: wsahelp.h:78
INT(WINAPI * PWSH_GET_SOCKADDR_TYPE)(PSOCKADDR, DWORD, PSOCKADDR_INFO)
Definition: wsahelp.h:71
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
#define GetProcAddress(x, y)
Definition: compat.h:418
INT MaxTDIAddressLength
Definition: helpers.h:19
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:402
_In_ NDIS_STATUS _In_ ULONG _In_ USHORT _In_opt_ PVOID _In_ ULONG DataSize
Definition: ndis.h:4751
INT(WINAPI * PWSH_NOTIFY)(PVOID, SOCKET, HANDLE, HANDLE, DWORD)
Definition: wsahelp.h:80
INT(WINAPI * PWSH_SET_SOCKET_INFORMATION)(PVOID, SOCKET, HANDLE, HANDLE, INT, INT, PCHAR, INT)
Definition: wsahelp.h:83
INT(WINAPI * PWSH_GET_WILDCARD_SOCKADDR)(PVOID, PSOCKADDR, PINT)
Definition: wsahelp.h:73
LONG RefCount
Definition: helpers.h:14
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by SockGetTdiName().

◆ SockLoadTransportList()

INT WSPAPI SockLoadTransportList ( PWSTR TransportList)

Definition at line 232 of file helpers.c.

234 {
235  ULONG TransportListSize;
236  HKEY KeyHandle;
237  LONG Status;
238 
239  TRACE("Called\n");
240 
241  /* Open the Transports Key */
243  L"SYSTEM\\CurrentControlSet\\Services\\Winsock\\Parameters",
244  0,
245  KEY_READ,
246  &KeyHandle);
247 
248  /* Check for error */
249  if (Status) {
250  ERR("Error reading transport list registry\n");
251  return WSAEINVAL;
252  }
253 
254  /* Get the Transport List Size */
256  L"Transports",
257  NULL,
258  NULL,
259  NULL,
260  &TransportListSize);
261 
262  /* Check for error */
263  if (Status) {
264  ERR("Error reading transport list registry\n");
265  return WSAEINVAL;
266  }
267 
268  /* Allocate Memory for the Transport List */
269  *TransportList = HeapAlloc(GlobalHeap, 0, TransportListSize);
270 
271  /* Check for error */
272  if (*TransportList == NULL) {
273  ERR("Buffer allocation failed\n");
274  return WSAEINVAL;
275  }
276 
277  /* Get the Transports */
279  L"Transports",
280  NULL,
281  NULL,
282  (LPBYTE)*TransportList,
283  &TransportListSize);
284 
285  /* Check for error */
286  if (Status) {
287  ERR("Error reading transport list registry\n");
288  HeapFree(GlobalHeap, 0, *TransportList);
289  return WSAEINVAL;
290  }
291 
292  /* Close key and return */
294  return 0;
295 }
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
#define KEY_READ
Definition: nt_native.h:1023
#define WSAEINVAL
Definition: winerror.h:1946
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
static const WCHAR L[]
Definition: oid.c:1250
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
#define HeapFree(x, y, z)
Definition: compat.h:402
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by SockGetTdiName().

◆ SockLoadTransportMapping()

INT WSPAPI SockLoadTransportMapping ( PWSTR  TransportName,
PWINSOCK_MAPPING Mapping 
)

Definition at line 161 of file helpers.c.

164 {
165  PWSTR TransportKey;
166  HKEY KeyHandle;
167  ULONG MappingSize;
168  LONG Status;
169 
170  TRACE("TransportName %ws\n", TransportName);
171 
172  /* Allocate a Buffer */
173  TransportKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
174 
175  /* Check for error */
176  if (TransportKey == NULL) {
177  ERR("Buffer allocation failed\n");
178  return WSAEINVAL;
179  }
180 
181  /* Generate the right key name */
182  wcscpy(TransportKey, L"System\\CurrentControlSet\\Services\\");
183  wcscat(TransportKey, TransportName);
184  wcscat(TransportKey, L"\\Parameters\\Winsock");
185 
186  /* Open the Key */
188 
189  /* We don't need the Transport Key anymore */
190  HeapFree(GlobalHeap, 0, TransportKey);
191 
192  /* Check for error */
193  if (Status) {
194  ERR("Error reading transport mapping registry\n");
195  return WSAEINVAL;
196  }
197 
198  /* Find out how much space we need for the Mapping */
199  Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, NULL, &MappingSize);
200 
201  /* Check for error */
202  if (Status) {
203  ERR("Error reading transport mapping registry\n");
204  return WSAEINVAL;
205  }
206 
207  /* Allocate Memory for the Mapping */
208  *Mapping = HeapAlloc(GlobalHeap, 0, MappingSize);
209 
210  /* Check for error */
211  if (*Mapping == NULL) {
212  ERR("Buffer allocation failed\n");
213  return WSAEINVAL;
214  }
215 
216  /* Read the Mapping */
217  Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, (LPBYTE)*Mapping, &MappingSize);
218 
219  /* Check for error */
220  if (Status) {
221  ERR("Error reading transport mapping registry\n");
223  return WSAEINVAL;
224  }
225 
226  /* Close key and return */
228  return 0;
229 }
_Must_inspect_result_ _Out_ PNDIS_STATUS _In_ NDIS_HANDLE _In_ ULONG _Out_ PNDIS_STRING _Out_ PNDIS_HANDLE KeyHandle
Definition: ndis.h:4711
#define KEY_READ
Definition: nt_native.h:1023
uint16_t * PWSTR
Definition: typedefs.h:54
#define WSAEINVAL
Definition: winerror.h:1946
static PVOID Mapping[EMS_PHYSICAL_PAGES]
Definition: emsdrv.c:41
LONG WINAPI RegCloseKey(HKEY hKey)
Definition: reg.c:423
unsigned char * LPBYTE
Definition: typedefs.h:52
long LONG
Definition: pedump.c:60
smooth NULL
Definition: ftsmooth.c:416
#define TRACE(s)
Definition: solgame.cpp:4
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
LONG WINAPI RegQueryValueExW(_In_ HKEY hkeyorg, _In_ LPCWSTR name, _In_ LPDWORD reserved, _In_ LPDWORD type, _In_ LPBYTE data, _In_ LPDWORD count)
Definition: reg.c:4116
__wchar_t WCHAR
Definition: xmlstorage.h:180
_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
HANDLE GlobalHeap
Definition: dllmain.c:19
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
_CRTIMP wchar_t *__cdecl wcscat(_Inout_updates_z_(_String_length_(_Dest)+_String_length_(_Source)+1) wchar_t *_Dest, _In_z_ const wchar_t *_Source)
unsigned int ULONG
Definition: retypes.h:1
LONG WINAPI RegOpenKeyExW(HKEY hKey, LPCWSTR lpSubKey, DWORD ulOptions, REGSAM samDesired, PHKEY phkResult)
Definition: reg.c:3366
size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)
#define HeapFree(x, y, z)
Definition: compat.h:402
#define HKEY_LOCAL_MACHINE
Definition: winreg.h:12

Referenced by SockGetTdiName().

◆ SockNotifyHelperDll()

INT WSPAPI SockNotifyHelperDll ( IN PSOCKET_INFORMATION  Socket,
IN DWORD  Event 
)

◆ SockProcessAsyncSelect()

VOID WSPAPI 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 WSPAPI 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:403
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:1030
LONG AsyncEvents
Definition: msafd.h:92
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

◆ SockReenableAsyncSelectEvent()

INT WSPAPI 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:403
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().

◆ SockReleaseRwLockExclusive()

VOID WSPAPI SockReleaseRwLockExclusive ( IN PSOCK_RW_LOCK  Lock)

◆ SockReleaseRwLockShared()

VOID WSPAPI SockReleaseRwLockShared ( IN PSOCK_RW_LOCK  Lock)

◆ SockSanGetTcpipCatalogId()

VOID WSPAPI SockSanGetTcpipCatalogId ( VOID  )

◆ SockSanInitialize()

VOID WSPAPI SockSanInitialize ( VOID  )

◆ SockSetHandleContext()

INT WSPAPI SockSetHandleContext ( IN PSOCKET_INFORMATION  Socket)

◆ SockSetInformation()

INT WSPAPI SockSetInformation ( IN PSOCKET_INFORMATION  Socket,
IN ULONG  AfdInformationClass,
IN PBOOLEAN Boolean  OPTIONAL,
IN PULONG Ulong  OPTIONAL,
IN PLARGE_INTEGER LargeInteger  OPTIONAL 
)

◆ SockSocket()

INT WSPAPI SockSocket ( INT  AddressFamily,
INT  SocketType,
INT  Protocol,
LPGUID  ProviderId,
GROUP  g,
DWORD  dwFlags,
DWORD  ProviderFlags,
DWORD  ServiceFlags,
DWORD  CatalogEntryId,
PSOCKET_INFORMATION NewSocket 
)

◆ SockUpdateWindowSizes()

INT WSPAPI SockUpdateWindowSizes ( IN PSOCKET_INFORMATION  Socket,
IN BOOLEAN  Force 
)

◆ SockWaitForSingleObject()

BOOL WSPAPI SockWaitForSingleObject ( IN HANDLE  Handle,
IN SOCKET  SocketHandle,
IN DWORD  BlockingFlags,
IN DWORD  TimeoutFlags 
)

◆ WSPAccept()

SOCKET WSPAPI WSPAccept ( IN SOCKET  s,
OUT LPSOCKADDR  addr,
IN OUT LPINT  addrlen,
IN LPCONDITIONPROC  lpfnCondition,
IN DWORD  dwCallbackData,
OUT LPINT  lpErrno 
)

◆ 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().

◆ WSPAsyncSelect()

INT WSPAPI WSPAsyncSelect ( IN SOCKET  s,
IN HWND  hWnd,
IN UINT  wMsg,
IN LONG  lEvent,
OUT LPINT  lpErrno 
)

Definition at line 17 of file sndrcv.c.

22 {
23  PSOCKET_INFORMATION Socket = NULL;
24  PASYNC_DATA AsyncData;
25  BOOLEAN BlockMode;
26 
27  /* Get the Socket Structure associated to this Socket */
28  Socket = GetSocketStructure(Handle);
29  if (!Socket)
30  {
31  *lpErrno = WSAENOTSOCK;
32  return SOCKET_ERROR;
33  }
34 
35  /* Allocate the Async Data Structure to pass on to the Thread later */
36  AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(*AsyncData));
37  if (!AsyncData)
38  {
40  return INVALID_SOCKET;
41  }
42 
43  /* Change the Socket to Non Blocking */
44  BlockMode = TRUE;
46  Socket->SharedData->NonBlocking = TRUE;
47 
48  /* Deactivate WSPEventSelect */
49  if (Socket->SharedData->AsyncEvents)
50  {
51  if (WSPEventSelect(Handle, NULL, 0, lpErrno) == SOCKET_ERROR)
52  {
53  HeapFree(GetProcessHeap(), 0, AsyncData);
54  return SOCKET_ERROR;
55  }
56  }
57 
58  /* Create the Asynch Thread if Needed */
60 
61  /* Open a Handle to AFD's Async Helper */
63 
64  /* Store Socket Data */
65  Socket->SharedData->hWnd = hWnd;
66  Socket->SharedData->wMsg = wMsg;
67  Socket->SharedData->AsyncEvents = lEvent;
68  Socket->SharedData->AsyncDisabledEvents = 0;
69  Socket->SharedData->SequenceNumber++;
70 
71  /* Return if there are no more Events */
72  if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0)
73  {
74  HeapFree(GetProcessHeap(), 0, AsyncData);
75  return 0;
76  }
77 
78  /* Set up the Async Data */
79  AsyncData->ParentSocket = Socket;
80  AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
81 
82  /* Begin Async Select by using I/O Completion */
85  AsyncData,
86  0,
87  0);
88 
89  /* Return */
90  return ERROR_SUCCESS;
91 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
DWORD SequenceNumber
Definition: msafd.h:131
#define TRUE
Definition: types.h:120
#define STATUS_INSUFFICIENT_RESOURCES
Definition: udferr_usr.h:158
#define ERROR_SUCCESS
Definition: deptool.c:10
BOOLEAN SockGetAsyncSelectHelperAfdHandle(VOID)
Definition: dllmain.c:3675
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
HANDLE SockAsyncCompletionPort
Definition: dllmain.c:28
HWND hWnd
Definition: settings.c:17
DWORD SequenceNumber
Definition: msafd.h:90
BOOLEAN SockCreateOrReferenceAsyncThread(VOID)
Definition: dllmain.c:3580
VOID SockProcessQueuedAsyncSelect(PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
Definition: dllmain.c:3949
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define AFD_INFO_BLOCKING_MODE
Definition: shared.h:183
BOOLEAN NonBlocking
Definition: msafd.h:74
_In_ HANDLE Handle
Definition: extypes.h:390
#define GetProcessHeap()
Definition: compat.h:403
PVOID WINAPI HeapAlloc(HANDLE, DWORD, SIZE_T)
#define INVALID_SOCKET
Definition: winsock.h:332
FORCEINLINE DWORD MsafdReturnWithErrno(NTSTATUS Status, LPINT Errno, DWORD Received, LPDWORD ReturnedBytes)
Definition: msafd.h:546
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
int WSPAPI WSPEventSelect(IN SOCKET Handle, IN WSAEVENT hEventObject, IN long lNetworkEvents, OUT LPINT lpErrno)
Definition: event.c:17
HANDLE lEvent
Definition: tftpd.cpp:56
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: dllmain.c:3384
LONG AsyncDisabledEvents
Definition: msafd.h:93
LONG AsyncEvents
Definition: msafd.h:92
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by WSPStartup().

◆ WSPBind()

INT WSPAPI WSPBind ( IN SOCKET  s,
IN CONST SOCKADDR name,
IN INT  namelen,
OUT LPINT  lpErrno 
)

◆ WSPCancelBlockingCall()

INT WSPAPI WSPCancelBlockingCall ( OUT LPINT  lpErrno)

Definition at line 15 of file stubs.c.

17 {
19 
20  return 0;
21 }
#define UNIMPLEMENTED
Definition: stubs.c:20

Referenced by 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  s,
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:399
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:411
PSOCKET_INFORMATION SocketListHead
Definition: dllmain.c:23
HANDLE SharedDataHandle
Definition: msafd.h:101
#define HeapFree(x, y, z)
Definition: compat.h:402

Referenced by WSPAccept(), and WSPStartup().

◆ WSPConnect()

INT WSPAPI WSPConnect ( IN SOCKET  s,
IN CONST SOCKADDR name,
IN INT  namelen,
IN LPWSABUF  lpCallerData,
OUT LPWSABUF  lpCalleeData,
IN LPQOS  lpSQOS,
IN LPQOS  lpGQOS,
OUT LPINT  lpErrno 
)

◆ WSPDuplicateSocket()

INT WSPAPI WSPDuplicateSocket ( IN SOCKET  s,
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:410
#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:3584
#define INVALID_HANDLE_VALUE
Definition: compat.h:399
_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:402
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().

◆ WSPEnumNetworkEvents()

INT WSPAPI WSPEnumNetworkEvents ( IN SOCKET  s,
IN WSAEVENT  hEventObject,
OUT LPWSANETWORKEVENTS  lpNetworkEvents,
OUT LPINT  lpErrno 
)

Definition at line 133 of file event.c.

138 {
140  IO_STATUS_BLOCK IOSB;
141  PSOCKET_INFORMATION Socket = NULL;
144 
145  TRACE("Called (lpNetworkEvents %x)\n", lpNetworkEvents);
146 
147  /* Get the Socket Structure associate to this Socket*/
148  Socket = GetSocketStructure(Handle);
149  if (!Socket)
150  {
151  if (lpErrno) *lpErrno = WSAENOTSOCK;
152  return SOCKET_ERROR;
153  }
154  if (!lpNetworkEvents)
155  {
156  if (lpErrno) *lpErrno = WSAEFAULT;
157  return SOCKET_ERROR;
158  }
159 
162 
163  if( !NT_SUCCESS(Status) ) {
164  ERR("Could not make an event %x\n", Status);
165  return SOCKET_ERROR;
166  }
167 
168  EnumReq.Event = hEventObject;
169 
170  /* Send IOCTL */
172  SockEvent,
173  NULL,
174  NULL,
175  &IOSB,
177  &EnumReq,
178  sizeof(EnumReq),
179  NULL,
180  0);
181 
182  /* Wait for return */
183  if (Status == STATUS_PENDING) {
185  Status = IOSB.Status;
186  }
187 
188  NtClose (SockEvent);
189 
190  if (Status != STATUS_SUCCESS)
191  {
192  ERR("Status 0x%08x", Status);
193  return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
194  }
195 
196  lpNetworkEvents->lNetworkEvents = 0;
197 
198  /* Set Events to wait for */
199  if (EnumReq.PollEvents & AFD_EVENT_RECEIVE) {
200  lpNetworkEvents->lNetworkEvents |= FD_READ;
201  lpNetworkEvents->iErrorCode[FD_READ_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_READ_BIT]);
202  }
203 
204  if (EnumReq.PollEvents & AFD_EVENT_SEND) {
205  lpNetworkEvents->lNetworkEvents |= FD_WRITE;
206  lpNetworkEvents->iErrorCode[FD_WRITE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_WRITE_BIT]);
207  }
208 
209  if (EnumReq.PollEvents & AFD_EVENT_OOB_RECEIVE) {
210  lpNetworkEvents->lNetworkEvents |= FD_OOB;
211  lpNetworkEvents->iErrorCode[FD_OOB_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_OOB_BIT]);
212  }
213 
214  if (EnumReq.PollEvents & AFD_EVENT_ACCEPT) {
215  lpNetworkEvents->lNetworkEvents |= FD_ACCEPT;
216  lpNetworkEvents->iErrorCode[FD_ACCEPT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_ACCEPT_BIT]);
217  }
218 
219  if (EnumReq.PollEvents &
221  lpNetworkEvents->lNetworkEvents |= FD_CONNECT;
222  lpNetworkEvents->iErrorCode[FD_CONNECT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CONNECT_BIT]);
223  }
224 
225  if (EnumReq.PollEvents &
227  lpNetworkEvents->lNetworkEvents |= FD_CLOSE;
228  lpNetworkEvents->iErrorCode[FD_CLOSE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CLOSE_BIT]);
229  }
230 
231  if (EnumReq.PollEvents & AFD_EVENT_QOS) {
232  lpNetworkEvents->lNetworkEvents |= FD_QOS;
233  lpNetworkEvents->iErrorCode[FD_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_QOS_BIT]);
234  }
235 
236  if (EnumReq.PollEvents & AFD_EVENT_GROUP_QOS) {
237  lpNetworkEvents->lNetworkEvents |= FD_GROUP_QOS;
238  lpNetworkEvents->iErrorCode[FD_GROUP_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_GROUP_QOS_BIT]);
239  }
240 
241  TRACE("Leaving\n");
242 
243  return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, NULL);
244 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE SockEvent
#define WSAEFAULT
Definition: winerror.h:1945
#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
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
LONG NTSTATUS
Definition: precomp.h:26
#define AFD_EVENT_ABORT
Definition: shared.h:207
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 FD_QOS_BIT
Definition: winsock2.h:305
#define FD_CONNECT_BIT
Definition: winsock2.h:301
#define FD_READ
Definition: winsock.h:405
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_BIT
Definition: winsock2.h:297
#define FD_OOB
Definition: winsock.h:407
#define FD_WRITE
Definition: winsock.h:406
#define AFD_EVENT_CLOSE
Definition: shared.h:208
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define FD_GROUP_QOS
Definition: winsock2.h:308
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
smooth NULL
Definition: ftsmooth.c:416
#define AFD_EVENT_RECEIVE
Definition: shared.h:203
#define FD_GROUP_QOS_BIT
Definition: winsock2.h:307
#define AFD_EVENT_CONNECT
Definition: shared.h:209
#define FD_READ_BIT
Definition: winsock2.h:293
#define IOCTL_AFD_ENUM_NETWORK_EVENTS
Definition: shared.h:335
#define AFD_EVENT_SEND
Definition: shared.h:205
_In_ HANDLE Handle
Definition: extypes.h:390
#define FD_CLOSE_BIT
Definition: winsock2.h:303
#define AFD_EVENT_ACCEPT
Definition: shared.h:210
#define TRACE(s)
Definition: solgame.cpp:4
#define FD_CLOSE
Definition: winsock.h:410
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
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_EVENT_OOB_RECEIVE
Definition: shared.h:204
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
#define FD_ACCEPT_BIT
Definition: winsock2.h:299
#define AFD_EVENT_QOS
Definition: shared.h:212
INT TranslateNtStatusError(NTSTATUS Status)
Definition: dllmain.c:537
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2938
#define FD_WRITE_BIT
Definition: winsock2.h:295
NTSTATUS EventStatus[AFD_MAX_EVENTS]
Definition: shared.h:132
#define AFD_EVENT_GROUP_QOS
Definition: shared.h:213
#define FD_QOS
Definition: winsock2.h:306

Referenced by WSPStartup().

◆ WSPEventSelect()

INT WSPAPI WSPEventSelect ( IN SOCKET  s,
IN WSAEVENT  hEventObject,
IN LONG  lNetworkEvents,
OUT LPINT  lpErrno 
)

Definition at line 17 of file event.c.

22 {
23  IO_STATUS_BLOCK IOSB;
24  AFD_EVENT_SELECT_INFO EventSelectInfo;
25  PSOCKET_INFORMATION Socket = NULL;
27  BOOLEAN BlockMode;
29 
30  TRACE("WSPEventSelect (%lx) %lx %lx\n", Handle, hEventObject, lNetworkEvents);
31 
32  /* Get the Socket Structure associate to this Socket*/
33  Socket = GetSocketStructure(Handle);
34  if (!Socket)
35  {
36  if (lpErrno) *lpErrno = WSAENOTSOCK;
37  return SOCKET_ERROR;
38  }
39 
42 
43  if (!NT_SUCCESS(Status)) return SOCKET_ERROR;
44 
45  /* Set Socket to Non-Blocking */
46  BlockMode = TRUE;
48  Socket->SharedData->NonBlocking = TRUE;
49 
50  /* Deactivate Async Select if there is one */
51  if (Socket->EventObject) {
52  Socket->SharedData->hWnd = NULL;
53  Socket->SharedData->wMsg = 0;
54  Socket->SharedData->AsyncEvents = 0;
55  Socket->SharedData->SequenceNumber++; // This will kill Async Select after the next completion
56  }
57 
58  /* Set Structure Info */
59  EventSelectInfo.EventObject = hEventObject;
60  EventSelectInfo.Events = 0;
61 
62  /* Set Events to wait for */
63  if (lNetworkEvents & FD_READ) {
64  EventSelectInfo.Events |= AFD_EVENT_RECEIVE;
65  }
66 
67  if (lNetworkEvents & FD_WRITE) {
68  EventSelectInfo.Events |= AFD_EVENT_SEND;
69  }
70 
71  if (lNetworkEvents & FD_OOB) {
72  EventSelectInfo.Events |= AFD_EVENT_OOB_RECEIVE;
73  }
74 
75  if (lNetworkEvents & FD_ACCEPT) {
76  EventSelectInfo.Events |= AFD_EVENT_ACCEPT;
77  }
78 
79  if (lNetworkEvents & FD_CONNECT) {
80  EventSelectInfo.Events |= AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL;
81  }
82 
83  if (lNetworkEvents & FD_CLOSE) {
85  }
86 
87  if (lNetworkEvents & FD_QOS) {
88  EventSelectInfo.Events |= AFD_EVENT_QOS;
89  }
90 
91  if (lNetworkEvents & FD_GROUP_QOS) {
92  EventSelectInfo.Events |= AFD_EVENT_GROUP_QOS;
93  }
94 
95  /* Send IOCTL */
97  SockEvent,
98  NULL,
99  NULL,
100  &IOSB,
102  &EventSelectInfo,
103  sizeof(EventSelectInfo),
104  NULL,
105  0);
106 
107  /* Wait for return */
108  if (Status == STATUS_PENDING) {
110  Status = IOSB.Status;
111  }
112 
113  NtClose (SockEvent);
114 
115  if (Status != STATUS_SUCCESS)
116  {
117  ERR("Got status 0x%08x.\n", Status);
118  return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
119  }
120 
121  /* Set Socket Data*/
122  Socket->EventObject = hEventObject;
123  Socket->NetworkEvents = lNetworkEvents;
124 
125  TRACE("Leaving\n");
126 
127  return 0;
128 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define SOCKET_ERROR
Definition: winsock.h:333
HANDLE EventObject
Definition: msafd.h:110
HANDLE SockEvent
#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
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
LONG NTSTATUS
Definition: precomp.h:26
#define AFD_EVENT_ABORT
Definition: shared.h:207
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
DWORD SequenceNumber
Definition: msafd.h:90
#define FD_READ
Definition: winsock.h:405
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
DWORD WINAPI WaitForSingleObject(IN HANDLE hHandle, IN DWORD dwMilliseconds)
Definition: synch.c:82
#define FD_GROUP_QOS
Definition: winsock2.h:308
#define EVENT_ALL_ACCESS
Definition: isotest.c:82
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
#define AFD_EVENT_RECEIVE
Definition: shared.h:203
#define AFD_EVENT_CONNECT
Definition: shared.h:209
#define AFD_INFO_BLOCKING_MODE
Definition: shared.h:183
#define AFD_EVENT_SEND
Definition: shared.h:205
BOOLEAN NonBlocking
Definition: msafd.h:74
_In_ HANDLE Handle
Definition: extypes.h:390
#define AFD_EVENT_ACCEPT
Definition: shared.h:210
#define TRACE(s)
Definition: solgame.cpp:4
#define FD_CLOSE
Definition: winsock.h:410
#define NT_SUCCESS(StatCode)
Definition: apphelp.c:32
#define STATUS_PENDING
Definition: ntstatus.h:82
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_EVENT_OOB_RECEIVE
Definition: shared.h:204
Status
Definition: gdiplustypes.h:24
#define ERR(fmt,...)
Definition: debug.h:109
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: dllmain.c:3384
#define AFD_EVENT_QOS
Definition: shared.h:212
#define IOCTL_AFD_EVENT_SELECT
Definition: shared.h:329
LONG NetworkEvents
Definition: msafd.h:111
#define INFINITE
Definition: serial.h:102
return STATUS_SUCCESS
Definition: btrfs.c:2938
LONG AsyncEvents
Definition: msafd.h:92
#define AFD_EVENT_GROUP_QOS
Definition: shared.h:213
#define FD_QOS
Definition: winsock2.h:306

Referenced by WSPAsyncSelect(), and WSPStartup().

◆ WSPGetOverlappedResult()

BOOL WSPAPI WSPGetOverlappedResult ( IN SOCKET  s,
IN LPWSAOVERLAPPED  lpOverlapped,
OUT LPDWORD  lpcbTransfer,
IN BOOL  fWait,
OUT LPDWORD  lpdwFlags,
OUT LPINT  lpErrno 
)

Definition at line 96 of file sndrcv.c.

103 {
104  PSOCKET_INFORMATION Socket;
105  BOOL Ret;
106 
107  TRACE("Called (%x)\n", Handle);
108 
109  /* Get the Socket Structure associate to this Socket*/
110  Socket = GetSocketStructure(Handle);
111  if (!Socket)
112  {
113  if(lpErrno)
114  *lpErrno = WSAENOTSOCK;
115  return FALSE;
116  }
117  if (!lpOverlapped || !lpdwBytes || !lpdwFlags)
118  {
119  if (lpErrno)
120  *lpErrno = WSAEFAULT;
121  return FALSE;
122  }
123  Ret = GetOverlappedResult((HANDLE)Handle, lpOverlapped, lpdwBytes, fWait);
124 
125  if (Ret)
126  {
127  *lpdwFlags = 0;
128 
129  /* Re-enable Async Event */
133  }
134 
135  return Ret;
136 }
#define WSAENOTSOCK
Definition: winerror.h:1951
#define WSAEFAULT
Definition: winerror.h:1945
VOID SockReenableAsyncSelectEvent(IN PSOCKET_INFORMATION Socket, IN ULONG Event)
Definition: dllmain.c:3983
BOOL WINAPI GetOverlappedResult(IN HANDLE hFile, IN LPOVERLAPPED lpOverlapped, OUT LPDWORD lpNumberOfBytesTransferred, IN BOOL bWait)
Definition: iocompl.c:204
PSOCKET_INFORMATION GetSocketStructure(SOCKET Handle)
Definition: dllmain.c:3507
#define FD_READ
Definition: winsock.h:405
#define FD_OOB
Definition: winsock.h:407
#define FD_WRITE
Definition: winsock.h:406
unsigned int BOOL
Definition: ntddk_ex.h:94
_In_ HANDLE Handle
Definition: extypes.h:390
#define TRACE(s)
Definition: solgame.cpp:4
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:90

Referenced by WSPStartup().

◆ WSPGetPeerName()

INT WSPAPI WSPGetPeerName ( IN SOCKET  s,
OUT LPSOCKADDR  name,
IN OUT LPINT  namelen,
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:402

Referenced by WSPStartup().

◆ WSPGetQOSByName()

BOOL WSPAPI WSPGetQOSByName ( IN SOCKET  s,
IN OUT LPWSABUF  lpQOSName,
OUT LPQOS  lpQOS,
OUT LPINT  lpErrno 
)

Definition at line 26 of file stubs.c.

31 {
33 
34  return FALSE;
35 }
#define UNIMPLEMENTED
Definition: stubs.c:20

Referenced by WSPStartup().

◆ WSPGetSockName()

INT WSPAPI WSPGetSockName ( IN SOCKET  s,
OUT LPSOCKADDR  name,
IN OUT LPINT  namelen,
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:402

Referenced by WSPStartup().

◆ WSPGetSockOpt()

INT WSPAPI WSPGetSockOpt ( IN SOCKET  s,
IN INT  level,
IN INT  optname,
OUT CHAR FAR optval,
IN OUT LPINT  optlen,
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  s,
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
PSOCK_SHARED_INFO SharedData
Definition: msafd.h:100
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
PHELPER_DATA HelperData
Definition: msafd.h:103
void * PVOID
Definition: retypes.h:9
#define AFD_INFO_BLOCKING_MODE
Definition: shared.h:183
#define AFD_INFO_RECEIVE_CONTENT_SIZE
Definition: shared.h:188
BOOLEAN NonBlocking
Definition: msafd.h:74
_In_ HANDLE Handle
Definition: extypes.h:390
#define IS_INTRESOURCE(i)
Definition: winuser.h:580
INT SocketType
Definition: msafd.h:57
unsigned long DWORD
Definition: ntddk_ex.h:95
VOID WSPAPI WSPGetAcceptExSockaddrs(IN PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT struct sockaddr **LocalSockaddr, OUT LPINT LocalSockaddrLength, OUT struct sockaddr **RemoteSockaddr, OUT LPINT RemoteSockaddrLength)
Definition: stubs.c:104
BOOL WINAPI PostQueuedCompletionStatus(IN HANDLE CompletionHandle, IN DWORD dwNumberOfBytesTransferred, IN ULONG_PTR dwCompletionKey, IN LPOVERLAPPED lpOverlapped)
Definition: iocompl.c:175
HANDLE TdiConnectionHandle
Definition: msafd.h:108
HANDLE TdiAddressHandle
Definition: msafd.h:107
#define FIONBIO
Definition: winsock.h:149
#define ERR(fmt,...)
Definition: debug.h:109
PWSH_IOCTL WSHIoctl
Definition: helpers.h:33
_In_ HANDLE _In_ DWORD _In_ DWORD _Inout_opt_ LPOVERLAPPED lpOverlapped
Definition: mswsock.h:90
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: dllmain.c:3384
LONG AsyncDisabledEvents
Definition: msafd.h:93
unsigned int * PULONG
Definition: retypes.h:1
BOOL WINAPI IsEqualGUID(REFGUID rguid1, REFGUID rguid2)
Definition: compobj.c:4112
BOOL WSPAPI WSPConnectEx(IN SOCKET s, IN const struct sockaddr *name, IN int namelen, IN PVOID lpSendBuffer, IN DWORD dwSendDataLength, OUT LPDWORD lpdwBytesSent, IN OUT LPOVERLAPPED lpOverlapped)
Definition: stubs.c:75
#define WSAID_ACCEPTEX
Definition: mswsock.h:74
unsigned int ULONG
Definition: retypes.h:1
LONG NetworkEvents
Definition: msafd.h:111
#define SOCK_STREAM
Definition: tcpip.h:118
PVOID HelperContext
Definition: msafd.h:104
struct _SOCKET_ADDRESS_LIST SOCKET_ADDRESS_LIST
#define FIONREAD
Definition: winsock.h:247
LONG AsyncEvents
Definition: msafd.h:92
BOOL WSPAPI WSPDisconnectEx(IN SOCKET hSocket, IN LPOVERLAPPED lpOverlapped, IN DWORD dwFlags, IN DWORD reserved)
Definition: stubs.c:91
_In_ DWORD dwIoControlCode
Definition: winddi.h:1700

Referenced by WSPStartup().

◆ WSPJoinLeaf()

SOCKET WSPAPI WSPJoinLeaf ( IN SOCKET  s,
IN CONST SOCKADDR name,
IN INT  namelen,
IN LPWSABUF  lpCallerData,
OUT LPWSABUF  lpCalleeData,
IN LPQOS  lpSQOS,
IN LPQOS  lpGQOS,
IN DWORD  dwFlags,
OUT LPINT  lpErrno 
)

Definition at line 40 of file stubs.c.

50 {
52 
53  return (SOCKET)0;
54 }
#define UNIMPLEMENTED
Definition: stubs.c:20
UINT_PTR SOCKET
Definition: winsock.h:47

Referenced by WSPStartup().

◆ WSPListen()

INT WSPAPI WSPListen ( IN SOCKET  s,
IN INT  backlog,
OUT LPINT  lpErrno 
)

◆ WSPRecv()

INT WSPAPI WSPRecv ( IN SOCKET  s,
IN OUT LPWSABUF  lpBuffers,
IN DWORD  dwBufferCount,
OUT LPDWORD  lpNumberOfBytesRecvd,
IN OUT LPDWORD  lpFlags,
IN LPWSAOVERLAPPED  lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine,
IN LPWSATHREADID  lpThreadId,
OUT LPINT  lpErrno 
)

◆ WSPRecvDisconnect()

INT WSPAPI WSPRecvDisconnect ( IN SOCKET  s,
OUT LPWSABUF  lpInboundDisconnectData,
OUT LPINT  lpErrno 
)

Definition at line 919 of file sndrcv.c.

922 {
924  return 0;
925 }
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by WSPStartup().

◆ WSPRecvFrom()

INT WSPAPI WSPRecvFrom ( IN SOCKET  s,
IN OUT LPWSABUF  lpBuffers,
IN DWORD  dwBufferCount,
OUT LPDWORD  lpNumberOfBytesRecvd,
IN OUT LPDWORD  lpFlags,
OUT LPSOCKADDR  lpFrom,
IN OUT LPINT  lpFromlen,
IN LPWSAOVERLAPPED  lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine,
IN LPWSATHREADID  lpThreadId,
OUT LPINT  lpErrno 
)

◆ WSPSelect()

INT WSPAPI WSPSelect ( IN INT  nfds,
IN OUT LPFD_SET  readfds,
IN OUT LPFD_SET  writefds,
IN OUT LPFD_SET  exceptfds,
IN CONST LPTIMEVAL  timeout,
OUT LPINT  lpErrno 
)

◆ WSPSend()

INT WSPAPI WSPSend ( IN SOCKET  s,
IN LPWSABUF  lpBuffers,
IN DWORD  dwBufferCount,
OUT LPDWORD  lpNumberOfBytesSent,
IN DWORD  dwFlags,
IN LPWSAOVERLAPPED  lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine,
IN LPWSATHREADID  lpThreadId,
OUT LPINT  lpErrno 
)

◆ WSPSendDisconnect()

INT WSPAPI WSPSendDisconnect ( IN SOCKET  s,
IN LPWSABUF  lpOutboundDisconnectData,
OUT LPINT  lpErrno 
)

Definition at line 931 of file sndrcv.c.

934 {
936  return 0;
937 }
#define UNIMPLEMENTED
Definition: debug.h:114

Referenced by WSPStartup().

◆ WSPSendTo()

INT WSPAPI WSPSendTo ( IN SOCKET  s,
IN LPWSABUF  lpBuffers,
IN DWORD  dwBufferCount,
OUT LPDWORD  lpNumberOfBytesSent,
IN DWORD  dwFlags,
IN CONST SOCKADDR lpTo,
IN INT  iTolen,
IN LPWSAOVERLAPPED  lpOverlapped,
IN LPWSAOVERLAPPED_COMPLETION_ROUTINE  lpCompletionRoutine,
IN LPWSATHREADID  lpThreadId,
OUT LPINT  lpErrno 
)

◆ WSPSetSockOpt()

INT WSPAPI WSPSetSockOpt ( IN SOCKET  s,
IN INT  level,
IN INT  optname,
IN CONST CHAR FAR optval,
IN INT  optlen,
OUT LPINT  lpErrno 
)

Definition at line 2776 of file dllmain.c.

2783 {
2784  PSOCKET_INFORMATION Socket;
2785  INT Errno;
2786 
2787  /* Get the Socket Structure associate to this Socket*/
2788  Socket = GetSocketStructure(s);
2789  if (Socket == NULL)
2790  {
2791  if (lpErrno) *lpErrno = WSAENOTSOCK;
2792  return SOCKET_ERROR;
2793  }
2794  if (!optval)
2795  {
2796  if (lpErrno) *lpErrno = WSAEFAULT;
2797  return SOCKET_ERROR;
2798  }
2799 
2800 
2801  /* FIXME: We should handle some more cases here */
2802  if (level == SOL_SOCKET)
2803  {
2804  switch (optname)
2805  {
2806  case SO_BROADCAST:
2807  if (optlen < sizeof(BOOL))
2808  {
2809  if (lpErrno) *lpErrno = WSAEFAULT;
2810  return SOCKET_ERROR;
2811  }
2812  Socket->SharedData->Broadcast = (*optval != 0) ? 1 : 0;
2813  return NO_ERROR;
2814 
2815  case SO_OOBINLINE:
2816  if (optlen < sizeof(BOOL))
2817  {
2818  if (lpErrno) *lpErrno = WSAEFAULT;
2819  return SOCKET_ERROR;
2820  }
2821  Socket->SharedData->OobInline = (*optval != 0) ? 1 : 0;
2822  return NO_ERROR;
2823 
2824  case SO_DONTLINGER:
2825  if (optlen < sizeof(BOOL))
2826  {
2827  if (lpErrno) *lpErrno = WSAEFAULT;
2828  return SOCKET_ERROR;
2829  }
2830  Socket->SharedData->LingerData.l_onoff = (*optval != 0) ? 0 : 1;
2831  return NO_ERROR;
2832 
2833  case SO_REUSEADDR:
2834  if (optlen < sizeof(BOOL))
2835  {
2836  if (lpErrno) *lpErrno = WSAEFAULT;
2837  return SOCKET_ERROR;
2838  }
2839  Socket->SharedData->ReuseAddresses = (*optval != 0) ? 1 : 0;
2840  return NO_ERROR;
2841 
2842  case SO_EXCLUSIVEADDRUSE:
2843  if (optlen < sizeof(BOOL))
2844  {
2845  if (lpErrno) *lpErrno = WSAEFAULT;
2846  return SOCKET_ERROR;
2847  }
2848  Socket->SharedData->ExclusiveAddressUse = (*optval != 0) ? 1 : 0;
2849  return NO_ERROR;
2850 
2851  case SO_LINGER:
2852  if (optlen < sizeof(struct linger))
2853  {
2854  if (lpErrno) *lpErrno = WSAEFAULT;
2855  return SOCKET_ERROR;