windows-xp/Source/XPSP1/NT/com/rpc/ndr20/proxy.cxx

/*++

Microsoft Windows
Copyright (c) 1994-2000 Microsoft Corporation.  All rights reserved.

Module Name:
    proxy.c

Abstract:
    Implements the IRpcProxyBuffer interface.

Author:
    ShannonC    12-Oct-1994

Environment:
    Windows NT and Windows 95 and PowerMac.
    We do not support DOS, Win16 and Mac.

Revision History:

--*/

#define USE_STUBLESS_PROXY
#define CINTERFACE

#include <ndrp.h>
#include <ndrole.h>
#include <rpcproxy.h>
#include <stddef.h>

CStdProxyBuffer * RPC_ENTRY
NdrGetProxyBuffer(
    void *pThis);

const IID * RPC_ENTRY
NdrGetProxyIID(
    const void *pThis);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_Release(
    IN  IRpcProxyBuffer *This);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer2_Release(
    IN  IRpcProxyBuffer *This);

BOOL NdrpFindInterface(
    IN  const ProxyFileInfo **  pProxyFileList, 
    IN  REFIID                  riid,
    OUT const ProxyFileInfo **  ppProxyFileInfo,
    OUT long *                  pIndex );


// The channel wrapper
//

typedef struct tagChannelWrapper
{
    const IRpcChannelBufferVtbl *lpVtbl;
    long                         RefCount;
    const IID *                  pIID;
    struct IRpcChannelBuffer *   pChannel;
} ChannelWrapper;


HRESULT STDMETHODCALLTYPE
CreateChannelWrapper
(
    const IID *          pIID,
    IRpcChannelBuffer *  pChannel,
    IRpcChannelBuffer ** pChannelWrapper
);

