combase_private.h File Reference

#include "winternl.h"
#include "wine/orpc.h"
#include "wine/list.h"

Include dependency graph for combase_private.h:

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

Go to the source code of this file.

Classes
struct	apartment
struct	tlsdata
struct	class_reg_data
struct	ifstub
struct	stub_manager

Macros
#define	DM_EXECUTERPC   (WM_USER + 0) /* WPARAM = 0, LPARAM = (struct dispatch_params *) */
#define	DM_HOSTOBJECT   (WM_USER + 1) /* WPARAM = 0, LPARAM = (struct host_object_params *) */
#define	CHARS_IN_GUID   39
#define	MSHLFLAGSP_REMUNKNOWN   0x80000000

Typedefs
typedef enum ifstub_state	STUB_STATE

Enumerations
enum	tlsdata_flags { OLETLS_UUIDINITIALIZED = 0x2 , OLETLS_DISABLE_OLE1DDE = 0x40 , OLETLS_APARTMENTTHREADED = 0x80 , OLETLS_MULTITHREADED = 0x100 }
enum	class_reg_data_origin { CLASS_REG_ACTCTX , CLASS_REG_REGISTRY , CLASS_REG_ACTCTX , CLASS_REG_REGISTRY }
enum	ifstub_state {   STUBSTATE_NORMAL_MARSHALED , STUBSTATE_NORMAL_UNMARSHALED , STUBSTATE_TABLE_WEAK_MARSHALED , STUBSTATE_TABLE_WEAK_UNMARSHALED ,   STUBSTATE_TABLE_STRONG }

Functions
HRESULT	open_key_for_clsid (REFCLSID clsid, const WCHAR *keyname, REGSAM access, HKEY *subkey)
HRESULT	open_appidkey_from_clsid (REFCLSID clsid, REGSAM access, HKEY *subkey)
HRESULT WINAPI	InternalTlsAllocData (struct tlsdata **data)
BOOL WINAPI	InternalIsProcessInitialized (void)
static HRESULT	com_get_tlsdata (struct tlsdata **data)
static struct apartment *	com_get_current_apt (void)
HWND	apartment_getwindow (const struct apartment *apt)
HRESULT	apartment_createwindowifneeded (struct apartment *apt)
void	apartment_freeunusedlibraries (struct apartment *apt, DWORD unload_delay)
void	apartment_global_cleanup (void)
OXID	apartment_getoxid (const struct apartment *apt)
HRESULT	apartment_disconnectproxies (struct apartment *apt)
HRESULT	rpcss_get_next_seqid (DWORD *id)
HRESULT	rpc_get_local_class_object (REFCLSID rclsid, REFIID riid, void **obj)
HRESULT	rpc_register_local_server (REFCLSID clsid, IStream *stream, DWORD flags, unsigned int *cookie)
HRESULT	rpc_revoke_local_server (unsigned int cookie)
HRESULT	rpc_create_clientchannel (const OXID *oxid, const IPID *ipid, const OXID_INFO *oxid_info, const IID *iid, DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan, struct apartment *apt)
HRESULT	rpc_create_serverchannel (DWORD dest_context, void *dest_context_data, IRpcChannelBuffer **chan)
HRESULT	rpc_register_interface (REFIID riid)
void	rpc_unregister_interface (REFIID riid, BOOL wait)
HRESULT	rpc_resolve_oxid (OXID oxid, OXID_INFO *oxid_info)
void	rpc_start_remoting (struct apartment *apt)
HRESULT	rpc_register_channel_hook (REFGUID rguid, IChannelHook *hook)
void	rpc_unregister_channel_hooks (void)
void	rpc_execute_call (struct dispatch_params *params)
HRESULT	enter_apartment (struct tlsdata *data, DWORD model)
void	leave_apartment (struct tlsdata *data)
void	apartment_release (struct apartment *apt)
struct apartment *	apartment_get_current_or_mta (void)
HRESULT	apartment_increment_mta_usage (CO_MTA_USAGE_COOKIE *cookie)
void	apartment_decrement_mta_usage (CO_MTA_USAGE_COOKIE cookie)
HRESULT	ensure_mta (void)
struct apartment *	apartment_get_mta (void)
HRESULT	apartment_get_inproc_class_object (struct apartment *apt, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, DWORD class_context, void **ppv)
HRESULT	apartment_get_local_server_stream (struct apartment *apt, IStream **ret)
IUnknown *	com_get_registered_class_object (const struct apartment *apartment, REFCLSID rclsid, DWORD clscontext)
void	apartment_revoke_all_classes (const struct apartment *apt)
struct apartment *	apartment_findfromoxid (OXID oxid)
struct apartment *	apartment_findfromtid (DWORD tid)
HRESULT	marshal_object (struct apartment *apt, STDOBJREF *stdobjref, REFIID riid, IUnknown *object, DWORD dest_context, void *dest_context_data, MSHLFLAGS mshlflags)
ULONG	stub_manager_int_release (struct stub_manager *stub_manager)
struct stub_manager *	get_stub_manager_from_object (struct apartment *apt, IUnknown *object, BOOL alloc)
void	stub_manager_disconnect (struct stub_manager *m)
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)
struct stub_manager *	get_stub_manager (struct apartment *apt, OID oid)
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)
BOOL	stub_manager_notify_unmarshal (struct stub_manager *m, const IPID *ipid)
struct ifstub *	stub_manager_find_ifstub (struct stub_manager *m, REFIID iid, MSHLFLAGS flags)
struct ifstub *	stub_manager_new_ifstub (struct stub_manager *m, IRpcStubBuffer *sb, REFIID iid, DWORD dest_context, void *dest_context_data, MSHLFLAGS flags)
HRESULT	ipid_get_dispatch_params (const IPID *ipid, struct apartment **stub_apt, struct stub_manager **manager, IRpcStubBuffer **stub, IRpcChannelBuffer **chan, IID *iid, IUnknown **iface)
HRESULT	ipid_get_dest_context (const IPID *ipid, MSHCTX *dest_context, void **dest_context_data)
HRESULT	start_apartment_remote_unknown (struct apartment *apt)

Variables
HINSTANCE	hProxyDll

Macro Definition Documentation

CHARS_IN_GUID

#define CHARS_IN_GUID   39

Definition at line 63 of file combase_private.h.

DM_EXECUTERPC

#define DM_EXECUTERPC   (WM_USER + 0) /* WPARAM = 0, LPARAM = (struct dispatch_params *) */

Definition at line 60 of file combase_private.h.

DM_HOSTOBJECT

#define DM_HOSTOBJECT   (WM_USER + 1) /* WPARAM = 0, LPARAM = (struct host_object_params *) */

Definition at line 61 of file combase_private.h.

MSHLFLAGSP_REMUNKNOWN

#define MSHLFLAGSP_REMUNKNOWN   0x80000000

Definition at line 183 of file combase_private.h.

Typedef Documentation

STUB_STATE

typedef enum ifstub_state STUB_STATE

Enumeration Type Documentation

class_reg_data_origin

enum class_reg_data_origin

Enumerator
CLASS_REG_ACTCTX
CLASS_REG_REGISTRY
CLASS_REG_ACTCTX
CLASS_REG_REGISTRY

