apartment.c File Reference

#include <stdarg.h>
#include <assert.h>
#include "windef.h"
#include "winbase.h"
#include "servprov.h"
#include "combase_private.h"
#include "wine/debug.h"
#include "wine/list.h"

Include dependency graph for apartment.c:

Go to the source code of this file.

Classes
struct	opendll
struct	apartment_loaded_dll
struct	local_server
struct	host_object_params
struct	host_thread_params
struct	mta_cookie

Macros
#define	COBJMACROS

Typedefs
typedef HRESULT(WINAPI *	DllGetClassObjectFunc) (REFCLSID clsid, REFIID iid, void **obj)
typedef HRESULT(WINAPI *	DllCanUnloadNowFunc) (void)

Enumerations
enum	comclass_threadingmodel {   ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 , ThreadingModel_Both = 4 ,   ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 , ThreadingModel_No = 3 ,   ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 , ThreadingModel_Apartment = 1 , ThreadingModel_Free = 2 ,   ThreadingModel_No = 3 , ThreadingModel_Both = 4 , ThreadingModel_Neutral = 5 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static struct opendll *	apartment_get_dll (const WCHAR *library_name)
static HRESULT	apartment_add_dll (const WCHAR *library_name, struct opendll **ret)
static void	apartment_release_dll (struct opendll *entry, BOOL free_entry)
static void	apartment_release_dlls (void)
static struct local_server *	impl_from_IServiceProvider (IServiceProvider *iface)
static HRESULT WINAPI	local_server_QueryInterface (IServiceProvider *iface, REFIID riid, void **obj)
static ULONG WINAPI	local_server_AddRef (IServiceProvider *iface)
static ULONG WINAPI	local_server_Release (IServiceProvider *iface)
static HRESULT WINAPI	local_server_QueryService (IServiceProvider *iface, REFGUID guid, REFIID riid, void **obj)
HRESULT	apartment_get_local_server_stream (struct apartment *apt, IStream **ret)
static struct apartment *	apartment_construct (DWORD model)
void	apartment_freeunusedlibraries (struct apartment *apt, DWORD delay)
void	apartment_release (struct apartment *apt)
static DWORD	apartment_addref (struct apartment *apt)
static struct apartment *	apartment_get_or_create (DWORD model)
struct apartment *	apartment_get_mta (void)
struct apartment *	apartment_get_current_or_mta (void)
struct apartment *	apartment_findfromoxid (OXID oxid)
struct apartment *	apartment_findfromtid (DWORD tid)
static struct apartment *	apartment_findmain (void)
static BOOL	get_object_dll_path (const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen)
static HRESULT	apartment_getclassobject (struct apartment *apt, LPCWSTR dllpath, BOOL apartment_threaded, REFCLSID rclsid, REFIID riid, void **ppv)
static HRESULT	apartment_hostobject (struct apartment *apt, const struct host_object_params *params)
static DWORD CALLBACK	apartment_hostobject_thread (void *p)
static HRESULT	apartment_hostobject_in_hostapt (struct apartment *apt, BOOL multi_threaded, BOOL main_apartment, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, void **ppv)
static enum comclass_threadingmodel	get_threading_model (const struct class_reg_data *data)
HRESULT	apartment_get_inproc_class_object (struct apartment *apt, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, DWORD class_context, void **ppv)
static LRESULT CALLBACK	apartment_wndproc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
static BOOL	apartment_is_model (const struct apartment *apt, DWORD model)
HRESULT	enter_apartment (struct tlsdata *data, DWORD model)
void	leave_apartment (struct tlsdata *data)
HRESULT	apartment_increment_mta_usage (CO_MTA_USAGE_COOKIE *cookie)
void	apartment_decrement_mta_usage (CO_MTA_USAGE_COOKIE cookie)
static BOOL WINAPI	register_class (INIT_ONCE *once, void *param, void **context)
HRESULT	apartment_createwindowifneeded (struct apartment *apt)
HWND	apartment_getwindow (const struct apartment *apt)
OXID	apartment_getoxid (const struct apartment *apt)
void	apartment_global_cleanup (void)
HRESULT	ensure_mta (void)

Variables
static struct apartment *	mta
static struct apartment *	main_sta
static struct list	apts = LIST_INIT(apts)
static CRITICAL_SECTION	apt_cs = { &apt_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	apt_cs_debug
static struct list	dlls = LIST_INIT(dlls)
static CRITICAL_SECTION	dlls_cs = { &dlls_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	dlls_cs_debug
static const IServiceProviderVtbl	local_server_vtbl
static const WCHAR	aptwinclassW [] = L"OleMainThreadWndClass"
static ATOM	apt_win_class

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 29 of file apartment.c.

Typedef Documentation

DllCanUnloadNowFunc

typedef HRESULT(WINAPI * DllCanUnloadNowFunc) (void)

Definition at line 75 of file apartment.c.

DllGetClassObjectFunc

typedef HRESULT(WINAPI * DllGetClassObjectFunc) (REFCLSID clsid, REFIID iid, void **obj)

Definition at line 74 of file apartment.c.

Enumeration Type Documentation

comclass_threadingmodel

enum comclass_threadingmodel

Enumerator
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral
ThreadingModel_Apartment
ThreadingModel_Free
ThreadingModel_No
ThreadingModel_Both
ThreadingModel_Neutral

Definition at line 41 of file apartment.c.

{
    ThreadingModel_Apartment = 1,
    ThreadingModel_Free      = 2,
    ThreadingModel_No        = 3,
    ThreadingModel_Both      = 4,
    ThreadingModel_Neutral   = 5
};

Function Documentation

apartment_add_dll()

static HRESULT apartment_add_dll ( const WCHAR *  library_name, struct opendll **  ret  )

static

Definition at line 115 of file apartment.c.

{
    struct opendll *entry;
    int len;
    HRESULT hr = S_OK;
    HANDLE hLibrary;
    DllCanUnloadNowFunc DllCanUnloadNow;
    DllGetClassObjectFunc DllGetClassObject;
 
    TRACE("%s\n", debugstr_w(library_name));
 
    *ret = apartment_get_dll(library_name);
    if (*ret) return S_OK;
 
    /* Load outside of dlls lock to avoid dependency on the loader lock */
    hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
    if (!hLibrary)
    {
        ERR("couldn't load in-process dll %s\n", debugstr_w(library_name));
        /* failure: DLL could not be loaded */
        return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
    }
 
    /* DllCanUnloadNow is optional */
    DllCanUnloadNow = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
    DllGetClassObject = (void *)GetProcAddress(hLibrary, "DllGetClassObject");
    if (!DllGetClassObject)
    {
        /* failure: the dll did not export DllGetClassObject */
        ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name));
        FreeLibrary(hLibrary);
        return CO_E_DLLNOTFOUND;
    }
 
    EnterCriticalSection(&dlls_cs);
 
    *ret = apartment_get_dll(library_name);
    if (*ret)
    {
        /* another caller to this function already added the dll while we
         * weren't in the critical section */
        FreeLibrary(hLibrary);
    }
    else
    {
        len = lstrlenW(library_name);
        entry = malloc(sizeof(*entry));
        if (entry)
            entry->library_name = malloc((len + 1) * sizeof(WCHAR));
        if (entry && entry->library_name)
        {
            memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
            entry->library = hLibrary;
            entry->refs = 1;
            entry->DllCanUnloadNow = DllCanUnloadNow;
            entry->DllGetClassObject = DllGetClassObject;
            list_add_tail(&dlls, &entry->entry);
            *ret = entry;
        }
        else
        {
            free(entry);
            hr = E_OUTOFMEMORY;
            FreeLibrary(hLibrary);
        }
    }
 
    LeaveCriticalSection(&dlls_cs);
 
    return hr;
}

Referenced by apartment_getclassobject().

apartment_addref()

static DWORD apartment_addref ( struct apartment *  apt )

static

Definition at line 542 of file apartment.c.

{
    DWORD refs = InterlockedIncrement(&apt->refs);
    TRACE("%s: before = %ld\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
    return refs;
}

Referenced by apartment_findfromoxid(), apartment_findfromtid(), apartment_findmain(), apartment_get_current_or_mta(), apartment_get_mta(), apartment_get_or_create(), and apartment_increment_mta_usage().

apartment_construct()

static struct apartment * apartment_construct ( DWORD  model )

static

Definition at line 362 of file apartment.c.

{
    struct apartment *apt;
 
    TRACE("creating new apartment, model %ld\n", model);
 
    apt = calloc(1, sizeof(*apt));
    apt->tid = GetCurrentThreadId();
 
    list_init(&apt->proxies);
    list_init(&apt->stubmgrs);
    list_init(&apt->loaded_dlls);
    list_init(&apt->usage_cookies);
    apt->ipidc = 0;
    apt->refs = 1;
    apt->remunk_exported = FALSE;
    apt->oidc = 1;
    InitializeCriticalSectionEx(&apt->cs, 0, RTL_CRITICAL_SECTION_FLAG_FORCE_DEBUG_INFO);
    apt->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": apartment");
 
    apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
 
    if (apt->multi_threaded)
    {
        /* FIXME: should be randomly generated by in an RPC call to rpcss */
        apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
    }
    else
    {
        /* FIXME: should be randomly generated by in an RPC call to rpcss */
        apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
    }
 
    TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 
    list_add_head(&apts, &apt->entry);
 
    return apt;
}

Referenced by apartment_get_or_create(), and apartment_increment_mta_usage().

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

static struct apartment * apartment_findmain ( void  )

static

Definition at line 686 of file apartment.c.

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

Referenced by apartment_hostobject_in_hostapt().

apartment_freeunusedlibraries()

void apartment_freeunusedlibraries	(	struct apartment *	apt,
		DWORD	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_dll()

static struct opendll * apartment_get_dll ( const WCHAR *  library_name )

static

Definition at line 95 of file apartment.c.

{
    struct opendll *ptr, *ret = NULL;
 
    EnterCriticalSection(&dlls_cs);
    LIST_FOR_EACH_ENTRY(ptr, &dlls, struct opendll, entry)
    {
        if (!wcsicmp(library_name, ptr->library_name) &&
            (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroyed if == 1 */)
        {
            ret = ptr;
            break;
        }
    }
    LeaveCriticalSection(&dlls_cs);
 
    return ret;
}

Referenced by apartment_add_dll().

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

static struct apartment * apartment_get_or_create ( DWORD  model )

static

Definition at line 550 of file apartment.c.

{
    struct apartment *apt = com_get_current_apt();
    struct tlsdata *data;
 
    if (!apt)
    {
        com_get_tlsdata(&data);
 
        if (model & COINIT_APARTMENTTHREADED)
        {
            EnterCriticalSection(&apt_cs);
 
            apt = apartment_construct(model);
            if (!main_sta)
            {
                main_sta = apt;
                apt->main = TRUE;
                TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
            }
 
            data->flags |= OLETLS_APARTMENTTHREADED;
            if (model & COINIT_DISABLE_OLE1DDE)
                data->flags |= OLETLS_DISABLE_OLE1DDE;
 
            LeaveCriticalSection(&apt_cs);
 
            if (apt->main)
                apartment_createwindowifneeded(apt);
        }
        else
        {
            EnterCriticalSection(&apt_cs);
 
            /* The multi-threaded apartment (MTA) contains zero or more threads interacting
             * with free threaded (ie thread safe) COM objects. There is only ever one MTA
             * in a process */
            if (mta)
            {
                TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(mta->oxid));
                apartment_addref(mta);
            }
            else
                mta = apartment_construct(model);
 
            data->flags |= OLETLS_MULTITHREADED | OLETLS_DISABLE_OLE1DDE;
 
            apt = mta;
 
            LeaveCriticalSection(&apt_cs);
        }
        data->apt = apt;
    }
 
    return apt;
}

Referenced by enter_apartment().

apartment_getclassobject()

static HRESULT apartment_getclassobject ( struct apartment *  apt, LPCWSTR  dllpath, BOOL  apartment_threaded, REFCLSID  rclsid, REFIID  riid, void **  ppv  )

static

Definition at line 760 of file apartment.c.

{
    HRESULT hr = S_OK;
    BOOL found = FALSE;
    struct apartment_loaded_dll *apartment_loaded_dll;
 
    if (!wcsicmp(dllpath, L"ole32.dll"))
    {
        HRESULT (WINAPI *p_ole32_DllGetClassObject)(REFCLSID clsid, REFIID riid, void **obj);
 
        p_ole32_DllGetClassObject = (void *)GetProcAddress(GetModuleHandleW(L"ole32.dll"), "DllGetClassObject");
 
        /* we don't need to control the lifetime of this dll, so use the local
         * implementation of DllGetClassObject directly */
        TRACE("calling ole32!DllGetClassObject\n");
        hr = p_ole32_DllGetClassObject(rclsid, riid, ppv);
 
        if (hr != S_OK)
            ERR("DllGetClassObject returned error %#lx for dll %s\n", hr, debugstr_w(dllpath));
 
        return hr;
    }
 
    EnterCriticalSection(&apt->cs);
 
    LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
        if (!wcsicmp(dllpath, apartment_loaded_dll->dll->library_name))
        {
            TRACE("found %s already loaded\n", debugstr_w(dllpath));
            found = TRUE;
            break;
        }
 
    if (!found)
    {
        apartment_loaded_dll = malloc(sizeof(*apartment_loaded_dll));
        if (!apartment_loaded_dll)
            hr = E_OUTOFMEMORY;
        if (SUCCEEDED(hr))
        {
            apartment_loaded_dll->unload_time = 0;
            apartment_loaded_dll->multi_threaded = FALSE;
            hr = apartment_add_dll(dllpath, &apartment_loaded_dll->dll);
            if (FAILED(hr))
                free(apartment_loaded_dll);
        }
        if (SUCCEEDED(hr))
        {
            TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
            list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
        }
    }
 
    LeaveCriticalSection(&apt->cs);
 
    if (SUCCEEDED(hr))
    {
        /* one component being multi-threaded overrides any number of
         * apartment-threaded components */
        if (!apartment_threaded)
            apartment_loaded_dll->multi_threaded = TRUE;
 
        TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
        /* OK: get the ClassObject */
        hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
 
        if (hr != S_OK)
            ERR("DllGetClassObject returned error %#lx for dll %s\n", hr, debugstr_w(dllpath));
    }
 
    return hr;
}

Referenced by apartment_get_inproc_class_object(), and apartment_hostobject().

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

static HRESULT apartment_hostobject ( struct apartment *  apt, const struct host_object_params *  params  )

static

Definition at line 1080 of file apartment.c.

{
    static const LARGE_INTEGER llZero;
    WCHAR dllpath[MAX_PATH+1];
    IUnknown *object;
    HRESULT hr;
 
    TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
 
    if (!get_object_dll_path(&params->regdata, dllpath, ARRAY_SIZE(dllpath)))
    {
        /* failure: CLSID is not found in registry */
        WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
        return REGDB_E_CLASSNOTREG;
    }
 
    hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded, &params->clsid, &params->iid, (void **)&object);
    if (FAILED(hr))
        return hr;
 
    hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    if (FAILED(hr))
        IUnknown_Release(object);
    IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
 
    return hr;
}

Referenced by apartment_hostobject_thread(), and apartment_wndproc().

apartment_hostobject_in_hostapt()

static HRESULT apartment_hostobject_in_hostapt ( struct apartment *  apt, BOOL  multi_threaded, BOOL  main_apartment, const struct class_reg_data *  regdata, REFCLSID  rclsid, REFIID  riid, void **  ppv  )

static

Definition at line 899 of file apartment.c.

{
    struct host_object_params params;
    HWND apartment_hwnd = NULL;
    DWORD apartment_tid = 0;
    HRESULT hr;
 
    if (!multi_threaded && main_apartment)
    {
        struct apartment *host_apt = apartment_findmain();
        if (host_apt)
        {
            apartment_hwnd = apartment_getwindow(host_apt);
            apartment_release(host_apt);
        }
    }
 
    if (!apartment_hwnd)
    {
        EnterCriticalSection(&apt->cs);
 
        if (!apt->host_apt_tid)
        {
            struct host_thread_params thread_params;
            HANDLE handles[2];
            DWORD wait_value;
 
            thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
            handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
            thread_params.apartment_hwnd = NULL;
            handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
            if (!handles[1])
            {
                CloseHandle(handles[0]);
                LeaveCriticalSection(&apt->cs);
                return E_OUTOFMEMORY;
            }
            wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
            CloseHandle(handles[0]);
            CloseHandle(handles[1]);
            if (wait_value == WAIT_OBJECT_0)
                apt->host_apt_hwnd = thread_params.apartment_hwnd;
            else
            {
                LeaveCriticalSection(&apt->cs);
                return E_OUTOFMEMORY;
            }
        }
 
        if (multi_threaded || !main_apartment)
        {
            apartment_hwnd = apt->host_apt_hwnd;
            apartment_tid = apt->host_apt_tid;
        }
 
        LeaveCriticalSection(&apt->cs);
    }
 
    /* another thread may have become the main apartment in the time it took
     * us to create the thread for the host apartment */
    if (!apartment_hwnd && !multi_threaded && main_apartment)
    {
        struct apartment *host_apt = apartment_findmain();
        if (host_apt)
        {
            apartment_hwnd = apartment_getwindow(host_apt);
            apartment_release(host_apt);
        }
    }
 
    params.regdata = *regdata;
    params.clsid = *rclsid;
    params.iid = *riid;
    hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
    if (FAILED(hr))
        return hr;
    params.apartment_threaded = !multi_threaded;
    if (multi_threaded)
    {
        params.hr = S_OK;
        params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
        if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
            hr = E_OUTOFMEMORY;
        else
        {
            WaitForSingleObject(params.event, INFINITE);
            hr = params.hr;
        }
        CloseHandle(params.event);
    }
    else
    {
        if (!apartment_hwnd)
        {
            ERR("host apartment didn't create window\n");
            hr = E_OUTOFMEMORY;
        }
        else
            hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
    }
    if (SUCCEEDED(hr))
        hr = CoUnmarshalInterface(params.stream, riid, ppv);
    IStream_Release(params.stream);
    return hr;
}

Referenced by apartment_get_inproc_class_object().

apartment_hostobject_thread()

static DWORD CALLBACK apartment_hostobject_thread ( void *  p )

static

Definition at line 847 of file apartment.c.

{
    struct host_thread_params *params = p;
    MSG msg;
    HRESULT hr;
    struct apartment *apt;
 
    TRACE("\n");
 
    hr = CoInitializeEx(NULL, params->threading_model);
    if (FAILED(hr)) return hr;
 
    apt = com_get_current_apt();
    if (params->threading_model == COINIT_APARTMENTTHREADED)
    {
        apartment_createwindowifneeded(apt);
        params->apartment_hwnd = apartment_getwindow(apt);
    }
    else
        params->apartment_hwnd = NULL;
 
    /* force the message queue to be created before signaling parent thread */
    PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 
    SetEvent(params->ready_event);
    params = NULL; /* can't touch params after here as it may be invalid */
 
    while (GetMessageW(&msg, NULL, 0, 0))
    {
        if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
        {
            struct host_object_params *obj_params = (struct host_object_params *)msg.lParam;
            obj_params->hr = apartment_hostobject(apt, obj_params);
            SetEvent(obj_params->event);
        }
        else
        {
            TranslateMessage(&msg);
            DispatchMessageW(&msg);
        }
    }
 
    TRACE("exiting\n");
 
    CoUninitialize();
 
    return S_OK;
}

Referenced by apartment_hostobject_in_hostapt().

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

static BOOL apartment_is_model ( const struct apartment *  apt, DWORD  model  )

static

Definition at line 1124 of file apartment.c.

{
    return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
}

Referenced by enter_apartment().

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

static void apartment_release_dll ( struct opendll *  entry, BOOL  free_entry  )

static

Definition at line 189 of file apartment.c.

{
    if (!InterlockedDecrement(&entry->refs) && free_entry)
    {
        EnterCriticalSection(&dlls_cs);
        list_remove(&entry->entry);
        LeaveCriticalSection(&dlls_cs);
 
        TRACE("freeing %p\n", entry->library);
        FreeLibrary(entry->library);
 
        free(entry->library_name);
        free(entry);
    }
}

Referenced by apartment_freeunusedlibraries(), and apartment_release().

apartment_release_dlls()

static void apartment_release_dlls ( void  )

static

Definition at line 206 of file apartment.c.

{
    struct opendll *entry, *cursor2;
    EnterCriticalSection(&dlls_cs);
    LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &dlls, struct opendll, entry)
    {
        list_remove(&entry->entry);
        free(entry->library_name);
        free(entry);
    }
    LeaveCriticalSection(&dlls_cs);
    DeleteCriticalSection(&dlls_cs);
}

