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_STATE *	PSOCKET_STATE
typedef struct _SOCK_SHARED_INFO	SOCK_SHARED_INFO
typedef struct _SOCK_SHARED_INFO *	PSOCK_SHARED_INFO
typedef struct _HELPER_DATA	HELPER_DATA
typedef struct _HELPER_DATA *	PHELPER_DATA
typedef struct _ASYNC_DATA	ASYNC_DATA
typedef struct _ASYNC_DATA *	PASYNC_DATA
typedef struct _SOCKET_INFORMATION	SOCKET_INFORMATION
typedef struct _SOCKET_INFORMATION *	PSOCKET_INFORMATION
typedef struct _SOCKET_CONTEXT	SOCKET_CONTEXT
typedef struct _SOCKET_CONTEXT *	PSOCKET_CONTEXT
typedef struct _SOCK_RW_LOCK	SOCK_RW_LOCK
typedef struct _SOCK_RW_LOCK *	PSOCK_RW_LOCK
typedef struct _WINSOCK_TEB_DATA	WINSOCK_TEB_DATA
typedef struct _WINSOCK_TEB_DATA *	PWINSOCK_TEB_DATA
typedef INT(WINAPI *	PICF_CONNECT) (PVOID IcfData)
typedef struct _SOCK_ICF_DATA	SOCK_ICF_DATA
typedef struct _SOCK_ICF_DATA *	PSOCK_ICF_DATA
typedef PVOID(NTAPI *	PRTL_HEAP_ALLOCATE) (IN HANDLE Heap, IN ULONG Flags, IN ULONG Size)
typedef VOID(WSPAPI *	PASYNC_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_ROOT |\
                                 WSA_FLAG_MULTIPOINT_C_LEAF |\
                                 WSA_FLAG_MULTIPOINT_D_ROOT |\
                                 WSA_FLAG_MULTIPOINT_D_LEAF)

Definition at line 18 of file msafdlib.h.

Typedef Documentation

ASYNC_DATA

typedef struct _ASYNC_DATA ASYNC_DATA

HELPER_DATA

typedef struct _HELPER_DATA HELPER_DATA

PASYNC_COMPLETION_ROUTINE

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

Definition at line 438 of file msafdlib.h.

PASYNC_DATA

typedef struct _ASYNC_DATA * PASYNC_DATA

PHELPER_DATA

typedef struct _HELPER_DATA * PHELPER_DATA

PICF_CONNECT

typedef INT(WINAPI * PICF_CONNECT) (PVOID IcfData)

Definition at line 169 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 181 of file msafdlib.h.

PSOCK_ICF_DATA

typedef struct _SOCK_ICF_DATA * PSOCK_ICF_DATA

PSOCK_RW_LOCK

typedef struct _SOCK_RW_LOCK * PSOCK_RW_LOCK

PSOCK_SHARED_INFO

typedef struct _SOCK_SHARED_INFO * PSOCK_SHARED_INFO

PSOCKET_CONTEXT

typedef struct _SOCKET_CONTEXT * PSOCKET_CONTEXT

PSOCKET_INFORMATION

typedef struct _SOCKET_INFORMATION * PSOCKET_INFORMATION

PSOCKET_STATE

typedef enum _SOCKET_STATE * PSOCKET_STATE

PWINSOCK_TEB_DATA

typedef struct _WINSOCK_TEB_DATA * PWINSOCK_TEB_DATA

SOCK_ICF_DATA

typedef struct _SOCK_ICF_DATA SOCK_ICF_DATA

SOCK_RW_LOCK

typedef struct _SOCK_RW_LOCK SOCK_RW_LOCK

SOCK_SHARED_INFO

typedef struct _SOCK_SHARED_INFO SOCK_SHARED_INFO

SOCKET_CONTEXT

typedef struct _SOCKET_CONTEXT SOCKET_CONTEXT

SOCKET_INFORMATION

typedef struct _SOCKET_INFORMATION SOCKET_INFORMATION

SOCKET_STATE

typedef enum _SOCKET_STATE SOCKET_STATE

WINSOCK_TEB_DATA

typedef struct _WINSOCK_TEB_DATA WINSOCK_TEB_DATA

Enumeration Type Documentation

_SOCKET_STATE

enum _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.

{
    SocketUndefined = -1,
    SocketOpen,
    SocketBound,
    SocketBoundUdp,
    SocketConnected,
    SocketClosed
} 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 3763 of file dllmain.c.

{
    PVOID AsyncContext;
    PASYNC_COMPLETION_ROUTINE AsyncCompletionRoutine;
    IO_STATUS_BLOCK IOSB;
    NTSTATUS Status;
 
    /* Make the Thread Higher Priority */
    SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_ABOVE_NORMAL);
 
    /* Do a KQUEUE/WorkItem Style Loop, thanks to IoCompletion Ports */
    do
    {
        Status =  NtRemoveIoCompletion (SockAsyncCompletionPort,
                                        (PVOID*)&AsyncCompletionRoutine,
                                        &AsyncContext,
                                        &IOSB,
                                        NULL);
        /* Call the Async Function */
        if (NT_SUCCESS(Status))
        {
            (*AsyncCompletionRoutine)(AsyncContext, &IOSB);
        }
        else
        {
            /* It Failed, sleep for a second */
            Sleep(1000);
        }
    } while ((Status != STATUS_TIMEOUT));
 
    /* The Thread has Ended */
    return 0;
}

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.

{
    /* Dereference and see if it's the last count */
    if (!InterlockedDecrement(&Helper->RefCount))
    {
        /* Destroy the Helper DLL */
        SockFreeHelperDll(Helper);
    }
}

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.

{
    /* Make sure we aren't terminating and get our thread data */
    if (!(SockProcessTerminating) &&
        (SockWspStartupCount > 0) &&
        ((*ThreadData = NtCurrentTeb()->WinSockData)))
    {
        /* Everything is good, return */
        return NO_ERROR;
    }
 
    /* Something didn't work out, use the slow path */
    return SockEnterApiSlow(ThreadData);
}

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

)

Referenced by SockDereferenceHelperDll().

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.

