sndrcv.c File Reference

#include <msafd.h>

Include dependency graph for sndrcv.c:

Go to the source code of this file.

Functions
INT WSPAPI	WSPAsyncSelect (IN SOCKET Handle, IN HWND hWnd, IN UINT wMsg, IN LONG lEvent, OUT LPINT lpErrno)
BOOL WSPAPI	WSPGetOverlappedResult (IN SOCKET Handle, IN LPWSAOVERLAPPED lpOverlapped, OUT LPDWORD lpdwBytes, IN BOOL fWait, OUT LPDWORD lpdwFlags, OUT LPINT lpErrno)
static VOID NTAPI	MsafdRecvAPC (_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
static VOID NTAPI	MsafdSendAPC (_In_ PVOID ApcContext, _In_ PIO_STATUS_BLOCK IoStatusBlock, _In_ ULONG Reserved)
int WSPAPI	WSPRecv (SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRead, LPDWORD ReceiveFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
int WSPAPI	WSPRecvFrom (SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesRead, LPDWORD ReceiveFlags, struct sockaddr *SocketAddress, int *SocketAddressLength, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
int WSPAPI	WSPSend (SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD iFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
int WSPAPI	WSPSendTo (SOCKET Handle, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD iFlags, const struct sockaddr *SocketAddress, int SocketAddressLength, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
INT WSPAPI	WSPRecvDisconnect (IN SOCKET s, OUT LPWSABUF lpInboundDisconnectData, OUT LPINT lpErrno)
INT WSPAPI	WSPSendDisconnect (IN SOCKET s, IN LPWSABUF lpOutboundDisconnectData, OUT LPINT lpErrno)

Function Documentation

MsafdRecvAPC()

static VOID NTAPI MsafdRecvAPC ( _In_ PVOID  ApcContext, _In_ PIO_STATUS_BLOCK  IoStatusBlock, _In_ ULONG  Reserved  )

static

Definition at line 171 of file sndrcv.c.

{
    PMSAFD_RECV_APC_CONTEXT Context = ApcContext;
 
    TRACE("MsafdRecvAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
 
    /* Re-enable Async Event */
    if (IoStatusBlock->Status == STATUS_RECEIVE_EXPEDITED ||
        IoStatusBlock->Status == STATUS_RECEIVE_PARTIAL_EXPEDITED)
    {
        SockReenableAsyncSelectEvent(Context->lpSocket, FD_OOB);
    }
    else
    {
        SockReenableAsyncSelectEvent(Context->lpSocket, FD_READ);
    }
 
    if (Context->lpCompletionRoutine)
        Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, (LPWSAOVERLAPPED)IoStatusBlock, 0);
 
    HeapFree(GlobalHeap, 0, ApcContext);
}

Referenced by WSPRecv(), and WSPRecvFrom().

MsafdSendAPC()

static VOID NTAPI MsafdSendAPC ( _In_ PVOID  ApcContext, _In_ PIO_STATUS_BLOCK  IoStatusBlock, _In_ ULONG  Reserved  )

static

Definition at line 200 of file sndrcv.c.

{
    PMSAFD_SEND_APC_CONTEXT Context = ApcContext;
 
    TRACE("MsafdSendAPC(%p %lx %lx)\n", ApcContext, IoStatusBlock->Status, IoStatusBlock->Information);
 
    /* Re-enable Async Event */
    SockReenableAsyncSelectEvent(Context->lpSocket, FD_WRITE);
 
    if (Context->lpCompletionRoutine)
        Context->lpCompletionRoutine(IoStatusBlock->Status, IoStatusBlock->Information, (LPWSAOVERLAPPED)IoStatusBlock, 0);
 
    /* Free IOCTL buffers */
    HeapFree(GlobalHeap, 0, ApcContext);
}

Referenced by WSPSend(), and WSPSendTo().

WSPAsyncSelect()

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

Definition at line 17 of file sndrcv.c.

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

Referenced by WSPStartup().

WSPGetOverlappedResult()

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

Definition at line 96 of file sndrcv.c.

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

Referenced by WSPStartup().

WSPRecv()

int WSPAPI WSPRecv	(	SOCKET	Handle,
		LPWSABUF	lpBuffers,
		DWORD	dwBufferCount,
		LPDWORD	lpNumberOfBytesRead,
		LPDWORD	ReceiveFlags,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		LPINT	lpErrno
	)

Definition at line 221 of file sndrcv.c.

{
    PIO_STATUS_BLOCK        IOSB;
    IO_STATUS_BLOCK         DummyIOSB;
    AFD_RECV_INFO           RecvInfo;
    NTSTATUS                Status;
    PMSAFD_RECV_APC_CONTEXT APCContext;
    PIO_APC_ROUTINE         APCFunction = NULL;
    HANDLE                  Event = NULL;
    HANDLE                  SockEvent;
    PSOCKET_INFORMATION     Socket;
    DWORD                   NumberOfBytesRead;
 
    TRACE("WSPRecv(%x)\n", Handle);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if (lpErrno)
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!lpNumberOfBytesRead && !lpOverlapped)
    {
        if (lpErrno)
            *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
    if (Socket->SharedData->OobInline && ReceiveFlags && (*ReceiveFlags & MSG_OOB) != 0)
    {
        if (lpErrno)
            *lpErrno = WSAEINVAL;
        return SOCKET_ERROR;
    }
 
    memset(&RecvInfo, 0, sizeof(RecvInfo));
 
    Status = NtCreateEvent( &SockEvent, EVENT_ALL_ACCESS,
                            NULL, SynchronizationEvent, FALSE );
 
    if (!NT_SUCCESS(Status))
    {
        return SOCKET_ERROR;
    }
 
    /* Set up the Receive Structure */
    RecvInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    RecvInfo.BufferCount = dwBufferCount;
    RecvInfo.TdiFlags = 0;
    RecvInfo.AfdFlags = Socket->SharedData->NonBlocking ? AFD_IMMEDIATE : 0;
 
    /* Set the TDI Flags */
    if (!ReceiveFlags || *ReceiveFlags == 0)
    {
        RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
    }
    else
    {
        if (*ReceiveFlags & MSG_OOB)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_EXPEDITED;
        }
 
        if (*ReceiveFlags & MSG_PEEK)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_PEEK;
        }
 
        if (*ReceiveFlags & MSG_PARTIAL)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_PARTIAL;
        }
    }
 
    /* Verify if we should use APC */
    if (!lpOverlapped)
    {
        /* 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);
            return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, lpNumberOfBytesRead);
        }
 
        IOSB = (PIO_STATUS_BLOCK)lpOverlapped;
        if (lpCompletionRoutine)
        {
            RecvInfo.AfdFlags |= AFD_SKIP_FIO;
            APCFunction = &MsafdRecvAPC;
            APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
            if (!APCContext)
            {
                ERR("Not enough memory for APC Context\n");
                NtClose(SockEvent);
                return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, lpNumberOfBytesRead);
            }
            APCContext->lpCompletionRoutine = lpCompletionRoutine;
            APCContext->lpOverlapped = lpOverlapped;
            APCContext->lpSocket = Socket;
            Event = NULL;
        }
        else
        {
            // .NET expects APCContext to be a pointer to lpOverlapped, because it adds some additional metadata past OVERLAPPED structure
            // Do not use APC when there is no completion context
            Event = lpOverlapped->hEvent;
            
            APCFunction = NULL;
            if (Event)
            {
                APCContext = NULL;
            }
            else
            {
                APCContext = (PMSAFD_RECV_APC_CONTEXT)lpOverlapped;
            }
        }
 
        RecvInfo.AfdFlags |= AFD_OVERLAPPED;
    }
 
    IOSB->Information = 0;
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                   Event,
                                   APCFunction,
                                   APCContext,
                                   IOSB,
                                   IOCTL_AFD_RECV,
                                   &RecvInfo,
                                   sizeof(RecvInfo),
                                   NULL,
                                   0);
 
    /* Wait for completion if not overlapped */
    if (!lpOverlapped && Status == STATUS_PENDING)
    {
        /* It's up to the protocol to time out recv. We must wait
         * until the protocol decides it's had enough. */
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    NtClose(SockEvent);
 
    if (Status == STATUS_PENDING)
    {
        TRACE("Leaving (Pending)\n");
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    NumberOfBytesRead = (DWORD)IOSB->Information;
 
    /* Return the Flags */
    if (ReceiveFlags)
    {
        switch (Status)
        {
            case STATUS_RECEIVE_EXPEDITED:
                *ReceiveFlags = MSG_OOB;
                break;
            case STATUS_RECEIVE_PARTIAL_EXPEDITED:
                *ReceiveFlags = MSG_PARTIAL | MSG_OOB;
                break;
            case STATUS_RECEIVE_PARTIAL:
                *ReceiveFlags = MSG_PARTIAL;
                break;
            default:
                *ReceiveFlags = 0;
                break;
        }
    }
 
    /* Re-enable Async Event */
    if (ReceiveFlags && (*ReceiveFlags & MSG_OOB))
    {
        SockReenableAsyncSelectEvent(Socket, FD_OOB);
    }
    else
    {
        SockReenableAsyncSelectEvent(Socket, FD_READ);
    }
 
    TRACE("Leaving (%lx %ld)\n", Status, NumberOfBytesRead);
    return MsafdReturnWithErrno(Status, lpErrno, NumberOfBytesRead, lpNumberOfBytesRead);
}

Referenced by WSPRecvFrom(), and WSPStartup().

WSPRecvDisconnect()

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

Definition at line 1052 of file sndrcv.c.

{
    UNIMPLEMENTED;
    return 0;
}

Referenced by WSPStartup().

WSPRecvFrom()

int WSPAPI WSPRecvFrom	(	SOCKET	Handle,
		LPWSABUF	lpBuffers,
		DWORD	dwBufferCount,
		LPDWORD	lpNumberOfBytesRead,
		LPDWORD	ReceiveFlags,
		struct sockaddr *	SocketAddress,
		int *	SocketAddressLength,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		LPINT	lpErrno
	)

Definition at line 430 of file sndrcv.c.

{
    PIO_STATUS_BLOCK            IOSB;
    IO_STATUS_BLOCK             DummyIOSB;
    AFD_RECV_INFO_UDP           RecvInfo;
    NTSTATUS                    Status;
    PMSAFD_RECV_APC_CONTEXT     APCContext;
    PIO_APC_ROUTINE             APCFunction = NULL;
    HANDLE                      Event = NULL;
    HANDLE                      SockEvent;
    PSOCKET_INFORMATION         Socket;
    DWORD                       NumberOfBytesRead;
 
    TRACE("WSPRecvFrom(%x)\n", Handle);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if (lpErrno)
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!lpNumberOfBytesRead && !lpOverlapped)
    {
        if (lpErrno)
            *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
    if (Socket->SharedData->OobInline && ReceiveFlags && (*ReceiveFlags & MSG_OOB) != 0)
    {
        if (lpErrno)
            *lpErrno = WSAEINVAL;
        return SOCKET_ERROR;
    }
 
    if (!(Socket->SharedData->ServiceFlags1 & XP1_CONNECTIONLESS))
    {
        /* Call WSPRecv for a non-datagram socket */
        return WSPRecv(Handle,
                       lpBuffers,
                       dwBufferCount,
                       lpNumberOfBytesRead,
                       ReceiveFlags,
                       lpOverlapped,
                       lpCompletionRoutine,
                       lpThreadId,
                       lpErrno);
    }
 
    /* Bind us First */
    if (Socket->SharedData->State == SocketOpen)
    {
        Socket->HelperData->WSHGetWildcardSockaddr(Socket->HelperContext,
            SocketAddress,
            SocketAddressLength);
        /* Bind it */
        if (WSPBind(Handle, SocketAddress, *SocketAddressLength, lpErrno) == SOCKET_ERROR)
            return SOCKET_ERROR;
    }
    memset(&RecvInfo, 0, sizeof(RecvInfo));
 
    Status = NtCreateEvent( &SockEvent, EVENT_ALL_ACCESS,
                            NULL, SynchronizationEvent, FALSE );
 
    if( !NT_SUCCESS(Status) )
    {
        return SOCKET_ERROR;
    }
 
    /* Set up the Receive Structure */
    RecvInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    RecvInfo.BufferCount = dwBufferCount;
    RecvInfo.TdiFlags = 0;
    RecvInfo.AfdFlags = Socket->SharedData->NonBlocking ? AFD_IMMEDIATE : 0;
    RecvInfo.AddressLength = SocketAddressLength;
    RecvInfo.Address = SocketAddress;
 
    /* Set the TDI Flags */
    if (!ReceiveFlags || *ReceiveFlags == 0)
    {
        RecvInfo.TdiFlags |= TDI_RECEIVE_NORMAL;
    }
    else
    {
        if (*ReceiveFlags & MSG_OOB)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_EXPEDITED;
        }
 
        if (*ReceiveFlags & MSG_PEEK)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_PEEK;
        }
 
        if (*ReceiveFlags & MSG_PARTIAL)
        {
            RecvInfo.TdiFlags |= TDI_RECEIVE_PARTIAL;
        }
    }
 
    /* Verify if we should use APC */
    if (!lpOverlapped)
    {
        /* 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);
            return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, lpNumberOfBytesRead);
        }
 
        IOSB = (PIO_STATUS_BLOCK)lpOverlapped;
        if (lpCompletionRoutine)
        {
            RecvInfo.AfdFlags |= AFD_SKIP_FIO;
            APCFunction = &MsafdRecvAPC;
            APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
            if (!APCContext)
            {
                ERR("Not enough memory for APC Context\n");
                NtClose(SockEvent);
                return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, lpNumberOfBytesRead);
            }
            APCContext->lpCompletionRoutine = lpCompletionRoutine;
            APCContext->lpOverlapped = lpOverlapped;
            APCContext->lpSocket = Socket;
            Event = NULL;
        }
        else
        {
            // .NET expects APCContext to be a pointer to lpOverlapped, because it adds some additional metadata past OVERLAPPED structure
            // Do not use APC when there is no completion context
            Event = lpOverlapped->hEvent;
            
            APCFunction = NULL;
            if (Event)
            {
                APCContext = NULL;
            }
            else
            {
                APCContext = (PMSAFD_RECV_APC_CONTEXT)lpOverlapped;
            }
        }
 
        RecvInfo.AfdFlags |= AFD_OVERLAPPED;
    }
 
    IOSB->Information = 0;
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                    Event,
                                    APCFunction,
                                    APCContext,
                                    IOSB,
                                    IOCTL_AFD_RECV_DATAGRAM,
                                    &RecvInfo,
                                    sizeof(RecvInfo),
                                    NULL,
                                    0);
 
    /* Wait for completion if not overlapped */
    if (!lpOverlapped && Status == STATUS_PENDING)
    {
        /* FIXME: Shouldn't wait infinitely for receive... */
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    /* Return the Flags */
    if (ReceiveFlags)
    {
        switch (Status)
        {
            case STATUS_RECEIVE_EXPEDITED:
                *ReceiveFlags = MSG_OOB;
                break;
            case STATUS_RECEIVE_PARTIAL_EXPEDITED:
                *ReceiveFlags = MSG_PARTIAL | MSG_OOB;
                break;
            case STATUS_RECEIVE_PARTIAL:
                *ReceiveFlags = MSG_PARTIAL;
                break;
            default:
                *ReceiveFlags = 0;
                break;
        }
    }
 
    NtClose(SockEvent);
 
    if (Status == STATUS_PENDING)
    {
        TRACE("Leaving (Pending)\n");
        *lpErrno = WSA_IO_PENDING;
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    NumberOfBytesRead = (DWORD)IOSB->Information;
 
    /* Re-enable Async Event */
    if (ReceiveFlags && (*ReceiveFlags & MSG_OOB))
    {
        SockReenableAsyncSelectEvent(Socket, FD_OOB);
    }
    else
    {
        SockReenableAsyncSelectEvent(Socket, FD_READ);
    }
 
    TRACE("Leaving (%lx %ld)\n", Status, NumberOfBytesRead);
    return MsafdReturnWithErrno(Status, lpErrno, NumberOfBytesRead, lpNumberOfBytesRead);
}

Referenced by WSPStartup().

WSPSend()

int WSPAPI WSPSend	(	SOCKET	Handle,
		LPWSABUF	lpBuffers,
		DWORD	dwBufferCount,
		LPDWORD	lpNumberOfBytesSent,
		DWORD	iFlags,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		LPINT	lpErrno
	)

Definition at line 668 of file sndrcv.c.

{
    PIO_STATUS_BLOCK        IOSB;
    IO_STATUS_BLOCK         DummyIOSB;
    AFD_SEND_INFO          SendInfo;
    NTSTATUS                Status;
    PMSAFD_SEND_APC_CONTEXT APCContext;
    PIO_APC_ROUTINE         APCFunction = NULL;
    HANDLE                  Event = NULL;
    HANDLE                  SockEvent;
    PSOCKET_INFORMATION     Socket;
    DWORD                   NumberOfBytesSent;
    
    TRACE("WSPSend(%x)\n", Handle);
 
    /* Get the Socket Structure associate to this Socket*/
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if (lpErrno)
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!lpNumberOfBytesSent && !lpOverlapped)
    {
        if (lpErrno)
            *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    memset(&SendInfo, 0, sizeof(SendInfo));
 
    Status = NtCreateEvent( &SockEvent, EVENT_ALL_ACCESS,
                            NULL, SynchronizationEvent, FALSE );
 
    if( !NT_SUCCESS(Status) )
    {
        return SOCKET_ERROR;
    }
 
    /* Set up the Send Structure */
    SendInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    SendInfo.BufferCount = dwBufferCount;
    SendInfo.TdiFlags = 0;
    SendInfo.AfdFlags = Socket->SharedData->NonBlocking ? AFD_IMMEDIATE : 0;
 
    /* Set the TDI Flags */
    if (iFlags)
    {
        if (iFlags & MSG_OOB)
        {
            SendInfo.TdiFlags |= TDI_SEND_EXPEDITED;
        }
        if (iFlags & MSG_PARTIAL)
        {
            SendInfo.TdiFlags |= TDI_SEND_PARTIAL;
        }
    }
 
    /* Verify if we should use APC */
    if (!lpOverlapped)
    {
        /* 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);
            return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, lpNumberOfBytesSent);
        }
 
        IOSB = (PIO_STATUS_BLOCK)lpOverlapped;
        if (lpCompletionRoutine)
        {
            SendInfo.AfdFlags |= AFD_SKIP_FIO;
            APCFunction = &MsafdSendAPC;
            APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
            if (!APCContext)
            {
                ERR("Not enough memory for APC Context\n");
                NtClose(SockEvent);
                return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, lpNumberOfBytesSent);
            }
            APCContext->lpCompletionRoutine = lpCompletionRoutine;
            APCContext->lpOverlapped = lpOverlapped;
            APCContext->lpSocket = Socket;
            APCContext->lpRemoteAddress = NULL;
            Event = NULL;
        }
        else
        {
            // .NET expects APCContext to be a pointer to lpOverlapped, because it adds some additional metadata past OVERLAPPED structure
            // Do not use APC when there is no completion context
            Event = lpOverlapped->hEvent;
            
            APCFunction = NULL;
            if (Event)
            {
                APCContext = NULL;
            }
            else
            {
                APCContext = (PMSAFD_SEND_APC_CONTEXT)lpOverlapped;
            }
        }
        
        Event = lpOverlapped->hEvent;
        // APCContext is unsupported when using event
        if (Event)
        {
            if (lpCompletionRoutine)
                HeapFree(GetProcessHeap(), 0, APCContext);
            APCContext = NULL;
        }
 
        SendInfo.AfdFlags |= AFD_OVERLAPPED;
    }
 
    IOSB->Information = 0;
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                    Event,
                                    APCFunction,
                                    APCContext,
                                    IOSB,
                                    IOCTL_AFD_SEND,
                                    &SendInfo,
                                    sizeof(SendInfo),
                                    NULL,
                                    0);
 
    /* Wait for completion if not overlapped */
    if (!lpOverlapped && Status == STATUS_PENDING)
    {
        /* FIXME: Shouldn't wait infinitely for send... */
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    NtClose(SockEvent);
 
    if (Status == STATUS_PENDING)
    {
        TRACE("Leaving (Pending)\n");
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    NumberOfBytesSent = (DWORD)IOSB->Information;
 
    /* Re-enable Async Event */
    SockReenableAsyncSelectEvent(Socket, FD_WRITE);
 
    TRACE("Leaving (%lx %ld)\n", Status, NumberOfBytesSent);
    return MsafdReturnWithErrno(Status, lpErrno, NumberOfBytesSent, lpNumberOfBytesSent);
}

Referenced by WSPSendTo(), and WSPStartup().

WSPSendDisconnect()

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

Definition at line 1064 of file sndrcv.c.

{
    UNIMPLEMENTED;
    return 0;
}

Referenced by WSPStartup().

WSPSendTo()

int WSPAPI WSPSendTo	(	SOCKET	Handle,
		LPWSABUF	lpBuffers,
		DWORD	dwBufferCount,
		LPDWORD	lpNumberOfBytesSent,
		DWORD	iFlags,
		const struct sockaddr *	SocketAddress,
		int	SocketAddressLength,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		LPINT	lpErrno
	)

Definition at line 843 of file sndrcv.c.

{
    PIO_STATUS_BLOCK        IOSB;
    IO_STATUS_BLOCK         DummyIOSB;
    AFD_SEND_INFO_UDP       SendInfo;
    NTSTATUS                Status;
    PMSAFD_SEND_APC_CONTEXT APCContext;
    PIO_APC_ROUTINE         APCFunction = NULL;
    HANDLE                  Event = NULL;
    PTRANSPORT_ADDRESS      RemoteAddress;
    HANDLE                  SockEvent;
    PSOCKET_INFORMATION     Socket;
    DWORD                   NumberOfBytesSent;
    UCHAR                   Buffer[128];
 
    TRACE("WSPSendTo(%x)\n", Handle);
 
    /* Get the Socket Structure associate to this Socket */
    Socket = GetSocketStructure(Handle);
    if (!Socket)
    {
        if (lpErrno)
            *lpErrno = WSAENOTSOCK;
        return SOCKET_ERROR;
    }
    if (!lpNumberOfBytesSent && !lpOverlapped)
    {
        if (lpErrno)
            *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    if (!(Socket->SharedData->ServiceFlags1 & XP1_CONNECTIONLESS))
    {
        /* Use WSPSend for connection-oriented sockets */
        return WSPSend(Handle,
                       lpBuffers,
                       dwBufferCount,
                       lpNumberOfBytesSent,
                       iFlags,
                       lpOverlapped,
                       lpCompletionRoutine,
                       lpThreadId,
                       lpErrno);
    }
 
    /* Bind us First */
    if (Socket->SharedData->State == SocketOpen)
    {
        INT BindAddressLength;
        PSOCKADDR BindAddress;
        INT BindError;
 
        /* Get the Wildcard Address */
        BindAddressLength = Socket->HelperData->MaxWSAddressLength;
        BindAddress = HeapAlloc(GlobalHeap, 0, BindAddressLength);
        if (!BindAddress)
        {
            MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, NULL);
            return INVALID_SOCKET;
        }
 
        Socket->HelperData->WSHGetWildcardSockaddr(Socket->HelperContext,
                                                   BindAddress,
                                                   &BindAddressLength);
        /* Bind it */
        BindError = WSPBind(Handle, BindAddress, BindAddressLength, lpErrno);
        HeapFree(GlobalHeap, 0, BindAddress);
        if (BindError == SOCKET_ERROR)
            return SOCKET_ERROR;
    }
 
    Status = NtCreateEvent(&SockEvent,
                        EVENT_ALL_ACCESS,
                        NULL, SynchronizationEvent, FALSE);
 
    if (!NT_SUCCESS(Status))
    {
        return SOCKET_ERROR;
    }
 
    RemoteAddress = (PTRANSPORT_ADDRESS)Buffer;
 
    if (SocketAddressLength > 128 - sizeof(TRANSPORT_ADDRESS)) {
        *lpErrno = WSAEFAULT;
        return SOCKET_ERROR;
    }
 
    /* Fill TDI address */
    RemoteAddress->TAAddressCount = 1;
    RemoteAddress->Address[0].AddressLength = SocketAddressLength - sizeof(SocketAddress->sa_family);
    RtlCopyMemory(&RemoteAddress->Address[0].AddressType, SocketAddress, SocketAddressLength);
 
    /* Set up Structure */
    SendInfo.BufferArray = (PAFD_WSABUF)lpBuffers;
    SendInfo.AfdFlags = Socket->SharedData->NonBlocking ? AFD_IMMEDIATE : 0;
    SendInfo.BufferCount = dwBufferCount;
    SendInfo.TdiConnection.RemoteAddress = RemoteAddress;
    SendInfo.TdiConnection.RemoteAddressLength = Socket->HelperData->MaxTDIAddressLength;
 
    /* Verify if we should use APC */
    if (!lpOverlapped)
    {
        /* 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);
            return MsafdReturnWithErrno(STATUS_SUCCESS, lpErrno, 0, lpNumberOfBytesSent);
        }
 
        IOSB = (PIO_STATUS_BLOCK)lpOverlapped;
        if (lpCompletionRoutine)
        {
            SendInfo.AfdFlags |= AFD_SKIP_FIO;
            APCFunction = &MsafdSendAPC;
            APCContext = HeapAlloc(GlobalHeap, 0, sizeof(*APCContext));
            if (!APCContext)
            {
                ERR("Not enough memory for APC Context\n");
                NtClose(SockEvent);
                return MsafdReturnWithErrno(STATUS_INSUFFICIENT_RESOURCES, lpErrno, 0, lpNumberOfBytesSent);
            }
            APCContext->lpCompletionRoutine = lpCompletionRoutine;
            APCContext->lpOverlapped = lpOverlapped;
            APCContext->lpSocket = Socket;
            APCContext->lpRemoteAddress = RemoteAddress;
            Event = NULL;
        }
        else
        {
            // .NET expects APCContext to be a pointer to lpOverlapped, because it adds some additional metadata past OVERLAPPED structure
            // Do not use APC when there is no completion context
            Event = lpOverlapped->hEvent;
            
            APCFunction = NULL;
            if (Event)
            {
                APCContext = NULL;
            }
            else
            {
                APCContext = (PMSAFD_SEND_APC_CONTEXT)lpOverlapped;
            }
        }
 
        SendInfo.AfdFlags |= AFD_OVERLAPPED;
    }
 
    IOSB->Information = 0;
    IOSB->Status = STATUS_PENDING;
 
    /* Send IOCTL */
    Status = NtDeviceIoControlFile((HANDLE)Handle,
                                   Event,
                                   APCFunction,
                                   APCContext,
                                   IOSB,
                                   IOCTL_AFD_SEND_DATAGRAM,
                                   &SendInfo,
                                   sizeof(SendInfo),
                                   NULL,
                                   0);
 
    /* Wait for completion if not overlapped */
    if (!lpOverlapped && Status == STATUS_PENDING)
    {
        /* FIXME: Shouldn't wait infinitely for send... */
        MsafdWaitForAlert(SockEvent);
        Status = IOSB->Status;
    }
 
    NtClose(SockEvent);
 
    if (Status == STATUS_PENDING)
    {
        TRACE("Leaving (Pending)\n");
        return MsafdReturnWithErrno(Status, lpErrno, 0, NULL);
    }
 
    NumberOfBytesSent = (DWORD)IOSB->Information;
 
    /* Re-enable Async Event */
    SockReenableAsyncSelectEvent(Socket, FD_WRITE);
 
    TRACE("Leaving (%lx %ld)\n", Status, NumberOfBytesSent);
    return MsafdReturnWithErrno(Status, lpErrno, NumberOfBytesSent, lpNumberOfBytesSent);
}

Referenced by WSPStartup().