Referenced by apartment_global_cleanup().

apartment_wndproc()

static LRESULT CALLBACK apartment_wndproc ( HWND  hWnd, UINT  msg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1110 of file apartment.c.

{
    switch (msg)
    {
    case DM_EXECUTERPC:
        rpc_execute_call((struct dispatch_params *)lParam);
        return 0;
    case DM_HOSTOBJECT:
        return apartment_hostobject(com_get_current_apt(), (const struct host_object_params *)lParam);
    default:
        return DefWindowProcW(hWnd, msg, wParam, lParam);
    }
}

Referenced by register_class().

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

static BOOL get_object_dll_path ( const struct class_reg_data *  regdata, WCHAR *  dst, DWORD  dstlen  )

static

Definition at line 712 of file apartment.c.

{
    DWORD ret;
 
    if (regdata->origin == CLASS_REG_REGISTRY)
    {
        DWORD keytype;
        WCHAR src[MAX_PATH];
        DWORD dwLength = dstlen * sizeof(WCHAR);
 
        if ((ret = RegQueryValueExW(regdata->u.hkey, NULL, NULL, &keytype, (BYTE*)src, &dwLength)) == ERROR_SUCCESS)
        {
            if (keytype == REG_EXPAND_SZ)
            {
                if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
            }
            else
            {
                const WCHAR *quote_start;
                quote_start = wcschr(src, '\"');
                if (quote_start)
                {
                    const WCHAR *quote_end = wcschr(quote_start + 1, '\"');
                    if (quote_end)
                    {
                        memmove(src, quote_start + 1, (quote_end - quote_start - 1) * sizeof(WCHAR));
                        src[quote_end - quote_start - 1] = '\0';
                    }
                }
                lstrcpynW(dst, src, dstlen);
            }
        }
        return !ret;
    }
    else
    {
        ULONG_PTR cookie;
 
        *dst = 0;
        ActivateActCtx(regdata->u.actctx.hactctx, &cookie);
        ret = SearchPathW(NULL, regdata->u.actctx.module_name, L".dll", dstlen, dst, NULL);
        DeactivateActCtx(0, cookie);
        return *dst != 0;
    }
}

Referenced by apartment_get_inproc_class_object(), and apartment_hostobject().

get_threading_model()

static enum comclass_threadingmodel get_threading_model ( const struct class_reg_data *  data )

static

Definition at line 1006 of file apartment.c.

{
    if (data->origin == CLASS_REG_REGISTRY)
    {
        WCHAR threading_model[10 /* lstrlenW(L"apartment")+1 */];
        DWORD dwLength = sizeof(threading_model);
        DWORD keytype;
        DWORD ret;
 
        ret = RegQueryValueExW(data->u.hkey, L"ThreadingModel", NULL, &keytype, (BYTE*)threading_model, &dwLength);
        if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
            threading_model[0] = '\0';
 
        if (!wcsicmp(threading_model, L"Apartment")) return ThreadingModel_Apartment;
        if (!wcsicmp(threading_model, L"Free")) return ThreadingModel_Free;
        if (!wcsicmp(threading_model, L"Both")) return ThreadingModel_Both;
 
        /* there's not specific handling for this case */
        if (threading_model[0]) return ThreadingModel_Neutral;
        return ThreadingModel_No;
    }
    else
        return data->u.actctx.threading_model;
}

Referenced by apartment_get_inproc_class_object().

impl_from_IServiceProvider()

static struct local_server * impl_from_IServiceProvider ( IServiceProvider *  iface )

inlinestatic

Definition at line 234 of file apartment.c.

{
    return CONTAINING_RECORD(iface, struct local_server, IServiceProvider_iface);
}

Referenced by local_server_AddRef(), local_server_QueryInterface(), local_server_QueryService(), and local_server_Release().

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

local_server_AddRef()

static ULONG WINAPI local_server_AddRef ( IServiceProvider *  iface )

static

Definition at line 260 of file apartment.c.

{
    struct local_server *local_server = impl_from_IServiceProvider(iface);
    LONG refcount = InterlockedIncrement(&local_server->refcount);
 
    TRACE("%p, refcount %ld\n", iface, refcount);
 
    return refcount;
}

local_server_QueryInterface()

static HRESULT WINAPI local_server_QueryInterface ( IServiceProvider *  iface, REFIID  riid, void **  obj  )

static

Definition at line 239 of file apartment.c.

{
    struct local_server *local_server = impl_from_IServiceProvider(iface);
 
    TRACE("%p, %s, %p\n", iface, debugstr_guid(riid), obj);
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
            IsEqualGUID(riid, &IID_IServiceProvider))
    {
        *obj = &local_server->IServiceProvider_iface;
    }
    else
    {
        *obj = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown *)*obj);
    return S_OK;
}