{
    PHELPER_DATA        HelperData;
    PWSTR               HelperDllName;
    PWSTR               FullHelperDllName;
    PWSTR               HelperKey;
    HKEY                KeyHandle;
    ULONG               DataSize;
    LONG                Status;
 
    /* Allocate space for the Helper Structure and TransportName */
    HelperData = HeapAlloc(GlobalHeap, 0, sizeof(*HelperData) + (wcslen(TransportName) + 1) * sizeof(WCHAR));
 
    /* Check for error */
    if (HelperData == NULL) {
        ERR("Buffer allocation failed\n");
        return WSAEINVAL;
    }
 
    /* Allocate Space for the Helper DLL Key */
    HelperKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
 
    /* Check for error */
    if (HelperKey == NULL) {
        ERR("Buffer allocation failed\n");
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    /* Generate the right key name */
    wcscpy(HelperKey, L"System\\CurrentControlSet\\Services\\");
    wcscat(HelperKey, TransportName);
    wcscat(HelperKey, L"\\Parameters\\Winsock");
 
    /* Open the Key */
    Status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HelperKey, 0, KEY_READ, &KeyHandle);
 
    HeapFree(GlobalHeap, 0, HelperKey);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading helper DLL parameters\n");
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    /* Read Size of SockAddr Structures */
    DataSize = sizeof(HelperData->MinWSAddressLength);
    HelperData->MinWSAddressLength = 16;
    RegQueryValueExW (KeyHandle,
                      L"MinSockaddrLength",
                      NULL,
                      NULL,
                      (LPBYTE)&HelperData->MinWSAddressLength,
                      &DataSize);
    DataSize = sizeof(HelperData->MinWSAddressLength);
    HelperData->MaxWSAddressLength = 16;
    RegQueryValueExW (KeyHandle,
                      L"MaxSockaddrLength",
                      NULL,
                      NULL,
                      (LPBYTE)&HelperData->MaxWSAddressLength,
                      &DataSize);
 
    /* Size of TDI Structures */
    HelperData->MinTDIAddressLength = HelperData->MinWSAddressLength + 6;
    HelperData->MaxTDIAddressLength = HelperData->MaxWSAddressLength + 6;
 
    /* Read Delayed Acceptance Setting */
    DataSize = sizeof(DWORD);
    HelperData->UseDelayedAcceptance = FALSE;
    RegQueryValueExW (KeyHandle,
                      L"UseDelayedAcceptance",
                      NULL,
                      NULL,
                      (LPBYTE)&HelperData->UseDelayedAcceptance,
                      &DataSize);
 
    /* Allocate Space for the Helper DLL Names */
    HelperDllName = HeapAlloc(GlobalHeap, 0, 512);
 
    /* Check for error */
    if (HelperDllName == NULL) {
        ERR("Buffer allocation failed\n");
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    FullHelperDllName = HeapAlloc(GlobalHeap, 0, 512);
 
    /* Check for error */
    if (FullHelperDllName == NULL) {
        ERR("Buffer allocation failed\n");
        HeapFree(GlobalHeap, 0, HelperDllName);
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    /* Get the name of the Helper DLL*/
    DataSize = 512;
    Status = RegQueryValueExW (KeyHandle,
                               L"HelperDllName",
                               NULL,
                               NULL,
                               (LPBYTE)HelperDllName,
                               &DataSize);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading helper DLL parameters\n");
        HeapFree(GlobalHeap, 0, FullHelperDllName);
        HeapFree(GlobalHeap, 0, HelperDllName);
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    /* Get the Full name, expanding Environment Strings */
    ExpandEnvironmentStringsW (HelperDllName,
                               FullHelperDllName,
                               256);
 
    /* Load the DLL */
    HelperData->hInstance = LoadLibraryW(FullHelperDllName);
 
    HeapFree(GlobalHeap, 0, HelperDllName);
    HeapFree(GlobalHeap, 0, FullHelperDllName);
 
    if (HelperData->hInstance == NULL) {
        ERR("Error loading helper DLL\n");
        HeapFree(GlobalHeap, 0, HelperData);
        return WSAEINVAL;
    }
 
    /* Close Key */
    RegCloseKey(KeyHandle);
 
    /* Get the Pointers to the Helper Routines */
    HelperData->WSHOpenSocket = (PWSH_OPEN_SOCKET)
                                    GetProcAddress(HelperData->hInstance,
                                    "WSHOpenSocket");
    HelperData->WSHOpenSocket2 = (PWSH_OPEN_SOCKET2)
                                    GetProcAddress(HelperData->hInstance,
                                    "WSHOpenSocket2");
    HelperData->WSHJoinLeaf = (PWSH_JOIN_LEAF)
                                GetProcAddress(HelperData->hInstance,
                                "WSHJoinLeaf");
    HelperData->WSHNotify = (PWSH_NOTIFY)
                                GetProcAddress(HelperData->hInstance, "WSHNotify");
    HelperData->WSHGetSocketInformation = (PWSH_GET_SOCKET_INFORMATION)
                                            GetProcAddress(HelperData->hInstance,
                                            "WSHGetSocketInformation");
    HelperData->WSHSetSocketInformation = (PWSH_SET_SOCKET_INFORMATION)
                                            GetProcAddress(HelperData->hInstance,
                                            "WSHSetSocketInformation");
    HelperData->WSHGetSockaddrType = (PWSH_GET_SOCKADDR_TYPE)
                                        GetProcAddress(HelperData->hInstance,
                                        "WSHGetSockaddrType");
    HelperData->WSHGetWildcardSockaddr = (PWSH_GET_WILDCARD_SOCKADDR)
                                            GetProcAddress(HelperData->hInstance,
                                            "WSHGetWildcardSockaddr");
    HelperData->WSHGetBroadcastSockaddr = (PWSH_GET_BROADCAST_SOCKADDR)
                                            GetProcAddress(HelperData->hInstance,
                                            "WSHGetBroadcastSockaddr");
    HelperData->WSHAddressToString = (PWSH_ADDRESS_TO_STRING)
                                        GetProcAddress(HelperData->hInstance,
                                        "WSHAddressToString");
    HelperData->WSHStringToAddress = (PWSH_STRING_TO_ADDRESS)
                                        GetProcAddress(HelperData->hInstance,
                                        "WSHStringToAddress");
    HelperData->WSHIoctl = (PWSH_IOCTL)
                            GetProcAddress(HelperData->hInstance,
                            "WSHIoctl");
 
    /* Save the Mapping Structure and transport name */
    HelperData->Mapping = Mapping;
    wcscpy(HelperData->TransportName, TransportName);
 
    /* Increment Reference Count */
    HelperData->RefCount = 1;
 
    /* Add it to our list */
    InsertHeadList(&SockHelpersListHead, &HelperData->Helpers);
 
    /* Return Pointers */
    *HelperDllData = HelperData;
    return 0;
}

Referenced by SockGetTdiName().

SockLoadTransportList()

INT WSPAPI SockLoadTransportList

(

PWSTR *

TransportList

)

Definition at line 232 of file helpers.c.

{
    ULONG   TransportListSize;
    HKEY    KeyHandle;
    LONG    Status;
 
    TRACE("Called\n");
 
    /* Open the Transports Key */
    Status = RegOpenKeyExW (HKEY_LOCAL_MACHINE,
                            L"SYSTEM\\CurrentControlSet\\Services\\Winsock\\Parameters",
                            0,
                            KEY_READ,
                            &KeyHandle);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport list registry\n");
        return WSAEINVAL;
    }
 
    /* Get the Transport List Size */
    Status = RegQueryValueExW(KeyHandle,
                              L"Transports",
                              NULL,
                              NULL,
                              NULL,
                              &TransportListSize);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport list registry\n");
        return WSAEINVAL;
    }
 
    /* Allocate Memory for the Transport List */
    *TransportList = HeapAlloc(GlobalHeap, 0, TransportListSize);
 
    /* Check for error */
    if (*TransportList == NULL) {
        ERR("Buffer allocation failed\n");
        return WSAEINVAL;
    }
 
    /* Get the Transports */
    Status = RegQueryValueExW (KeyHandle,
                               L"Transports",
                               NULL,
                               NULL,
                               (LPBYTE)*TransportList,
                               &TransportListSize);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport list registry\n");
        HeapFree(GlobalHeap, 0, *TransportList);
        return WSAEINVAL;
    }
 
    /* Close key and return */
    RegCloseKey(KeyHandle);
    return 0;
}

Referenced by SockGetTdiName().

SockLoadTransportMapping()

INT WSPAPI SockLoadTransportMapping	(	PWSTR	TransportName,
		PWINSOCK_MAPPING *	Mapping
	)

Definition at line 161 of file helpers.c.

{
    PWSTR               TransportKey;
    HKEY                KeyHandle;
    ULONG               MappingSize;
    LONG                Status;
 
    TRACE("TransportName %ws\n", TransportName);
 
    /* Allocate a Buffer */
    TransportKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
 
    /* Check for error */
    if (TransportKey == NULL) {
        ERR("Buffer allocation failed\n");
        return WSAEINVAL;
    }
 
    /* Generate the right key name */
    wcscpy(TransportKey, L"System\\CurrentControlSet\\Services\\");
    wcscat(TransportKey, TransportName);
    wcscat(TransportKey, L"\\Parameters\\Winsock");
 
    /* Open the Key */
    Status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, TransportKey, 0, KEY_READ, &KeyHandle);
 
    /* We don't need the Transport Key anymore */
    HeapFree(GlobalHeap, 0, TransportKey);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport mapping registry\n");
        return WSAEINVAL;
    }
 
    /* Find out how much space we need for the Mapping */
    Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, NULL, &MappingSize);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport mapping registry\n");
        return WSAEINVAL;
    }
 
    /* Allocate Memory for the Mapping */
    *Mapping = HeapAlloc(GlobalHeap, 0, MappingSize);
 
    /* Check for error */
    if (*Mapping == NULL) {
        ERR("Buffer allocation failed\n");
        return WSAEINVAL;
    }
 
    /* Read the Mapping */
    Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, (LPBYTE)*Mapping, &MappingSize);
 
    /* Check for error */
    if (Status) {
        ERR("Error reading transport mapping registry\n");
        HeapFree(GlobalHeap, 0, *Mapping);
        return WSAEINVAL;
    }
 
    /* Close key and return */
    RegCloseKey(KeyHandle);
    return 0;
}

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 3988 of file dllmain.c.

{
 
    ULONG lNetworkEvents;
    NTSTATUS Status;
 
    /* Set up the Async Data Event Info */
    AsyncData->AsyncSelectInfo.Timeout.HighPart = 0x7FFFFFFF;
    AsyncData->AsyncSelectInfo.Timeout.LowPart = 0xFFFFFFFF;
    AsyncData->AsyncSelectInfo.HandleCount = 1;
    AsyncData->AsyncSelectInfo.Exclusive = TRUE;
    AsyncData->AsyncSelectInfo.Handles[0].Handle = Socket->Handle;
    AsyncData->AsyncSelectInfo.Handles[0].Events = 0;
 
    /* Remove unwanted events */
    lNetworkEvents = Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents);
 
    /* Set Events to wait for */
    if (lNetworkEvents & FD_READ)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_RECEIVE;
    }
 
    if (lNetworkEvents & FD_WRITE)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_SEND;
    }
 
    if (lNetworkEvents & FD_OOB)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_OOB_RECEIVE;
    }
 
    if (lNetworkEvents & FD_ACCEPT)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_ACCEPT;
    }
 
    /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
    if (lNetworkEvents & FD_CONNECT)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL;
    }
 
    if (lNetworkEvents & FD_CLOSE)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE;
    }
 
    if (lNetworkEvents & FD_QOS)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_QOS;
    }
 
    if (lNetworkEvents & FD_GROUP_QOS)
    {
        AsyncData->AsyncSelectInfo.Handles[0].Events |= AFD_EVENT_GROUP_QOS;
    }
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile (SockAsyncHelperAfdHandle,
                                    NULL,
                                    NULL,
                                    AsyncData,
                                    &AsyncData->IoStatusBlock,
                                    IOCTL_AFD_SELECT,
                                    &AsyncData->AsyncSelectInfo,
                                    sizeof(AsyncData->AsyncSelectInfo),
                                    &AsyncData->AsyncSelectInfo,
                                    sizeof(AsyncData->AsyncSelectInfo));
 
    /* I/O Manager Won't call the completion routine, let's do it manually */
    if (NT_SUCCESS(Status))
    {
        return;
    }
    else
    {
        AsyncData->IoStatusBlock.Status = Status;
        SockAsyncSelectCompletionRoutine(AsyncData, &AsyncData->IoStatusBlock);
    }
}

