cpsf.h File Reference

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

Go to the source code of this file.

Classes
struct	StdProxyImpl
struct	cstdstubbuffer_delegating_t

Functions
HRESULT	StdProxy_Construct (REFIID riid, LPUNKNOWN pUnkOuter, const ProxyFileInfo *ProxyInfo, int Index, LPPSFACTORYBUFFER pPSFactory, LPRPCPROXYBUFFER *ppProxy, LPVOID *ppvObj) DECLSPEC_HIDDEN
HRESULT WINAPI	StdProxy_QueryInterface (IRpcProxyBuffer *iface, REFIID iid, void **obj) DECLSPEC_HIDDEN
ULONG WINAPI	StdProxy_AddRef (IRpcProxyBuffer *iface) DECLSPEC_HIDDEN
HRESULT WINAPI	StdProxy_Connect (IRpcProxyBuffer *iface, IRpcChannelBuffer *channel) DECLSPEC_HIDDEN
void WINAPI	StdProxy_Disconnect (IRpcProxyBuffer *iface) DECLSPEC_HIDDEN
HRESULT	CStdStubBuffer_Construct (REFIID riid, LPUNKNOWN pUnkServer, PCInterfaceName name, CInterfaceStubVtbl *vtbl, LPPSFACTORYBUFFER pPSFactory, LPRPCSTUBBUFFER *ppStub) DECLSPEC_HIDDEN
HRESULT	CStdStubBuffer_Delegating_Construct (REFIID riid, LPUNKNOWN pUnkServer, PCInterfaceName name, CInterfaceStubVtbl *vtbl, REFIID delegating_iid, LPPSFACTORYBUFFER pPSFactory, LPRPCSTUBBUFFER *ppStub) DECLSPEC_HIDDEN
const MIDL_SERVER_INFO *	CStdStubBuffer_GetServerInfo (IRpcStubBuffer *iface) DECLSPEC_HIDDEN
BOOL	fill_delegated_proxy_table (IUnknownVtbl *vtbl, DWORD num) DECLSPEC_HIDDEN
HRESULT	create_proxy (REFIID iid, IUnknown *pUnkOuter, IRpcProxyBuffer **pproxy, void **ppv) DECLSPEC_HIDDEN
HRESULT	create_stub (REFIID iid, IUnknown *pUnk, IRpcStubBuffer **ppstub) DECLSPEC_HIDDEN
BOOL	fill_stubless_table (IUnknownVtbl *vtbl, DWORD num) DECLSPEC_HIDDEN
IUnknownVtbl *	get_delegating_vtbl (DWORD num_methods) DECLSPEC_HIDDEN
void	release_delegating_vtbl (IUnknownVtbl *vtbl) DECLSPEC_HIDDEN

Variables
const IRpcStubBufferVtbl CStdStubBuffer_Vtbl	DECLSPEC_HIDDEN

Function Documentation

create_proxy()

HRESULT create_proxy	(	REFIID	iid,
		IUnknown *	pUnkOuter,
		IRpcProxyBuffer **	pproxy,
		void **	ppv
	)

Definition at line 442 of file ndr_ole.c.

{
    CLSID clsid;
    IPSFactoryBuffer *psfac;
    HRESULT r;
 
    if(!LoadCOM()) return E_FAIL;
 
    r = COM_GetPSClsid( iid, &clsid );
    if(FAILED(r)) return r;
 
    r = COM_GetClassObject( &clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (void**)&psfac );
    if(FAILED(r)) return r;
 
    r = IPSFactoryBuffer_CreateProxy(psfac, pUnkOuter, iid, pproxy, ppv);
 
    IPSFactoryBuffer_Release(psfac);
    return r;
}

Referenced by StdProxy_Construct(), and typelib_proxy_init().

create_stub()

HRESULT create_stub	(	REFIID	iid,
		IUnknown *	pUnk,
		IRpcStubBuffer **	ppstub
	)

Definition at line 466 of file ndr_ole.c.

{
    CLSID clsid;
    IPSFactoryBuffer *psfac;
    HRESULT r;
 
    if(!LoadCOM()) return E_FAIL;
 
    r = COM_GetPSClsid( iid, &clsid );
    if(FAILED(r)) return r;
 
    r = COM_GetClassObject( &clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (void**)&psfac );
    if(FAILED(r)) return r;
 
    r = IPSFactoryBuffer_CreateStub(psfac, iid, pUnk, ppstub);
 
    IPSFactoryBuffer_Release(psfac);
    return r;
}

Referenced by CStdStubBuffer_Delegating_Construct(), test_Connect(), test_CreateStub(), test_delegating_Invoke(), test_Disconnect(), test_Release(), and typelib_stub_init().

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_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_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().

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_stubless_table()

BOOL fill_stubless_table	(	IUnknownVtbl *	vtbl,
		DWORD	num
	)

Definition at line 285 of file cproxy.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;
    }
    for (i = 0; i < (num - 3 + BLOCK_SIZE - 1) / BLOCK_SIZE; i++)
    {
        const struct thunk *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 == (LPVOID)-1) *entry = &block[j];
    }
    return TRUE;
}

Referenced by StdProxy_Construct(), and typelib_proxy_init().

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().

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().

StdProxy_AddRef()

ULONG WINAPI StdProxy_AddRef

(

IRpcProxyBuffer *

iface

)

