cstub.c File Reference

#include <stdarg.h>
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "excpt.h"
#include "objbase.h"
#include "rpcproxy.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "cpsf.h"

Include dependency graph for cstub.c:

Go to the source code of this file.

Classes
struct	ref_counted_vtbl
struct	vtbl_method_t

Macros
#define	COBJMACROS
#define	STUB_HEADER(This)   (((const CInterfaceStubHeader*)((This)->lpVtbl))[-1])
#define	BLOCK_SIZE   1024
#define	MAX_BLOCKS   64 /* 64k methods should be enough for anybody */

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static LONG WINAPI	stub_filter (EXCEPTION_POINTERS *eptr)
static cstdstubbuffer_delegating_t *	impl_from_delegating (IRpcStubBuffer *iface)
HRESULT	CStdStubBuffer_Construct (REFIID riid, LPUNKNOWN pUnkServer, PCInterfaceName name, CInterfaceStubVtbl *vtbl, LPPSFACTORYBUFFER pPSFactory, LPRPCSTUBBUFFER *ppStub)
static HRESULT WINAPI	delegating_QueryInterface (IUnknown *pUnk, REFIID iid, void **ppv)
static ULONG WINAPI	delegating_AddRef (IUnknown *pUnk)
static ULONG WINAPI	delegating_Release (IUnknown *pUnk)
static const vtbl_method_t *	allocate_block (unsigned int num)
static BOOL	fill_delegated_stub_table (IUnknownVtbl *vtbl, DWORD num)
BOOL	fill_delegated_proxy_table (IUnknownVtbl *vtbl, DWORD num)
IUnknownVtbl *	get_delegating_vtbl (DWORD num_methods)
void	release_delegating_vtbl (IUnknownVtbl *vtbl)
HRESULT	CStdStubBuffer_Delegating_Construct (REFIID riid, LPUNKNOWN pUnkServer, PCInterfaceName name, CInterfaceStubVtbl *vtbl, REFIID delegating_iid, LPPSFACTORYBUFFER pPSFactory, LPRPCSTUBBUFFER *ppStub)
HRESULT WINAPI	CStdStubBuffer_QueryInterface (LPRPCSTUBBUFFER iface, REFIID riid, LPVOID *obj)
ULONG WINAPI	CStdStubBuffer_AddRef (LPRPCSTUBBUFFER iface)
ULONG WINAPI	NdrCStdStubBuffer_Release (LPRPCSTUBBUFFER iface, LPPSFACTORYBUFFER pPSF)
ULONG WINAPI	NdrCStdStubBuffer2_Release (LPRPCSTUBBUFFER iface, LPPSFACTORYBUFFER pPSF)
HRESULT WINAPI	CStdStubBuffer_Connect (LPRPCSTUBBUFFER iface, LPUNKNOWN lpUnkServer)
void WINAPI	CStdStubBuffer_Disconnect (LPRPCSTUBBUFFER iface)
HRESULT WINAPI	CStdStubBuffer_Invoke (LPRPCSTUBBUFFER iface, PRPCOLEMESSAGE pMsg, LPRPCCHANNELBUFFER pChannel)
LPRPCSTUBBUFFER WINAPI	CStdStubBuffer_IsIIDSupported (LPRPCSTUBBUFFER iface, REFIID riid)
ULONG WINAPI	CStdStubBuffer_CountRefs (LPRPCSTUBBUFFER iface)
HRESULT WINAPI	CStdStubBuffer_DebugServerQueryInterface (LPRPCSTUBBUFFER iface, LPVOID *ppv)
void WINAPI	CStdStubBuffer_DebugServerRelease (LPRPCSTUBBUFFER iface, LPVOID pv)
static HRESULT WINAPI	CStdStubBuffer_Delegating_Connect (LPRPCSTUBBUFFER iface, LPUNKNOWN lpUnkServer)
static void WINAPI	CStdStubBuffer_Delegating_Disconnect (LPRPCSTUBBUFFER iface)
static ULONG WINAPI	CStdStubBuffer_Delegating_CountRefs (LPRPCSTUBBUFFER iface)
const MIDL_SERVER_INFO *	CStdStubBuffer_GetServerInfo (IRpcStubBuffer *iface)
void __RPC_STUB	NdrStubForwardingFunction (IRpcStubBuffer *iface, IRpcChannelBuffer *pChannel, PRPC_MESSAGE pMsg, DWORD *pdwStubPhase)
void WINAPI	NdrStubInitialize (PRPC_MESSAGE pRpcMsg, PMIDL_STUB_MESSAGE pStubMsg, PMIDL_STUB_DESC pStubDescriptor, LPRPCCHANNELBUFFER pRpcChannelBuffer)
void WINAPI	NdrStubGetBuffer (LPRPCSTUBBUFFER iface, LPRPCCHANNELBUFFER pRpcChannelBuffer, PMIDL_STUB_MESSAGE pStubMsg)

