lspdef.h File Reference

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ws2spi.h>
#include <mswsock.h>
#include <ws2tcpip.h>
#include <mstcpip.h>
#include <lspcommon.h>

Include dependency graph for lspdef.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	_SOCKET_CONTEXT
Typedefs
typedef struct _SOCKET_CONTEXT	SOCKET_CONTEXT
Functions
void	FreeLspProviders (PROVIDER *lspProvider, int lspProviderCount, int *lpErrno)
void	FindDestinationAddress (SOCKET_CONTEXT *context, const SOCKADDR *destAddr, int destLen, SOCKADDR **proxyAddr, int *proxyLen)
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	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)
SOCKET WSPAPI	WSPSocket (int af, int type, int protocol, LPWSAPROTOCOL_INFOW lpProtocolInfo, GROUP g, DWORD dwFlags, LPINT lpErrno)
SOCKET_CONTEXT *	FindSocketContext (SOCKET s, BOOL Remove=FALSE)
SOCKET_CONTEXT *	CreateSocketContext (PROVIDER *Provider, SOCKET Socket, int *lpErrno)
void	FreeSocketContext (PROVIDER *Provider, SOCKET_CONTEXT *Context)
void	FreeSocketContextList (PROVIDER *Provider)
BOOL PASCAL FAR	ExtConnectEx (IN SOCKET s, IN const struct sockaddr FAR *name, IN int namelen, IN PVOID lpSendBuffer OPTIONAL, IN DWORD dwSendDataLength, OUT LPDWORD lpdwBytesSent, IN LPOVERLAPPED lpOverlapped)
Variables
CRITICAL_SECTION	gCriticalSection
INT	gLayerCount
PROVIDER *	gLayerInfo
WSPUPCALLTABLE	gMainUpCallTable
GUID	gProviderGuid

---

Typedef Documentation

typedef struct _SOCKET_CONTEXT SOCKET_CONTEXT

---

Function Documentation

SOCKET_CONTEXT* CreateSocketContext	(	PROVIDER *	Provider,
		SOCKET	Socket,
		int *	lpErrno
	)

Definition at line 94 of file sockinfo.cpp.

{
    SOCKET_CONTEXT   *newContext = NULL;

    newContext = (SOCKET_CONTEXT *) LspAlloc(
            sizeof( SOCKET_CONTEXT ),
            lpErrno
            );
    if ( NULL == newContext )
    {
        dbgprint("CreateSocketContext: LspAlloc failed: %d", *lpErrno );
        goto cleanup;
    }

    newContext->Socket     = Socket;
    newContext->Provider   = Provider;
    newContext->Proxied    = FALSE;

    EnterCriticalSection( &Provider->ProviderCritSec );

    InsertHeadList( &Provider->SocketList, &newContext->Link );

    LeaveCriticalSection( &Provider->ProviderCritSec );

    return newContext;

cleanup:

    return NULL;
}

BOOL PASCAL FAR ExtConnectEx	(	IN SOCKET	s,
		IN const struct sockaddr FAR *	name,
		IN int	namelen,
		IN PVOID lpSendBuffer	OPTIONAL,
		IN DWORD	dwSendDataLength,
		OUT LPDWORD	lpdwBytesSent,
		IN LPOVERLAPPED	lpOverlapped
	)

Definition at line 83 of file extension.cpp.

{
    SOCKET_CONTEXT *sockContext = NULL;
    SOCKADDR       *proxyAddr = NULL;
    int             Errno = NO_ERROR,
                    proxyLen = 0,
                    rc = FALSE;

    sockContext = FindSocketContext( s );
    if ( NULL == sockContext )
    {
        dbgprint("ExtConnectEx: FindSocketContext failed!");
        Errno = WSAENOTSOCK;
        goto cleanup;
    }

    // Make sure we already have the extension function
    if ( NULL == sockContext->Provider->NextProcTableExt.lpfnConnectEx )
    {
        GUID    guidConnectEx = WSAID_CONNECTEX;

        rc = LoadExtensionFunction(
                (FARPROC **)&sockContext->Provider->NextProcTableExt.lpfnConnectEx,
                guidConnectEx,
                sockContext->Provider->NextProcTable.lpWSPIoctl,
                s
                );
        if ( FALSE == rc )
        {
            dbgprint("Next proc table ConnectEx == NULL!");
            Errno = WSAEFAULT;
            goto cleanup;
        }
    }

    // See if the connect needs to be proxied
    FindDestinationAddress( sockContext, name, namelen, &proxyAddr, &proxyLen );

    rc = sockContext->Provider->NextProcTableExt.lpfnConnectEx(
            s,
            proxyAddr,
            proxyLen,
            lpSendBuffer,
            dwSendDataLength,
            lpdwBytesSent,
            lpOverlapped
            );

cleanup:

    return rc;
}

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

SOCKET_CONTEXT* FindSocketContext	(	SOCKET	s,
		BOOL	Remove = FALSE
	)

Definition at line 32 of file sockinfo.cpp.

{
    SOCKET_CONTEXT  *SocketContext = NULL,
               *info = NULL;
    LIST_ENTRY *lptr = NULL;
    int         i;

    EnterCriticalSection( &gCriticalSection );

    for(i=0; i < gLayerCount ;i++)
    {
        EnterCriticalSection( &gLayerInfo[ i ].ProviderCritSec );

        for(lptr = gLayerInfo[ i ].SocketList.Flink ;
            lptr != &gLayerInfo[ i ].SocketList ;
            lptr = lptr->Flink )
        {
            info = CONTAINING_RECORD( lptr, SOCKET_CONTEXT, Link );

            if ( s == info->Socket )
            {
                SocketContext = info;
                
                if ( TRUE == Remove )
                {
                    RemoveEntryList( &info->Link );
                }
                break;
            }
        }

        LeaveCriticalSection( &gLayerInfo[ i ].ProviderCritSec );

        if ( NULL != SocketContext )
            break;
    }

    LeaveCriticalSection( &gCriticalSection );

    return SocketContext;
}

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

void FreeSocketContext	(	PROVIDER *	Provider,
		SOCKET_CONTEXT *	Context
	)

Definition at line 136 of file sockinfo.cpp.

{
    EnterCriticalSection( &Provider->ProviderCritSec );

    RemoveEntryList( &Context->Link );
    LspFree( Context );

    LeaveCriticalSection( &Provider->ProviderCritSec );

    return;
}

void FreeSocketContextList

(

PROVIDER *

Provider

)

Definition at line 160 of file sockinfo.cpp.

{
    LIST_ENTRY     *lptr = NULL;
    SOCKET_CONTEXT *context = NULL;

    ASSERT( provider );

    // Walk the list of sockets
    while ( !IsListEmpty( &provider->SocketList ) )
    {
        lptr = RemoveHeadList( &provider->SocketList );

        ASSERT( lptr );

        context = CONTAINING_RECORD( lptr, SOCKET_CONTEXT, Link );

        // Context is already removed so just free it
        LspFree( context );
    }

    return;
}

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

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

---

Variable Documentation

CRITICAL_SECTION gCriticalSection

Definition at line 45 of file spi.cpp.

INT gLayerCount

Definition at line 48 of file spi.cpp.

PROVIDER* gLayerInfo

Definition at line 47 of file spi.cpp.

WSPUPCALLTABLE gMainUpCallTable

Definition at line 46 of file spi.cpp.

GUID gProviderGuid

Definition at line 37 of file lspguid.cpp.