Definition at line 139 of file combase_private.h.

{
    CLASS_REG_ACTCTX,
    CLASS_REG_REGISTRY,
};

ifstub_state

enum ifstub_state

Enumerator
STUBSTATE_NORMAL_MARSHALED
STUBSTATE_NORMAL_UNMARSHALED
STUBSTATE_TABLE_WEAK_MARSHALED
STUBSTATE_TABLE_WEAK_UNMARSHALED
STUBSTATE_TABLE_STRONG

Definition at line 198 of file combase_private.h.

{
    STUBSTATE_NORMAL_MARSHALED,
    STUBSTATE_NORMAL_UNMARSHALED,
    STUBSTATE_TABLE_WEAK_MARSHALED,
    STUBSTATE_TABLE_WEAK_UNMARSHALED,
    STUBSTATE_TABLE_STRONG,
} STUB_STATE;

tlsdata_flags

enum tlsdata_flags

Enumerator
OLETLS_UUIDINITIALIZED
OLETLS_DISABLE_OLE1DDE
OLETLS_APARTMENTTHREADED
OLETLS_MULTITHREADED

Definition at line 65 of file combase_private.h.

{
    OLETLS_UUIDINITIALIZED = 0x2,
    OLETLS_DISABLE_OLE1DDE = 0x40,
    OLETLS_APARTMENTTHREADED = 0x80,
    OLETLS_MULTITHREADED = 0x100,
};

Function Documentation

apartment_createwindowifneeded()

HRESULT apartment_createwindowifneeded

(

struct apartment *

apt

)

Definition at line 1250 of file apartment.c.

{
    static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
 
    if (apt->multi_threaded)
        return S_OK;
 
    if (!apt->win)
    {
        HWND hwnd;
 
        InitOnceExecuteOnce( &class_init_once, register_class, NULL, NULL );
 
        hwnd = CreateWindowW(aptwinclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, hProxyDll, NULL);
        if (!hwnd)
        {
            ERR("CreateWindow failed with error %ld\n", GetLastError());
            return HRESULT_FROM_WIN32(GetLastError());
        }
        if (InterlockedCompareExchangePointer((void **)&apt->win, hwnd, NULL))
            /* someone beat us to it */
            DestroyWindow(hwnd);
    }
 
    return S_OK;
}

Referenced by apartment_get_or_create(), apartment_hostobject_thread(), and marshal_object().

apartment_decrement_mta_usage()

void apartment_decrement_mta_usage

(

CO_MTA_USAGE_COOKIE

cookie

)

Definition at line 1199 of file apartment.c.

{
    struct mta_cookie *mta_cookie = (struct mta_cookie *)cookie;
 
    EnterCriticalSection(&apt_cs);
 
    if (mta)
    {
        struct mta_cookie *cur;
 
        LIST_FOR_EACH_ENTRY(cur, &mta->usage_cookies, struct mta_cookie, entry)
        {
            if (mta_cookie == cur)
            {
                list_remove(&cur->entry);
                free(cur);
                apartment_release(mta);
                break;
            }
        }
    }
 
    LeaveCriticalSection(&apt_cs);
}

Referenced by CoDecrementMTAUsage(), com_cleanup_tlsdata(), and leave_apartment().

apartment_disconnectproxies()

HRESULT apartment_disconnectproxies

(

struct apartment *

apt

)

Definition at line 1992 of file marshal.c.

{
    struct proxy_manager *proxy;
 
    LIST_FOR_EACH_ENTRY(proxy, &apt->proxies, struct proxy_manager, entry)
    {
        proxy_manager_disconnect(proxy);
    }
 
    return S_OK;
}

Referenced by apartment_release().

apartment_findfromoxid()

struct apartment * apartment_findfromoxid

(

OXID

oxid

)

Definition at line 635 of file apartment.c.

{
    struct apartment *result = NULL, *apt;
 
    EnterCriticalSection(&apt_cs);
    LIST_FOR_EACH_ENTRY(apt, &apts, struct apartment, entry)
    {
        if (apt->oxid == oxid)
        {
            result = apt;
            apartment_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&apt_cs);
 
    return result;
}

Referenced by ipid_to_ifstub(), std_release_marshal_data(), and std_unmarshal_interface().

apartment_findfromtid()

struct apartment * apartment_findfromtid

(

DWORD

tid

)

Definition at line 657 of file apartment.c.

{
    struct apartment *result = NULL, *apt;
 
    EnterCriticalSection(&apt_cs);
    LIST_FOR_EACH_ENTRY(apt, &apts, struct apartment, entry)
    {
        if (apt != mta && apt->tid == tid)
        {
            result = apt;
            apartment_addref(result);
            break;
        }
    }
 
    if (!result && mta && mta->tid == tid)
    {
        result = mta;
        apartment_addref(result);
    }
 
    LeaveCriticalSection(&apt_cs);
 
    return result;
}

Referenced by ipid_to_ifstub().

apartment_freeunusedlibraries()

void apartment_freeunusedlibraries	(	struct apartment *	apt,
		DWORD	unload_delay
	)

Definition at line 403 of file apartment.c.

{
    struct apartment_loaded_dll *entry, *next;
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH_ENTRY_SAFE(entry, next, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
    {
        if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
        {
            DWORD real_delay = delay;
 
            if (real_delay == INFINITE)
            {
                /* DLLs that return multi-threaded objects aren't unloaded
                 * straight away to cope for programs that have races between
                 * last object destruction and threads in the DLLs that haven't
                 * finished, despite DllCanUnloadNow returning S_OK */
                if (entry->multi_threaded)
                    real_delay = 10 * 60 * 1000; /* 10 minutes */
                else
                    real_delay = 0;
            }
 
            if (!real_delay || (entry->unload_time && ((int)(GetTickCount() - entry->unload_time) > 0)))
            {
                list_remove(&entry->entry);
                apartment_release_dll(entry->dll, TRUE);
                free(entry);
            }
            else
            {
                entry->unload_time = GetTickCount() + real_delay;
                if (!entry->unload_time) entry->unload_time = 1;
            }
        }
        else if (entry->unload_time)
            entry->unload_time = 0;
    }
    LeaveCriticalSection(&apt->cs);
}

Referenced by apartment_release(), and CoFreeUnusedLibrariesEx().

apartment_get_current_or_mta()

struct apartment * apartment_get_current_or_mta

(

void

)

Definition at line 623 of file apartment.c.

{
    struct apartment *apt = com_get_current_apt();
    if (apt)
    {
        apartment_addref(apt);
        return apt;
    }
    return apartment_get_mta();
}

Referenced by ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_SendReceive(), CoDisconnectObject(), CoLockObjectExternal(), com_get_class_object(), CoRegisterClassObject(), CoRevokeClassObject(), InternalIsProcessInitialized(), proxy_manager_get_remunknown(), std_unmarshal_interface(), and StdMarshalImpl_MarshalInterface().

apartment_get_inproc_class_object()

HRESULT apartment_get_inproc_class_object	(	struct apartment *	apt,
		const struct class_reg_data *	regdata,
		REFCLSID	rclsid,
		REFIID	riid,
		DWORD	class_context,
		void **	ppv
	)

Definition at line 1031 of file apartment.c.

{
    WCHAR dllpath[MAX_PATH+1];
    BOOL apartment_threaded;
 
    if (!(class_context & CLSCTX_PS_DLL))
    {
        enum comclass_threadingmodel model = get_threading_model(regdata);
 
        if (model == ThreadingModel_Apartment)
        {
            apartment_threaded = TRUE;
            if (apt->multi_threaded)
                return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, regdata, rclsid, riid, ppv);
        }
        else if (model == ThreadingModel_Free)
        {
            apartment_threaded = FALSE;
            if (!apt->multi_threaded)
                return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, regdata, rclsid, riid, ppv);
        }
        /* everything except "Apartment", "Free" and "Both" */
        else if (model != ThreadingModel_Both)
        {
            apartment_threaded = TRUE;
            /* everything else is main-threaded */
            if (model != ThreadingModel_No)
                FIXME("unrecognised threading model %d for object %s, should be main-threaded?\n", model, debugstr_guid(rclsid));
 
            if (apt->multi_threaded || !apt->main)
                return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, regdata, rclsid, riid, ppv);
        }
        else
            apartment_threaded = FALSE;
    }
    else
        apartment_threaded = !apt->multi_threaded;
 
    if (!get_object_dll_path(regdata, dllpath, ARRAY_SIZE(dllpath)))
    {
        /* failure: CLSID is not found in registry */
        WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
        return REGDB_E_CLASSNOTREG;
    }
 
    return apartment_getclassobject(apt, dllpath, apartment_threaded, rclsid, riid, ppv);
}

