overlap.cpp File Reference

#include "lspdef.h"
#include <stdio.h>
#include <stdlib.h>

Include dependency graph for overlap.cpp:

Go to the source code of this file.

Functions
LPWSAOVERLAPPEDPLUS	AllocOverlappedStructure (SOCK_INFO *SocketContext)
void	FreeOverlappedStructure (WSAOVERLAPPEDPLUS *olp)
int	ExecuteOverlappedOperation (WSAOVERLAPPEDPLUS *lpOverlapped, BOOL bSynchronous)
int	EnqueueOverlappedOperation (WSAOVERLAPPEDPLUS *op)
void	SetOverlappedInProgress (OVERLAPPED *ol)
DWORD WINAPI	OverlappedManagerThread (LPVOID lpParam)
VOID CALLBACK	CallUserApcProc (ULONG_PTR Context)
void	CheckForContextCleanup (WSAOVERLAPPEDPLUS *ol)
int	InitOverlappedManager ()
int	StopOverlappedManager ()
int	QueueOverlappedOperation (WSAOVERLAPPEDPLUS *ol, SOCK_INFO *SocketContext)
WSAOVERLAPPEDPLUS *	DequeueOverlappedOperation ()
void CALLBACK	IntermediateCompletionRoutine (DWORD dwError, DWORD cbTransferred, LPWSAOVERLAPPED lpOverlapped, DWORD dwFlags)
WSAOVERLAPPEDPLUS *	PrepareOverlappedOperation (SOCK_INFO *SocketContext, LspOperation operation, WSABUF *lpBuffers, DWORD dwBufferCount, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, int *lpErrno)
void	UndoOverlappedOperation (SOCK_INFO *SocketContext, WSAOVERLAPPEDPLUS *ProviderOverlapped)
void	FreeOverlappedLookasideList ()
Variables
HANDLE *	gWorkerThread = NULL
HANDLE	gWakeupSemaphore = NULL
HANDLE	gIocp = NULL
DWORD	gThreadCount = (DWORD)-1

---

Function Documentation

LPWSAOVERLAPPEDPLUS AllocOverlappedStructure

(

SOCK_INFO *

SocketContext

)

Definition at line 913 of file overlap.cpp.

{
    LPWSAOVERLAPPEDPLUS lpWorkerOverlappedPlus = NULL;

    if ( NULL == SocketContext )
    {
        dbgprint("AllocOverlappedStructure: SocketContext is NULL!");
        return NULL;
    }

    EnterCriticalSection( &gOverlappedCS );

    AcquireSocketLock( SocketContext );

    //
    // We have to keep track of the number of outstanding overlapped requests 
    // an application has. Otherwise, if the app were to close a socket that 
    // had oustanding overlapped ops remaining, we'd start leaking structures 
    // in gOverlappedPool. The idea here is to force the CallerSocket to remain 
    // open until the lower provider has processed all the overlapped requests. 
    // If we closed both the lower socket and the caller socket, we would no 
    // longer be able to correlate completed requests to any apps sockets.
    //
    (SocketContext->dwOutstandingAsync)++;

    if ( IsListEmpty( &gFreeOverlappedPlus ) )
    {
        int     err;

        lpWorkerOverlappedPlus = (WSAOVERLAPPEDPLUS *) LspAlloc( 
                sizeof(WSAOVERLAPPEDPLUS), 
               &err 
                );
    }
    else
    {
        LIST_ENTRY  *entry = NULL;

        entry = RemoveHeadList( &gFreeOverlappedPlus );

        lpWorkerOverlappedPlus = CONTAINING_RECORD( entry, WSAOVERLAPPEDPLUS, Link );
    }

    ReleaseSocketLock( SocketContext );

    LeaveCriticalSection( &gOverlappedCS );

    return lpWorkerOverlappedPlus;
}

VOID CALLBACK CallUserApcProc

(

ULONG_PTR

Context

)

Definition at line 1255 of file overlap.cpp.

{
    LPOVERLAPPED                        lpOverlapped;
    LPWSAOVERLAPPED_COMPLETION_ROUTINE  UserCompletionRoutine;

    lpOverlapped = (LPOVERLAPPED) Context;
    UserCompletionRoutine  = (LPWSAOVERLAPPED_COMPLETION_ROUTINE)lpOverlapped->Internal;
    lpOverlapped->Internal = 0; // Remove the WSS_OPERATION_IN_PROGRESS value 

    UserCompletionRoutine(
            (DWORD)lpOverlapped->OffsetHigh,
            (DWORD)lpOverlapped->InternalHigh,
            lpOverlapped,
            (DWORD)lpOverlapped->Offset
            );
    return;
}

void CheckForContextCleanup

(

WSAOVERLAPPEDPLUS *

ol

)

Definition at line 1285 of file overlap.cpp.

