spi.cpp File Reference

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

Include dependency graph for spi.cpp:

Go to the source code of this file.

Defines
#define	DEFAULT_PRINT_BUFFER   512
Functions
int	FindUrl (__in_ecount(buflen) char *buf, int buflen, __out char **start)
BOOL WINAPI	DllMain (IN HINSTANCE hinstDll, IN DWORD dwReason, LPVOID lpvReserved)
int WSPAPI	WSPCleanup (LPINT lpErrno)
int WSPAPI	WSPCloseSocket (SOCKET s, LPINT lpErrno)
int WSPAPI	WSPConnect (SOCKET s, const struct sockaddr FAR *name, int namelen, LPWSABUF lpCallerData, LPWSABUF lpCalleeData, LPQOS lpSQOS, LPQOS lpGQOS, LPINT lpErrno)
int WSPAPI	WSPGetPeerName (SOCKET s, struct sockaddr FAR *name, LPINT namelen, LPINT lpErrno)
int WSPAPI	WSPGetSockOpt (SOCKET s, int level, int optname, __out_bcount(*optlen) char FAR *optval, __inout LPINT optlen, LPINT lpErrno)
int WSPAPI	WSPIoctl (SOCKET s, DWORD dwIoControlCode, LPVOID lpvInBuffer, DWORD cbInBuffer, LPVOID lpvOutBuffer, DWORD cbOutBuffer, LPDWORD lpcbBytesReturned, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
int WSPAPI	WSPSend (SOCKET s, LPWSABUF lpBuffers, DWORD dwBufferCount, LPDWORD lpNumberOfBytesSent, DWORD dwFlags, LPWSAOVERLAPPED lpOverlapped, LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine, LPWSATHREADID lpThreadId, LPINT lpErrno)
SOCKET WSPAPI	WSPSocket (int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags, LPINT lpErrno)
SOCKET WSPAPI	WSPAccept (SOCKET s, struct sockaddr FAR *addr, LPINT addrlen, LPCONDITIONPROC lpfnCondition, DWORD_PTR dwCallbackData, LPINT lpErrno)
int WSPAPI	WSPStartup (WORD wVersion, LPWSPDATA lpWSPData, LPWSAPROTOCOL_INFOW lpProtocolInfo, WSPUPCALLTABLE UpCallTable, LPWSPPROC_TABLE lpProcTable)
void	FindDestinationAddress (SOCKET_CONTEXT *context, const SOCKADDR *destAddr, int destLen, SOCKADDR **proxyAddr, int *proxyLen)
void	FreeLspProviders (PROVIDER *lspProvider, int lspProviderCount, int *lpErrno)
Variables
CRITICAL_SECTION	gCriticalSection
WSPUPCALLTABLE	gMainUpCallTable
LPPROVIDER	gLayerInfo = NULL
int	gLayerCount = 0

---

Define Documentation

#define DEFAULT_PRINT_BUFFER   512

Definition at line 37 of file spi.cpp.

---

Function Documentation

BOOL WINAPI DllMain	(	IN HINSTANCE	hinstDll,
		IN DWORD	dwReason,
		LPVOID	lpvReserved
	)

Definition at line 81 of file spi.cpp.

{
    UNREFERENCED_PARAMETER( hinstDll );
    UNREFERENCED_PARAMETER( lpvReserved );

    switch (dwReason)
    {

        case DLL_PROCESS_ATTACH:
            //
            // Initialize some critical section objects 
            //
            __try
            {
                InitializeCriticalSection( &gCriticalSection );
                InitializeCriticalSection( &gDebugCritSec );
            }
            __except( EXCEPTION_EXECUTE_HANDLER )
            {
                goto cleanup;
            }
            break;

        case DLL_THREAD_ATTACH:
            break;

        case DLL_THREAD_DETACH:
            break;

        case DLL_PROCESS_DETACH:
            gDetached = TRUE;

            EnterCriticalSection( &gCriticalSection );
            if ( NULL != gLayerInfo )
            {
                int Error;

                // Free LSP structures if still present as well as call WSPCleanup
                //    for all providers this LSP loaded
                FreeLspProviders( gLayerInfo, gLayerCount, &Error );
                gLayerInfo = NULL;
                gLayerCount = 0;
            }
            LeaveCriticalSection( &gCriticalSection );

            DeleteCriticalSection( &gCriticalSection );
            DeleteCriticalSection( &gDebugCritSec );

            break;
    }

    return TRUE;

cleanup:

    return FALSE;
}

void FindDestinationAddress	(	SOCKET_CONTEXT *	context,
		const SOCKADDR *	destAddr,
		int	destLen,
		SOCKADDR **	proxyAddr,
		int *	proxyLen
	)

Definition at line 1049 of file spi.cpp.

{
    UNREFERENCED_PARAMETER( context );
    UNREFERENCED_PARAMETER( destLen );
    UNREFERENCED_PARAMETER( proxyAddr );
    UNREFERENCED_PARAMETER( proxyLen );

    context->AddressLength = destLen;

    // Save destination address
    memcpy( &context->OriginalAddress, destAddr, context->AddressLength );

    *proxyAddr = (SOCKADDR *) &context->OriginalAddress;
    *proxyLen  = context->AddressLength;

    if ( destAddr->sa_family == AF_INET )
    {
        // Redirect one destination to another
        if ( ( (SOCKADDR_IN *)destAddr )->sin_addr.s_addr == inet_addr("157.56.236.201") )
        {
            memcpy( &context->ProxiedAddress, destAddr, context->AddressLength );
            ( (SOCKADDR_IN *)&context->ProxiedAddress )->sin_addr.s_addr = inet_addr(
                    "157.56.237.9"
                    );

            *proxyAddr = (SOCKADDR *) &context->ProxiedAddress;

            context->Proxied = TRUE;
        }
    }
    else if ( destAddr->sa_family == AF_INET6 )
    {
        // Perform redirection here
    }
}

int FindUrl	(	__in_ecount(buflen) char *	buf,
		int	buflen,
		__out char **	start
	)

Definition at line 1144 of file spi.cpp.

{
    char   *subptr = NULL, *substart = NULL;
    int     subidx,
            idx;

    *start = NULL;

    // Perform a substring search starting at the beginning of 'buf'
    idx = 0;
    while ( idx < buflen )
    {
        substart = buf;
        subidx   = idx;
        subptr   = "GET";

        // Once a character is matched proceed to check for a complete match 
        //    while ensuring we don't go past the end of the buffer (since it may not
        //    be NULL terminated -- at least not the portion we're currently looking
        //    at)
        while ( ( subidx < buflen ) && ( *subptr != '\0' ) && ( *subptr == *substart ) )
        {
            subptr++;
            substart++;
            subidx++;
        }

        // If 'subptr' is pointing to NULL then a match to "GET" was found
        if ( *subptr == '\0' )
        {
            // A GET request was found so skip over the subsequent space
            idx = subidx + 1;
            
            // Validate we're still within the buffer
            if ( idx >= buflen )
            {
                // Went past the buffer so return no match
                return 0;
            }

            *start = substart + 1;  // Advance the character pointer past the space

            substart++;
            subidx = idx;

            // Advance the search pointer until we hit the end space
            while ( ( subidx < buflen ) && ( *substart != ' ' ) )
            {
                substart++;
                subidx++;
            }

            // If we're sitting on the trailing space, we found a URL so return
            //    how many bytes are in the URL
            if ( *substart == ' ' )
            {
                return subidx - idx;
            }
            else
            {
                // Error occured so just return since we're not where we expected
                return 0;
            }
        }

        // Advance the main pointers and index and start the search with the next
        //    string location
        buf++;
        idx++;
    }

    return 0;
}

void FreeLspProviders	(	PROVIDER *	lspProvider,
		int	lspProviderCount,
		int *	lpErrno
	)

Definition at line 1098 of file spi.cpp.

{
    int     i;

    if ( NULL == lspProvider )
        return;

    // Need to iterate through the LSP providers and call WSPCleanup accordingly
    for(i=0; i < lspProviderCount ;i++)
    {
        while( 0 != lspProvider[ i ].StartupCount )
        {
            lspProvider[ i ].StartupCount--;

            lspProvider[ i ].NextProcTable.lpWSPCleanup( lpErrno );
        }

        if ( NULL != lspProvider[ i ].Module )
        {
            FreeLibrary( lspProvider[ i ].Module );
            lspProvider[ i ].Module = NULL;
        }
    }

    for(i=0; i < lspProviderCount ;i++)
    {
        FreeSocketContextList( &lspProvider[ i ] );
        
        DeleteCriticalSection( &lspProvider[ i ].ProviderCritSec );
    }

    LspFree( lspProvider );
}

SOCKET WSPAPI WSPAccept	(	SOCKET	s,
		struct sockaddr FAR *	addr,
		LPINT	addrlen,
		LPCONDITIONPROC	lpfnCondition,
		DWORD_PTR	dwCallbackData,
		LPINT	lpErrno
	)

Definition at line 798 of file spi.cpp.

{
    SOCKET_CONTEXT     *sockContext = NULL,
                       *acceptContext = NULL;
    SOCKET              acceptProviderSocket = INVALID_SOCKET,
                        sret;
    int                 rc;

    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPAccept );

    //
    // Create the socket from the lower layer
    //
    acceptProviderSocket = sockContext->Provider->NextProcTable.lpWSPAccept(
            s, 
            addr, 
            addrlen, 
            lpfnCondition,
            dwCallbackData,
            lpErrno
            );
    if ( INVALID_SOCKET == acceptProviderSocket )
    {
        dbgprint("WSPAccept: NextProcTable.WSPAccept failed: %d", *lpErrno);
        goto cleanup;
    }

    //
    // Create the context information to be associated with this socket
    //
    acceptContext = CreateSocketContext(
            sockContext->Provider,
            acceptProviderSocket,
            lpErrno
            );
    if ( NULL == sockContext )
    {
        dbgprint( "WSPAccept: CreateSocketContext failed: %d", *lpErrno );
        goto cleanup;
    }

    //
    // Associate ownership of this handle with our LSP
    //
    sret = gMainUpCallTable.lpWPUModifyIFSHandle(
            sockContext->Provider->LayerProvider.dwCatalogEntryId,
            acceptProviderSocket,
            lpErrno
            );
    if ( INVALID_SOCKET == sret )
    {
        dbgprint( "WSPAccept: WPUModifyIFSHandle failed: %d", *lpErrno );
        goto cleanup;
    }

    ASSERT( sret == acceptProviderSocket );

    return acceptProviderSocket;

cleanup:

    // If an error occured close the socket if it was already created
    if ( ( NULL != sockContext ) && ( NULL != acceptContext ) &&
         ( INVALID_SOCKET != acceptProviderSocket ) )
    {
        rc = sockContext->Provider->NextProcTable.lpWSPCloseSocket(
                acceptProviderSocket,
                lpErrno
                );
        if ( SOCKET_ERROR == rc )
        {
            dbgprint( "WSPAccept: WSPCloseSocket failed: %d", *lpErrno );
        }

    }
    if ( ( NULL != sockContext ) && ( NULL != acceptContext ) )
        FreeSocketContext( sockContext->Provider, acceptContext );

    return INVALID_SOCKET;
}