local_server_QueryService()

static HRESULT WINAPI local_server_QueryService ( IServiceProvider *  iface, REFGUID  guid, REFIID  riid, void **  obj  )

static

Definition at line 286 of file apartment.c.

{
    struct local_server *local_server = impl_from_IServiceProvider(iface);
    struct apartment *apt = com_get_current_apt();
    HRESULT hr = E_FAIL;
    IUnknown *unk;
 
    TRACE("%p, %s, %s, %p\n", iface, debugstr_guid(guid), debugstr_guid(riid), obj);
 
    if (!local_server->apt)
        return E_UNEXPECTED;
 
    if ((unk = com_get_registered_class_object(apt, guid, CLSCTX_LOCAL_SERVER)))
    {
        hr = IUnknown_QueryInterface(unk, riid, obj);
        IUnknown_Release(unk);
    }
 
    return hr;
}

local_server_Release()

static ULONG WINAPI local_server_Release ( IServiceProvider *  iface )

static

Definition at line 270 of file apartment.c.

{
    struct local_server *local_server = impl_from_IServiceProvider(iface);
    LONG refcount = InterlockedDecrement(&local_server->refcount);
 
    TRACE("%p, refcount %ld\n", iface, refcount);
 
    if (!refcount)
    {
        assert(!local_server->apt);
        free(local_server);
    }
 
    return refcount;
}