{
    SOCK_INFO  *SocketContext = NULL;
    int         Error,
                ret;

    SocketContext = FindAndRefSocketContext( ol->CallerSocket, &Error );
    if ( NULL == SocketContext )
    {
        dbgprint( "CheckForContextCleanup: FindAndRefSocketContext failed!" );
        return;
    }

    EnterCriticalSection( &gCriticalSection );

    AcquireSocketLock( ol->SockInfo );

    (ol->SockInfo->dwOutstandingAsync)--;

    if ( ( TRUE == ol->SockInfo->bClosing ) && 
         ( 0 == ol->SockInfo->dwOutstandingAsync ) &&
         ( 1 == ol->SockInfo->RefCount )
       )
    {
        //
        // If the calling app closed the socket while there were still outstanding
        //  async operations then all the outstanding operations have completed so
        //  we can close the apps socket handle.
        //
        ret = gMainUpCallTable.lpWPUCloseSocketHandle(
                ol->CallerSocket, 
               &ol->Error
                );
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("CheckForContextClenaup: WPUCloseSocketHandle() failed: %d", ol->Error);
        }

        ol->SockInfo->LayeredSocket = INVALID_SOCKET;

        RemoveSocketInfo( ol->SockInfo->Provider, ol->SockInfo );

        dbgprint("CheckForContxtCleanup: Closing socket %d Bytes Sent [%lu] Bytes Recv [%lu]", 
                ol->CallerSocket, ol->SockInfo->BytesSent, ol->SockInfo->BytesRecv);

        ReleaseSocketLock( ol->SockInfo );

        ol->SockInfo = NULL;

        FreeSockInfo( SocketContext );

        goto cleanup;
    }

    ReleaseSocketLock( ol->SockInfo );

    DerefSocketContext( SocketContext, &Error );

cleanup:

    LeaveCriticalSection( &gCriticalSection );

    return;
}

WSAOVERLAPPEDPLUS* DequeueOverlappedOperation

(

)

Definition at line 472 of file overlap.cpp.

{
    WSAOVERLAPPEDPLUS   *op = NULL;
    LIST_ENTRY         *link = NULL;

    EnterCriticalSection( &gOverlappedCS );

    link = RemoveHeadList( &gPendingOperations );

    op = CONTAINING_RECORD( link, WSAOVERLAPPEDPLUS, Link );

    /*
    op = gPendingStart;
    if ( NULL != gPendingStart )
    {
        gPendingStart = op->next;
    }
    if (op == gPendingEnd)
    {
        gPendingStart = gPendingEnd = NULL;
    }
    */

    LeaveCriticalSection( &gOverlappedCS );

    return op;
}

int EnqueueOverlappedOperation

(

WSAOVERLAPPEDPLUS *

op

)

Definition at line 433 of file overlap.cpp.

{
    int ret = WSA_IO_PENDING;

    EnterCriticalSection( &gOverlappedCS );

    if ( NULL == op )
    {
        dbgprint("EnqueueOverlappedOperation: op == NULL!");
        ret = WSAEFAULT;
        goto cleanup;
    }

    InsertTailList( &gPendingOperations, &op->Link );

    //
    // Increment the semaphore count. This lets the worker thread
    // know that there are pending overlapped operations to execute.
    //
    ReleaseSemaphore( gWakeupSemaphore, 1, NULL );

cleanup:

    LeaveCriticalSection( &gOverlappedCS );

    return ret;
}

int ExecuteOverlappedOperation	(	WSAOVERLAPPEDPLUS *	lpOverlapped,
		BOOL	bSynchronous
	)

Definition at line 512 of file overlap.cpp.