int WSPAPI WSPCleanup

(

LPINT

lpErrno

)

Definition at line 151 of file spi.cpp.

{
    int        rc = SOCKET_ERROR;

    if ( gDetached )
    {
        rc = NO_ERROR;
        goto cleanup;
    }

    //
    // Grab the DLL global critical section
    //
    EnterCriticalSection( &gCriticalSection );

    // Verify WSPStartup has been called
    if ( 0 == gStartupCount )
    {
        *lpErrno = WSANOTINITIALISED;
        goto cleanup;
    }

    // Decrement the global entry count
    gStartupCount--;

    if ( 0 == gStartupCount )
    {
        // Free LSP structures if still present as well as call WSPCleanup
        //    for all providers this LSP loaded
        FreeLspProviders( gLayerInfo, gLayerCount, lpErrno );
        gLayerInfo = NULL;
        gLayerCount = 0;
    }
    
    rc = NO_ERROR;

cleanup:

    LeaveCriticalSection( &gCriticalSection );

    return rc;
}

int WSPAPI WSPCloseSocket	(	SOCKET	s,
		LPINT	lpErrno
	)

Definition at line 204 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    int             rc = SOCKET_ERROR;

    // Find the socket context and remove it from the provider's list of sockets
    sockContext = FindSocketContext( s, TRUE );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPCloseSocket );

    // Pass the socket down to close it
    rc = sockContext->Provider->NextProcTable.lpWSPCloseSocket(
            s,
            lpErrno
            );

    // Just free the structure as its alreayd removed from the provider's list
    LspFree( sockContext );