Referenced by SockAsyncSelectCompletionRoutine(), and SockProcessQueuedAsyncSelect().

SockProcessQueuedAsyncSelect()

VOID WSPAPI SockProcessQueuedAsyncSelect	(	PVOID	Context,
		PIO_STATUS_BLOCK	IoStatusBlock
	)

Definition at line 4071 of file dllmain.c.

{
    PASYNC_DATA AsyncData = Context;
    BOOL FreeContext = TRUE;
    PSOCKET_INFORMATION Socket;
 
    /* Get the Socket */
    Socket = AsyncData->ParentSocket;
 
    /* If someone closed it, stop the function */
    if (Socket->SharedData->State != SocketClosed)
    {
        /* Check if the Sequence Number changed by now, in which case quit */
        if (AsyncData->SequenceNumber == Socket->SharedData->SequenceNumber)
        {
            /* Do the actual select, if needed */
            if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)))
            {
                SockProcessAsyncSelect(Socket, AsyncData);
                FreeContext = FALSE;
            }
        }
    }
 
    /* Free the Context */
    if (FreeContext)
    {
        HeapFree(GetProcessHeap(), 0, AsyncData);
    }
 
    return;
}

Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

SockReenableAsyncSelectEvent()

INT WSPAPI SockReenableAsyncSelectEvent	(	IN PSOCKET_INFORMATION	Socket,
		IN ULONG	Event
	)

Definition at line 4105 of file dllmain.c.

{
    PASYNC_DATA AsyncData;
 
    /* Make sure the event is actually disabled */
    if (!(Socket->SharedData->AsyncDisabledEvents & Event))
    {
        return;
    }
 
    /* Re-enable it */
    Socket->SharedData->AsyncDisabledEvents &= ~Event;
 
    /* Return if no more events are being polled */
    if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
    {
        return;
    }
 
    /* Wait on new events */
    AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(ASYNC_DATA));
    if (!AsyncData) return;
 
    /* Create the Asynch Thread if Needed */
    SockCreateOrReferenceAsyncThread();
 
    /* Increase the sequence number to stop anything else */
    Socket->SharedData->SequenceNumber++;
 
    /* Set up the Async Data */
    AsyncData->ParentSocket = Socket;
    AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
 
    /* Begin Async Select by using I/O Completion */
    NtSetIoCompletion(SockAsyncCompletionPort,
                     (PVOID)&SockProcessQueuedAsyncSelect,
                     AsyncData,
                     0,
                     0);
 
    /* All done */
    return;
}

Referenced by MsafdConnectAPC(), MsafdRecvAPC(), MsafdSendAPC(), 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 3165 of file dllmain.c.

{
    SIZE_T size;
    WCHAR buffer[54]; /* 32 digits + 7':' + '[' + '%" + 5 digits + ']:' + 5 digits + '\0' */
    WCHAR *p;
 
    if (!lpsaAddress || !lpszAddressString || !lpdwAddressStringLength)
    {
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    switch (lpsaAddress->sa_family)
    {
        case AF_INET:
            if (dwAddressLength < sizeof(SOCKADDR_IN))
            {
                if (lpErrno) *lpErrno = WSAEINVAL;
                return SOCKET_ERROR;
            }
            swprintf(buffer,
                     L"%u.%u.%u.%u:%u",
                     (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 24 & 0xff),
                     (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 16 & 0xff),
                     (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) >> 8 & 0xff),
                     (unsigned int)(ntohl(((SOCKADDR_IN *)lpsaAddress)->sin_addr.s_addr) & 0xff),
                     ntohs(((SOCKADDR_IN *)lpsaAddress)->sin_port));
 
            p = wcschr(buffer, L':');
            if (!((SOCKADDR_IN *)lpsaAddress)->sin_port)
            {
                *p = 0;
            }
            break;
        default:
            if (lpErrno) *lpErrno = WSAEINVAL;
            return SOCKET_ERROR;
    }
 
    size = wcslen(buffer) + 1;
 
    if (*lpdwAddressStringLength < size)
    {
        *lpdwAddressStringLength = size;
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    *lpdwAddressStringLength = size;
    wcscpy(lpszAddressString, buffer);
    return 0;
}

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.

{
    PSOCKET_INFORMATION Socket = NULL;
    PASYNC_DATA                 AsyncData;
    BOOLEAN                     BlockMode;
 
    /* Get the Socket Structure associated to this Socket */
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
       *lpErrno = WSAENOTSOCK;
       return SOCKET_ERROR;
    }
 
    /* Allocate the Async Data Structure to pass on to the Thread later */
    AsyncData = HeapAlloc(GetProcessHeap(), 0, sizeof(*AsyncData));
    if (!AsyncData)
    {
        MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL );
        return INVALID_SOCKET;
    }
 
    /* Change the Socket to Non Blocking */
    BlockMode = TRUE;
    SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &BlockMode, NULL, NULL, NULL, NULL);
    Socket->SharedData->NonBlocking = TRUE;
 
    /* Deactivate WSPEventSelect */
    if (Socket->SharedData->AsyncEvents)
    {
        if (WSPEventSelect(Handle, NULL, 0, lpErrno) == SOCKET_ERROR)
        {
            HeapFree(GetProcessHeap(), 0, AsyncData);
            return SOCKET_ERROR;
        }
    }
 
    /* Create the Asynch Thread if Needed */
    SockCreateOrReferenceAsyncThread();
 
    /* Open a Handle to AFD's Async Helper */
    SockGetAsyncSelectHelperAfdHandle();
 
    /* Store Socket Data */
    Socket->SharedData->hWnd = hWnd;
    Socket->SharedData->wMsg = wMsg;
    Socket->SharedData->AsyncEvents = lEvent;
    Socket->SharedData->AsyncDisabledEvents = 0;
    Socket->SharedData->SequenceNumber++;
 
    /* Return if there are no more Events */
    if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0)
    {
        HeapFree(GetProcessHeap(), 0, AsyncData);
        return 0;
    }
 
    /* Set up the Async Data */
    AsyncData->ParentSocket = Socket;
    AsyncData->SequenceNumber = Socket->SharedData->SequenceNumber;
 
    /* Begin Async Select by using I/O Completion */
    NtSetIoCompletion(SockAsyncCompletionPort,
                      (PVOID)&SockProcessQueuedAsyncSelect,
                      AsyncData,
                      0,
                      0);
 
    /* Return */
    return ERROR_SUCCESS;
}

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.

{
    UNIMPLEMENTED;
 
    return 0;
}

Referenced by WSPStartup().

WSPCleanup()

INT WSPAPI WSPCleanup

(

OUT LPINT

lpErrno

)

Definition at line 3349 of file dllmain.c.

{
    TRACE("Leaving.\n");
 
    if (lpErrno) *lpErrno = NO_ERROR;
 
    return 0;
}

Referenced by WSPStartup(), and WsTpWSPCleanup().

WSPCloseSocket()

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

Definition at line 637 of file dllmain.c.