Variables
static CRITICAL_SECTION	delegating_vtbl_section = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
static ref_counted_vtbl *	current_vtbl
static const BYTE	opcodes [1]
static const vtbl_method_t *	method_blocks [MAX_BLOCKS]
const IRpcStubBufferVtbl	CStdStubBuffer_Vtbl
const IRpcStubBufferVtbl	CStdStubBuffer_Delegating_Vtbl

Macro Definition Documentation

BLOCK_SIZE

#define BLOCK_SIZE   1024

Definition at line 214 of file cstub.c.

COBJMACROS

#define COBJMACROS

Definition at line 24 of file cstub.c.

MAX_BLOCKS

#define MAX_BLOCKS   64 /* 64k methods should be enough for anybody */

Definition at line 215 of file cstub.c.

STUB_HEADER

#define STUB_HEADER

(

This

)

(((const CInterfaceStubHeader*)((This)->lpVtbl))[-1])

Definition at line 41 of file cstub.c.

Function Documentation

allocate_block()

static const vtbl_method_t * allocate_block ( unsigned int  num )

static

Definition at line 219 of file cstub.c.

{
    unsigned int i;
    vtbl_method_t *prev, *block;
    DWORD oldprot;
 
    block = VirtualAlloc( NULL, BLOCK_SIZE * sizeof(*block),
                          MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE );
    if (!block) return NULL;
 
    for (i = 0; i < BLOCK_SIZE; i++)
    {
        memcpy( &block[i], opcodes, sizeof(opcodes) );
        block[i].offset = (BLOCK_SIZE * num + i + 3) * sizeof(void *);
    }
    VirtualProtect( block, BLOCK_SIZE * sizeof(*block), PAGE_EXECUTE_READ, &oldprot );
    prev = InterlockedCompareExchangePointer( (void **)&method_blocks[num], block, NULL );
    if (prev) /* someone beat us to it */
    {
        VirtualFree( block, 0, MEM_RELEASE );
        block = prev;
    }
    return block;
}

Referenced by fill_delegated_proxy_table(), and fill_delegated_stub_table().

CStdStubBuffer_AddRef()

ULONG WINAPI CStdStubBuffer_AddRef

(

LPRPCSTUBBUFFER

iface

)

Definition at line 410 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->AddRef()\n",This);
  return InterlockedIncrement(&This->RefCount);
}

CStdStubBuffer_Connect()

HRESULT WINAPI CStdStubBuffer_Connect	(	LPRPCSTUBBUFFER	iface,
		LPUNKNOWN	lpUnkServer
	)

Definition at line 463 of file cstub.c.

{
    CStdStubBuffer *This = (CStdStubBuffer *)iface;
    HRESULT r;
    IUnknown *new = NULL;
 
    TRACE("(%p)->Connect(%p)\n",This,lpUnkServer);
 
    r = IUnknown_QueryInterface(lpUnkServer, STUB_HEADER(This).piid, (void**)&new);
    new = InterlockedExchangePointer((void**)&This->pvServerObject, new);
    if(new)
        IUnknown_Release(new);
    return r;
}

Referenced by CStdStubBuffer_Delegating_Connect().

CStdStubBuffer_Construct()

HRESULT CStdStubBuffer_Construct	(	REFIID	riid,
		LPUNKNOWN	pUnkServer,
		PCInterfaceName	name,
		CInterfaceStubVtbl *	vtbl,
		LPPSFACTORYBUFFER	pPSFactory,
		LPRPCSTUBBUFFER *	ppStub
	)

Definition at line 55 of file cstub.c.