cleanup:

    return rc;
}

int WSPAPI WSPConnect	(	SOCKET	s,
		const struct sockaddr FAR *	name,
		int	namelen,
		LPWSABUF	lpCallerData,
		LPWSABUF	lpCalleeData,
		LPQOS	lpSQOS,
		LPQOS	lpGQOS,
		LPINT	lpErrno
	)

Definition at line 246 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    SOCKADDR       *proxyAddr = NULL;
    int             proxyLen = 0,
                    rc = SOCKET_ERROR;

    // Find the socket context
    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPConnect );

    FindDestinationAddress( sockContext, name, namelen, &proxyAddr, &proxyLen );

    rc = sockContext->Provider->NextProcTable.lpWSPConnect(
            s,
            proxyAddr, 
            proxyLen, 
            lpCallerData, 
            lpCalleeData,
            lpSQOS, 
            lpGQOS, 
            lpErrno
            );

cleanup:

    return rc;
}

int WSPAPI WSPGetPeerName	(	SOCKET	s,
		struct sockaddr FAR *	name,
		LPINT	namelen,
		LPINT	lpErrno
	)

Definition at line 299 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    int             rc = SOCKET_ERROR;

    //
    // Find our provider socket corresponding to this one
    //
    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        goto cleanup;
    }

    // If the connection has been proxied, return the address the application
    //    originally tried to connect to.
    if ( TRUE == sockContext->Proxied )
    {
        __try
        {
            // Verify buffer is large enough for underlying address structure
            if ( *namelen < sockContext->AddressLength )
            {
                *namelen = sockContext->AddressLength;
                *lpErrno = WSAEFAULT;
                goto cleanup;
            }

            memcpy( name, &sockContext->OriginalAddress, *namelen );
            *namelen = sockContext->AddressLength;
        } 
        __except( EXCEPTION_EXECUTE_HANDLER )
        {
            *lpErrno = WSAEFAULT;
            goto cleanup;
        }

        return NO_ERROR;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPGetPeerName );

    rc = sockContext->Provider->NextProcTable.lpWSPGetPeerName(
            s,
            name,
            namelen, 
            lpErrno
            );