Referenced by com_get_class_object().

apartment_get_local_server_stream()

HRESULT apartment_get_local_server_stream	(	struct apartment *	apt,
		IStream **	ret
	)

Definition at line 315 of file apartment.c.

{
    HRESULT hr = S_OK;
 
    EnterCriticalSection(&apt->cs);
 
    if (!apt->local_server)
    {
        struct local_server *obj;
 
        obj = malloc(sizeof(*obj));
        if (obj)
        {
            obj->IServiceProvider_iface.lpVtbl = &local_server_vtbl;
            obj->refcount = 1;
            obj->apt = apt;
 
            hr = CreateStreamOnHGlobal(0, TRUE, &obj->marshal_stream);
            if (SUCCEEDED(hr))
            {
                hr = CoMarshalInterface(obj->marshal_stream, &IID_IServiceProvider, (IUnknown *)&obj->IServiceProvider_iface,
                        MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
                if (FAILED(hr))
                    IStream_Release(obj->marshal_stream);
            }
 
            if (SUCCEEDED(hr))
                apt->local_server = obj;
            else
                free(obj);
        }
        else
            hr = E_OUTOFMEMORY;
    }
 
    if (SUCCEEDED(hr))
        hr = IStream_Clone(apt->local_server->marshal_stream, ret);
 
    LeaveCriticalSection(&apt->cs);
 
    if (FAILED(hr))
        ERR("Failed: %#lx\n", hr);
 
    return hr;
}

Referenced by CoRegisterClassObject().

apartment_get_mta()

struct apartment * apartment_get_mta

(

void

)

Definition at line 607 of file apartment.c.

{
    struct apartment *apt;
 
    EnterCriticalSection(&apt_cs);
 
    if ((apt = mta))
        apartment_addref(apt);
 
    LeaveCriticalSection(&apt_cs);
 
    return apt;
}

Referenced by apartment_get_current_or_mta(), CoGetApartmentType(), and ipid_to_ifstub().

apartment_getoxid()

OXID apartment_getoxid

(

const struct apartment *

apt

)

Definition at line 1284 of file apartment.c.

{
    return apt->oxid;
}

Referenced by ClientRpcChannelBuffer_IsCorrectApartment(), marshal_object(), rpc_create_clientchannel(), and std_unmarshal_interface().

apartment_getwindow()

HWND apartment_getwindow

(

const struct apartment *

apt

)

Definition at line 1278 of file apartment.c.

{
    assert(!apt->multi_threaded);
    return apt->win;
}

Referenced by apartment_hostobject_in_hostapt(), apartment_hostobject_thread(), ClientRpcChannelBuffer_GetBuffer(), and dispatch_rpc().

apartment_global_cleanup()

void apartment_global_cleanup

(

void

)

Definition at line 1289 of file apartment.c.

{
    if (apt_win_class)
        UnregisterClassW((const WCHAR *)MAKEINTATOM(apt_win_class), hProxyDll);
    apartment_release_dlls();
    DeleteCriticalSection(&apt_cs);
}

Referenced by DllMain().

apartment_increment_mta_usage()

HRESULT apartment_increment_mta_usage

(

CO_MTA_USAGE_COOKIE *

cookie

)

Definition at line 1175 of file apartment.c.

{
    struct mta_cookie *mta_cookie;
 
    *cookie = NULL;
 
    if (!(mta_cookie = malloc(sizeof(*mta_cookie))))
        return E_OUTOFMEMORY;
 
    EnterCriticalSection(&apt_cs);
 
    if (mta)
        apartment_addref(mta);
    else
        mta = apartment_construct(COINIT_MULTITHREADED);
    list_add_head(&mta->usage_cookies, &mta_cookie->entry);
 
    LeaveCriticalSection(&apt_cs);
 
    *cookie = (CO_MTA_USAGE_COOKIE)mta_cookie;
 
    return S_OK;
}

Referenced by CoIncrementMTAUsage(), and ensure_mta().

apartment_release()

void apartment_release

(

struct apartment *

apt

)

Definition at line 444 of file apartment.c.

{
    DWORD refcount;
 
    EnterCriticalSection(&apt_cs);
 
    refcount = InterlockedDecrement(&apt->refs);
    TRACE("%s: after = %ld\n", wine_dbgstr_longlong(apt->oxid), refcount);
 
    if (apt->being_destroyed)
    {
        LeaveCriticalSection(&apt_cs);
        return;
    }
 
    /* destruction stuff that needs to happen under global */
    if (!refcount)
    {
        apt->being_destroyed = TRUE;
        if (apt == mta) mta = NULL;
        else if (apt == main_sta) main_sta = NULL;
        list_remove(&apt->entry);
    }
 
    LeaveCriticalSection(&apt_cs);
 
    if (!refcount)
    {
        struct list *cursor, *cursor2;
 
        TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
 
        if (apt->local_server)
        {
            struct local_server *local_server = apt->local_server;
            LARGE_INTEGER zero;
 
            memset(&zero, 0, sizeof(zero));
            IStream_Seek(local_server->marshal_stream, zero, STREAM_SEEK_SET, NULL);
            CoReleaseMarshalData(local_server->marshal_stream);
            IStream_Release(local_server->marshal_stream);
            local_server->marshal_stream = NULL;
 
            apt->local_server = NULL;
            local_server->apt = NULL;
            IServiceProvider_Release(&local_server->IServiceProvider_iface);
        }
 
        /* Release the references to the registered class objects */
        apartment_revoke_all_classes(apt);
 
        /* no locking is needed for this apartment, because no other thread
         * can access it at this point */
 
        apartment_disconnectproxies(apt);
 
        if (apt->win) DestroyWindow(apt->win);
        if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
 
        LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
        {
            struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
            /* release the implicit reference given by the fact that the
             * stub has external references (it must do since it is in the
             * stub manager list in the apartment and all non-apartment users
             * must have a ref on the apartment and so it cannot be destroyed).
             */
            stub_manager_int_release(stubmgr);
        }
 
        /* if this assert fires, then another thread took a reference to a
         * stub manager without taking a reference to the containing
         * apartment, which it must do. */
        assert(list_empty(&apt->stubmgrs));
 
        if (apt->filter) IMessageFilter_Release(apt->filter);
 
        /* free as many unused libraries as possible... */
        apartment_freeunusedlibraries(apt, 0);
 
        /* ... and free the memory for the apartment loaded dll entry and
         * release the dll list reference without freeing the library for the
         * rest */
        while ((cursor = list_head(&apt->loaded_dlls)))
        {
            struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
            apartment_release_dll(apartment_loaded_dll->dll, FALSE);
            list_remove(cursor);
            free(apartment_loaded_dll);
        }
 
        apt->cs.DebugInfo->Spare[0] = 0;
        DeleteCriticalSection(&apt->cs);
 
        free(apt);
    }
}

Referenced by apartment_decrement_mta_usage(), apartment_hostobject_in_hostapt(), ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_GetBuffer(), ClientRpcChannelBuffer_SendReceive(), CoDisconnectObject(), CoGetApartmentType(), CoLockObjectExternal(), com_cleanup_tlsdata(), com_get_class_object(), CoRegisterClassObject(), CoRevokeClassObject(), dispatch_rpc(), InternalIsProcessInitialized(), ipid_get_dest_context(), ipid_to_ifstub(), leave_apartment(), proxy_manager_get_remunknown(), RemUnknown_RemAddRef(), RemUnknown_RemQueryInterface(), RemUnknown_RemRelease(), std_release_marshal_data(), std_unmarshal_interface(), and StdMarshalImpl_MarshalInterface().

apartment_revoke_all_classes()

void apartment_revoke_all_classes

(

const struct apartment *

apt

)

Definition at line 3089 of file combase.c.

{
    struct registered_class *cur, *cur2;
 
    EnterCriticalSection(&registered_classes_cs);
 
    LIST_FOR_EACH_ENTRY_SAFE(cur, cur2, &registered_classes, struct registered_class, entry)
    {
        if (cur->apartment_id == apt->oxid)
            com_revoke_class_object(cur);
    }
 
    LeaveCriticalSection(&registered_classes_cs);
}

Referenced by apartment_release().

com_get_current_apt()

static struct apartment * com_get_current_apt ( void  )

inlinestatic

Definition at line 107 of file combase_private.h.

{
    struct tlsdata *tlsdata = NULL;
    com_get_tlsdata(&tlsdata);
    return tlsdata->apt;
}

Referenced by apartment_get_current_or_mta(), apartment_get_or_create(), apartment_hostobject_thread(), apartment_wndproc(), CoFreeUnusedLibrariesEx(), CoRegisterMessageFilter(), CoWaitForMultipleHandles(), local_server_QueryService(), and rpc_execute_call().

com_get_registered_class_object()

IUnknown * com_get_registered_class_object	(	const struct apartment *	apartment,
		REFCLSID	rclsid,
		DWORD	clscontext
	)

Definition at line 144 of file combase.c.

{
    struct registered_class *cur;
    IUnknown *object = NULL;
 
    EnterCriticalSection(&registered_classes_cs);
 
    LIST_FOR_EACH_ENTRY(cur, &registered_classes, struct registered_class, entry)
    {
        if ((apt->oxid == cur->apartment_id) &&
            (clscontext & cur->clscontext) &&
            IsEqualGUID(&cur->clsid, rclsid))
        {
            object = cur->object;
            IUnknown_AddRef(cur->object);
            break;
        }
    }
 
    LeaveCriticalSection(&registered_classes_cs);
 
    return object;
}

Referenced by com_get_class_object(), CoRegisterClassObject(), and local_server_QueryService().

com_get_tlsdata()

static HRESULT com_get_tlsdata ( struct tlsdata **  data )

inlinestatic

Definition at line 101 of file combase_private.h.

{
    *data = NtCurrentTeb()->ReservedForOle;
    return *data ? S_OK : InternalTlsAllocData(data);
}

Referenced by apartment_get_or_create(), ClientRpcChannelBuffer_SendReceive(), CoDisableCallCancellation(), CoEnableCallCancellation(), CoGetApartmentType(), CoGetCallContext(), CoGetContextToken(), CoGetCurrentLogicalThreadId(), CoGetCurrentProcess(), CoInitializeEx(), com_get_current_apt(), CoRegisterInitializeSpy(), CoRevokeInitializeSpy(), CoSwitchCallContext(), CoUninitialize(), CoWaitForMultipleHandles(), dispatch_rpc(), ensure_mta(), GetErrorInfo(), rpc_execute_call(), and SetErrorInfo().

ensure_mta()

HRESULT ensure_mta

(

void

)

Definition at line 1297 of file apartment.c.

{
    struct apartment *apt;
    struct tlsdata *data;
    HRESULT hr;
 
    if (FAILED(hr = com_get_tlsdata(&data)))
        return hr;
    if ((apt = data->apt) && (data->implicit_mta_cookie || apt->multi_threaded))
        return S_OK;
 
    EnterCriticalSection(&apt_cs);
    if (apt || mta)
        hr = apartment_increment_mta_usage(&data->implicit_mta_cookie);
    else
        hr = CO_E_NOTINITIALIZED;
    LeaveCriticalSection(&apt_cs);
 
    if (FAILED(hr))
    {
        ERR("Failed, hr %#lx.\n", hr);
        return hr;
    }
    return S_OK;
}

Referenced by RoGetActivationFactory().

enter_apartment()

HRESULT enter_apartment	(	struct tlsdata *	data,
		DWORD	model
	)

Definition at line 1129 of file apartment.c.

{
    HRESULT hr = S_OK;
 
    if (!data->apt)
    {
        if (!apartment_get_or_create(model))
            return E_OUTOFMEMORY;
    }
    else if (!apartment_is_model(data->apt, model))
    {
        WARN("Attempt to change threading model of this apartment from %s to %s\n",
              data->apt->multi_threaded ? "multi-threaded" : "apartment threaded",
              model & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded" );
        return RPC_E_CHANGED_MODE;
    }
    else
        hr = S_FALSE;
 
    data->inits++;
 
    return hr;
}

Referenced by CoInitializeEx(), and dispatch_rpc().

get_stub_manager()

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

Definition at line 381 of file stubmanager.c.

{
    struct stub_manager *result = NULL, *m;
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH_ENTRY(m, &apt->stubmgrs, 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_object()

struct stub_manager * get_stub_manager_from_object	(	struct apartment *	apt,
		IUnknown *	object,
		BOOL	alloc
	)

Definition at line 335 of file stubmanager.c.

{
    struct stub_manager *result = NULL, *m;
    IUnknown *object;
    HRESULT hres;
 
    hres = IUnknown_QueryInterface(obj, &IID_IUnknown, (void**)&object);
    if (FAILED(hres))
    {
        ERR("QueryInterface(IID_IUnknown failed): %#lx\n", hres);
        return NULL;
    }
 
    EnterCriticalSection(&apt->cs);
    LIST_FOR_EACH_ENTRY(m, &apt->stubmgrs, 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().

InternalIsProcessInitialized()

BOOL WINAPI InternalIsProcessInitialized

(

void

)

Definition at line 391 of file combase.c.

{
    struct apartment *apt;
 
    if (!(apt = apartment_get_current_or_mta()))
        return FALSE;
    apartment_release(apt);
 
    return TRUE;
}

InternalTlsAllocData()

HRESULT WINAPI InternalTlsAllocData

(

struct tlsdata **

data

)

Definition at line 405 of file combase.c.

{
    if (!(*data = calloc(1, sizeof(**data))))
        return E_OUTOFMEMORY;
 
    list_init(&(*data)->spies);
    NtCurrentTeb()->ReservedForOle = *data;
 
    return S_OK;
}

Referenced by com_get_tlsdata().

ipid_get_dest_context()

HRESULT ipid_get_dest_context	(	const IPID *	ipid,
		MSHCTX *	dest_context,
		void **	dest_context_data
	)

Definition at line 557 of file stubmanager.c.

{
    struct stub_manager *stubmgr;
    struct ifstub *ifstub;
    struct apartment *apt;
    void *data;
    HRESULT hr;
    DWORD ctx;
 
    hr = ipid_to_ifstub(ipid, &apt, &stubmgr, &ifstub);
    if (hr != S_OK) return RPC_E_DISCONNECTED;
 
    hr = IRpcChannelBuffer_GetDestCtx(ifstub->chan, &ctx, &data);
    if (SUCCEEDED(hr))
    {
        *dest_context = ctx;
        *dest_context_data = data;
    }
 
    stub_manager_int_release(stubmgr);
    apartment_release(apt);
 
    return hr;
}

Referenced by std_unmarshal_interface().

ipid_get_dispatch_params()

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

Definition at line 530 of file stubmanager.c.

{
    struct stub_manager *stubmgr;
    struct ifstub *ifstub;
    struct 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().

leave_apartment()

void leave_apartment

(

struct tlsdata *

data

)

Definition at line 1153 of file apartment.c.

{
    if (!--data->inits)
    {
        if (data->ole_inits)
            WARN( "Uninitializing apartment while Ole is still initialized\n" );
        apartment_release(data->apt);
        if (data->implicit_mta_cookie)
        {
            apartment_decrement_mta_usage(data->implicit_mta_cookie);
            data->implicit_mta_cookie = NULL;
        }
        data->apt = NULL;
        data->flags &= ~(OLETLS_DISABLE_OLE1DDE | OLETLS_APARTMENTTHREADED | OLETLS_MULTITHREADED);
    }
}

Referenced by CoUninitialize(), and dispatch_rpc().

marshal_object()

HRESULT marshal_object	(	struct apartment *	apt,
		STDOBJREF *	stdobjref,
		REFIID	riid,
		IUnknown *	object,
		DWORD	dest_context,
		void *	dest_context_data,
		MSHLFLAGS	mshlflags
	)

Definition at line 870 of file marshal.c.

{
    struct stub_manager *manager;
    struct ifstub       *ifstub;
    BOOL                 tablemarshal;
    HRESULT              hr;
 
    stdobjref->oxid = apartment_getoxid(apt);
 
    hr = apartment_createwindowifneeded(apt);
    if (hr != S_OK)
        return hr;
 
    if (!(manager = get_stub_manager_from_object(apt, object, TRUE)))
        return E_OUTOFMEMORY;
 
    stdobjref->flags = SORF_NULL;
    if (mshlflags & MSHLFLAGS_TABLEWEAK)
        stdobjref->flags |= SORFP_TABLEWEAK;
    if (mshlflags & MSHLFLAGS_NOPING)
        stdobjref->flags |= SORF_NOPING;
    stdobjref->oid = manager->oid;
 
    tablemarshal = ((mshlflags & MSHLFLAGS_TABLESTRONG) || (mshlflags & MSHLFLAGS_TABLEWEAK));
 
    /* make sure ifstub that we are creating is unique */
    ifstub = stub_manager_find_ifstub(manager, riid, mshlflags);
    if (!ifstub) {
        IRpcStubBuffer *stub = NULL;
 
        /* IUnknown doesn't require a stub buffer, because it never goes out on
         * the wire */
        if (!IsEqualIID(riid, &IID_IUnknown))
        {
            IPSFactoryBuffer *psfb;
 
            hr = get_facbuf_for_iid(riid, &psfb);
            if (hr == S_OK) {
                hr = IPSFactoryBuffer_CreateStub(psfb, riid, manager->object, &stub);
                IPSFactoryBuffer_Release(psfb);
                if (hr != S_OK)
                    ERR("Failed to create an IRpcStubBuffer from IPSFactory for %s with error %#lx\n",
                        debugstr_guid(riid), hr);
            }else {
                WARN("couldn't get IPSFactory buffer for interface %s\n", debugstr_guid(riid));
                hr = E_NOINTERFACE;
            }
 
        }
 
        if (hr == S_OK) {
            ifstub = stub_manager_new_ifstub(manager, stub, riid, dest_context, dest_context_data, mshlflags);
            if (!ifstub)
                hr = E_OUTOFMEMORY;
        }
        if (stub) IRpcStubBuffer_Release(stub);
 
        if (hr != S_OK) {
            stub_manager_int_release(manager);
            /* destroy the stub manager if it has no ifstubs by releasing
             * zero external references */
            stub_manager_ext_release(manager, 0, FALSE, TRUE);
            return hr;
        }
    }
 
    if (!tablemarshal)
    {
        stdobjref->cPublicRefs = NORMALEXTREFS;
        stub_manager_ext_addref(manager, stdobjref->cPublicRefs, FALSE);
    }
    else
    {
        stdobjref->cPublicRefs = 0;
        if (mshlflags & MSHLFLAGS_TABLESTRONG)
            stub_manager_ext_addref(manager, 1, FALSE);
        else
            stub_manager_ext_addref(manager, 0, TRUE);
    }
 
    /* FIXME: check return value */
    rpc_register_interface(riid);
 
    stdobjref->ipid = ifstub->ipid;
 
    stub_manager_int_release(manager);
    return S_OK;
}

Referenced by RemUnknown_RemQueryInterface(), start_apartment_remote_unknown(), and StdMarshalImpl_MarshalInterface().

open_appidkey_from_clsid()

HRESULT open_appidkey_from_clsid	(	REFCLSID	clsid,
		REGSAM	access,
		HKEY *	subkey
	)

Definition at line 353 of file combase.c.

{
    static const WCHAR appidkeyW[] = L"AppId\\";
    DWORD res;
    WCHAR buf[CHARS_IN_GUID];
    WCHAR keyname[ARRAY_SIZE(appidkeyW) + CHARS_IN_GUID];
    DWORD size;
    HKEY hkey;
    DWORD type;
    HRESULT hr;
 
    /* read the AppID value under the class's key */
    hr = open_key_for_clsid(clsid, NULL, access, &hkey);
    if (FAILED(hr))
        return hr;
 
    size = sizeof(buf);
    res = RegQueryValueExW(hkey, L"AppId", NULL, &type, (LPBYTE)buf, &size);
    RegCloseKey(hkey);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS || type!=REG_SZ)
        return REGDB_E_READREGDB;
 
    lstrcpyW(keyname, appidkeyW);
    lstrcatW(keyname, buf);
    res = open_classes_key(HKEY_CLASSES_ROOT, keyname, access, subkey);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    return S_OK;
}

Referenced by create_local_service(), and create_surrogate_server().

open_key_for_clsid()

HRESULT open_key_for_clsid	(	REFCLSID	clsid,
		const WCHAR *	keyname,
		REGSAM	access,
		HKEY *	subkey
	)

Definition at line 320 of file combase.c.

{
    static const WCHAR clsidW[] = L"CLSID\\";
    WCHAR path[CHARS_IN_GUID + ARRAY_SIZE(clsidW) - 1];
    LONG res;
    HKEY key;
 
    lstrcpyW(path, clsidW);
    StringFromGUID2(clsid, path + lstrlenW(clsidW), CHARS_IN_GUID);
    res = open_classes_key(HKEY_CLASSES_ROOT, path, access, &key);
 
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_CLASSNOTREG;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    if (!keyname)
    {
        *subkey = key;
        return S_OK;
    }
 
    res = open_classes_key(key, keyname, access, subkey);
    RegCloseKey(key);
    if (res == ERROR_FILE_NOT_FOUND)
        return REGDB_E_KEYMISSING;
    else if (res != ERROR_SUCCESS)
        return REGDB_E_READREGDB;
 
    return S_OK;
}

Referenced by CoGetTreatAsClass(), com_get_class_object(), create_server(), create_surrogate_server(), open_appidkey_from_clsid(), and ProgIDFromCLSID().

rpc_create_clientchannel()

HRESULT rpc_create_clientchannel	(	const OXID *	oxid,
		const IPID *	ipid,
		const OXID_INFO *	oxid_info,
		const IID *	iid,
		DWORD	dest_context,
		void *	dest_context_data,
		IRpcChannelBuffer **	chan,
		struct apartment *	apt
	)

Definition at line 1642 of file rpc.c.

{
    ClientRpcChannelBuffer *This;
    WCHAR                   endpoint[200];
    RPC_BINDING_HANDLE      bind;
    RPC_STATUS              status;
    LPWSTR                  string_binding;
 
    /* FIXME: get the endpoint from oxid_info->psa instead */
    get_rpc_endpoint(endpoint, oxid);
 
    TRACE("proxy pipe: connecting to endpoint: %s\n", debugstr_w(endpoint));
 
    status = RpcStringBindingComposeW(
        NULL,
        rpctransportW,
        NULL,
        endpoint,
        NULL,
        &string_binding);
 
    if (status == RPC_S_OK)
    {
        status = RpcBindingFromStringBindingW(string_binding, &bind);
 
        if (status == RPC_S_OK)
        {
            IPID ipid2 = *ipid; /* why can't RpcBindingSetObject take a const? */
            status = RpcBindingSetObject(bind, &ipid2);
            if (status != RPC_S_OK)
                RpcBindingFree(&bind);
        }
 
        RpcStringFreeW(&string_binding);
    }
 
    if (status != RPC_S_OK)
    {
        ERR("Couldn't get binding for endpoint %s, status = %ld\n", debugstr_w(endpoint), status);
        return HRESULT_FROM_WIN32(status);
    }
 
    This = malloc(sizeof(*This));
    if (!This)
    {
        RpcBindingFree(&bind);
        return E_OUTOFMEMORY;
    }
 
    This->super.IRpcChannelBuffer_iface.lpVtbl = &ClientRpcChannelBufferVtbl;
    This->super.refs = 1;
    This->super.dest_context = dest_context;
    This->super.dest_context_data = dest_context_data;
    This->bind = bind;
    This->oxid = apartment_getoxid(apt);
    This->server_pid = oxid_info->dwPid;
    This->event = NULL;
    This->iid = *iid;
 
    *chan = &This->super.IRpcChannelBuffer_iface;
 
    return S_OK;
}

Referenced by unmarshal_object().

rpc_create_serverchannel()

HRESULT rpc_create_serverchannel	(	DWORD	dest_context,
		void *	dest_context_data,
		IRpcChannelBuffer **	chan
	)

Definition at line 1709 of file rpc.c.

{
    RpcChannelBuffer *This = malloc(sizeof(*This));
    if (!This)
        return E_OUTOFMEMORY;
 
    This->IRpcChannelBuffer_iface.lpVtbl = &ServerRpcChannelBufferVtbl;
    This->refs = 1;
    This->dest_context = dest_context;
    This->dest_context_data = dest_context_data;
 
    *chan = &This->IRpcChannelBuffer_iface;
 
    return S_OK;
}

Referenced by stub_manager_new_ifstub().

rpc_execute_call()

void rpc_execute_call

(

struct dispatch_params *

params

)

Definition at line 1874 of file rpc.c.

{
    struct message_state *message_state = NULL;
    RPC_MESSAGE *msg = (RPC_MESSAGE *)params->msg;
    char *original_buffer = msg->Buffer;
    ORPCTHIS orpcthis;
    ORPC_EXTENT_ARRAY orpc_ext_array;
    WIRE_ORPC_EXTENT *first_wire_orpc_extent;
    GUID old_causality_id;
    struct tlsdata *tlsdata;
    struct apartment *apt;
 
    if (FAILED(com_get_tlsdata(&tlsdata)))
        return;
 
    apt = com_get_current_apt();
 
    /* handle ORPCTHIS and server extensions */
 
    params->hr = unmarshal_ORPCTHIS(msg, &orpcthis, &orpc_ext_array, &first_wire_orpc_extent);
    if (params->hr != S_OK)
    {
        msg->Buffer = original_buffer;
        goto exit;
    }
 
    message_state = malloc(sizeof(*message_state));
    if (!message_state)
    {
        params->hr = E_OUTOFMEMORY;
        msg->Buffer = original_buffer;
        goto exit;
    }
 
    message_state->prefix_data_len = (char *)msg->Buffer - original_buffer;
    message_state->binding_handle = msg->Handle;
    message_state->bypass_rpcrt = params->bypass_rpcrt;
 
    message_state->channel_hook_info.iid = params->iid;
    message_state->channel_hook_info.cbSize = sizeof(message_state->channel_hook_info);
    message_state->channel_hook_info.uCausality = orpcthis.cid;
    message_state->channel_hook_info.dwServerPid = GetCurrentProcessId();
    message_state->channel_hook_info.iMethod = msg->ProcNum;
    message_state->channel_hook_info.pObject = params->iface;
 
    if (orpcthis.extensions && first_wire_orpc_extent &&
        orpcthis.extensions->size)
        ChannelHooks_ServerNotify(&message_state->channel_hook_info, msg->DataRepresentation, first_wire_orpc_extent, orpcthis.extensions->size);
 
    msg->Handle = message_state;
    msg->BufferLength -= message_state->prefix_data_len;
 
    /* call message filter */
 
    if (apt->filter)
    {
        DWORD handlecall;
        INTERFACEINFO interface_info;
        CALLTYPE calltype;
 
        interface_info.pUnk = params->iface;
        interface_info.iid = params->iid;
        interface_info.wMethod = msg->ProcNum;
 
        if (IsEqualGUID(&orpcthis.cid, &tlsdata->causality_id))
            calltype = CALLTYPE_NESTED;
        else if (tlsdata->pending_call_count_server == 0)
            calltype = CALLTYPE_TOPLEVEL;
        else
            calltype = CALLTYPE_TOPLEVEL_CALLPENDING;
 
        handlecall = IMessageFilter_HandleInComingCall(apt->filter,
                                                       calltype,
                                                       UlongToHandle(GetCurrentProcessId()),
                                                       0 /* FIXME */,
                                                       &interface_info);
        TRACE("IMessageFilter_HandleInComingCall returned %ld\n", handlecall);
        switch (handlecall)
        {
        case SERVERCALL_REJECTED:
            params->hr = RPC_E_CALL_REJECTED;
            goto exit_reset_state;
        case SERVERCALL_RETRYLATER:
#if 0 /* FIXME: handle retries on the client side before enabling this code */
            params->hr = RPC_E_RETRY;
            goto exit_reset_state;
#else
            FIXME("retry call later not implemented\n");
            break;
#endif
        case SERVERCALL_ISHANDLED:
        default:
            break;
        }
    }
 
    /* invoke the method */
 
    /* save the old causality ID - note: any calls executed while processing
     * messages received during the SendReceive will appear to originate from
     * this call - this should be checked with what Windows does */
    old_causality_id = tlsdata->causality_id;
    tlsdata->causality_id = orpcthis.cid;
    tlsdata->pending_call_count_server++;
    params->hr = IRpcStubBuffer_Invoke(params->stub, params->msg, params->chan);
    tlsdata->pending_call_count_server--;
    tlsdata->causality_id = old_causality_id;
 
    /* the invoke allocated a new buffer, so free the old one */
    if (message_state->bypass_rpcrt && original_buffer != msg->Buffer)
        free(original_buffer);
 
exit_reset_state:
    message_state = msg->Handle;
    msg->Handle = message_state->binding_handle;
    msg->Buffer = (char *)msg->Buffer - message_state->prefix_data_len;
    msg->BufferLength += message_state->prefix_data_len;
 
exit:
    free(message_state);
    if (params->handle) SetEvent(params->handle);
}

Referenced by apartment_wndproc(), and dispatch_rpc().

rpc_get_local_class_object()

HRESULT rpc_get_local_class_object	(	REFCLSID	rclsid,
		REFIID	riid,
		void **	obj
	)

Definition at line 629 of file rpc.c.

{
    PMInterfacePointer objref = NULL;
    IServiceProvider *local_server;
    IStream *stream = NULL;
    ULARGE_INTEGER newpos;
    LARGE_INTEGER seekto;
    int tries = 0;
    ULONG length;
    HRESULT hr;
    static const int MAXTRIES = 30; /* 30 seconds */
 
    TRACE("clsid %s, riid %s\n", debugstr_guid(rclsid), debugstr_guid(riid));
 
    while (tries++ < MAXTRIES)
    {
        DWORD index, start_ticks;
        HANDLE process = 0;
 
        if (SUCCEEDED(hr = rpcss_get_class_object(rclsid, &objref)))
            break;
 
        if (tries == 1)
        {
            if ((hr = create_local_service(rclsid)) && (hr = create_server(rclsid, &process)) &&
                (hr = create_surrogate_server(rclsid, &process)) )
                return hr;
        }
 
        /* Wait for one second, even if messages arrive. */
        start_ticks = GetTickCount();
        do
        {
            if (SUCCEEDED(CoWaitForMultipleHandles(0, 1000, (process != 0), &process, &index)) && process && !index)
            {
                WARN("Server for %s failed to start.\n", debugstr_guid(rclsid));
                CloseHandle(process);
                return E_NOINTERFACE;
            }
        } while (GetTickCount() - start_ticks < 1000);
 
        if (process) CloseHandle(process);
    }
 
    if (!objref || tries >= MAXTRIES)
        return E_NOINTERFACE;
 
    if (SUCCEEDED(hr = CreateStreamOnHGlobal(0, TRUE, &stream)))
        hr = IStream_Write(stream, objref->abData, objref->ulCntData, &length);
 
    MIDL_user_free(objref);
 
    if (SUCCEEDED(hr))
    {
        seekto.QuadPart = 0;
        IStream_Seek(stream, seekto, STREAM_SEEK_SET, &newpos);
 
        TRACE("Unmarshalling local server.\n");
        hr = CoUnmarshalInterface(stream, &IID_IServiceProvider, (void **)&local_server);
        if (SUCCEEDED(hr))
        {
            hr = IServiceProvider_QueryService(local_server, rclsid, riid, obj);
            IServiceProvider_Release(local_server);
        }
    }
 
    if (stream)
        IStream_Release(stream);
 
    return hr;
}

Referenced by com_get_class_object().

rpc_register_channel_hook()

HRESULT rpc_register_channel_hook	(	REFGUID	rguid,
		IChannelHook *	hook
	)

Definition at line 971 of file rpc.c.

{
    struct channel_hook_entry *entry;
 
    entry = malloc(sizeof(*entry));
    if (!entry)
        return E_OUTOFMEMORY;
 
    entry->id = *rguid;
    entry->hook = hook;
    IChannelHook_AddRef(hook);
 
    EnterCriticalSection(&csChannelHook);
    list_add_tail(&channel_hooks, &entry->entry);
    LeaveCriticalSection(&csChannelHook);
 
    return S_OK;
}

Referenced by CoRegisterChannelHook().

rpc_register_interface()

HRESULT rpc_register_interface

(

REFIID

riid

)

Definition at line 2086 of file rpc.c.

{
    struct registered_if *rif;
    BOOL found = FALSE;
    HRESULT hr = S_OK;
 
    TRACE("(%s)\n", debugstr_guid(riid));
 
    EnterCriticalSection(&csRegIf);
    LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry)
    {
        if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid))
        {
            rif->refs++;
            found = TRUE;
            break;
        }
    }
    if (!found)
    {
        TRACE("Creating new interface\n");
 
        rif = calloc(1, sizeof(*rif));
        if (rif)
        {
            RPC_STATUS status;
 
            rif->refs = 1;
            rif->If.Length = sizeof(RPC_SERVER_INTERFACE);
            /* RPC interface ID = COM interface ID */
            rif->If.InterfaceId.SyntaxGUID = *riid;
            rif->If.DispatchTable = &rpc_dispatch;
            /* all other fields are 0, including the version asCOM objects
             * always have a version of 0.0 */
            status = RpcServerRegisterIfEx(
                (RPC_IF_HANDLE)&rif->If,
                NULL, NULL,
                RPC_IF_OLE | RPC_IF_AUTOLISTEN,
                RPC_C_LISTEN_MAX_CALLS_DEFAULT,
                NULL);
            if (status == RPC_S_OK)
                list_add_tail(&registered_interfaces, &rif->entry);
            else
            {
                ERR("RpcServerRegisterIfEx failed with error %ld\n", status);
                free(rif);
                hr = HRESULT_FROM_WIN32(status);
            }
        }
        else
            hr = E_OUTOFMEMORY;
    }
    LeaveCriticalSection(&csRegIf);
    return hr;
}

Referenced by marshal_object().

rpc_register_local_server()

HRESULT rpc_register_local_server	(	REFCLSID	clsid,
		IStream *	stream,
		DWORD	flags,
		unsigned int *	cookie
	)

Definition at line 701 of file rpc.c.

{
    MInterfacePointer *obj;
    const void *ptr;
    HGLOBAL hmem;
    SIZE_T size;
    HRESULT hr;
 
    TRACE("%s, %#lx\n", debugstr_guid(clsid), flags);
 
    hr = GetHGlobalFromStream(stream, &hmem);
    if (FAILED(hr)) return hr;
 
    size = GlobalSize(hmem);
    if (!(obj = malloc(FIELD_OFFSET(MInterfacePointer, abData[size]))))
        return E_OUTOFMEMORY;
    obj->ulCntData = size;
    ptr = GlobalLock(hmem);
    memcpy(obj->abData, ptr, size);
    GlobalUnlock(hmem);
 
    hr = rpcss_server_register(clsid, flags, obj, cookie);
 
    free(obj);
 
    return hr;
}

Referenced by CoRegisterClassObject().

rpc_resolve_oxid()

HRESULT rpc_resolve_oxid	(	OXID	oxid,
		OXID_INFO *	oxid_info
	)

Definition at line 2165 of file rpc.c.

{
    TRACE("%s\n", wine_dbgstr_longlong(oxid));
 
    oxid_info->dwTid = 0;
    oxid_info->dwPid = 0;
    oxid_info->dwAuthnHint = RPC_C_AUTHN_LEVEL_NONE;
    /* FIXME: this is a hack around not having an OXID resolver yet -
     * this function should contact the machine's OXID resolver and then it
     * should give us the IPID of the IRemUnknown interface */
    oxid_info->ipidRemUnknown.Data1 = 0xffffffff;
    oxid_info->ipidRemUnknown.Data2 = 0xffff;
    oxid_info->ipidRemUnknown.Data3 = 0xffff;
    memcpy(oxid_info->ipidRemUnknown.Data4, &oxid, sizeof(OXID));
    oxid_info->psa = NULL /* FIXME */;
 
    return S_OK;
}

Referenced by proxy_manager_construct().

rpc_revoke_local_server()

HRESULT rpc_revoke_local_server

(

unsigned int

cookie

)

Definition at line 375 of file rpc.c.

{
    RPCSS_CALL_START
    hr = irpcss_server_revoke(get_irpcss_handle(), cookie);
    RPCSS_CALL_END
}

Referenced by com_revoke_class_object().

rpc_start_remoting()

void rpc_start_remoting

(

struct apartment *

apt

)

Definition at line 2186 of file rpc.c.

{
    if (!InterlockedExchange(&apt->remoting_started, TRUE))
    {
        WCHAR endpoint[200];
        RPC_STATUS status;
 
        get_rpc_endpoint(endpoint, &apt->oxid);
 
        status = RpcServerUseProtseqEpW(
            rpctransportW,
            RPC_C_PROTSEQ_MAX_REQS_DEFAULT,
            endpoint,
            NULL);
        if (status != RPC_S_OK)
            ERR("Couldn't register endpoint %s\n", debugstr_w(endpoint));
 
        /* FIXME: move remote unknown exporting into this function */
    }
    start_apartment_remote_unknown(apt);
}

Referenced by StdMarshalImpl_MarshalInterface().

rpc_unregister_channel_hooks()

void rpc_unregister_channel_hooks

(

void

)

Definition at line 990 of file rpc.c.

{
    struct channel_hook_entry *cursor;
    struct channel_hook_entry *cursor2;
 
    EnterCriticalSection(&csChannelHook);
    LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &channel_hooks, struct channel_hook_entry, entry)
        free(cursor);
    LeaveCriticalSection(&csChannelHook);
    DeleteCriticalSection(&csChannelHook);
    DeleteCriticalSection(&csRegIf);
}

Referenced by DllMain().

rpc_unregister_interface()

void rpc_unregister_interface	(	REFIID	riid,
		BOOL	wait
	)

Definition at line 2143 of file rpc.c.

{
    struct registered_if *rif;
    EnterCriticalSection(&csRegIf);
    LIST_FOR_EACH_ENTRY(rif, &registered_interfaces, struct registered_if, entry)
    {
        if (IsEqualGUID(&rif->If.InterfaceId.SyntaxGUID, riid))
        {
            if (!--rif->refs)
            {
                RpcServerUnregisterIf((RPC_IF_HANDLE)&rif->If, NULL, wait);
                list_remove(&rif->entry);
                free(rif);
            }
            break;
        }
    }
    LeaveCriticalSection(&csRegIf);
}

Referenced by stub_manager_delete_ifstub(), and stub_manager_disconnect().

rpcss_get_next_seqid()

HRESULT rpcss_get_next_seqid

(

DWORD *

id

)

Definition at line 308 of file rpc.c.

{
    RPCSS_CALL_START
    hr = irpcss_get_thread_seq_id(get_irpcss_handle(), id);
    RPCSS_CALL_END
}

Referenced by CoGetCurrentProcess().

start_apartment_remote_unknown()

HRESULT start_apartment_remote_unknown

(

struct apartment *

apt

)

Definition at line 838 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_start_remoting().

stub_manager_disconnect()

void stub_manager_disconnect

(

struct stub_manager *

m

)

Definition at line 242 of file stubmanager.c.

{
    struct ifstub *ifstub;
 
    EnterCriticalSection(&m->lock);
    if (!m->disconnected)
    {
        LIST_FOR_EACH_ENTRY(ifstub, &m->ifstubs, struct ifstub, entry)
            rpc_unregister_interface(&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 406 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 %lu refs to %p (oid %s), rc is now %lu\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 437 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 %lu refs from %p (oid %s), rc is now %lu\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 156 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_release()

ULONG stub_manager_int_release

(

struct stub_manager *

stub_manager

)

Definition at line 309 of file stubmanager.c.

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

Referenced by apartment_release(), CoDisconnectObject(), CoLockObjectExternal(), dispatch_rpc(), ipid_get_dest_context(), 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_is_table_marshaled()

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

Definition at line 630 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 71 of file stubmanager.c.

{
    struct ifstub *stub;
    HRESULT hr;
 
    TRACE("oid=%s, stubbuffer=%p, iid=%s, dest_context=%lx\n", wine_dbgstr_longlong(m->oid), sb,
          debugstr_guid(iid), dest_context);
 
    stub = calloc(1, sizeof(struct ifstub));
    if (!stub) return NULL;
 
    hr = IUnknown_QueryInterface(m->object, iid, (void **)&stub->iface);
    if (hr != S_OK)
    {
        free(stub);
        return NULL;
    }
 
    hr = rpc_create_serverchannel(dest_context, dest_context_data, &stub->chan);
    if (hr != S_OK)
    {
        IUnknown_Release(stub->iface);
        free(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 583 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 614 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().

Variable Documentation

hProxyDll

HINSTANCE hProxyDll

extern

Definition at line 40 of file combase.c.