{
  CStdStubBuffer *This;
  IUnknown *pvServer;
  HRESULT r;
  TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
  TRACE("iid=%s\n", debugstr_guid(vtbl->header.piid));
  TRACE("vtbl=%p\n", &vtbl->Vtbl);
 
  if (!IsEqualGUID(vtbl->header.piid, riid)) {
    ERR("IID mismatch during stub creation\n");
    return RPC_E_UNEXPECTED;
  }
 
  r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
  if(FAILED(r))
    return r;
 
  This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(CStdStubBuffer));
  if (!This) {
    IUnknown_Release(pvServer);
    return E_OUTOFMEMORY;
  }
 
  This->lpVtbl = &vtbl->Vtbl;
  This->RefCount = 1;
  This->pvServerObject = pvServer;
  This->pPSFactory = pPSFactory;
  *ppStub = (LPRPCSTUBBUFFER)This;
 
  IPSFactoryBuffer_AddRef(pPSFactory);
  return S_OK;
}

Referenced by CStdPSFactory_CreateStub().

CStdStubBuffer_CountRefs()

ULONG WINAPI CStdStubBuffer_CountRefs

(

LPRPCSTUBBUFFER

iface

)

Definition at line 530 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->CountRefs()\n",This);
  return This->RefCount;
}

Referenced by CStdStubBuffer_Delegating_CountRefs().

CStdStubBuffer_DebugServerQueryInterface()

HRESULT WINAPI CStdStubBuffer_DebugServerQueryInterface	(	LPRPCSTUBBUFFER	iface,
		LPVOID *	ppv
	)

Definition at line 537 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->DebugServerQueryInterface(%p)\n",This,ppv);
  return S_OK;
}

CStdStubBuffer_DebugServerRelease()

void WINAPI CStdStubBuffer_DebugServerRelease	(	LPRPCSTUBBUFFER	iface,
		LPVOID	pv
	)

Definition at line 545 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->DebugServerRelease(%p)\n",This,pv);
}

CStdStubBuffer_Delegating_Connect()

static HRESULT WINAPI CStdStubBuffer_Delegating_Connect ( LPRPCSTUBBUFFER  iface, LPUNKNOWN  lpUnkServer  )

static

Definition at line 566 of file cstub.c.

{
    cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
    HRESULT r;
    TRACE("(%p)->Connect(%p)\n", This, lpUnkServer);
 
    r = CStdStubBuffer_Connect(iface, lpUnkServer);
    if(SUCCEEDED(r))
        r = IRpcStubBuffer_Connect(This->base_stub, (IUnknown*)&This->base_obj);
 
    return r;
}

CStdStubBuffer_Delegating_Construct()

HRESULT CStdStubBuffer_Delegating_Construct	(	REFIID	riid,
		LPUNKNOWN	pUnkServer,
		PCInterfaceName	name,
		CInterfaceStubVtbl *	vtbl,
		REFIID	delegating_iid,
		LPPSFACTORYBUFFER	pPSFactory,
		LPRPCSTUBBUFFER *	ppStub
	)

Definition at line 340 of file cstub.c.

{
    cstdstubbuffer_delegating_t *This;
    IUnknown *pvServer;
    HRESULT r;
 
    TRACE("(%p,%p,%p,%p) %s\n", pUnkServer, vtbl, pPSFactory, ppStub, name);
    TRACE("iid=%s delegating to %s\n", debugstr_guid(vtbl->header.piid), debugstr_guid(delegating_iid));
    TRACE("vtbl=%p\n", &vtbl->Vtbl);
 
    if (!IsEqualGUID(vtbl->header.piid, riid))
    {
        ERR("IID mismatch during stub creation\n");
        return RPC_E_UNEXPECTED;
    }
 
    r = IUnknown_QueryInterface(pUnkServer, riid, (void**)&pvServer);
    if(FAILED(r)) return r;
 
    This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
    if (!This)
    {
        IUnknown_Release(pvServer);
        return E_OUTOFMEMORY;
    }
 
    This->base_obj = get_delegating_vtbl( vtbl->header.DispatchTableCount );
    r = create_stub(delegating_iid, (IUnknown*)&This->base_obj, &This->base_stub);
    if(FAILED(r))
    {
        release_delegating_vtbl(This->base_obj);
        HeapFree(GetProcessHeap(), 0, This);
        IUnknown_Release(pvServer);
        return r;
    }
 
    This->stub_buffer.lpVtbl = &vtbl->Vtbl;
    This->stub_buffer.RefCount = 1;
    This->stub_buffer.pvServerObject = pvServer;
    This->stub_buffer.pPSFactory = pPSFactory;
    *ppStub = (LPRPCSTUBBUFFER)&This->stub_buffer;
 
    IPSFactoryBuffer_AddRef(pPSFactory);
    return S_OK;
}