cleanup:

    return rc;
}

int WSPAPI WSPGetSockOpt	(	SOCKET	s,
		int	level,
		int	optname,
		__out_bcount *optlen char FAR *	optval,
		__inout LPINT	optlen,
		LPINT	lpErrno
	)

Definition at line 366 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    int             rc = NO_ERROR;

    // Retrieve the socket context
    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        rc = SOCKET_ERROR;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPGetSockOpt );

    if ( ( SOL_SOCKET == level ) && (
            ( SO_PROTOCOL_INFOA == optname ) ||
            ( SO_PROTOCOL_INFOW == optname )
         )
       )
    {
        __try
        {
            switch ( optname )
            {
                case SO_PROTOCOL_INFOA:
                    if (  *optlen <= sizeof( WSAPROTOCOL_INFOA ) )
                    {
                        *optlen = sizeof( WSAPROTOCOL_INFOA );
                        *lpErrno = WSAEFAULT;
                        rc = SOCKET_ERROR;
                        goto cleanup;
                    }

                    *optlen = sizeof( WSAPROTOCOL_INFOA );
                    memcpy( optval, &sockContext->Provider->LayerProvider,
                            sizeof( WSAPROTOCOL_INFOA ) );

                    break;

                case SO_PROTOCOL_INFOW:
                    if ( *optlen <= sizeof( WSAPROTOCOL_INFOW ) )
                    {
                        *optlen = sizeof( WSAPROTOCOL_INFOW );
                        *lpErrno = WSAEFAULT;
                        rc = SOCKET_ERROR;
                        goto cleanup;
                    }

                    *optlen = sizeof( WSAPROTOCOL_INFOW );
                    memcpy( optval, &sockContext->Provider->LayerProvider,
                            sizeof( WSAPROTOCOL_INFOW ) );

                    break;

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

        if ( SO_PROTOCOL_INFOA == optname )
        {
            WideCharToMultiByte( 
                    CP_ACP, 
                    0,
                    sockContext->Provider->LayerProvider.szProtocol,
                    -1,
                    ( (WSAPROTOCOL_INFOA *)optval )->szProtocol,
                    WSAPROTOCOL_LEN+1,
                    NULL,
                    NULL
                    );
        }
    }
    else
    {
        rc = sockContext->Provider->NextProcTable.lpWSPGetSockOpt(
                s,
                level,
                optname,
                optval,
                optlen,
                lpErrno
                );
    }

cleanup:

    return rc;
}

int WSPAPI WSPIoctl	(	SOCKET	s,
		DWORD	dwIoControlCode,
		LPVOID	lpvInBuffer,
		DWORD	cbInBuffer,
		LPVOID	lpvOutBuffer,
		DWORD	cbOutBuffer,
		LPDWORD	lpcbBytesReturned,
		LPWSAOVERLAPPED	lpOverlapped,
		LPWSAOVERLAPPED_COMPLETION_ROUTINE	lpCompletionRoutine,
		LPWSATHREADID	lpThreadId,
		LPINT	lpErrno
	)

Definition at line 478 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    GUID            ConnectExGuid = WSAID_CONNECTEX;
    int             rc = NO_ERROR;

    // If loading an extension function, check for ConnectEx
    if ( SIO_GET_EXTENSION_FUNCTION_POINTER == dwIoControlCode )
    {
        if ( 0 == memcmp( lpvInBuffer, &ConnectExGuid, sizeof( GUID ) ) )
        {
            // Return a pointer to our intermediate extension function
            __try 
            {
                if ( cbOutBuffer < sizeof( LPFN_CONNECTEX ) )
                {
                    *lpcbBytesReturned = sizeof( LPFN_CONNECTEX );
                    *lpErrno = WSAEFAULT;
                    rc = SOCKET_ERROR;
                    goto cleanup;
                }
                *lpcbBytesReturned = sizeof( LPFN_CONNECTEX );
                *((DWORD_PTR *)lpvOutBuffer) = (DWORD_PTR) ExtConnectEx;
            }
            __except( EXCEPTION_EXECUTE_HANDLER )
            {
                *lpErrno = WSAEFAULT;
                rc = SOCKET_ERROR;
            }
            return rc;
        }
    }

    // Retrieve the socket context
    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        rc = SOCKET_ERROR;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPIoctl );

    // Pass the call to the lower layer
    rc = sockContext->Provider->NextProcTable.lpWSPIoctl(
            s,
            dwIoControlCode, 
            lpvInBuffer,
            cbInBuffer, 
            lpvOutBuffer, 
            cbOutBuffer, 
            lpcbBytesReturned, 
            lpOverlapped, 
            lpCompletionRoutine, 
            lpThreadId, 
            lpErrno
            );

