stubmanager.c File Reference

#include <assert.h>
#include <stdarg.h>
#include <limits.h>
#include "windef.h"
#include "winbase.h"
#include "winuser.h"
#include "objbase.h"
#include "rpc.h"
#include "wine/debug.h"
#include "wine/exception.h"
#include "compobj_private.h"

Include dependency graph for stubmanager.c:

Go to the source code of this file.

Classes
struct	rem_unknown

Macros
#define	COBJMACROS

Typedefs
typedef struct rem_unknown	RemUnknown

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static HRESULT	generate_ipid (struct stub_manager *m, IPID *ipid)
struct ifstub *	stub_manager_new_ifstub (struct stub_manager *m, IRpcStubBuffer *sb, REFIID iid, DWORD dest_context, void *dest_context_data, MSHLFLAGS flags)
static void	stub_manager_delete_ifstub (struct stub_manager *m, struct ifstub *ifstub)
static struct ifstub *	stub_manager_ipid_to_ifstub (struct stub_manager *m, const IPID *ipid)
struct ifstub *	stub_manager_find_ifstub (struct stub_manager *m, REFIID iid, MSHLFLAGS flags)
static struct stub_manager *	new_stub_manager (APARTMENT *apt, IUnknown *object)
void	stub_manager_disconnect (struct stub_manager *m)
static void	stub_manager_delete (struct stub_manager *m)
static ULONG	stub_manager_int_addref (struct stub_manager *This)
ULONG	stub_manager_int_release (struct stub_manager *This)
struct stub_manager *	get_stub_manager_from_object (APARTMENT *apt, IUnknown *obj, BOOL alloc)
struct stub_manager *	get_stub_manager (APARTMENT *apt, OID oid)
ULONG	stub_manager_ext_addref (struct stub_manager *m, ULONG refs, BOOL tableweak)
ULONG	stub_manager_ext_release (struct stub_manager *m, ULONG refs, BOOL tableweak, BOOL last_unlock_releases)
static struct stub_manager *	get_stub_manager_from_ipid (APARTMENT *apt, const IPID *ipid, struct ifstub **ifstub)
static HRESULT	ipid_to_ifstub (const IPID *ipid, APARTMENT **stub_apt, struct stub_manager **stubmgr_ret, struct ifstub **ifstub)
static HRESULT	ipid_to_stub_manager (const IPID *ipid, APARTMENT **stub_apt, struct stub_manager **stub)
HRESULT	ipid_get_dispatch_params (const IPID *ipid, APARTMENT **stub_apt, struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, IID *iid, IUnknown **iface)
BOOL	stub_manager_notify_unmarshal (struct stub_manager *m, const IPID *ipid)
void	stub_manager_release_marshal_data (struct stub_manager *m, ULONG refs, const IPID *ipid, BOOL tableweak)
BOOL	stub_manager_is_table_marshaled (struct stub_manager *m, const IPID *ipid)
static RemUnknown *	impl_from_IRemUnknown (IRemUnknown *iface)
static HRESULT	RemUnknown_Construct (IRemUnknown **ppRemUnknown)
static HRESULT WINAPI	RemUnknown_QueryInterface (IRemUnknown *iface, REFIID riid, void **ppv)
static ULONG WINAPI	RemUnknown_AddRef (IRemUnknown *iface)
static ULONG WINAPI	RemUnknown_Release (IRemUnknown *iface)
static HRESULT WINAPI	RemUnknown_RemQueryInterface (IRemUnknown *iface, REFIPID ripid, ULONG cRefs, USHORT cIids, IID *iids, REMQIRESULT **ppQIResults)
static HRESULT WINAPI	RemUnknown_RemAddRef (IRemUnknown *iface, USHORT cInterfaceRefs, REMINTERFACEREF *InterfaceRefs, HRESULT *pResults)
static HRESULT WINAPI	RemUnknown_RemRelease (IRemUnknown *iface, USHORT cInterfaceRefs, REMINTERFACEREF *InterfaceRefs)
HRESULT	start_apartment_remote_unknown (APARTMENT *apt)

Variables
static const IRemUnknownVtbl	RemUnknown_Vtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 26 of file stubmanager.c.

Typedef Documentation

RemUnknown

typedef struct rem_unknown RemUnknown

Function Documentation

generate_ipid()