{
    LPWSAOVERLAPPED_COMPLETION_ROUTINE   routine = NULL;
    PROVIDER                            *Provider;
    DWORD                               *lpdwFlags = NULL,
                                        *lpdwBytes = NULL;
    int                                  ret=SOCKET_ERROR, err=0;

    if ( NULL == gIocp)
        routine = IntermediateCompletionRoutine;

    Provider = ol->Provider;

    //
    // Reset the event handle if present. The handle is masked with 0xFFFFFFFE in
    //  order to zero out the last bit. If the last bit is one and the socket is
    //  associated with a compeltion port then when an overlapped operation is 
    //  called, the operation is not posted to the IO completion port.
    //
    if ( NULL != ol->lpCallerOverlapped->hEvent )
    {
        ULONG_PTR   ptr = 1;

        ResetEvent( (HANDLE) ( (ULONG_PTR) ol->lpCallerOverlapped->hEvent & ~ptr ) );
    }

    switch ( ol->Operation )
    {
        case LSP_OP_IOCTL:
            lpdwFlags = NULL;
            lpdwBytes = &ol->IoctlArgs.cbBytesReturned;
            ret = Provider->NextProcTable.lpWSPIoctl(
                    ol->ProviderSocket,
                    ol->IoctlArgs.dwIoControlCode,
                    ol->IoctlArgs.lpvInBuffer,
                    ol->IoctlArgs.cbInBuffer,
                    ol->IoctlArgs.lpvOutBuffer,
                    ol->IoctlArgs.cbOutBuffer,
                   &ol->IoctlArgs.cbBytesReturned,
                   &ol->ProviderOverlapped,
                    routine,
                   &ol->CallerThreadId,
                   &err
                   );
            break;                         

        case LSP_OP_RECV:
            lpdwFlags = &ol->RecvArgs.dwFlags;
            lpdwBytes = &ol->RecvArgs.dwNumberOfBytesRecvd;
            ret = Provider->NextProcTable.lpWSPRecv(
                    ol->ProviderSocket,
                    ol->RecvArgs.lpBuffers,
                    ol->RecvArgs.dwBufferCount,
                   &ol->RecvArgs.dwNumberOfBytesRecvd,
                   &ol->RecvArgs.dwFlags,
                   &ol->ProviderOverlapped,
                    routine,
                   &ol->CallerThreadId,
                   &err
                    );
            break;

        case LSP_OP_RECVFROM:
            lpdwFlags = &ol->RecvFromArgs.dwFlags;
            lpdwBytes = &ol->RecvFromArgs.dwNumberOfBytesRecvd;
            ret = Provider->NextProcTable.lpWSPRecvFrom(
                    ol->ProviderSocket,
                    ol->RecvFromArgs.lpBuffers,
                    ol->RecvFromArgs.dwBufferCount,
                   &ol->RecvFromArgs.dwNumberOfBytesRecvd,
                   &ol->RecvFromArgs.dwFlags,
                    ol->RecvFromArgs.lpFrom,
                    ol->RecvFromArgs.lpFromLen,
                   &ol->ProviderOverlapped,
                    routine,
                   &ol->CallerThreadId,
                   &err
                    );
            break;

        case LSP_OP_SEND:
            lpdwFlags = &ol->SendArgs.dwFlags;
            lpdwBytes = &ol->SendArgs.dwNumberOfBytesSent;
            ret = Provider->NextProcTable.lpWSPSend(
                    ol->ProviderSocket,
                    ol->SendArgs.lpBuffers,
                    ol->SendArgs.dwBufferCount,
                   &ol->SendArgs.dwNumberOfBytesSent,
                    ol->SendArgs.dwFlags,
                   &ol->ProviderOverlapped,
                    routine,
                   &ol->CallerThreadId,
                   &err
                   );
             break;

        case LSP_OP_SENDTO:
            lpdwFlags = &ol->SendToArgs.dwFlags;
            lpdwBytes = &ol->SendToArgs.dwNumberOfBytesSent;
            ret = Provider->NextProcTable.lpWSPSendTo(
                    ol->ProviderSocket,
                    ol->SendToArgs.lpBuffers,
                    ol->SendToArgs.dwBufferCount,
                   &ol->SendToArgs.dwNumberOfBytesSent,
                    ol->SendToArgs.dwFlags,
                    (SOCKADDR *)&ol->SendToArgs.To,
                    ol->SendToArgs.iToLen,
                   &ol->ProviderOverlapped,
                    routine,
                   &ol->CallerThreadId,
                   &err
                    );
            break;

        case LSP_OP_TRANSMITFILE:
            lpdwFlags = &ol->TransmitFileArgs.dwFlags;
            lpdwBytes = NULL;
            ret = Provider->NextProcTableExt.lpfnTransmitFile(
                    ol->ProviderSocket,
                    ol->TransmitFileArgs.hFile,
                    ol->TransmitFileArgs.nNumberOfBytesToWrite,
                    ol->TransmitFileArgs.nNumberOfBytesPerSend,
                   &ol->ProviderOverlapped,
                    ol->TransmitFileArgs.lpTransmitBuffers,
                    ol->TransmitFileArgs.dwFlags
                    );
            if ( FALSE == ret )
            {
                ret = SOCKET_ERROR;
                err = WSAGetLastError();
                WSASetLastError(err);
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        case LSP_OP_ACCEPTEX:
            lpdwFlags = NULL;
            lpdwBytes = &ol->AcceptExArgs.dwBytesReceived;
            ret = Provider->NextProcTableExt.lpfnAcceptEx(
                    ol->ProviderSocket,
                    ol->AcceptExArgs.sProviderAcceptSocket,
                    ol->AcceptExArgs.lpOutputBuffer,
                    ol->AcceptExArgs.dwReceiveDataLength,
                    ol->AcceptExArgs.dwLocalAddressLength,
                    ol->AcceptExArgs.dwRemoteAddressLength,
                   &ol->AcceptExArgs.dwBytesReceived,
                   &ol->ProviderOverlapped
                    );
            if ( FALSE == ret )
            {
                ret = SOCKET_ERROR;
                err = WSAGetLastError();
                WSASetLastError(err);
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        case LSP_OP_CONNECTEX:
            lpdwFlags = NULL;
            lpdwBytes = &ol->ConnectExArgs.dwBytesSent;
            ret = Provider->NextProcTableExt.lpfnConnectEx(
                    ol->ProviderSocket,
                    (SOCKADDR *)&ol->ConnectExArgs.name,
                    ol->ConnectExArgs.namelen,
                    ol->ConnectExArgs.lpSendBuffer,
                    ol->ConnectExArgs.dwSendDataLength,
                   &ol->ConnectExArgs.dwBytesSent,
                   &ol->ProviderOverlapped
                    );
            if ( FALSE == ret )
            {
                ret = SOCKET_ERROR;
                err = WSAGetLastError();
                WSASetLastError(err);
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        case LSP_OP_DISCONNECTEX:
            lpdwFlags = &ol->DisconnectExArgs.dwFlags;
            lpdwBytes = NULL;
            ret = Provider->NextProcTableExt.lpfnDisconnectEx(
                    ol->ProviderSocket,
                   &ol->ProviderOverlapped,
                    ol->DisconnectExArgs.dwFlags,
                    ol->DisconnectExArgs.dwReserved
                    );
            if ( FALSE == ret )
            {
                ret = SOCKET_ERROR;
                err = WSAGetLastError();
                WSASetLastError(err);
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        case LSP_OP_TRANSMITPACKETS:
            lpdwFlags = &ol->TransmitPacketsArgs.dwFlags;
            lpdwBytes = NULL;
            ret = Provider->NextProcTableExt.lpfnTransmitPackets(
                    ol->ProviderSocket,
                    ol->TransmitPacketsArgs.lpPacketArray,
                    ol->TransmitPacketsArgs.nElementCount,
                    ol->TransmitPacketsArgs.nSendSize,
                   &ol->ProviderOverlapped,
                    ol->TransmitPacketsArgs.dwFlags
                    );
            if ( FALSE == ret )
            {
                ret = SOCKET_ERROR;
                err = WSAGetLastError();
                WSASetLastError(err);
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        case LSP_OP_WSARECVMSG:
            lpdwFlags = NULL;
            lpdwBytes = &ol->WSARecvMsgArgs.dwNumberOfBytesRecvd;
            ret = Provider->NextProcTableExt.lpfnWSARecvMsg(
                    ol->ProviderSocket,
                    ol->WSARecvMsgArgs.lpMsg,
                   &ol->WSARecvMsgArgs.dwNumberOfBytesRecvd,
                   &ol->ProviderOverlapped,
                    routine
                    );
            if ( SOCKET_ERROR == ret )
            {
                err = WSAGetLastError();
                WSASetLastError( err );
            }
            else
            {
                ret = NO_ERROR;
            }
            break;

        default:
            dbgprint("ExecuteOverlappedOperation: Unknown operation!");
            ret = SOCKET_ERROR;
            break;
    }

    if ( ( NO_ERROR != ret ) && ( WSA_IO_PENDING != err ) )
    {
        //
        // If the call immediately fails, update the OVERLAPPED info and return
        //
        ol->lpCallerOverlapped->Offset       = (lpdwFlags ? *lpdwFlags : 0);
        ol->lpCallerOverlapped->OffsetHigh   = err;
        ol->lpCallerOverlapped->InternalHigh = (lpdwBytes ? *lpdwBytes : 0);
        ol->lpCallerOverlapped->Internal     = 0;

        dbgprint("Overlap op failed immediately: %d", ol->Error);

        CheckForContextCleanup( ol );

        FreeOverlappedStructure( ol );
    }
    else if ( ( NO_ERROR == ret ) && ( FALSE == bSynchronous ) )
    {
        // 
        // NOTE: We could return success from here, but if you want to perform
        //       some post processing on the data buffers before indicating
        //       success to the upper layer (because once success is returned, the
        //       upper layer can inspect the buffers). Because of this we return
        //       pending and in the completion processing (either via IOCP or
        //       APC), we can do post processing there.
        //
        err = WSA_IO_PENDING;
        ret = SOCKET_ERROR;
    }
    else if ( ( NO_ERROR == ret ) && ( TRUE == bSynchronous ) )
    {
        // The winsock call actually blocked and there will be no completion
        // notification on the IOCP.
        //
        dbgprint("Succeeded without error - synchronous socket though");
    }

    return ( ( NO_ERROR == ret ) ? ret : err );
}

void FreeOverlappedLookasideList

(

)

Definition at line 1545 of file overlap.cpp.

{
    WSAOVERLAPPEDPLUS  *olp = NULL;
    LIST_ENTRY         *entry = NULL;

    EnterCriticalSection( &gOverlappedCS );

    while ( ! IsListEmpty( &gFreeOverlappedPlus ) )
    {
        entry = RemoveHeadList( &gFreeOverlappedPlus );

        olp = CONTAINING_RECORD( entry, WSAOVERLAPPEDPLUS, Link );

        LspFree( olp );
    }

    LeaveCriticalSection( &gOverlappedCS );
}

void FreeOverlappedStructure

(

WSAOVERLAPPEDPLUS *

olp

)

Definition at line 973 of file overlap.cpp.

{
    EnterCriticalSection( &gOverlappedCS );

    switch ( olp->Operation )
    {
        case LSP_OP_RECV:
            FreeWSABuf( olp->RecvArgs.lpBuffers );
            break;

        case LSP_OP_RECVFROM:
            FreeWSABuf( olp->RecvFromArgs.lpBuffers );
            break;

        case LSP_OP_SEND:
            FreeWSABuf( olp->SendArgs.lpBuffers );
            break;

        case LSP_OP_SENDTO:
            FreeWSABuf( olp->SendToArgs.lpBuffers );
            break;

        default:
            break;
    }

    memset( olp, 0, sizeof( WSAOVERLAPPEDPLUS ) );

    InsertHeadList( &gFreeOverlappedPlus, &olp->Link );

    LeaveCriticalSection( &gOverlappedCS );
}

int InitOverlappedManager

(

)

Definition at line 127 of file overlap.cpp.

{
    DWORD   i;
    int     ret = NO_ERROR;

    EnterCriticalSection( &gOverlappedCS );

    //
    // Make sure we're not already initialized -- we'll always have at least
    // one worker thread running
    //
    if ( NULL != gWorkerThread )
        goto cleanup;

    InitializeListHead( &gFreeOverlappedPlus );
    InitializeListHead( &gPendingOperations );

    //
    // See if we're on NT by trying to create the completion port. If it
    //  fails then we're on Win9x.
    //
    gIocp = CreateIoCompletionPort(
            INVALID_HANDLE_VALUE,
            NULL,
            (ULONG_PTR)0,
            0
            );
    if ( NULL != gIocp )
    {
        SYSTEM_INFO     sinfo;

        //
        // We're on NT so figure out how many processors we have
        //
        GetSystemInfo( &sinfo );
        gThreadCount = sinfo.dwNumberOfProcessors;
    }
    else
    {
        //
        // We're on Win9x so create a semaphore instead. This is used to
        //  wake up the worker thread to service overlapped IO calls.
        //
        gWakeupSemaphore = CreateSemaphore(
                NULL,
                0,
                MAXLONG,
                NULL
                );
        if ( NULL == gWakeupSemaphore )
        {
            dbgprint("InitOverlappedManager: CreateSemaphore() failed: %d", GetLastError());
            ret = WSAEPROVIDERFAILEDINIT;
            goto cleanup;
        }

        //
        // This is Win9x, no multiproc support so create just a single thread
        //
        gThreadCount = 1;
    }

    dbgprint("Creating %d threads", gThreadCount);

    gWorkerThread = (HANDLE *) LspAlloc(
            sizeof( HANDLE ) * gThreadCount,
           &ret         // if fails, ret will be WSAENOBUFS
            );
    if ( NULL == gWorkerThread )
    {
        goto cleanup;
    }

    //
    // Create our worker threads
    //
    for(i=0; i < gThreadCount ;i++)
    {
        gWorkerThread[i] = CreateThread(
                NULL, 
                0, 
                OverlappedManagerThread, 
                (LPVOID)gIocp, 
                0, 
                NULL
                );
        if ( NULL == gWorkerThread[ i ] )
        {
            dbgprint("InitOverlappedManager: CreateThread() failed: %d", GetLastError());
            ret = WSAEPROVIDERFAILEDINIT;
            goto cleanup;
        }
    }

cleanup:

    LeaveCriticalSection( &gOverlappedCS );

    return ret;
}

void CALLBACK IntermediateCompletionRoutine	(	DWORD	dwError,
		DWORD	cbTransferred,
		LPWSAOVERLAPPED	lpOverlapped,
		DWORD	dwFlags
	)

Definition at line 1033 of file overlap.cpp.

{
    LPWSAOVERLAPPEDPLUS olp = NULL;
    SOCK_INFO          *SocketContext = NULL,
                       *AcceptSocketContext = NULL;
    int                 Error,
                        ret;

    if ( NULL == lpOverlapped )
    {
        dbgprint("IntermediateCompletionRoutine: lpOverlapped == NULL!");
        goto cleanup;
    }

    ASSERT( lpOverlapped );

    olp = CONTAINING_RECORD( lpOverlapped, WSAOVERLAPPEDPLUS, ProviderOverlapped );

    //
    // We actually already have the socket context for this operation (its in
    //    the WSAOVERLAPPEDPLUS structure but do this anyway to make sure the
    //    socket hasn't been closed as well as to increment the ref count while
    //    we're accessing the SOCK_INFO structure.
    //
    SocketContext = FindAndRefSocketContext(olp->CallerSocket, &Error);
    if ( NULL == SocketContext )
    {
        dbgprint( "IntermediateCompletionRoutine: FindAndRefSocketContext failed!" );
        goto cleanup;
    }

    if ( WSA_IO_PENDING == dwError )
    {
        //
        // Get the results of the operation
        //

        ASSERT( olp->Provider );
        ASSERT( olp->Provider->NextProcTable.lpWSPGetOverlappedResult );

        dwError = NO_ERROR;
        ret = olp->Provider->NextProcTable.lpWSPGetOverlappedResult(
                olp->ProviderSocket,
                lpOverlapped,
               &cbTransferred,
                FALSE,
               &dwFlags,
                (int *)&dwError
                );
 
        if ( FALSE == ret )
        {
            dbgprint("IntermediateCompletionRoutine: WSPGetOverlappedResult failed: %d", dwError);
        }
        else
        {

            dbgprint("Bytes transferred on socket 0x%x: %d [op=%d; err=%d]", 
                    olp->CallerSocket, cbTransferred, olp->Operation, dwError);
        }
    }

    olp->lpCallerOverlapped->Offset       = dwFlags;
    olp->lpCallerOverlapped->OffsetHigh   = dwError;
    olp->lpCallerOverlapped->InternalHigh = cbTransferred;

    SocketContext->LastError = dwError;

    if ( 0 == dwError )
    {
        AcquireSocketLock( SocketContext );

        //
        // NOTE: This is where any post processing should go for overlapped operations.
        //       For example, if you wanted to inspect the data received, you would do
        //       that here for any operation that receives data (don't forget AcceptEx!).
        //       In this sample, all we do is count the bytes sent and received on the
        //       socket.
        //

        switch ( olp->Operation )
        {
            case LSP_OP_RECV:
                SocketContext->BytesRecv += cbTransferred;
                FreeWSABuf(olp->RecvArgs.lpBuffers);
                break;

            case LSP_OP_RECVFROM:
                SocketContext->BytesRecv += cbTransferred;
                FreeWSABuf(olp->RecvFromArgs.lpBuffers);
                break;

            case LSP_OP_SEND:
                SocketContext->BytesSent += cbTransferred;
                FreeWSABuf(olp->SendArgs.lpBuffers);
                break;

            case LSP_OP_SENDTO:
                SocketContext->BytesSent += cbTransferred;
                FreeWSABuf(olp->SendToArgs.lpBuffers);
                break;

            case LSP_OP_TRANSMITFILE:
                SocketContext->BytesSent += cbTransferred;
                break;

            case LSP_OP_TRANSMITPACKETS:
                SocketContext->BytesSent += cbTransferred;
                break;

            case LSP_OP_ACCEPTEX:

                ReleaseSocketLock( SocketContext );

                AcceptSocketContext = FindAndRefSocketContext(
                        olp->AcceptExArgs.sAcceptSocket,
                       &Error
                       );
                if (AcceptSocketContext == NULL)
                {
                    dbgprint( "IntermediateCompletionRoutine: FindAndRefSocketContext failed! (LSP_OP_ACCEPTEX)" );
                }
                AcquireSocketLock( AcceptSocketContext );

                AcceptSocketContext->BytesRecv += cbTransferred;

                ReleaseSocketLock( AcceptSocketContext );

                DerefSocketContext(AcceptSocketContext, &Error);

                break;

            case LSP_OP_CONNECTEX:
                SocketContext->BytesSent += cbTransferred;
                break;

            case LSP_OP_WSARECVMSG:
                SocketContext->BytesRecv += cbTransferred;
                break;

            default:
                break;
        }
        // Already released for AcceptEx operations
        if ( LSP_OP_ACCEPTEX != olp->Operation )
            ReleaseSocketLock( SocketContext );
    }

    DerefSocketContext( SocketContext, &Error );

    if ( NULL != olp->lpCallerCompletionRoutine )
    {
        //
        // If the app supplied a completion routine, queue it up for completion
        //
        olp->lpCallerOverlapped->Internal = (ULONG_PTR)olp->lpCallerCompletionRoutine;

        ret = gMainUpCallTable.lpWPUQueueApc(
               &olp->CallerThreadId,
               CallUserApcProc,
               (DWORD_PTR) olp->lpCallerOverlapped,
              &Error
               );
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("IntermediateCompletionRoutine: WPUQueueApc() failed: %d", Error);
        }
    }
    else
    {
        //
        // Otherwise we signal that the op has completed
        //
        ret = WPUCompleteOverlappedRequest(
                olp->CallerSocket,
                olp->lpCallerOverlapped,
                dwError,
                cbTransferred,
               &Error
                );
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("WPUCompleteOverlappedRequest failed: %d (provider socket 0x%x)", 
                    Error, olp->CallerSocket );
        }
    }

    if ( ( NULL != olp ) && ( TRUE == olp->CloseThread ) )
    {
        ret = gMainUpCallTable.lpWPUCloseThread( &olp->CallerThreadId, &Error );
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("WPUCloseThread failed: %d", Error );
        }
        olp->CloseThread = FALSE;
    }

    //
    // Cleanup the accounting on the socket
    //
    CheckForContextCleanup( olp );

cleanup:

    if ( NULL != olp )
        FreeOverlappedStructure( olp );

    return;
}

DWORD WINAPI OverlappedManagerThread

(

LPVOID

lpParam

)

Definition at line 822 of file overlap.cpp.

{
    WSAOVERLAPPEDPLUS *pOverlapPlus = NULL;
    WSAOVERLAPPED     *pOverlap = NULL;
    HANDLE             hIocp = (HANDLE)lpParam;
    ULONG_PTR          key;
    DWORD              dwBytesXfered;
    int                ret;

    while ( TRUE )
    {
        if ( NULL != hIocp )
        {
            ret = GetQueuedCompletionStatus(
                    hIocp,
                   &dwBytesXfered,
                   &key,
                   &pOverlap,
                    INFINITE
                    );
            if ( 0 == ret )
            {
                // Socket failures could be reported here so we still
                // call IntermediateCompletionRoutine
                dbgprint("GetQueuedCompletionStatus() failed: %d", GetLastError());
            }

            if ( -1 == dwBytesXfered )
            {
                //
                // StopOverlappedManager will send a completion packet with -1
                //    bytes transfered to indicate the completion routine
                //    should exit
                //
                dbgprint("OverlappedManagerThread: Received exit message");
                goto cleanup;
            }

            // Handle the IO that completed
            IntermediateCompletionRoutine(
                    WSA_IO_PENDING,
                    dwBytesXfered,
                    pOverlap,
                    0
                    );
        }
        else
        {
            ret = WaitForSingleObjectEx(
                    gWakeupSemaphore,
                    INFINITE, 
                    TRUE
                    );
            if ( WAIT_IO_COMPLETION == ret )
            {
                // An APC fired so keep waiting until semaphore is signaled
                continue;
            }
            else if ( WAIT_OBJECT_0 == ret )
            {
                pOverlapPlus = DequeueOverlappedOperation();
                if ( NULL == pOverlapPlus )
                    continue;

                ExecuteOverlappedOperation( pOverlapPlus, FALSE );
            }
            else
            {
                dbgprint("OverlappedManagerThread: WaitForSingleObjectEx() failed: %d (error = %d)",
                        ret, GetLastError() );
                goto cleanup;
            }
        }
    }

cleanup:

    ExitThread( 0 );
}

WSAOVERLAPPEDPLUS* PrepareOverlappedOperation	(	SOCK_INFO *	SocketContext,
		LspOperation	operation,
		WSABUF *	lpBuffers,
		DWORD	dwBufferCount,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		int *	lpErrno
	)

Definition at line 1361 of file overlap.cpp.

{
    WSAOVERLAPPEDPLUS *ProviderOverlapped = NULL;
    int                ret = SOCKET_ERROR,
                       err = 0;

    // Allocate a WSAOVERLAPPEDPLUS structure
    ProviderOverlapped = AllocOverlappedStructure( SocketContext );
    if ( NULL == ProviderOverlapped )
    {
        *lpErrno = WSAENOBUFS;
        goto cleanup;
    }

    __try 
    {
        // Check for an event and reset if. Also, copy the offsets from the upper
        // layer's WSAOVERLAPPED structure.
        if ( ( NULL == lpCompletionRoutine ) && 
             ( NULL != lpOverlapped->hEvent ) )
        { 
            ULONG_PTR   ptr = 1;

            ret = ResetEvent( (HANDLE) ( (ULONG_PTR) lpOverlapped->hEvent & ~ptr ) );
            if (ret == 0)
            {
                *lpErrno = ERROR_INVALID_HANDLE;
                ret = SOCKET_ERROR;
                goto cleanup;
            }
        }

        // Copy any offset information from the caller's overlapped to ours
        CopyOffset( &ProviderOverlapped->ProviderOverlapped, lpOverlapped );

    }
    __except(EXCEPTION_EXECUTE_HANDLER)
    {
        *lpErrno = WSAEFAULT;
        goto cleanup;
    }

    if ( NULL != lpThreadId )
    {
        ProviderOverlapped->CallerThreadId = *lpThreadId;
    }
    else
    {
        // If thread info wasn't passed to us, we need to open the thread context
        ret = gMainUpCallTable.lpWPUOpenCurrentThread( &ProviderOverlapped->CallerThreadId, &err );
        if ( SOCKET_ERROR == ret )
        {
            dbgprint("WPUOpenCurrentThread failed: %d", err);
        }
        else
        {
            // Need to remember for later to close the context since we opened it
            ProviderOverlapped->CloseThread = TRUE;
        }
    }

    // Fill in the remaining fields
    ProviderOverlapped->Provider           = SocketContext->Provider;
    ProviderOverlapped->lpCallerOverlapped = lpOverlapped;
    ProviderOverlapped->lpCallerCompletionRoutine = lpCompletionRoutine;
    ProviderOverlapped->SockInfo           = SocketContext;
    ProviderOverlapped->CallerSocket       = SocketContext->LayeredSocket;
    ProviderOverlapped->ProviderSocket     = SocketContext->ProviderSocket;
    ProviderOverlapped->Error              = NO_ERROR;
    ProviderOverlapped->Operation          = operation;

    if ( ( NULL != lpBuffers) && ( dwBufferCount ) )
    {
        // Depending on the underlying operation, copy some parameters specific to it
        switch ( operation )
        {
            case LSP_OP_RECV:
                ProviderOverlapped->RecvArgs.dwBufferCount = dwBufferCount;
                ProviderOverlapped->RecvArgs.lpBuffers = CopyWSABuf(
                        lpBuffers,
                        dwBufferCount,
                        lpErrno
                        );
                if ( NULL == ProviderOverlapped->RecvArgs.lpBuffers )
                    goto cleanup;

                break;

            case LSP_OP_RECVFROM:
                ProviderOverlapped->RecvFromArgs.dwBufferCount = dwBufferCount;
                ProviderOverlapped->RecvFromArgs.lpBuffers = CopyWSABuf(
                        lpBuffers,
                        dwBufferCount,
                        lpErrno
                        );
                if ( NULL == ProviderOverlapped->RecvFromArgs.lpBuffers )
                    goto cleanup;

                break;

            case LSP_OP_SEND:
                ProviderOverlapped->SendArgs.dwBufferCount = dwBufferCount;
                ProviderOverlapped->SendArgs.lpBuffers = CopyWSABuf(
                        lpBuffers,
                        dwBufferCount,
                        lpErrno
                        );
                if ( NULL == ProviderOverlapped->SendArgs.lpBuffers )
                    goto cleanup;

                break;
              
            case LSP_OP_SENDTO:
                ProviderOverlapped->SendToArgs.dwBufferCount = dwBufferCount;
                ProviderOverlapped->SendToArgs.lpBuffers = CopyWSABuf(
                        lpBuffers,
                        dwBufferCount,
                        lpErrno
                        );
                if ( NULL == ProviderOverlapped->SendToArgs.lpBuffers )
                    goto cleanup;

                break;

            default:
                break;
        }
    }

    ret = NO_ERROR;

cleanup:

    if ( SOCKET_ERROR == ret )
    {
        UndoOverlappedOperation( SocketContext, ProviderOverlapped );
        ProviderOverlapped = NULL;
    }
    else
    {
        ASSERT( NO_ERROR == ret );
    }

    return ProviderOverlapped;
}

int QueueOverlappedOperation	(	WSAOVERLAPPEDPLUS *	ol,
		SOCK_INFO *	SocketContext
	)

Definition at line 344 of file overlap.cpp.

{
    BOOL    bSynchronous = FALSE;
    int     err;

    //
    // Set the fields of the overlapped to indicate IO is not complete yet
    //

    __try
    {
        SetOverlappedInProgress( ol->lpCallerOverlapped );
    } 
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
        return WSAEFAULT;
    }

    if ( NULL != gIocp )
    {
        //
        // If we haven't already added the provider socket to the IOCP then
        //  do it now.
        //
        AcquireSocketLock( SocketContext );

        if ( NULL == SocketContext->hIocp )
        {
            SocketContext->hIocp = CreateIoCompletionPort(
                    (HANDLE)ol->ProviderSocket,
                    gIocp,
                    ol->CallerSocket,
                    0
                    );
            if ( NULL == SocketContext->hIocp )
            {
                if ( ERROR_INVALID_PARAMETER == (err = GetLastError() ) )
                {
                    //
                    // If the socket option SO_SYNCHRONOUS_(NON)ALERT is set then 
                    // no overlapped operation can be performed on that socket and 
                    // tryiing to associate it with a completion port will fail. 
                    // The other bad news is that an LSP cannot trap this setsockopt 
                    // call. In reality we don't have to do anything. If an app sets 
                    // this option and then makes overlapped calls anyway, then they 
                    // shouldn't be expecting any overlapped notifications! This 
                    // statement is put here in case you want to mark the socket
                    // info structure as synchronous.
                    //
                    bSynchronous = TRUE;
                }
                else
                {
                    dbgprint("QueueOverlappedOperation: CreateIoCompletionPort() "
                              "failed: %d (Prov %d Iocp 0x%x Caller 0x%x 0)", 
                            err, ol->ProviderSocket, 
                            gIocp, ol->CallerSocket);
                }
            }

            dbgprint("Adding provider handle %X to IOCP", ol->ProviderSocket);
        }

        ReleaseSocketLock( SocketContext );

        //
        // Simply execute the operation
        //
        return ExecuteOverlappedOperation( ol, bSynchronous );
    }
    else
    {
        // Queue up the operation for the worker thread to initiate
        //
        return EnqueueOverlappedOperation( ol );
    }
}

void SetOverlappedInProgress

(

OVERLAPPED *

ol

)

Definition at line 1016 of file overlap.cpp.

{
    ol->Internal = WSS_OPERATION_IN_PROGRESS;
    ol->InternalHigh = 0;
}

int StopOverlappedManager

(

)

Definition at line 238 of file overlap.cpp.

{
    DWORD     i;
    int       ret = NO_ERROR;

    EnterCriticalSection( &gOverlappedCS );

    //
    // Post a completion packet to the IOCP (one for each thread)
    //
    if ( NULL != gIocp )
    {
        for(i=0; i < gThreadCount ;i++)
        {
            ret = PostQueuedCompletionStatus(
                    gIocp,
                    (DWORD)-1,
                    0,
                    NULL
                    );
            if ( 0 == ret )
            {
                dbgprint("PostQueuedCompletionStatus() failed: %d", GetLastError());
            }
        }

        //
        // Wait a while for the threads to get the signal and exit - if it fails or
        // times out then oh well, we need to clean up anyway
        //
    }
    else
    {
        //
        // On Win9x we closed the semaphore so the worker thread should fail
        // when waiting for a signal and break out of the loop.
        // 

        LIST_ENTRY         *entry = NULL;
        WSAOVERLAPPEDPLUS  *olp = NULL;

        while ( !IsListEmpty( &gPendingOperations ) )
        {
            entry = RemoveHeadList( &gPendingOperations );

            olp = CONTAINING_RECORD( entry, WSAOVERLAPPEDPLUS, Link );

            FreeOverlappedStructure( olp );
        }
    }

    if ( NULL != gWorkerThread )
    {
        ret = WaitForMultipleObjectsEx( gThreadCount, gWorkerThread, TRUE, 5000, TRUE );
        if ( WAIT_TIMEOUT == ret )
            dbgprint("StopOverlappedManager: Timed out waiting for IOCP threads to exit!");
        else if ( WAIT_FAILED == ret )
            dbgprint("StopOverlappedManager: WaitForMultipleObjectsEx failed: %d",
                    GetLastError());
        else
            dbgprint("StopOverlappedManager: All worker threads stopped!");

        for(i=0; i < gThreadCount ;i++)
        {
            CloseHandle( gWorkerThread[ i ] );
            gWorkerThread[ i ] = NULL;

            dbgprint("Closing overlapped thread(s)");
        }

        LspFree( gWorkerThread );
        gWorkerThread = NULL;
    }

    //
    // Cleanup remaining handles...
    //
    if ( NULL != gIocp )
    {
        CloseHandle( gIocp );
        gIocp = NULL;
    }

    if ( NULL != gWakeupSemaphore )
    {
        CloseHandle( gWakeupSemaphore );
        gWakeupSemaphore = NULL;
    }

    LeaveCriticalSection( &gOverlappedCS );

    return ret;
}

void UndoOverlappedOperation	(	SOCK_INFO *	SocketContext,
		WSAOVERLAPPEDPLUS *	ProviderOverlapped
	)

Definition at line 1525 of file overlap.cpp.

{
    AcquireSocketLock( SocketContext );
    (SocketContext->dwOutstandingAsync)--;
    ReleaseSocketLock( SocketContext );

    FreeOverlappedStructure( ProviderOverlapped );
}

---

Variable Documentation

HANDLE gIocp = NULL

Definition at line 47 of file overlap.cpp.

DWORD gThreadCount = (DWORD)-1

Definition at line 48 of file overlap.cpp.

HANDLE gWakeupSemaphore = NULL

Definition at line 46 of file overlap.cpp.

HANDLE* gWorkerThread = NULL

Definition at line 45 of file overlap.cpp.