The LSP Helper Winsock Layered Service Provider (LSP)

Other versions of this page are also available for the following:

• Windows Embedded CE 6.0 R3

8/28/2008

The LSP Helper simplifies the creation of Winsock Layered Service Providers (LSP) by providing two pass-through classes and a LSP module class from which developers only have to override the SPI interfaces needed for a new LSP. The LSP helper abstracts the installation algorithm and the algorithms necessary to determine the next provider to call in the Winsock provider chain.

The ILSPModule class defines the interface used by the LSP helper to define the installation details for an LSP. This includes the GUIDs and name of the of the LSP.

The ILSPProvider class defines the interface used by the CLSPProviderPassthrough class which provides a “pass through” implementation of all the non-socket related SPI interfaces.

The ILSPSocket class defines the interface used by the CLSPSocketPasstrhough class which provides a “pass through” implementation of all the socket related SPI interfaces.

ILSPModule

The developer must create a derived class of ILSPModule and implement the interfaces described in the following table.

ILSPModule Example Code

The following code is an example implementation of an ILSPModule derived class.

// TODO: Replace these GUIDs with your own. 
static GUID v_sampelsp_guid = 
{ 0x1546b33b, 0xa4c3, 0x4978, { 0xa3, 0x52, 0x97, 0xad, 0xd2, 0xc1, 0xd5, 0xf } };

// TODO: Replace these GUIDs with your own. 
static GUID v_samplelsp_chain_guid = 
{ 0xb26a9109, 0xabc9, 0x4bf4, { 0xb1, 0xbe, 0x78, 0x84, 0x5d, 0xac, 0xde, 0x9e } };

class CLSPModuleSampleLsp :public ILSPModule
{
    public:
        virtual GUID* getGUIDForLSP()
        { 
           return &v_sampelsp_guid;
        }
        virtual GUID* getGUIDForChain()
        {
           return &v_samplelsp_chain_guid;
        }
        virtual LPCWSTR getModuleName() 
        {
           return L"SampleLSP";
        }
};

ILSPModule*  CreateLSPModule()
{ 
return new CLSPModuleSampleLsp();
}

CLSProviderPassthrough Interfaces

The developer must create a derived class of CProviderPassthrough to use the LSP Helper. The following table outlines the required implementations necessary to instantiate a basic LSP using the LSP Helper classes.

The interfaces in the next table describe interfaces that should not be overridden by the developer.

The interfaces in the next table describe the SPI interfaces that the developer can optionally override in their class derived from CLSPProviderPassThrough.

CLSProviderPassthrough Example

The following code is an example implementation of a CLSProviderPassthrough derived class.

class  CProviderSampleLsp : public CLSPProviderPassthrough
{
    public: 
        CProviderSampleLsp() 
        {
        }

        DWORD  Initialize()
        {
            return NO_ERROR;
        }

        void Cleanup( bool bInProcessExit)
        {
            // 'this'  is only deleted if not in PROCESS_EXIT;
            CLSPProviderPassthrough::Cleanup(bInProcessExit);
            return;
        }

        ~CProviderSampleLsp()
        {
            // Destructor should not be called during PROCESS_EXIT.
            // Thus it's ok to make a blocking call.
        }

        ILSPSocket* CreateSocket()
        {
            // Must return an object of a class 
            // derived from CLSPSocketPassthrough
            return new CSocketSampleLsp(); 
        }
};


ILSPProvider* CreateLSPProvider()
{
    CProviderSampleLsp* pLSP =  new CProviderSampleLsp();

    if (pLSP) 
    {
        DWORD ret = pLSP->Initialize();

        if (NO_ERROR != ret)
        {
            // unable to initialize
            delete pLSP;
            pLSP = NULL;
        }
    }
    return  (ILSPProvider*) pLSP;
}

CLSSocketPassthrough Interfaces

The developer must create a class derived from CLSPSocketPassthrough class in order to override any socket related SPI interfaces. Objects of the derived class must be returned from the ILSPProvider::CreateSocket() interface described in the CLPProviderPassthrough section.

CLSSocketPassthrough Socket Creation and Initialization

In order to control the creation of and initialization of new sockets, the developer must implement the interfaces described in the following table.

CLSSocketPassthrough Example

The following is a simple example of overriding an SPI interfaces in a class derived from CLSPSocketPassthrough.

class CSocketSampleLsp : public CLSPSocketPassthrough
{
public:
    virtual INT WSPRecv(
        IN LPWSABUF lpBuffers,
        IN DWORD dwBufferCount,
        IN LPDWORD lpNumberOfBytesRecvd,
        IN OUT LPDWORD lpFlags,
        IN LPWSAOVERLAPPED lpOverlapped,
        IN LPWSAOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine,
        IN LPWSATHREADID lpThreadId,
        OUT INT FAR *lpErrno)
    {       
        INT ret = CLSPSocketPassthrough::WSPRecv(
                        lpBuffers, 
                        dwBufferCount, 
                        lpNumberOfBytesRecvd, 
                        lpFlags, 
                        lpOverlapped, 
                        lpCompletionRoutine, 
                        lpThreadId, 
                        lpErrno);

        DEBUGMSG(1, (L"WSPRecv() override received %d bytes.\n",           
                        *lpNumberOfBytesRecvd));

        return ret;
    }
};

See Also

Tasks

Using the LSP Installer

Concepts

Layered Protocols and Provider Chains
Installing an LSP
AutoBind LSP
Desktop Passthrough LSP