{
    IO_STATUS_BLOCK IoStatusBlock;
    PSOCKET_INFORMATION Socket = NULL, CurrentSocket;
    NTSTATUS Status;
    HANDLE SockEvent;
    AFD_DISCONNECT_INFO DisconnectInfo;
    SOCKET_STATE OldState;
    LONG LingerWait = -1;
    DWORD References;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
       if (lpErrno) *lpErrno = WSAENOTSOCK;
       return SOCKET_ERROR;
    }
 
    /* HACK: Allow APC to be processed */
    SleepEx(0, TRUE);
 
    if (Socket->HelperEvents & WSH_NOTIFY_CLOSE)
    {
        Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
                                               Socket->Handle,
                                               Socket->TdiAddressHandle,
                                               Socket->TdiConnectionHandle,
                                               WSH_NOTIFY_CLOSE);
 
        if (Status)
        {
            ERR("WSHNotify failed. Error 0x%#x\n", Status);
            if (lpErrno) *lpErrno = Status;
            return SOCKET_ERROR;
        }
    }
 
    /* If a Close is already in Process, give up */
    if (Socket->SharedData->State == SocketClosed)
    {
        WARN("Socket is closing.\n");
        if (lpErrno) *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
 
    /* Create the Wait Event */
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
    if (!NT_SUCCESS(Status))
    {
        ERR("NtCreateEvent failed: 0x%08x\n", Status);
        return SOCKET_ERROR;
    }
 
    /* Decrement reference count on SharedData */
    References = InterlockedDecrement(&Socket->SharedData->RefCount);
    if (References)
        goto ok;
 
    /* Set the state to close */
    OldState = Socket->SharedData->State;
    Socket->SharedData->State = SocketClosed;
 
    /* If SO_LINGER is ON and the Socket is connected, we need to disconnect */
    /* FIXME: Should we do this on Datagram Sockets too? */
    if ((OldState == SocketConnected) && (Socket->SharedData->LingerData.l_onoff))
    {
        ULONG SendsInProgress;
        ULONG SleepWait;
 
        /* We need to respect the timeout */
        SleepWait = 100;
        LingerWait = Socket->SharedData->LingerData.l_linger * 1000;
 
        /* Loop until no more sends are pending, within the timeout */
        while (LingerWait)
        {
            /* Find out how many Sends are in Progress */
            if (GetSocketInformation(Socket,
                                     AFD_INFO_SENDS_IN_PROGRESS,
                                     NULL,
                                     &SendsInProgress,
                                     NULL,
                                     NULL,
                                     NULL))
            {
                /* Bail out if anything but NO_ERROR */
                LingerWait = 0;
                break;
            }
 
            /* Bail out if no more sends are pending */
            if (!SendsInProgress)
            {
                LingerWait = -1;
                break;
            }
 
            /*
             * We have to execute a sleep, so it's kind of like
             * a block. If the socket is Nonblock, we cannot
             * go on since asynchronous operation is expected
             * and we cannot offer it
             */
            if (Socket->SharedData->NonBlocking)
            {
                WARN("Would block!\n");
                NtClose(SockEvent);
                Socket->SharedData->State = OldState;
                if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
                return SOCKET_ERROR;
            }
 
            /* Now we can sleep, and decrement the linger wait */
            /*
            * FIXME: It seems Windows does some funky acceleration
            * since the waiting seems to be longer and longer. I
            * don't think this improves performance so much, so we
            * wait a fixed time instead.
            */
            Sleep(SleepWait);
            LingerWait -= SleepWait;
        }
    }
 
    if (OldState == SocketConnected)
    {
        if (LingerWait <= 0)
        {
            DisconnectInfo.Timeout = RtlConvertLongToLargeInteger(0);
            DisconnectInfo.DisconnectType = LingerWait < 0 ? AFD_DISCONNECT_SEND : AFD_DISCONNECT_ABORT;
 
            if (((DisconnectInfo.DisconnectType & AFD_DISCONNECT_SEND) && (!Socket->SharedData->SendShutdown)) ||
                ((DisconnectInfo.DisconnectType & AFD_DISCONNECT_ABORT) && (!Socket->SharedData->ReceiveShutdown)))
            {
                /* Send IOCTL */
                Status = NtDeviceIoControlFile((HANDLE)Handle,
                                               SockEvent,
                                               NULL,
                                               NULL,
                                               &IoStatusBlock,
                                               IOCTL_AFD_DISCONNECT,
                                               &DisconnectInfo,
                                               sizeof(DisconnectInfo),
                                               NULL,
                                               0);
 
                /* Wait for return */
                if (Status == STATUS_PENDING)
                {
                    MsafdWaitForAlert(SockEvent);
                    Status = IoStatusBlock.Status;
                }
            }
        }
    }
 
    /* Cleanup Time! */
    Socket->HelperContext = NULL;
    Socket->SharedData->AsyncDisabledEvents = -1;
    NtClose(Socket->TdiAddressHandle);
    Socket->TdiAddressHandle = NULL;
    NtClose(Socket->TdiConnectionHandle);
    Socket->TdiConnectionHandle = NULL;
ok:
    EnterCriticalSection(&SocketListLock);
    if (SocketListHead == Socket)
    {
        SocketListHead = SocketListHead->NextSocket;
    }
    else
    {
        CurrentSocket = SocketListHead;
        while (CurrentSocket->NextSocket)
        {
            if (CurrentSocket->NextSocket == Socket)
            {
                CurrentSocket->NextSocket = CurrentSocket->NextSocket->NextSocket;
                break;
            }
 
            CurrentSocket = CurrentSocket->NextSocket;
        }
    }
    LeaveCriticalSection(&SocketListLock);
 
    /* Close the handle */
    NtClose((HANDLE)Handle);
    NtClose(SockEvent);
 
    if( Socket->SharedDataHandle != INVALID_HANDLE_VALUE )
    {
        /* It is a duplicated socket, so unmap the memory */
        UnmapViewOfFile(Socket->SharedData);
        NtClose(Socket->SharedDataHandle);
        Socket->SharedData = NULL;
    }
    if( !References && Socket->SharedData )
    {
        HeapFree(GlobalHeap, 0, Socket->SharedData);
    }
    HeapFree(GlobalHeap, 0, Socket);
    return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
}

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.

{
    HANDLE hProcess, hDuplicatedSharedData, hDuplicatedHandle;
    PSOCKET_INFORMATION Socket;
    PSOCK_SHARED_INFO pSharedData, pOldSharedData;
    BOOL bDuplicated;
 
    if (Handle == INVALID_SOCKET)
        return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER, lpErrno, 0, NULL);
    Socket = GetSocketStructure(Handle);
    if( !Socket )
    {
        if( lpErrno )
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if ( !(hProcess = OpenProcess(PROCESS_DUP_HANDLE, FALSE, dwProcessId)) )
        return MsafdReturnWithErrno(STATUS_INVALID_PARAMETER, lpErrno, 0, NULL);
 
    /* It is a not yet duplicated socket, so map the memory, copy the SharedData and free heap */
    if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
    {
        Socket->SharedDataHandle = CreateFileMapping(INVALID_HANDLE_VALUE,
                                                     NULL,
                                                     PAGE_READWRITE | SEC_COMMIT,
                                                     0,
                                                     (sizeof(SOCK_SHARED_INFO) + PAGE_SIZE - 1) & ~(PAGE_SIZE - 1),
                                                     NULL);
        if( Socket->SharedDataHandle == INVALID_HANDLE_VALUE )
            return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
        pSharedData = MapViewOfFile(Socket->SharedDataHandle,
                                    FILE_MAP_ALL_ACCESS,
                                    0,
                                    0,
                                    sizeof(SOCK_SHARED_INFO));
 
        RtlCopyMemory(pSharedData, Socket->SharedData, sizeof(SOCK_SHARED_INFO));
        pOldSharedData = Socket->SharedData;
        Socket->SharedData = pSharedData;
        HeapFree(GlobalHeap, 0, pOldSharedData);
    }
    /* Duplicate the handles for the new process */
    bDuplicated = DuplicateHandle(GetCurrentProcess(),
                                  Socket->SharedDataHandle,
                                  hProcess,
                                  (LPHANDLE)&hDuplicatedSharedData,
                                  0,
                                  FALSE,
                                  DUPLICATE_SAME_ACCESS);
    if (!bDuplicated)
    {
        NtClose(hProcess);
        return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
    }
    bDuplicated = DuplicateHandle(GetCurrentProcess(),
                                  (HANDLE)Socket->Handle,
                                  hProcess,
                                  (LPHANDLE)&hDuplicatedHandle,
                                  0,
                                  FALSE,
                                  DUPLICATE_SAME_ACCESS);
    NtClose(hProcess);
    if( !bDuplicated )
        return MsafdReturnWithErrno(STATUS_ACCESS_DENIED, lpErrno, 0, NULL);
 
 
    if (!lpProtocolInfo)
        return MsafdReturnWithErrno(STATUS_ACCESS_VIOLATION, lpErrno, 0, NULL);
 
    RtlCopyMemory(lpProtocolInfo, &Socket->ProtocolInfo, sizeof(*lpProtocolInfo));
 
    lpProtocolInfo->iAddressFamily = Socket->SharedData->AddressFamily;
    lpProtocolInfo->iProtocol = Socket->SharedData->Protocol;
    lpProtocolInfo->iSocketType = Socket->SharedData->SocketType;
    lpProtocolInfo->dwServiceFlags3 = HandleToUlong(hDuplicatedSharedData);
    lpProtocolInfo->dwServiceFlags4 = HandleToUlong(hDuplicatedHandle);
 
    if( lpErrno )
        *lpErrno = NO_ERROR;
 
    return NO_ERROR;
}

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.