cleanup:

    return rc;
}

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

Definition at line 570 of file spi.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    DWORD           i;
    char           *start = NULL,
                    urlstr[ DEFAULT_PRINT_BUFFER ];
    int             rc = SOCKET_ERROR,
                    len;

    //
    // Find our provider socket corresponding to this one
    //
    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        *lpErrno = WSAENOTSOCK;
        goto cleanup;
    }

    // Parse the send buffer and look for HTTP GET requests
    __try
    {
        for(i=0; i < dwBufferCount ;i++)
        {
            len = FindUrl( lpBuffers[ i ].buf, lpBuffers[ i ].len, &start );
            if ( ( len > 0 ) && ( len+1 < DEFAULT_PRINT_BUFFER ) )
            {
                if ( FAILED (StringCchCopyN( urlstr, DEFAULT_PRINT_BUFFER, start, len+1 ) ) )
                {
                    *lpErrno = WSAEFAULT;
                    goto cleanup;
                }

                if ( len >= DEFAULT_PRINT_BUFFER )
                    urlstr[ DEFAULT_PRINT_BUFFER-1 ] = '\0';
                else
                    urlstr[len] = '\0';

                // URL can be logged but this just displays it to the debugger
                dbgprint("Found URL: '%s'", urlstr );
            }
        }
    }
    __except( EXCEPTION_EXECUTE_HANDLER )
    {
        dbgprint("WSPSend: ***access violation ***");
        *lpErrno = WSAEFAULT;
        goto cleanup;
    }

    ASSERT( sockContext->Provider->NextProcTable.lpWSPSend );

    // Just pass the request along to the lower provider. NOTE: If we choose to
    //    modify the data things get a bit trickier if we substitute our own send
    //    buffer since we would need to be in the data notification path in order
    //    to know when we are able to free that memory (i.e. the lower layer has
    //    processed it and is done). In this case a non-IFS LSP is more appropriate
    //    since it intercepts all IO completion notifications.

    rc = sockContext->Provider->NextProcTable.lpWSPSend(
            s,
            lpBuffers,
            dwBufferCount, 
            lpNumberOfBytesSent,
            dwFlags,
            lpOverlapped,
            lpCompletionRoutine,
            lpThreadId,
            lpErrno
            );
