msafd.h File Reference

#include <stdarg.h>
#include <windef.h>
#include <winbase.h>
#include <ws2spi.h>
#include <ndk/exfuncs.h>
#include <ndk/iofuncs.h>
#include <ndk/obfuncs.h>
#include <ndk/rtlfuncs.h>
#include <wsahelp.h>
#include <tdi.h>
#include <afd/shared.h>
#include <mswsock.h>
#include <wine/debug.h>
#include "include/helpers.h"

Include dependency graph for msafd.h:

Go to the source code of this file.

Classes
struct	_SOCKET_INFORMATION
struct	_SOCKET_CONTEXT
struct	_ASYNC_DATA
struct	_MSAFD_INFO_APC_CONTEXT
struct	_MSAFD_SEND_APC_CONTEXT
struct	_MSAFD_RECV_APC_CONTEXT
struct	_MSAFD_CONNECT_APC_CONTEXT

Macros
#define	WIN32_NO_STATUS
#define	_INC_WINDOWS
#define	COM_NO_WINDOWS_H
#define	NTOS_MODE_USER

Typedefs
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 _ASYNC_DATA	ASYNC_DATA
typedef struct _ASYNC_DATA *	PASYNC_DATA
typedef struct _MSAFD_INFO_APC_CONTEXT	MSAFD_INFO_APC_CONTEXT
typedef struct _MSAFD_INFO_APC_CONTEXT *	PMSAFD_INFO_APC_CONTEXT
typedef struct _MSAFD_SEND_APC_CONTEXT	MSAFD_SEND_APC_CONTEXT
typedef struct _MSAFD_SEND_APC_CONTEXT *	PMSAFD_SEND_APC_CONTEXT
typedef struct _MSAFD_RECV_APC_CONTEXT	MSAFD_RECV_APC_CONTEXT
typedef struct _MSAFD_RECV_APC_CONTEXT *	PMSAFD_RECV_APC_CONTEXT
typedef struct _MSAFD_CONNECT_APC_CONTEXT	MSAFD_CONNECT_APC_CONTEXT
typedef struct _MSAFD_CONNECT_APC_CONTEXT *	PMSAFD_CONNECT_APC_CONTEXT
typedef VOID(*	PASYNC_COMPLETION_ROUTINE) (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msafd)
_Must_inspect_result_ SOCKET WSPAPI	WSPAccept (_In_ SOCKET s, _Out_writes_bytes_to_opt_(*addrlen, *addrlen) struct sockaddr FAR *addr, _Inout_opt_ LPINT addrlen, _In_opt_ LPCONDITIONPROC lpfnCondition, _In_opt_ DWORD_PTR 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 fd_set *readfds, IN OUT fd_set *writefds, IN OUT fd_set *exceptfds, IN CONST struct timeval *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)
BOOL WSPAPI	WSPAcceptEx (IN SOCKET sListenSocket, IN SOCKET sAcceptSocket, OUT PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT LPDWORD lpdwBytesReceived, IN OUT LPOVERLAPPED lpOverlapped)
BOOL WSPAPI	WSPConnectEx (IN SOCKET s, IN const struct sockaddr *name, IN int namelen, IN PVOID lpSendBuffer, IN DWORD dwSendDataLength, OUT LPDWORD lpdwBytesSent, IN OUT LPOVERLAPPED lpOverlapped)
BOOL WSPAPI	WSPDisconnectEx (IN SOCKET hSocket, IN LPOVERLAPPED lpOverlapped, IN DWORD dwFlags, IN DWORD reserved)
VOID WSPAPI	WSPGetAcceptExSockaddrs (IN PVOID lpOutputBuffer, IN DWORD dwReceiveDataLength, IN DWORD dwLocalAddressLength, IN DWORD dwRemoteAddressLength, OUT struct sockaddr **LocalSockaddr, OUT LPINT LocalSockaddrLength, OUT struct sockaddr **RemoteSockaddr, OUT LPINT RemoteSockaddrLength)
PSOCKET_INFORMATION	GetSocketStructure (SOCKET Handle)
INT	TranslateNtStatusError (NTSTATUS Status)
VOID	DeleteSocketStructure (SOCKET Handle)
int	GetSocketInformation (PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
int	SetSocketInformation (PSOCKET_INFORMATION Socket, ULONG AfdInformationClass, PBOOLEAN Boolean OPTIONAL, PULONG Ulong OPTIONAL, PLARGE_INTEGER LargeInteger OPTIONAL, LPWSAOVERLAPPED Overlapped OPTIONAL, LPWSAOVERLAPPED_COMPLETION_ROUTINE CompletionRoutine OPTIONAL)
int	CreateContext (PSOCKET_INFORMATION Socket)
ULONG NTAPI	SockAsyncThread (PVOID ThreadParam)
VOID	SockProcessAsyncSelect (PSOCKET_INFORMATION Socket, PASYNC_DATA AsyncData)
VOID	SockAsyncSelectCompletionRoutine (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
BOOLEAN	SockCreateOrReferenceAsyncThread (VOID)
BOOLEAN	SockGetAsyncSelectHelperAfdHandle (VOID)
VOID	SockProcessQueuedAsyncSelect (PVOID Context, PIO_STATUS_BLOCK IoStatusBlock)
VOID	SockReenableAsyncSelectEvent (IN PSOCKET_INFORMATION Socket, IN ULONG Event)
FORCEINLINE DWORD	MsafdReturnWithErrno (_In_ NTSTATUS Status, _Out_opt_ LPINT Errno, _In_ DWORD Received, _Out_opt_ LPDWORD ReturnedBytes)
VOID	MsafdWaitForAlert (_In_ HANDLE hObject)

Variables
HANDLE	GlobalHeap
WSPUPCALLTABLE	Upcalls
LPWPUCOMPLETEOVERLAPPEDREQUEST	lpWPUCompleteOverlappedRequest
LIST_ENTRY	SockHelpersListHead
HANDLE	SockEvent
HANDLE	SockAsyncCompletionPort
BOOLEAN	SockAsyncSelectCalled

Macro Definition Documentation

_INC_WINDOWS

#define _INC_WINDOWS

Definition at line 14 of file msafd.h.

COM_NO_WINDOWS_H

#define COM_NO_WINDOWS_H

Definition at line 15 of file msafd.h.

NTOS_MODE_USER

#define NTOS_MODE_USER

Definition at line 20 of file msafd.h.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 13 of file msafd.h.

Typedef Documentation

ASYNC_DATA

typedef struct _ASYNC_DATA ASYNC_DATA

MSAFD_CONNECT_APC_CONTEXT

typedef struct _MSAFD_CONNECT_APC_CONTEXT MSAFD_CONNECT_APC_CONTEXT

MSAFD_INFO_APC_CONTEXT

typedef struct _MSAFD_INFO_APC_CONTEXT MSAFD_INFO_APC_CONTEXT

MSAFD_RECV_APC_CONTEXT

typedef struct _MSAFD_RECV_APC_CONTEXT MSAFD_RECV_APC_CONTEXT

MSAFD_SEND_APC_CONTEXT

typedef struct _MSAFD_SEND_APC_CONTEXT MSAFD_SEND_APC_CONTEXT

PASYNC_COMPLETION_ROUTINE

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

Definition at line 511 of file msafd.h.

PASYNC_DATA

typedef struct _ASYNC_DATA * PASYNC_DATA

PMSAFD_CONNECT_APC_CONTEXT

typedef struct _MSAFD_CONNECT_APC_CONTEXT * PMSAFD_CONNECT_APC_CONTEXT

PMSAFD_INFO_APC_CONTEXT

typedef struct _MSAFD_INFO_APC_CONTEXT * PMSAFD_INFO_APC_CONTEXT

PMSAFD_RECV_APC_CONTEXT

typedef struct _MSAFD_RECV_APC_CONTEXT * PMSAFD_RECV_APC_CONTEXT

PMSAFD_SEND_APC_CONTEXT

typedef struct _MSAFD_SEND_APC_CONTEXT * PMSAFD_SEND_APC_CONTEXT

PSOCKET_CONTEXT

typedef struct _SOCKET_CONTEXT * PSOCKET_CONTEXT

PSOCKET_INFORMATION

typedef struct _SOCKET_INFORMATION * PSOCKET_INFORMATION

SOCKET_CONTEXT

typedef struct _SOCKET_CONTEXT SOCKET_CONTEXT

SOCKET_INFORMATION

typedef struct _SOCKET_INFORMATION SOCKET_INFORMATION

Function Documentation

CreateContext()

int CreateContext

(

PSOCKET_INFORMATION

Socket

)

Definition at line 3868 of file dllmain.c.

{
    IO_STATUS_BLOCK     IOSB;
    SOCKET_CONTEXT      ContextData;
    NTSTATUS            Status;
    HANDLE              SockEvent;
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
 
    if( !NT_SUCCESS(Status) )
        return SOCKET_ERROR;
 
    /* Create Context */
    ContextData.SharedData = *Socket->SharedData;
    ContextData.SizeOfHelperData = 0;
    RtlCopyMemory (&ContextData.LocalAddress,
                   Socket->LocalAddress,
                   Socket->SharedData->SizeOfLocalAddress);
    RtlCopyMemory (&ContextData.RemoteAddress,
                   Socket->RemoteAddress,
                   Socket->SharedData->SizeOfRemoteAddress);
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_SET_CONTEXT,
                                   &ContextData,
                                   sizeof(ContextData),
                                   NULL,
                                   0);
 
    /* Wait for Completion */
    if (Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    NtClose( SockEvent );
 
    return Status == STATUS_SUCCESS ? NO_ERROR : SOCKET_ERROR;
}

Referenced by WSPSocket().

DeleteSocketStructure()

VOID DeleteSocketStructure

(

SOCKET

Handle

)

GetSocketInformation()

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

Definition at line 3597 of file dllmain.c.

{
    PIO_STATUS_BLOCK        IOSB;
    IO_STATUS_BLOCK         DummyIOSB;
    PAFD_INFO               InfoData;
    NTSTATUS                Status;
    PMSAFD_INFO_APC_CONTEXT APCContext;
    PIO_APC_ROUTINE         APCFunction;
    HANDLE                  Event = NULL;
    HANDLE                  SockEvent;
 
    InfoData = HeapAlloc(GlobalHeap, 0, sizeof(*InfoData));
    if (!InfoData)
        return SOCKET_ERROR;
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
    if (!NT_SUCCESS(Status))
    {
        HeapFree(GlobalHeap, 0, InfoData);
        return SOCKET_ERROR;
    }
 
    /* Set Info Class */
    InfoData->InformationClass = AfdInformationClass;
 
    /* Verify if we should use APC */
    if (!Overlapped)
    {
        /* Not using Overlapped structure, so use normal blocking on event */
        APCContext = NULL;
        APCFunction = NULL;
        Event = SockEvent;
        IOSB = &DummyIOSB;
    }
    else
    {
        /* Overlapped request for non overlapped opened socket */
        if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
        {
            TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
            NtClose(SockEvent);
            HeapFree(GlobalHeap, 0, InfoData);
            return MsafdReturnWithErrno(STATUS_SUCCESS, NULL, 0, NULL);
        }
 
        APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
        if (!APCContext)
        {
            ERR("Not enough memory for APC Context\n");
            NtClose(SockEvent);
            HeapFree(GlobalHeap, 0, InfoData);
            return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, NULL, 0, NULL);
        }
        APCContext->lpCompletionRoutine = CompletionRoutine;
        APCContext->lpOverlapped = Overlapped;
        APCContext->lpInfoData = InfoData;
        APCFunction = &MsafdInfoAPC;
 
        if (!CompletionRoutine)
            Event = Overlapped->hEvent;
 
        IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
    }
 
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   Event,
                                   APCFunction,
                                   APCContext,
                                   IOSB,
                                   IOCTL_AFD_GET_INFO,
                                   InfoData,
                                   sizeof(*InfoData),
                                   InfoData,
                                   sizeof(*InfoData));
 
    /* Wait for completion if not overlapped */
    if (!Overlapped && Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    TRACE("Status %lx\n", Status);
 
    if (Status == STATUS_SUCCESS)
    {
        /* Return Information */
        if (Ulong != NULL)
        {
            *Ulong = InfoData->Information.Ulong;
        }
        if (LargeInteger != NULL)
        {
            *LargeInteger = InfoData->Information.LargeInteger;
        }
        if (Boolean != NULL)
        {
            *Boolean = InfoData->Information.Boolean;
        }
    }
 
    NtClose(SockEvent);
    if (!APCFunction)
    {
        /* When using APC, this will be freed by the APC function */
        HeapFree(GlobalHeap, 0, InfoData);
    }
 
    return MsafdReturnWithErrno(Status, NULL, 0, NULL);
}

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

GetSocketStructure()

PSOCKET_INFORMATION GetSocketStructure

(

SOCKET

Handle

)

Definition at line 3845 of file dllmain.c.

{
    PSOCKET_INFORMATION CurrentSocket;
 
    EnterCriticalSection(&SocketListLock);
 
    CurrentSocket = SocketListHead;
    while (CurrentSocket)
    {
        if (CurrentSocket->Handle == Handle)
        {
            LeaveCriticalSection(&SocketListLock);
            return CurrentSocket;
        }
 
        CurrentSocket = CurrentSocket->NextSocket;
    }
 
    LeaveCriticalSection(&SocketListLock);
 
    return NULL;
}

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

MsafdReturnWithErrno()

FORCEINLINE DWORD MsafdReturnWithErrno	(	_In_ NTSTATUS	Status,
		_Out_opt_ LPINT	Errno,
		_In_ DWORD	Received,
		_Out_opt_ LPDWORD	ReturnedBytes
	)

Definition at line 515 of file msafd.h.

{
    if (Errno)
    {
        *Errno = TranslateNtStatusError(Status);
 
        if (ReturnedBytes)
            *ReturnedBytes = (*Errno == 0) ? Received : 0;
 
        return (*Errno == 0) ? 0 : SOCKET_ERROR;
    }
    else
    {
        if (ReturnedBytes)
            *ReturnedBytes = (Status == STATUS_SUCCESS) ? Received : 0;
 
        return (Status == STATUS_SUCCESS) ? 0 : SOCKET_ERROR;
    }
}

Referenced by GetSocketInformation(), SetSocketInformation(), WSPAccept(), WSPAsyncSelect(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPDuplicateSocket(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetPeerName(), WSPGetSockName(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSend(), WSPSendTo(), and WSPShutdown().

MsafdWaitForAlert()

VOID MsafdWaitForAlert

(

_In_ HANDLE

hObject

)

Definition at line 614 of file dllmain.c.

{
    DWORD Result;
 
    for (;;)
    {
        Result = WaitForSingleObjectEx(hObject, INFINITE, TRUE);
        if (Result != WAIT_IO_COMPLETION)
            break;
    }
}

Referenced by CreateContext(), GetSocketInformation(), MsafdUpdateConnectionContext(), SetSocketInformation(), WSPAccept(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetPeerName(), WSPGetSockName(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), and WSPShutdown().

SetSocketInformation()

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

Definition at line 3723 of file dllmain.c.

{
    PIO_STATUS_BLOCK        IOSB;
    IO_STATUS_BLOCK         DummyIOSB;
    PAFD_INFO               InfoData;
    NTSTATUS                Status;
    PMSAFD_INFO_APC_CONTEXT APCContext;
    PIO_APC_ROUTINE         APCFunction;
    HANDLE                  Event = NULL;
    HANDLE                  SockEvent;
 
    InfoData = HeapAlloc(GlobalHeap, 0, sizeof(*InfoData));
    if (!InfoData)
        return SOCKET_ERROR;
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
    if (!NT_SUCCESS(Status))
    {
        HeapFree(GlobalHeap, 0, InfoData);
        return SOCKET_ERROR;
    }
 
    /* Set Info Class */
    InfoData->InformationClass = AfdInformationClass;
 
    /* Set Information */
    if (Ulong != NULL)
    {
        InfoData->Information.Ulong = *Ulong;
    }
    if (LargeInteger != NULL)
    {
        InfoData->Information.LargeInteger = *LargeInteger;
    }
    if (Boolean != NULL)
    {
        InfoData->Information.Boolean = *Boolean;
    }
 
    /* Verify if we should use APC */
    if (!Overlapped)
    {
        /* Not using Overlapped structure, so use normal blocking on event */
        APCContext = NULL;
        APCFunction = NULL;
        Event = SockEvent;
        IOSB = &DummyIOSB;
    }
    else
    {
        /* Overlapped request for non overlapped opened socket */
        if ((Socket->SharedData->CreateFlags & SO_SYNCHRONOUS_NONALERT) != 0)
        {
            TRACE("Opened without flag WSA_FLAG_OVERLAPPED. Do nothing.\n");
            NtClose(SockEvent);
            HeapFree(GlobalHeap, 0, InfoData);
            return MsafdReturnWithErrno(STATUS_SUCCESS, NULL, 0, NULL);
        }
 
        APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
        if (!APCContext)
        {
            ERR("Not enough memory for APC Context\n");
            NtClose(SockEvent);
            HeapFree(GlobalHeap, 0, InfoData);
            return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, NULL, 0, NULL);
        }
        APCContext->lpCompletionRoutine = CompletionRoutine;
        APCContext->lpOverlapped = Overlapped;
        APCContext->lpInfoData = InfoData;
        APCFunction = &MsafdInfoAPC;
 
        if (!CompletionRoutine)
            Event = Overlapped->hEvent;
 
        IOSB = (PIO_STATUS_BLOCK)&Overlapped->Internal;
    }
 
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   Event,
                                   APCFunction,
                                   APCContext,
                                   IOSB,
                                   IOCTL_AFD_SET_INFO,
                                   InfoData,
                                   sizeof(*InfoData),
                                   NULL,
                                   0);
 
    /* Wait for completion if not overlapped */
    if (!Overlapped && Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    TRACE("Status %lx\n", Status);
 
    NtClose(SockEvent);
    if (!APCFunction)
    {
        /* When using APC, this will be freed by the APC function */
        HeapFree(GlobalHeap, 0, InfoData);
    }
 
    return MsafdReturnWithErrno(Status, NULL, 0, NULL);
}

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

SockAsyncSelectCompletionRoutine()

VOID SockAsyncSelectCompletionRoutine	(	PVOID	Context,
		PIO_STATUS_BLOCK	IoStatusBlock
	)

Definition at line 4075 of file dllmain.c.

{
 
    PASYNC_DATA AsyncData = Context;
    PSOCKET_INFORMATION Socket;
    ULONG x;
 
    /* Get the Socket */
    Socket = AsyncData->ParentSocket;
 
    /* Check if the Sequence  Number Changed behind our back */
    if (AsyncData->SequenceNumber != Socket->SharedData->SequenceNumber )
    {
        return;
    }
 
    /* Check we were manually called b/c of a failure */
    if (!NT_SUCCESS(IoStatusBlock->Status))
    {
        /* FIXME: Perform Upcall */
        return;
    }
 
    for (x = 1; x; x<<=1)
    {
        switch (AsyncData->AsyncSelectInfo.Handles[0].Events & x)
        {
            case AFD_EVENT_RECEIVE:
                if (0 != (Socket->SharedData->AsyncEvents & FD_READ) &&
                    0 == (Socket->SharedData->AsyncDisabledEvents & FD_READ))
                {
                    /* Make the Notification */
                    (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                                               Socket->SharedData->wMsg,
                                               Socket->Handle,
                                               WSAMAKESELECTREPLY(FD_READ, 0));
                    /* Disable this event until the next read(); */
                    Socket->SharedData->AsyncDisabledEvents |= FD_READ;
                }
            break;
 
            case AFD_EVENT_OOB_RECEIVE:
            if (0 != (Socket->SharedData->AsyncEvents & FD_OOB) &&
                0 == (Socket->SharedData->AsyncDisabledEvents & FD_OOB))
            {
                /* Make the Notification */
                (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                                           Socket->SharedData->wMsg,
                                           Socket->Handle,
                                           WSAMAKESELECTREPLY(FD_OOB, 0));
                /* Disable this event until the next read(); */
                Socket->SharedData->AsyncDisabledEvents |= FD_OOB;
            }
            break;
 
            case AFD_EVENT_SEND:
                if (0 != (Socket->SharedData->AsyncEvents & FD_WRITE) &&
                    0 == (Socket->SharedData->AsyncDisabledEvents & FD_WRITE))
                {
                    /* Make the Notification */
                    (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                                               Socket->SharedData->wMsg,
                                               Socket->Handle,
                                               WSAMAKESELECTREPLY(FD_WRITE, 0));
                    /* Disable this event until the next write(); */
                    Socket->SharedData->AsyncDisabledEvents |= FD_WRITE;
                }
                break;
 
                /* FIXME: THIS IS NOT RIGHT!!! HACK HACK HACK! */
            case AFD_EVENT_CONNECT:
            case AFD_EVENT_CONNECT_FAIL:
                if (0 != (Socket->SharedData->AsyncEvents & FD_CONNECT) &&
                    0 == (Socket->SharedData->AsyncDisabledEvents & FD_CONNECT))
                {
                    /* Make the Notification */
                    (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                        Socket->SharedData->wMsg,
                        Socket->Handle,
                        WSAMAKESELECTREPLY(FD_CONNECT, 0));
                    /* Disable this event forever; */
                    Socket->SharedData->AsyncDisabledEvents |= FD_CONNECT;
                }
                break;
 
            case AFD_EVENT_ACCEPT:
                if (0 != (Socket->SharedData->AsyncEvents & FD_ACCEPT) &&
                    0 == (Socket->SharedData->AsyncDisabledEvents & FD_ACCEPT))
                {
                    /* Make the Notification */
                    (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                                               Socket->SharedData->wMsg,
                                               Socket->Handle,
                                               WSAMAKESELECTREPLY(FD_ACCEPT, 0));
                    /* Disable this event until the next accept(); */
                    Socket->SharedData->AsyncDisabledEvents |= FD_ACCEPT;
                }
                break;
 
            case AFD_EVENT_DISCONNECT:
            case AFD_EVENT_ABORT:
            case AFD_EVENT_CLOSE:
                if (0 != (Socket->SharedData->AsyncEvents & FD_CLOSE) &&
                    0 == (Socket->SharedData->AsyncDisabledEvents & FD_CLOSE))
                {
                    /* Make the Notification */
                    (Upcalls.lpWPUPostMessage)(Socket->SharedData->hWnd,
                                               Socket->SharedData->wMsg,
                                               Socket->Handle,
                                               WSAMAKESELECTREPLY(FD_CLOSE, 0));
                    /* Disable this event forever; */
                    Socket->SharedData->AsyncDisabledEvents |= FD_CLOSE;
                }
                 break;
            /* FIXME: Support QOS */
        }
    }
 
    /* Check if there are any events left for us to check */
    if ((Socket->SharedData->AsyncEvents & (~Socket->SharedData->AsyncDisabledEvents)) == 0 )
    {
        return;
    }
 
    /* Keep Polling */
    SockProcessAsyncSelect(Socket, AsyncData);
    return;
}

Referenced by SockGetAsyncSelectHelperAfdHandle(), and SockProcessAsyncSelect().

SockAsyncThread()

ULONG NTAPI SockAsyncThread

(

PVOID

ThreadParam

)

Definition at line 3979 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;
}

SockCreateOrReferenceAsyncThread()

BOOLEAN SockCreateOrReferenceAsyncThread

(

VOID

)

Definition at line 3918 of file dllmain.c.

{
    HANDLE hAsyncThread;
    DWORD AsyncThreadId;
    HANDLE AsyncEvent;
    OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
    NTSTATUS Status;
 
    /* Check if the Thread Already Exists */
    if (SockAsyncThreadRefCount)
    {
        ASSERT(SockAsyncCompletionPort);
        return TRUE;
    }
 
    /* Create the Completion Port */
    if (!SockAsyncCompletionPort)
    {
        Status = NtCreateIoCompletion(&SockAsyncCompletionPort,
                                      IO_COMPLETION_ALL_ACCESS,
                                      NULL,
                                      2); // Allow 2 threads only
        if (!NT_SUCCESS(Status))
        {
             ERR("Failed to create completion port: 0x%08x\n", Status);
             return FALSE;
        }
        /* Protect Handle */
        HandleFlags.ProtectFromClose = TRUE;
        HandleFlags.Inherit = FALSE;
        Status = NtSetInformationObject(SockAsyncCompletionPort,
                                        ObjectHandleFlagInformation,
                                        &HandleFlags,
                                        sizeof(HandleFlags));
    }
 
    /* Create the Async Event */
    Status = NtCreateEvent(&AsyncEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           NotificationEvent,
                           FALSE);
 
    /* Create the Async Thread */
    hAsyncThread = CreateThread(NULL,
                                0,
                                SockAsyncThread,
                                NULL,
                                0,
                                &AsyncThreadId);
 
    /* Close the Handle */
    NtClose(hAsyncThread);
 
    /* Increase the Reference Count */
    SockAsyncThreadRefCount++;
    return TRUE;
}

Referenced by SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

SockGetAsyncSelectHelperAfdHandle()

BOOLEAN SockGetAsyncSelectHelperAfdHandle

(

VOID

)

Definition at line 4013 of file dllmain.c.

{
    UNICODE_STRING AfdHelper;
    OBJECT_ATTRIBUTES ObjectAttributes;
    IO_STATUS_BLOCK IoSb;
    FILE_COMPLETION_INFORMATION CompletionInfo;
    OBJECT_HANDLE_ATTRIBUTE_INFORMATION HandleFlags;
 
    /* First, make sure we're not already initialized */
    if (SockAsyncHelperAfdHandle)
    {
        return TRUE;
    }
 
    /* Set up Handle Name and Object */
    RtlInitUnicodeString(&AfdHelper, L"\\Device\\Afd\\AsyncSelectHlp" );
                         InitializeObjectAttributes(&ObjectAttributes,
                         &AfdHelper,
                         OBJ_INHERIT | OBJ_CASE_INSENSITIVE,
                         NULL,
                         NULL);
 
    /* Open the Handle to AFD */
    NtCreateFile(&SockAsyncHelperAfdHandle,
                 GENERIC_READ | GENERIC_WRITE | SYNCHRONIZE,
                 &ObjectAttributes,
                 &IoSb,
                 NULL,
                 0,
                 FILE_SHARE_READ | FILE_SHARE_WRITE,
                 FILE_OPEN_IF,
                 0,
                 NULL,
                 0);
 
    /*
     * Now Set up the Completion Port Information
     * This means that whenever a Poll is finished, the routine will be executed
     */
    CompletionInfo.Port = SockAsyncCompletionPort;
    CompletionInfo.Key = SockAsyncSelectCompletionRoutine;
    NtSetInformationFile(SockAsyncHelperAfdHandle,
                         &IoSb,
                         &CompletionInfo,
                         sizeof(CompletionInfo),
                         FileCompletionInformation);
 
 
    /* Protect the Handle */
    HandleFlags.ProtectFromClose = TRUE;
    HandleFlags.Inherit = FALSE;
    NtSetInformationObject(SockAsyncCompletionPort,
                           ObjectHandleFlagInformation,
                           &HandleFlags,
                           sizeof(HandleFlags));
 
 
    /* Set this variable to true so that Send/Recv/Accept will know wether to renable disabled events */
    SockAsyncSelectCalled = TRUE;
    return TRUE;
}

Referenced by WSPAsyncSelect().

SockProcessAsyncSelect()

VOID SockProcessAsyncSelect	(	PSOCKET_INFORMATION	Socket,
		PASYNC_DATA	AsyncData
	)

Definition at line 4204 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);
    }
}