static HRESULT generate_ipid ( struct stub_manager *  m, IPID *  ipid  )

inlinestatic

Definition at line 52 of file stubmanager.c.

{
    HRESULT hr;
    hr = UuidCreate(ipid);
    if (FAILED(hr))
    {
        ERR("couldn't create IPID for stub manager %p\n", m);
        UuidCreateNil(ipid);
        return hr;
    }
 
    ipid->Data1 = InterlockedIncrement(&m->apt->ipidc);
    ipid->Data2 = (USHORT)m->apt->tid;
    ipid->Data3 = (USHORT)GetCurrentProcessId();
    return S_OK;
}

Referenced by stub_manager_new_ifstub().

get_stub_manager()

struct stub_manager * get_stub_manager	(	APARTMENT *	apt,
		OID	oid
	)

Definition at line 380 of file stubmanager.c.

{
    struct stub_manager *result = NULL;
    struct list         *cursor;
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH( cursor, &apt->stubmgrs )
    {
        struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 
        if (m->oid == oid)
        {
            result = m;
            stub_manager_int_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
 
    if (result)
        TRACE("found %p for oid %s\n", result, wine_dbgstr_longlong(oid));
    else
        TRACE("not found for oid %s\n", wine_dbgstr_longlong(oid));
 
    return result;
}

Referenced by std_release_marshal_data(), and std_unmarshal_interface().

get_stub_manager_from_ipid()

static struct stub_manager * get_stub_manager_from_ipid ( APARTMENT *  apt, const IPID *  ipid, struct ifstub **  ifstub  )

static

Definition at line 474 of file stubmanager.c.

{
    struct stub_manager *result = NULL;
    struct list         *cursor;
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH( cursor, &apt->stubmgrs )
    {
        struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 
        if ((*ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
        {
            result = m;
            stub_manager_int_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
 
    if (result)
        TRACE("found %p for ipid %s\n", result, debugstr_guid(ipid));
    else
        ERR("not found for ipid %s\n", debugstr_guid(ipid));
 
    return result;
}

Referenced by ipid_to_ifstub().

get_stub_manager_from_object()

struct stub_manager * get_stub_manager_from_object	(	APARTMENT *	apt,
		IUnknown *	obj,
		BOOL	alloc
	)

Definition at line 337 of file stubmanager.c.

{
    struct stub_manager *result = NULL;
    struct list         *cursor;
    IUnknown *object;
    HRESULT hres;
 
    hres = IUnknown_QueryInterface(obj, &IID_IUnknown, (void**)&object);
    if (FAILED(hres)) {
        ERR("QueryInterface(IID_IUnknown failed): %08x\n", hres);
        return NULL;
    }
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH( cursor, &apt->stubmgrs )
    {
        struct stub_manager *m = LIST_ENTRY( cursor, struct stub_manager, entry );
 
        if (m->object == object)
        {
            result = m;
            stub_manager_int_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt->cs);
 
    if (result) {
        TRACE("found %p for object %p\n", result, object);
    }else if (alloc) {
        TRACE("not found, creating new stub manager...\n");
        result = new_stub_manager(apt, object);
    }else {
        TRACE("not found for object %p\n", object);
    }
 
    IUnknown_Release(object);
    return result;    
}

Referenced by CoDisconnectObject(), CoLockObjectExternal(), and marshal_object().

impl_from_IRemUnknown()

static RemUnknown * impl_from_IRemUnknown ( IRemUnknown *  iface )

inlinestatic

Definition at line 636 of file stubmanager.c.

{
    return CONTAINING_RECORD(iface, RemUnknown, IRemUnknown_iface);
}

Referenced by RemUnknown_AddRef(), and RemUnknown_Release().

ipid_get_dispatch_params()

HRESULT ipid_get_dispatch_params	(	const IPID *	ipid,
		APARTMENT **	stub_apt,
		struct stub_manager **	manager,
		IRpcStubBuffer **	stub,
		IRpcChannelBuffer **	chan,
		IID *	iid,
		IUnknown **	iface
	)

Definition at line 533 of file stubmanager.c.

{
    struct stub_manager *stubmgr;
    struct ifstub *ifstub;
    APARTMENT *apt;
    HRESULT hr;
 
    hr = ipid_to_ifstub(ipid, &apt, &stubmgr, &ifstub);
    if (hr != S_OK) return RPC_E_DISCONNECTED;
 
    *stub = ifstub->stubbuffer;
    IRpcStubBuffer_AddRef(*stub);
    *chan = ifstub->chan;
    IRpcChannelBuffer_AddRef(*chan);
    *stub_apt = apt;
    *iid = ifstub->iid;
    *iface = ifstub->iface;
 
    if (manager)
        *manager = stubmgr;
    else
        stub_manager_int_release(stubmgr);
    return S_OK;
}

Referenced by ClientRpcChannelBuffer_GetBuffer(), and dispatch_rpc().

ipid_to_ifstub()

static HRESULT ipid_to_ifstub ( const IPID *  ipid, APARTMENT **  stub_apt, struct stub_manager **  stubmgr_ret, struct ifstub **  ifstub  )

static

Definition at line 501 of file stubmanager.c.

{
    /* FIXME: hack for IRemUnknown */
    if (ipid->Data2 == 0xffff)
        *stub_apt = apartment_findfromoxid(*(const OXID *)ipid->Data4, TRUE);
    else
        *stub_apt = apartment_findfromtid(ipid->Data2);
    if (!*stub_apt)
    {
        TRACE("Couldn't find apartment corresponding to TID 0x%04x\n", ipid->Data2);
        return RPC_E_INVALID_OBJECT;
    }
    *stubmgr_ret = get_stub_manager_from_ipid(*stub_apt, ipid, ifstub);
    if (!*stubmgr_ret)
    {
        apartment_release(*stub_apt);
        *stub_apt = NULL;
        return RPC_E_INVALID_OBJECT;
    }
    return S_OK;
}

Referenced by ipid_get_dispatch_params(), ipid_to_stub_manager(), and RemUnknown_RemQueryInterface().

ipid_to_stub_manager()

static HRESULT ipid_to_stub_manager ( const IPID *  ipid, APARTMENT **  stub_apt, struct stub_manager **  stub  )

static

Definition at line 524 of file stubmanager.c.

{
    struct ifstub *ifstub;
    return ipid_to_ifstub(ipid, stub_apt, stub, &ifstub);
}

Referenced by RemUnknown_RemAddRef(), and RemUnknown_RemRelease().

new_stub_manager()

static struct stub_manager * new_stub_manager ( APARTMENT *  apt, IUnknown *  object  )

static

Definition at line 180 of file stubmanager.c.

{
    struct stub_manager *sm;
    HRESULT hres;
 
    assert( apt );
    
    sm = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct stub_manager));
    if (!sm) return NULL;
 
    list_init(&sm->ifstubs);
 
    InitializeCriticalSection(&sm->lock);
    DEBUG_SET_CRITSEC_NAME(&sm->lock, "stub_manager");
 
    IUnknown_AddRef(object);
    sm->object = object;
    sm->apt    = apt;
 
    /* start off with 2 references because the stub is in the apartment
     * and the caller will also hold a reference */
    sm->refs   = 2;
    sm->weakrefs = 0;
 
    sm->oxid_info.dwPid = GetCurrentProcessId();
    sm->oxid_info.dwTid = GetCurrentThreadId();
    /*
     * FIXME: this is a hack for marshalling IRemUnknown. In real
     * DCOM, the IPID of the IRemUnknown interface is generated like
     * any other and passed to the OXID resolver which then returns it
     * when queried. We don't have an OXID resolver yet so instead we
     * use a magic IPID reserved for IRemUnknown.
     */
    sm->oxid_info.ipidRemUnknown.Data1 = 0xffffffff;
    sm->oxid_info.ipidRemUnknown.Data2 = 0xffff;
    sm->oxid_info.ipidRemUnknown.Data3 = 0xffff;
    assert(sizeof(sm->oxid_info.ipidRemUnknown.Data4) == sizeof(apt->oxid));
    memcpy(sm->oxid_info.ipidRemUnknown.Data4, &apt->oxid, sizeof(OXID));
    sm->oxid_info.dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE;
    sm->oxid_info.psa = NULL /* FIXME */;
 
    /* Yes, that's right, this starts at zero. that's zero EXTERNAL
     * refs, i.e., nobody has unmarshalled anything yet. We can't have
     * negative refs because the stub manager cannot be explicitly
     * killed, it has to die by somebody unmarshalling then releasing
     * the marshalled ifptr.
     */
    sm->extrefs = 0;
    sm->disconnected = FALSE;
 
    hres = IUnknown_QueryInterface(object, &IID_IExternalConnection, (void**)&sm->extern_conn);
    if(FAILED(hres))
        sm->extern_conn = NULL;
 
    EnterCriticalSection(&apt->cs);
    sm->oid = apt->oidc++;
    list_add_head(&apt->stubmgrs, &sm->entry);
    LeaveCriticalSection(&apt->cs);
 
    TRACE("Created new stub manager (oid=%s) at %p for object with IUnknown %p\n", wine_dbgstr_longlong(sm->oid), sm, object);
    
    return sm;
}

Referenced by get_stub_manager_from_object().

RemUnknown_AddRef()

static ULONG WINAPI RemUnknown_AddRef ( IRemUnknown *  iface )

static

Definition at line 675 of file stubmanager.c.

{
    ULONG refs;
    RemUnknown *This = impl_from_IRemUnknown(iface);
 
    refs = InterlockedIncrement(&This->refs);
 
    TRACE("%p before: %d\n", iface, refs-1);
    return refs;
}

RemUnknown_Construct()

static HRESULT RemUnknown_Construct ( IRemUnknown **  ppRemUnknown )

static

Definition at line 643 of file stubmanager.c.

{
    RemUnknown *This = HeapAlloc(GetProcessHeap(), 0, sizeof(*This));
 
    if (!This) return E_OUTOFMEMORY;
 
    This->IRemUnknown_iface.lpVtbl = &RemUnknown_Vtbl;
    This->refs = 1;
 
    *ppRemUnknown = &This->IRemUnknown_iface;
    return S_OK;
}

Referenced by start_apartment_remote_unknown().

RemUnknown_QueryInterface()

static HRESULT WINAPI RemUnknown_QueryInterface ( IRemUnknown *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 656 of file stubmanager.c.

{
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
 
    if (IsEqualIID(riid, &IID_IUnknown) ||
        IsEqualIID(riid, &IID_IRemUnknown))
    {
        *ppv = iface;
        IRemUnknown_AddRef(iface);
        return S_OK;
    }
 
    if (!IsEqualIID(riid, &IID_IExternalConnection))
        FIXME("No interface for iid %s\n", debugstr_guid(riid));
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

RemUnknown_Release()

static ULONG WINAPI RemUnknown_Release ( IRemUnknown *  iface )

static

Definition at line 686 of file stubmanager.c.

{
    ULONG refs;
    RemUnknown *This = impl_from_IRemUnknown(iface);
 
    refs = InterlockedDecrement(&This->refs);
    if (!refs)
        HeapFree(GetProcessHeap(), 0, This);
 
    TRACE("%p after: %d\n", iface, refs);
    return refs;
}

RemUnknown_RemAddRef()

static HRESULT WINAPI RemUnknown_RemAddRef ( IRemUnknown *  iface, USHORT  cInterfaceRefs, REMINTERFACEREF *  InterfaceRefs, HRESULT *  pResults  )

static

Definition at line 741 of file stubmanager.c.

{
    HRESULT hr = S_OK;
    USHORT i;
 
    TRACE("(%p)->(%d, %p, %p)\n", iface, cInterfaceRefs, InterfaceRefs, pResults);
 
    for (i = 0; i < cInterfaceRefs; i++)
    {
        APARTMENT *apt;
        struct stub_manager *stubmgr;
 
        pResults[i] = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
        if (pResults[i] != S_OK)
        {
            hr = S_FALSE;
            continue;
        }
 
        stub_manager_ext_addref(stubmgr, InterfaceRefs[i].cPublicRefs, FALSE);
        if (InterfaceRefs[i].cPrivateRefs)
            FIXME("Adding %d refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
 
        stub_manager_int_release(stubmgr);
        apartment_release(apt);
    }
 
    return hr;
}

RemUnknown_RemQueryInterface()

static HRESULT WINAPI RemUnknown_RemQueryInterface ( IRemUnknown *  iface, REFIPID  ripid, ULONG  cRefs, USHORT  cIids, IID *  iids, REMQIRESULT **  ppQIResults  )

static

Definition at line 699 of file stubmanager.c.

{
    HRESULT hr;
    USHORT i;
    USHORT successful_qis = 0;
    APARTMENT *apt;
    struct stub_manager *stubmgr;
    struct ifstub *ifstub;
    DWORD dest_context;
    void *dest_context_data;
 
    TRACE("(%p)->(%s, %d, %d, %p, %p)\n", iface, debugstr_guid(ripid), cRefs, cIids, iids, ppQIResults);
 
    hr = ipid_to_ifstub(ripid, &apt, &stubmgr, &ifstub);
    if (hr != S_OK) return hr;
 
    IRpcChannelBuffer_GetDestCtx(ifstub->chan, &dest_context, &dest_context_data);
 
    *ppQIResults = CoTaskMemAlloc(sizeof(REMQIRESULT) * cIids);
 
    for (i = 0; i < cIids; i++)
    {
        HRESULT hrobj = marshal_object(apt, &(*ppQIResults)[i].std, &iids[i],
                                       stubmgr->object, dest_context, dest_context_data, MSHLFLAGS_NORMAL);
        if (hrobj == S_OK)
            successful_qis++;
        (*ppQIResults)[i].hResult = hrobj;
    }
 
    stub_manager_int_release(stubmgr);
    apartment_release(apt);
 
    if (successful_qis == cIids)
        return S_OK; /* we got all requested interfaces */
    else if (successful_qis == 0)
        return E_NOINTERFACE; /* we didn't get any interfaces */
    else
        return S_FALSE; /* we got some interfaces */
}

RemUnknown_RemRelease()

static HRESULT WINAPI RemUnknown_RemRelease ( IRemUnknown *  iface, USHORT  cInterfaceRefs, REMINTERFACEREF *  InterfaceRefs  )

static

Definition at line 774 of file stubmanager.c.

{
    HRESULT hr = S_OK;
    USHORT i;
 
    TRACE("(%p)->(%d, %p)\n", iface, cInterfaceRefs, InterfaceRefs);
 
    for (i = 0; i < cInterfaceRefs; i++)
    {
        APARTMENT *apt;
        struct stub_manager *stubmgr;
 
        hr = ipid_to_stub_manager(&InterfaceRefs[i].ipid, &apt, &stubmgr);
        if (hr != S_OK)
        {
            hr = E_INVALIDARG;
            /* FIXME: we should undo any changes already made in this function */
            break;
        }
 
        stub_manager_ext_release(stubmgr, InterfaceRefs[i].cPublicRefs, FALSE, TRUE);
        if (InterfaceRefs[i].cPrivateRefs)
            FIXME("Releasing %d refs securely not implemented\n", InterfaceRefs[i].cPrivateRefs);
 
        stub_manager_int_release(stubmgr);
        apartment_release(apt);
    }
 
    return hr;
}

start_apartment_remote_unknown()

HRESULT start_apartment_remote_unknown

(

APARTMENT *

apt

)

Definition at line 818 of file stubmanager.c.

{
    IRemUnknown *pRemUnknown;
    HRESULT hr = S_OK;
 
    EnterCriticalSection(&apt->cs);
    if (!apt->remunk_exported)
    {
        /* create the IRemUnknown object */
        hr = RemUnknown_Construct(&pRemUnknown);
        if (hr == S_OK)
        {
            STDOBJREF stdobjref; /* dummy - not used */
            /* register it with the stub manager */
            hr = marshal_object(apt, &stdobjref, &IID_IRemUnknown, (IUnknown *)pRemUnknown, MSHCTX_DIFFERENTMACHINE, NULL, MSHLFLAGS_NORMAL|MSHLFLAGSP_REMUNKNOWN);
            /* release our reference to the object as the stub manager will manage the life cycle for us */
            IRemUnknown_Release(pRemUnknown);
            if (hr == S_OK)
                apt->remunk_exported = TRUE;
        }
    }
    LeaveCriticalSection(&apt->cs);
    return hr;
}

Referenced by RPC_StartRemoting().

stub_manager_delete()

static void stub_manager_delete ( struct stub_manager *  m )

static

Definition at line 260 of file stubmanager.c.

{
    struct list *cursor;
 
    TRACE("destroying %p (oid=%s)\n", m, wine_dbgstr_longlong(m->oid));
 
    /* release every ifstub */
    while ((cursor = list_head(&m->ifstubs)))
    {
        struct ifstub *ifstub = LIST_ENTRY(cursor, struct ifstub, entry);
        stub_manager_delete_ifstub(m, ifstub);
    }
 
    if(m->extern_conn)
        IExternalConnection_Release(m->extern_conn);
 
    CoTaskMemFree(m->oxid_info.psa);
 
    /* Some broken apps crash in object destructors. We have a test showing
     * that on winxp+ those crashes are caught and ignored. */
    __TRY
    {
        IUnknown_Release(m->object);
    }
    __EXCEPT_PAGE_FAULT
    {
        ERR("Got page fault when releasing stub!\n");
    }
    __ENDTRY
 
    DEBUG_CLEAR_CRITSEC_NAME(&m->lock);
    DeleteCriticalSection(&m->lock);
 
    HeapFree(GetProcessHeap(), 0, m);
}

Referenced by stub_manager_int_release().

stub_manager_delete_ifstub()

static void stub_manager_delete_ifstub ( struct stub_manager *  m, struct ifstub *  ifstub  )

static

Definition at line 121 of file stubmanager.c.

{
    TRACE("m=%p, m->oid=%s, ipid=%s\n", m, wine_dbgstr_longlong(m->oid), debugstr_guid(&ifstub->ipid));
 
    list_remove(&ifstub->entry);
 
    if (!m->disconnected)
        RPC_UnregisterInterface(&ifstub->iid, TRUE);
 
    if (ifstub->stubbuffer) IRpcStubBuffer_Release(ifstub->stubbuffer);
    IUnknown_Release(ifstub->iface);
    IRpcChannelBuffer_Release(ifstub->chan);
 
    HeapFree(GetProcessHeap(), 0, ifstub);
}

Referenced by stub_manager_delete().

stub_manager_disconnect()

void stub_manager_disconnect

(

struct stub_manager *

m

)

Definition at line 244 of file stubmanager.c.

{
    struct ifstub *ifstub;
 
    EnterCriticalSection(&m->lock);
    if (!m->disconnected)
    {
        LIST_FOR_EACH_ENTRY(ifstub, &m->ifstubs, struct ifstub, entry)
            RPC_UnregisterInterface(&ifstub->iid, FALSE);
 
        m->disconnected = TRUE;
    }
    LeaveCriticalSection(&m->lock);
}

Referenced by CoDisconnectObject().

stub_manager_ext_addref()

ULONG stub_manager_ext_addref	(	struct stub_manager *	m,
		ULONG	refs,
		BOOL	tableweak
	)

Definition at line 408 of file stubmanager.c.

{
    BOOL first_extern_ref;
    ULONG rc;
 
    EnterCriticalSection(&m->lock);
 
    first_extern_ref = refs && !m->extrefs;
 
    /* make sure we don't overflow extrefs */
    refs = min(refs, (ULONG_MAX-1 - m->extrefs));
    rc = (m->extrefs += refs);
 
    if (tableweak)
        rc += ++m->weakrefs;
 
    LeaveCriticalSection(&m->lock);
    
    TRACE("added %u refs to %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 
    /*
     * NOTE: According to tests, creating a stub causes two AddConnection calls followed by
     * one ReleaseConnection call (with fLastReleaseCloses=FALSE).
     */
    if(first_extern_ref && m->extern_conn)
        IExternalConnection_AddConnection(m->extern_conn, EXTCONN_STRONG, 0);
 
    return rc;
}

Referenced by CoLockObjectExternal(), marshal_object(), and RemUnknown_RemAddRef().

stub_manager_ext_release()

ULONG stub_manager_ext_release	(	struct stub_manager *	m,
		ULONG	refs,
		BOOL	tableweak,
		BOOL	last_unlock_releases
	)

Definition at line 439 of file stubmanager.c.

{
    BOOL last_extern_ref;
    ULONG rc;
 
    EnterCriticalSection(&m->lock);
 
    /* make sure we don't underflow extrefs */
    refs = min(refs, m->extrefs);
    rc = (m->extrefs -= refs);
 
    if (tableweak)
        --m->weakrefs;
    if (!last_unlock_releases)
        rc += m->weakrefs;
 
    last_extern_ref = refs && !m->extrefs;
 
    LeaveCriticalSection(&m->lock);
    
    TRACE("removed %u refs from %p (oid %s), rc is now %u\n", refs, m, wine_dbgstr_longlong(m->oid), rc);
 
    if (last_extern_ref && m->extern_conn)
        IExternalConnection_ReleaseConnection(m->extern_conn, EXTCONN_STRONG, 0, last_unlock_releases);
 
    if (rc == 0)
        if (!(m->extern_conn && last_unlock_releases && m->weakrefs))
            stub_manager_int_release(m);
 
    return rc;
}

Referenced by CoLockObjectExternal(), marshal_object(), RemUnknown_RemRelease(), std_unmarshal_interface(), and stub_manager_release_marshal_data().

stub_manager_find_ifstub()

struct ifstub * stub_manager_find_ifstub	(	struct stub_manager *	m,
		REFIID	iid,
		MSHLFLAGS	flags
	)

Definition at line 158 of file stubmanager.c.

{
    struct ifstub  *result = NULL;
    struct ifstub  *ifstub;
 
    EnterCriticalSection(&m->lock);
    LIST_FOR_EACH_ENTRY( ifstub, &m->ifstubs, struct ifstub, entry )
    {
        if (IsEqualIID(iid, &ifstub->iid) && (ifstub->flags == flags))
        {
            result = ifstub;
            break;
        }
    }
    LeaveCriticalSection(&m->lock);
 
    return result;
}

Referenced by marshal_object().

stub_manager_int_addref()

static ULONG stub_manager_int_addref ( struct stub_manager *  This )

static

Definition at line 297 of file stubmanager.c.

{
    ULONG refs;
 
    EnterCriticalSection(&This->apt->cs);
    refs = ++This->refs;
    LeaveCriticalSection(&This->apt->cs);
 
    TRACE("before %d\n", refs - 1);
 
    return refs;
}

Referenced by get_stub_manager(), get_stub_manager_from_ipid(), and get_stub_manager_from_object().

stub_manager_int_release()

ULONG stub_manager_int_release

(

struct stub_manager *

This

)

Definition at line 311 of file stubmanager.c.

{
    ULONG refs;
    APARTMENT *apt = This->apt;
 
    EnterCriticalSection(&apt->cs);
    refs = --This->refs;
 
    TRACE("after %d\n", refs);
 
    /* remove from apartment so no other thread can access it... */
    if (!refs)
        list_remove(&This->entry);
 
    LeaveCriticalSection(&apt->cs);
 
    /* ... so now we can delete it without being inside the apartment critsec */
    if (!refs)
        stub_manager_delete(This);
 
    return refs;
}

Referenced by apartment_release(), CoDisconnectObject(), CoLockObjectExternal(), dispatch_rpc(), ipid_get_dispatch_params(), marshal_object(), RemUnknown_RemAddRef(), RemUnknown_RemQueryInterface(), RemUnknown_RemRelease(), std_release_marshal_data(), std_unmarshal_interface(), and stub_manager_ext_release().

stub_manager_ipid_to_ifstub()

static struct ifstub * stub_manager_ipid_to_ifstub ( struct stub_manager *  m, const IPID *  ipid  )

static

Definition at line 137 of file stubmanager.c.

{
    struct list    *cursor;
    struct ifstub  *result = NULL;
 
    EnterCriticalSection(&m->lock);
    LIST_FOR_EACH( cursor, &m->ifstubs )
    {
        struct ifstub *ifstub = LIST_ENTRY( cursor, struct ifstub, entry );
 
        if (IsEqualGUID(ipid, &ifstub->ipid))
        {
            result = ifstub;
            break;
        }
    }
    LeaveCriticalSection(&m->lock);
 
    return result;
}

Referenced by get_stub_manager_from_ipid(), stub_manager_is_table_marshaled(), stub_manager_notify_unmarshal(), and stub_manager_release_marshal_data().

stub_manager_is_table_marshaled()

BOOL stub_manager_is_table_marshaled	(	struct stub_manager *	m,
		const IPID *	ipid
	)

Definition at line 609 of file stubmanager.c.

{
    struct ifstub *ifstub = stub_manager_ipid_to_ifstub(m, ipid);
 
    assert( ifstub );
    
    return ifstub->flags & (MSHLFLAGS_TABLESTRONG | MSHLFLAGS_TABLEWEAK);
}

Referenced by std_unmarshal_interface().

stub_manager_new_ifstub()

struct ifstub * stub_manager_new_ifstub	(	struct stub_manager *	m,
		IRpcStubBuffer *	sb,
		REFIID	iid,
		DWORD	dest_context,
		void *	dest_context_data,
		MSHLFLAGS	flags
	)

Definition at line 70 of file stubmanager.c.

{
    struct ifstub *stub;
    HRESULT hr;
 
    TRACE("oid=%s, stubbuffer=%p, iid=%s, dest_context=%x\n", wine_dbgstr_longlong(m->oid), sb,
          debugstr_guid(iid), dest_context);
 
    stub = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(struct ifstub));
    if (!stub) return NULL;
 
    hr = IUnknown_QueryInterface(m->object, iid, (void **)&stub->iface);
    if (hr != S_OK)
    {
        HeapFree(GetProcessHeap(), 0, stub);
        return NULL;
    }
 
    hr = RPC_CreateServerChannel(dest_context, dest_context_data, &stub->chan);
    if (hr != S_OK)
    {
        IUnknown_Release(stub->iface);
        HeapFree(GetProcessHeap(), 0, stub);
        return NULL;
    }
 
    stub->stubbuffer = sb;
    if (sb) IRpcStubBuffer_AddRef(sb);
 
    stub->flags = flags;
    stub->iid = *iid;
 
    /* FIXME: find a cleaner way of identifying that we are creating an ifstub
     * for the remunknown interface */
    if (flags & MSHLFLAGSP_REMUNKNOWN)
        stub->ipid = m->oxid_info.ipidRemUnknown;
    else
        generate_ipid(m, &stub->ipid);
 
    EnterCriticalSection(&m->lock);
    list_add_head(&m->ifstubs, &stub->entry);
    /* every normal marshal is counted so we don't allow more than we should */
    if (flags & MSHLFLAGS_NORMAL) m->norm_refs++;
    LeaveCriticalSection(&m->lock);
 
    TRACE("ifstub %p created with ipid %s\n", stub, debugstr_guid(&stub->ipid));
 
    return stub;
}

Referenced by marshal_object().

stub_manager_notify_unmarshal()

BOOL stub_manager_notify_unmarshal	(	struct stub_manager *	m,
		const IPID *	ipid
	)

Definition at line 562 of file stubmanager.c.

{
    BOOL ret = TRUE;
    struct ifstub *ifstub;
 
    if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
    {
        ERR("attempted unmarshal of unknown IPID %s\n", debugstr_guid(ipid));
        return FALSE;
    }
 
    EnterCriticalSection(&m->lock);
 
    /* track normal marshals so we can enforce rules whilst in-process */
    if (ifstub->flags & MSHLFLAGS_NORMAL)
    {
        if (m->norm_refs)
            m->norm_refs--;
        else
        {
            ERR("attempted invalid normal unmarshal, norm_refs is zero\n");
            ret = FALSE;
        }
    }
 
    LeaveCriticalSection(&m->lock);
 
    return ret;
}

Referenced by std_unmarshal_interface().

stub_manager_release_marshal_data()

void stub_manager_release_marshal_data	(	struct stub_manager *	m,
		ULONG	refs,
		const IPID *	ipid,
		BOOL	tableweak
	)

Definition at line 593 of file stubmanager.c.

{
    struct ifstub *ifstub;
 
    if (!(ifstub = stub_manager_ipid_to_ifstub(m, ipid)))
        return;
 
    if (ifstub->flags & MSHLFLAGS_TABLEWEAK)
        refs = 0;
    else if (ifstub->flags & MSHLFLAGS_TABLESTRONG)
        refs = 1;
 
    stub_manager_ext_release(m, refs, tableweak, !tableweak);
}

Referenced by std_release_marshal_data().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

RemUnknown_Vtbl

static const IRemUnknownVtbl RemUnknown_Vtbl

static

Initial value:

=
{
    RemUnknown_QueryInterface,
    RemUnknown_AddRef,
    RemUnknown_Release,
    RemUnknown_RemQueryInterface,
    RemUnknown_RemAddRef,
    RemUnknown_RemRelease
}

Definition at line 634 of file stubmanager.c.

Referenced by RemUnknown_Construct().