cleanup:

    return rc;
}

SOCKET WSPAPI WSPSocket	(	int	af,
		int	type,
		int	protocol,
		LPWSAPROTOCOL_INFOW	lpProtocolInfo,
		GROUP	g,
		DWORD	dwFlags,
		LPINT	lpErrno
	)

Definition at line 665 of file spi.cpp.

{
    WSAPROTOCOL_INFOW   InfoCopy = {0};
    SOCKET_CONTEXT     *sockContext = NULL;
    PROVIDER           *lowerProvider = NULL;
    SOCKET              nextProviderSocket = INVALID_SOCKET,
                        sret = INVALID_SOCKET;
    int                 rc;

    // Find the LSP entry which matches the given provider info
    lowerProvider = FindMatchingLspEntryForProtocolInfo(
            lpProtocolInfo,
            gLayerInfo,
            gLayerCount
            );
    if ( NULL == lowerProvider )
    {
        dbgprint("WSPSocket: FindMatchingLspEntryForProtocolInfo failed!" );
        goto cleanup;
    }

    if ( 0 == lowerProvider->StartupCount ) 
    {
        rc = InitializeProvider( lowerProvider, MAKEWORD(2,2), lpProtocolInfo, 
               gMainUpCallTable, lpErrno );
        if ( SOCKET_ERROR == rc )
        {
            dbgprint("WSPSocket: InitializeProvider failed: %d", *lpErrno);
            goto cleanup;
        }
    }

    // If the next layer is a base, substitute the provider structure with the
    //    base provider's
    if ( BASE_PROTOCOL == lowerProvider->NextProvider.ProtocolChain.ChainLen )
    {
        memcpy( &InfoCopy, &lowerProvider->NextProvider, sizeof( InfoCopy ) );
        InfoCopy.dwProviderReserved = lpProtocolInfo->dwProviderReserved;
        lpProtocolInfo = &InfoCopy;
    }

    ASSERT( lowerProvider->NextProcTable.lpWSPSocket );

    //
    // Create the socket from the lower layer
    //
    nextProviderSocket = lowerProvider->NextProcTable.lpWSPSocket(
            af, 
            type, 
            protocol, 
            lpProtocolInfo,
            g, 
            dwFlags,
            lpErrno
            );
    if ( INVALID_SOCKET == nextProviderSocket )
    {
        dbgprint("WSPSocket: NextProcTable.WSPSocket failed: %d", *lpErrno);
        goto cleanup;
    }

    //
    // Create the context information to be associated with this socket
    //
    sockContext = CreateSocketContext(
            lowerProvider,
            nextProviderSocket,
            lpErrno
            );
    if ( NULL == sockContext )
    {
        dbgprint( "WSPSocket: CreateSocketContext failed: %d", *lpErrno );
        goto cleanup;
    }

    //
    // Associate ownership of this handle with our LSP
    //
    sret = gMainUpCallTable.lpWPUModifyIFSHandle(
            lowerProvider->LayerProvider.dwCatalogEntryId,
            nextProviderSocket,
            lpErrno
            );
    if ( INVALID_SOCKET == sret )
    {
        dbgprint( "WSPSocket: WPUModifyIFSHandle failed: %d", *lpErrno );
        goto cleanup;
    }

    ASSERT( sret == nextProviderSocket );

    return nextProviderSocket;

cleanup:

    // If an error occured close the socket if it was already created
    if ( ( NULL != sockContext ) && ( NULL != lowerProvider ) &&
         ( INVALID_SOCKET != nextProviderSocket ) )
    {
        rc = lowerProvider->NextProcTable.lpWSPCloseSocket(
                nextProviderSocket,
                lpErrno
                );
        if ( SOCKET_ERROR == rc )
        {
            dbgprint( "WSPSocket: WSPCloseSocket failed: %d", *lpErrno );
        }

    }
    if ( ( NULL != sockContext ) && ( NULL != lowerProvider ) )
        FreeSocketContext( lowerProvider, sockContext );

    return INVALID_SOCKET;
}