Referenced by CStdPSFactory_CreateStub().

CStdStubBuffer_Delegating_CountRefs()

static ULONG WINAPI CStdStubBuffer_Delegating_CountRefs ( LPRPCSTUBBUFFER  iface )

static

Definition at line 589 of file cstub.c.

{
    cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
    ULONG ret;
    TRACE("(%p)->CountRefs()\n", This);
 
    ret = CStdStubBuffer_CountRefs(iface);
    ret += IRpcStubBuffer_CountRefs(This->base_stub);
 
    return ret;
}

CStdStubBuffer_Delegating_Disconnect()

static void WINAPI CStdStubBuffer_Delegating_Disconnect ( LPRPCSTUBBUFFER  iface )

static

Definition at line 580 of file cstub.c.

{
    cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
    TRACE("(%p)->Disconnect()\n", This);
 
    IRpcStubBuffer_Disconnect(This->base_stub);
    CStdStubBuffer_Disconnect(iface);
}

CStdStubBuffer_Disconnect()

void WINAPI CStdStubBuffer_Disconnect

(

LPRPCSTUBBUFFER

iface

)

Definition at line 479 of file cstub.c.

{
    CStdStubBuffer *This = (CStdStubBuffer *)iface;
    IUnknown *old;
    TRACE("(%p)->Disconnect()\n",This);
 
    old = InterlockedExchangePointer((void**)&This->pvServerObject, NULL);
 
    if(old)
        IUnknown_Release(old);
}

Referenced by CStdStubBuffer_Delegating_Disconnect().

CStdStubBuffer_GetServerInfo()

const MIDL_SERVER_INFO * CStdStubBuffer_GetServerInfo

(

IRpcStubBuffer *

iface

)

Definition at line 615 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  return STUB_HEADER(This).pServerInfo;
}

Referenced by NdrStubCall2().

CStdStubBuffer_Invoke()

HRESULT WINAPI CStdStubBuffer_Invoke	(	LPRPCSTUBBUFFER	iface,
		PRPCOLEMESSAGE	pMsg,
		LPRPCCHANNELBUFFER	pChannel
	)

Definition at line 491 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  DWORD dwPhase = STUB_UNMARSHAL;
  HRESULT hr = S_OK;
 
  TRACE("(%p)->Invoke(%p,%p)\n",This,pMsg,pChannel);
 
  __TRY
  {
    if (STUB_HEADER(This).pDispatchTable)
      STUB_HEADER(This).pDispatchTable[pMsg->iMethod](iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
    else /* pure interpreted */
      NdrStubCall2(iface, pChannel, (PRPC_MESSAGE)pMsg, &dwPhase);
  }
  __EXCEPT(stub_filter)
  {
    DWORD dwExceptionCode = GetExceptionCode();
    WARN("a stub call failed with exception 0x%08x (%d)\n", dwExceptionCode, dwExceptionCode);
    if (FAILED(dwExceptionCode))
      hr = dwExceptionCode;
    else
      hr = HRESULT_FROM_WIN32(dwExceptionCode);
  }
  __ENDTRY
 
  return hr;
}

CStdStubBuffer_IsIIDSupported()

LPRPCSTUBBUFFER WINAPI CStdStubBuffer_IsIIDSupported	(	LPRPCSTUBBUFFER	iface,
		REFIID	riid
	)

Definition at line 522 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->IsIIDSupported(%s)\n",This,debugstr_guid(riid));
  return IsEqualGUID(STUB_HEADER(This).piid, riid) ? iface : NULL;
}

CStdStubBuffer_QueryInterface()

HRESULT WINAPI CStdStubBuffer_QueryInterface	(	LPRPCSTUBBUFFER	iface,
		REFIID	riid,
		LPVOID *	obj
	)

Definition at line 392 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
 
  if (IsEqualIID(&IID_IUnknown, riid) ||
      IsEqualIID(&IID_IRpcStubBuffer, riid))
  {
    IRpcStubBuffer_AddRef(iface);
    *obj = iface;
    return S_OK;
  }
  *obj = NULL;
  return E_NOINTERFACE;
}

