windows-xp/Source/XPSP1/NT/com/rpc/ndr20/ndrole.h

/*+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

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

Module Name:
    ndrole.h

Abstract:
    OLE routines for interface pointer marshalling.

Author:
    ShannonC    18-Apr-1994

Environment:
    Windows NT and Windows 95.

Revision History:

---------------------------------------------------------------------*/

#ifndef _NDROLE_
#define _NDROLE_


#include <objbase.h>

#ifdef __cplusplus
extern "C" {
#endif

// ProxyFile->TableVersion may be
//    1 for really old junk
//    2 since the time we defined new proxy and stub Buffer2 for delegation
//    6 for async uuid as we treat the previous values as flags.

#define NDR_PROXY_FILE_ASYNC_UUID   0x4

EXTERN_C IStream *__stdcall
NdrpCreateStreamOnMemory( unsigned char *pData, unsigned long cbSize );

// Note, both proxies and stubs have been remapped to the same size,
// as a preparation for some code simplifications.
// This means that some fields may not be used in some circumstances.

// Non-delegated proxy

typedef struct tagCStdProxyBuffer
{
    const struct IRpcProxyBufferVtbl *  lpVtbl;
    const void *                        pProxyVtbl; //Points to Vtbl in CInterfaceProxyVtbl
    long                                RefCount;
    struct IUnknown *                   punkOuter;
    struct IRpcChannelBuffer *          pChannel;
    struct IPSFactoryBuffer    *        pPSFactory; // endof old ProxyBuffer
    struct IRpcProxyBuffer *            Pad_pBaseProxyBuffer;
    struct IPSFactoryBuffer *           Pad_pPSFactory;
    IID                                 Pad_iidBase;
    const struct ICallFactoryVtbl  *    pCallFactoryVtbl;
    const IID *                         pAsyncIID;
    const struct IReleaseMarshalBuffersVtbl  *    pRMBVtbl;
} CStdProxyBuffer;

// Delegated proxy

typedef struct tagCStdProxyBuffer2
{
    const struct IRpcProxyBufferVtbl *  lpVtbl;
    const void *                        pProxyVtbl; //Points to Vtbl in CInterfaceProxyVtbl
    long                                RefCount;
    struct IUnknown *                   punkOuter;
    struct IRpcChannelBuffer *          pChannel;
    struct IUnknown *                   pBaseProxy; // colides with pPSFactory
    struct IRpcProxyBuffer *            pBaseProxyBuffer;
    struct IPSFactoryBuffer *           pPSFactory;
    IID                                 iidBase;    // endof old ProxyBuffer2
    const struct ICallFactoryVtbl *     pCallFactoryVtbl;
    const IID *                         pAsyncIID;
    const struct IReleaseMarshalBuffersVtbl  *    pRMBVtbl;
} CStdProxyBuffer2;

// Async proxy buffer, one for delegated and non-delegated case.

typedef struct _NdrDcomAsyncFlags
{
    unsigned long                       AsyncMsgSet     : 1;
    unsigned long                       BeginStarted    : 1;
    unsigned long                       BeginDone       : 1;
    unsigned long                       FinishStarted   : 1;
    unsigned long                       FinishDone      : 1;
    unsigned long                       BeginError      : 1;
    unsigned long                       FinishError     : 1;
    unsigned long                       InvokeForwarded : 1;
    unsigned long                       Unused          :24;
} NdrDcomAsyncFlags;

typedef struct _CStdProxyBufferMap
{
    struct IUnknown *                   pBaseProxy;
} CStdProxyBufferMap;

typedef struct _NdrDcomAsyncCallState
{
    unsigned long                       Signature;
    unsigned long                       Lock;
    void *                              pAsyncMsg;
    NdrDcomAsyncFlags                   Flags;
    HRESULT                             Hr;
} NdrDcomAsyncCallState;

typedef struct tagCStdAsyncProxyBuffer
{
    const struct IRpcProxyBufferVtbl *  lpVtbl;
    const void *                        pProxyVtbl; //Points to Vtbl in CInterfaceProxyVtbl
    long                                RefCount;
    struct IUnknown *                   punkOuter;
    struct IRpcChannelBuffer *          pChannel;
    CStdProxyBufferMap                  map;        // the only colision 1<>2
    struct IRpcProxyBuffer *            pBaseProxyBuffer;
    struct IPSFactoryBuffer *           pPSFactory;
    IID                                 iidBase;
    const struct ICallFactoryVtbl *     pCallFactoryVtbl;
    const IID *                         pSyncIID;  // points to sync iid in async
    // endof new ProxyBuffer,2 

    const struct IReleaseMarshalBuffersVtbl *     pRMBVtbl;
    NdrDcomAsyncCallState               CallState;

} CStdAsyncProxyBuffer;


// This definition is in rpcproxy.h because CStdStubBuffer::pvServerObject is called explicitly
// from /Os stub.
// It is reproduced here for convenience.
// It should be removed from there or may be left but a renamed clone  used internally.

#if 0
typedef struct tagCStdStubBuffer
{
    const struct IRpcStubBufferVtbl *   lpVtbl; //Points to Vtbl field in CInterfaceStubVtbl.
    long                                RefCount;
    struct IUnknown *                   pvServerObject;

    const struct ICallFactoryVtbl *     pCallFactoryVtbl;
    const IID *                         pAsyncIID;
    struct IPSFactoryBuffer *           pPSFactory;
    const struct IReleaseMarshalBuffersVtbl *     pRMBVtbl;
} CStdStubBuffer;
#endif

// The plan to rewrite and colapse these structure does involve removing of the
// pvServerObject field completely.
// The channel would supply a pvServerObject pointer on the only call where
// this is really needed, that is on the Invoke call.
// In this model there would be no need whatsover for Connect and Disconnect operations
// on the stub object, both sync stubs and async stub call objects.


typedef struct tagCStdStubBuffer2
{
    const void *                        lpForwardingVtbl;
    struct IRpcStubBuffer *             pBaseStubBuffer;
    const struct IRpcStubBufferVtbl *   lpVtbl; //Points to Vtbl field in CInterfaceStubVtbl.
    long                                RefCount;
    struct IUnknown *                   pvServerObject;

    const struct ICallFactoryVtbl *     pCallFactoryVtbl;
    const IID *                         pAsyncIID;
    struct IPSFactoryBuffer *           pPSFactory;
    const struct IReleaseMarshalBuffersVtbl *     pRMBVtbl;
} CStdStubBuffer2;

typedef struct tagCStdAsyncStubBuffer
{
    void *                              lpForwardingVtbl;
    struct IRpcStubBuffer *             pBaseStubBuffer;
    const struct IRpcStubBufferVtbl *   lpVtbl; //Points to Vtbl field in CInterfaceStubVtbl.
    long                                RefCount;
    struct IUnknown *                   pvServerObject;

    const struct ICallFactoryVtbl *     pCallFactoryVtbl;
    const IID *                         pAsyncIID;
    struct IPSFactoryBuffer *           pPSFactory;
    const struct IReleaseMarshalBuffersVtbl *     pRMBVtbl;

    const struct ISynchronizeVtbl *     pSynchronizeVtbl;

    NdrDcomAsyncCallState               CallState;

} CStdAsyncStubBuffer;



HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_QueryInterface(IRpcProxyBuffer *pThis,REFIID riid, void **ppv);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_AddRef(IRpcProxyBuffer *pThis);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_Connect(IRpcProxyBuffer *pThis, IRpcChannelBuffer *pChannel);

void STDMETHODCALLTYPE
CStdProxyBuffer_Disconnect(IRpcProxyBuffer *pThis);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer2_Release(IRpcProxyBuffer *pThis);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer2_Connect(IRpcProxyBuffer *pThis, IRpcChannelBuffer *pChannel);

void STDMETHODCALLTYPE
CStdProxyBuffer2_Disconnect(IRpcProxyBuffer *pThis);


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_RMB_QueryInterface(IReleaseMarshalBuffers *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_RMB_AddRef(IReleaseMarshalBuffers *pthis);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_RMB_Release(IReleaseMarshalBuffers *pthis);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_RMB_ReleaseMarshalBuffer(IN IReleaseMarshalBuffers *This,RPCOLEMESSAGE * pMsg,DWORD dwFlags,IUnknown *pChnl);

HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_RMB_ReleaseMarshalBuffer(IN IReleaseMarshalBuffers *This,RPCOLEMESSAGE * pMsg,DWORD dwFlags,IUnknown *pChnl);


HRESULT STDMETHODCALLTYPE
IUnknown_QueryInterface_Proxy(
    IN  IUnknown *  This,
    IN  REFIID      riid,
    OUT void **     ppv);

ULONG STDMETHODCALLTYPE
IUnknown_AddRef_Proxy(
    IN  IUnknown *This);

ULONG STDMETHODCALLTYPE
IUnknown_Release_Proxy(
    IN  IUnknown *This);


HRESULT STDMETHODCALLTYPE
Forwarding_QueryInterface(
    IN  IUnknown *  This,
    IN  REFIID      riid,
    OUT void **     ppv);

ULONG STDMETHODCALLTYPE
Forwarding_AddRef(
    IN  IUnknown *This);

ULONG STDMETHODCALLTYPE
Forwarding_Release(
    IN  IUnknown *This);


void __RPC_STUB NdrStubForwardingFunction(
    IN  IRpcStubBuffer *    This,
    IN  IRpcChannelBuffer * pChannel,
    IN  PRPC_MESSAGE        pmsg,
    OUT DWORD             * pdwStubPhase);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_QueryInterface(IRpcStubBuffer *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_AddRef(IRpcStubBuffer *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_Connect(IRpcStubBuffer *pthis, IUnknown *pUnkServer);

void STDMETHODCALLTYPE
CStdStubBuffer_Disconnect(IRpcStubBuffer *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_Invoke(IRpcStubBuffer *pthis,RPCOLEMESSAGE *_prpcmsg,IRpcChannelBuffer *_pRpcChannelBuffer);

IRpcStubBuffer * STDMETHODCALLTYPE
CStdStubBuffer_IsIIDSupported(IRpcStubBuffer *pthis,REFIID riid);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_CountRefs(IRpcStubBuffer *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_DebugServerQueryInterface(IRpcStubBuffer *pthis, void **ppv);

void STDMETHODCALLTYPE
CStdStubBuffer_DebugServerRelease(IRpcStubBuffer *pthis, void *pv);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer2_Connect(IRpcStubBuffer *pthis, IUnknown *pUnkServer);

void STDMETHODCALLTYPE
CStdStubBuffer2_Disconnect(IRpcStubBuffer *pthis);

ULONG STDMETHODCALLTYPE
CStdStubBuffer2_CountRefs(IRpcStubBuffer *pthis);

//  Async

extern const IRpcProxyBufferVtbl CStdAsyncProxyBufferVtbl;
extern const IRpcProxyBufferVtbl CStdAsyncProxyBuffer2Vtbl;

extern const IRpcStubBufferVtbl CStdAsyncStubBufferVtbl;
extern const IRpcStubBufferVtbl CStdAsyncStubBuffer2Vtbl;

extern const ISynchronizeVtbl CStdStubBuffer_ISynchronizeVtbl;
extern const ISynchronizeVtbl CStdStubBuffer2_ISynchronizeVtbl;

extern void * const ForwardingVtbl[];


HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_CF_QueryInterface(ICallFactory *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_CF_AddRef(ICallFactory *pthis);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer_CF_Release(ICallFactory *pthis);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer_CF_CreateCall(ICallFactory *pthis, REFIID riid, IUnknown* punkOuter, REFIID riid2, IUnknown **ppvObject);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer2_CF_QueryInterface(ICallFactory *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer2_CF_AddRef(ICallFactory *pthis);

ULONG STDMETHODCALLTYPE
CStdProxyBuffer2_CF_Release(ICallFactory *pthis);

HRESULT STDMETHODCALLTYPE
CStdProxyBuffer2_CF_CreateCall(ICallFactory *pthis, REFIID riid, IUnknown* punkOuter, REFIID riid2, IUnknown **ppvObject);


HRESULT STDMETHODCALLTYPE
CStdStubBuffer_CF_QueryInterface(ICallFactory *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_CF_AddRef(ICallFactory *pthis);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_CF_Release(ICallFactory *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_CF_CreateCall(ICallFactory *pthis, REFIID riid, IUnknown* punkOuter, REFIID riid2, IUnknown **ppvObject);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer2_CF_QueryInterface(ICallFactory *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdStubBuffer2_CF_AddRef(ICallFactory *pthis);

ULONG STDMETHODCALLTYPE
CStdStubBuffer2_CF_Release(ICallFactory *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer2_CF_CreateCall(ICallFactory *pthis, REFIID riid, IUnknown* punkOuter, REFIID riid2, IUnknown **ppvObject);


HRESULT STDMETHODCALLTYPE
CStdStubBuffer_RMB_QueryInterface(IReleaseMarshalBuffers *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_RMB_AddRef(IReleaseMarshalBuffers *pthis);

ULONG STDMETHODCALLTYPE
CStdStubBuffer_RMB_Release(IReleaseMarshalBuffers *pthis);

HRESULT STDMETHODCALLTYPE
CStdStubBuffer_RMB_ReleaseMarshalBuffer(IN IReleaseMarshalBuffers *This,RPCOLEMESSAGE * pMsg,DWORD dwFlags,IUnknown *pChnl);

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_RMB_QueryInterface(IReleaseMarshalBuffers *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_RMB_AddRef(IReleaseMarshalBuffers *pthis);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_RMB_Release(IReleaseMarshalBuffers *pthis);

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_RMB_ReleaseMarshalBuffer(IN IReleaseMarshalBuffers *This,RPCOLEMESSAGE * pMsg,DWORD dwFlags,IUnknown *pChnl);


HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_QueryInterface(IRpcProxyBuffer *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdAsyncProxyBuffer_Release(IRpcProxyBuffer *pthis);

HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer_Connect(IRpcProxyBuffer *pThis, IRpcChannelBuffer *pChannel);

ULONG STDMETHODCALLTYPE
CStdAsyncProxyBuffer2_Release(IRpcProxyBuffer *pThis);

HRESULT STDMETHODCALLTYPE
CStdAsyncProxyBuffer2_Connect(IRpcProxyBuffer *pThis, IRpcChannelBuffer *pChannel);


HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_QueryInterface(IRpcStubBuffer *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_AddRef(IRpcStubBuffer *pthis);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_Release(IRpcStubBuffer *pthis);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer2_Release(IRpcStubBuffer *pthis);

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Connect(IRpcStubBuffer *pthis, IUnknown *pUnkServer);

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer2_Connect(IRpcStubBuffer *pthis, IUnknown *pUnkServer);

void STDMETHODCALLTYPE
CStdAsyncStubBuffer_Disconnect(IRpcStubBuffer *pthis );

void STDMETHODCALLTYPE
CStdAsyncStubBuffer2_Disconnect(IRpcStubBuffer *pthis );

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Invoke(IRpcStubBuffer *pthis,RPCOLEMESSAGE *_prpcmsg,IRpcChannelBuffer *_pRpcChannelBuffer);


HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_QueryInterface( ISynchronize *pthis, REFIID riid, void **ppvObject);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_AddRef(ISynchronize *pthis);

ULONG STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_Release(ISynchronize *pthis);

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_Wait( ISynchronize *pthis, DWORD dwFlags, DWORD mili );

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_Signal( ISynchronize *pthis );

HRESULT STDMETHODCALLTYPE
CStdAsyncStubBuffer_Synchronize_Reset( ISynchronize *pthis );


HRESULT
NdrpAsyncProxySignal(
    CStdAsyncProxyBuffer * pAsyncPB );

HRESULT
NdrpAsyncProxyMsgConstructor(
    CStdAsyncProxyBuffer * pAsyncPB );

HRESULT
NdrpAsyncProxyMsgDestructor(
    CStdAsyncProxyBuffer * pAsyncPB );


HRESULT
NdrpAsyncStubMsgConstructor(
    CStdAsyncStubBuffer * pAsyncSB );

HRESULT
NdrpAsyncStubMsgDestructor(
    CStdAsyncStubBuffer * pAsyncSB );

HRESULT
NdrLoadOleRoutines();

typedef
HRESULT (STDAPICALLTYPE RPC_GET_CLASS_OBJECT_ROUTINE)(
    REFCLSID      rclsid,
    DWORD dwClsContext,
    void *pvReserved,
    REFIID riid,
    void **ppv);

typedef
HRESULT (STDAPICALLTYPE RPC_GET_MARSHAL_SIZE_MAX_ROUTINE)(
    ULONG *     pulSize,
    REFIID      riid,
    LPUNKNOWN   pUnk,
    DWORD       dwDestContext,
    LPVOID      pvDestContext,
    DWORD       mshlflags);

typedef
HRESULT (STDAPICALLTYPE RPC_MARSHAL_INTERFACE_ROUTINE)(
    LPSTREAM    pStm,
    REFIID      riid,
    LPUNKNOWN   pUnk,
    DWORD       dwDestContext,
    LPVOID      pvDestContext,
    DWORD       mshlflags);

typedef
HRESULT (STDAPICALLTYPE RPC_UNMARSHAL_INTERFACE_ROUTINE)(
    LPSTREAM    pStm,
    REFIID      riid,
    LPVOID FAR* ppv);

typedef
HRESULT (STDAPICALLTYPE RPC_STRING_FROM_IID)(
    REFIID rclsid,
    LPOLESTR FAR* lplpsz);

typedef
HRESULT (STDAPICALLTYPE RPC_GET_PS_CLSID)(
    REFIID iid,
    LPCLSID lpclsid);

typedef
HRESULT (STDAPICALLTYPE RPC_CO_CREATE_INSTANCE)(
    REFCLSID    rclsid,
    LPUNKNOWN   pUnkOuter,
    DWORD       dwClsContext,
    REFIID      riid,
    LPVOID *    ppv);

typedef
HRESULT (STDAPICALLTYPE RPC_CO_RELEASEMARSHALDATA)(
    IStream * pStm);

typedef
HRESULT (STDAPICALLTYPE RPC_DCOMCHANNELSETHRESULT)(
        PRPC_MESSAGE pmsg,
        ULONG * ulReserved,
        HRESULT appsHR );


extern  RPC_GET_CLASS_OBJECT_ROUTINE     *  pfnCoGetClassObject;
extern  RPC_GET_MARSHAL_SIZE_MAX_ROUTINE *  pfnCoGetMarshalSizeMax;
extern  RPC_MARSHAL_INTERFACE_ROUTINE    *  pfnCoMarshalInterface;
extern  RPC_UNMARSHAL_INTERFACE_ROUTINE  *  pfnCoUnmarshalInterface;
extern  RPC_STRING_FROM_IID              *  pfnStringFromIID;
extern  RPC_GET_PS_CLSID                 *  pfnCoGetPSClsid;
extern  RPC_CO_CREATE_INSTANCE           *  pfnCoCreateInstance;
extern  RPC_CO_RELEASEMARSHALDATA        *  pfnCoReleaseMarshalData;
extern  RPC_CLIENT_ALLOC                 *  pfnCoTaskMemAlloc;
extern  RPC_CLIENT_FREE                  *  pfnCoTaskMemFree;
extern  RPC_DCOMCHANNELSETHRESULT        *  pfnDcomChannelSetHResult;


HRESULT (STDAPICALLTYPE NdrStringFromIID)(
    REFIID rclsid,
    char * lplpsz);

//------------------------------------------------------------------------
// New async support
// -----------------------------------------------------------------------

void
NdrpAsyncProxyMgrConstructor(
    CStdAsyncProxyBuffer * pAsyncPB );

void
NdrpAsyncStubMgrConstructor(
    CStdAsyncStubBuffer * pAsyncSB );

HRESULT
NdrpAsyncStubSignal(
    CStdAsyncStubBuffer * pAsyncSB );


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


HRESULT NdrpClientReleaseMarshalBuffer(
        IReleaseMarshalBuffers * pRMB,
        RPC_MESSAGE *pRpcMsg,
        DWORD dwIOFlags,
        BOOLEAN fAsync);

HRESULT NdrpServerReleaseMarshalBuffer(
        IReleaseMarshalBuffers *pRMB,
        RPC_MESSAGE *pRpcMsg,
        DWORD dwIOFlags,
        BOOLEAN fAsync);

HRESULT Ndr64pReleaseMarshalBuffer( 
        PRPC_MESSAGE        pRpcMsg,
        PMIDL_SYNTAX_INFO   pSyntaxInfo,
        unsigned long       ProcNum,
        PMIDL_STUB_DESC     pStubDesc,
        DWORD               dwIOFlags,
        BOOLEAN             IsClient );

HRESULT 
NdrpInitializeMutex( I_RPC_MUTEX * pMutex );

EXTERN_C const IID IID_IPrivStubBuffer;
//--------------------
// HookOle Interface
//--------------------
EXTERN_C extern const IID IID_IPSFactoryHook;

#if defined(__cplusplus) && !defined(CINTERFACE)
interface IPSFactoryHook : public IPSFactoryBuffer
{
public:

    STDMETHOD (HkGetProxyFileInfo)
    (
        REFIID          riid,
        PINT            pOffset,
        PVOID           *ppProxyFileInfo
    )=0;
};
typedef IPSFactoryHook *PI_PSFACTORYHOOK;

#else   /* C Style Interface */

    typedef struct IPSFactoryHookVtbl
    {
        BEGIN_INTERFACE

        HRESULT ( __stdcall *QueryInterface )(
            IPSFactoryBuffer *  This,
            /* [in] */ REFIID   riid,
            /* [out] */ void ** ppvObject);

        ULONG ( __stdcall *AddRef )(
            IPSFactoryBuffer *  This);

        ULONG ( __stdcall *Release )(
            IPSFactoryBuffer *  This);

        HRESULT ( __stdcall *CreateProxy )(
            IPSFactoryBuffer            *   This,
            /* [in] */ IUnknown         *   pUnkOuter,
            /* [in] */ REFIID               riid,
            /* [out] */ IRpcProxyBuffer **  ppProxy,
            /* [out] */ void            **  ppv);

        HRESULT ( __stdcall *CreateStub )(
            IPSFactoryBuffer            *   This,
            /* [in] */ REFIID               riid,
            /* [unique][in] */ IUnknown *   pUnkServer,
            /* [out] */ IRpcStubBuffer  **  ppStub);


        HRESULT ( __stdcall *HkGetProxyFileInfo )(
            IPSFactoryBuffer *  This,
            /* [in] */ REFIID   riid,
            /* [out]*/ PINT     pOffset,
            /* [out]*/ PVOID  * ppProxyFileInfo);

        END_INTERFACE
    } IPSFactoryHookVtbl;


    interface IPSFactoryHook
    {
        CONST_VTBL struct IPSFactoryHookVtbl *lpVtbl;
    };

typedef interface IPSFactoryHook *PI_PSFACTORYHOOK;

#ifdef COBJMACROS

#define IPSFactoryHook_QueryInterface(This,riid,ppvObject)    \
    (This)->lpVtbl -> QueryInterface(This,riid,ppvObject)

#define IPSFactoryHook_AddRef(This)   \
    (This)->lpVtbl -> AddRef(This)

#define IPSFactoryHook_Release(This)  \
    (This)->lpVtbl -> Release(This)


#define IPSFactoryHook_CreateProxy(This,pUnkOuter,riid,ppProxy,ppv)   \
    (This)->lpVtbl -> CreateProxy(This,pUnkOuter,riid,ppProxy,ppv)

#define IPSFactoryHook_CreateStub(This,riid,pUnkServer,ppStub)    \
    (This)->lpVtbl -> CreateStub(This,riid,pUnkServer,ppStub)

#define IPSFactoryHook_HkGetProxyFileInfo(This,riid,pOffset,ppProxyFileInfo)    \
    (This)->lpVtbl -> HkGetProxyFileInfo(This,riid,pOffset,ppProxyFileInfo)

#endif /* COBJMACROS */


#endif  /* C style interface */
//-------------------------
// End - HookOle Interface
//-------------------------

#ifdef __cplusplus
}
#endif

#endif /* _NDROLE_ */