SockProcessQueuedAsyncSelect()

VOID SockProcessQueuedAsyncSelect	(	PVOID	Context,
		PIO_STATUS_BLOCK	IoStatusBlock
	)

Definition at line 4287 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;
}

SockReenableAsyncSelectEvent()

VOID SockReenableAsyncSelectEvent	(	IN PSOCKET_INFORMATION	Socket,
		IN ULONG	Event
	)

Definition at line 4321 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;
}

TranslateNtStatusError()

INT TranslateNtStatusError

(

NTSTATUS

Status

)

Definition at line 537 of file dllmain.c.

{
    switch (Status)
    {
       case STATUS_CANT_WAIT:
          return WSAEWOULDBLOCK;
 
       case STATUS_TIMEOUT:
          return WSAETIMEDOUT;
 
       case STATUS_SUCCESS:
          return NO_ERROR;
 
       case STATUS_FILE_CLOSED:
         return WSAECONNRESET;
 
       case STATUS_END_OF_FILE:
          return WSAESHUTDOWN;
 
       case STATUS_PENDING:
          return WSA_IO_PENDING;
 
       case STATUS_BUFFER_TOO_SMALL:
       case STATUS_BUFFER_OVERFLOW:
          return WSAEMSGSIZE;
 
       case STATUS_NO_MEMORY:
       case STATUS_INSUFFICIENT_RESOURCES:
          return WSAENOBUFS;
 
       case STATUS_INVALID_CONNECTION:
          return WSAENOTCONN;
 
       case STATUS_PROTOCOL_NOT_SUPPORTED:
          return WSAEAFNOSUPPORT;
 
       case STATUS_INVALID_ADDRESS:
          return WSAEADDRNOTAVAIL;
 
       case STATUS_REMOTE_NOT_LISTENING:
       case STATUS_REMOTE_DISCONNECT:
          return WSAECONNREFUSED;
 
       case STATUS_NETWORK_UNREACHABLE:
          return WSAENETUNREACH;
 
       case STATUS_HOST_UNREACHABLE:
          return WSAEHOSTUNREACH;
 
       case STATUS_INVALID_PARAMETER:
          return WSAEINVAL;
 
       case STATUS_CANCELLED:
          return WSA_OPERATION_ABORTED;
 
       case STATUS_ADDRESS_ALREADY_EXISTS:
          return WSAEADDRINUSE;
 
       case STATUS_LOCAL_DISCONNECT:
          return WSAECONNABORTED;
 
       case STATUS_ACCESS_VIOLATION:
          return WSAEFAULT;
 
       case STATUS_ACCESS_DENIED:
          return WSAEACCES;
 
       case STATUS_NOT_IMPLEMENTED:
          return WSAEOPNOTSUPP;
 
       default:
          ERR("MSAFD: Unhandled NTSTATUS value: 0x%x\n", Status);
          return WSAENETDOWN;
    }
}