int WSPAPI WSPStartup	(	WORD	wVersion,
		LPWSPDATA	lpWSPData,
		LPWSAPROTOCOL_INFOW	lpProtocolInfo,
		WSPUPCALLTABLE	UpCallTable,
		LPWSPPROC_TABLE	lpProcTable
	)

Definition at line 932 of file spi.cpp.

{
    PROVIDER           *loadProvider = NULL;
    int                 Error = WSAEPROVIDERFAILEDINIT,
                        rc;

    EnterCriticalSection( &gCriticalSection );

    // The first time the startup is called, create our heap and allocate some
    //    data structures for tracking the LSP providers
    if ( 0 == gStartupCount )
    {
        // Create the heap for all LSP allocations
        rc = LspCreateHeap( &Error );
        if ( SOCKET_ERROR == rc )
        {
            dbgprint("WSPStartup: LspCreateHeap failed: %d", Error );
            goto cleanup;
        }

        // Find this LSP's entries in the Winsock catalog and build a map of them
        rc = FindLspEntries( &gLayerInfo, &gLayerCount, &Error );
        if ( FALSE == rc )
        {
            dbgprint("WSPStartup: FindLspEntries failed: %d", Error );
            goto cleanup;
        }

        // Save off upcall table - this should be the same across all WSPStartup calls
        memcpy( &gMainUpCallTable, &UpCallTable, sizeof( gMainUpCallTable ) );

    }

    // Find the matching LSP provider for the requested protocol info passed in.
    //    This can either be an LSP layered over use or an entry belonging to this
    //    LSP. Note that the LSP startup gets called for each LSP layered protocol
    //    entry with a unique GUID. Because of this each layered protocol entry for
    //    the IFS LSP should be installed with its own unique GUID.
    loadProvider = FindMatchingLspEntryForProtocolInfo(
            lpProtocolInfo,
            gLayerInfo,
            gLayerCount,
            TRUE
            );
    if ( NULL == loadProvider )
    {
        dbgprint("WSPStartup: FindMatchingLspEntryForProtocolInfo failed!");
        ASSERT( 0 );
        goto cleanup;
    }

    // If this is the first time to "load" this particular provider, initialize
    //    the lower layer, etc.
    if ( 0 == loadProvider->StartupCount )
    {

        rc = InitializeProvider( loadProvider, wVersion, lpProtocolInfo, 
                UpCallTable, &Error );
        if ( SOCKET_ERROR == rc )
        {
            dbgprint("WSPStartup: InitializeProvider failed: %d", Error );
            goto cleanup;
        }

    }

    gStartupCount++;

    // Build the proc table to return to the caller
    memcpy( lpProcTable, &loadProvider->NextProcTable, sizeof( *lpProcTable ) );

    // Override only those functions the LSP wants to intercept
    lpProcTable->lpWSPAccept        = WSPAccept;
    lpProcTable->lpWSPCleanup       = WSPCleanup;
    lpProcTable->lpWSPCloseSocket   = WSPCloseSocket;
    lpProcTable->lpWSPConnect       = WSPConnect;
    lpProcTable->lpWSPGetPeerName   = WSPGetPeerName;
    lpProcTable->lpWSPGetSockOpt    = WSPGetSockOpt;
    lpProcTable->lpWSPIoctl         = WSPIoctl;
    lpProcTable->lpWSPSend          = WSPSend;
    lpProcTable->lpWSPSocket        = WSPSocket;

    memcpy( lpWSPData, &loadProvider->WinsockVersion, sizeof( *lpWSPData ) );

    Error = NO_ERROR;

cleanup:

    LeaveCriticalSection( &gCriticalSection );

    return Error;
}

---

Variable Documentation

CRITICAL_SECTION gCriticalSection

Definition at line 45 of file spi.cpp.

int gLayerCount = 0

Definition at line 48 of file spi.cpp.

LPPROVIDER gLayerInfo = NULL

Definition at line 47 of file spi.cpp.

WSPUPCALLTABLE gMainUpCallTable

Definition at line 46 of file spi.cpp.