delegating_AddRef()

static ULONG WINAPI delegating_AddRef ( IUnknown *  pUnk )

static

Definition at line 120 of file cstub.c.

{
    return 1;
}

Referenced by fill_delegated_stub_table().

delegating_QueryInterface()

static HRESULT WINAPI delegating_QueryInterface ( IUnknown *  pUnk, REFIID  iid, void **  ppv  )

static

Definition at line 114 of file cstub.c.

{
    *ppv = pUnk;
    return S_OK;
}

Referenced by fill_delegated_stub_table().

delegating_Release()

static ULONG WINAPI delegating_Release ( IUnknown *  pUnk )

static

Definition at line 125 of file cstub.c.

{
    return 1;
}

Referenced by fill_delegated_stub_table().

fill_delegated_proxy_table()

BOOL fill_delegated_proxy_table	(	IUnknownVtbl *	vtbl,
		DWORD	num
	)

Definition at line 266 of file cstub.c.

{
    const void **entry = (const void **)(vtbl + 1);
    DWORD i, j;
 
    if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
    {
        FIXME( "%u methods not supported\n", num );
        return FALSE;
    }
    vtbl->QueryInterface = IUnknown_QueryInterface_Proxy;
    vtbl->AddRef = IUnknown_AddRef_Proxy;
    vtbl->Release = IUnknown_Release_Proxy;
    for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
    {
        const vtbl_method_t *block = method_blocks[i];
        if (!block && !(block = allocate_block( i ))) return FALSE;
        for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++, entry++)
            if (!*entry) *entry = &block[j];
    }
    return TRUE;
}

Referenced by CreateProxyFromTypeInfo(), and init_psfactory().

fill_delegated_stub_table()

static BOOL fill_delegated_stub_table ( IUnknownVtbl *  vtbl, DWORD  num  )

static

Definition at line 244 of file cstub.c.

{
    const void **entry = (const void **)(vtbl + 1);
    DWORD i, j;
 
    if (num - 3 > BLOCK_SIZE * MAX_BLOCKS)
    {
        FIXME( "%u methods not supported\n", num );
        return FALSE;
    }
    vtbl->QueryInterface = delegating_QueryInterface;
    vtbl->AddRef = delegating_AddRef;
    vtbl->Release = delegating_Release;
    for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
    {
        const vtbl_method_t *block = method_blocks[i];
        if (!block && !(block = allocate_block( i ))) return FALSE;
        for (j = 0; j < BLOCK_SIZE && j < num - 3 - i * BLOCK_SIZE; j++) *entry++ = &block[j];
    }
    return TRUE;
}

Referenced by get_delegating_vtbl().

get_delegating_vtbl()

IUnknownVtbl * get_delegating_vtbl

(

DWORD

num_methods

)

Definition at line 289 of file cstub.c.

{
    IUnknownVtbl *ret;
 
    if (num_methods < 256) num_methods = 256;  /* avoid frequent reallocations */
 
    EnterCriticalSection(&delegating_vtbl_section);
 
    if(!current_vtbl || num_methods > current_vtbl->size)
    {
        ref_counted_vtbl *table = HeapAlloc(GetProcessHeap(), 0,
                                            FIELD_OFFSET(ref_counted_vtbl, vtbl) + num_methods * sizeof(void*));
        if (!table)
        {
            LeaveCriticalSection(&delegating_vtbl_section);
            return NULL;
        }
 
        table->ref = 0;
        table->size = num_methods;
        fill_delegated_stub_table(&table->vtbl, num_methods);
 
        if (current_vtbl && current_vtbl->ref == 0)
        {
            TRACE("freeing old table\n");
            HeapFree(GetProcessHeap(), 0, current_vtbl);
        }
        current_vtbl = table;
    }
 
    current_vtbl->ref++;
    ret = &current_vtbl->vtbl;
    LeaveCriticalSection(&delegating_vtbl_section);
    return ret;
}

Referenced by CStdStubBuffer_Delegating_Construct(), and typelib_stub_init().

impl_from_delegating()

static cstdstubbuffer_delegating_t * impl_from_delegating ( IRpcStubBuffer *  iface )

inlinestatic

Definition at line 50 of file cstub.c.