Referenced by MsafdConnectAPC(), MsafdReturnWithErrno(), MsafdUpdateConnectionContext(), WSPAccept(), WSPBind(), WSPConnect(), WSPConnectEx(), WSPEnumNetworkEvents(), WSPGetOverlappedResult(), WSPListen(), WSPShutdown(), and WSPSocket().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msafd

)

WSPAccept()

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

Definition at line 1451 of file dllmain.c.

{
    IO_STATUS_BLOCK             IOSB;
    PAFD_RECEIVED_ACCEPT_DATA   ListenReceiveData;
    AFD_ACCEPT_DATA             AcceptData;
    AFD_DEFER_ACCEPT_DATA       DeferData;
    AFD_PENDING_ACCEPT_DATA     PendingAcceptData;
    PSOCKET_INFORMATION         Socket = NULL;
    NTSTATUS                    Status;
    struct fd_set               ReadSet;
    struct timeval              Timeout;
    PVOID                       PendingData = NULL;
    ULONG                       PendingDataLength = 0;
    PVOID                       CalleeDataBuffer;
    WSABUF                      CallerData, CalleeID, CallerID, CalleeData;
    PSOCKADDR                   RemoteAddress =  NULL;
    GROUP                       GroupID = 0;
    ULONG                       CallBack;
    SOCKET                      AcceptSocket;
    PSOCKET_INFORMATION         AcceptSocketInfo;
    UCHAR                       ReceiveBuffer[0x1A];
    HANDLE                      SockEvent;
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
       if (lpErrno) *lpErrno = WSAENOTSOCK;
       return SOCKET_ERROR;
    }
    if (!Socket->SharedData->Listening)
    {
       if (lpErrno) *lpErrno = WSAEINVAL;
       return SOCKET_ERROR;
    }
    if ((SocketAddress && !SocketAddressLength) ||
        (SocketAddressLength && !SocketAddress) ||
        (SocketAddressLength && *SocketAddressLength < sizeof(SOCKADDR)))
    {
       if (lpErrno) *lpErrno = WSAEFAULT;
       return INVALID_SOCKET;
    }
 
    Status = NtCreateEvent(&SockEvent,
                           EVENT_ALL_ACCESS,
                           NULL,
                           SynchronizationEvent,
                           FALSE);
 
    if( !NT_SUCCESS(Status) )
    {
        return SOCKET_ERROR;
    }
 
    /* Dynamic Structure...ugh */
    ListenReceiveData = (PAFD_RECEIVED_ACCEPT_DATA)ReceiveBuffer;
 
    /* If this is non-blocking, make sure there's something for us to accept */
    if (Socket->SharedData->NonBlocking)
    {
        FD_ZERO(&ReadSet);
        FD_SET(Socket->Handle, &ReadSet);
        Timeout.tv_sec=0;
        Timeout.tv_usec=0;
 
        if (WSPSelect(0, &ReadSet, NULL, NULL, &Timeout, lpErrno) == SOCKET_ERROR)
        {
            NtClose(SockEvent);
            return SOCKET_ERROR;
        }
 
        if (ReadSet.fd_array[0] != Socket->Handle)
        {
            NtClose(SockEvent);
            if (lpErrno) *lpErrno = WSAEWOULDBLOCK;
            return SOCKET_ERROR;
        }
    }
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_WAIT_FOR_LISTEN,
                                   NULL,
                                   0,
                                   ListenReceiveData,
                                   0xA + sizeof(*ListenReceiveData));
 
    /* Wait for return */
    if (Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    if (!NT_SUCCESS(Status))
    {
        NtClose( SockEvent );
        return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
    }
 
    if (lpfnCondition != NULL)
    {
        if ((Socket->SharedData->ServiceFlags1 & XP1_CONNECT_DATA) != 0)
        {
            /* Find out how much data is pending */
            PendingAcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
            PendingAcceptData.ReturnSize = TRUE;
 
            /* Send IOCTL */
            Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                           SockEvent,
                                           NULL,
                                           NULL,
                                           &IOSB,
                                           IOCTL_AFD_GET_PENDING_CONNECT_DATA,
                                           &PendingAcceptData,
                                           sizeof(PendingAcceptData),
                                           &PendingAcceptData,
                                           sizeof(PendingAcceptData));
 
            /* Wait for return */
            if (Status == STATUS_PENDING)
            {
                MsafdWaitForAlert(SockEvent);
                Status = IOSB.Status;
            }
 
            if (!NT_SUCCESS(Status))
            {
                NtClose( SockEvent );
                return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
            }
 
            /* How much data to allocate */
            PendingDataLength = IOSB.Information;
 
            if (PendingDataLength)
            {
                /* Allocate needed space */
                PendingData = HeapAlloc(GlobalHeap, 0, PendingDataLength);
                if (!PendingData)
                {
                    return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL );
                }
 
                /* We want the data now */
                PendingAcceptData.ReturnSize = FALSE;
 
                /* Send IOCTL */
                Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                               SockEvent,
                                               NULL,
                                               NULL,
                                               &IOSB,
                                               IOCTL_AFD_GET_PENDING_CONNECT_DATA,
                                               &PendingAcceptData,
                                               sizeof(PendingAcceptData),
                                               PendingData,
                                               PendingDataLength);
 
                /* Wait for return */
                if (Status == STATUS_PENDING)
                {
                    MsafdWaitForAlert(SockEvent);
                    Status = IOSB.Status;
                }
 
                if (!NT_SUCCESS(Status))
                {
                    NtClose( SockEvent );
                    return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
                }
            }
        }
 
        if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
        {
            /* I don't support this yet */
        }
 
        /* Build Callee ID */
        CalleeID.buf = (PVOID)Socket->LocalAddress;
        CalleeID.len = Socket->SharedData->SizeOfLocalAddress;
 
        RemoteAddress = HeapAlloc(GlobalHeap, 0, sizeof(*RemoteAddress));
        if (!RemoteAddress)
        {
            return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
        }
 
        /* Set up Address in SOCKADDR Format */
        RtlCopyMemory (RemoteAddress,
                       &ListenReceiveData->Address.Address[0].AddressType,
                       sizeof(*RemoteAddress));
 
        /* Build Caller ID */
        CallerID.buf = (PVOID)RemoteAddress;
        CallerID.len = sizeof(*RemoteAddress);
 
        /* Build Caller Data */
        CallerData.buf = PendingData;
        CallerData.len = PendingDataLength;
 
        /* Check if socket supports Conditional Accept */
        if (Socket->SharedData->UseDelayedAcceptance != 0)
        {
            /* Allocate Buffer for Callee Data */
            CalleeDataBuffer = HeapAlloc(GlobalHeap, 0, 4096);
            if (!CalleeDataBuffer) {
                return MsafdReturnWithErrno( STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL );
            }
            CalleeData.buf = CalleeDataBuffer;
            CalleeData.len = 4096;
        }
        else
        {
            /* Nothing */
            CalleeData.buf = 0;
            CalleeData.len = 0;
        }
 
        /* Call the Condition Function */
        CallBack = (lpfnCondition)(&CallerID,
                                   CallerData.buf == NULL ? NULL : &CallerData,
                                   NULL,
                                   NULL,
                                   &CalleeID,
                                   CalleeData.buf == NULL ? NULL : &CalleeData,
                                   &GroupID,
                                   dwCallbackData);
 
        if (((CallBack == CF_ACCEPT) && GroupID) != 0)
        {
            /* TBD: Check for Validity */
        }
 
        if (CallBack == CF_ACCEPT)
        {
            if ((Socket->SharedData->ServiceFlags1 & XP1_QOS_SUPPORTED) != 0)
            {
                /* I don't support this yet */
            }
            if (CalleeData.buf)
            {
                // SockSetConnectData Sockets(SocketID), IOCTL_AFD_SET_CONNECT_DATA, CalleeData.Buffer, CalleeData.BuffSize, 0
            }
        }
        else
        {
            /* Callback rejected. Build Defer Structure */
            DeferData.SequenceNumber = ListenReceiveData->SequenceNumber;
            DeferData.RejectConnection = (CallBack == CF_REJECT);
 
            /* Send IOCTL */
            Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                           SockEvent,
                                           NULL,
                                           NULL,
                                           &IOSB,
                                           IOCTL_AFD_DEFER_ACCEPT,
                                           &DeferData,
                                           sizeof(DeferData),
                                           NULL,
                                           0);
 
            /* Wait for return */
            if (Status == STATUS_PENDING)
            {
                MsafdWaitForAlert(SockEvent);
                Status = IOSB.Status;
            }
 
            NtClose( SockEvent );
 
            if (!NT_SUCCESS(Status))
            {
                return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
            }
 
            if (CallBack == CF_REJECT )
            {
                if (lpErrno) *lpErrno = WSAECONNREFUSED;
                return SOCKET_ERROR;
            }
            else
            {
                if (lpErrno) *lpErrno = WSAECONNREFUSED;
                return SOCKET_ERROR;
            }
        }
    }
 
    /* Create a new Socket */
    AcceptSocket = WSPSocket (Socket->SharedData->AddressFamily,
                              Socket->SharedData->SocketType,
                              Socket->SharedData->Protocol,
                              &Socket->ProtocolInfo,
                              GroupID,
                              Socket->SharedData->CreateFlags,
                              lpErrno);
    if (AcceptSocket == INVALID_SOCKET)
        return SOCKET_ERROR;
 
    /* Set up the Accept Structure */
    AcceptData.ListenHandle = (HANDLE)AcceptSocket;
    AcceptData.SequenceNumber = ListenReceiveData->SequenceNumber;
 
    /* Send IOCTL to Accept */
    Status = NtDeviceIoControlFile((HANDLE)Socket->Handle,
                                   SockEvent,
                                   NULL,
                                   NULL,
                                   &IOSB,
                                   IOCTL_AFD_ACCEPT,
                                   &AcceptData,
                                   sizeof(AcceptData),
                                   NULL,
                                   0);
 
    /* Wait for return */
    if (Status == STATUS_PENDING)
    {
        MsafdWaitForAlert(SockEvent);
        Status = IOSB.Status;
    }
 
    Socket->SharedData->SocketLastError = TranslateNtStatusError(Status);
    if (!NT_SUCCESS(Status))
    {
        NtClose(SockEvent);
        WSPCloseSocket( AcceptSocket, lpErrno );
        return MsafdReturnWithErrno( Status, lpErrno, 0, NULL );
    }
 
    AcceptSocketInfo = GetSocketStructure(AcceptSocket);
    if (!AcceptSocketInfo)
    {
        NtClose(SockEvent);
        WSPCloseSocket( AcceptSocket, lpErrno );
        return MsafdReturnWithErrno( STATUS_PROTOCOL_NOT_SUPPORTED, lpErrno, 0, NULL );
    }
 
    AcceptSocketInfo->SharedData->State = SocketConnected;
    AcceptSocketInfo->SharedData->ConnectTime = GetCurrentTimeInSeconds();
    AcceptSocketInfo->SharedData->NonBlocking = Socket->SharedData->NonBlocking;
 
    /* Return Address in SOCKADDR FORMAT */
    if( SocketAddress )
    {
        RtlCopyMemory (SocketAddress,
                       &ListenReceiveData->Address.Address[0].AddressType,
                       sizeof(*RemoteAddress));
        if( SocketAddressLength )
            *SocketAddressLength = sizeof(*RemoteAddress);
    }
 
    NtClose( SockEvent );
 
    /* Re-enable Async Event */
    SockReenableAsyncSelectEvent(Socket, FD_ACCEPT);
 
    TRACE("Socket %x\n", AcceptSocket);
 
    if (Status == STATUS_SUCCESS && (Socket->HelperEvents & WSH_NOTIFY_ACCEPT))
    {
        Status = Socket->HelperData->WSHNotify(Socket->HelperContext,
                                               Socket->Handle,
                                               Socket->TdiAddressHandle,
                                               Socket->TdiConnectionHandle,
                                               WSH_NOTIFY_ACCEPT);
 
        if (Status)
        {
            if (lpErrno) *lpErrno = Status;
            return SOCKET_ERROR;
        }
    }
 
    if (lpErrno) *lpErrno = NO_ERROR;
 
    /* Return Socket */
    return AcceptSocket;
}