{
    AFD_ENUM_NETWORK_EVENTS_INFO EnumReq;
    IO_STATUS_BLOCK              IOSB;
    PSOCKET_INFORMATION          Socket = NULL;
    NTSTATUS                     Status;
    HANDLE                       SockEvent;
 
    TRACE("Called (lpNetworkEvents %x)\n", lpNetworkEvents);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
       if (lpErrno) *lpErrno = WSAENOTSOCK;
       return SOCKET_ERROR;
    }
    if (!lpNetworkEvents)
    {
       if (lpErrno) *lpErrno = WSAEFAULT;
       return SOCKET_ERROR;
    }
 
    Status = NtCreateEvent(&SockEvent, EVENT_ALL_ACCESS,
                           NULL, SynchronizationEvent, FALSE);
 
    if( !NT_SUCCESS(Status) ) {
        ERR("Could not make an event %x\n", Status);
        return SOCKET_ERROR;
    }
 
    EnumReq.Event = hEventObject;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_ENUM_NETWORK_EVENTS,
                                   &EnumReq,
                                   sizeof(EnumReq),
                                   NULL,
                                   0);
 
    /* Wait for return */
    if (Status == STATUS_PENDING) {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    NtClose (SockEvent);
 
    if (Status != STATUS_SUCCESS)
    {
        ERR("Status 0x%08x\n", Status);
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    lpNetworkEvents->lNetworkEvents = 0;
 
    /* Set Events to wait for */
    if (EnumReq.PollEvents & AFD_EVENT_RECEIVE) {
        lpNetworkEvents->lNetworkEvents |= FD_READ;
        lpNetworkEvents->iErrorCode[FD_READ_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_READ_BIT]);
    }
 
    if (EnumReq.PollEvents & AFD_EVENT_SEND) {
        lpNetworkEvents->lNetworkEvents |= FD_WRITE;
        lpNetworkEvents->iErrorCode[FD_WRITE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_WRITE_BIT]);
    }
 
    if (EnumReq.PollEvents & AFD_EVENT_OOB_RECEIVE) {
        lpNetworkEvents->lNetworkEvents |= FD_OOB;
        lpNetworkEvents->iErrorCode[FD_OOB_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_OOB_BIT]);
    }
 
    if (EnumReq.PollEvents & AFD_EVENT_ACCEPT) {
        lpNetworkEvents->lNetworkEvents |= FD_ACCEPT;
        lpNetworkEvents->iErrorCode[FD_ACCEPT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_ACCEPT_BIT]);
    }
 
    if (EnumReq.PollEvents &
            (AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL)) {
        lpNetworkEvents->lNetworkEvents |= FD_CONNECT;
        lpNetworkEvents->iErrorCode[FD_CONNECT_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CONNECT_BIT]);
    }
 
    if (EnumReq.PollEvents &
            (AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE)) {
        lpNetworkEvents->lNetworkEvents |= FD_CLOSE;
        lpNetworkEvents->iErrorCode[FD_CLOSE_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_CLOSE_BIT]);
    }
 
    if (EnumReq.PollEvents & AFD_EVENT_QOS) {
        lpNetworkEvents->lNetworkEvents |= FD_QOS;
        lpNetworkEvents->iErrorCode[FD_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_QOS_BIT]);
    }
 
    if (EnumReq.PollEvents & AFD_EVENT_GROUP_QOS) {
        lpNetworkEvents->lNetworkEvents |= FD_GROUP_QOS;
        lpNetworkEvents->iErrorCode[FD_GROUP_QOS_BIT] = TranslateNtStatusError(EnumReq.EventStatus[FD_GROUP_QOS_BIT]);
    }
 
    TRACE("Leaving\n");
 
    return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, NULL);
}

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.

{
    IO_STATUS_BLOCK        IOSB;
    AFD_EVENT_SELECT_INFO  EventSelectInfo;
    PSOCKET_INFORMATION    Socket = NULL;
    NTSTATUS               Status;
    BOOLEAN                BlockMode;
    HANDLE                 SockEvent;
 
    TRACE("WSPEventSelect (%lx) %lx %lx\n", Handle, hEventObject, lNetworkEvents);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if (lpErrno) *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
 
    Status = NtCreateEvent(&SockEvent, EVENT_ALL_ACCESS,
                           NULL, SynchronizationEvent, FALSE);
 
    if (!NT_SUCCESS(Status)) return SOCKET_ERROR;
 
    /* Set Socket to Non-Blocking */
    BlockMode = TRUE;
    SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &BlockMode, NULL, NULL, NULL, NULL);
    Socket->SharedData->NonBlocking = TRUE;
 
    /* Deactivate Async Select if there is one */
    if (Socket->EventObject) {
        Socket->SharedData->hWnd = NULL;
        Socket->SharedData->wMsg = 0;
        Socket->SharedData->AsyncEvents = 0;
        Socket->SharedData->SequenceNumber++; // This will kill Async Select after the next completion
    }
 
    /* Set Structure Info */
    EventSelectInfo.EventObject = hEventObject;
    EventSelectInfo.Events = 0;
 
    /* Set Events to wait for */
    if (lNetworkEvents & FD_READ) {
        EventSelectInfo.Events |= AFD_EVENT_RECEIVE;
    }
 
    if (lNetworkEvents & FD_WRITE) {
        EventSelectInfo.Events |= AFD_EVENT_SEND;
    }
 
    if (lNetworkEvents & FD_OOB) {
        EventSelectInfo.Events |= AFD_EVENT_OOB_RECEIVE;
    }
 
    if (lNetworkEvents & FD_ACCEPT) {
        EventSelectInfo.Events |= AFD_EVENT_ACCEPT;
    }
 
    if (lNetworkEvents & FD_CONNECT) {
        EventSelectInfo.Events |= AFD_EVENT_CONNECT | AFD_EVENT_CONNECT_FAIL;
    }
 
    if (lNetworkEvents & FD_CLOSE) {
        EventSelectInfo.Events |= AFD_EVENT_DISCONNECT | AFD_EVENT_ABORT | AFD_EVENT_CLOSE;
    }
 
    if (lNetworkEvents & FD_QOS) {
        EventSelectInfo.Events |= AFD_EVENT_QOS;
    }
 
    if (lNetworkEvents & FD_GROUP_QOS) {
        EventSelectInfo.Events |= AFD_EVENT_GROUP_QOS;
    }
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_EVENT_SELECT,
                                   &EventSelectInfo,
                                   sizeof(EventSelectInfo),
                                   NULL,
                                   0);
 
    /* Wait for return */
    if (Status == STATUS_PENDING) {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    NtClose (SockEvent);
 
    if (Status != STATUS_SUCCESS)
    {
        ERR("Got status 0x%08x.\n", Status);
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    /* Set Socket Data*/
    Socket->EventObject = hEventObject;
    Socket->NetworkEvents = lNetworkEvents;
 
    TRACE("Leaving\n");
 
    return 0;
}

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.

{
    PSOCKET_INFORMATION     Socket;
    PIO_STATUS_BLOCK        IoStatusBlock;
    BOOL                    Ret;
 
    TRACE("Called (%x)\n", Handle);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if(lpErrno)
            *lpErrno = WSAENOTSOCK;
        return FALSE;
    }
    if (!lpOverlapped || !lpdwBytes || !lpdwFlags)
    {
        if (lpErrno)
            *lpErrno = WSAEFAULT;
        return FALSE;
    }
 
    IoStatusBlock = (PIO_STATUS_BLOCK)lpOverlapped;
    Ret = GetOverlappedResult((HANDLE)Handle, lpOverlapped, lpdwBytes, fWait);
 
    /* HACK: Allow APC to be processed */
    SleepEx(0, TRUE);
 
    if (!fWait && IoStatusBlock->Status == STATUS_PENDING)
    {
        if (lpErrno)
            *lpErrno = WSA_IO_INCOMPLETE;
        return FALSE;
    }
 
    if (Ret)
    {
 
        /* Re-enable Async Event */
        SockReenableAsyncSelectEvent(Socket, FD_OOB);
        SockReenableAsyncSelectEvent(Socket, FD_WRITE);
        SockReenableAsyncSelectEvent(Socket, FD_READ);
    }
 
    switch (IoStatusBlock->Status)
    {
        case STATUS_RECEIVE_EXPEDITED:
            *lpdwFlags = MSG_OOB;
            break;
        case STATUS_RECEIVE_PARTIAL_EXPEDITED:
            *lpdwFlags = MSG_PARTIAL | MSG_OOB;
            break;
        case STATUS_RECEIVE_PARTIAL:
            *lpdwFlags = MSG_PARTIAL;
            break;
        default:
            *lpdwFlags = 0;
            if (lpErrno)
                *lpErrno = TranslateNtStatusError(IoStatusBlock->Status);
            break;
    }
 
    return Ret;
}

Referenced by WSPStartup().

WSPGetPeerName()

INT WSPAPI WSPGetPeerName	(	IN SOCKET	s,
		OUT LPSOCKADDR	name,
		IN OUT LPINT	namelen,
		OUT LPINT	lpErrno
	)

Definition at line 2360 of file dllmain.c.