{
    return CONTAINING_RECORD((void *)iface, cstdstubbuffer_delegating_t, stub_buffer);
}

Referenced by CStdStubBuffer_Delegating_Connect(), CStdStubBuffer_Delegating_CountRefs(), CStdStubBuffer_Delegating_Disconnect(), NdrCStdStubBuffer2_Release(), and NdrStubForwardingFunction().

NdrCStdStubBuffer2_Release()

ULONG WINAPI NdrCStdStubBuffer2_Release	(	LPRPCSTUBBUFFER	iface,
		LPPSFACTORYBUFFER	pPSF
	)

Definition at line 438 of file cstub.c.

{
    cstdstubbuffer_delegating_t *This = impl_from_delegating( iface );
    ULONG refs;
 
    TRACE("(%p)->Release()\n", This);
 
    refs = InterlockedDecrement(&This->stub_buffer.RefCount);
    if (!refs)
    {
        /* Just like NdrCStdStubBuffer_Release, we shouldn't call
           Disconnect here */
        IRpcStubBuffer_Disconnect((IRpcStubBuffer *)&This->stub_buffer);
 
        IRpcStubBuffer_Release(This->base_stub);
        release_delegating_vtbl(This->base_obj);
 
        IPSFactoryBuffer_Release(pPSF);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return refs;
}

Referenced by test_CStdStubBuffer2_Release().

NdrCStdStubBuffer_Release()

ULONG WINAPI NdrCStdStubBuffer_Release	(	LPRPCSTUBBUFFER	iface,
		LPPSFACTORYBUFFER	pPSF
	)

Definition at line 417 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  ULONG refs;
 
  TRACE("(%p)->Release()\n",This);
 
  refs = InterlockedDecrement(&This->RefCount);
  if (!refs)
  {
    /* test_Release shows that native doesn't call Disconnect here.
       We'll leave it in for the time being. */
    IRpcStubBuffer_Disconnect(iface);
 
    IPSFactoryBuffer_Release(pPSF);
    HeapFree(GetProcessHeap(),0,This);
  }
  return refs;
}

Referenced by test_CStdStubBuffer_Release(), and test_Release().

NdrStubForwardingFunction()

void __RPC_STUB NdrStubForwardingFunction	(	IRpcStubBuffer *	iface,
		IRpcChannelBuffer *	pChannel,
		PRPC_MESSAGE	pMsg,
		DWORD *	pdwStubPhase
	)

Definition at line 624 of file cstub.c.

{
    /* Note pMsg is passed intact since RPCOLEMESSAGE is basically a RPC_MESSAGE. */
 
    cstdstubbuffer_delegating_t *This = impl_from_delegating(iface);
    HRESULT r = IRpcStubBuffer_Invoke(This->base_stub, (RPCOLEMESSAGE*)pMsg, pChannel);
    if(FAILED(r)) RpcRaiseException(r);
    return;
}

Referenced by CreateStubFromTypeInfo(), and test_NdrStubForwardingFunction().

NdrStubGetBuffer()

void WINAPI NdrStubGetBuffer	(	LPRPCSTUBBUFFER	iface,
		LPRPCCHANNELBUFFER	pRpcChannelBuffer,
		PMIDL_STUB_MESSAGE	pStubMsg
	)

Definition at line 654 of file cstub.c.

{
  CStdStubBuffer *This = (CStdStubBuffer *)iface;
  HRESULT hr;
 
  TRACE("(%p, %p, %p)\n", This, pRpcChannelBuffer, pStubMsg);
 
  pStubMsg->RpcMsg->BufferLength = pStubMsg->BufferLength;
  hr = IRpcChannelBuffer_GetBuffer(pRpcChannelBuffer,
    (RPCOLEMESSAGE *)pStubMsg->RpcMsg, STUB_HEADER(This).piid);
  if (FAILED(hr))
  {
    RpcRaiseException(hr);
    return;
  }
 
  pStubMsg->Buffer = pStubMsg->RpcMsg->Buffer;
}

Referenced by NdrStubCall2().

NdrStubInitialize()

void WINAPI NdrStubInitialize	(	PRPC_MESSAGE	pRpcMsg,
		PMIDL_STUB_MESSAGE	pStubMsg,
		PMIDL_STUB_DESC	pStubDescriptor,
		LPRPCCHANNELBUFFER	pRpcChannelBuffer
	)