Referenced by WSPStartup().

WSPAcceptEx()

BOOL WSPAPI WSPAcceptEx	(	IN SOCKET	sListenSocket,
		IN SOCKET	sAcceptSocket,
		OUT PVOID	lpOutputBuffer,
		IN DWORD	dwReceiveDataLength,
		IN DWORD	dwLocalAddressLength,
		IN DWORD	dwRemoteAddressLength,
		OUT LPDWORD	lpdwBytesReceived,
		IN OUT LPOVERLAPPED	lpOverlapped
	)

Definition at line 58 of file stubs.c.

{
    UNIMPLEMENTED;
 
    return FALSE;
}

Referenced by WSPIoctl().

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 3381 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;
}

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;
}

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;
}

WSPCleanup()

INT WSPAPI WSPCleanup

(

OUT LPINT

lpErrno

)

Definition at line 3565 of file dllmain.c.

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

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);
}

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
	)

WSPConnectEx()

BOOL WSPAPI WSPConnectEx	(	IN SOCKET	s,
		IN const struct sockaddr *	name,
		IN int	namelen,
		IN PVOID	lpSendBuffer,
		IN DWORD	dwSendDataLength,
		OUT LPDWORD	lpdwBytesSent,
		IN OUT LPOVERLAPPED	lpOverlapped
	)