{
    IO_STATUS_BLOCK         IOSB;
    ULONG                   TdiAddressSize;
    PTRANSPORT_ADDRESS      SocketAddress;
    PSOCKET_INFORMATION     Socket = NULL;
    NTSTATUS                Status;
    HANDLE                  SockEvent;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(s);
    if (!Socket)
    {
        if (lpErrno) *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
 
    if (Socket->SharedData->State != SocketConnected)
    {
        if (lpErrno) *lpErrno = WSAENOTCONN;
        return SOCKET_ERROR;
    }
 
    if (!Name || !NameLength)
    {
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
 
    if( !NT_SUCCESS(Status) )
        return SOCKET_ERROR;
 
    /* Allocate a buffer for the address */
    TdiAddressSize = sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfRemoteAddress;
    SocketAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
 
    if ( SocketAddress == NULL )
    {
        NtClose( SockEvent );
        if (lpErrno) *lpErrno = WSAENOBUFS;
        return SOCKET_ERROR;
    }
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_GET_PEER_NAME,
                                   NULL,
                                   0,
                                   SocketAddress,
                                   TdiAddressSize);
 
    /* Wait for return */
    if (Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    NtClose( SockEvent );
 
    if (NT_SUCCESS(Status))
    {
        if (*NameLength >= Socket->SharedData->SizeOfRemoteAddress)
        {
            Name->sa_family = SocketAddress->Address[0].AddressType;
            RtlCopyMemory (Name->sa_data,
                           SocketAddress->Address[0].Address,
                           SocketAddress->Address[0].AddressLength);
            *NameLength = Socket->SharedData->SizeOfRemoteAddress;
            TRACE("NameLength %d Address: %x Port %x\n",
                          *NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
                          ((struct sockaddr_in *)Name)->sin_port);
            HeapFree(GlobalHeap, 0, SocketAddress);
            return 0;
        }
        else
        {
            HeapFree(GlobalHeap, 0, SocketAddress);
            if (lpErrno) *lpErrno = WSAEFAULT;
            return SOCKET_ERROR;
        }
    }
 
    HeapFree(GlobalHeap, 0, SocketAddress);
 
    return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
}

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.

{
    UNIMPLEMENTED;
 
    return FALSE;
}

Referenced by WSPStartup().

WSPGetSockName()

INT WSPAPI WSPGetSockName	(	IN SOCKET	s,
		OUT LPSOCKADDR	name,
		IN OUT LPINT	namelen,
		OUT LPINT	lpErrno
	)

Definition at line 2258 of file dllmain.c.

{
    IO_STATUS_BLOCK         IOSB;
    ULONG                   TdiAddressSize;
    PTDI_ADDRESS_INFO       TdiAddress;
    PTRANSPORT_ADDRESS      SocketAddress;
    PSOCKET_INFORMATION     Socket = NULL;
    NTSTATUS                Status;
    HANDLE                  SockEvent;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
       if (lpErrno) *lpErrno = WSAENOTSOCK;
       return SOCKET_ERROR;
    }
 
    if (!Name || !NameLength)
    {
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
 
    if( !NT_SUCCESS(Status) )
        return SOCKET_ERROR;
 
    /* Allocate a buffer for the address */
    TdiAddressSize =
        sizeof(TRANSPORT_ADDRESS) + Socket->SharedData->SizeOfLocalAddress;
    TdiAddress = HeapAlloc(GlobalHeap, 0, TdiAddressSize);
 
    if ( TdiAddress == NULL )
    {
        NtClose( SockEvent );
        if (lpErrno) *lpErrno = WSAENOBUFS;
        return SOCKET_ERROR;
    }
 
    SocketAddress = &TdiAddress->Address;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_GET_SOCK_NAME,
                                   NULL,
                                   0,
                                   TdiAddress,
                                   TdiAddressSize);
 
    /* Wait for return */
    if (Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    NtClose( SockEvent );
 
    if (NT_SUCCESS(Status))
    {
        if (*NameLength >= Socket->SharedData->SizeOfLocalAddress)
        {
            Name->sa_family = SocketAddress->Address[0].AddressType;
            RtlCopyMemory (Name->sa_data,
                           SocketAddress->Address[0].Address,
                           SocketAddress->Address[0].AddressLength);
            *NameLength = Socket->SharedData->SizeOfLocalAddress;
            TRACE("NameLength %d Address: %x Port %x\n",
                          *NameLength, ((struct sockaddr_in *)Name)->sin_addr.s_addr,
                          ((struct sockaddr_in *)Name)->sin_port);
            HeapFree(GlobalHeap, 0, TdiAddress);
            return 0;
        }
        else
        {
            HeapFree(GlobalHeap, 0, TdiAddress);
            if (lpErrno) *lpErrno = WSAEFAULT;
            return SOCKET_ERROR;
        }
    }
 
    HeapFree(GlobalHeap, 0, TdiAddress);
 
    return MsafdReturnWithErrno ( Status, lpErrno, 0, NULL );
}

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 2711 of file dllmain.c.

{
    PSOCKET_INFORMATION Socket = NULL;
    PVOID Buffer;
    INT BufferSize;
    BOOL BoolBuffer;
    DWORD DwordBuffer;
    INT Errno;
 
    TRACE("Called\n");
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (Socket == NULL)
    {
        if (lpErrno) *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!OptionLength || !OptionValue)
    {
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    switch (Level)
    {
        case SOL_SOCKET:
            switch (OptionName)
            {
                case SO_TYPE:
                    Buffer = &Socket->SharedData->SocketType;
                    BufferSize = sizeof(INT);
                    break;
 
                case SO_RCVBUF:
                    Buffer = &Socket->SharedData->SizeOfRecvBuffer;
                    BufferSize = sizeof(ULONG);
                    break;
 
                case SO_SNDBUF:
                    Buffer = &Socket->SharedData->SizeOfSendBuffer;
                    BufferSize = sizeof(ULONG);
                    break;
 
                case SO_ACCEPTCONN:
                    BoolBuffer = Socket->SharedData->Listening;
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_BROADCAST:
                    BoolBuffer = Socket->SharedData->Broadcast;
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_DEBUG:
                    BoolBuffer = Socket->SharedData->Debug;
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_DONTLINGER:
                    BoolBuffer = (Socket->SharedData->LingerData.l_onoff == 0);
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_LINGER:
                    if (Socket->SharedData->SocketType == SOCK_DGRAM)
                    {
                        if (lpErrno) *lpErrno = WSAENOPROTOOPT;
                        return SOCKET_ERROR;
                    }
                    Buffer = &Socket->SharedData->LingerData;
                    BufferSize = sizeof(struct linger);
                    break;
 
                case SO_OOBINLINE:
                    BoolBuffer = (Socket->SharedData->OobInline != 0);
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_KEEPALIVE:
                case SO_DONTROUTE:
                   /* These guys go directly to the helper */
                   goto SendToHelper;
 
                case SO_CONDITIONAL_ACCEPT:
                    BoolBuffer = (Socket->SharedData->UseDelayedAcceptance != 0);
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_REUSEADDR:
                    BoolBuffer = (Socket->SharedData->ReuseAddresses != 0);
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_EXCLUSIVEADDRUSE:
                    BoolBuffer = (Socket->SharedData->ExclusiveAddressUse != 0);
                    Buffer = &BoolBuffer;
                    BufferSize = sizeof(BOOL);
                    break;
 
                case SO_ERROR:
                    Buffer = &Socket->SharedData->SocketLastError;
                    BufferSize = sizeof(INT);
                    break;
 
                case SO_CONNECT_TIME:
                    DwordBuffer = GetCurrentTimeInSeconds() - Socket->SharedData->ConnectTime;
                    Buffer = &DwordBuffer;
                    BufferSize = sizeof(DWORD);
                    break;
 
                case SO_SNDTIMEO:
                    Buffer = &Socket->SharedData->SendTimeout;
                    BufferSize = sizeof(DWORD);
                    break;
                case SO_RCVTIMEO:
                    Buffer = &Socket->SharedData->RecvTimeout;
                    BufferSize = sizeof(DWORD);
                    break;
                case SO_PROTOCOL_INFOW:
                    Buffer = &Socket->ProtocolInfo;
                    BufferSize = sizeof(Socket->ProtocolInfo);
                    break;
 
                case SO_GROUP_ID:
                case SO_GROUP_PRIORITY:
                case SO_MAX_MSG_SIZE:
 
                default:
                    DbgPrint("MSAFD: Get unknown optname %x\n", OptionName);
                    if (lpErrno) *lpErrno = WSAENOPROTOOPT;
                    return SOCKET_ERROR;
            }
 
            if (*OptionLength < BufferSize)
            {
                if (lpErrno) *lpErrno = WSAEFAULT;
                *OptionLength = BufferSize;
                return SOCKET_ERROR;
            }
            RtlCopyMemory(OptionValue, Buffer, BufferSize);
 
            return 0;
 
        default:
            if (lpErrno) *lpErrno = WSAEINVAL;
            return SOCKET_ERROR;
    }
 
SendToHelper:
    Errno = Socket->HelperData->WSHGetSocketInformation(Socket->HelperContext,
                                                        Handle,
                                                        Socket->TdiAddressHandle,
                                                        Socket->TdiConnectionHandle,
                                                        Level,
                                                        OptionName,
                                                        OptionValue,
                                                        (LPINT)OptionLength);
    if (lpErrno) *lpErrno = Errno;
    return (Errno == NO_ERROR) ? NO_ERROR : SOCKET_ERROR;
}

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 2463 of file dllmain.c.

{
    PSOCKET_INFORMATION Socket = NULL;
    BOOL NeedsCompletion = lpOverlapped != NULL;
    BOOLEAN NonBlocking;
    INT Errno = NO_ERROR, Ret = SOCKET_ERROR;
    DWORD cbRet = 0;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if(lpErrno)
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
 
    if (!lpcbBytesReturned && !lpOverlapped)
    {
        if(lpErrno)
            *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    switch( dwIoControlCode )
    {
        case FIONBIO:
            if( cbInBuffer < sizeof(INT) || IS_INTRESOURCE(lpvInBuffer) )
            {
                Errno = WSAEFAULT;
                break;
            }
            NonBlocking = *((PULONG)lpvInBuffer) ? TRUE : FALSE;
            /* Don't allow to go in blocking mode if WSPAsyncSelect or WSPEventSelect is pending */
            if (!NonBlocking)
            {
                /* If there is an WSPAsyncSelect pending, fail with WSAEINVAL */
                if (Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents))
                {
                    Errno = WSAEINVAL;
                    break;
                }
                /* If there is an WSPEventSelect pending, fail with WSAEINVAL */
                if (Socket->NetworkEvents)
                {
                    Errno = WSAEINVAL;
                    break;
                }
            }
            Socket->SharedData->NonBlocking = NonBlocking ? 1 : 0;
            NeedsCompletion = FALSE;
            Errno = SetSocketInformation(Socket, AFD_INFO_BLOCKING_MODE, &NonBlocking, NULL, NULL, lpOverlapped, lpCompletionRoutine);
            if (Errno == NO_ERROR)
                Ret = NO_ERROR;
            break;
        case FIONREAD:
            if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
            {
                cbRet = sizeof(ULONG);
                Errno = WSAEFAULT;
                break;
            }
            if (cbOutBuffer < sizeof(ULONG))
            {
                Errno = WSAEINVAL;
                break;
            }
            NeedsCompletion = FALSE;
            Errno = GetSocketInformation(Socket, AFD_INFO_RECEIVE_CONTENT_SIZE, NULL, (PULONG)lpvOutBuffer, NULL, lpOverlapped, lpCompletionRoutine);
            if (Errno == NO_ERROR)
            {
                cbRet = sizeof(ULONG);
                Ret = NO_ERROR;
            }
            break;
        case SIOCATMARK:
            if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
            {
                cbRet = sizeof(BOOL);
                Errno = WSAEFAULT;
                break;
            }
            if (cbOutBuffer < sizeof(BOOL))
            {
                Errno = WSAEINVAL;
                break;
            }
            if (Socket->SharedData->SocketType != SOCK_STREAM)
            {
                Errno = WSAEINVAL;
                break;
            }
 
            /* FIXME: Return false if OOBINLINE is true for now
               We should MSG_PEEK|MSG_OOB check with driver
            */
            *(BOOL*)lpvOutBuffer = !Socket->SharedData->OobInline;
 
            cbRet = sizeof(BOOL);
            Errno = NO_ERROR;
            Ret = NO_ERROR;
            break;
        case SIO_GET_EXTENSION_FUNCTION_POINTER:
            if (cbOutBuffer == 0)
            {
                cbRet = sizeof(PVOID);
                Errno = WSAEFAULT;
                break;
            }
 
            if (cbInBuffer < sizeof(GUID) ||
                cbOutBuffer < sizeof(PVOID))
            {
                Errno = WSAEINVAL;
                break;
            }
 
            {
                GUID AcceptExGUID = WSAID_ACCEPTEX;
                GUID ConnectExGUID = WSAID_CONNECTEX;
                GUID DisconnectExGUID = WSAID_DISCONNECTEX;
                GUID GetAcceptExSockaddrsGUID = WSAID_GETACCEPTEXSOCKADDRS;
 
                if (IsEqualGUID(&AcceptExGUID, lpvInBuffer))
                {
                    *((PVOID *)lpvOutBuffer) = WSPAcceptEx;
                    cbRet = sizeof(PVOID);
                    Errno = NO_ERROR;
                    Ret = NO_ERROR;
                }
                else if (IsEqualGUID(&ConnectExGUID, lpvInBuffer))
                {
                    *((PVOID *)lpvOutBuffer) = WSPConnectEx;
                    cbRet = sizeof(PVOID);
                    Errno = NO_ERROR;
                    Ret = NO_ERROR;
                }
                else if (IsEqualGUID(&DisconnectExGUID, lpvInBuffer))
                {
                    *((PVOID *)lpvOutBuffer) = WSPDisconnectEx;
                    cbRet = sizeof(PVOID);
                    Errno = NO_ERROR;
                    Ret = NO_ERROR;
                }
                else if (IsEqualGUID(&GetAcceptExSockaddrsGUID, lpvInBuffer))
                {
                    *((PVOID *)lpvOutBuffer) = WSPGetAcceptExSockaddrs;
                    cbRet = sizeof(PVOID);
                    Errno = NO_ERROR;
                    /* See CORE-14966 and associated commits.
                     * Original line below was 'Ret = NO_ERROR:'.
                     * This caused winetest ws2_32:sock to hang.
                     * This new Ret value allows the test to complete. */
                    ERR("SIO_GET_EXTENSION_FUNCTION_POINTER UNIMPLEMENTED\n");
                    Ret = SOCKET_ERROR;
                }
                else
                {
                    ERR("Querying unknown extension function: %x\n", ((GUID*)lpvInBuffer)->Data1);
                    Errno = WSAEOPNOTSUPP;
                }
            }
 
            break;
        case SIO_ADDRESS_LIST_QUERY:
            if (IS_INTRESOURCE(lpvOutBuffer) || cbOutBuffer == 0)
            {
                cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
                Errno = WSAEFAULT;
                break;
            }
            if (cbOutBuffer < sizeof(INT))
            {
                Errno = WSAEINVAL;
                break;
            }
 
            cbRet = sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress);
 
            ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->iAddressCount = 1;
 
            if (cbOutBuffer < (sizeof(SOCKET_ADDRESS_LIST) + sizeof(Socket->SharedData->WSLocalAddress)))
            {
                Errno = WSAEFAULT;
                break;
            }
 
            ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].iSockaddrLength = sizeof(Socket->SharedData->WSLocalAddress);
            ((SOCKET_ADDRESS_LIST*)lpvOutBuffer)->Address[0].lpSockaddr = &Socket->SharedData->WSLocalAddress;
 
            Errno = NO_ERROR;
            Ret = NO_ERROR;
            break;
        default:
            Errno = Socket->HelperData->WSHIoctl(Socket->HelperContext,
                                                 Handle,
                                                 Socket->TdiAddressHandle,
                                                 Socket->TdiConnectionHandle,
                                                 dwIoControlCode,
                                                 lpvInBuffer,
                                                 cbInBuffer,
                                                 lpvOutBuffer,
                                                 cbOutBuffer,
                                                 &cbRet,
                                                 lpOverlapped,
                                                 lpCompletionRoutine,
                                                 &NeedsCompletion);
 
            if (Errno == NO_ERROR)
                Ret = NO_ERROR;
            break;
    }
    if (lpOverlapped && NeedsCompletion)
    {
        lpOverlapped->Internal = Errno;
        lpOverlapped->InternalHigh = cbRet;
        if (lpCompletionRoutine != NULL)
        {
            lpCompletionRoutine(Errno, cbRet, lpOverlapped, 0);
        }
        if (lpOverlapped->hEvent)
            SetEvent(lpOverlapped->hEvent);
        if (!PostQueuedCompletionStatus((HANDLE)Handle, cbRet, 0, lpOverlapped))
        {
            ERR("PostQueuedCompletionStatus failed %d\n", GetLastError());
        }
        return NO_ERROR;
    }
    if (lpErrno)
        *lpErrno = Errno;
    if (lpcbBytesReturned)
        *lpcbBytesReturned = cbRet;
    return Ret;
}

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.

{
    UNIMPLEMENTED;
 
    return (SOCKET)0;
}

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 1052 of file sndrcv.c.

{
    UNIMPLEMENTED;
    return 0;
}

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 1064 of file sndrcv.c.

{
    UNIMPLEMENTED;
    return 0;
}

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 2887 of file dllmain.c.

{
    PSOCKET_INFORMATION Socket;
    INT Errno;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(s);
    if (Socket == NULL)
    {
        if (lpErrno) *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!optval)
    {
        if (lpErrno) *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
 
    /* FIXME: We should handle some more cases here */
    if (level == SOL_SOCKET)
    {
        switch (optname)
        {
           case SO_BROADCAST:
              if (optlen < sizeof(BOOL))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              Socket->SharedData->Broadcast = (*optval != 0) ? 1 : 0;
              return NO_ERROR;
 
           case SO_OOBINLINE:
              if (optlen < sizeof(BOOL))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              Socket->SharedData->OobInline = (*optval != 0) ? 1 : 0;
              return NO_ERROR;
 
           case SO_DONTLINGER:
              if (optlen < sizeof(BOOL))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              Socket->SharedData->LingerData.l_onoff = (*optval != 0) ? 0 : 1;
              return NO_ERROR;
 
           case SO_REUSEADDR:
              if (optlen < sizeof(BOOL))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              Socket->SharedData->ReuseAddresses = (*optval != 0) ? 1 : 0;
              return NO_ERROR;
 
           case SO_EXCLUSIVEADDRUSE:
              if (optlen < sizeof(BOOL))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              Socket->SharedData->ExclusiveAddressUse = (*optval != 0) ? 1 : 0;
              return NO_ERROR;
 
           case SO_LINGER:
              if (optlen < sizeof(struct linger))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
              RtlCopyMemory(&Socket->SharedData->LingerData,
                            optval,
                            sizeof(struct linger));
              return NO_ERROR;
 
           case SO_SNDBUF:
              if (optlen < sizeof(ULONG))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
 
              SetSocketInformation(Socket,
                                   AFD_INFO_SEND_WINDOW_SIZE,
                                   NULL,
                                   (PULONG)optval,
                                   NULL,
                                   NULL,
                                   NULL);
              GetSocketInformation(Socket,
                                   AFD_INFO_SEND_WINDOW_SIZE,
                                   NULL,
                                   &Socket->SharedData->SizeOfSendBuffer,
                                   NULL,
                                   NULL,
                                   NULL);
 
              return NO_ERROR;
 
           case SO_RCVBUF:
              if (optlen < sizeof(ULONG))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
 
              /* FIXME: We should not have to limit the packet receive buffer size like this. workaround for CORE-15804 */
              if (*(PULONG)optval > 0x2000)
                  *(PULONG)optval = 0x2000;
 
              SetSocketInformation(Socket,
                                   AFD_INFO_RECEIVE_WINDOW_SIZE,
                                   NULL,
                                   (PULONG)optval,
                                   NULL,
                                   NULL,
                                   NULL);
              GetSocketInformation(Socket,
                                   AFD_INFO_RECEIVE_WINDOW_SIZE,
                                   NULL,
                                   &Socket->SharedData->SizeOfRecvBuffer,
                                   NULL,
                                   NULL,
                                   NULL);
 
              return NO_ERROR;
 
           case SO_ERROR:
              if (optlen < sizeof(INT))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
 
              RtlCopyMemory(&Socket->SharedData->SocketLastError,
                            optval,
                            sizeof(INT));
              return NO_ERROR;
 
           case SO_SNDTIMEO:
              if (optlen < sizeof(DWORD))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
 
              RtlCopyMemory(&Socket->SharedData->SendTimeout,
                            optval,
                            sizeof(DWORD));
              return NO_ERROR;
 
           case SO_RCVTIMEO:
              if (optlen < sizeof(DWORD))
              {
                  if (lpErrno) *lpErrno = WSAEFAULT;
                  return SOCKET_ERROR;
              }
 
              RtlCopyMemory(&Socket->SharedData->RecvTimeout,
                            optval,
                            sizeof(DWORD));
              return NO_ERROR;
 
           case SO_KEEPALIVE:
           case SO_DONTROUTE:
              /* These go directly to the helper dll */
              goto SendToHelper;
 
           default:
              /* Obviously this is a hack */
              ERR("MSAFD: Set unknown optname %x\n", optname);
              return NO_ERROR;
        }
    }
 
SendToHelper:
    Errno = Socket->HelperData->WSHSetSocketInformation(Socket->HelperContext,
                                                        s,
                                                        Socket->TdiAddressHandle,
                                                        Socket->TdiConnectionHandle,
                                                        level,
                                                        optname,
                                                        (PCHAR)optval,
                                                        optlen);
    if (lpErrno) *lpErrno = Errno;
    return (Errno == NO_ERROR) ? NO_ERROR : SOCKET_ERROR;
}

Referenced by WSPStartup().

WSPShutdown()

INT WSPAPI WSPShutdown	(	IN SOCKET	s,
		IN INT	how,
		OUT LPINT	lpErrno
	)

WSPSocket()

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
	)

WSPStringToAddress()

INT WSPAPI WSPStringToAddress	(	IN LPWSTR	AddressString,
		IN INT	AddressFamily,
		IN LPWSAPROTOCOL_INFOW	lpProtocolInfo,
		OUT LPSOCKADDR	lpAddress,
		IN OUT LPINT	lpAddressLength,
		OUT LPINT	lpErrno
	)

Definition at line 3225 of file dllmain.c.

{
    int numdots = 0;
    USHORT port;
    LONG inetaddr = 0, ip_part;
    LPWSTR *bp = NULL;
    SOCKADDR_IN *sockaddr;
 
    if (!lpAddressLength || !lpAddress || !AddressString)
    {
        if (lpErrno) *lpErrno = WSAEINVAL;
        return SOCKET_ERROR;
    }
 
    sockaddr = (SOCKADDR_IN *)lpAddress;
 
    /* Set right address family */
    if (lpProtocolInfo != NULL)
    {
        sockaddr->sin_family = lpProtocolInfo->iAddressFamily;
    }
    else
    {
        sockaddr->sin_family = AddressFamily;
    }
 
    /* Report size */
    if (AddressFamily == AF_INET)
    {
        if (*lpAddressLength < (INT)sizeof(SOCKADDR_IN))
        {
            if (lpErrno) *lpErrno = WSAEFAULT;
        }
        else
        {
            // translate ip string to ip
 
            /* Get ip number */
            bp = &AddressString;
            inetaddr = 0;
 
            while (*bp < &AddressString[wcslen(AddressString)])
            {
                ip_part = wcstol(*bp, bp, 10);
                /* ip part number should be in range 0-255 */
                if (ip_part < 0 || ip_part > 255)
                {
                    if (lpErrno) *lpErrno = WSAEINVAL;
                    return SOCKET_ERROR;
                }
                inetaddr = (inetaddr << 8) + ip_part;
                /* we end on string end or port separator */
                if ((*bp)[0] == 0 || (*bp)[0] == L':')
                    break;
                /* ip parts are dot separated. verify it */
                if ((*bp)[0] != L'.')
                {
                    if (lpErrno) *lpErrno = WSAEINVAL;
                    return SOCKET_ERROR;
                }
                /* count the dots */
                numdots++;
                /* move over the dot to next ip part */
                (*bp)++;
            }
 
            /* check dots count */
            if (numdots != 3)
            {
                if (lpErrno) *lpErrno = WSAEINVAL;
                return SOCKET_ERROR;
            }
 
            /* Get port number */
            if ((*bp)[0] == L':')
            {
                /* move over the column to port part */
                (*bp)++;
                /* next char should be numeric */
                if ((*bp)[0] < L'0' || (*bp)[0] > L'9')
                {
                    if (lpErrno) *lpErrno = WSAEINVAL;
                    return SOCKET_ERROR;
                }
                port = wcstol(*bp, bp, 10);
            }
            else
            {
                port = 0;
            }
 
            if (lpErrno) *lpErrno = NO_ERROR;
            /* rest sockaddr.sin_addr.s_addr
            for we need to be sure it is zero when we come to while */
            *lpAddressLength = sizeof(*sockaddr);
            memset(lpAddress, 0, sizeof(*sockaddr));
            sockaddr->sin_family = AF_INET;
            sockaddr->sin_addr.s_addr = inetaddr;
            sockaddr->sin_port = port;
        }
    }
 
    if (lpErrno && !*lpErrno)
    {
        return 0;
    }
 
    return SOCKET_ERROR;
}

Referenced by WSPStartup().

Variable Documentation

g_fRnrLockInit

BOOLEAN g_fRnrLockInit

extern

g_RnrLock

CRITICAL_SECTION g_RnrLock

extern

gWSM_NSPCallRef

LONG gWSM_NSPCallRef

extern

gWSM_NSPStartupRef

LONG gWSM_NSPStartupRef

extern

MSWSOCK_SocketLock

CRITICAL_SECTION MSWSOCK_SocketLock

extern

NlsMsgSourcemModuleHandle

HINSTANCE NlsMsgSourcemModuleHandle

extern

SockAllocateHeapRoutine

PRTL_HEAP_ALLOCATE SockAllocateHeapRoutine

extern

SockAsyncQueuePort

HANDLE SockAsyncQueuePort

extern

SockAsyncSelectCalled

BOOLEAN SockAsyncSelectCalled

extern

Definition at line 29 of file dllmain.c.

Referenced by SockGetAsyncSelectHelperAfdHandle().

SockAsyncThreadReferenceCount

LONG SockAsyncThreadReferenceCount

extern

SockBufferKeyTable

PVOID SockBufferKeyTable

extern

SockBufferKeyTableSize

ULONG SockBufferKeyTableSize

extern

SockContextTable

PWAH_HANDLE_TABLE SockContextTable

extern

SocketGlobalLock

SOCK_RW_LOCK SocketGlobalLock

extern

SockHelperDllListHead

LIST_ENTRY SockHelperDllListHead

extern

SockModuleHandle

HINSTANCE SockModuleHandle

extern

SockPrivateHeap

HANDLE SockPrivateHeap

extern

SockProcessPendingAPCCount

LONG SockProcessPendingAPCCount

extern

SockProcessTerminating

BOOL SockProcessTerminating

extern

Referenced by SockEnterApiFast().

SockReceiveBufferWindow

DWORD SockReceiveBufferWindow

extern

SockSanCleanUpCompleteEvent

HANDLE SockSanCleanUpCompleteEvent

extern

SockSanEnabled

BOOLEAN SockSanEnabled

extern

SockSendBufferWindow

DWORD SockSendBufferWindow

extern

SockTcpProviderInfo

WSAPROTOCOL_INFOW SockTcpProviderInfo

extern

SockUpcallTable

LPWSPUPCALLTABLE SockUpcallTable

extern

SockWspStartupCount

LONG SockWspStartupCount

extern

Referenced by SockEnterApiFast().