Definition at line 638 of file cstub.c.

{
  TRACE("(%p,%p,%p,%p)\n", pRpcMsg, pStubMsg, pStubDescriptor, pRpcChannelBuffer);
  NdrServerInitializeNew(pRpcMsg, pStubMsg, pStubDescriptor);
  pStubMsg->pRpcChannelBuffer = pRpcChannelBuffer;
  IRpcChannelBuffer_GetDestCtx(pStubMsg->pRpcChannelBuffer,
                               &pStubMsg->dwDestContext,
                               &pStubMsg->pvDestContext);
}

Referenced by NdrStubCall2().

release_delegating_vtbl()

void release_delegating_vtbl

(

IUnknownVtbl *

vtbl

)

Definition at line 325 of file cstub.c.

{
    ref_counted_vtbl *table = (ref_counted_vtbl*)((DWORD *)vtbl - 1);
 
    EnterCriticalSection(&delegating_vtbl_section);
    table->ref--;
    TRACE("ref now %d\n", table->ref);
    if(table->ref == 0 && table != current_vtbl)
    {
        TRACE("... and we're not current so free'ing\n");
        HeapFree(GetProcessHeap(), 0, table);
    }
    LeaveCriticalSection(&delegating_vtbl_section);
}

Referenced by CStdStubBuffer_Delegating_Construct(), NdrCStdStubBuffer2_Release(), typelib_stub_init(), and typelib_stub_Release().

stub_filter()

static LONG WINAPI stub_filter ( EXCEPTION_POINTERS *  eptr )

static

Definition at line 43 of file cstub.c.

{
    if (eptr->ExceptionRecord->ExceptionFlags & EXCEPTION_NONCONTINUABLE)
        return EXCEPTION_CONTINUE_SEARCH;
    return EXCEPTION_EXECUTE_HANDLER;
}

Referenced by CStdStubBuffer_Invoke().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

=
{
    0, 0, &delegating_vtbl_section,
    { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": delegating_vtbl_section") }
}

Definition at line 95 of file cstub.c.

CStdStubBuffer_Delegating_Vtbl

const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl

Initial value:

=
{
    CStdStubBuffer_QueryInterface,
    CStdStubBuffer_AddRef,
    NULL,
    CStdStubBuffer_Delegating_Connect,
    CStdStubBuffer_Delegating_Disconnect,
    CStdStubBuffer_Invoke,
    CStdStubBuffer_IsIIDSupported,
    CStdStubBuffer_Delegating_CountRefs,
    CStdStubBuffer_DebugServerQueryInterface,
    CStdStubBuffer_DebugServerRelease
}

Definition at line 601 of file cstub.c.

Referenced by CreateStubFromTypeInfo(), and init_psfactory().

CStdStubBuffer_Vtbl

const IRpcStubBufferVtbl CStdStubBuffer_Vtbl

Initial value:

=
{
    CStdStubBuffer_QueryInterface,
    CStdStubBuffer_AddRef,
    NULL,
    CStdStubBuffer_Connect,
    CStdStubBuffer_Disconnect,
    CStdStubBuffer_Invoke,
    CStdStubBuffer_IsIIDSupported,
    CStdStubBuffer_CountRefs,
    CStdStubBuffer_DebugServerQueryInterface,
    CStdStubBuffer_DebugServerRelease
}

Definition at line 552 of file cstub.c.

Referenced by CreateStubFromTypeInfo(), and init_psfactory().

current_vtbl

ref_counted_vtbl* current_vtbl

static

Definition at line 111 of file cstub.c.

Referenced by get_delegating_vtbl(), and release_delegating_vtbl().

delegating_vtbl_section

static CRITICAL_SECTION delegating_vtbl_section = { &critsect_debug, -1, 0, 0, 0, 0 }

static

Definition at line 94 of file cstub.c.

Referenced by get_delegating_vtbl(), and release_delegating_vtbl().

method_blocks

const vtbl_method_t* method_blocks[MAX_BLOCKS]

static

Definition at line 217 of file cstub.c.

Referenced by allocate_block(), fill_delegated_proxy_table(), and fill_delegated_stub_table().

opcodes

const BYTE opcodes[1]

static

Definition at line 210 of file cstub.c.

Referenced by allocate_block().