WSPDisconnectEx()

BOOL WSPAPI WSPDisconnectEx	(	IN SOCKET	hSocket,
		IN LPOVERLAPPED	lpOverlapped,
		IN DWORD	dwFlags,
		IN DWORD	reserved
	)

Definition at line 75 of file stubs.c.

{
    UNIMPLEMENTED;
 
    return FALSE;
}

Referenced by WSPIoctl().

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;
}

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);
}

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;
}

WSPGetAcceptExSockaddrs()

VOID WSPAPI WSPGetAcceptExSockaddrs	(	IN PVOID	lpOutputBuffer,
		IN DWORD	dwReceiveDataLength,
		IN DWORD	dwLocalAddressLength,
		IN DWORD	dwRemoteAddressLength,
		OUT struct sockaddr **	LocalSockaddr,
		OUT LPINT	LocalSockaddrLength,
		OUT struct sockaddr **	RemoteSockaddr,
		OUT LPINT	RemoteSockaddrLength
	)

Definition at line 88 of file stubs.c.

{
    UNIMPLEMENTED;
}

Referenced by WSPIoctl().

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;
}

WSPGetPeerName()

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

Definition at line 2463 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 );
}

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;
}

WSPGetSockName()

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

Definition at line 2361 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 );
}

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 2814 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;
}

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 2566 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;
}

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;
}

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;
}

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 fd_set *	readfds,
		IN OUT fd_set *	writefds,
		IN OUT fd_set *	exceptfds,
		IN CONST struct timeval *	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;
}

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 3100 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 && optlen)
    {
        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_UPDATE_CONNECT_CONTEXT:
              return MsafdUpdateConnectionContext(s, lpErrno);
 
           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;
}

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 3441 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;
}