register_class()

static BOOL WINAPI register_class ( INIT_ONCE *  once, void *  param, void **  context  )

static

Definition at line 1227 of file apartment.c.

{
    WNDCLASSW wclass;
 
    /* Dispatching to the correct thread in an apartment is done through
     * window messages rather than RPC transports. When an interface is
     * marshalled into another apartment in the same process, a window of the
     * following class is created. The *caller* of CoMarshalInterface (i.e., the
     * application) is responsible for pumping the message loop in that thread.
     * The WM_USER messages which point to the RPCs are then dispatched to
     * apartment_wndproc by the user's code from the apartment in which the
     * interface was unmarshalled.
     */
    memset(&wclass, 0, sizeof(wclass));
    wclass.lpfnWndProc = apartment_wndproc;
    wclass.hInstance = hProxyDll;
    wclass.lpszClassName = aptwinclassW;
    apt_win_class = RegisterClassW(&wclass);
    return TRUE;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

apt_cs

static CRITICAL_SECTION apt_cs = { &apt_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 54 of file apartment.c.

Referenced by apartment_decrement_mta_usage(), apartment_findfromoxid(), apartment_findfromtid(), apartment_findmain(), apartment_get_mta(), apartment_get_or_create(), apartment_global_cleanup(), apartment_increment_mta_usage(), apartment_release(), and ensure_mta().

apt_cs_debug

CRITICAL_SECTION_DEBUG apt_cs_debug

static

Initial value:

=
{
    0, 0, &apt_cs,
    { &apt_cs_debug.ProcessLocksList, &apt_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": apt_cs") }
}

Definition at line 55 of file apartment.c.

apt_win_class

ATOM apt_win_class

static

Definition at line 1225 of file apartment.c.

Referenced by apartment_global_cleanup(), and register_class().

apts

struct list apts = LIST_INIT(apts)

static

Definition at line 52 of file apartment.c.

Referenced by apartment_construct(), apartment_findfromoxid(), apartment_findfromtid(), EMFDC_PolyDraw(), emfdc_polylinegon(), EMFDRV_PolyDraw(), EMFDRV_Polylinegon(), test_pack_EMRPOLYBEZIER16(), test_pack_EMRPOLYBEZIERTO16(), test_pack_EMRPOLYDRAW16(), test_pack_EMRPOLYGON16(), test_pack_EMRPOLYLINE16(), test_pack_EMRPOLYLINETO16(), test_pack_EMRPOLYPOLYGON16(), and test_pack_EMRPOLYPOLYLINE16().

aptwinclassW

const WCHAR aptwinclassW[] = L"OleMainThreadWndClass"

static

Definition at line 1224 of file apartment.c.

Referenced by apartment_createwindowifneeded(), and register_class().

dlls

struct list dlls = LIST_INIT(dlls)

static

Definition at line 63 of file apartment.c.

Referenced by apartment_add_dll(), apartment_get_dll(), apartment_release_dlls(), build_directxfiles_tree(), ciffile_GetDetDlls(), CRYPT_GetDefaultOIDDlls(), CRYPT_SetDefaultOIDDlls(), CryptRegisterDefaultOIDFunction(), CryptUnregisterDefaultOIDFunction(), and test_wow64_redirection().

dlls_cs

static CRITICAL_SECTION dlls_cs = { &dlls_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 65 of file apartment.c.

Referenced by apartment_add_dll(), apartment_get_dll(), apartment_release_dll(), and apartment_release_dlls().

dlls_cs_debug

CRITICAL_SECTION_DEBUG dlls_cs_debug

static

Initial value:

=
{
    0, 0, &dlls_cs,
    { &dlls_cs_debug.ProcessLocksList, &dlls_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": dlls_cs") }
}

Definition at line 66 of file apartment.c.

local_server_vtbl

const IServiceProviderVtbl local_server_vtbl

static

Initial value:

=
{
    local_server_QueryInterface,
    local_server_AddRef,
    local_server_Release,
    local_server_QueryService
}

Definition at line 307 of file apartment.c.

Referenced by apartment_get_local_server_stream().

main_sta

struct apartment* main_sta

static

Definition at line 51 of file apartment.c.

Referenced by apartment_findmain(), apartment_get_or_create(), and apartment_release().

mta

struct apartment* mta

static

Definition at line 50 of file apartment.c.

Referenced by apartment_decrement_mta_usage(), apartment_findfromtid(), apartment_get_mta(), apartment_get_or_create(), apartment_increment_mta_usage(), apartment_release(), ensure_mta(), and test_implicit_mta().