Definition at line 390 of file cproxy.c.

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

StdProxy_Connect()

HRESULT WINAPI StdProxy_Connect	(	IRpcProxyBuffer *	iface,
		IRpcChannelBuffer *	channel
	)

Definition at line 420 of file cproxy.c.

{
  StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
  TRACE("(%p)->Connect(%p)\n",This,pChannel);
 
  This->pChannel = pChannel;
  IRpcChannelBuffer_AddRef(pChannel);
  if (This->base_proxy) IRpcProxyBuffer_Connect( This->base_proxy, pChannel );
  return S_OK;
}

StdProxy_Construct()

HRESULT StdProxy_Construct	(	REFIID	riid,
		LPUNKNOWN	pUnkOuter,
		const ProxyFileInfo *	ProxyInfo,
		int	Index,
		LPPSFACTORYBUFFER	pPSFactory,
		LPRPCPROXYBUFFER *	ppProxy,
		LPVOID *	ppvObj
	)

Definition at line 305 of file cproxy.c.

{
  StdProxyImpl *This;
  PCInterfaceName name = ProxyInfo->pNamesArray[Index];
  CInterfaceProxyVtbl *vtbl = ProxyInfo->pProxyVtblList[Index];
 
  TRACE("(%p,%p,%p,%p,%p) %s\n", pUnkOuter, vtbl, pPSFactory, ppProxy, ppvObj, name);
 
  /* TableVersion = 2 means it is the stubless version of CInterfaceProxyVtbl */
  if (ProxyInfo->TableVersion > 1) {
    ULONG count = ProxyInfo->pStubVtblList[Index]->header.DispatchTableCount;
    vtbl = (CInterfaceProxyVtbl *)((const void **)vtbl + 1);
    TRACE("stubless vtbl %p: count=%d\n", vtbl->Vtbl, count );
    fill_stubless_table( (IUnknownVtbl *)vtbl->Vtbl, count );
  }
 
  if (!IsEqualGUID(vtbl->header.piid, riid)) {
    ERR("IID mismatch during proxy creation\n");
    return RPC_E_UNEXPECTED;
  }
 
  This = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(StdProxyImpl));
  if (!This) return E_OUTOFMEMORY;
 
  if (!pUnkOuter) pUnkOuter = (IUnknown *)This;
  This->IRpcProxyBuffer_iface.lpVtbl = &StdProxy_Vtbl;
  This->PVtbl = vtbl->Vtbl;
  /* one reference for the proxy */
  This->RefCount = 1;
  This->piid = vtbl->header.piid;
  This->base_object = NULL;
  This->base_proxy = NULL;
  This->pUnkOuter = pUnkOuter;
  This->name = name;
  This->pPSFactory = pPSFactory;
  This->pChannel = NULL;
 
  if(ProxyInfo->pDelegatedIIDs && ProxyInfo->pDelegatedIIDs[Index])
  {
      HRESULT r = create_proxy( ProxyInfo->pDelegatedIIDs[Index], NULL,
                                &This->base_proxy, (void **)&This->base_object );
      if (FAILED(r))
      {
          HeapFree( GetProcessHeap(), 0, This );
          return r;
      }
  }
 
  *ppProxy = &This->IRpcProxyBuffer_iface;
  *ppvObj = &This->PVtbl;
  IUnknown_AddRef((IUnknown *)*ppvObj);
  IPSFactoryBuffer_AddRef(pPSFactory);
 
  TRACE( "iid=%s this %p proxy %p obj %p vtbl %p base proxy %p base obj %p\n",
         debugstr_guid(riid), This, *ppProxy, *ppvObj, This->PVtbl, This->base_proxy, This->base_object );
  return S_OK;
}

Referenced by CStdPSFactory_CreateProxy().

StdProxy_Disconnect()

void WINAPI StdProxy_Disconnect

(

IRpcProxyBuffer *

iface

)

Definition at line 431 of file cproxy.c.

{
  StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
  TRACE("(%p)->Disconnect()\n",This);
 
  if (This->base_proxy) IRpcProxyBuffer_Disconnect( This->base_proxy );
 
  IRpcChannelBuffer_Release(This->pChannel);
  This->pChannel = NULL;
}

StdProxy_QueryInterface()

HRESULT WINAPI StdProxy_QueryInterface	(	IRpcProxyBuffer *	iface,
		REFIID	iid,
		void **	obj
	)

Definition at line 369 of file cproxy.c.

{
  StdProxyImpl *This = impl_from_IRpcProxyBuffer(iface);
  TRACE("(%p)->QueryInterface(%s,%p)\n",This,debugstr_guid(riid),obj);
 
  if (IsEqualGUID(&IID_IUnknown,riid) ||
      IsEqualGUID(This->piid,riid)) {
    *obj = &This->PVtbl;
    InterlockedIncrement(&This->RefCount);
    return S_OK;
  }
 
  if (IsEqualGUID(&IID_IRpcProxyBuffer,riid)) {
    *obj = &This->IRpcProxyBuffer_iface;
    InterlockedIncrement(&This->RefCount);
    return S_OK;
  }
 
  return E_NOINTERFACE;
}

Variable Documentation

DECLSPEC_HIDDEN

const IRpcStubBufferVtbl CStdStubBuffer_Delegating_Vtbl DECLSPEC_HIDDEN

extern

Definition at line 66 of file cpsf.h.