Variable Documentation

GlobalHeap

HANDLE GlobalHeap

extern

Definition at line 19 of file dllmain.c.

lpWPUCompleteOverlappedRequest

LPWPUCOMPLETEOVERLAPPEDREQUEST lpWPUCompleteOverlappedRequest

extern

Definition at line 22 of file dllmain.c.

SockAsyncCompletionPort

HANDLE SockAsyncCompletionPort

extern

Definition at line 28 of file dllmain.c.

Referenced by SockAsyncThread(), SockCreateOrReferenceAsyncThread(), SockGetAsyncSelectHelperAfdHandle(), SockReenableAsyncSelectEvent(), and WSPAsyncSelect().

SockAsyncSelectCalled

BOOLEAN SockAsyncSelectCalled

extern

Definition at line 29 of file dllmain.c.

SockEvent

HANDLE SockEvent

extern

Referenced by CreateContext(), GetSocketInformation(), MsafdUpdateConnectionContext(), SetSocketInformation(), WSPAccept(), WSPBind(), WSPCloseSocket(), WSPConnect(), WSPEnumNetworkEvents(), WSPEventSelect(), WSPGetPeerName(), WSPGetSockName(), WSPListen(), WSPRecv(), WSPRecvFrom(), WSPSelect(), WSPSend(), WSPSendTo(), and WSPShutdown().

SockHelpersListHead

LIST_ENTRY SockHelpersListHead

extern

Definition at line 25 of file dllmain.c.

Referenced by DllMain(), SockGetTdiName(), and SockLoadHelperDll().

Upcalls

WSPUPCALLTABLE Upcalls

extern

Definition at line 20 of file dllmain.c.

Referenced by SockAsyncSelectCompletionRoutine(), WSPSocket(), and WSPStartup().