HRESULT STDMETHODCALLTYPE
CreateAsyncChannelWrapper
(
    const IID *          pIID,
    IRpcChannelBuffer *  pChannel,
    IRpcChannelBuffer ** pChannelWrapper
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_QueryInterface
(
    IRpcChannelBuffer3 * This,
    REFIID               riid,
    void **              ppvObject
);

ULONG STDMETHODCALLTYPE
ChannelWrapper_AddRef
(
    IRpcChannelBuffer3 * This
);

ULONG STDMETHODCALLTYPE
ChannelWrapper_Release
(
    IRpcChannelBuffer3 * This
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetBuffer
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    REFIID              riid
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_SendReceive
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG *             pStatus
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_FreeBuffer
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetDestCtx
(
    IRpcChannelBuffer3 * This,
    DWORD *             pdwDestContext,
    void **             ppvDestContext
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_IsConnected
(
    IRpcChannelBuffer3 * This
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetProtocolVersion
(
    IRpcChannelBuffer3 * This,
    DWORD             * pdwVersion
);

HRESULT STDMETHODCALLTYPE
ChannelWrapper_Send(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG *             pStatus
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_Receive(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG               ulSize,
    ULONG *             pStatus
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_Cancel(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetCallContext(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    REFIID              riid,
    void    **          pInterface
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetDestCtxEx(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    DWORD *             pdwDestContext,
    void **             ppvDestContext
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetState(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    DWORD         *     pState
    );

HRESULT STDMETHODCALLTYPE
ChannelWrapper_RegisterAsync(
    IRpcChannelBuffer3 *    This,
    RPCOLEMESSAGE *         pMessage,
    IAsyncManager *         pAsyncMgr
    );



HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_QueryInterface
(
    IAsyncRpcChannelBuffer  *   This,
    REFIID                      riid,
    void **                     ppvObject
);

ULONG STDMETHODCALLTYPE
AsyncChannelWrapper_AddRef
(
    IAsyncRpcChannelBuffer  *   This
);

ULONG STDMETHODCALLTYPE
AsyncChannelWrapper_Release
(
    IAsyncRpcChannelBuffer  *   This
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetBuffer
(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage,
    REFIID                      riid
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_SendReceive
(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage,
    ULONG *                     pStatus
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_FreeBuffer
(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetDestCtx
(
    IAsyncRpcChannelBuffer  *   This,
    DWORD *                     pdwDestContext,
    void **                     ppvDestContext
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_IsConnected
(
    IAsyncRpcChannelBuffer  *   This
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetProtocolVersion
(
    IAsyncRpcChannelBuffer  *   This,
    DWORD                   *   pdwVersion
);

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_Send(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage,
    ISynchronize *              pSynchronize,
    ULONG *                     pStatus
    );

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_Receive(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage,
    ULONG *                     pStatus
    );

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetDestCtxEx
(
    IAsyncRpcChannelBuffer  *   This,
    RPCOLEMESSAGE *             pMessage,
    DWORD *                     pdwDestContext,
    void **                     ppvDestContext
);


//+-------------------------------------------------------------------------
//
//  Global data
//
//--------------------------------------------------------------------------

// ProxyBuffer vtables for non-delegaed and delegated case.

extern const IRpcProxyBufferVtbl CStdProxyBufferVtbl = {
    CStdProxyBuffer_QueryInterface,
    CStdProxyBuffer_AddRef,
    CStdProxyBuffer_Release,
    CStdProxyBuffer_Connect,
    CStdProxyBuffer_Disconnect };

extern const IRpcProxyBufferVtbl CStdProxyBuffer2Vtbl = {
    CStdProxyBuffer_QueryInterface,
    CStdProxyBuffer_AddRef,
    CStdProxyBuffer2_Release,
    CStdProxyBuffer2_Connect,
    CStdProxyBuffer2_Disconnect };

// ICallFactory interface on the ProxyBuffer objects.
// ICallFactory is an interface on a sync proxy only.
// It has been introduced for NT5 beta2.

extern const ICallFactoryVtbl CStdProxyBuffer_CallFactoryVtbl = {
    CStdProxyBuffer_CF_QueryInterface,
    CStdProxyBuffer_CF_AddRef,
    CStdProxyBuffer_CF_Release,
    CStdProxyBuffer_CF_CreateCall };

extern const ICallFactoryVtbl CStdProxyBuffer2_CallFactoryVtbl = {
    CStdProxyBuffer_CF_QueryInterface,
    CStdProxyBuffer_CF_AddRef,
    CStdProxyBuffer_CF_Release,
    CStdProxyBuffer2_CF_CreateCall };

extern const IReleaseMarshalBuffersVtbl CStdProxyBuffer_ReleaseMarshalBuffersVtbl = {
    CStdProxyBuffer_RMB_QueryInterface,
    CStdProxyBuffer_RMB_AddRef,
    CStdProxyBuffer_RMB_Release,
    CStdProxyBuffer_RMB_ReleaseMarshalBuffer };

extern const IReleaseMarshalBuffersVtbl CStdAsyncProxyBuffer_ReleaseMarshalBuffersVtbl = {
    CStdProxyBuffer_RMB_QueryInterface,
    CStdProxyBuffer_RMB_AddRef,
    CStdProxyBuffer_RMB_Release,
    CStdAsyncProxyBuffer_RMB_ReleaseMarshalBuffer };

// Async proxy buffer vtables

extern const IRpcProxyBufferVtbl CStdAsyncProxyBufferVtbl = {
    CStdAsyncProxyBuffer_QueryInterface,
    CStdProxyBuffer_AddRef,
    CStdAsyncProxyBuffer_Release,
    CStdAsyncProxyBuffer_Connect,
    CStdProxyBuffer_Disconnect };

extern const IRpcProxyBufferVtbl CStdAsyncProxyBuffer2Vtbl = {
    CStdAsyncProxyBuffer_QueryInterface,
    CStdProxyBuffer_AddRef,
    CStdAsyncProxyBuffer2_Release,
    CStdAsyncProxyBuffer2_Connect,
    CStdProxyBuffer2_Disconnect };

// Channel wrapper is used for delegetion only.


extern const IRpcChannelBuffer3Vtbl ChannelWrapperVtbl = {
    ChannelWrapper_QueryInterface,
    ChannelWrapper_AddRef,
    ChannelWrapper_Release,
    ChannelWrapper_GetBuffer,
    ChannelWrapper_SendReceive,
    ChannelWrapper_FreeBuffer,
    ChannelWrapper_GetDestCtx,
    ChannelWrapper_IsConnected,
    ChannelWrapper_GetProtocolVersion,
    ChannelWrapper_Send,
    ChannelWrapper_Receive,
    ChannelWrapper_Cancel,
    ChannelWrapper_GetCallContext,
    ChannelWrapper_GetDestCtxEx,
    ChannelWrapper_GetState,
    ChannelWrapper_RegisterAsync
    };

extern const IAsyncRpcChannelBufferVtbl AsyncChannelWrapperVtbl = {
    AsyncChannelWrapper_QueryInterface,
    AsyncChannelWrapper_AddRef,
    AsyncChannelWrapper_Release,
    AsyncChannelWrapper_GetBuffer,
    AsyncChannelWrapper_SendReceive,
    AsyncChannelWrapper_FreeBuffer,
    AsyncChannelWrapper_GetDestCtx,
    AsyncChannelWrapper_IsConnected,
    AsyncChannelWrapper_GetProtocolVersion,
    AsyncChannelWrapper_Send,
    AsyncChannelWrapper_Receive,
    AsyncChannelWrapper_GetDestCtxEx
    };

//+-------------------------------------------------------------------------
//
//  End of Global data
//
//--------------------------------------------------------------------------


#pragma code_seg(".orpc")

// __inline
CStdProxyBuffer * RPC_ENTRY
NdrGetProxyBuffer(
    IN  void *pThis)
/*++

Routine Description:
    The "this" pointer points to the pProxyVtbl field in the
    CStdProxyBuffer structure.  The NdrGetProxyBuffer function
    returns a pointer to the top of the CStdProxyBuffer
    structure.

Arguments:
    pThis - Supplies a pointer to the interface proxy.

Return Value:
    This function returns a pointer to the proxy buffer.

--*/
{
    unsigned char *pTemp;

    pTemp = (unsigned char *) pThis;
    pTemp -= offsetof(CStdProxyBuffer, pProxyVtbl);

    return (CStdProxyBuffer *)pTemp;
}

//__inline
const IID * RPC_ENTRY
NdrGetProxyIID(
    IN  const void *pThis)
/*++

Routine Description:
    The NDRGetProxyIID function returns a pointer to IID.

Arguments:
    pThis - Supplies a pointer to the interface proxy.

Return Value:
    This function returns a pointer to the IID.

--*/
{
    unsigned char **    ppTemp;
    unsigned char *     pTemp;
    CInterfaceProxyVtbl *pProxyVtbl;

    //Get a pointer to the proxy vtbl.
    ppTemp = (unsigned char **) pThis;
    pTemp = *ppTemp;
    pTemp -= sizeof(CInterfaceProxyHeader);
    pProxyVtbl = (CInterfaceProxyVtbl *) pTemp;

    return pProxyVtbl->header.piid;
}


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_QueryInterface(
    IN  IRpcProxyBuffer *   This,
    IN  REFIID              riid,
    OUT void **             ppv)
/*++

Routine Description:
    Query for an interface on the proxy.  This function provides access
    to both internal and external interfaces.

Arguments:
    riid - Supplies the IID of the requested interface.
        ppv  - Returns a pointer to the requested interface.

Return Value:
    S_OK
        E_NOINTERFACE

--*/
{
    CStdProxyBuffer   * pCThis  = (CStdProxyBuffer *) This;
    HRESULT             hr = E_NOINTERFACE;
    const IID *         pIID;

    *ppv = 0;

    if( (memcmp(&riid, &IID_IUnknown, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcProxyBuffer, sizeof(IID)) == 0) )
    {
        //This is an internal interface. Increment the internal reference count.
        InterlockedIncrement( &pCThis->RefCount);
        *ppv = This;
        hr = S_OK;
        return hr;   
    }
    else if ( pCThis->pCallFactoryVtbl != 0  && 
              memcmp(&riid, &IID_ICallFactory, sizeof(IID)) == 0 )
        {
        // This is an exposed interface so go through punkOuter ot addref.
        pCThis->punkOuter->lpVtbl->AddRef(pCThis->punkOuter);

        *ppv = (void *) & pCThis->pCallFactoryVtbl;
        hr = S_OK;
        return hr;
        }
    else if ( pCThis->pRMBVtbl && 
              (memcmp(&riid, &IID_IReleaseMarshalBuffers,sizeof(IID)) == 0))
    {
        InterlockedIncrement( &pCThis->RefCount);

        *ppv = (void *) & pCThis->pRMBVtbl;
        hr = S_OK;
        return hr;
    }

    pIID = NdrGetProxyIID(&pCThis->pProxyVtbl);

    if( memcmp(&riid, pIID, sizeof(IID)) == 0)
    {
        //Increment the reference count.

        pCThis->punkOuter->lpVtbl->AddRef(pCThis->punkOuter);
        *ppv = (void *) &pCThis->pProxyVtbl;
        hr = S_OK;
    }

    return hr;
};


HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_QueryInterface(
    IN  IRpcProxyBuffer *   This,
    IN  REFIID              riid,
    OUT void **             ppv)
/*++

Routine Description:
    Query for an interface on the proxy.  This function provides access
    to both internal and external interfaces.
    
Used for
    CStdAsyncProxyBuffer2 as well.

Arguments:
    riid - Supplies the IID of the requested interface.
        ppv  - Returns a pointer to the requested interface.

Return Value:
    S_OK
        E_NOINTERFACE

--*/
{
    CStdProxyBuffer   * pCThis  = (CStdProxyBuffer *) This;
    HRESULT             hr = E_NOINTERFACE;
    const IID *         pIID;

    *ppv = 0;

    if( (memcmp(&riid, &IID_IUnknown, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcProxyBuffer, sizeof(IID)) == 0))
    {
        //This is an internal interface. Increment the internal reference count.
        InterlockedIncrement( &pCThis->RefCount);
        *ppv = This;
        hr = S_OK;
        return hr;   
    }
    else if ( pCThis->pRMBVtbl && 
              (memcmp(&riid, &IID_IReleaseMarshalBuffers,sizeof(IID)) == 0))
    {
        InterlockedIncrement( &pCThis->RefCount);

        *ppv = (void *) & pCThis->pRMBVtbl;
        hr = S_OK;
        return hr;
    }

    if(memcmp(&riid, &IID_ISynchronize, sizeof(IID)) == 0)
    {
        hr = pCThis->punkOuter->lpVtbl->QueryInterface( pCThis->punkOuter,
                                                        IID_ISynchronize,
                                                        ppv);
    }

    pIID = NdrGetProxyIID(&pCThis->pProxyVtbl);

    if(memcmp(&riid, pIID, sizeof(IID)) == 0)
    {
        //Increment the reference count.
        pCThis->punkOuter->lpVtbl->AddRef(pCThis->punkOuter);
        
        *ppv = (void *) &pCThis->pProxyVtbl;
        hr = S_OK;
    }

    return hr;
};


ULONG STDMETHODCALLTYPE
CStdProxyBuffer_AddRef(
    IN  IRpcProxyBuffer *This)
/*++

Routine Description:
    Increment reference count.

Used for
    CStdProxyBuffer2
    CStdAsyncProxyBuffer
    CStdAsuncProxyBuffer2

Arguments:

Return Value:
    Reference count.

--*/
{
    // We do not need to go through punkOuter for ICallFactory.

    CStdProxyBuffer   *  pCThis  = (CStdProxyBuffer *) This;

    InterlockedIncrement(&pCThis->RefCount);

    return (ULONG) pCThis->RefCount;
};



ULONG STDMETHODCALLTYPE
CStdProxyBuffer_Release(
    IN  IRpcProxyBuffer *This)
/*++

Routine Description:
    Decrement reference count.

Arguments:

Return Value:
    Reference count.

--*/
{
    ULONG count;
    IPSFactoryBuffer *pFactory;

    NDR_ASSERT(((CStdProxyBuffer *)This)->RefCount > 0, "Invalid reference count");

    count = (unsigned long) ((CStdProxyBuffer *)This)->RefCount - 1;


    if(InterlockedDecrement(&((CStdProxyBuffer *)This)->RefCount) == 0)
    {
        count = 0;

        pFactory = (IPSFactoryBuffer *) ((CStdProxyBuffer *)This)->pPSFactory;

        //Decrement the DLL reference count.
        pFactory->lpVtbl->Release(pFactory);

#if DBG == 1
        //In debug builds, zero fill the memory.
        memset(This,  '\0', sizeof(CStdProxyBuffer));
#endif

        //Free the memory
        (*pfnCoTaskMemFree)(This);
    }

    return count;
};


ULONG STDMETHODCALLTYPE
CStdProxyBuffer2_Release(
    IN  IRpcProxyBuffer *   This)
/*++

Routine Description:
    Decrement reference count.  This function is used by proxies
    which delegate to the base interface.

Arguments:
    This - Points to a CStdProxyBuffer2.

Return Value:
    Reference count.

--*/
{
    ULONG               count;
    IPSFactoryBuffer *  pFactory;
    IRpcProxyBuffer *   pBaseProxyBuffer;
    IUnknown *          pBaseProxy;

    NDR_ASSERT(((CStdProxyBuffer2 *)This)->RefCount > 0, "Invalid reference count");

    count = (ULONG) ((CStdProxyBuffer2 *)This)->RefCount - 1;

    if(InterlockedDecrement(&((CStdProxyBuffer2 *)This)->RefCount) == 0)
    {
        count = 0;

        //Delegation support.
        pBaseProxy = ((CStdProxyBuffer2 *)This)->pBaseProxy;
        if(pBaseProxy != 0)
        {
// Shannon - why?
            //This is a weak reference, so we don't release it.
            //pBaseProxy->lpVtbl->Release(pBaseProxy);
        }

        pBaseProxyBuffer = ((CStdProxyBuffer2 *)This)->pBaseProxyBuffer;

        if( pBaseProxyBuffer != 0)
        {
            pBaseProxyBuffer->lpVtbl->Release(pBaseProxyBuffer);
        }

        //Decrement the DLL reference count.
        pFactory = (IPSFactoryBuffer *) ((CStdProxyBuffer2 *)This)->pPSFactory;
        pFactory->lpVtbl->Release(pFactory);

#if DBG == 1
        //In debug builds, zero fill the memory.
        memset(This,  '\0', sizeof(CStdProxyBuffer2));
#endif

        //Free the memory
        (*pfnCoTaskMemFree)(This);
    }

    return count;
};


ULONG STDMETHODCALLTYPE
CStdAsyncProxyBuffer_Release(
    IN  IRpcProxyBuffer *This)
/*++

Routine Description:
    Decrement reference count.

Arguments:

Return Value:
    Reference count.

--*/
{
    // We do not need to go through punkOuter for ICallFactory
    // and so everything is local.

    CStdAsyncProxyBuffer * pAsyncPB = (CStdAsyncProxyBuffer *)This;
    ULONG                  count;


    NDR_ASSERT( pAsyncPB->RefCount > 0, "Async proxy Invalid reference count");

    count = (unsigned long) pAsyncPB->RefCount - 1;


    if ( InterlockedDecrement(&pAsyncPB->RefCount) == 0)
        {
        IPSFactoryBuffer * pFactory = pAsyncPB->pPSFactory;

        count = 0;

        // Release the pAsyncMsg and the related state
        NdrpAsyncProxyMsgDestructor( pAsyncPB );

        //Decrement the DLL reference count.
        pFactory->lpVtbl->Release( pFactory );

#if DBG == 1
        //In debug builds, zero fill the memory.
        memset( pAsyncPB,  '\32', sizeof(CStdAsyncProxyBuffer));
#endif

        //Free the memory
        (*pfnCoTaskMemFree)(pAsyncPB);
        }

    return count;
};


ULONG STDMETHODCALLTYPE
CStdAsyncProxyBuffer2_Release(
    IN  IRpcProxyBuffer *   This)
/*++

Routine Description:
    Decrement reference count.  This function is used by proxies
    which delegate to the base interface.

Arguments:
    This - Points to a CStdProxyBuffer2.

Return Value:
    Reference count.

--*/
{
    CStdAsyncProxyBuffer * pAsyncPB = (CStdAsyncProxyBuffer *)This;
    ULONG                  count;

    NDR_ASSERT( pAsyncPB->RefCount > 0, "Invalid reference count");

    count = (ULONG) pAsyncPB->RefCount - 1;

    if ( InterlockedDecrement(&pAsyncPB->RefCount) == 0)
        {
        IRpcProxyBuffer *   pBaseProxyBuffer ;
        IPSFactoryBuffer *  pFactory = pAsyncPB->pPSFactory;

        count = 0;

        // Delegation support - release the base async proxy.

        if( pAsyncPB->map.pBaseProxy != 0)
            {
            // Shannon - why?
            //This is a weak reference, so we don't release it.
            //pBaseProxy->lpVtbl->Release(pBaseProxy);
            }

        pBaseProxyBuffer = pAsyncPB->pBaseProxyBuffer;

        if( pBaseProxyBuffer != 0)
            pBaseProxyBuffer->lpVtbl->Release(pBaseProxyBuffer);

        // Release the pAsyncMsg and the related state
        NdrpAsyncProxyMsgDestructor( (CStdAsyncProxyBuffer*)This );

        // Then clean up the async proxy itself.

        //Decrement the DLL reference count.
        pFactory->lpVtbl->Release(pFactory);

#if DBG == 1
        //In debug builds, zero fill the memory.
        memset(pAsyncPB,  '\32', sizeof(CStdAsyncProxyBuffer));
#endif

        //Free the memory
        (*pfnCoTaskMemFree)(pAsyncPB);
        }

    return count;
};


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_RMB_QueryInterface(
    IN  IReleaseMarshalBuffers   *This,
    IN  REFIID          riid,
    OUT void **         ppvObject)
/*++

Routine Description:
    Query for an interface on the interface stub IReleaseMarshalBuffers pointer.

Arguments:
    riid        - Supplies the IID of the interface being requested.
    ppvObject   - Returns a pointer to the requested interface.

Return Value:
    S_OK
    E_NOINTERFACE

Note:
    Works the same way for ProxyBuffer2 and AsyncProxyBuffer.
--*/
{
    CStdProxyBuffer * pSyncPB = (CStdProxyBuffer *)
                        ((uchar *)This - offsetof(CStdProxyBuffer,pRMBVtbl));

    return pSyncPB->lpVtbl->QueryInterface( (IRpcProxyBuffer *)pSyncPB,
                                            riid,
                                            ppvObject );
}


ULONG STDMETHODCALLTYPE
CStdProxyBuffer_RMB_AddRef(
    IN  IReleaseMarshalBuffers *This)
/*++

Routine Description:
    Implementation of AddRef for interface proxy.

Arguments:

Return Value:
    Reference count.
    
--*/
{
    ULONG  count;

    CStdProxyBuffer * pSyncPB = (CStdProxyBuffer *)
                        ((uchar *)This - offsetof(CStdProxyBuffer,pRMBVtbl));

    // It needs to go through punkOuter.

    count = pSyncPB->lpVtbl->AddRef((IRpcProxyBuffer *) pSyncPB );
    return count;
};


ULONG STDMETHODCALLTYPE
CStdProxyBuffer_RMB_Release(
    IN  IReleaseMarshalBuffers *This)
/*++

Routine Description:
    Implementation of Release for interface proxy.

Arguments:

Return Value:
    Reference count.

--*/
{
    ULONG               count;

    CStdProxyBuffer2 * pSyncPB = (CStdProxyBuffer2 *)
                        ((uchar *)This - offsetof(CStdProxyBuffer2,pRMBVtbl));

    count = pSyncPB->lpVtbl->Release( (IRpcProxyBuffer *)pSyncPB);

    return count;
};


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_RMB_ReleaseMarshalBuffer(
    IN IReleaseMarshalBuffers *This,
    IN RPCOLEMESSAGE * pMsg,
    IN DWORD dwFlags,
    IN IUnknown *pChnl)
{
    CStdProxyBuffer *      pSyncPB;
    HRESULT hr;
    if (NULL != pChnl)
        return E_INVALIDARG;

    // [in] only in client side.
    if (dwFlags)
        return E_INVALIDARG;
             
    hr = NdrpClientReleaseMarshalBuffer(This,
                                        (RPC_MESSAGE *)pMsg, 
                                        dwFlags,
                                        FALSE );    // SYNC 

    return hr;
}

#define IN_BUFFER           0
#define OUT_BUFFER          1

// the pRMBVtbl member is in the same position is both CStdProxyBuffer(2) and 
//     CStdAsyncProxyBuffer so we can cast it anyway.
HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_RMB_ReleaseMarshalBuffer(
    IN IReleaseMarshalBuffers *This,
    IN RPCOLEMESSAGE * pMsg,
    IN DWORD dwIOFlags,
    IN IUnknown *pChnl)
{
    HRESULT hr;
    if (NULL != pChnl)
        return E_INVALIDARG;

    // [in] only in client side.
    if (dwIOFlags != IN_BUFFER)
        return E_INVALIDARG;
             
    hr = NdrpClientReleaseMarshalBuffer(This,
                                        (RPC_MESSAGE *)pMsg, 
                                        dwIOFlags,
                                        TRUE);      // is async

    return hr;
}



HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_Connect(
    IN  IRpcProxyBuffer *   This,
    IN  IRpcChannelBuffer * pChannel)
/*++

Routine Description:
    Connect the proxy to the channel.

Arguments:
    pChannel - Supplies a pointer to the channel.

Return Value:
    S_OK

--*/
{
    CStdProxyBuffer   *     pCThis  = (CStdProxyBuffer *) This;
    HRESULT                 hr;
    IRpcChannelBuffer *     pTemp = 0;

    //
    // Get a pointer to the new channel.
    //
    hr = pChannel->lpVtbl->QueryInterface(
        pChannel, IID_IRpcChannelBuffer, (void **) &pTemp);

    if(hr == S_OK)
    {
        //
        // Save the pointer to the new channel.
        //
        pTemp = (IRpcChannelBuffer *) InterlockedExchangePointer(
            (PVOID *) &pCThis->pChannel, (PVOID) pTemp);

        if(pTemp != 0)
        {
            //
            //Release the old channel.
            //
            pTemp->lpVtbl->Release(pTemp);
            pTemp = 0;
        }
    }
    return hr;
};


HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_Connect(
    IN  IRpcProxyBuffer *   This,
    IN  IRpcChannelBuffer * pChannel)
/*++

Routine Description:
    Connect the proxy to the channel.

Arguments:
    pChannel - Supplies a pointer to the channel.

Return Value:
    S_OK

--*/
{
    CStdProxyBuffer   *     pCThis  = (CStdProxyBuffer *) This;
    HRESULT                 hr;
    IRpcChannelBuffer *    pTemp = 0;

    // Get a pointer to the new channel.
    // Note, the async proxy is not aggregated with the channel,
    // It simply keeps the channel pointer.
    //
    hr = pChannel->lpVtbl->QueryInterface(
        pChannel, IID_IAsyncRpcChannelBuffer, (void **) &pTemp);

    if(hr == S_OK)
    {
        //
        // Save the pointer to the new channel.
        //
        pTemp = (IRpcChannelBuffer *) InterlockedExchangePointer(
            (PVOID *) &pCThis->pChannel, (PVOID) pTemp);

        if(pTemp != 0)
        {
            //
            //Release the old channel.
            //
            pTemp->lpVtbl->Release(pTemp);
            pTemp = 0;
        }
    }
    return hr;
};



HRESULT STDMETHODCALLTYPE
CStdProxyBuffer2_Connect(
    IN  IRpcProxyBuffer *   This,
    IN  IRpcChannelBuffer * pChannel)
/*++

Routine Description:
    Connect the proxy to the channel.  Supports delegation.

Arguments:
    pChannel - Supplies a pointer to the channel.

Return Value:
    S_OK
        E_NOINTERFACE
        E_OUTOFMEMORY

--*/
{
    HRESULT                 hr;
    IRpcProxyBuffer *       pBaseProxyBuffer;
    IRpcChannelBuffer *     pWrapper;
    const IID *             pIID;

    hr = CStdProxyBuffer_Connect(This, pChannel);

    if(SUCCEEDED(hr))
    {
        pBaseProxyBuffer = ((CStdProxyBuffer2 *)This)->pBaseProxyBuffer;

        if(pBaseProxyBuffer != 0)
        {
           pIID = NdrGetProxyIID(&((CStdProxyBuffer2 *)This)->pProxyVtbl);

            hr = CreateChannelWrapper(pIID,
                                      pChannel,
                                      &pWrapper);
            if(SUCCEEDED(hr))
            {
                hr = pBaseProxyBuffer->lpVtbl->Connect(pBaseProxyBuffer, pWrapper);
                // HACKALERT: OleAutomation returns NULL pv in CreateProxy
                // in cases where they don't know whether to return an NDR
                // proxy or a custom-format proxy. So we have to go connect
                // the proxy first then Query for the real interface once that
                // is done.
                if((NULL == ((CStdProxyBuffer2 *)This)->pBaseProxy) &&
                   SUCCEEDED(hr))
                {
                    IUnknown *pv;

                    hr = pBaseProxyBuffer->lpVtbl->QueryInterface(pBaseProxyBuffer,
                                                                  ((CStdProxyBuffer2 *)This)->iidBase,
                                                                  (void **) &pv);
                    if(SUCCEEDED(hr))
                    {
                        //Release our reference here.
                        pv->lpVtbl->Release(pv);

                        //We keep a weak reference to pv.
                        ((CStdProxyBuffer2 *)This)->pBaseProxy = pv;
                    }
                }
                pWrapper->lpVtbl->Release(pWrapper);
            }
        }
    }

    return hr;
};


HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer2_Connect(
    IN  IRpcProxyBuffer *   This,
    IN  IRpcChannelBuffer * pChannel)
/*++

Routine Description:
    Connect the proxy to the channel.  Supports delegation.

Arguments:
    pChannel - Supplies a pointer to the channel.

Return Value:
    S_OK
        E_NOINTERFACE
        E_OUTOFMEMORY

--*/
{
    HRESULT                 hr;
    IRpcProxyBuffer *       pBaseProxyBuffer;
    IRpcChannelBuffer *     pWrapper;
    const IID *             pIID;

    hr = CStdAsyncProxyBuffer_Connect(This, pChannel);

    if(SUCCEEDED(hr))
    {
        // Note that all the fields from CStdProxyBuffer2 that we indicate below
        // have the same offsets in CStdAsyncProxyBuffer that is being handled.
        // So I leave the cast unchanged to make future code merge easier.
        //
        pBaseProxyBuffer = ((CStdProxyBuffer2 *)This)->pBaseProxyBuffer;

        if(pBaseProxyBuffer != 0)
        {
            pIID = NdrGetProxyIID(&((CStdProxyBuffer2 *)This)->pProxyVtbl);

            // We need a pChannel that is guaranteed to be IAsyncRpcChannelBuffer -
            // but note, this is exactly what we obtained in the Connect call above.

            hr = CreateAsyncChannelWrapper( pIID,
                                           ((CStdProxyBuffer2*)This)->pChannel,
                                            &pWrapper);
            if(SUCCEEDED(hr))
            {
                hr = pBaseProxyBuffer->lpVtbl->Connect(pBaseProxyBuffer, pWrapper);

                // This hack alert is rather for future.
                // HACKALERT: OleAutomation returns NULL pv in CreateProxy
                // in cases where they don't know whether to return an NDR
                // proxy or a custom-format proxy. So we have to go connect
                // the proxy first then Query for the real interface once that
                // is done.
                if((NULL == ((CStdProxyBuffer2 *)This)->pBaseProxy) &&
                   SUCCEEDED(hr))
                {
                    IUnknown *pv;

                    hr = pBaseProxyBuffer->lpVtbl->QueryInterface(pBaseProxyBuffer,
                                                                  ((CStdProxyBuffer2 *)This)->iidBase,
                                                                  (void **) &pv);
                    if(SUCCEEDED(hr))
                    {
                        //Release our reference here.
                        pv->lpVtbl->Release(pv);

                        //We keep a weak reference to pv.
                        ((CStdProxyBuffer2 *)This)->pBaseProxy = pv;
                    }
                }
                pWrapper->lpVtbl->Release(pWrapper);
            }
        }
    }

    return hr;
};


void STDMETHODCALLTYPE
CStdProxyBuffer_Disconnect(
    IN  IRpcProxyBuffer *This)
/*++

Routine Description:
    Disconnect the proxy from the channel.
    
Also used for:
    CStdAsyncProxyBuffer_Disconnect

Arguments:

Return Value:
    None.

--*/
{
    CStdProxyBuffer   * pCThis  = (CStdProxyBuffer *) This;
    IRpcChannelBuffer * pOldChannel;

    pOldChannel = (IRpcChannelBuffer *) InterlockedExchangePointer(
                                        (PVOID *) &pCThis->pChannel, 0);

    if(pOldChannel != 0)
    {
        //Release the old channel.
        //
        pOldChannel->lpVtbl->Release(pOldChannel);
    }
};

void STDMETHODCALLTYPE
CStdProxyBuffer2_Disconnect(
    IN  IRpcProxyBuffer *This)
/*++

Routine Description:
    Disconnect the proxy from the channel.

Also used for:
    CStdAsyncProxyBuffer2_Disconnect

Arguments:

Return Value:
    None.

--*/
{
    IRpcProxyBuffer *pBaseProxyBuffer;

    CStdProxyBuffer_Disconnect(This);

    pBaseProxyBuffer = ((CStdProxyBuffer2 *)This)->pBaseProxyBuffer;

    if(pBaseProxyBuffer != 0)
        pBaseProxyBuffer->lpVtbl->Disconnect(pBaseProxyBuffer);
};


HRESULT
NdrpCreateNonDelegatedAsyncProxy( 
//CStdProxyBuffer_CreateAsyncProxy(
    IN  IRpcProxyBuffer         *This, 
    IN  REFIID                  riid, // async IID
    IN  IUnknown *              punkOuter, // controlling unknown
    OUT CStdAsyncProxyBuffer ** ppAsyncProxy
    )
/*
    Creates a call object, i.e. an async proxy object.
    An async proxy doesn't have a pSynchronize, just passes it.
    
    Note, because the call comes via a CStdProxyBuffer, not Buffer2,
    we know that we need to create only a non-delegated async proxy.
    This is because CStdProxyBuffer itself is a non-delegated proxy.
*/
{
    BOOL                    fFound;
    long                    j;   // if index
    const ProxyFileInfo *   pProxyFileInfo;

    CStdProxyBuffer *       pSyncPB = (CStdProxyBuffer *)This;

    *ppAsyncProxy = 0;
    
    if ( ! pSyncPB->pCallFactoryVtbl  ||  !pSyncPB->pAsyncIID )
        return E_NOINTERFACE;

    // Check if sync and async iids match.

    if ( memcmp( &riid, pSyncPB->pAsyncIID, sizeof(IID)) != 0 )
        return E_NOINTERFACE;

    // same file, so we can use the sync pPSFactory.

    fFound = NdrpFindInterface( ((CStdPSFactoryBuffer *)pSyncPB->pPSFactory)->pProxyFileList, 
                                riid, 
                                &pProxyFileInfo, 
                                & j);
    if ( !fFound )
        return E_NOINTERFACE;

    CStdAsyncProxyBuffer *pAsyncPB = 
        (CStdAsyncProxyBuffer*)(*pfnCoTaskMemAlloc)(sizeof(CStdAsyncProxyBuffer));
        
    if( ! pAsyncPB )
        return E_OUTOFMEMORY;

    memset( pAsyncPB, 0, sizeof(CStdAsyncProxyBuffer));
    //
    //  Everything gets zeroed out regardless of their position
    //  when mapping CStdBuffer vs. CstdBuffer2 into CStdAsyncBuffer

    // Non-delegated case.

    pAsyncPB->lpVtbl     = & CStdAsyncProxyBufferVtbl;
    pAsyncPB->pProxyVtbl = & pProxyFileInfo->pProxyVtblList[j]->Vtbl;
    pAsyncPB->RefCount   = 1;
    pAsyncPB->punkOuter  = punkOuter ? punkOuter 
                                     : (IUnknown *) pAsyncPB;
                                         
    pAsyncPB->pSyncIID   = NdrGetProxyIID( &pSyncPB->pProxyVtbl );
    // Note, no connection to channel yet.
    // Actually we never call create call on the channel.
                                  
    NdrpAsyncProxyMsgConstructor( pAsyncPB );

    // Increment the DLL reference count for DllCanUnloadNow.
    // Same dll, so we can use the sync pPSFactory.
    //
    pSyncPB->pPSFactory->lpVtbl->AddRef( pSyncPB->pPSFactory );
    // This is in the "map".
    ((CStdProxyBuffer *)pAsyncPB)->pPSFactory = pSyncPB->pPSFactory;

    // Just have it in both places.
    pAsyncPB->pPSFactory = pSyncPB->pPSFactory;

    *ppAsyncProxy = pAsyncPB;

    return S_OK;
}


HRESULT
// CStdProxyBuffer2_CreateAsyncProxy(
NdrpCreateDelegatedAsyncProxy(
    IN  IRpcProxyBuffer         *This, 
    IN  REFIID                  riid, // async IID
    IN  IUnknown *              punkOuter, // controlling unknown
    OUT CStdAsyncProxyBuffer ** ppAsyncProxy   
    )
/*
    Creates a call object, i.e. an async proxy object.
    
    Note, because the call comes via a CStdProxyBuffer2, not Buffer,
    we know that we need to create only a delegated async proxy.
*/
{
    HRESULT                 hr;
    BOOL                    fFound;
    long                     j;   // if index
    const ProxyFileInfo *   pProxyFileInfo;

    CStdProxyBuffer2 *      pSyncPB = (CStdProxyBuffer2 *)This;
    CStdAsyncProxyBuffer    *pBaseAsyncPB;

    ICallFactory *          pCallFactory;

    *ppAsyncProxy = 0;
    
    if ( ! pSyncPB->pCallFactoryVtbl  ||  !pSyncPB->pAsyncIID )
        return E_NOINTERFACE;

    if ( memcmp( &riid, pSyncPB->pAsyncIID, sizeof(IID)) != 0 )
        return E_NOINTERFACE;

    // same file, so we can use the sync pPSFactory.

    fFound = NdrpFindInterface( ((CStdPSFactoryBuffer *)pSyncPB->pPSFactory)->pProxyFileList, 
                                riid, 
                                &pProxyFileInfo, 
                                & j);
    if ( !fFound )
        return E_NOINTERFACE;

    // Create async proxy.

    CStdAsyncProxyBuffer *pAsyncPB = 
        (CStdAsyncProxyBuffer*)(*pfnCoTaskMemAlloc)(sizeof(CStdAsyncProxyBuffer));
        
    if( ! pAsyncPB )
        return E_OUTOFMEMORY;

    memset( pAsyncPB, 0, sizeof(CStdAsyncProxyBuffer));
    //
    //  Everything gets zeroed out regardless of their position
    //  when mapping CStdBuffer vs. CstdBuffer2 into CStdAsyncBuffer

    // Fill in for a delegated case.

    pAsyncPB->lpVtbl     = & CStdAsyncProxyBuffer2Vtbl;
    pAsyncPB->pProxyVtbl = & pProxyFileInfo->pProxyVtblList[j]->Vtbl;
    pAsyncPB->RefCount   = 1;
    pAsyncPB->punkOuter  = punkOuter ? punkOuter 
                                     : (IUnknown *) pAsyncPB;
    pAsyncPB->iidBase    = *pProxyFileInfo->pDelegatedIIDs[j];
    pAsyncPB->pPSFactory = pSyncPB->pPSFactory;
    pAsyncPB->pSyncIID   = NdrGetProxyIID( &pSyncPB->pProxyVtbl );
                                 
    // Note, no connection to channel yet.
    // So we cannot call create call on the channel.

    NdrpAsyncProxyMsgConstructor( pAsyncPB );

    // Create an async proxy for the base interface.
    // We don't know if the base is delegated, so we have to use base call factory.
    // Get the call factory from the base proxy.

    hr = pSyncPB->pBaseProxyBuffer->lpVtbl->QueryInterface(
                                                   pSyncPB->pBaseProxyBuffer,
                                                   IID_ICallFactory,
                                                   (void**)& pCallFactory );

    if ( SUCCEEDED(hr) )
        {
        const IID * pBaseAsyncIID;

        pBaseAsyncIID = *(const IID **)( (uchar*)pSyncPB->pBaseProxyBuffer
                                         + offsetof(CStdProxyBuffer, pAsyncIID));

        // Aggregate the base async proxy with the current async proxy,
        // not with the channel's punkOuter.
    
        hr = pCallFactory->lpVtbl->CreateCall( pCallFactory,
                                               *pBaseAsyncIID,
                                               (IUnknown*) pAsyncPB,
                                               IID_IUnknown,
                                               (IUnknown**)& pBaseAsyncPB );
        pCallFactory->lpVtbl->Release( pCallFactory );
        }


    if ( SUCCEEDED(hr) )
        {
        // Increment the DLL reference count for DllCanUnloadNow.
        // Same dll, so we can use the sync pPSFactory.
        //
        pSyncPB->pPSFactory->lpVtbl->AddRef( pSyncPB->pPSFactory );

        // Hook up the base async proxy.
    
        pAsyncPB->pBaseProxyBuffer = (IRpcProxyBuffer*) pBaseAsyncPB;
        pAsyncPB->map.pBaseProxy   = (IUnknown *) & pBaseAsyncPB->pProxyVtbl;

        *ppAsyncProxy = pAsyncPB;
        }
    else
        {
        (*pfnCoTaskMemFree)( pAsyncPB );
        }

    return hr;
}


//
//  ICallFactory interface on the sync ProxyBuffer and ProxyBuffer2 objects.
//

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_CF_QueryInterface(
    IN  ICallFactory   *This,
    IN  REFIID          riid,
    OUT void **         ppvObject)
/*++

Routine Description:
    Query for an interface on the interface stub CallFactory pointer.

Arguments:
    riid        - Supplies the IID of the interface being requested.
    ppvObject   - Returns a pointer to the requested interface.

Return Value:
    S_OK
    E_NOINTERFACE

Note:
    Works the same way for ProxyBuffer2 and AsyncProxyBuffer.
--*/
{
    CStdProxyBuffer * pSyncPB = (CStdProxyBuffer *)
                        ((uchar *)This - offsetof(CStdProxyBuffer,pCallFactoryVtbl));

    return pSyncPB->punkOuter->lpVtbl->QueryInterface( pSyncPB->punkOuter,
                                                       riid,
                                                       ppvObject );
}


ULONG STDMETHODCALLTYPE
CStdProxyBuffer_CF_AddRef(
    IN  ICallFactory *This)
/*++

Routine Description:
    Implementation of AddRef for interface proxy.

Arguments:

Return Value:
    Reference count.
    
--*/
{
    ULONG  count;

    CStdProxyBuffer * pSyncPB = (CStdProxyBuffer *)
                        ((uchar *)This - offsetof(CStdProxyBuffer,pCallFactoryVtbl));

    // It needs to go through punkOuter.

    count = pSyncPB->punkOuter->lpVtbl->AddRef( pSyncPB->punkOuter );
    return count;
};


ULONG STDMETHODCALLTYPE
CStdProxyBuffer_CF_Release(
    IN  ICallFactory *This)
/*++

Routine Description:
    Implementation of Release for interface proxy.

Arguments:

Return Value:
    Reference count.

--*/
{
    ULONG               count;

    CStdProxyBuffer2 * pSyncPB = (CStdProxyBuffer2 *)
                        ((uchar *)This - offsetof(CStdProxyBuffer2,pCallFactoryVtbl));

    count = pSyncPB->punkOuter->lpVtbl->Release( pSyncPB->punkOuter );

    return count;
};


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_CF_CreateCall(
    IN  ICallFactory *This, 
    IN  REFIID        riid, 
    IN  IUnknown *    punkOuter, // controlling unknown
    IN  REFIID        riid2, 
    OUT IUnknown **   ppv   
    )
/*
    Creates a call object, i.e. an async proxy object.
    
    Note, because the call comes via a CStdProxyBuffer, not Buffer2,
    we know that we need to create only a non-delegated async proxy.
*/
{
    CStdProxyBuffer * pSyncPB;

    if ( memcmp( &riid2, &IID_IUnknown, sizeof(IID)) != 0 )
        return E_INVALIDARG;
              
    pSyncPB = (CStdProxyBuffer *)
                  (((uchar *)This) - offsetof( CStdProxyBuffer, pCallFactoryVtbl ));
    
    return NdrpCreateNonDelegatedAsyncProxy( (IRpcProxyBuffer*) pSyncPB, 
                                      riid,
                                      punkOuter,
                                      (CStdAsyncProxyBuffer**) ppv );
}

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer2_CF_CreateCall(
    IN  ICallFactory *This, 
    IN  REFIID        riid, 
    IN  IUnknown *    punkOuter, // controlling unknown
    IN  REFIID        riid2, 
    OUT IUnknown **   ppv   
    )
/*
    Creates a call object, i.e. an async proxy object.

    Note, because the virtual call comes via a CStdProxyBuffer2,
    we know that we need to create only a delegated async proxy.
*/
{
    CStdProxyBuffer2 *      pSyncPB;

    if ( memcmp( &riid2, &IID_IUnknown, sizeof(IID)) != 0 )
        return E_INVALIDARG;
              
    pSyncPB = (CStdProxyBuffer2 *)
                  (((uchar *)This) - offsetof( CStdProxyBuffer2, pCallFactoryVtbl ));

    return NdrpCreateDelegatedAsyncProxy( (IRpcProxyBuffer*) pSyncPB, 
                                          riid,
                                          punkOuter,
                                          (CStdAsyncProxyBuffer**) ppv );
}
/*
HRESULT STDAPICALLTYPE
NdrClientReleaseMarshalBuffer(
    IN IRpcProxyBuffer *pProxy,
    IN RPCOLEMESSAGE * pMsg,
    IN DWORD dwFlags,
    IN IUnknown *pChnl)
{
    CStdProxyBuffer *      pSyncPB;
    void * This = NULL;
    HRESULT hr;

    if (NULL != pChnl)
        return E_INVALIDARG;

    if (dwFlags)
        return E_INVALIDARG;

    hr = pProxy->lpVtbl->QueryInterface(pProxy,&IID_IReleaseMarshalBuffers, &This);
    if (FAILED(hr))
        return E_NOTIMPL;
             
    pSyncPB = (CStdProxyBuffer *)
                  (((uchar *)This) - offsetof( CStdProxyBuffer, lpVtbl ));

    hr = NdrpClientReleaseMarshalBuffer(pSyncPB,(RPC_MESSAGE *)pMsg, dwFlags);
    ((IRpcProxyBuffer *)This)->lpVtbl->Release(This);

    return hr;
}

*/

//
//   IUknown Query, AddRef and Release.
//
HRESULT STDMETHODCALLTYPE
IUnknown_QueryInterface_Proxy(
    IN  IUnknown *  This,
    IN  REFIID      riid,
    OUT void **     ppv)
/*++

Routine Description:
    Implementation of QueryInterface for interface proxy.

Arguments:
    riid - Supplies the IID of the requested interface.
    ppv  - Returns a pointer to the requested interface.

Return Value:
    S_OK
        E_NOINTERFACE

--*/
{
    HRESULT             hr = E_NOINTERFACE;
    CStdProxyBuffer *   pProxyBuffer;

    pProxyBuffer = NdrGetProxyBuffer(This);

    hr = pProxyBuffer->punkOuter->lpVtbl->QueryInterface(
                                pProxyBuffer->punkOuter, riid, ppv);

    return hr;
};


ULONG STDMETHODCALLTYPE
IUnknown_AddRef_Proxy(
    IN  IUnknown *This)
/*++

Routine Description:
    Implementation of AddRef for interface proxy.

Arguments:

Return Value:
    Reference count.

--*/
{
    CStdProxyBuffer *   pProxyBuffer;
    ULONG               count;

    pProxyBuffer = NdrGetProxyBuffer(This);
    count = pProxyBuffer->punkOuter->lpVtbl->AddRef(pProxyBuffer->punkOuter);

    return count;
};


ULONG STDMETHODCALLTYPE
IUnknown_Release_Proxy(
    IN  IUnknown *This)
/*++

Routine Description:
    Implementation of Release for interface proxy.

Arguments:

Return Value:
    Reference count.

--*/
{
    CStdProxyBuffer *   pProxyBuffer;
    ULONG               count;

    pProxyBuffer = NdrGetProxyBuffer(This);
    count = pProxyBuffer->punkOuter->lpVtbl->Release(pProxyBuffer->punkOuter);

    return count;
};



void RPC_ENTRY
NdrProxyInitialize(
    IN  void * pThis,
    IN  PRPC_MESSAGE        pRpcMsg,
    IN  PMIDL_STUB_MESSAGE  pStubMsg,
    IN  PMIDL_STUB_DESC     pStubDescriptor,
    IN  unsigned int        ProcNum )
/*++

Routine Description:
    Initialize the MIDL_STUB_MESSAGE.

Arguments:
    pThis - Supplies a pointer to the interface proxy.
    pRpcMsg
        pStubMsg
        pStubDescriptor
        ProcNum

Return Value:

--*/
{
    CStdProxyBuffer *   pProxyBuffer;
    HRESULT             hr;

    pProxyBuffer = NdrGetProxyBuffer(pThis);

    //
    // Initialize the stub message fields.
    //
    NdrClientInitializeNew(
        pRpcMsg,
        pStubMsg,
        pStubDescriptor,
        ProcNum );

    //Note that NdrClientInitializeNew sets RPC_FLAGS_VALID_BIT in the ProcNum.
    //We don't want to do this for object interfaces, so we clear the flag here.
    pRpcMsg->ProcNum &= ~RPC_FLAGS_VALID_BIT;

    pStubMsg->pRpcChannelBuffer = pProxyBuffer->pChannel;

    //Check if we are connected to a channel.
    if(pStubMsg->pRpcChannelBuffer != 0)
    {
        //AddRef the channel.
        //We will release it later in NdrProxyFreeBuffer.
        pStubMsg->pRpcChannelBuffer->lpVtbl->AddRef(pStubMsg->pRpcChannelBuffer);

        //Get the destination context from the channel
        hr = pStubMsg->pRpcChannelBuffer->lpVtbl->GetDestCtx(
            pStubMsg->pRpcChannelBuffer, &pStubMsg->dwDestContext, &pStubMsg->pvDestContext);
    }
    else
    {
        //We are not connected to a channel.
        RpcRaiseException(CO_E_OBJNOTCONNECTED);
    }
}


void RPC_ENTRY
NdrProxyGetBuffer(
    IN  void *              pThis,
    IN  PMIDL_STUB_MESSAGE  pStubMsg)
/*++

Routine Description:
    Get a message buffer from the channel

Arguments:
    pThis - Supplies a pointer to the interface proxy.
    pStubMsg

Return Value:
    None.  If an error occurs, this function will raise an exception.

--*/
{
    HRESULT     hr;

    const IID * pIID = NdrGetProxyIID(pThis);
    pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
    pStubMsg->RpcMsg->DataRepresentation = NDR_LOCAL_DATA_REPRESENTATION;
    pStubMsg->dwStubPhase = PROXY_GETBUFFER;

    hr = pStubMsg->pRpcChannelBuffer->lpVtbl->GetBuffer(
        pStubMsg->pRpcChannelBuffer,
        (RPCOLEMESSAGE *) pStubMsg->RpcMsg,
        *pIID);

    pStubMsg->dwStubPhase = PROXY_MARSHAL;

    if(FAILED(hr))
    {
        RpcRaiseException(hr);
    }
    else
    {
        NDR_ASSERT( ! ((ULONG_PTR)pStubMsg->RpcMsg->Buffer & 0x7),
                    "marshaling buffer misaligned" );

        pStubMsg->Buffer = (unsigned char *) pStubMsg->RpcMsg->Buffer;
        pStubMsg->fBufferValid = TRUE;
    }
}


void RPC_ENTRY
NdrProxySendReceive(
    IN  void *              pThis,
    IN  MIDL_STUB_MESSAGE * pStubMsg)
/*++

Routine Description:
    Send a message to server, then wait for reply message.

Arguments:
    pThis - Supplies a pointer to the interface proxy.
    pStubMsg

Return Value:
        None.  If an error occurs, this function will raise an exception.

--*/
{
    HRESULT hr;
    DWORD   dwStatus;

    //Calculate the number of bytes to send.

    if ( pStubMsg->RpcMsg->BufferLength <
            (uint)(pStubMsg->Buffer - (uchar *)pStubMsg->RpcMsg->Buffer))
        {
        NDR_ASSERT( 0, "NdrProxySendReceive : buffer overflow" );
        RpcRaiseException( RPC_S_INTERNAL_ERROR );
        }

    pStubMsg->RpcMsg->BufferLength = (ulong)( pStubMsg->Buffer -
                                   (unsigned char *) pStubMsg->RpcMsg->Buffer );

    pStubMsg->fBufferValid = FALSE;
    pStubMsg->dwStubPhase = PROXY_SENDRECEIVE;

    hr = pStubMsg->pRpcChannelBuffer->lpVtbl->SendReceive(
        pStubMsg->pRpcChannelBuffer,
        (RPCOLEMESSAGE *) pStubMsg->RpcMsg, &dwStatus);

    pStubMsg->dwStubPhase = PROXY_UNMARSHAL;

    if(FAILED(hr))
    {
        switch(hr)
        {
        case RPC_E_FAULT:
            RpcRaiseException(dwStatus);
            break;

        default:
            RpcRaiseException(hr);
            break;
        }
    }
    else
    {
        NDR_ASSERT( ! ((ULONG_PTR)pStubMsg->RpcMsg->Buffer & 0x7),
                    "marshaling buffer misaligned" );

        pStubMsg->Buffer = (uchar*)pStubMsg->RpcMsg->Buffer;
        pStubMsg->BufferStart = pStubMsg->Buffer;
        pStubMsg->BufferEnd   = pStubMsg->BufferStart + pStubMsg->RpcMsg->BufferLength;
        pStubMsg->fBufferValid = TRUE;
    }
}


void RPC_ENTRY
NdrProxyFreeBuffer(
    IN  void *              pThis,
    IN  MIDL_STUB_MESSAGE * pStubMsg)
/*++

Routine Description:
    Free the message buffer.

Arguments:
    pThis - Supplies a pointer to the interface proxy.
    pStubMsg

Return Value:
    None.

--*/
{
    if(pStubMsg->pRpcChannelBuffer != 0)
    {
        //Free the message buffer.
        if(pStubMsg->fBufferValid == TRUE)
            {
            // If pipes, we need to reset the partial bit for some reason.

            pStubMsg->RpcMsg->RpcFlags &= ~RPC_BUFFER_PARTIAL;

            pStubMsg->pRpcChannelBuffer->lpVtbl->FreeBuffer(
                pStubMsg->pRpcChannelBuffer, (RPCOLEMESSAGE *) pStubMsg->RpcMsg);
            }

        //Release the channel.
        pStubMsg->pRpcChannelBuffer->lpVtbl->Release(pStubMsg->pRpcChannelBuffer);
        pStubMsg->pRpcChannelBuffer = 0;
    }
}

HRESULT RPC_ENTRY
NdrProxyErrorHandler(
    IN  DWORD dwExceptionCode)
/*++

Routine Description:
    Maps an exception code into an HRESULT failure code.

Arguments:
    dwExceptionCode

Return Value:
   This function returns an HRESULT failure code.

--*/
{
    HRESULT hr = dwExceptionCode;

    if(FAILED((HRESULT) dwExceptionCode))
        hr = (HRESULT) dwExceptionCode;
    else
        hr = HRESULT_FROM_WIN32(dwExceptionCode);

    return hr;
}


HRESULT STDMETHODCALLTYPE
CreateChannelWrapper
/*++

Routine Description:
    Creates a wrapper for the channel.  The wrapper ensures
        that we use the correct IID when the proxy for the base
        interface calls GetBuffer.

Arguments:
    pIID
        pChannel
        pChannelWrapper

Return Value:
    S_OK
        E_OUTOFMEMORY

--*/
(
    const IID *             pIID,
    IRpcChannelBuffer *     pChannel,
    IRpcChannelBuffer **    ppChannelWrapper
)
{
    HRESULT hr;
    ChannelWrapper *pWrapper = 
        (ChannelWrapper*)(*pfnCoTaskMemAlloc)(sizeof(ChannelWrapper));

    if(pWrapper != 0)
    {
        hr = S_OK;
        pWrapper->lpVtbl = (IRpcChannelBufferVtbl*) &ChannelWrapperVtbl;
        pWrapper->RefCount = 1;
        pWrapper->pIID = pIID;
        pChannel->lpVtbl->AddRef(pChannel);
        pWrapper->pChannel = pChannel;
        *ppChannelWrapper = (IRpcChannelBuffer *) pWrapper;
    }
    else
    {
        hr = E_OUTOFMEMORY;
        *ppChannelWrapper = 0;
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
CreateAsyncChannelWrapper
/*++

Routine Description:
    Creates a wrapper for the channel.  The wrapper ensures
        that we use the correct IID when the proxy for the base
        interface calls GetBuffer.

Arguments:
    pIID
        pChannel
        pChannelWrapper

Return Value:
    S_OK
        E_OUTOFMEMORY

--*/
(
    const IID *             pIID,
    IRpcChannelBuffer *     pChannel,
    IRpcChannelBuffer **    ppChannelWrapper
)
{
    HRESULT hr;
    ChannelWrapper *pWrapper = 
        (ChannelWrapper*)(*pfnCoTaskMemAlloc)(sizeof(ChannelWrapper));

    if(pWrapper != 0)
    {
        hr = S_OK;
        pWrapper->lpVtbl = (IRpcChannelBufferVtbl*) &AsyncChannelWrapperVtbl;
        pWrapper->RefCount = 1;
        pWrapper->pIID = pIID;
        pChannel->lpVtbl->AddRef(pChannel);
        pWrapper->pChannel = pChannel;
        *ppChannelWrapper = (IRpcChannelBuffer *) pWrapper;
    }
    else
    {
        hr = E_OUTOFMEMORY;
        *ppChannelWrapper = 0;
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_QueryInterface
/*++

Routine Description:
    The channel wrapper supports the IUnknown and IRpcChannelBuffer interfaces.

Arguments:
    riid
        ppvObject

Return Value:
    S_OK
        E_NOINTERFACE

--*/
(
    IRpcChannelBuffer3 * This,
    REFIID riid,
    void **ppvObject
)
{
    HRESULT hr;

    if((memcmp(&riid, &IID_IUnknown, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcChannelBuffer, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcChannelBuffer2, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcChannelBuffer3, sizeof(IID)) == 0))
    {
        hr = S_OK;
        This->lpVtbl->AddRef(This);
        *ppvObject = This;
    }
    else
    {
        hr = E_NOINTERFACE;
        *ppvObject = 0;
    }

    return hr;
}


HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_QueryInterface
/*++

Routine Description:
    The channel wrapper supports the IUnknown and IRpcChannelBuffer interfaces.

Arguments:
    riid
        ppvObject

Return Value:
    S_OK
        E_NOINTERFACE

--*/
    (
    IAsyncRpcChannelBuffer *    This,
    REFIID                      riid,
    void **                     ppvObject
    )
{
    HRESULT hr;

    if((memcmp(&riid, &IID_IUnknown, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcChannelBuffer, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IRpcChannelBuffer2, sizeof(IID)) == 0) ||
        (memcmp(&riid, &IID_IAsyncRpcChannelBuffer, sizeof(IID)) == 0))
    {
        hr = S_OK;
        This->lpVtbl->AddRef(This);
        *ppvObject = This;
    }
    else
    {
        hr = E_NOINTERFACE;
        *ppvObject = 0;
    }

    return hr;
}


ULONG STDMETHODCALLTYPE
ChannelWrapper_AddRef
/*++

Routine Description:
    Increment reference count.

Arguments:

Return Value:
    Reference count.

--*/
(
    IRpcChannelBuffer3 * This
)
{
    ChannelWrapper *pWrapper = (ChannelWrapper *) This;

    InterlockedIncrement(&pWrapper->RefCount);

    return (ULONG) pWrapper->RefCount;

}

ULONG STDMETHODCALLTYPE
AsyncChannelWrapper_AddRef(
    IAsyncRpcChannelBuffer * This
    )
{
    return ChannelWrapper_AddRef( (IRpcChannelBuffer3 *) This );
}


ULONG STDMETHODCALLTYPE
ChannelWrapper_Release
/*++

Routine Description:
    Decrement reference count.

Arguments:

Return Value:
    Reference count.

--*/
(
    IRpcChannelBuffer3 * This
)
{
    unsigned long           count;
    IRpcChannelBuffer *     pChannel;

    NDR_ASSERT(((ChannelWrapper *)This)->RefCount > 0, "Invalid reference count");

    count = (unsigned long) ((ChannelWrapper *)This)->RefCount - 1;

    if(InterlockedDecrement(&((ChannelWrapper *)This)->RefCount) == 0)
    {
        count = 0;

        pChannel = ((ChannelWrapper *)This)->pChannel;

        if(pChannel != 0)
            pChannel->lpVtbl->Release(pChannel);

#if DBG == 1
        //In debug builds, zero fill the memory.
        memset(This,  '\0', sizeof(ChannelWrapper));
#endif

        //Free the memory
        (*pfnCoTaskMemFree)(This);
    }

    return count;
}

ULONG STDMETHODCALLTYPE
AsyncChannelWrapper_Release(
    IAsyncRpcChannelBuffer * This
    )
{
    return ChannelWrapper_Release( (IRpcChannelBuffer3 *) This );
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetBuffer
/*++

Routine Description:
    Get a message buffer from the channel.
    
    This is the reason we have the ChannelWrapper at all.
    We replace the riid of the current proxy by the one from the Wrapper.

Arguments:
    pMessage
        riid

Return Value:

--*/
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *      pMessage,
    REFIID               riid
)
{
    HRESULT             hr;
    IRpcChannelBuffer * pChannel;
    const IID *         pIID;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    pIID = ((ChannelWrapper *)This)->pIID;

    hr = pChannel->lpVtbl->GetBuffer(pChannel,
                                     pMessage,
                                     *pIID);
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetBuffer(
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *      pMessage,
    REFIID               riid
    )
{
    return ChannelWrapper_GetBuffer( (IRpcChannelBuffer3 *) This,
                                     pMessage,
                                     riid );
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_SendReceive
/*++

Routine Description:
    Get a message buffer from the channel

Arguments:
    pMessage
        pStatus

Return Value:
    S_OK

--*/
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *      pMessage,
    ULONG *              pStatus
)
{
    HRESULT             hr;
    IRpcChannelBuffer * pChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->SendReceive(pChannel,
                                       pMessage,
                                       pStatus);
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_SendReceive(
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *      pMessage,
    ULONG *              pStatus
    )
{
    // This can never happen for an async call stub.
    return E_NOTIMPL;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_FreeBuffer
/*++

Routine Description:
    Free the message buffer.

Arguments:
    pMessage

Return Value:
    S_OK

--*/
(
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *pMessage
)
{
    HRESULT             hr;
    IRpcChannelBuffer * pChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->FreeBuffer(pChannel,
                                      pMessage);
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_FreeBuffer(
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *         pMessage
    )
{
    return ChannelWrapper_FreeBuffer( (IRpcChannelBuffer3 *) This,
                                      pMessage );
}



HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetDestCtx
/*++

Routine Description:
    Get the destination context from the channel

Arguments:
    pdwDestContext
        ppvDestContext

Return Value:
    S_OK

--*/
(
    IRpcChannelBuffer3 * This,
    DWORD              * pdwDestContext,
    void              ** ppvDestContext
)
{
    HRESULT             hr;
    IRpcChannelBuffer * pChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->GetDestCtx(pChannel,
                                      pdwDestContext,
                                      ppvDestContext);
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetDestCtx(
    IAsyncRpcChannelBuffer * This,
    DWORD *                 pdwDestContext,
    void **                 ppvDestContext
    )
{
    return ChannelWrapper_GetDestCtx( (IRpcChannelBuffer3 *) This,
                                      pdwDestContext,
                                      ppvDestContext );
}



HRESULT STDMETHODCALLTYPE
ChannelWrapper_IsConnected
/*++

Routine Description:
    Determines if the channel is connected.

Arguments:

Return Value:
    S_TRUE
        S_FALSE

--*/
(
    IRpcChannelBuffer3 * This
)
{
    HRESULT             hr;
    IRpcChannelBuffer * pChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->IsConnected(pChannel);
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_IsConnected(
    IAsyncRpcChannelBuffer * This
    )
{
    return ChannelWrapper_IsConnected( (IRpcChannelBuffer3 *) This );
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetProtocolVersion
/*++

Routine Description:
    Returns the protocol version if available.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
(
    IRpcChannelBuffer3 * This,
    DWORD             * pdwVersion
)
{
    HRESULT             hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer2 * pChannel2;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer2, (void**)&pChannel2);
    if (S_OK == hr)
    {
        hr = pChannel2->lpVtbl->GetProtocolVersion(pChannel2, pdwVersion);
        pChannel2->lpVtbl->Release(pChannel2);
    }
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetProtocolVersion(
    IAsyncRpcChannelBuffer * This,
    DWORD                  * pdwVersion
    )
{
    return ChannelWrapper_GetProtocolVersion( (IRpcChannelBuffer3 *) This,
                                              pdwVersion );
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_Send
/*++

Routine Description:
    Executes an asynchronous or partial send.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    (
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG *             pStatus 
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface( pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3 );
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->Send(pChannel3, pMessage, pStatus);
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_Send(
/*++

Routine Description:
    Executes an asynchronous or partial send.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *         pMessage,
    ISynchronize *          pSynchronize,
    ULONG *                 pStatus 
    )
{
    HRESULT                  hr;
    IRpcChannelBuffer  *     pChannel;
    IAsyncRpcChannelBuffer * pAsChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface( pChannel, 
                                           IID_IAsyncRpcChannelBuffer, 
                                           (void**)&pAsChannel );
    if (S_OK == hr)
    {
        hr = pAsChannel->lpVtbl->Send( pAsChannel, 
                                       pMessage, 
                                       pSynchronize,
                                       pStatus);
        pAsChannel->lpVtbl->Release( pAsChannel);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_Receive
/*++

Routine Description:
    Executes an asynchronous or partial receive.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    (
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG               ulSize,
    ULONG *             pStatus 
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->Receive( pChannel3, pMessage, ulSize, pStatus );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}

HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_Receive(
/*++

Routine Description:
    Executes an asynchronous or partial receive.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *     pMessage,
    ULONG *             pStatus 
    )
{
    HRESULT                 hr;
    IRpcChannelBuffer  *    pChannel;
    IAsyncRpcChannelBuffer *pAsChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface( pChannel, 
                                           IID_IAsyncRpcChannelBuffer, 
                                           (void**)&pAsChannel);
    if (S_OK == hr)
    {
        hr = pAsChannel->lpVtbl->Receive( pAsChannel, 
                                          pMessage, 
                                          pStatus );
        pAsChannel->lpVtbl->Release(pAsChannel);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_Cancel(
/*++

Routine Description:
    Executes an asynchronous Cancel.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->Cancel( pChannel3, pMessage );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetCallContext(
/*++

Routine Description:
    Gets an asynchronous call context.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    REFIID              riid,
    void    **          ppInterface
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->GetCallContext( pChannel3, pMessage, riid, ppInterface );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
AsyncChannelWrapper_GetDestCtxEx(
/*++

Routine Description:
    Gets an asynchronous call context.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IAsyncRpcChannelBuffer * This,
    RPCOLEMESSAGE *         pMessage,
    DWORD *                 pdw,
    void **                 ppv
    )
{
    HRESULT                     hr;
    IRpcChannelBuffer  *        pChannel;
    IAsyncRpcChannelBuffer *    pAsChannel;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface( pChannel, 
                                           IID_IAsyncRpcChannelBuffer, 
                                           (void**)&pAsChannel);
    if (S_OK == hr)
    {
        hr = pAsChannel->lpVtbl->GetDestCtxEx( pAsChannel, 
                                               pMessage, 
                                               pdw, 
                                               ppv );
        pAsChannel->lpVtbl->Release(pAsChannel);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetDestCtxEx(
/*++

Routine Description:
    Gets the new destination context.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    DWORD *             pdwDestContext,
    void **             ppvDestContext
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->GetDestCtxEx( pChannel3, pMessage, pdwDestContext, ppvDestContext );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}

HRESULT STDMETHODCALLTYPE
ChannelWrapper_GetState(
/*++

Routine Description:
    Gets the call state.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    DWORD         *     pState
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->GetState( pChannel3, pMessage, pState );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}


HRESULT STDMETHODCALLTYPE
ChannelWrapper_RegisterAsync(
/*++

Routine Description:
    Registers the async manager object and call with the channel.

Arguments:

Return Value:
    S_OK
    E_NOINTERFACE
--*/
    IRpcChannelBuffer3 * This,
    RPCOLEMESSAGE *     pMessage,
    IAsyncManager *     pAsyncMgr
    )
{
    HRESULT              hr;
    IRpcChannelBuffer  * pChannel;
    IRpcChannelBuffer3 * pChannel3;

    pChannel = ((ChannelWrapper *)This)->pChannel;
    hr = pChannel->lpVtbl->QueryInterface(pChannel, IID_IRpcChannelBuffer3, (void**)&pChannel3);
    if (S_OK == hr)
    {
        hr = pChannel3->lpVtbl->RegisterAsync( pChannel3, pMessage, pAsyncMgr );
        pChannel3->lpVtbl->Release(pChannel3);
    }
    return hr;
}