compobj.c File Reference

#include <stdarg.h>
#include <stdio.h>
#include <string.h>
#include <assert.h>
#include "ntstatus.h"
#include "windef.h"
#include "winbase.h"
#include "winerror.h"
#include "winreg.h"
#include "winuser.h"
#include "objbase.h"
#include "ole2.h"
#include "ole2ver.h"
#include "ctxtcall.h"
#include "dde.h"
#include "servprov.h"
#include "initguid.h"
#include "compobj_private.h"
#include "moniker.h"
#include "wine/debug.h"

Include dependency graph for compobj.c:

Go to the source code of this file.

Classes
struct	comclassredirect_data
struct	ifacepsredirect_data
struct	progidredirect_data
struct	class_reg_data
struct	registered_psclsid
struct	LocalServer
struct	tagRegisteredClass
struct	tagOpenDll
struct	apartment_loaded_dll
struct	ManualResetEvent
struct	host_object_params
struct	host_thread_params
struct	Context
struct	GlobalOptions

Macros
#define	COBJMACROS
#define	NONAMELESSUNION
#define	WIN32_NO_STATUS
#define	USE_COM_CONTEXT_DEF

Typedefs
typedef struct tagRegisteredClass	RegisteredClass
typedef HRESULT(CALLBACK *	DllGetClassObjectFunc) (REFCLSID clsid, REFIID iid, LPVOID *ppv)
typedef HRESULT(WINAPI *	DllCanUnloadNowFunc) (void)
typedef struct tagOpenDll	OpenDll
typedef struct ManualResetEvent	MREImpl
typedef struct Context	Context

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 }
enum	comclass_miscfields {   MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 , MiscStatusThumbnail = 8 ,   MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 , MiscStatusContent = 4 ,   MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 , MiscStatus = 1 , MiscStatusIcon = 2 ,   MiscStatusContent = 4 , MiscStatusThumbnail = 8 , MiscStatusDocPrint = 16 }

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (ole)
static enum comclass_miscfields	dvaspect_to_miscfields (DWORD aspect)
BOOL	actctx_get_miscstatus (const CLSID *clsid, DWORD aspect, DWORD *status)
static NTSTATUS	create_key (HKEY *retkey, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr)
static HKEY	create_classes_root_hkey (DWORD access)
static HKEY	get_classes_root_hkey (HKEY hkey, REGSAM access)
LSTATUS	create_classes_key (HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey)
LSTATUS	open_classes_key (HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey)
static OpenDll *	COMPOBJ_DllList_Get (LPCWSTR library_name)
static HRESULT	COMPOBJ_DllList_Add (LPCWSTR library_name, OpenDll **ret)
static void	COMPOBJ_DllList_ReleaseRef (OpenDll *entry, BOOL free_entry)
static void	COMPOBJ_DllList_Free (void)
static DWORD	apartment_addref (struct apartment *apt)
static APARTMENT *	apartment_construct (DWORD model)
static APARTMENT *	apartment_get_or_create (DWORD model)
static BOOL	apartment_is_model (const APARTMENT *apt, DWORD model)
static APARTMENT *	apartment_find_mta (void)
APARTMENT *	apartment_get_current_or_mta (void)
static void	COM_RevokeRegisteredClassObject (RegisteredClass *curClass)
static void	COM_RevokeAllClasses (const struct apartment *apt)
static void	revoke_registered_psclsids (void)
static MREImpl *	impl_from_ISynchronize (ISynchronize *iface)
static HRESULT WINAPI	ISynchronize_fnQueryInterface (ISynchronize *iface, REFIID riid, void **ppv)
static ULONG WINAPI	ISynchronize_fnAddRef (ISynchronize *iface)
static ULONG WINAPI	ISynchronize_fnRelease (ISynchronize *iface)
static HRESULT WINAPI	ISynchronize_fnWait (ISynchronize *iface, DWORD dwFlags, DWORD dwMilliseconds)
static HRESULT WINAPI	ISynchronize_fnSignal (ISynchronize *iface)
static HRESULT WINAPI	ISynchronize_fnReset (ISynchronize *iface)
static MREImpl *	impl_from_ISynchronizeHandle (ISynchronizeHandle *iface)
static HRESULT WINAPI	SynchronizeHandle_QueryInterface (ISynchronizeHandle *iface, REFIID riid, void **ppv)
static ULONG WINAPI	SynchronizeHandle_AddRef (ISynchronizeHandle *iface)
static ULONG WINAPI	SynchronizeHandle_Release (ISynchronizeHandle *iface)
static HRESULT WINAPI	SynchronizeHandle_GetHandle (ISynchronizeHandle *iface, HANDLE *ph)
static HRESULT	ManualResetEvent_Construct (IUnknown *punkouter, REFIID iid, void **ppv)
static LocalServer *	impl_from_IServiceProvider (IServiceProvider *iface)
static HRESULT WINAPI	LocalServer_QueryInterface (IServiceProvider *iface, REFIID riid, void **ppv)
static ULONG WINAPI	LocalServer_AddRef (IServiceProvider *iface)
static ULONG WINAPI	LocalServer_Release (IServiceProvider *iface)
static HRESULT WINAPI	LocalServer_QueryService (IServiceProvider *iface, REFGUID guid, REFIID riid, void **ppv)
static HRESULT	get_local_server_stream (APARTMENT *apt, IStream **ret)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoRevokeClassObject (DWORD dwRegister)
static void	apartment_freeunusedlibraries (struct apartment *apt, DWORD delay)
DWORD	apartment_release (struct apartment *apt)
APARTMENT *	apartment_findfromoxid (OXID oxid, BOOL ref)
APARTMENT *	apartment_findfromtid (DWORD tid)
static APARTMENT *	apartment_findmain (void)
static HRESULT	apartment_getclassobject (struct apartment *apt, LPCWSTR dllpath, BOOL apartment_threaded, REFCLSID rclsid, REFIID riid, void **ppv)
static BOOL	get_object_dll_path (const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen)
static HRESULT	apartment_hostobject (struct apartment *apt, const struct host_object_params *params)
static LRESULT CALLBACK	apartment_wndproc (HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
static DWORD CALLBACK	apartment_hostobject_thread (LPVOID 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 BOOL WINAPI	register_class (INIT_ONCE *once, void *param, void **context)
HRESULT	apartment_createwindowifneeded (struct apartment *apt)
HWND	apartment_getwindow (const struct apartment *apt)
static void	COM_TlsDestroy (void)
DWORD WINAPI	CoBuildVersion (void)
static struct init_spy *	get_spy_entry (struct oletls *info, unsigned int id)
static void	lock_init_spies (struct oletls *info)
static void	unlock_init_spies (struct oletls *info)
HRESULT WINAPI	CoRegisterInitializeSpy (IInitializeSpy *spy, ULARGE_INTEGER *cookie)
HRESULT WINAPI	CoRevokeInitializeSpy (ULARGE_INTEGER cookie)
HRESULT	enter_apartment (struct oletls *info, DWORD model)
void	leave_apartment (struct oletls *info)
HRESULT WINAPI	CoInitialize (LPVOID lpReserved)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoInitializeEx (LPVOID lpReserved, DWORD dwCoInit)
void WINAPI DECLSPEC_HOTPATCH	CoUninitialize (void)
HRESULT WINAPI	CoDisconnectObject (LPUNKNOWN lpUnk, DWORD reserved)
HRESULT WINAPI	CoCreateGuid (GUID *pguid)
static BOOL	is_valid_hex (WCHAR c)
static BOOL	guid_from_string (LPCWSTR s, GUID *id)
static HRESULT	clsid_from_string_reg (LPCOLESTR progid, CLSID *clsid)
HRESULT WINAPI	CLSIDFromString (LPCOLESTR idstr, LPCLSID id)
HRESULT WINAPI	IIDFromString (LPCOLESTR s, IID *iid)
HRESULT WINAPI	StringFromCLSID (REFCLSID id, LPOLESTR *idstr)
INT WINAPI	StringFromGUID2 (REFGUID id, LPOLESTR str, INT cmax)
HRESULT	COM_OpenKeyForCLSID (REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
HRESULT	COM_OpenKeyForAppIdFromCLSID (REFCLSID clsid, REGSAM access, HKEY *subkey)
HRESULT WINAPI DECLSPEC_HOTPATCH	ProgIDFromCLSID (REFCLSID clsid, LPOLESTR *ppszProgID)
HRESULT WINAPI DECLSPEC_HOTPATCH	CLSIDFromProgID (LPCOLESTR progid, LPCLSID clsid)
HRESULT WINAPI	CLSIDFromProgIDEx (LPCOLESTR progid, LPCLSID clsid)
static HRESULT	get_ps_clsid_from_registry (const WCHAR *path, REGSAM access, CLSID *pclsid)
HRESULT WINAPI	CoGetPSClsid (REFIID riid, CLSID *pclsid)
HRESULT WINAPI	CoRegisterPSClsid (REFIID riid, REFCLSID rclsid)
static HRESULT	COM_GetRegisteredClassObject (const struct apartment *apt, REFCLSID rclsid, DWORD dwClsContext, LPUNKNOWN *ppUnk)
HRESULT WINAPI	CoRegisterClassObject (REFCLSID rclsid, LPUNKNOWN pUnk, DWORD dwClsContext, DWORD flags, LPDWORD lpdwRegister)
static enum comclass_threadingmodel	get_threading_model (const struct class_reg_data *data)
static HRESULT	get_inproc_class_object (APARTMENT *apt, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, BOOL hostifnecessary, void **ppv)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoGetClassObject (REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo, REFIID iid, LPVOID *ppv)
HRESULT WINAPI	CoResumeClassObjects (void)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoCreateInstance (REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, REFIID iid, LPVOID *ppv)
static void	init_multi_qi (DWORD count, MULTI_QI *mqi, HRESULT hr)
static HRESULT	return_multi_qi (IUnknown *unk, DWORD count, MULTI_QI *mqi, BOOL include_unk)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoCreateInstanceEx (REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, COSERVERINFO *pServerInfo, ULONG cmq, MULTI_QI *pResults)
HRESULT WINAPI DECLSPEC_HOTPATCH	CoGetInstanceFromFile (COSERVERINFO *server_info, CLSID *rclsid, IUnknown *outer, DWORD cls_context, DWORD grfmode, OLECHAR *filename, DWORD count, MULTI_QI *results)
HRESULT WINAPI	CoGetInstanceFromIStorage (COSERVERINFO *server_info, CLSID *rclsid, IUnknown *outer, DWORD cls_context, IStorage *storage, DWORD count, MULTI_QI *results)
HINSTANCE WINAPI	CoLoadLibrary (LPOLESTR lpszLibName, BOOL bAutoFree)
void WINAPI	CoFreeLibrary (HINSTANCE hLibrary)
void WINAPI	CoFreeAllLibraries (void)
void WINAPI DECLSPEC_HOTPATCH	CoFreeUnusedLibrariesEx (DWORD dwUnloadDelay, DWORD dwReserved)
void WINAPI DECLSPEC_HOTPATCH	CoFreeUnusedLibraries (void)
HRESULT WINAPI	CoFileTimeNow (FILETIME *lpFileTime)
HRESULT WINAPI	CoLockObjectExternal (LPUNKNOWN pUnk, BOOL fLock, BOOL fLastUnlockReleases)
HRESULT WINAPI	CoInitializeWOW (DWORD x, DWORD y)
HRESULT WINAPI	CoGetState (IUnknown **ppv)
HRESULT WINAPI	CoSetState (IUnknown *pv)
HRESULT WINAPI	CoTreatAsClass (REFCLSID clsidOld, REFCLSID clsidNew)
HRESULT WINAPI	CoGetTreatAsClass (REFCLSID clsidOld, LPCLSID clsidNew)
DWORD WINAPI	CoGetCurrentProcess (void)
HRESULT WINAPI	CoGetCurrentLogicalThreadId (GUID *id)
HRESULT WINAPI	CoRegisterMessageFilter (LPMESSAGEFILTER lpMessageFilter, LPMESSAGEFILTER *lplpMessageFilter)
BOOL WINAPI	CoIsOle1Class (REFCLSID clsid)
BOOL WINAPI	IsEqualGUID (REFGUID rguid1, REFGUID rguid2)
HRESULT WINAPI	CoInitializeSecurity (PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc, SOLE_AUTHENTICATION_SERVICE *asAuthSvc, void *pReserved1, DWORD dwAuthnLevel, DWORD dwImpLevel, void *pReserved2, DWORD dwCapabilities, void *pReserved3)
HRESULT WINAPI	CoSuspendClassObjects (void)
ULONG WINAPI	CoAddRefServerProcess (void)
ULONG WINAPI	CoReleaseServerProcess (void)
BOOL WINAPI	CoIsHandlerConnected (IUnknown *pUnk)
HRESULT WINAPI	CoAllowSetForegroundWindow (IUnknown *pUnk, void *pvReserved)
HRESULT WINAPI	CoQueryProxyBlanket (IUnknown *pProxy, DWORD *pAuthnSvc, DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel, DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
HRESULT WINAPI	CoSetProxyBlanket (IUnknown *pProxy, DWORD AuthnSvc, DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel, DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
HRESULT WINAPI	CoCopyProxy (IUnknown *pProxy, IUnknown **ppCopy)
HRESULT WINAPI	CoGetCallContext (REFIID riid, void **ppv)
HRESULT WINAPI	CoSwitchCallContext (IUnknown *pObject, IUnknown **ppOldObject)
HRESULT WINAPI	CoQueryClientBlanket (DWORD *pAuthnSvc, DWORD *pAuthzSvc, OLECHAR **pServerPrincName, DWORD *pAuthnLevel, DWORD *pImpLevel, RPC_AUTHZ_HANDLE *pPrivs, DWORD *pCapabilities)
HRESULT WINAPI	CoImpersonateClient (void)
HRESULT WINAPI	CoRevertToSelf (void)
static BOOL	COM_PeekMessage (struct apartment *apt, MSG *msg)
HRESULT WINAPI	CoWaitForMultipleHandles (DWORD dwFlags, DWORD dwTimeout, ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex)
HRESULT WINAPI	CoGetObject (LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, void **ppv)
HRESULT WINAPI	CoRegisterChannelHook (REFGUID guidExtension, IChannelHook *pChannelHook)
static Context *	impl_from_IComThreadingInfo (IComThreadingInfo *iface)
static Context *	impl_from_IContextCallback (IContextCallback *iface)
static Context *	impl_from_IObjContext (IObjContext *iface)
static HRESULT	Context_QueryInterface (Context *iface, REFIID riid, LPVOID *ppv)
static ULONG	Context_AddRef (Context *This)
static ULONG	Context_Release (Context *This)
static HRESULT WINAPI	Context_CTI_QueryInterface (IComThreadingInfo *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	Context_CTI_AddRef (IComThreadingInfo *iface)
static ULONG WINAPI	Context_CTI_Release (IComThreadingInfo *iface)
static HRESULT WINAPI	Context_CTI_GetCurrentApartmentType (IComThreadingInfo *iface, APTTYPE *apttype)
static HRESULT WINAPI	Context_CTI_GetCurrentThreadType (IComThreadingInfo *iface, THDTYPE *thdtype)
static HRESULT WINAPI	Context_CTI_GetCurrentLogicalThreadId (IComThreadingInfo *iface, GUID *logical_thread_id)
static HRESULT WINAPI	Context_CTI_SetCurrentLogicalThreadId (IComThreadingInfo *iface, REFGUID logical_thread_id)
static HRESULT WINAPI	Context_CC_QueryInterface (IContextCallback *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	Context_CC_AddRef (IContextCallback *iface)
static ULONG WINAPI	Context_CC_Release (IContextCallback *iface)
static HRESULT WINAPI	Context_CC_ContextCallback (IContextCallback *iface, PFNCONTEXTCALL pCallback, ComCallData *param, REFIID riid, int method, IUnknown *punk)
static HRESULT WINAPI	Context_OC_QueryInterface (IObjContext *iface, REFIID riid, LPVOID *ppv)
static ULONG WINAPI	Context_OC_AddRef (IObjContext *iface)
static ULONG WINAPI	Context_OC_Release (IObjContext *iface)
static HRESULT WINAPI	Context_OC_SetProperty (IObjContext *iface, REFGUID propid, CPFLAGS flags, IUnknown *punk)
static HRESULT WINAPI	Context_OC_RemoveProperty (IObjContext *iface, REFGUID propid)
static HRESULT WINAPI	Context_OC_GetProperty (IObjContext *iface, REFGUID propid, CPFLAGS *flags, IUnknown **punk)
static HRESULT WINAPI	Context_OC_EnumContextProps (IObjContext *iface, IEnumContextProps **props)
static void WINAPI	Context_OC_Reserved1 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved2 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved3 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved4 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved5 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved6 (IObjContext *iface)
static void WINAPI	Context_OC_Reserved7 (IObjContext *iface)
HRESULT WINAPI	CoGetObjectContext (REFIID riid, void **ppv)
HRESULT WINAPI	CoGetContextToken (ULONG_PTR *token)
HRESULT WINAPI	CoGetDefaultContext (APTTYPE type, REFIID riid, LPVOID *ppv)
HRESULT	Handler_DllGetClassObject (REFCLSID rclsid, REFIID riid, LPVOID *ppv)
HRESULT WINAPI	CoGetApartmentType (APTTYPE *type, APTTYPEQUALIFIER *qualifier)
HRESULT WINAPI	CoDisableCallCancellation (void *reserved)
HRESULT WINAPI	CoEnableCallCancellation (void *reserved)
HRESULT WINAPI	CoRegisterSurrogate (ISurrogate *surrogate)
HRESULT WINAPI	CoRegisterSurrogateEx (REFGUID guid, void *reserved)
static GlobalOptions *	impl_from_IGlobalOptions (IGlobalOptions *iface)
static HRESULT WINAPI	GlobalOptions_QueryInterface (IGlobalOptions *iface, REFIID riid, void **ppv)
static ULONG WINAPI	GlobalOptions_AddRef (IGlobalOptions *iface)
static ULONG WINAPI	GlobalOptions_Release (IGlobalOptions *iface)
static HRESULT WINAPI	GlobalOptions_Set (IGlobalOptions *iface, GLOBALOPT_PROPERTIES property, ULONG_PTR value)
static HRESULT WINAPI	GlobalOptions_Query (IGlobalOptions *iface, GLOBALOPT_PROPERTIES property, ULONG_PTR *value)
HRESULT WINAPI	GlobalOptions_CreateInstance (IClassFactory *iface, IUnknown *outer, REFIID riid, void **ppv)
BOOL WINAPI	DllMain (HINSTANCE hinstDLL, DWORD fdwReason, LPVOID reserved)
HRESULT WINAPI	DllRegisterServer (void)
HRESULT WINAPI	DllUnregisterServer (void)

Variables
static APARTMENT *	MTA
static APARTMENT *	MainApartment
static struct list	apts = LIST_INIT( apts )
static CRITICAL_SECTION	csApartment = { &critsect_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	critsect_debug
static struct list	registered_psclsid_list = LIST_INIT(registered_psclsid_list)
static CRITICAL_SECTION	cs_registered_psclsid_list = { &psclsid_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	psclsid_cs_debug
static LONG	s_COMLockCount = 0
static LONG	s_COMServerProcessReferences = 0
static struct list	RegisteredClassList = LIST_INIT(RegisteredClassList)
static CRITICAL_SECTION	csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	class_cs_debug
static const WCHAR	classes_rootW []
static HKEY	classes_root_hkey
static struct list	openDllList = LIST_INIT(openDllList)
static CRITICAL_SECTION	csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 }
static CRITICAL_SECTION_DEBUG	dll_cs_debug
static const WCHAR	wszAptWinClass [] = {'O','l','e','M','a','i','n','T','h','r','e','a','d','W','n','d','C','l','a','s','s',0}
static ATOM	apt_win_class
static ISynchronizeVtbl	vt_ISynchronize
static const ISynchronizeHandleVtbl	SynchronizeHandleVtbl
static const IServiceProviderVtbl	LocalServerVtbl
static const BYTE	guid_conv_table [256]
static const IComThreadingInfoVtbl	Context_Threading_Vtbl
static const IContextCallbackVtbl	Context_Callback_Vtbl
static const IObjContextVtbl	Context_Object_Vtbl
static const IGlobalOptionsVtbl	GlobalOptionsVtbl

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 44 of file compobj.c.

NONAMELESSUNION

#define NONAMELESSUNION

Definition at line 45 of file compobj.c.

USE_COM_CONTEXT_DEF

#define USE_COM_CONTEXT_DEF

Definition at line 54 of file compobj.c.

WIN32_NO_STATUS

#define WIN32_NO_STATUS

Definition at line 48 of file compobj.c.

Typedef Documentation

Context

typedef struct Context Context

DllCanUnloadNowFunc

typedef HRESULT(WINAPI * DllCanUnloadNowFunc) (void)

Definition at line 450 of file compobj.c.

DllGetClassObjectFunc

typedef HRESULT(CALLBACK * DllGetClassObjectFunc) (REFCLSID clsid, REFIID iid, LPVOID *ppv)

Definition at line 449 of file compobj.c.

MREImpl

typedef struct ManualResetEvent MREImpl

OpenDll

typedef struct tagOpenDll OpenDll

RegisteredClass

typedef struct tagRegisteredClass RegisteredClass

Enumeration Type Documentation

comclass_miscfields

enum comclass_miscfields

Enumerator
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint
MiscStatus
MiscStatusIcon
MiscStatusContent
MiscStatusThumbnail
MiscStatusDocPrint

Definition at line 98 of file compobj.c.

{
    MiscStatus          = 1,
    MiscStatusIcon      = 2,
    MiscStatusContent   = 4,
    MiscStatusThumbnail = 8,
    MiscStatusDocPrint  = 16
};

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 89 of file compobj.c.

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

Function Documentation

actctx_get_miscstatus()

BOOL actctx_get_miscstatus	(	const CLSID *	clsid,
		DWORD	aspect,
		DWORD *	status
	)

Definition at line 254 of file compobj.c.

{
    ACTCTX_SECTION_KEYED_DATA data;
 
    data.cbSize = sizeof(data);
    if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                              clsid, &data))
    {
        struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
        enum comclass_miscfields misc = dvaspect_to_miscfields(aspect);
 
        if (!(comclass->miscmask & misc))
        {
            if (!(comclass->miscmask & MiscStatus))
            {
                *status = 0;
                return TRUE;
            }
            misc = MiscStatus;
        }
 
        switch (misc)
        {
        case MiscStatus:
            *status = comclass->miscstatus;
            break;
        case MiscStatusIcon:
            *status = comclass->miscstatusicon;
            break;
        case MiscStatusContent:
            *status = comclass->miscstatuscontent;
            break;
        case MiscStatusThumbnail:
            *status = comclass->miscstatusthumbnail;
            break;
        case MiscStatusDocPrint:
            *status = comclass->miscstatusdocprint;
            break;
        default:
           ;
        };
 
        return TRUE;
    }
    else
        return FALSE;
}

Referenced by OleRegGetMiscStatus().

apartment_addref()

static DWORD apartment_addref ( struct apartment *  apt )

static

Definition at line 619 of file compobj.c.

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

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

apartment_construct()

static APARTMENT * apartment_construct ( DWORD  model )

static

Definition at line 628 of file compobj.c.

{
    APARTMENT *apt;
 
    TRACE("creating new apartment, model=%d\n", model);
 
    apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
    apt->tid = GetCurrentThreadId();
 
    list_init(&apt->proxies);
    list_init(&apt->stubmgrs);
    list_init(&apt->loaded_dlls);
    apt->ipidc = 0;
    apt->refs = 1;
    apt->remunk_exported = FALSE;
    apt->oidc = 1;
    InitializeCriticalSection(&apt->cs);
    DEBUG_SET_CRITSEC_NAME(&apt->cs, "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().

apartment_createwindowifneeded()

HRESULT apartment_createwindowifneeded

(

struct apartment *

apt

)

Definition at line 1704 of file compobj.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(wszAptWinClass, NULL, 0, 0, 0, 0, 0,
                             HWND_MESSAGE, 0, hProxyDll, NULL);
        if (!hwnd)
        {
            ERR("CreateWindow failed with error %d\n", GetLastError());
            return HRESULT_FROM_WIN32(GetLastError());
        }
        if (InterlockedCompareExchangePointer((PVOID *)&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_find_mta()

static APARTMENT * apartment_find_mta ( void  )

static

Definition at line 726 of file compobj.c.

{
    APARTMENT *apt;
 
    EnterCriticalSection(&csApartment);
 
    if ((apt = MTA))
        apartment_addref(apt);
 
    LeaveCriticalSection(&csApartment);
 
    return apt;
}

Referenced by apartment_get_current_or_mta(), and CoGetApartmentType().

apartment_findfromoxid()

APARTMENT * apartment_findfromoxid	(	OXID	oxid,
		BOOL	ref
	)

Definition at line 1276 of file compobj.c.

{
    APARTMENT *result = NULL;
    struct list *cursor;
 
    EnterCriticalSection(&csApartment);
    LIST_FOR_EACH( cursor, &apts )
    {
        struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
        if (apt->oxid == oxid)
        {
            result = apt;
            if (ref) apartment_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&csApartment);
 
    return result;
}

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

apartment_findfromtid()

APARTMENT * apartment_findfromtid

(

DWORD

tid

)

Definition at line 1300 of file compobj.c.

{
    APARTMENT *result = NULL;
    struct list *cursor;
 
    EnterCriticalSection(&csApartment);
    LIST_FOR_EACH( cursor, &apts )
    {
        struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
        if (apt->tid == tid)
        {
            result = apt;
            apartment_addref(result);
            break;
        }
    }
    LeaveCriticalSection(&csApartment);
 
    return result;
}

Referenced by ipid_to_ifstub().

apartment_findmain()

static APARTMENT * apartment_findmain ( void  )

static

Definition at line 1324 of file compobj.c.

{
    APARTMENT *result;
 
    EnterCriticalSection(&csApartment);
 
    result = MainApartment;
    if (result) apartment_addref(result);
 
    LeaveCriticalSection(&csApartment);
 
    return result;
}

Referenced by apartment_hostobject_in_hostapt().

apartment_freeunusedlibraries()

static void apartment_freeunusedlibraries ( struct apartment *  apt, DWORD  delay  )

static

Definition at line 1132 of file compobj.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);
                COMPOBJ_DllList_ReleaseRef(entry->dll, TRUE);
                HeapFree(GetProcessHeap(), 0, 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()

APARTMENT * apartment_get_current_or_mta

(

void

)

Definition at line 742 of file compobj.c.

{
    APARTMENT *apt = COM_CurrentApt();
    if (apt)
    {
        apartment_addref(apt);
        return apt;
    }
    return apartment_find_mta();
}

Referenced by ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_SendReceive(), CoCreateInstanceEx(), CoDisconnectObject(), CoGetClassObject(), CoGetContextToken(), CoGetPSClsid(), CoLockObjectExternal(), CoRegisterClassObject(), CoRegisterPSClsid(), CoRevokeClassObject(), proxy_manager_get_remunknown(), std_unmarshal_interface(), and StdMarshalImpl_MarshalInterface().

apartment_get_or_create()

static APARTMENT * apartment_get_or_create ( DWORD  model )

static

Definition at line 670 of file compobj.c.

{
    APARTMENT *apt = COM_CurrentApt();
 
    if (!apt)
    {
        if (model & COINIT_APARTMENTTHREADED)
        {
            EnterCriticalSection(&csApartment);
 
            apt = apartment_construct(model);
            if (!MainApartment)
            {
                MainApartment = apt;
                apt->main = TRUE;
                TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
            }
 
            LeaveCriticalSection(&csApartment);
 
            if (apt->main)
                apartment_createwindowifneeded(apt);
        }
        else
        {
            EnterCriticalSection(&csApartment);
 
            /* 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);
 
            apt = MTA;
 
            LeaveCriticalSection(&csApartment);
        }
        COM_CurrentInfo()->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 1340 of file compobj.c.

{
    static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
    HRESULT hr = S_OK;
    BOOL found = FALSE;
    struct apartment_loaded_dll *apartment_loaded_dll;
 
    if (!wcsicmp(dllpath, wszOle32))
    {
        /* 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 = DllGetClassObject(rclsid, riid, ppv);
 
        if (hr != S_OK)
            ERR("DllGetClassObject returned error 0x%08x 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 = HeapAlloc(GetProcessHeap(), 0, 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 = COMPOBJ_DllList_Add( dllpath, &apartment_loaded_dll->dll );
            if (FAILED(hr))
                HeapFree(GetProcessHeap(), 0, 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 0x%08x for dll %s\n", hr, debugstr_w(dllpath));
    }
 
    return hr;
}

Referenced by apartment_hostobject(), and get_inproc_class_object().

apartment_getwindow()

HWND apartment_getwindow

(

const struct apartment *

apt

)

Definition at line 1733 of file compobj.c.

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

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

apartment_hostobject()

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

static

Definition at line 1468 of file compobj.c.

{
    IUnknown *object;
    HRESULT hr;
    static const LARGE_INTEGER llZero;
    WCHAR dllpath[MAX_PATH+1];
 
    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 1573 of file compobj.c.

{
    struct host_object_params params;
    HWND apartment_hwnd = NULL;
    DWORD apartment_tid = 0;
    HRESULT hr;
 
    if (!multi_threaded && main_apartment)
    {
        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)
    {
        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 get_inproc_class_object().

apartment_hostobject_thread()

static DWORD CALLBACK apartment_hostobject_thread ( LPVOID  p )

static

Definition at line 1521 of file compobj.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_CurrentApt();
    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_is_model()

static BOOL apartment_is_model ( const APARTMENT *  apt, DWORD  model  )

inlinestatic

Definition at line 718 of file compobj.c.

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

Referenced by enter_apartment().

apartment_release()

DWORD apartment_release

(

struct apartment *

apt

)

Definition at line 1172 of file compobj.c.

{
    DWORD ret;
 
    EnterCriticalSection(&csApartment);
 
    ret = InterlockedDecrement(&apt->refs);
    TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt->oxid), ret);
 
    if (apt->being_destroyed)
    {
        LeaveCriticalSection(&csApartment);
        return ret;
    }
 
    /* destruction stuff that needs to happen under csApartment CS */
    if (ret == 0)
    {
        apt->being_destroyed = TRUE;
        if (apt == MTA) MTA = NULL;
        else if (apt == MainApartment) MainApartment = NULL;
        list_remove(&apt->entry);
    }
 
    LeaveCriticalSection(&csApartment);
 
    if (ret == 0)
    {
        struct list *cursor, *cursor2;
 
        TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
 
        if(apt->local_server) {
            LocalServer *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 */
        COM_RevokeAllClasses(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);
            COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
            list_remove(cursor);
            HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
        }
 
        DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
        DeleteCriticalSection(&apt->cs);
 
        HeapFree(GetProcessHeap(), 0, apt);
    }
 
    return ret;
}

Referenced by apartment_hostobject_in_hostapt(), ClientIdentity_QueryMultipleInterfaces(), ClientRpcChannelBuffer_GetBuffer(), ClientRpcChannelBuffer_SendReceive(), CoCreateInstanceEx(), CoDisconnectObject(), CoGetApartmentType(), CoGetClassObject(), CoGetContextToken(), CoGetPSClsid(), CoLockObjectExternal(), COM_TlsDestroy(), CoRegisterClassObject(), CoRegisterPSClsid(), CoRevokeClassObject(), dispatch_rpc(), 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_wndproc()

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

static

Definition at line 1498 of file compobj.c.

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

Referenced by register_class().

clsid_from_string_reg()

static HRESULT clsid_from_string_reg ( LPCOLESTR  progid, CLSID *  clsid  )

static

Definition at line 2290 of file compobj.c.

{
    static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
    WCHAR buf2[CHARS_IN_GUID];
    LONG buf2len = sizeof(buf2);
    HKEY xhkey;
    WCHAR *buf;
 
    memset(clsid, 0, sizeof(*clsid));
    buf = HeapAlloc( GetProcessHeap(),0,(lstrlenW(progid)+8) * sizeof(WCHAR) );
    if (!buf) return E_OUTOFMEMORY;
    lstrcpyW( buf, progid );
    lstrcatW( buf, clsidW );
    if (open_classes_key(HKEY_CLASSES_ROOT, buf, MAXIMUM_ALLOWED, &xhkey))
    {
        HeapFree(GetProcessHeap(),0,buf);
        WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
        return CO_E_CLASSSTRING;
    }
    HeapFree(GetProcessHeap(),0,buf);
 
    if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
    {
        RegCloseKey(xhkey);
        WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
        return CO_E_CLASSSTRING;
    }
    RegCloseKey(xhkey);
    return guid_from_string(buf2, clsid) ? S_OK : CO_E_CLASSSTRING;
}

Referenced by CLSIDFromProgID(), and CLSIDFromString().

CLSIDFromProgID()

HRESULT WINAPI DECLSPEC_HOTPATCH CLSIDFromProgID	(	LPCOLESTR	progid,
		LPCLSID	clsid
	)

Definition at line 2602 of file compobj.c.

{
    ACTCTX_SECTION_KEYED_DATA data;
 
    if (!progid || !clsid)
        return E_INVALIDARG;
 
    data.cbSize = sizeof(data);
    if (FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION,
                                 progid, &data))
    {
        struct progidredirect_data *progiddata = (struct progidredirect_data*)data.lpData;
        CLSID *alias = (CLSID*)((BYTE*)data.lpSectionBase + progiddata->clsid_offset);
        *clsid = *alias;
        return S_OK;
    }
 
    return clsid_from_string_reg(progid, clsid);
}

Referenced by call_script(), CLSIDFromProgIDEx(), ATL::CComPtr< T >::CoCreateInstance(), create_activex_object(), create_object(), get_content_type(), get_engine_clsid(), get_guid_from_language(), get_moniker_for_progid_display_name(), GetClassFile(), Host_CreateObject(), MkProtocol_StartEx(), OLECONVERT_CreateCompObjStream(), run_script(), START_TEST(), test_CLSIDFromProgID(), and test_IWinHttpRequest_Invoke().

CLSIDFromProgIDEx()

HRESULT WINAPI CLSIDFromProgIDEx	(	LPCOLESTR	progid,
		LPCLSID	clsid
	)

Definition at line 2625 of file compobj.c.

{
    FIXME("%s,%p: semi-stub\n", debugstr_w(progid), clsid);
 
    return CLSIDFromProgID(progid, clsid);
}

CLSIDFromString()

HRESULT WINAPI CLSIDFromString	(	LPCOLESTR	idstr,
		LPCLSID	id
	)

Definition at line 2338 of file compobj.c.

{
    HRESULT ret = CO_E_CLASSSTRING;
    CLSID tmp_id;
 
    if (!id)
        return E_INVALIDARG;
 
    if (guid_from_string(idstr, id))
        return S_OK;
 
    /* It appears a ProgID is also valid */
    ret = clsid_from_string_reg(idstr, &tmp_id);
    if(SUCCEEDED(ret))
        *id = tmp_id;
 
    return ret;
}

Referenced by ACTION_MsiPublishAssemblies(), ACTION_PublishFeatures(), build_directshowfilters_tree(), CategoryMgr_FindClosestCategory(), CATIDEnumGUID_Next(), CLSIDEnumGUID_Next(), CLSIDFromStringWrap(), CLSIDPrefix(), CoGetTreatAsClass(), COMCAT_IEnumCATEGORYINFO_Next(), ComponentInfo_GetGuidList(), ComponentInfo_GetGUIDValue(), CoTreatAsClass(), CreateComponentEnumerator(), CreateNotificationObject(), CreateRegItem(), DEVENUM_IMediaCatMoniker_BindToObject(), DEVENUM_IParseDisplayName_ParseDisplayName(), DEVENUM_ReadPinTypes(), DirectPlayEnumerateAW(), do_enum(), DP_LoadSP(), EnumClientServiceProtocol(), CDefaultContextMenu::EnumerateDynamicContextHandlerForKey(), CNetConnectionManager::EnumerateINetConnections(), EnumerateNetworkAdapter(), EnumTfLanguageProfiles_Next(), FilterMapper3_EnumMatchingFilters(), FilterMapper_EnumMatchingFilters(), get_content_type(), get_mime_clsid(), get_mime_filter(), get_protocol_cf(), get_ps_clsid_from_registry(), GetClassMediaFile(), GetCLSIDForFileTypeFromExtension(), GetFilterInfo(), CQueryAssociations::GetString(), GUIDFromStringA(), GUIDFromStringW(), IDirectMusic8Impl_GetDefaultPort(), IDirectPlay4AImpl_EnumConnections(), IDirectPlayLobby3AImpl_EnumAddressTypes(), IDirectPlayLobby3AImpl_EnumLocalApplications(), IEnumDMO_fnNext(), InitIconOverlays(), InitShellServices(), InputProcessorProfiles_GetDefaultLanguageProfile(), InternetProtocolSink_ReportProgress(), IsProductCode(), ITERATE_RegisterTypeLibraries(), ITERATE_UnregisterTypeLibraries(), CLangBarItemList::Load(), load_devices_from_reg(), MMDevPropStore_GetAt(), msi_create_component_advertise_string(), next_LanguageProfile(), OleGetAutoConvert(), parse_classid(), process_extensions(), ProfilesEnumGuid_Next(), ATL::CRegKey::QueryGUIDValue(), read_types(), register_legacy_filters(), SSOThread::Run(), CShellLink::SetAdvertiseInfo(), CDeviceNode::SetupNode(), SHCLSIDFromStringA(), SHCLSIDFromStringW(), SHDOCVW_GetShellInstanceObjectClassObject(), SHELL32_GetCLSIDForDirectory(), SHELL_GetRegCLSID(), ShellExecute_FromContextMenuHandlers(), CShellBrowser::ShowBrowserBar(), squash_guid(), statusclb_OnProgress(), string_to_guid(), test_CLSIDFromProgID(), test_CLSIDFromString(), test_devenum(), test_first_device(), UIINSERTOBJECTDLG_PopulateObjectTypes(), and wmain().

CoAddRefServerProcess()

ULONG WINAPI CoAddRefServerProcess

(

void

)

Definition at line 4162 of file compobj.c.

{
    ULONG refs;
 
    TRACE("\n");
 
    EnterCriticalSection(&csRegisteredClassList);
    refs = ++s_COMServerProcessReferences;
    LeaveCriticalSection(&csRegisteredClassList);
 
    TRACE("refs before: %d\n", refs - 1);
 
    return refs;
}

Referenced by ATL::CAtlExeModuleT< T >::Lock(), and LockModuleOOP().

CoAllowSetForegroundWindow()

HRESULT WINAPI CoAllowSetForegroundWindow	(	IUnknown *	pUnk,
		void *	pvReserved
	)

Definition at line 4234 of file compobj.c.

{
    FIXME("(%p, %p): stub\n", pUnk, pvReserved);
    return S_OK;
}

CoBuildVersion()

DWORD WINAPI CoBuildVersion

(

void

)

Definition at line 1774 of file compobj.c.

{
    TRACE("Returning version %d, build %d.\n", rmm, rup);
    return (rmm<<16)+rup;
}

CoCopyProxy()

HRESULT WINAPI CoCopyProxy	(	IUnknown *	pProxy,
		IUnknown **	ppCopy
	)

Definition at line 4346 of file compobj.c.

{
    IClientSecurity *pCliSec;
    HRESULT hr;
 
    TRACE("%p\n", pProxy);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
    if (SUCCEEDED(hr))
    {
        hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
        IClientSecurity_Release(pCliSec);
    }
 
    if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
    return hr;
}

CoCreateGuid()

HRESULT WINAPI CoCreateGuid

(

GUID *

pguid

)

Definition at line 2206 of file compobj.c.

{
    DWORD status;
 
    if(!pguid) return E_INVALIDARG;
 
    status = UuidCreate(pguid);
    if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY) return S_OK;
    return HRESULT_FROM_WIN32( status );
}

Referenced by BackgroundCopyJobConstructor(), COM_CurrentCausalityId(), compose_base85_guid(), create_test_guid(), do_msidbCustomActionTypeDll(), do_msidbCustomActionTypeScript(), DP_SetSessionDesc(), main(), test_ClientId(), test_CoCreateGuid(), test_fm2_enummatchingfilters(), test_legacy_filter_registration(), test_NewWorkItem(), test_register_filter_with_null_clsMinorType(), test_session(), test_session_creation(), test_TfGuidAtom(), test_volume_dependence(), and ThreadMgr_ActivateEx().

CoCreateInstance()

HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance	(	REFCLSID	rclsid,
		LPUNKNOWN	pUnkOuter,
		DWORD	dwClsContext,
		REFIID	iid,
		LPVOID *	ppv
	)

Definition at line 3325 of file compobj.c.

{
    MULTI_QI multi_qi = { iid };
    HRESULT hres;
 
    TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
          pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
 
    if (ppv==0)
        return E_POINTER;
 
    hres = CoCreateInstanceEx(rclsid, pUnkOuter, dwClsContext, NULL, 1, &multi_qi);
    *ppv = multi_qi.pItf;
    return hres;
}

Referenced by _CBandSite_CreateInstance(), _CBandSiteMenu_CreateInstance(), _create_object(), _CStartMenu_CreateInstance(), CViewStatePropertyBag::_GetMRUSlots(), CViewStatePropertyBag::_PruneMRUTree(), activate_given_ts(), add_favs_to_menu(), AMovieDllRegisterServer2(), AtlAxCreateControlLicEx(), ATL::AtlRegisterClassCategoriesHelper(), AtlRegisterClassCategoriesHelper(), AutoComplete_AddMRU(), AutoComplete_LoadList(), AVIFileOpenW(), AVIMakeCompressedStream(), AVIStreamCreate(), BaseOutputPinImpl_InitAllocator(), build_directshowfilters_tree(), cache_InstallAssembly(), cache_UninstallAssembly(), CAddressBand_CreateInstance(), CAddressEditBox_CreateInstance(), call_script(), CBandProxy_CreateInstance(), CBrandBand_CreateInstance(), CExplorerBand_CreateInstance(), check_bits20(), check_bits25(), check_ie(), check_jscript(), check_lnk_(), check_tiff_format(), check_vbscript(), ChildWndProc(), CInternetToolbar_CreateInstance(), CMenuBand_CreateInstance(), CMergedFolder_CreateInstance(), CNetConnectionManager_CreateInstance(), CNetworkConnections::CNetworkConnections(), CoGetInstanceFromFile(), CoGetInstanceFromIStorage(), CommitDecommitTest(), confirm_safety(), cp_from_charset_string(), create_ammultimediastream(), create_audio_data(), create_avisplitter(), create_configuration(), create_doc_from_url(), create_document(), create_dsound_renderer(), create_engine(), create_graph(), create_input_pin(), create_instance(), create_jscript(), create_lnk_(), create_mime_object(), create_mpeg_splitter(), create_path(), create_root_IDxDiagContainer(), create_script(), create_script_host(), create_server_xhr(), create_session(), create_system_ports_list(), create_test(), create_vbscript(), create_video_renderer(), create_xhr(), CreateAndInitXMLDOMDocument(), CreateCShellMenu(), CreateDropTarget(), CreateExtractIcon(), CreateFilterInstanceAndLoadFile(), SIfacePtr< T >::CreateInstance(), CreateInternetShortcut(), CreateNotificationObject(), CreateObjectsFromPersistFolder(), CInputPin::CreatePin(), COutputPin::CreatePin(), CreatePosPassThru(), CreateShellLink(), CreateShortcut(), CSearchBar_CreateInstance(), DefaultHandler_Construct(), DefaultHandler_Run(), determine_patch_sequence(), DEVENUM_IMediaCatMoniker_BindToObject(), device_tests(), DllRegisterServer(), do_child(), do_enum(), DoCreateShortcut(), CShellBrowser::DoFolderOptions(), DoInitAutoCompleteWithCWD(), DoTestCaseA(), DoTestCaseB(), DragSourceHelper::DragSourceHelper(), ebrowser_instantiate(), EnumConnections_cb(), FileAsyncReader_RequestAllocator(), FileMonikerImpl_BindToObject(), fill_filter_data_information(), fill_processor_information(), FilterGraph2_SetDefaultSyncSource(), FilterGraph_create(), FilterMapper3_EnumMatchingFilters(), FilterMapper3_GetICreateDevEnum(), FilterMapper3_RegisterFilter(), find_moniker(), fnCaptureGraphBuilder2_RenderStream(), get_class_support_data(), get_component_info(), get_mime_filter(), get_mlang(), get_tasks_root_folder(), BtrfsContextMenu::get_uac_icon(), get_unmarshaler_from_stream(), GetExeFromLnk(), GetFileSourceFilter(), GetSplitter(), getstring_test(), CFolderOptions::HandleDefFolderSettings(), hlink_frame_navigate(), HlinkCreateBrowseContext(), HlinkCreateFromMoniker(), HlinkCreateFromString(), Host_CreateObject(), IAMMultiMediaStreamImpl_AddMediaStream(), IAMMultiMediaStreamImpl_Initialize(), IDirectSound8_tests(), IDirectSound_tests(), IDirectSoundFullDuplex_tests(), IDropTargetImpl::IDropTargetImpl(), implicit_mta_proc(), init_explorerbrowser(), init_TCPIP_provider(), initialize(), CNetConnectionPropertyUi::InitializeLANPropertiesUIDlg(), InitializeObjectPicker(), InitializeRemoteRegistryPicker(), InitializeSecurity(), InitIconOverlays(), CSysTray::InitNetShell(), InitShellServices(), InstallTypicalNetworkSettings(), InstanceObjectFactory_IClassFactory_CreateInstance(), CBandSiteMenu::InvokeCommand(), CDefaultContextMenu::InvokeRegVerb(), is_firewall_enabled(), ITERATE_CreateShortcuts(), ITypeInfo_fnCreateInstance(), LoadAndInitialize(), CComCatCachedCategory::LoadFromComCatMgr(), CShellBrowser::LoadHistory(), CInputPin::LoadProxyPlugins(), COutputPin::LoadProxyPlugins(), CKsProxy::LoadProxyPlugins(), LoadShellLinkConsoleInfo(), locator_ConnectServer(), main_test(), match_smart_tee_pin(), MCIQTZ_mciOpen(), MediaDet_put_Filename(), MkProtocol_StartEx(), MMDevice_Activate(), MRUList_DataList_0(), MRUList_DataList_1(), MRUList_DataList_2(), MRUList_PidlList_0(), MsiGetShortcutTargetW(), navigate_new_window(), OleCreate(), OleCreatePropertyFrameIndirect(), OleLoad(), OleLoadFromStream(), OLEPictureImpl_LoadWICDecoder(), CShellBrowser::OnSearch(), OpenCHM(), OpenControlPanelItem(), parse_config(), parse_path(), perform_test(), QCAP_createSmartTeeFilter(), query_prop(), register_codec(), register_filters(), RegisterComCat(), run_script(), SampleGrabber_create(), set_firewall(), setup(), setup_task(), setup_trigger(), SHAddToRecentDocs(), SHAutoComplete(), SHCoCreateInstance(), SHCoCreateInstanceAC(), SHCreatePropSheetExtArrayEx(), SHDOCVW_CreateShortcut(), SHDOCVW_GetPathOfShortcut(), shellex_load_object_and_run(), SHFileOperationW(), SHFindComputer(), SHLoadInProc(), CShellBrowser::ShowBand(), ShowNetConnectionProperties(), START_TEST(), synth_port_create(), test_ACListISF(), test_ACListISF_CURRENTDIR(), test_ACListISF_CURRENTDIR2(), test_ACListISF_DESKTOP(), test_ACListISF_FAVORITES(), test_ACListISF_FILESYSDIRS(), test_ACListISF_FILESYSONLY(), test_ACListISF_MYCOMPUTER(), test_ACListISF_NONE(), test_ACLMulti(), test_action_mapping(), test_Activate(), test_Add(), test_advise(), test_aggregate_filter_graph(), test_aggregate_filter_mapper(), test_aggregation(), test_AtlAxAttachControl(), test_basics(), test_CAccPropServices(), test_capture(), test_checklinkpath(), test_CoCreateInstance(), test_cocreateinstance_proxy(), test_codec(), test_CoFreeUnusedLibraries(), test_COM(), test_COM_dplobby(), test_COM_sg_enumpins(), test_COM_wavfile(), test_comparemode(), test_componentinfo(), test_create_decoder(), test_create_manager(), test_create_reader(), test_CreateBody(), test_createElement(), test_createfromstream(), test_CreateGroup(), test_CreateJob(), test_CreatePlayer(), test_CShellMenu_with_DeskBar(), test_custom_source(), test_customize(), test_datalink(), test_decode_1bpp(), test_decode_24bpp(), test_decode_4bpp(), test_decode_adobe_cmyk(), test_decode_rle4(), test_decode_rle8(), test_decoder_info(), test_default_converter(), test_default_handler(), test_default_handler_run(), test_default_properties(), test_delegated_methods(), test_devenum(), test_directshow_filter(), test_dispex(), test_dmo(), test_domdoc(), test_dragdrophelper(), test_dsound(), test_dsound8(), test_early_abort(), test_empty_propertybag(), test_Enum(), test_EnumAddressTypes(), test_EnumConnections(), test_EnumGroups(), test_EnumGroupsInGroup(), test_EnumJobs(), test_EnumPlayers(), test_EnumSessions(), test_events(), test_Exists(), test_file_protocol_fail(), test_filename_opendlg_(), test_filename_savedlg_(), test_filesourcefilter(), test_filled_propertybag(), test_filter_graph(), test_first_device(), test_fm2_enummatchingfilters(), test_FolderShortcut(), test_get_set(), test_GetCaps(), test_GetDefaultColumn(), test_GetDefaultSearchGUID(), test_GetIconLocation(), test_GetMessageCount(), test_GetMessageQueue(), test_GetPlayerAccount(), test_GetPlayerAddress(), test_GetPlayerCaps(), test_GetPlayerFlags(), test_GetRootContainer(), test_GetTargetComputer(), test_gif_notrailer(), test_globalinterfacetable(), test_globalness(), test_GlobalOptions(), test_graph_builder(), test_graph_builder_connect(), test_GroupOwner(), test_groups_cs(), test_groups_p2p(), test_hash_value(), test_host_migration(), test_HTMLLoadOptions(), test_IACLCustomMRU_Basics(), test_IACLCustomMRU_Continue(), test_IACLCustomMRU_ExtraChars(), test_IACLCustomMRU_TypedURLs(), test_IACLCustomMRU_UpdateOrder(), test_IClientSecurity(), test_ico_data_(), test_iconlocation(), test_IEnumVARIANT(), test_ifiltermapper_from_filtergraph(), test_imagingfactory_interfaces(), test_init(), test_Initialize(), test_InitializeConnection(), test_inmemorystore(), test_inproc_handler(), test_instantiation(), test_interfaces(), test_invalid_init(), test_IObjectSafety(), test_IPersistStream(), test_IProgressDialog_QueryInterface(), test_IQueryAssociations_GetString(), test_IQueryAssociations_Init(), test_IQueryAssociations_QueryInterface(), test_IReferenceClock_SystemClock(), test_Item(), test_items(), test_IUPnPNAT(), test_IWbemLocator(), test_IWinHttpRequest(), test_IWinHttpRequest_Invoke(), test_Keys(), test_knownFolders(), test_legacy_filter(), test_legacy_filter_registration(), test_Load(), test_local_server(), test_locator(), test_manualresetevent(), test_media_streams(), test_mediadet(), test_metadata_APE(), test_metadata_cHRM(), test_metadata_Exif(), test_metadata_gAMA(), test_metadata_GCE(), test_metadata_gif(), test_metadata_GIF_comment(), test_metadata_IFD(), test_metadata_IMD(), test_metadata_LSD(), test_metadata_png(), test_metadata_tEXt(), test_metadata_unknown(), test_mhtml_protocol_binding(), test_mhtml_protocol_info(), test_midiout(), test_moniker_isequal(), test_mouse_keyboard(), test_multi_encoder(), test_MultiThreadApartment_Thread(), test_mxattr_addAttribute(), test_mxattr_clear(), test_mxattr_dispex(), test_mxattr_localname(), test_mxattr_qi(), test_mxnamespacemanager(), test_mxnamespacemanager_override(), test_mxwriter_cdata(), test_mxwriter_characters(), test_mxwriter_comment(), test_mxwriter_default_properties(), test_mxwriter_dispex(), test_mxwriter_dtd(), test_mxwriter_encoding(), test_mxwriter_flush(), test_mxwriter_handlers(), test_mxwriter_ignorablespaces(), test_mxwriter_indent(), test_mxwriter_pi(), test_mxwriter_properties(), test_mxwriter_startenddocument(), test_mxwriter_startendelement(), test_mxwriter_startendelement_batch(), test_mxwriter_startendelement_batch2(), test_mxwriter_stream(), test_namespace(), test_namespaces_as_attributes(), test_namespaces_change(), test_NetFwAuthorizedApplication(), test_newline_normalization(), test_newmenu(), test_NewWorkItem(), test_OleInitialize_InitCounting(), test_Open(), test_overwrite(), test_parse_filter_data(), test_ParseDisplayName(), test_ParseName(), test_persistent_state(), test_persistserialized(), test_persiststreaminit(), test_PlayerData(), test_PlayerName(), test_popup(), test_prefix_filtering(), test_preinitialization(), test_printers_folder(), test_propertystore(), test_QueryInterface(), test_queryreader(), test_reader_info(), test_Receive(), test_RegExp(), test_register_filter(), test_register_filter_with_null_clsMinorType(), test_registrar(), test_registry(), test_remote_data_replication(), test_Remove(), test_render_filter_priority(), test_res_url(), test_RtlQueryPackageIdentity(), test_samplegrabber(), test_save_settings(), test_saxreader(), test_saxreader_dispex(), test_saxreader_encoding(), test_saxreader_features(), test_saxreader_properties(), test_Send(), test_service(), test_SessionDesc(), test_set_frame_palette(), test_SetData(), test_SetTargetComputer(), test_ShellExecute(), test_ShellWindows(), test_StdHlink(), test_StdURLMoniker(), test_stillimage_aggregation(), test_StreamOnIStream(), test_StreamOnMemory(), test_StreamOnStreamRange(), test_supporterrorinfo(), test_timeline(), test_timelineobj_interfaces(), test_TreatAsClass(), test_try_xmldoc(), test_UninitializedUri(), test_Verbs(), test_vfw(), test_wavein(), test_waveout(), test_whitespace(), test_wshshell(), test_xmldoc(), test_xmlelem(), test_xmlelem_children(), test_xmlelem_collection(), test_XPath(), test_xsltemplate(), TestDescription(), TestGetUIObjectOf(), TestInitialize(), TestModuleInterfaces(), TestNotification(), TestUninitialized(), CHardErrorThread::ThreadProc(), TransformFilter_Init(), unregister_filters(), UnregisterComCat(), WICCreateColorTransform_Proxy(), CShellDispatch::Windows(), write_filter_data(), and WshShortcut_Create().

CoCreateInstanceEx()

HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstanceEx	(	REFCLSID	rclsid,
		LPUNKNOWN	pUnkOuter,
		DWORD	dwClsContext,
		COSERVERINFO *	pServerInfo,
		ULONG	cmq,
		MULTI_QI *	pResults
	)

Definition at line 3387 of file compobj.c.

{
    IUnknown *unk = NULL;
    IClassFactory *cf;
    APARTMENT *apt;
    CLSID clsid;
    HRESULT hres;
 
    TRACE("(%s %p %x %p %u %p)\n", debugstr_guid(rclsid), pUnkOuter, dwClsContext, pServerInfo, cmq, pResults);
 
    if (!cmq || !pResults)
        return E_INVALIDARG;
 
    if (pServerInfo)
        FIXME("() non-NULL pServerInfo not supported!\n");
 
    init_multi_qi(cmq, pResults, E_NOINTERFACE);
 
    hres = CoGetTreatAsClass(rclsid, &clsid);
    if(FAILED(hres))
        clsid = *rclsid;
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
    apartment_release(apt);
 
    /*
     * The Standard Global Interface Table (GIT) object is a process-wide singleton.
     */
    if (IsEqualIID(&clsid, &CLSID_StdGlobalInterfaceTable))
    {
        IGlobalInterfaceTable *git = get_std_git();
        TRACE("Retrieving GIT\n");
        return return_multi_qi((IUnknown*)git, cmq, pResults, FALSE);
    }
 
    if (IsEqualCLSID(&clsid, &CLSID_ManualResetEvent)) {
        hres = ManualResetEvent_Construct(pUnkOuter, pResults[0].pIID, (void**)&unk);
        if (FAILED(hres))
            return hres;
        return return_multi_qi(unk, cmq, pResults, TRUE);
    }
 
    /*
     * Get a class factory to construct the object we want.
     */
    hres = CoGetClassObject(&clsid, dwClsContext, NULL, &IID_IClassFactory, (void**)&cf);
    if (FAILED(hres))
        return hres;
 
    /*
     * Create the object and don't forget to release the factory
     */
    hres = IClassFactory_CreateInstance(cf, pUnkOuter, pResults[0].pIID, (void**)&unk);
    IClassFactory_Release(cf);
    if (FAILED(hres))
    {
        if (hres == CLASS_E_NOAGGREGATION && pUnkOuter)
            FIXME("Class %s does not support aggregation\n", debugstr_guid(&clsid));
        else
            FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n",
                  debugstr_guid(pResults[0].pIID),
                  debugstr_guid(&clsid),hres);
        return hres;
    }
 
    return return_multi_qi(unk, cmq, pResults, TRUE);
}

Referenced by CoCreateInstance(), and test_CoCreateInstanceEx().

CoDisableCallCancellation()

HRESULT WINAPI CoDisableCallCancellation

(

void *

reserved

)

Definition at line 5239 of file compobj.c.

{
    FIXME("(%p): stub\n", reserved);
 
    return E_NOTIMPL;
}

CoDisconnectObject()

HRESULT WINAPI CoDisconnectObject	(	LPUNKNOWN	lpUnk,
		DWORD	reserved
	)

Definition at line 2149 of file compobj.c.

{
    struct stub_manager *manager;
    HRESULT hr;
    IMarshal *marshal;
    APARTMENT *apt;
 
    TRACE("(%p, 0x%08x)\n", lpUnk, reserved);
 
    if (!lpUnk) return E_INVALIDARG;
 
    hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
    if (hr == S_OK)
    {
        hr = IMarshal_DisconnectObject(marshal, reserved);
        IMarshal_Release(marshal);
        return hr;
    }
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
 
    manager = get_stub_manager_from_object(apt, lpUnk, FALSE);
    if (manager) {
        stub_manager_disconnect(manager);
        /* Release stub manager twice, to remove the apartment reference. */
        stub_manager_int_release(manager);
        stub_manager_int_release(manager);
    }
 
    /* Note: native is pretty broken here because it just silently
     * fails, without returning an appropriate error code if the object was
     * not found, making apps think that the object was disconnected, when
     * it actually wasn't */
 
    apartment_release(apt);
    return S_OK;
}

Referenced by implicit_mta_proc(), local_server_GetClassID(), test_disconnect_stub(), and test_lock_object_external().

CoEnableCallCancellation()

HRESULT WINAPI CoEnableCallCancellation

(

void *

reserved

)

Definition at line 5249 of file compobj.c.

{
    FIXME("(%p): stub\n", reserved);
 
    return E_NOTIMPL;
}

CoFileTimeNow()

HRESULT WINAPI CoFileTimeNow

(

FILETIME *

lpFileTime

)

Definition at line 3717 of file compobj.c.

{
    GetSystemTimeAsFileTime( lpFileTime );
    return S_OK;
}

Referenced by RunningObjectTableImpl_Register().

CoFreeAllLibraries()

void WINAPI CoFreeAllLibraries

(

void

)

Definition at line 3655 of file compobj.c.

{
    /* NOP */
}

CoFreeLibrary()

void WINAPI CoFreeLibrary

(

HINSTANCE

hLibrary

)

Definition at line 3638 of file compobj.c.

{
    FreeLibrary(hLibrary);
}

CoFreeUnusedLibraries()

void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibraries

(

void

)

Definition at line 3701 of file compobj.c.

{
    CoFreeUnusedLibrariesEx(INFINITE, 0);
}

Referenced by AMovieDllRegisterServer2(), free_libraries_thread(), SHFreeUnusedLibraries(), and test_CoFreeUnusedLibraries().

CoFreeUnusedLibrariesEx()

void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibrariesEx	(	DWORD	dwUnloadDelay,
		DWORD	dwReserved
	)

Definition at line 3677 of file compobj.c.

{
    struct apartment *apt = COM_CurrentApt();
    if (!apt)
    {
        ERR("apartment not initialised\n");
        return;
    }
 
    apartment_freeunusedlibraries(apt, dwUnloadDelay);
}

Referenced by CoFreeUnusedLibraries().

CoGetApartmentType()

HRESULT WINAPI CoGetApartmentType	(	APTTYPE *	type,
		APTTYPEQUALIFIER *	qualifier
	)

Definition at line 5202 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    APARTMENT *apt;
 
    TRACE("(%p, %p)\n", type, qualifier);
 
    if (!type || !qualifier)
        return E_INVALIDARG;
 
    if (!info)
        return E_OUTOFMEMORY;
 
    if (!info->apt)
        *type = APTTYPE_CURRENT;
    else if (info->apt->multi_threaded)
        *type = APTTYPE_MTA;
    else if (info->apt->main)
        *type = APTTYPE_MAINSTA;
    else
        *type = APTTYPE_STA;
 
    *qualifier = APTTYPEQUALIFIER_NONE;
 
    if (!info->apt && (apt = apartment_find_mta()))
    {
        apartment_release(apt);
        *type = APTTYPE_MTA;
        *qualifier = APTTYPEQUALIFIER_IMPLICIT_MTA;
    }
 
    return info->apt ? S_OK : CO_E_NOTINITIALIZED;
}

Referenced by Context_CTI_GetCurrentApartmentType(), and Context_CTI_GetCurrentThreadType().

CoGetCallContext()

HRESULT WINAPI CoGetCallContext	(	REFIID	riid,
		void **	ppv
	)

Definition at line 4379 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
 
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 
    if (!info)
        return E_OUTOFMEMORY;
 
    if (!info->call_state)
        return RPC_E_CALL_COMPLETE;
 
    return IUnknown_QueryInterface(info->call_state, riid, ppv);
}

Referenced by CoImpersonateClient(), CoQueryClientBlanket(), CoRevertToSelf(), and test_CoGetCallContext().

CoGetClassObject()

HRESULT WINAPI DECLSPEC_HOTPATCH CoGetClassObject	(	REFCLSID	rclsid,
		DWORD	dwClsContext,
		COSERVERINFO *	pServerInfo,
		REFIID	iid,
		LPVOID *	ppv
	)

Definition at line 3103 of file compobj.c.

{
    struct class_reg_data clsreg;
    IUnknown *regClassObject;
    HRESULT hres = E_UNEXPECTED;
    APARTMENT  *apt;
 
    TRACE("CLSID: %s,IID: %s\n", debugstr_guid(rclsid), debugstr_guid(iid));
 
    if (!ppv)
        return E_INVALIDARG;
 
    *ppv = NULL;
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
 
    if (pServerInfo) {
    FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
              debugstr_w(pServerInfo->pwszName), pServerInfo->pAuthInfo);
    }
 
    if (CLSCTX_INPROC_SERVER & dwClsContext)
    {
        if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
        {
            apartment_release(apt);
            return FTMarshalCF_Create(iid, ppv);
        }
        if (IsEqualCLSID(rclsid, &CLSID_GlobalOptions))
            return IClassFactory_QueryInterface(&GlobalOptionsCF, iid, ppv);
    }
 
    if (CLSCTX_INPROC & dwClsContext)
    {
        ACTCTX_SECTION_KEYED_DATA data;
 
        data.cbSize = sizeof(data);
        /* search activation context first */
        if (FindActCtxSectionGuid(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
                                  ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                                  rclsid, &data))
        {
            struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
 
            clsreg.u.actctx.hactctx = data.hActCtx;
            clsreg.u.actctx.data = data.lpData;
            clsreg.u.actctx.section = data.lpSectionBase;
            clsreg.hkey = FALSE;
 
            hres = get_inproc_class_object(apt, &clsreg, &comclass->clsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
            ReleaseActCtx(data.hActCtx);
            apartment_release(apt);
            return hres;
        }
    }
 
    /*
     * First, try and see if we can't match the class ID with one of the
     * registered classes.
     */
    if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
                                             &regClassObject))
    {
      /* Get the required interface from the retrieved pointer. */
      hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
 
      /*
       * Since QI got another reference on the pointer, we want to release the
       * one we already have. If QI was unsuccessful, this will release the object. This
       * is good since we are not returning it in the "out" parameter.
       */
      IUnknown_Release(regClassObject);
      apartment_release(apt);
      return hres;
    }
 
    /* First try in-process server */
    if (CLSCTX_INPROC_SERVER & dwClsContext)
    {
        static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
        HKEY hkey;
 
        hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
        if (FAILED(hres))
        {
            if (hres == REGDB_E_CLASSNOTREG)
                ERR("class %s not registered\n", debugstr_guid(rclsid));
            else if (hres == REGDB_E_KEYMISSING)
            {
                WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
                hres = REGDB_E_CLASSNOTREG;
            }
        }
 
        if (SUCCEEDED(hres))
        {
            clsreg.u.hkey = hkey;
            clsreg.hkey = TRUE;
 
            hres = get_inproc_class_object(apt, &clsreg, rclsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
            RegCloseKey(hkey);
        }
 
        /* return if we got a class, otherwise fall through to one of the
         * other types */
        if (SUCCEEDED(hres))
        {
            apartment_release(apt);
            return hres;
        }
    }
 
    /* Next try in-process handler */
    if (CLSCTX_INPROC_HANDLER & dwClsContext)
    {
        static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
        HKEY hkey;
 
        hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
        if (FAILED(hres))
        {
            if (hres == REGDB_E_CLASSNOTREG)
                ERR("class %s not registered\n", debugstr_guid(rclsid));
            else if (hres == REGDB_E_KEYMISSING)
            {
                WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
                hres = REGDB_E_CLASSNOTREG;
            }
        }
 
        if (SUCCEEDED(hres))
        {
            clsreg.u.hkey = hkey;
            clsreg.hkey = TRUE;
 
            hres = get_inproc_class_object(apt, &clsreg, rclsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
            RegCloseKey(hkey);
        }
 
        /* return if we got a class, otherwise fall through to one of the
         * other types */
        if (SUCCEEDED(hres))
        {
            apartment_release(apt);
            return hres;
        }
    }
    apartment_release(apt);
 
    /* Next try out of process */
    if (CLSCTX_LOCAL_SERVER & dwClsContext)
    {
        hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
        if (SUCCEEDED(hres))
            return hres;
    }
 
    /* Finally try remote: this requires networked DCOM (a lot of work) */
    if (CLSCTX_REMOTE_SERVER & dwClsContext)
    {
        FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
        hres = REGDB_E_CLASSNOTREG;
    }
 
    if (FAILED(hres))
        ERR("no class object %s could be created for context 0x%x\n",
            debugstr_guid(rclsid), dwClsContext);
    return hres;
}

Referenced by ClassMoniker_BindToObject(), CoCreateInstanceEx(), create_activex_object(), create_object(), get_class_object(), get_class_object_proxy_thread(), get_facbuf_for_iid(), get_protocol_cf(), IDirectSound8_tests(), IDirectSound_tests(), implicit_mta_proc(), is_jscript_available(), register_protocols(), START_TEST(), test_about_protocol(), test_capture(), test_CoGetClassObject(), test_com_aggregation(), test_CoRegisterClassObject(), test_CoRegisterPSClsid(), test_file_protocol_url(), test_ftp_protocol(), test_gopher_protocol(), test_http_protocol_url(), test_its_protocol(), test_javascript_protocol(), test_local_server(), test_marshal_channel_buffer(), test_mhtml_protocol(), test_mk_protocol(), test_OleCreateFontIndirect(), test_proxybuffer(), test_res_protocol(), test_stub(), and test_stubbuffer().

CoGetContextToken()

HRESULT WINAPI CoGetContextToken

(

ULONG_PTR *

token

)

Definition at line 5114 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    APARTMENT *apt;
 
    TRACE("(%p)\n", token);
 
    if (!info)
        return E_OUTOFMEMORY;
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
    apartment_release(apt);
 
    if (!token)
        return E_POINTER;
 
    if (!info->context_token)
    {
        Context *context;
 
        context = HeapAlloc(GetProcessHeap(), 0, sizeof(*context));
        if (!context)
            return E_OUTOFMEMORY;
 
        context->IComThreadingInfo_iface.lpVtbl = &Context_Threading_Vtbl;
        context->IContextCallback_iface.lpVtbl = &Context_Callback_Vtbl;
        context->IObjContext_iface.lpVtbl = &Context_Object_Vtbl;
        /* Context token does not take a reference, it's always zero until the
           interface is explicitly requested with CoGetObjectContext(). */
        context->refs = 0;
 
        info->context_token = &context->IObjContext_iface;
    }
 
    *token = (ULONG_PTR)info->context_token;
    TRACE("context_token=%p\n", info->context_token);
 
    return S_OK;
}

Referenced by CoGetObjectContext(), and implicit_mta_proc().

CoGetCurrentLogicalThreadId()

HRESULT WINAPI CoGetCurrentLogicalThreadId

(

GUID *

id

)

Definition at line 4012 of file compobj.c.

{
    TRACE("(%p)\n", id);
 
    if (!id)
        return E_INVALIDARG;
 
    *id = COM_CurrentCausalityId();
    return S_OK;
}

Referenced by Context_CTI_GetCurrentLogicalThreadId(), test_CoGetCurrentLogicalThreadId(), and test_CoGetObjectContext().

CoGetCurrentProcess()

DWORD WINAPI CoGetCurrentProcess

(

void

)

Definition at line 4004 of file compobj.c.

{
    return GetCurrentProcessId();
}

CoGetDefaultContext()

HRESULT WINAPI CoGetDefaultContext	(	APTTYPE	type,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 5161 of file compobj.c.

{
    FIXME("%d %s %p stub\n", type, debugstr_guid(riid), ppv);
    return E_NOINTERFACE;
}

CoGetInstanceFromFile()

HRESULT WINAPI DECLSPEC_HOTPATCH CoGetInstanceFromFile	(	COSERVERINFO *	server_info,
		CLSID *	rclsid,
		IUnknown *	outer,
		DWORD	cls_context,
		DWORD	grfmode,
		OLECHAR *	filename,
		DWORD	count,
		MULTI_QI *	results
	)

Definition at line 3468 of file compobj.c.

{
  IPersistFile *pf = NULL;
  IUnknown* unk = NULL;
  CLSID clsid;
  HRESULT hr;
 
  if (count == 0 || !results)
    return E_INVALIDARG;
 
  if (server_info)
    FIXME("() non-NULL server_info not supported\n");
 
  init_multi_qi(count, results, E_NOINTERFACE);
 
  /* optionally get CLSID from a file */
  if (!rclsid)
  {
    hr = GetClassFile(filename, &clsid);
    if (FAILED(hr))
    {
      ERR("failed to get CLSID from a file\n");
      return hr;
    }
 
    rclsid = &clsid;
  }
 
  hr = CoCreateInstance(rclsid,
            outer,
            cls_context,
            &IID_IUnknown,
            (void**)&unk);
 
  if (hr != S_OK)
  {
      init_multi_qi(count, results, hr);
      return hr;
  }
 
  /* init from file */
  hr = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&pf);
  if (FAILED(hr))
  {
      init_multi_qi(count, results, hr);
      IUnknown_Release(unk);
      return hr;
  }
 
  hr = IPersistFile_Load(pf, filename, grfmode);
  IPersistFile_Release(pf);
  if (SUCCEEDED(hr))
      return return_multi_qi(unk, count, results, FALSE);
  else
  {
      init_multi_qi(count, results, hr);
      IUnknown_Release(unk);
      return hr;
  }
}

Referenced by test_CoGetInstanceFromFile().

CoGetInstanceFromIStorage()

HRESULT WINAPI CoGetInstanceFromIStorage	(	COSERVERINFO *	server_info,
		CLSID *	rclsid,
		IUnknown *	outer,
		DWORD	cls_context,
		IStorage *	storage,
		DWORD	count,
		MULTI_QI *	results
	)

Definition at line 3541 of file compobj.c.

{
  IPersistStorage *ps = NULL;
  IUnknown* unk = NULL;
  STATSTG stat;
  HRESULT hr;
 
  if (count == 0 || !results || !storage)
    return E_INVALIDARG;
 
  if (server_info)
    FIXME("() non-NULL server_info not supported\n");
 
  init_multi_qi(count, results, E_NOINTERFACE);
 
  /* optionally get CLSID from a file */
  if (!rclsid)
  {
    memset(&stat.clsid, 0, sizeof(stat.clsid));
    hr = IStorage_Stat(storage, &stat, STATFLAG_NONAME);
    if (FAILED(hr))
    {
      ERR("failed to get CLSID from a file\n");
      return hr;
    }
 
    rclsid = &stat.clsid;
  }
 
  hr = CoCreateInstance(rclsid,
            outer,
            cls_context,
            &IID_IUnknown,
            (void**)&unk);
 
  if (hr != S_OK)
    return hr;
 
  /* init from IStorage */
  hr = IUnknown_QueryInterface(unk, &IID_IPersistStorage, (void**)&ps);
  if (FAILED(hr))
      ERR("failed to get IPersistStorage\n");
 
  if (ps)
  {
      IPersistStorage_Load(ps, storage);
      IPersistStorage_Release(ps);
  }
 
  return return_multi_qi(unk, count, results, FALSE);
}

CoGetObject()

HRESULT WINAPI CoGetObject	(	LPCWSTR	pszName,
		BIND_OPTS *	pBindOptions,
		REFIID	riid,
		void **	ppv
	)

Definition at line 4742 of file compobj.c.

{
    IBindCtx *pbc;
    HRESULT hr;
 
    *ppv = NULL;
 
    hr = CreateBindCtx(0, &pbc);
    if (SUCCEEDED(hr))
    {
        if (pBindOptions)
            hr = IBindCtx_SetBindOptions(pbc, pBindOptions);
 
        if (SUCCEEDED(hr))
        {
            ULONG chEaten;
            IMoniker *pmk;
 
            hr = MkParseDisplayName(pbc, pszName, &chEaten, &pmk);
            if (SUCCEEDED(hr))
            {
                hr = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppv);
                IMoniker_Release(pmk);
            }
        }
 
        IBindCtx_Release(pbc);
    }
    return hr;
}

CoGetObjectContext()

HRESULT WINAPI CoGetObjectContext	(	REFIID	riid,
		void **	ppv
	)

Definition at line 5096 of file compobj.c.

{
    IObjContext *context;
    HRESULT hr;
 
    TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 
    *ppv = NULL;
    hr = CoGetContextToken((ULONG_PTR*)&context);
    if (FAILED(hr))
        return hr;
 
    return IObjContext_QueryInterface(context, riid, ppv);
}

Referenced by implicit_mta_proc().

CoGetPSClsid()

HRESULT WINAPI CoGetPSClsid	(	REFIID	riid,
		CLSID *	pclsid
	)

Definition at line 2690 of file compobj.c.

{
    static const WCHAR wszInterface[] = {'I','n','t','e','r','f','a','c','e','\\',0};
    static const WCHAR wszPSC[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
    WCHAR path[ARRAY_SIZE(wszInterface) - 1 + CHARS_IN_GUID - 1 + ARRAY_SIZE(wszPSC)];
    APARTMENT *apt;
    struct registered_psclsid *registered_psclsid;
    ACTCTX_SECTION_KEYED_DATA data;
    HRESULT hr;
    REGSAM opposite = (sizeof(void*) > sizeof(int)) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
    BOOL is_wow64;
 
    TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
    apartment_release(apt);
 
    if (!pclsid)
        return E_INVALIDARG;
 
    EnterCriticalSection(&cs_registered_psclsid_list);
 
    LIST_FOR_EACH_ENTRY(registered_psclsid, &registered_psclsid_list, struct registered_psclsid, entry)
        if (IsEqualIID(&registered_psclsid->iid, riid))
        {
            *pclsid = registered_psclsid->clsid;
            LeaveCriticalSection(&cs_registered_psclsid_list);
            return S_OK;
        }
 
    LeaveCriticalSection(&cs_registered_psclsid_list);
 
    data.cbSize = sizeof(data);
    if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION,
                              riid, &data))
    {
        struct ifacepsredirect_data *ifaceps = (struct ifacepsredirect_data*)data.lpData;
        *pclsid = ifaceps->iid;
        return S_OK;
    }
 
    /* Interface\\{string form of riid}\\ProxyStubClsid32 */
    lstrcpyW(path, wszInterface);
    StringFromGUID2(riid, path + ARRAY_SIZE(wszInterface) - 1, CHARS_IN_GUID);
    lstrcpyW(path + ARRAY_SIZE(wszInterface) - 1 + CHARS_IN_GUID - 1, wszPSC);
 
    hr = get_ps_clsid_from_registry(path, 0, pclsid);
    if (FAILED(hr) && (opposite == KEY_WOW64_32KEY ||
                       (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)))
        hr = get_ps_clsid_from_registry(path, opposite, pclsid);
 
    if (hr == S_OK)
        TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
    else
        WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
 
    return hr;
}

Referenced by get_facbuf_for_iid(), implicit_mta_proc(), register_ps_clsid_thread(), test_CoGetPSClsid(), test_CoRegisterPSClsid(), test_marshal_channel_buffer(), test_proxybuffer(), test_stub(), and test_stubbuffer().

CoGetState()

HRESULT WINAPI CoGetState

(

IUnknown **

ppv

)

Definition at line 3819 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    if (!info) return E_OUTOFMEMORY;
 
    *ppv = NULL;
 
    if (info->state)
    {
        IUnknown_AddRef(info->state);
        *ppv = info->state;
        TRACE("apt->state=%p\n", info->state);
    }
 
    return S_OK;
}

CoGetTreatAsClass()

HRESULT WINAPI CoGetTreatAsClass	(	REFCLSID	clsidOld,
		LPCLSID	clsidNew
	)

Definition at line 3959 of file compobj.c.

{
    static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
    HKEY hkey = NULL;
    WCHAR szClsidNew[CHARS_IN_GUID];
    HRESULT res = S_OK;
    LONG len = sizeof(szClsidNew);
 
    TRACE("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
 
    if (!clsidOld || !clsidNew)
        return E_INVALIDARG;
 
    *clsidNew = *clsidOld; /* copy over old value */
 
    res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
    if (FAILED(res))
    {
        res = S_FALSE;
        goto done;
    }
    if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
    {
        res = S_FALSE;
    goto done;
    }
    res = CLSIDFromString(szClsidNew,clsidNew);
    if (FAILED(res))
        ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
done:
    if (hkey) RegCloseKey(hkey);
    return res;
}

Referenced by CoCreateInstanceEx().

CoImpersonateClient()

HRESULT WINAPI CoImpersonateClient

(

void

)

Definition at line 4494 of file compobj.c.

{
    IServerSecurity *pSrvSec;
    HRESULT hr;
 
    TRACE("\n");
 
    hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
    if (SUCCEEDED(hr))
    {
        hr = IServerSecurity_ImpersonateClient(pSrvSec);
        IServerSecurity_Release(pSrvSec);
    }
 
    return hr;
}

CoInitialize()

HRESULT WINAPI CoInitialize

(

LPVOID

lpReserved

)

Definition at line 1964 of file compobj.c.

{
  /*
   * Just delegate to the newer method.
   */
  return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
}

Referenced by _CmdWndProc(), CRecyclerDropTarget::_DoDeleteThreadProc(), CFSDropTarget::_DoDropThreadProc(), ACTION_CreateShortcuts(), AMovieDllRegisterServer2(), bsc_thread(), cache_across_threads_test(), cache_InstallAssembly(), cache_UninstallAssembly(), call_script(), CGuidItemExtractIcon_CreateInstance(), ComInit::ComInit(), cowait_unmarshal_thread(), crash_couninitialize_proc(), CreateSecurityPage(), CreateShortcut(), CreateShortcuts(), DisplayWizard(), DllMain(), DllRegisterServer(), CTipbarCoInitialize::EnsureCoInit(), get_global_interface_proc(), IEWinMain(), init_test(), initialize(), InitIconOverlays(), InstallTypicalNetworkSettings(), LoadShellLinkConsoleInfo(), local_server_proc(), main(), MsiGetShortcutTargetW(), OLEPictureImpl_LoadWICDecoder(), OpenControlPanelItem(), query_prop(), register_filters(), RegisterComCat(), run_script(), RunOnceExProcess(), SHAddToRecentDocs(), SHCreateFromDesktop(), SHFileOperationW(), START_TEST(), test_click_make_new_folder_button(), test_CoCreateInstanceEx(), test_CoGetCallContext(), test_CoGetContextToken(), test_controlevent(), test_DPA_LoadStream(), test_DPA_SaveStream(), test_externalui_message(), test_GetDefaultColumn(), test_GetDefaultSearchGUID(), test_GlobalOptions(), test_iface_ptr(), test_IWinHttpRequest(), test_IWinHttpRequest_Invoke(), test_knownFolders(), test_MsiSetComponentState(), test_OleInitialize_InitCounting(), test_packagecoltypes(), test_printers_folder(), test_properties(), test_PSRefreshPropertySchema(), test_selection(), test_set_clipboard(), test_StreamOnStreamRange(), test_top_level_action(), unregister_filters(), WinMain(), wmain(), and wWinMain().

CoInitializeEx()

HRESULT WINAPI DECLSPEC_HOTPATCH CoInitializeEx	(	LPVOID	lpReserved,
		DWORD	dwCoInit
	)

Definition at line 2002 of file compobj.c.

{
  struct oletls *info = COM_CurrentInfo();
  struct init_spy *cursor;
  HRESULT hr;
 
  TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
 
  if (lpReserved!=NULL)
  {
    ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
  }
 
  /*
   * Check the lock count. If this is the first time going through the initialize
   * process, we have to initialize the libraries.
   *
   * And crank-up that lock count.
   */
  if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
  {
    /*
     * Initialize the various COM libraries and data structures.
     */
    TRACE("() - Initializing the COM libraries\n");
 
    /* we may need to defer this until after apartment initialisation */
    RunningObjectTableImpl_Initialize();
  }
 
  lock_init_spies(info);
  LIST_FOR_EACH_ENTRY(cursor, &info->spies, struct init_spy, entry)
  {
      if (cursor->spy) IInitializeSpy_PreInitialize(cursor->spy, dwCoInit, info->inits);
  }
  unlock_init_spies(info);
 
  hr = enter_apartment( info, dwCoInit );
 
  lock_init_spies(info);
  LIST_FOR_EACH_ENTRY(cursor, &info->spies, struct init_spy, entry)
  {
      if (cursor->spy) hr = IInitializeSpy_PostInitialize(cursor->spy, hr, dwCoInit, info->inits);
  }
  unlock_init_spies(info);
 
  return hr;
}

Referenced by apartment_hostobject_thread(), ChooseFolder(), CoInitialize(), custom_action_server(), custom_client_thread(), DllMain(), download_proc(), dummy_thread_proc(), FileExtractDialogWndProc(), host_object_proc(), ImageView_Main(), Imm32CoInitializeEx(), implicit_mta_unmarshal_proc(), implicit_mta_use_proc(), InitializeSecurity(), is_firewall_enabled(), main_test(), MCIQTZ_mciOpen(), ole_server(), OleInitialize(), parse_config_file(), PullPin_Thread_Main(), RunDlgProc(), CFindFolder::SearchThreadProc(), server(), set_firewall(), SHCoInitializeAnyApartment(), SHLWAPI_ThreadWrapper(), START_TEST(), StartCount(), CSysTray::SysTrayThreadProc(), test_CoWaitForMultipleHandles(), test_IInitializeSpy(), test_IInitializeSpy_register2(), test_IInitializeSpy_switch_apt(), test_implicit_mta(), test_init_spies_proc(), test_MultiThreadApartment_Thread(), test_render_with_multithread(), test_RtlQueryPackageIdentity(), test_shortcut(), test_stub(), test_WICCreateColorTransform_Proxy(), TestClasses(), TestThread(), union_tests(), and WICCreateColorTransform_Proxy().

CoInitializeSecurity()

HRESULT WINAPI CoInitializeSecurity	(	PSECURITY_DESCRIPTOR	pSecDesc,
		LONG	cAuthSvc,
		SOLE_AUTHENTICATION_SERVICE *	asAuthSvc,
		void *	pReserved1,
		DWORD	dwAuthnLevel,
		DWORD	dwImpLevel,
		void *	pReserved2,
		DWORD	dwCapabilities,
		void *	pReserved3
	)

Definition at line 4122 of file compobj.c.

{
  FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
        asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
        dwCapabilities, pReserved3);
  return S_OK;
}

Referenced by InitializeSecurity(), query_prop(), START_TEST(), and StartCount().

CoInitializeWOW()

HRESULT WINAPI CoInitializeWOW	(	DWORD	x,
		DWORD	y
	)

Definition at line 3793 of file compobj.c.

{
    FIXME("(0x%08x,0x%08x),stub!\n",x,y);
    return 0;
}

CoIsHandlerConnected()

BOOL WINAPI CoIsHandlerConnected

(

IUnknown *

pUnk

)

Definition at line 4223 of file compobj.c.

{
    FIXME("%p\n", pUnk);
 
    return TRUE;
}

CoIsOle1Class()

BOOL WINAPI CoIsOle1Class

(

REFCLSID

clsid

)

Definition at line 4093 of file compobj.c.

{
  FIXME("%s\n", debugstr_guid(clsid));
  return FALSE;
}

CoLoadLibrary()

HINSTANCE WINAPI CoLoadLibrary	(	LPOLESTR	lpszLibName,
		BOOL	bAutoFree
	)

Definition at line 3617 of file compobj.c.

{
    TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
 
    return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
}

CoLockObjectExternal()

HRESULT WINAPI CoLockObjectExternal	(	LPUNKNOWN	pUnk,
		BOOL	fLock,
		BOOL	fLastUnlockReleases
	)

Definition at line 3743 of file compobj.c.

{
    struct stub_manager *stubmgr;
    struct apartment *apt;
 
    TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
          pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
 
    stubmgr = get_stub_manager_from_object(apt, pUnk, fLock);
    if (!stubmgr)
    {
        WARN("stub object not found %p\n", pUnk);
        /* Note: native is pretty broken here because it just silently
         * fails, without returning an appropriate error code, making apps
         * think that the object was disconnected, when it actually wasn't */
        apartment_release(apt);
        return S_OK;
    }
 
    if (fLock)
        stub_manager_ext_addref(stubmgr, 1, FALSE);
    else
        stub_manager_ext_release(stubmgr, 1, FALSE, fLastUnlockReleases);
 
    stub_manager_int_release(stubmgr);
    apartment_release(apt);
    return S_OK;
}

Referenced by CoRegisterClassObject(), implicit_mta_proc(), OleNoteObjectVisible(), test_disconnect_stub(), and test_lock_object_external().

COM_GetRegisteredClassObject()

static HRESULT COM_GetRegisteredClassObject ( const struct apartment *  apt, REFCLSID  rclsid, DWORD  dwClsContext, LPUNKNOWN *  ppUnk  )

static

Definition at line 2832 of file compobj.c.

{
  HRESULT hr = S_FALSE;
  RegisteredClass *curClass;
 
  EnterCriticalSection( &csRegisteredClassList );
 
  LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
  {
    /*
     * Check if we have a match on the class ID and context.
     */
    if ((apt->oxid == curClass->apartment_id) &&
        (dwClsContext & curClass->runContext) &&
        IsEqualGUID(&(curClass->classIdentifier), rclsid))
    {
      /*
       * We have a match, return the pointer to the class object.
       */
      *ppUnk = curClass->classObject;
 
      IUnknown_AddRef(curClass->classObject);
 
      hr = S_OK;
      break;
    }
  }
 
  LeaveCriticalSection( &csRegisteredClassList );
 
  return hr;
}

Referenced by CoGetClassObject(), and CoRegisterClassObject().

COM_OpenKeyForAppIdFromCLSID()

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

Definition at line 2480 of file compobj.c.

{
    static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
    static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
    DWORD res;
    WCHAR buf[CHARS_IN_GUID];
    WCHAR keyname[ARRAY_SIZE(szAppIdKey) + CHARS_IN_GUID];
    DWORD size;
    HKEY hkey;
    DWORD type;
    HRESULT hr;
 
    /* read the AppID value under the class's key */
    hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
    if (FAILED(hr))
        return hr;
 
    size = sizeof(buf);
    res = RegQueryValueExW(hkey, szAppId, 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, szAppIdKey);
    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().

COM_OpenKeyForCLSID()

HRESULT COM_OpenKeyForCLSID	(	REFCLSID	clsid,
		LPCWSTR	keyname,
		REGSAM	access,
		HKEY *	subkey
	)

Definition at line 2448 of file compobj.c.

{
    static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
    WCHAR path[CHARS_IN_GUID + ARRAY_SIZE(wszCLSIDSlash) - 1];
    LONG res;
    HKEY key;
 
    lstrcpyW(path, wszCLSIDSlash);
    StringFromGUID2(clsid, path + lstrlenW(wszCLSIDSlash), CHARS_IN_GUID);
    res = open_classes_key(HKEY_CLASSES_ROOT, path, keyname ? KEY_READ : 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 CoGetClassObject(), CoGetTreatAsClass(), COM_OpenKeyForAppIdFromCLSID(), CoTreatAsClass(), create_server(), Handler_DllGetClassObject(), OleGetAutoConvert(), OleRegEnumVerbs(), OleRegGetMiscStatus(), OleRegGetUserType(), OleSetAutoConvert(), and ProgIDFromCLSID().

COM_PeekMessage()

static BOOL COM_PeekMessage ( struct apartment *  apt, MSG *  msg  )

static

Definition at line 4544 of file compobj.c.

{
    /* first try to retrieve messages for incoming COM calls to the apartment window */
    return (apt->win && PeekMessageW(msg, apt->win, 0, 0, PM_REMOVE|PM_NOYIELD)) ||
           /* next retrieve other messages necessary for the app to remain responsive */
           PeekMessageW(msg, NULL, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE|PM_NOYIELD) ||
           PeekMessageW(msg, NULL, 0, 0, PM_QS_PAINT|PM_QS_SENDMESSAGE|PM_REMOVE|PM_NOYIELD);
}

Referenced by CoWaitForMultipleHandles().

COM_RevokeAllClasses()

static void COM_RevokeAllClasses ( const struct apartment *  apt )

static

Definition at line 764 of file compobj.c.

{
  RegisteredClass *curClass, *cursor;
 
  EnterCriticalSection( &csRegisteredClassList );
 
  LIST_FOR_EACH_ENTRY_SAFE(curClass, cursor, &RegisteredClassList, RegisteredClass, entry)
  {
    if (curClass->apartment_id == apt->oxid)
      COM_RevokeRegisteredClassObject(curClass);
  }
 
  LeaveCriticalSection( &csRegisteredClassList );
}

Referenced by apartment_release().

COM_RevokeRegisteredClassObject()

static void COM_RevokeRegisteredClassObject ( RegisteredClass *  curClass )

static

Definition at line 753 of file compobj.c.

{
    list_remove(&curClass->entry);
 
    if (curClass->runContext & CLSCTX_LOCAL_SERVER)
        RPC_StopLocalServer(curClass->RpcRegistration);
 
    IUnknown_Release(curClass->classObject);
    HeapFree(GetProcessHeap(), 0, curClass);
}

Referenced by COM_RevokeAllClasses(), and CoRevokeClassObject().

COM_TlsDestroy()

static void COM_TlsDestroy ( void  )

static

Definition at line 1739 of file compobj.c.

{
    struct oletls *info = NtCurrentTeb()->ReservedForOle;
    if (info)
    {
        struct init_spy *cursor, *cursor2;
 
        if (info->apt) apartment_release(info->apt);
        if (info->errorinfo) IErrorInfo_Release(info->errorinfo);
        if (info->state) IUnknown_Release(info->state);
 
        LIST_FOR_EACH_ENTRY_SAFE(cursor, cursor2, &info->spies, struct init_spy, entry)
        {
            list_remove(&cursor->entry);
            if (cursor->spy) IInitializeSpy_Release(cursor->spy);
            heap_free(cursor);
        }
 
        if (info->context_token) IObjContext_Release(info->context_token);
 
        HeapFree(GetProcessHeap(), 0, info);
        NtCurrentTeb()->ReservedForOle = NULL;
    }
}

Referenced by DllMain().

COMPOBJ_DllList_Add()

static HRESULT COMPOBJ_DllList_Add ( LPCWSTR  library_name, OpenDll **  ret  )

static

Definition at line 508 of file compobj.c.

{
    OpenDll *entry;
    int len;
    HRESULT hr = S_OK;
    HANDLE hLibrary;
    DllCanUnloadNowFunc DllCanUnloadNow;
    DllGetClassObjectFunc DllGetClassObject;
 
    TRACE("%s\n", debugstr_w(library_name));
 
    *ret = COMPOBJ_DllList_Get(library_name);
    if (*ret) return S_OK;
 
    /* do this outside the csOpenDllList to avoid creating a lock 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 = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
    /* Note: failing to find DllCanUnloadNow is not a failure */
    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( &csOpenDllList );
 
    *ret = COMPOBJ_DllList_Get(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 = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
        if (entry)
            entry->library_name = HeapAlloc(GetProcessHeap(), 0, (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(&openDllList, &entry->entry);
            *ret = entry;
        }
        else
        {
            HeapFree(GetProcessHeap(), 0, entry);
            hr = E_OUTOFMEMORY;
            FreeLibrary(hLibrary);
        }
    }
 
    LeaveCriticalSection( &csOpenDllList );
 
    return hr;
}

Referenced by apartment_getclassobject().

COMPOBJ_DllList_Free()

static void COMPOBJ_DllList_Free ( void  )

static

Definition at line 600 of file compobj.c.

{
    OpenDll *entry, *cursor2;
    EnterCriticalSection(&csOpenDllList);
    LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &openDllList, OpenDll, entry)
    {
        list_remove(&entry->entry);
 
        HeapFree(GetProcessHeap(), 0, entry->library_name);
        HeapFree(GetProcessHeap(), 0, entry);
    }
    LeaveCriticalSection(&csOpenDllList);
    DeleteCriticalSection(&csOpenDllList);
}

Referenced by DllMain().

COMPOBJ_DllList_Get()

static OpenDll * COMPOBJ_DllList_Get ( LPCWSTR  library_name )

static

Definition at line 489 of file compobj.c.

{
    OpenDll *ptr;
    OpenDll *ret = NULL;
    EnterCriticalSection(&csOpenDllList);
    LIST_FOR_EACH_ENTRY(ptr, &openDllList, OpenDll, entry)
    {
        if (!wcsicmp(library_name, ptr->library_name) &&
            (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroy if == 1 */)
        {
            ret = ptr;
            break;
        }
    }
    LeaveCriticalSection(&csOpenDllList);
    return ret;
}

Referenced by COMPOBJ_DllList_Add().

COMPOBJ_DllList_ReleaseRef()

static void COMPOBJ_DllList_ReleaseRef ( OpenDll *  entry, BOOL  free_entry  )

static

Definition at line 583 of file compobj.c.

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

Referenced by apartment_freeunusedlibraries(), and apartment_release().

Context_AddRef()

static ULONG Context_AddRef ( Context *  This )

static

Definition at line 4845 of file compobj.c.

{
    return InterlockedIncrement(&This->refs);
}

Referenced by Context_CC_AddRef(), Context_CTI_AddRef(), and Context_OC_AddRef().

Context_CC_AddRef()

static ULONG WINAPI Context_CC_AddRef ( IContextCallback *  iface )

static

Definition at line 4944 of file compobj.c.

{
    Context *This = impl_from_IContextCallback(iface);
    return Context_AddRef(This);
}

Context_CC_ContextCallback()

static HRESULT WINAPI Context_CC_ContextCallback ( IContextCallback *  iface, PFNCONTEXTCALL  pCallback, ComCallData *  param, REFIID  riid, int  method, IUnknown *  punk  )

static

Definition at line 4956 of file compobj.c.

{
    Context *This = impl_from_IContextCallback(iface);
 
    FIXME("(%p/%p)->(%p, %p, %s, %d, %p)\n", This, iface, pCallback, param, debugstr_guid(riid), method, punk);
    return E_NOTIMPL;
}

Context_CC_QueryInterface()

static HRESULT WINAPI Context_CC_QueryInterface ( IContextCallback *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 4938 of file compobj.c.

{
    Context *This = impl_from_IContextCallback(iface);
    return Context_QueryInterface(This, riid, ppv);
}

Context_CC_Release()

static ULONG WINAPI Context_CC_Release ( IContextCallback *  iface )

static

Definition at line 4950 of file compobj.c.

{
    Context *This = impl_from_IContextCallback(iface);
    return Context_Release(This);
}

Context_CTI_AddRef()

static ULONG WINAPI Context_CTI_AddRef ( IComThreadingInfo *  iface )

static

Definition at line 4869 of file compobj.c.

{
    Context *This = impl_from_IComThreadingInfo(iface);
    return Context_AddRef(This);
}

Context_CTI_GetCurrentApartmentType()

static HRESULT WINAPI Context_CTI_GetCurrentApartmentType ( IComThreadingInfo *  iface, APTTYPE *  apttype  )

static

Definition at line 4881 of file compobj.c.

{
    APTTYPEQUALIFIER qualifier;
 
    TRACE("(%p)\n", apttype);
 
    return CoGetApartmentType(apttype, &qualifier);
}

Context_CTI_GetCurrentLogicalThreadId()

static HRESULT WINAPI Context_CTI_GetCurrentLogicalThreadId ( IComThreadingInfo *  iface, GUID *  logical_thread_id  )

static

Definition at line 4915 of file compobj.c.

{
    TRACE("(%p)\n", logical_thread_id);
    return CoGetCurrentLogicalThreadId(logical_thread_id);
}

Context_CTI_GetCurrentThreadType()

static HRESULT WINAPI Context_CTI_GetCurrentThreadType ( IComThreadingInfo *  iface, THDTYPE *  thdtype  )

static

Definition at line 4890 of file compobj.c.

{
    APTTYPEQUALIFIER qualifier;
    APTTYPE apttype;
    HRESULT hr;
 
    hr = CoGetApartmentType(&apttype, &qualifier);
    if (FAILED(hr))
        return hr;
 
    TRACE("(%p)\n", thdtype);
 
    switch (apttype)
    {
    case APTTYPE_STA:
    case APTTYPE_MAINSTA:
        *thdtype = THDTYPE_PROCESSMESSAGES;
        break;
    default:
        *thdtype = THDTYPE_BLOCKMESSAGES;
        break;
    }
    return S_OK;
}

Context_CTI_QueryInterface()

static HRESULT WINAPI Context_CTI_QueryInterface ( IComThreadingInfo *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 4863 of file compobj.c.

{
    Context *This = impl_from_IComThreadingInfo(iface);
    return Context_QueryInterface(This, riid, ppv);
}

Context_CTI_Release()

static ULONG WINAPI Context_CTI_Release ( IComThreadingInfo *  iface )

static

Definition at line 4875 of file compobj.c.

{
    Context *This = impl_from_IComThreadingInfo(iface);
    return Context_Release(This);
}

Context_CTI_SetCurrentLogicalThreadId()

static HRESULT WINAPI Context_CTI_SetCurrentLogicalThreadId ( IComThreadingInfo *  iface, REFGUID  logical_thread_id  )

static

Definition at line 4921 of file compobj.c.

{
    FIXME("(%s): stub\n", debugstr_guid(logical_thread_id));
    return E_NOTIMPL;
}

Context_OC_AddRef()

static ULONG WINAPI Context_OC_AddRef ( IObjContext *  iface )

static

Definition at line 4979 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    return Context_AddRef(This);
}

Context_OC_EnumContextProps()

static HRESULT WINAPI Context_OC_EnumContextProps ( IObjContext *  iface, IEnumContextProps **  props  )

static

Definition at line 5015 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
 
    FIXME("(%p/%p)->(%p)\n", This, iface, props);
    return E_NOTIMPL;
}

Context_OC_GetProperty()

static HRESULT WINAPI Context_OC_GetProperty ( IObjContext *  iface, REFGUID  propid, CPFLAGS *  flags, IUnknown **  punk  )

static

Definition at line 5007 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
 
    FIXME("(%p/%p)->(%s, %p, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
    return E_NOTIMPL;
}

Context_OC_QueryInterface()

static HRESULT WINAPI Context_OC_QueryInterface ( IObjContext *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 4973 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    return Context_QueryInterface(This, riid, ppv);
}

Context_OC_Release()

static ULONG WINAPI Context_OC_Release ( IObjContext *  iface )

static

Definition at line 4985 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    return Context_Release(This);
}

Context_OC_RemoveProperty()

static HRESULT WINAPI Context_OC_RemoveProperty ( IObjContext *  iface, REFGUID  propid  )

static

Definition at line 4999 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
 
    FIXME("(%p/%p)->(%s)\n", This, iface, debugstr_guid(propid));
    return E_NOTIMPL;
}

Context_OC_Reserved1()

static void WINAPI Context_OC_Reserved1 ( IObjContext *  iface )

static

Definition at line 5023 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved2()

static void WINAPI Context_OC_Reserved2 ( IObjContext *  iface )

static

Definition at line 5029 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved3()

static void WINAPI Context_OC_Reserved3 ( IObjContext *  iface )

static

Definition at line 5035 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved4()

static void WINAPI Context_OC_Reserved4 ( IObjContext *  iface )

static

Definition at line 5041 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved5()

static void WINAPI Context_OC_Reserved5 ( IObjContext *  iface )

static

Definition at line 5047 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved6()

static void WINAPI Context_OC_Reserved6 ( IObjContext *  iface )

static

Definition at line 5053 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_Reserved7()

static void WINAPI Context_OC_Reserved7 ( IObjContext *  iface )

static

Definition at line 5059 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
    FIXME("(%p/%p)\n", This, iface);
}

Context_OC_SetProperty()

static HRESULT WINAPI Context_OC_SetProperty ( IObjContext *  iface, REFGUID  propid, CPFLAGS  flags, IUnknown *  punk  )

static

Definition at line 4991 of file compobj.c.

{
    Context *This = impl_from_IObjContext(iface);
 
    FIXME("(%p/%p)->(%s, %x, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
    return E_NOTIMPL;
}

Context_QueryInterface()

static HRESULT Context_QueryInterface ( Context *  iface, REFIID  riid, LPVOID *  ppv  )

static

Definition at line 4817 of file compobj.c.

{
    *ppv = NULL;
 
    if (IsEqualIID(riid, &IID_IComThreadingInfo) ||
        IsEqualIID(riid, &IID_IUnknown))
    {
        *ppv = &iface->IComThreadingInfo_iface;
    }
    else if (IsEqualIID(riid, &IID_IContextCallback))
    {
        *ppv = &iface->IContextCallback_iface;
    }
    else if (IsEqualIID(riid, &IID_IObjContext))
    {
        *ppv = &iface->IObjContext_iface;
    }
 
    if (*ppv)
    {
        IUnknown_AddRef((IUnknown*)*ppv);
        return S_OK;
    }
 
    FIXME("interface not implemented %s\n", debugstr_guid(riid));
    return E_NOINTERFACE;
}

Referenced by Context_CC_QueryInterface(), Context_CTI_QueryInterface(), and Context_OC_QueryInterface().

Context_Release()

static ULONG Context_Release ( Context *  This )

static

Definition at line 4850 of file compobj.c.

{
    /* Context instance is initially created with CoGetContextToken() with refcount set to 0,
       releasing context while refcount is at 0 destroys it. */
    if (!This->refs)
    {
        HeapFree(GetProcessHeap(), 0, This);
        return 0;
    }
 
    return InterlockedDecrement(&This->refs);
}

Referenced by Context_CC_Release(), Context_CTI_Release(), and Context_OC_Release().

CoQueryClientBlanket()

HRESULT WINAPI CoQueryClientBlanket	(	DWORD *	pAuthnSvc,
		DWORD *	pAuthzSvc,
		OLECHAR **	pServerPrincName,
		DWORD *	pAuthnLevel,
		DWORD *	pImpLevel,
		RPC_AUTHZ_HANDLE *	pPrivs,
		DWORD *	pCapabilities
	)

Definition at line 4445 of file compobj.c.

{
    IServerSecurity *pSrvSec;
    HRESULT hr;
 
    TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
        pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel,
        pPrivs, pCapabilities);
 
    hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
    if (SUCCEEDED(hr))
    {
        hr = IServerSecurity_QueryBlanket(
            pSrvSec, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel,
            pImpLevel, pPrivs, pCapabilities);
        IServerSecurity_Release(pSrvSec);
    }
 
    return hr;
}

CoQueryProxyBlanket()

HRESULT WINAPI CoQueryProxyBlanket	(	IUnknown *	pProxy,
		DWORD *	pAuthnSvc,
		DWORD *	pAuthzSvc,
		OLECHAR **	ppServerPrincName,
		DWORD *	pAuthnLevel,
		DWORD *	pImpLevel,
		void **	ppAuthInfo,
		DWORD *	pCapabilities
	)

Definition at line 4262 of file compobj.c.

{
    IClientSecurity *pCliSec;
    HRESULT hr;
 
    TRACE("%p\n", pProxy);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
    if (SUCCEEDED(hr))
    {
        hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
                                          pAuthzSvc, ppServerPrincName,
                                          pAuthnLevel, pImpLevel, ppAuthInfo,
                                          pCapabilities);
        IClientSecurity_Release(pCliSec);
    }
 
    if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
    return hr;
}

CoRegisterChannelHook()

HRESULT WINAPI CoRegisterChannelHook	(	REFGUID	guidExtension,
		IChannelHook *	pChannelHook
	)

Definition at line 4787 of file compobj.c.

{
    TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook);
 
    return RPC_RegisterChannelHook(guidExtension, pChannelHook);
}

Referenced by test_channel_hook().

CoRegisterClassObject()

HRESULT WINAPI CoRegisterClassObject	(	REFCLSID	rclsid,
		LPUNKNOWN	pUnk,
		DWORD	dwClsContext,
		DWORD	flags,
		LPDWORD	lpdwRegister
	)

Definition at line 2897 of file compobj.c.

{
  static LONG next_cookie;
  RegisteredClass* newClass;
  LPUNKNOWN        foundObject;
  HRESULT          hr;
  APARTMENT *apt;
 
  TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
    debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
 
  if ( (lpdwRegister==0) || (pUnk==0) )
    return E_INVALIDARG;
 
  if (!(apt = apartment_get_current_or_mta()))
  {
      ERR("COM was not initialized\n");
      return CO_E_NOTINITIALIZED;
  }
 
  *lpdwRegister = 0;
 
  /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
   * differentiates the flag from REGCLS_MULTI_SEPARATE. */
  if (flags & REGCLS_MULTIPLEUSE)
    dwClsContext |= CLSCTX_INPROC_SERVER;
 
  /*
   * First, check if the class is already registered.
   * If it is, this should cause an error.
   */
  hr = COM_GetRegisteredClassObject(apt, rclsid, dwClsContext, &foundObject);
  if (hr == S_OK) {
    if (flags & REGCLS_MULTIPLEUSE) {
      if (dwClsContext & CLSCTX_LOCAL_SERVER)
        hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
      IUnknown_Release(foundObject);
      apartment_release(apt);
      return hr;
    }
    IUnknown_Release(foundObject);
    ERR("object already registered for class %s\n", debugstr_guid(rclsid));
    apartment_release(apt);
    return CO_E_OBJISREG;
  }
 
  newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
  if ( newClass == NULL )
  {
    apartment_release(apt);
    return E_OUTOFMEMORY;
  }
 
  newClass->classIdentifier = *rclsid;
  newClass->apartment_id    = apt->oxid;
  newClass->runContext      = dwClsContext;
  newClass->connectFlags    = flags;
  newClass->RpcRegistration = NULL;
 
  if (!(newClass->dwCookie = InterlockedIncrement( &next_cookie )))
      newClass->dwCookie = InterlockedIncrement( &next_cookie );
 
  /*
   * Since we're making a copy of the object pointer, we have to increase its
   * reference count.
   */
  newClass->classObject     = pUnk;
  IUnknown_AddRef(newClass->classObject);
 
  EnterCriticalSection( &csRegisteredClassList );
  list_add_tail(&RegisteredClassList, &newClass->entry);
  LeaveCriticalSection( &csRegisteredClassList );
 
  *lpdwRegister = newClass->dwCookie;
 
  if (dwClsContext & CLSCTX_LOCAL_SERVER) {
      IStream *marshal_stream;
 
      hr = get_local_server_stream(apt, &marshal_stream);
      if(FAILED(hr))
      {
          apartment_release(apt);
          return hr;
      }
 
      hr = RPC_StartLocalServer(&newClass->classIdentifier,
                                marshal_stream,
                                flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
                                &newClass->RpcRegistration);
      IStream_Release(marshal_stream);
  }
  apartment_release(apt);
  return S_OK;
}

Referenced by ATL::AtlComModuleRegisterClassObjects(), AtlModuleRegisterClassObjects(), host_object_proc(), IEWinMain(), implicit_mta_proc(), local_server_proc(), ole_server(), register_activex(), register_class_object_thread(), register_script_engine(), ATL::_ATL_OBJMAP_ENTRY30::RegisterClassObject(), RegisterTextService(), START_TEST(), StartCount(), test_BindToObject(), test_CoCreateInstanceEx(), test_CoGetInstanceFromFile(), test_CoRegisterClassObject(), test_CoRegisterPSClsid(), test_default_handler(), test_default_handler_run(), test_delegated_methods(), test_local_server(), test_marshal_channel_buffer(), test_MkParseDisplayName(), test_register_local_server(), test_registered_object_thread_affinity(), and test_render_filter_priority().

CoRegisterInitializeSpy()

HRESULT WINAPI CoRegisterInitializeSpy	(	IInitializeSpy *	spy,
		ULARGE_INTEGER *	cookie
	)

Definition at line 1832 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    struct init_spy *entry;
    unsigned int id;
    HRESULT hr;
 
    TRACE("(%p, %p)\n", spy, cookie);
 
    if (!spy || !cookie || !info)
    {
        if (!info)
            WARN("Could not allocate tls\n");
        return E_INVALIDARG;
    }
 
    hr = IInitializeSpy_QueryInterface(spy, &IID_IInitializeSpy, (void **)&spy);
    if (FAILED(hr))
        return hr;
 
    entry = heap_alloc(sizeof(*entry));
    if (!entry)
    {
        IInitializeSpy_Release(spy);
        return E_OUTOFMEMORY;
    }
 
    entry->spy = spy;
 
    id = 0;
    while (get_spy_entry(info, id) != NULL)
    {
        id++;
    }
 
    entry->id = id;
    list_add_head(&info->spies, &entry->entry);
 
    cookie->s.HighPart = GetCurrentThreadId();
    cookie->s.LowPart = entry->id;
 
    return S_OK;
}

Referenced by Imm32CoRegisterInitializeSpy(), and test_IInitializeSpy().

CoRegisterMessageFilter()

HRESULT WINAPI CoRegisterMessageFilter	(	LPMESSAGEFILTER	lpMessageFilter,
		LPMESSAGEFILTER *	lplpMessageFilter
	)

Definition at line 4046 of file compobj.c.

{
    struct apartment *apt;
    IMessageFilter *lpOldMessageFilter;
 
    TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
 
    apt = COM_CurrentApt();
 
    /* can't set a message filter in a multi-threaded apartment */
    if (!apt || apt->multi_threaded)
    {
        WARN("can't set message filter in MTA or uninitialized apt\n");
        return CO_E_NOT_SUPPORTED;
    }
 
    if (lpMessageFilter)
        IMessageFilter_AddRef(lpMessageFilter);
 
    EnterCriticalSection(&apt->cs);
 
    lpOldMessageFilter = apt->filter;
    apt->filter = lpMessageFilter;
 
    LeaveCriticalSection(&apt->cs);
 
    if (lplpMessageFilter)
        *lplpMessageFilter = lpOldMessageFilter;
    else if (lpOldMessageFilter)
        IMessageFilter_Release(lpOldMessageFilter);
 
    return S_OK;
}

Referenced by host_object_proc(), implicit_mta_proc(), test_channel_hook(), test_CoRegisterMessageFilter(), test_CoWaitForMultipleHandles_thread(), and test_message_filter().

CoRegisterPSClsid()

HRESULT WINAPI CoRegisterPSClsid	(	REFIID	riid,
		REFCLSID	rclsid
	)

Definition at line 2778 of file compobj.c.

{
    APARTMENT *apt;
    struct registered_psclsid *registered_psclsid;
 
    TRACE("(%s, %s)\n", debugstr_guid(riid), debugstr_guid(rclsid));
 
    if (!(apt = apartment_get_current_or_mta()))
    {
        ERR("apartment not initialised\n");
        return CO_E_NOTINITIALIZED;
    }
    apartment_release(apt);
 
    EnterCriticalSection(&cs_registered_psclsid_list);
 
    LIST_FOR_EACH_ENTRY(registered_psclsid, &registered_psclsid_list, struct registered_psclsid, entry)
        if (IsEqualIID(&registered_psclsid->iid, riid))
        {
            registered_psclsid->clsid = *rclsid;
            LeaveCriticalSection(&cs_registered_psclsid_list);
            return S_OK;
        }
 
    registered_psclsid = HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid));
    if (!registered_psclsid)
    {
        LeaveCriticalSection(&cs_registered_psclsid_list);
        return E_OUTOFMEMORY;
    }
 
    registered_psclsid->iid = *riid;
    registered_psclsid->clsid = *rclsid;
    list_add_head(&registered_psclsid_list, &registered_psclsid->entry);
 
    LeaveCriticalSection(&cs_registered_psclsid_list);
 
    return S_OK;
}

Referenced by implicit_mta_proc(), local_server_proc(), register_ps_clsid_thread(), test_CoGetPSClsid(), test_CoRegisterPSClsid(), test_delegated_methods(), test_marshal_channel_buffer(), and test_NdrDllGetClassObject().

CoRegisterSurrogate()

HRESULT WINAPI CoRegisterSurrogate

(

ISurrogate *

surrogate

)

Definition at line 5259 of file compobj.c.

{
    FIXME("(%p): stub\n", surrogate);
 
    return E_NOTIMPL;
}

CoRegisterSurrogateEx()

HRESULT WINAPI CoRegisterSurrogateEx	(	REFGUID	guid,
		void *	reserved
	)

Definition at line 5269 of file compobj.c.

{
    FIXME("(%s %p): stub\n", debugstr_guid(guid), reserved);
 
    return E_NOTIMPL;
}

CoReleaseServerProcess()

ULONG WINAPI CoReleaseServerProcess

(

void

)

Definition at line 4193 of file compobj.c.

{
    ULONG refs;
 
    TRACE("\n");
 
    EnterCriticalSection(&csRegisteredClassList);
 
    refs = --s_COMServerProcessReferences;
    /* FIXME: if (!refs) COM_SuspendClassObjects(); */
 
    LeaveCriticalSection(&csRegisteredClassList);
 
    TRACE("refs after: %d\n", refs);
 
    return refs;
}

Referenced by ATL::CAtlExeModuleT< T >::Unlock(), and UnlockModuleOOP().

CoResumeClassObjects()

HRESULT WINAPI CoResumeClassObjects

(

void

)

Definition at line 3288 of file compobj.c.

{
       FIXME("stub\n");
    return S_OK;
}

Referenced by test_local_server().

CoRevertToSelf()

HRESULT WINAPI CoRevertToSelf

(

void

)

Definition at line 4527 of file compobj.c.

{
    IServerSecurity *pSrvSec;
    HRESULT hr;
 
    TRACE("\n");
 
    hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
    if (SUCCEEDED(hr))
    {
        hr = IServerSecurity_RevertToSelf(pSrvSec);
        IServerSecurity_Release(pSrvSec);
    }
 
    return hr;
}

CoRevokeClassObject()

HRESULT WINAPI DECLSPEC_HOTPATCH CoRevokeClassObject

(

DWORD

dwRegister

)

Definition at line 1086 of file compobj.c.

{
  HRESULT hr = E_INVALIDARG;
  RegisteredClass *curClass;
  APARTMENT *apt;
 
  TRACE("(%08x)\n",dwRegister);
 
  if (!(apt = apartment_get_current_or_mta()))
  {
    ERR("COM was not initialized\n");
    return CO_E_NOTINITIALIZED;
  }
 
  EnterCriticalSection( &csRegisteredClassList );
 
  LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
  {
    /*
     * Check if we have a match on the cookie.
     */
    if (curClass->dwCookie == dwRegister)
    {
      if (curClass->apartment_id == apt->oxid)
      {
          COM_RevokeRegisteredClassObject(curClass);
          hr = S_OK;
      }
      else
      {
          ERR("called from wrong apartment, should be called from %s\n",
              wine_dbgstr_longlong(curClass->apartment_id));
          hr = RPC_E_WRONG_THREAD;
      }
      break;
    }
  }
 
  LeaveCriticalSection( &csRegisteredClassList );
  apartment_release(apt);
  return hr;
}

Referenced by ATL::AtlComModuleRevokeClassObjects(), IEWinMain(), implicit_mta_proc(), local_server_proc(), ole_server(), revoke_class_object_thread(), ATL::_ATL_OBJMAP_ENTRY30::RevokeClassObject(), START_TEST(), test_BindToObject(), test_CoCreateInstanceEx(), test_CoGetInstanceFromFile(), test_CoRegisterClassObject(), test_CoRegisterPSClsid(), test_default_handler(), test_default_handler_run(), test_delegated_methods(), test_local_server(), test_marshal_channel_buffer(), test_MkParseDisplayName(), test_register_local_server(), test_registered_object_thread_affinity(), test_render_filter_priority(), and UnregisterTextService().

CoRevokeInitializeSpy()

HRESULT WINAPI CoRevokeInitializeSpy

(

ULARGE_INTEGER

cookie

)

Definition at line 1891 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    struct init_spy *spy;
 
    TRACE("(%s)\n", wine_dbgstr_longlong(cookie.QuadPart));
 
    if (!info || cookie.s.HighPart != GetCurrentThreadId())
        return E_INVALIDARG;
 
    if (!(spy = get_spy_entry(info, cookie.s.LowPart))) return E_INVALIDARG;
 
    IInitializeSpy_Release(spy->spy);
    spy->spy = NULL;
    if (!info->spies_lock)
    {
        list_remove(&spy->entry);
        heap_free(spy);
    }
    return S_OK;
}

Referenced by Imm32CoRevokeInitializeSpy(), test_IInitializeSpy(), test_init_spies_proc(), and testinitialize_PreUninitialize().

CoSetProxyBlanket()

HRESULT WINAPI CoSetProxyBlanket	(	IUnknown *	pProxy,
		DWORD	AuthnSvc,
		DWORD	AuthzSvc,
		OLECHAR *	pServerPrincName,
		DWORD	AuthnLevel,
		DWORD	ImpLevel,
		void *	pAuthInfo,
		DWORD	Capabilities
	)

Definition at line 4307 of file compobj.c.

{
    IClientSecurity *pCliSec;
    HRESULT hr;
 
    TRACE("%p\n", pProxy);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
    if (SUCCEEDED(hr))
    {
        hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
                                        AuthzSvc, pServerPrincName,
                                        AuthnLevel, ImpLevel, pAuthInfo,
                                        Capabilities);
        IClientSecurity_Release(pCliSec);
    }
 
    if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
    return hr;
}

Referenced by START_TEST().

CoSetState()

HRESULT WINAPI CoSetState

(

IUnknown *

pv

)

Definition at line 3851 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
    if (!info) return E_OUTOFMEMORY;
 
    if (pv) IUnknown_AddRef(pv);
 
    if (info->state)
    {
        TRACE("-- release %p now\n", info->state);
        IUnknown_Release(info->state);
    }
 
    info->state = pv;
 
    return S_OK;
}

CoSuspendClassObjects()

HRESULT WINAPI CoSuspendClassObjects

(

void

)

Definition at line 4144 of file compobj.c.

{
    FIXME("\n");
    return S_OK;
}

CoSwitchCallContext()

HRESULT WINAPI CoSwitchCallContext	(	IUnknown *	pObject,
		IUnknown **	ppOldObject
	)

Definition at line 4408 of file compobj.c.

{
    struct oletls *info = COM_CurrentInfo();
 
    TRACE("(%p, %p)\n", pObject, ppOldObject);
 
    if (!info)
        return E_OUTOFMEMORY;
 
    *ppOldObject = info->call_state;
    info->call_state = pObject; /* CoSwitchCallContext does not addref nor release objects */
 
    return S_OK;
}

CoTreatAsClass()

HRESULT WINAPI CoTreatAsClass	(	REFCLSID	clsidOld,
		REFCLSID	clsidNew
	)

Definition at line 3886 of file compobj.c.

{
    static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
    static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
    HKEY hkey = NULL;
    WCHAR szClsidNew[CHARS_IN_GUID];
    HRESULT res = S_OK;
    WCHAR auto_treat_as[CHARS_IN_GUID];
    LONG auto_treat_as_size = sizeof(auto_treat_as);
    CLSID id;
 
    res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
    if (FAILED(res))
        goto done;
 
    if (IsEqualGUID( clsidOld, clsidNew ))
    {
       if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
           CLSIDFromString(auto_treat_as, &id) == S_OK)
       {
           if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
           {
               res = REGDB_E_WRITEREGDB;
               goto done;
           }
       }
       else
       {
           if(RegDeleteKeyW(hkey, wszTreatAs))
               res = REGDB_E_WRITEREGDB;
           goto done;
       }
    }
    else
    {
        if(IsEqualGUID(clsidNew, &CLSID_NULL)){
           RegDeleteKeyW(hkey, wszTreatAs);
        }else{
            if(!StringFromGUID2(clsidNew, szClsidNew, ARRAY_SIZE(szClsidNew))){
                WARN("StringFromGUID2 failed\n");
                res = E_FAIL;
                goto done;
            }
 
            if(RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)) != ERROR_SUCCESS){
                WARN("RegSetValue failed\n");
                res = REGDB_E_WRITEREGDB;
                goto done;
            }
        }
    }
 
done:
    if (hkey) RegCloseKey(hkey);
    return res;
}

CoUninitialize()

void WINAPI DECLSPEC_HOTPATCH CoUninitialize

(

void

)

Definition at line 2067 of file compobj.c.

{
  struct oletls * info = COM_CurrentInfo();
  struct init_spy *cursor, *next;
  LONG lCOMRefCnt;
 
  TRACE("()\n");
 
  /* will only happen on OOM */
  if (!info) return;
 
  lock_init_spies(info);
  LIST_FOR_EACH_ENTRY_SAFE(cursor, next, &info->spies, struct init_spy, entry)
  {
      if (cursor->spy) IInitializeSpy_PreUninitialize(cursor->spy, info->inits);
  }
  unlock_init_spies(info);
 
  /* sanity check */
  if (!info->inits)
  {
      ERR("Mismatched CoUninitialize\n");
 
      lock_init_spies(info);
      LIST_FOR_EACH_ENTRY_SAFE(cursor, next, &info->spies, struct init_spy, entry)
      {
          if (cursor->spy) IInitializeSpy_PostUninitialize(cursor->spy, info->inits);
      }
      unlock_init_spies(info);
 
      return;
  }
 
  leave_apartment( info );
 
  /*
   * Decrease the reference count.
   * If we are back to 0 locks on the COM library, make sure we free
   * all the associated data structures.
   */
  lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
  if (lCOMRefCnt==1)
  {
    TRACE("() - Releasing the COM libraries\n");
 
    revoke_registered_psclsids();
    RunningObjectTableImpl_UnInitialize();
  }
  else if (lCOMRefCnt<1) {
    ERR( "CoUninitialize() - not CoInitialized.\n" );
    InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
  }
 
  lock_init_spies(info);
  LIST_FOR_EACH_ENTRY(cursor, &info->spies, struct init_spy, entry)
  {
      if (cursor->spy) IInitializeSpy_PostUninitialize(cursor->spy, info->inits);
  }
  unlock_init_spies(info);
}

Referenced by _CmdWndProc(), CRecyclerDropTarget::_DoDeleteThreadProc(), CFSDropTarget::_DoDropThreadProc(), ACTION_CreateShortcuts(), AMovieDllRegisterServer2(), apartment_hostobject_thread(), bad_thread_proc(), bsc_thread(), cache_across_threads_test(), cache_InstallAssembly(), cache_UninstallAssembly(), call_script(), ChooseFolder(), cleanup(), cleanup_test(), CTipbarCoInitialize::CoUninit(), cowait_unmarshal_thread(), crash_couninitialize_proc(), CreateSecurityPage(), CreateShortcut(), CreateShortcuts(), custom_action_server(), custom_client_thread(), DestroySecurityPage(), DisplayWizard(), DllMain(), DllRegisterServer(), download_proc(), dummy_thread_proc(), duo_marshal_thread_proc(), FileExtractDialogWndProc(), get_class_object_proxy_thread(), get_class_object_thread(), get_global_interface_proc(), host_object_proc(), IEWinMain(), ImageView_Main(), Imm32CoUninitialize(), implicit_mta_unmarshal_proc(), implicit_mta_use_proc(), InstallTypicalNetworkSettings(), is_firewall_enabled(), LoadShellLinkConsoleInfo(), local_server_GetClassID(), local_server_proc(), main(), main_test(), MCIQTZ_mciClose(), MCIQTZ_mciOpen(), MsiGetShortcutTargetW(), ole_server(), OLEPictureImpl_LoadWICDecoder(), OleUninitialize(), OpenControlPanelItem(), parse_config_file(), PullPin_Thread_Stop(), query_prop(), register_class_object_thread(), register_filters(), register_ps_clsid_thread(), RegisterComCat(), revoke_class_object_thread(), run_script(), RunDlgProc(), RunOnceExProcess(), CFindFolder::SearchThreadProc(), server(), ServiceMain(), set_firewall(), SHAddToRecentDocs(), SHCreateFromDesktop(), ShellExecuteExW(), SHFileOperationW(), SHGetNameAndFlagsW(), SHLWAPI_ThreadWrapper(), START_TEST(), CSysTray::SysTrayThreadProc(), test_click_make_new_folder_button(), test_cocreateinstance_proxy(), test_CoCreateInstanceEx(), test_CoFreeUnusedLibraries(), test_CoGetApartmentType(), test_CoGetCallContext(), test_CoGetClassObject(), test_CoGetContextToken(), test_CoGetInstanceFromFile(), test_CoGetInterfaceAndReleaseStream(), test_CoGetObjectContext(), test_CoGetPSClsid(), test_CoInitializeEx(), test_CoMarshalInterface(), test_CoMarshalInterThreadInterfaceInStream(), test_controlevent(), test_CoRegisterClassObject(), test_CoRegisterMessageFilter(), test_CoRegisterPSClsid(), test_CoUnmarshalInterface(), test_CoWaitForMultipleHandles(), test_CoWaitForMultipleHandles_thread(), test_DPA_LoadStream(), test_DPA_SaveStream(), test_externalui_message(), test_GetDefaultColumn(), test_GetDefaultSearchGUID(), test_GlobalOptions(), test_iface_ptr(), test_IInitializeSpy(), test_IInitializeSpy_register2(), test_IInitializeSpy_switch_apt(), test_implicit_mta(), test_init_spies_proc(), test_IWinHttpRequest(), test_IWinHttpRequest_Invoke(), test_knownFolders(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_MsiSetComponentState(), test_MultiThreadApartment_Thread(), test_OleInitialize_InitCounting(), test_packagecoltypes(), test_printers_folder(), test_properties(), test_PSRefreshPropertySchema(), test_registered_object_thread_affinity(), test_render_with_multithread(), test_RtlQueryPackageIdentity(), test_selection(), test_set_clipboard(), test_shortcut(), test_StreamOnStreamRange(), test_stub(), test_top_level_action(), test_WICCreateColorTransform_Proxy(), TestClasses(), TestThread(), ATL::CAtlExeModuleT< T >::UninitializeCom(), UninitXMLDOMParser(), union_tests(), unregister_filters(), WICCreateColorTransform_Proxy(), wmain(), wWinMain(), and ComInit::~ComInit().

CoWaitForMultipleHandles()

HRESULT WINAPI CoWaitForMultipleHandles	(	DWORD	dwFlags,
		DWORD	dwTimeout,
		ULONG	cHandles,
		LPHANDLE	pHandles,
		LPDWORD	lpdwindex
	)

Definition at line 4578 of file compobj.c.

{
    HRESULT hr = S_OK;
    DWORD start_time = GetTickCount();
    APARTMENT *apt = COM_CurrentApt();
    BOOL message_loop = apt && !apt->multi_threaded;
    BOOL check_apc = (dwFlags & COWAIT_ALERTABLE) != 0;
    BOOL post_quit = FALSE;
    UINT exit_code;
 
    TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags, dwTimeout, cHandles,
        pHandles, lpdwindex);
 
    if (!lpdwindex)
        return E_INVALIDARG;
 
    *lpdwindex = 0;
 
    if (!pHandles)
        return E_INVALIDARG;
 
    if (!cHandles)
        return RPC_E_NO_SYNC;
 
    while (TRUE)
    {
        DWORD now = GetTickCount();
        DWORD res;
 
        if (now - start_time > dwTimeout)
        {
            hr = RPC_S_CALLPENDING;
            break;
        }
 
        if (message_loop)
        {
            DWORD wait_flags = ((dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0) |
                    ((dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0);
 
            TRACE("waiting for rpc completion or window message\n");
 
            res = WAIT_TIMEOUT;
 
            if (check_apc)
            {
                res = WaitForMultipleObjectsEx(cHandles, pHandles,
                    (dwFlags & COWAIT_WAITALL) != 0, 0, TRUE);
                check_apc = FALSE;
            }
 
            if (res == WAIT_TIMEOUT)
                res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
                    (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
                    QS_SENDMESSAGE | QS_ALLPOSTMESSAGE | QS_PAINT, wait_flags);
 
            if (res == WAIT_OBJECT_0 + cHandles)  /* messages available */
            {
                MSG msg;
                int count = 0;
 
                /* call message filter */
 
                if (COM_CurrentApt()->filter)
                {
                    PENDINGTYPE pendingtype =
                        COM_CurrentInfo()->pending_call_count_server ?
                            PENDINGTYPE_NESTED : PENDINGTYPE_TOPLEVEL;
                    DWORD be_handled = IMessageFilter_MessagePending(
                        COM_CurrentApt()->filter, 0 /* FIXME */,
                        now - start_time, pendingtype);
                    TRACE("IMessageFilter_MessagePending returned %d\n", be_handled);
                    switch (be_handled)
                    {
                    case PENDINGMSG_CANCELCALL:
                        WARN("call canceled\n");
                        hr = RPC_E_CALL_CANCELED;
                        break;
                    case PENDINGMSG_WAITNOPROCESS:
                    case PENDINGMSG_WAITDEFPROCESS:
                    default:
                        /* FIXME: MSDN is very vague about the difference
                         * between WAITNOPROCESS and WAITDEFPROCESS - there
                         * appears to be none, so it is possibly a left-over
                         * from the 16-bit world. */
                        break;
                    }
                }
 
                if (!apt->win)
                {
                    /* If window is NULL on apartment, peek at messages so that it will not trigger
                     * MsgWaitForMultipleObjects next time. */
                    PeekMessageW(NULL, NULL, 0, 0, PM_QS_POSTMESSAGE | PM_NOREMOVE | PM_NOYIELD);
                }
                /* some apps (e.g. Visio 2010) don't handle WM_PAINT properly and loop forever,
                 * so after processing 100 messages we go back to checking the wait handles */
                while (count++ < 100 && COM_PeekMessage(apt, &msg))
                {
                    if (msg.message == WM_QUIT)
                    {
                        TRACE("received WM_QUIT message\n");
                        post_quit = TRUE;
                        exit_code = msg.wParam;
                    }
                    else
                    {
                        TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
                        TranslateMessage(&msg);
                        DispatchMessageW(&msg);
                    }
                }
                continue;
            }
        }
        else
        {
            TRACE("waiting for rpc completion\n");
 
            res = WaitForMultipleObjectsEx(cHandles, pHandles, (dwFlags & COWAIT_WAITALL) != 0,
                (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
                (dwFlags & COWAIT_ALERTABLE) != 0);
        }
 
        switch (res)
        {
        case WAIT_TIMEOUT:
            hr = RPC_S_CALLPENDING;
            break;
        case WAIT_FAILED:
            hr = HRESULT_FROM_WIN32( GetLastError() );
            break;
        default:
            *lpdwindex = res;
            break;
        }
        break;
    }
    if (post_quit) PostQuitMessage(exit_code);
    TRACE("-- 0x%08x\n", hr);
    return hr;
}

Referenced by ClientRpcChannelBuffer_SendReceive(), ISynchronize_fnWait(), local_server_proc(), RPC_GetLocalClassObject(), test_CoWaitForMultipleHandles(), and test_CoWaitForMultipleHandles_thread().

create_classes_key()

LSTATUS create_classes_key	(	HKEY	hkey,
		const WCHAR *	name,
		REGSAM	access,
		HKEY *	retkey
	)

Definition at line 402 of file compobj.c.

{
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING nameW;
 
    if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, name );
 
    return RtlNtStatusToDosError( create_key( retkey, access, &attr ) );
}

Referenced by COMCAT_ICatRegister_RegisterCategories(), COMCAT_RegisterClassCategories(), and get_classes_root_hkey().

create_classes_root_hkey()

static HKEY create_classes_root_hkey ( DWORD  access )

static

Definition at line 352 of file compobj.c.

{
    HKEY hkey, ret = 0;
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING name;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = 0;
    attr.ObjectName = &name;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &name, classes_rootW );
    if (create_key( &hkey, access, &attr )) return 0;
    TRACE( "%s -> %p\n", debugstr_w(attr.ObjectName->Buffer), hkey );
 
    if (!(access & KEY_WOW64_64KEY))
    {
        if (!(ret = InterlockedCompareExchangePointer( (void **)&classes_root_hkey, hkey, 0 )))
            ret = hkey;
        else
            NtClose( hkey );  /* somebody beat us to it */
    }
    else
        ret = hkey;
    return ret;
}

Referenced by get_classes_root_hkey().

create_key()

static NTSTATUS create_key ( HKEY *  retkey, ACCESS_MASK  access, OBJECT_ATTRIBUTES *  attr  )

static

Definition at line 303 of file compobj.c.

{
    NTSTATUS status = NtCreateKey( (HANDLE *)retkey, access, attr, 0, NULL, 0, NULL );
 
    if (status == STATUS_OBJECT_NAME_NOT_FOUND)
    {
        HANDLE subkey, root = attr->RootDirectory;
        WCHAR *buffer = attr->ObjectName->Buffer;
        DWORD attrs, pos = 0, i = 0, len = attr->ObjectName->Length / sizeof(WCHAR);
        UNICODE_STRING str;
 
        while (i < len && buffer[i] != '\\') i++;
        if (i == len) return status;
 
        attrs = attr->Attributes;
        attr->ObjectName = &str;
 
        while (i < len)
        {
            str.Buffer = buffer + pos;
            str.Length = (i - pos) * sizeof(WCHAR);
            status = NtCreateKey( &subkey, access, attr, 0, NULL, 0, NULL );
            if (attr->RootDirectory != root) NtClose( attr->RootDirectory );
            if (status) return status;
            attr->RootDirectory = subkey;
            while (i < len && buffer[i] == '\\') i++;
            pos = i;
            while (i < len && buffer[i] != '\\') i++;
        }
        str.Buffer = buffer + pos;
        str.Length = (i - pos) * sizeof(WCHAR);
        attr->Attributes = attrs;
        status = NtCreateKey( (PHANDLE)retkey, access, attr, 0, NULL, 0, NULL );
        if (attr->RootDirectory != root) NtClose( attr->RootDirectory );
    }
    return status;
}

Referenced by create_classes_key(), and create_classes_root_hkey().

DllMain()

BOOL WINAPI DllMain	(	HINSTANCE	hinstDLL,
		DWORD	fdwReason,
		LPVOID	reserved
	)

Definition at line 5375 of file compobj.c.

{
    TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, reserved);
 
    switch(fdwReason) {
    case DLL_PROCESS_ATTACH:
        hProxyDll = hinstDLL;
    break;
 
    case DLL_PROCESS_DETACH:
        if (reserved) break;
        release_std_git();
        if(apt_win_class)
            UnregisterClassW( (const WCHAR*)MAKEINTATOM(apt_win_class), hProxyDll );
        RPC_UnregisterAllChannelHooks();
        COMPOBJ_DllList_Free();
        DeleteCriticalSection(&csRegisteredClassList);
        DeleteCriticalSection(&csApartment);
    break;
 
    case DLL_THREAD_DETACH:
        COM_TlsDestroy();
        break;
    }
    return TRUE;
}

DllRegisterServer()

HRESULT WINAPI DllRegisterServer

(

void

)

Definition at line 5405 of file compobj.c.

{
    return OLE32_DllRegisterServer();
}

DllUnregisterServer()

HRESULT WINAPI DllUnregisterServer

(

void

)

Definition at line 5413 of file compobj.c.

{
    return OLE32_DllUnregisterServer();
}

dvaspect_to_miscfields()

static enum comclass_miscfields dvaspect_to_miscfields ( DWORD  aspect )

inlinestatic

Definition at line 237 of file compobj.c.

{
    switch (aspect)
    {
    case DVASPECT_CONTENT:
        return MiscStatusContent;
    case DVASPECT_THUMBNAIL:
        return MiscStatusThumbnail;
    case DVASPECT_ICON:
        return MiscStatusIcon;
    case DVASPECT_DOCPRINT:
        return MiscStatusDocPrint;
    default:
        return MiscStatus;
    };
}

Referenced by actctx_get_miscstatus().

enter_apartment()

HRESULT enter_apartment	(	struct oletls *	info,
		DWORD	model
	)

Definition at line 1913 of file compobj.c.

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

Referenced by CoInitializeEx(), and dispatch_rpc().

get_classes_root_hkey()

static HKEY get_classes_root_hkey ( HKEY  hkey, REGSAM  access  )

inlinestatic

Definition at line 381 of file compobj.c.

{
    HKEY ret = hkey;
    const BOOL is_win64 = sizeof(void*) > sizeof(int);
    const BOOL force_wow32 = is_win64 && (access & KEY_WOW64_32KEY);
 
    if (hkey == HKEY_CLASSES_ROOT &&
        ((access & KEY_WOW64_64KEY) || !(ret = classes_root_hkey)))
        ret = create_classes_root_hkey(MAXIMUM_ALLOWED | (access & KEY_WOW64_64KEY));
    if (force_wow32 && ret && ret == classes_root_hkey)
    {
        static const WCHAR wow6432nodeW[] = {'W','o','w','6','4','3','2','N','o','d','e',0};
        access &= ~KEY_WOW64_32KEY;
        if (create_classes_key(classes_root_hkey, wow6432nodeW, access, &hkey))
            return 0;
        ret = hkey;
    }
 
    return ret;
}

Referenced by create_classes_key(), and open_classes_key().

get_inproc_class_object()

static HRESULT get_inproc_class_object ( APARTMENT *  apt, const struct class_reg_data *  regdata, REFCLSID  rclsid, REFIID  riid, BOOL  hostifnecessary, void **  ppv  )

static

Definition at line 3026 of file compobj.c.

{
    WCHAR dllpath[MAX_PATH+1];
    BOOL apartment_threaded;
 
    if (hostifnecessary)
    {
        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 CoGetClassObject().

get_local_server_stream()

static HRESULT get_local_server_stream ( APARTMENT *  apt, IStream **  ret  )

static

Definition at line 1025 of file compobj.c.

{
    HRESULT hres = S_OK;
 
    EnterCriticalSection(&apt->cs);
 
    if(!apt->local_server) {
        LocalServer *obj;
 
        obj = heap_alloc(sizeof(*obj));
        if(obj) {
            obj->IServiceProvider_iface.lpVtbl = &LocalServerVtbl;
            obj->ref = 1;
            obj->apt = apt;
 
            hres = CreateStreamOnHGlobal(0, TRUE, &obj->marshal_stream);
            if(SUCCEEDED(hres)) {
                hres = CoMarshalInterface(obj->marshal_stream, &IID_IServiceProvider, (IUnknown*)&obj->IServiceProvider_iface,
                        MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
                if(FAILED(hres))
                    IStream_Release(obj->marshal_stream);
            }
 
            if(SUCCEEDED(hres))
                apt->local_server = obj;
            else
                heap_free(obj);
        }else {
            hres = E_OUTOFMEMORY;
        }
    }
 
    if(SUCCEEDED(hres))
        hres = IStream_Clone(apt->local_server->marshal_stream, ret);
 
    LeaveCriticalSection(&apt->cs);
 
    if(FAILED(hres))
        ERR("Failed: %08x\n", hres);
    return hres;
}

Referenced by CoRegisterClassObject().

get_object_dll_path()

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

static

Definition at line 1413 of file compobj.c.

{
    DWORD ret;
 
    if (regdata->hkey)
    {
    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
    {
        static const WCHAR dllW[] = {'.','d','l','l',0};
        ULONG_PTR cookie;
        WCHAR *nameW;
 
        *dst = 0;
        nameW = (WCHAR*)((BYTE*)regdata->u.actctx.section + regdata->u.actctx.data->name_offset);
        ActivateActCtx(regdata->u.actctx.hactctx, &cookie);
        ret = SearchPathW(NULL, nameW, dllW, dstlen, dst, NULL);
        DeactivateActCtx(0, cookie);
        return *dst != 0;
    }
}

Referenced by apartment_hostobject(), get_inproc_class_object(), and Handler_DllGetClassObject().

get_ps_clsid_from_registry()

static HRESULT get_ps_clsid_from_registry ( const WCHAR *  path, REGSAM  access, CLSID *  pclsid  )

static

Definition at line 2632 of file compobj.c.

{
    HKEY hkey;
    WCHAR value[CHARS_IN_GUID];
    DWORD len;
 
    access |= KEY_READ;
 
    if (open_classes_key(HKEY_CLASSES_ROOT, path, access, &hkey))
        return REGDB_E_IIDNOTREG;
 
    len = sizeof(value);
    if (ERROR_SUCCESS != RegQueryValueExW(hkey, NULL, NULL, NULL, (BYTE *)value, &len))
        return REGDB_E_IIDNOTREG;
    RegCloseKey(hkey);
 
    if (CLSIDFromString(value, pclsid) != NOERROR)
        return REGDB_E_IIDNOTREG;
 
    return S_OK;
}

Referenced by CoGetPSClsid().

get_spy_entry()

static struct init_spy * get_spy_entry ( struct oletls *  info, unsigned int  id  )

static

Definition at line 1780 of file compobj.c.

{
    struct init_spy *spy;
 
    LIST_FOR_EACH_ENTRY(spy, &info->spies, struct init_spy, entry)
    {
        if (id == spy->id && spy->spy)
            return spy;
    }
 
    return NULL;
}

Referenced by CoRegisterInitializeSpy(), and CoRevokeInitializeSpy().

get_threading_model()

static enum comclass_threadingmodel get_threading_model ( const struct class_reg_data *  data )

static

Definition at line 2997 of file compobj.c.

{
    if (data->hkey)
    {
        static const WCHAR wszThreadingModel[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
        static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
        static const WCHAR wszFree[] = {'F','r','e','e',0};
        static const WCHAR wszBoth[] = {'B','o','t','h',0};
        WCHAR threading_model[10 /* lstrlenW(L"apartment")+1 */];
        DWORD dwLength = sizeof(threading_model);
        DWORD keytype;
        DWORD ret;
 
        ret = RegQueryValueExW(data->u.hkey, wszThreadingModel, NULL, &keytype, (BYTE*)threading_model, &dwLength);
        if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
            threading_model[0] = '\0';
 
        if (!wcsicmp(threading_model, wszApartment)) return ThreadingModel_Apartment;
        if (!wcsicmp(threading_model, wszFree)) return ThreadingModel_Free;
        if (!wcsicmp(threading_model, wszBoth)) 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.data->model;
}

Referenced by get_inproc_class_object().

GlobalOptions_AddRef()

static ULONG WINAPI GlobalOptions_AddRef ( IGlobalOptions *  iface )

static

Definition at line 5306 of file compobj.c.

{
    GlobalOptions *This = impl_from_IGlobalOptions(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}

GlobalOptions_CreateInstance()

HRESULT WINAPI GlobalOptions_CreateInstance	(	IClassFactory *	iface,
		IUnknown *	outer,
		REFIID	riid,
		void **	ppv
	)

Definition at line 5351 of file compobj.c.

{
    GlobalOptions *global_options;
    HRESULT hres;
 
    TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), ppv);
 
    if (outer)
        return E_INVALIDARG;
 
    global_options = heap_alloc(sizeof(*global_options));
    if (!global_options)
        return E_OUTOFMEMORY;
    global_options->IGlobalOptions_iface.lpVtbl = &GlobalOptionsVtbl;
    global_options->ref = 1;
 
    hres = IGlobalOptions_QueryInterface(&global_options->IGlobalOptions_iface, riid, ppv);
    IGlobalOptions_Release(&global_options->IGlobalOptions_iface);
    return hres;
}

GlobalOptions_Query()

static HRESULT WINAPI GlobalOptions_Query ( IGlobalOptions *  iface, GLOBALOPT_PROPERTIES  property, ULONG_PTR *  value  )

static

Definition at line 5336 of file compobj.c.

{
    GlobalOptions *This = impl_from_IGlobalOptions(iface);
    FIXME("(%p)->(%u %p)\n", This, property, value);
    return E_NOTIMPL;
}

GlobalOptions_QueryInterface()

static HRESULT WINAPI GlobalOptions_QueryInterface ( IGlobalOptions *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 5286 of file compobj.c.

{
    GlobalOptions *This = impl_from_IGlobalOptions(iface);
 
    TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 
    if (IsEqualGUID(&IID_IGlobalOptions, riid) || IsEqualGUID(&IID_IUnknown, riid))
    {
        *ppv = iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

GlobalOptions_Release()

static ULONG WINAPI GlobalOptions_Release ( IGlobalOptions *  iface )

static

Definition at line 5316 of file compobj.c.

{
    GlobalOptions *This = impl_from_IGlobalOptions(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if (!ref)
        heap_free(This);
 
    return ref;
}

GlobalOptions_Set()

static HRESULT WINAPI GlobalOptions_Set ( IGlobalOptions *  iface, GLOBALOPT_PROPERTIES  property, ULONG_PTR  value  )

static

Definition at line 5329 of file compobj.c.

{
    GlobalOptions *This = impl_from_IGlobalOptions(iface);
    FIXME("(%p)->(%u %lx)\n", This, property, value);
    return S_OK;
}

guid_from_string()

static BOOL guid_from_string ( LPCWSTR  s, GUID *  id  )

static

Definition at line 2238 of file compobj.c.

{
  int   i;
 
  if (!s || s[0]!='{') {
    memset( id, 0, sizeof (CLSID) );
    if(!s) return TRUE;
    return FALSE;
  }
 
  TRACE("%s -> %p\n", debugstr_w(s), id);
 
  /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
 
  id->Data1 = 0;
  for (i = 1; i < 9; i++) {
    if (!is_valid_hex(s[i])) return FALSE;
    id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
  }
  if (s[9]!='-') return FALSE;
 
  id->Data2 = 0;
  for (i = 10; i < 14; i++) {
    if (!is_valid_hex(s[i])) return FALSE;
    id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
  }
  if (s[14]!='-') return FALSE;
 
  id->Data3 = 0;
  for (i = 15; i < 19; i++) {
    if (!is_valid_hex(s[i])) return FALSE;
    id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
  }
  if (s[19]!='-') return FALSE;
 
  for (i = 20; i < 37; i+=2) {
    if (i == 24) {
      if (s[i]!='-') return FALSE;
      i++;
    }
    if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
    id->Data4[(i-20)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
  }
 
  if (s[37] == '}' && s[38] == '\0')
    return TRUE;
 
  return FALSE;
}

Referenced by clsid_from_string_reg(), CLSIDFromString(), and IIDFromString().

Handler_DllGetClassObject()

HRESULT Handler_DllGetClassObject	(	REFCLSID	rclsid,
		REFIID	riid,
		LPVOID *	ppv
	)

Definition at line 5167 of file compobj.c.

{
    static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
    HKEY hkey;
    HRESULT hres;
 
    hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
    if (SUCCEEDED(hres))
    {
        struct class_reg_data regdata;
        WCHAR dllpath[MAX_PATH+1];
 
        regdata.u.hkey = hkey;
        regdata.hkey = TRUE;
 
        if (get_object_dll_path(&regdata, dllpath, ARRAY_SIZE(dllpath)))
        {
            static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
            if (!wcsicmp(dllpath, wszOle32))
            {
                RegCloseKey(hkey);
                return HandlerCF_Create(rclsid, riid, ppv);
            }
        }
        else
            WARN("not creating object for inproc handler path %s\n", debugstr_w(dllpath));
        RegCloseKey(hkey);
    }
 
    return CLASS_E_CLASSNOTAVAILABLE;
}

Referenced by DllGetClassObject().

IIDFromString()

HRESULT WINAPI IIDFromString	(	LPCOLESTR	s,
		IID *	iid
	)

Definition at line 2374 of file compobj.c.

{
  TRACE("%s -> %p\n", debugstr_w(s), iid);
 
  if (!s)
  {
      memset(iid, 0, sizeof(*iid));
      return S_OK;
  }
 
  /* length mismatch is a special case */
  if (lstrlenW(s) + 1 != CHARS_IN_GUID)
      return E_INVALIDARG;
 
  if (s[0] != '{')
      return CO_E_IIDSTRING;
 
  return guid_from_string(s, iid) ? S_OK : CO_E_IIDSTRING;
}

Referenced by FindExeCplClass(), StreamingDeviceSetupW(), test_dump_typelib(), and test_IIDFromString().

impl_from_IComThreadingInfo()

static Context * impl_from_IComThreadingInfo ( IComThreadingInfo *  iface )

inlinestatic

Definition at line 4802 of file compobj.c.

{
        return CONTAINING_RECORD(iface, Context, IComThreadingInfo_iface);
}

Referenced by Context_CTI_AddRef(), Context_CTI_QueryInterface(), and Context_CTI_Release().

impl_from_IContextCallback()

static Context * impl_from_IContextCallback ( IContextCallback *  iface )

inlinestatic

Definition at line 4807 of file compobj.c.

{
        return CONTAINING_RECORD(iface, Context, IContextCallback_iface);
}

Referenced by Context_CC_AddRef(), Context_CC_ContextCallback(), Context_CC_QueryInterface(), and Context_CC_Release().

impl_from_IGlobalOptions()

static GlobalOptions * impl_from_IGlobalOptions ( IGlobalOptions *  iface )

inlinestatic

Definition at line 5281 of file compobj.c.

{
    return CONTAINING_RECORD(iface, GlobalOptions, IGlobalOptions_iface);
}

Referenced by GlobalOptions_AddRef(), GlobalOptions_Query(), GlobalOptions_QueryInterface(), GlobalOptions_Release(), and GlobalOptions_Set().

impl_from_IObjContext()

static Context * impl_from_IObjContext ( IObjContext *  iface )

inlinestatic

Definition at line 4812 of file compobj.c.

{
        return CONTAINING_RECORD(iface, Context, IObjContext_iface);
}

Referenced by Context_OC_AddRef(), Context_OC_EnumContextProps(), Context_OC_GetProperty(), Context_OC_QueryInterface(), Context_OC_Release(), Context_OC_RemoveProperty(), Context_OC_Reserved1(), Context_OC_Reserved2(), Context_OC_Reserved3(), Context_OC_Reserved4(), Context_OC_Reserved5(), Context_OC_Reserved6(), Context_OC_Reserved7(), and Context_OC_SetProperty().

impl_from_IServiceProvider()

static LocalServer * impl_from_IServiceProvider ( IServiceProvider *  iface )

inlinestatic

Definition at line 943 of file compobj.c.

{
    return CONTAINING_RECORD(iface, LocalServer, IServiceProvider_iface);
}

Referenced by LocalServer_AddRef(), LocalServer_QueryInterface(), LocalServer_QueryService(), and LocalServer_Release().

impl_from_ISynchronize()

static MREImpl * impl_from_ISynchronize ( ISynchronize *  iface )

inlinestatic

Definition at line 805 of file compobj.c.

{
    return CONTAINING_RECORD(iface, MREImpl, ISynchronize_iface);
}

Referenced by ISynchronize_fnAddRef(), ISynchronize_fnQueryInterface(), ISynchronize_fnRelease(), ISynchronize_fnReset(), ISynchronize_fnSignal(), and ISynchronize_fnWait().

impl_from_ISynchronizeHandle()

static MREImpl * impl_from_ISynchronizeHandle ( ISynchronizeHandle *  iface )

inlinestatic

Definition at line 887 of file compobj.c.

{
    return CONTAINING_RECORD(iface, MREImpl, ISynchronizeHandle_iface);
}

Referenced by SynchronizeHandle_AddRef(), SynchronizeHandle_GetHandle(), SynchronizeHandle_QueryInterface(), and SynchronizeHandle_Release().

init_multi_qi()

static void init_multi_qi ( DWORD  count, MULTI_QI *  mqi, HRESULT  hr  )

static

Definition at line 3346 of file compobj.c.

{
  ULONG i;
 
  for (i = 0; i < count; i++)
  {
      mqi[i].pItf = NULL;
      mqi[i].hr = hr;
  }
}

Referenced by CoCreateInstanceEx(), CoGetInstanceFromFile(), and CoGetInstanceFromIStorage().

is_valid_hex()

static BOOL is_valid_hex ( WCHAR  c )

inlinestatic

Definition at line 2217 of file compobj.c.

{
    if (!(((c >= '0') && (c <= '9'))  ||
          ((c >= 'a') && (c <= 'f'))  ||
          ((c >= 'A') && (c <= 'F'))))
        return FALSE;
    return TRUE;
}

Referenced by guid_from_string().

IsEqualGUID()

BOOL WINAPI IsEqualGUID	(	REFGUID	rguid1,
		REFGUID	rguid2
	)

Definition at line 4112 of file compobj.c.

{
    return !memcmp(rguid1,rguid2,sizeof(GUID));
}

ISynchronize_fnAddRef()

static ULONG WINAPI ISynchronize_fnAddRef ( ISynchronize *  iface )

static

Definition at line 830 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
    LONG ref = InterlockedIncrement(&This->ref);
    TRACE("%p - ref %d\n", This, ref);
 
    return ref;
}

ISynchronize_fnQueryInterface()

static HRESULT WINAPI ISynchronize_fnQueryInterface ( ISynchronize *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 810 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
 
    TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppv);
 
    if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISynchronize)) {
        *ppv = &This->ISynchronize_iface;
    }else if(IsEqualGUID(riid, &IID_ISynchronizeHandle)) {
        *ppv = &This->ISynchronizeHandle_iface;
    }else {
        ERR("Unknown interface %s requested.\n", debugstr_guid(riid));
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

ISynchronize_fnRelease()

static ULONG WINAPI ISynchronize_fnRelease ( ISynchronize *  iface )

static

Definition at line 839 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
    LONG ref = InterlockedDecrement(&This->ref);
    TRACE("%p - ref %d\n", This, ref);
 
    if(!ref)
    {
        CloseHandle(This->event);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

ISynchronize_fnReset()

static HRESULT WINAPI ISynchronize_fnReset ( ISynchronize *  iface )

static

Definition at line 870 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
    TRACE("%p\n", This);
    ResetEvent(This->event);
    return S_OK;
}

ISynchronize_fnSignal()

static HRESULT WINAPI ISynchronize_fnSignal ( ISynchronize *  iface )

static

Definition at line 862 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
    TRACE("%p\n", This);
    SetEvent(This->event);
    return S_OK;
}

ISynchronize_fnWait()

static HRESULT WINAPI ISynchronize_fnWait ( ISynchronize *  iface, DWORD  dwFlags, DWORD  dwMilliseconds  )

static

Definition at line 854 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronize(iface);
    UINT index;
    TRACE("%p (%08x, %08x)\n", This, dwFlags, dwMilliseconds);
    return CoWaitForMultipleHandles(dwFlags, dwMilliseconds, 1, &This->event, &index);
}

leave_apartment()

void leave_apartment

(

struct oletls *

info

)

Definition at line 1937 of file compobj.c.

{
    if (!--info->inits)
    {
        if (info->ole_inits)
            WARN( "Uninitializing apartment while Ole is still initialized\n" );
        apartment_release( info->apt );
        info->apt = NULL;
    }
}

Referenced by CoUninitialize(), and dispatch_rpc().

LocalServer_AddRef()

static ULONG WINAPI LocalServer_AddRef ( IServiceProvider *  iface )

static

Definition at line 965 of file compobj.c.

{
    LocalServer *This = impl_from_IServiceProvider(iface);
    LONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    return ref;
}

LocalServer_QueryInterface()

static HRESULT WINAPI LocalServer_QueryInterface ( IServiceProvider *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 948 of file compobj.c.

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

LocalServer_QueryService()

static HRESULT WINAPI LocalServer_QueryService ( IServiceProvider *  iface, REFGUID  guid, REFIID  riid, void **  ppv  )

static

Definition at line 990 of file compobj.c.

{
    LocalServer *This = impl_from_IServiceProvider(iface);
    APARTMENT *apt = COM_CurrentApt();
    RegisteredClass *iter;
    HRESULT hres = E_FAIL;
 
    TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guid), debugstr_guid(riid), ppv);
 
    if(!This->apt)
        return E_UNEXPECTED;
 
    EnterCriticalSection(&csRegisteredClassList);
 
    LIST_FOR_EACH_ENTRY(iter, &RegisteredClassList, RegisteredClass, entry) {
        if(iter->apartment_id == apt->oxid
           && (iter->runContext & CLSCTX_LOCAL_SERVER)
           && IsEqualGUID(&iter->classIdentifier, guid)) {
            hres = IUnknown_QueryInterface(iter->classObject, riid, ppv);
            break;
        }
    }
 
    LeaveCriticalSection( &csRegisteredClassList );
 
    return hres;
}

LocalServer_Release()

static ULONG WINAPI LocalServer_Release ( IServiceProvider *  iface )

static

Definition at line 975 of file compobj.c.

{
    LocalServer *This = impl_from_IServiceProvider(iface);
    LONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p) ref=%d\n", This, ref);
 
    if(!ref) {
        assert(!This->apt);
        HeapFree(GetProcessHeap(), 0, This);
    }
 
    return ref;
}

lock_init_spies()

static void lock_init_spies ( struct oletls *  info )

inlinestatic

Definition at line 1797 of file compobj.c.

{
    info->spies_lock++;
}

Referenced by CoInitializeEx(), and CoUninitialize().

ManualResetEvent_Construct()

static HRESULT ManualResetEvent_Construct ( IUnknown *  punkouter, REFIID  iid, void **  ppv  )

static

Definition at line 925 of file compobj.c.

{
    MREImpl *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MREImpl));
    HRESULT hr;
 
    if(punkouter)
        FIXME("Aggregation not implemented.\n");
 
    This->ref = 1;
    This->ISynchronize_iface.lpVtbl = &vt_ISynchronize;
    This->ISynchronizeHandle_iface.lpVtbl = &SynchronizeHandleVtbl;
    This->event = CreateEventW(NULL, TRUE, FALSE, NULL);
 
    hr = ISynchronize_QueryInterface(&This->ISynchronize_iface, iid, ppv);
    ISynchronize_Release(&This->ISynchronize_iface);
    return hr;
}

Referenced by CoCreateInstanceEx().

open_classes_key()

LSTATUS open_classes_key	(	HKEY	hkey,
		const WCHAR *	name,
		REGSAM	access,
		HKEY *	retkey
	)

Definition at line 420 of file compobj.c.

{
    OBJECT_ATTRIBUTES attr;
    UNICODE_STRING nameW;
 
    if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 
    attr.Length = sizeof(attr);
    attr.RootDirectory = hkey;
    attr.ObjectName = &nameW;
    attr.Attributes = 0;
    attr.SecurityDescriptor = NULL;
    attr.SecurityQualityOfService = NULL;
    RtlInitUnicodeString( &nameW, name );
 
    return RtlNtStatusToDosError( NtOpenKey( (HANDLE *)retkey, access, &attr ) );
}

Referenced by CATIDEnumGUID_Clone(), CATIDEnumGUID_Construct(), clsid_from_string_reg(), CLSIDEnumGUID_Clone(), CLSIDEnumGUID_Construct(), CLSIDEnumGUID_Next(), COM_OpenKeyForAppIdFromCLSID(), COM_OpenKeyForCLSID(), COMCAT_ICatInformation_GetCategoryDesc(), COMCAT_ICatInformation_IsClassOfCategories(), COMCAT_ICatRegister_UnRegisterCategories(), COMCAT_IEnumCATEGORYINFO_Clone(), COMCAT_IEnumCATEGORYINFO_Next(), COMCAT_IsClassOfCategories(), COMCAT_UnRegisterClassCategories(), EnumCATEGORYINFO_Construct(), get_ps_clsid_from_registry(), OLECONVERT_CreateCompObjStream(), and OleRegGetMiscStatus().

ProgIDFromCLSID()

HRESULT WINAPI DECLSPEC_HOTPATCH ProgIDFromCLSID	(	REFCLSID	clsid,
		LPOLESTR *	ppszProgID
	)

Definition at line 2530 of file compobj.c.

{
    static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
    ACTCTX_SECTION_KEYED_DATA data;
    HKEY     hkey;
    HRESULT  ret;
    LONG progidlen = 0;
 
    if (!ppszProgID)
        return E_INVALIDARG;
 
    *ppszProgID = NULL;
 
    data.cbSize = sizeof(data);
    if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
                              clsid, &data))
    {
        struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
        if (comclass->progid_len)
        {
            WCHAR *ptrW;
 
            *ppszProgID = CoTaskMemAlloc(comclass->progid_len + sizeof(WCHAR));
            if (!*ppszProgID) return E_OUTOFMEMORY;
 
            ptrW = (WCHAR*)((BYTE*)comclass + comclass->progid_offset);
            memcpy(*ppszProgID, ptrW, comclass->progid_len + sizeof(WCHAR));
            return S_OK;
        }
        else
            return REGDB_E_CLASSNOTREG;
    }
 
    ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
    if (FAILED(ret))
        return ret;
 
    if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
      ret = REGDB_E_CLASSNOTREG;
 
    if (ret == S_OK)
    {
      *ppszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
      if (*ppszProgID)
      {
        if (RegQueryValueW(hkey, NULL, *ppszProgID, &progidlen)) {
          ret = REGDB_E_CLASSNOTREG;
          CoTaskMemFree(*ppszProgID);
          *ppszProgID = NULL;
        }
      }
      else
        ret = E_OUTOFMEMORY;
    }
 
    RegCloseKey(hkey);
    return ret;
}

Referenced by g2s(), guid2string(), OLECONVERT_GetOLE10ProgID(), render_embed_source_hack(), test_ProgIDFromCLSID(), and WriteFmtUserTypeStg().

register_class()

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

static

Definition at line 1681 of file compobj.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 = wszAptWinClass;
    apt_win_class = RegisterClassW(&wclass);
    return TRUE;
}

return_multi_qi()

static HRESULT return_multi_qi ( IUnknown *  unk, DWORD  count, MULTI_QI *  mqi, BOOL  include_unk  )

static

Definition at line 3357 of file compobj.c.

{
  ULONG index = 0, fetched = 0;
 
  if (include_unk)
  {
    mqi[0].hr = S_OK;
    mqi[0].pItf = unk;
    index = fetched = 1;
  }
 
  for (; index < count; index++)
  {
    mqi[index].hr = IUnknown_QueryInterface(unk, mqi[index].pIID, (void**)&mqi[index].pItf);
    if (mqi[index].hr == S_OK)
      fetched++;
  }
 
  if (!include_unk)
      IUnknown_Release(unk);
 
  if (fetched == 0)
    return E_NOINTERFACE;
 
  return fetched == count ? S_OK : CO_S_NOTALLINTERFACES;
}

Referenced by CoCreateInstanceEx(), CoGetInstanceFromFile(), and CoGetInstanceFromIStorage().

revoke_registered_psclsids()

static void revoke_registered_psclsids ( void  )

static

Definition at line 779 of file compobj.c.

{
    struct registered_psclsid *psclsid, *psclsid2;
 
    EnterCriticalSection( &cs_registered_psclsid_list );
 
    LIST_FOR_EACH_ENTRY_SAFE(psclsid, psclsid2, &registered_psclsid_list, struct registered_psclsid, entry)
    {
        list_remove(&psclsid->entry);
        HeapFree(GetProcessHeap(), 0, psclsid);
    }
 
    LeaveCriticalSection( &cs_registered_psclsid_list );
}

Referenced by CoUninitialize().

StringFromCLSID()

HRESULT WINAPI StringFromCLSID	(	REFCLSID	id,
		LPOLESTR *	idstr
	)

Definition at line 2412 of file compobj.c.

{
    if (!(*idstr = CoTaskMemAlloc(CHARS_IN_GUID * sizeof(WCHAR)))) return E_OUTOFMEMORY;
    StringFromGUID2( id, *idstr, CHARS_IN_GUID );
    return S_OK;
}

Referenced by ApplyOrCancelChanges(), BindProtocol_StartEx(), CEnumMediaTypes_fnConstructor(), CEnumTuningSpaces_fnConstructor(), CKsProxy_Constructor(), CNetworkProvider_fnConstructor(), CPin_fnConstructor(), CreateNotificationObject(), CScanningTunner_fnConstructor(), CTuneRequest_fnConstructor(), CTuningSpace_fnConstructor(), CTuningSpaceContainer_fnConstructor(), CNetConnection::Disconnect(), DllRegisterServer(), DllUnregisterServer(), EnumerateNetworkComponent(), FilterMapper3_CreateCategory(), FilterMapper3_RegisterFilter(), FilterMapper3_UnregisterFilter(), FilterMapper_RegisterFilter(), FilterMapper_RegisterPin(), FilterMapper_RegisterPinType(), FilterMapper_UnregisterFilter(), FilterMapper_UnregisterPin(), FM2_WriteClsid(), CTuningSpace::get_NetworkType(), CNetConnectionPropertyUi::GetDeviceInstanceID(), CBDADeviceControl::GetNodeDescriptors(), CBDADeviceControl::GetNodeInterfaces(), CNetConnection::GetProperties(), HCR_GetClassNameA(), HCR_GetClassNameW(), HCR_GetFolderAttributes(), INetCfgComponentControl_fnApplyRegistryChanges(), Initialize(), InitializePropertyDialog(), CKsProxy::IsFormatSupported(), COutputPin::KsProperty(), CNetConnectionPropertyUi::LANPropertiesUIDlg(), load_mapping_settings(), LoadDNSSettings(), LoadFilterSettings(), CInputPin::LoadProxyPlugins(), COutputPin::LoadProxyPlugins(), CKsProxy::LoadProxyPlugins(), CControlNode::QueryInterface(), CBDADigitalDemodulator::QueryInterface(), CBDAFrequencyFilter::QueryInterface(), CBDALNBInfo::QueryInterface(), CInputPin::QueryInterface(), COutputPin::QueryInterface(), CKsProxy::QueryInterface(), CNetworkProvider::QueryInterface(), CPin::QueryInterface(), CScanningTunner::QueryInterface(), CEnumTuningSpaces::QueryInterface(), CTuneRequest::QueryInterface(), CTuningSpace::QueryInterface(), CTuningSpaceContainer::QueryInterface(), CKsProxy::QueryVendorInfo(), reg_context_menu_handler(), reg_icon_overlay(), reg_prop_sheet_handler(), reg_unreg_wine_test_class(), register_clsid(), CNetConnection::Rename(), save_mapping_settings(), CRegFolder::SetNameOf(), SHGetObjectCompatFlags(), TestCommandLine(), unregister_clsid(), and anonymous_namespace{mstscax.cpp}::UUIDToString().

StringFromGUID2()

INT WINAPI StringFromGUID2	(	REFGUID	id,
		LPOLESTR	str,
		INT	cmax
	)

Definition at line 2434 of file compobj.c.

{
    static const WCHAR formatW[] = { '{','%','0','8','X','-','%','0','4','X','-',
                                     '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
                                     '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
                                     '%','0','2','X','%','0','2','X','}',0 };
    if (!id || cmax < CHARS_IN_GUID) return 0;
    swprintf( str, formatW, id->Data1, id->Data2, id->Data3,
              id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
              id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
    return CHARS_IN_GUID;
}

Referenced by CBandSiteMenu::_CreateMenuPart(), _SHGetUserProfilePath(), _SHRegisterFolders(), add_userkey(), AddClsidKeyToArray(), ATL::AtlRegisterClassCategoriesHelper(), AtlRegisterClassCategoriesHelper(), audiomediastream_create(), CShellBrowser::BuildExplorerBandCategory(), CComCatCachedCategory::CacheDSA(), CategoryMgr_FindClosestCategory(), CategoryMgr_RegisterCategory(), CategoryMgr_UnregisterCategory(), CATIDEnumGUID_Construct(), ATL::CComBSTR::CComBSTR(), ClassMoniker_GetDisplayName(), CoGetPSClsid(), COM_OpenKeyForCLSID(), COMCAT_ICatInformation_GetCategoryDesc(), COMCAT_ICatInformation_IsClassOfCategories(), COMCAT_ICatRegister_RegisterCategories(), COMCAT_ICatRegister_UnRegisterCategories(), COMCAT_PrepareClassCategories(), COMCAT_RegisterClassCategories(), COMCAT_UnRegisterClassCategories(), compose_base85_guid(), CoTreatAsClass(), create_EnumMoniker(), create_monodata(), create_PropertyBag(), create_test_guid(), CreateComponentEnumerator(), CreateComponentInfo(), CRegItemContextMenu_CreateInstance(), ddrawmediastream_create(), debugstr_iid(), DEVENUM_CreateAMCategoryKey(), DEVENUM_ICreateDevEnum_CreateClassEnumerator(), DEVENUM_IEnumMoniker_Next(), DEVENUM_IMediaCatMoniker_GetDisplayName(), do_typelib_reg_key(), enum_compartments(), expect_guid(), fill_display_information_d3d(), find_typelib_key(), FormatGUIDKey(), g2s(), get_interface_key(), get_localserver_pipe_name(), get_typelib_key(), GetActiveObject(), CDefView::GetDefaultViewStream(), guid2string(), InputProcessorProfiles_AddLanguageProfile(), InputProcessorProfiles_EnableLanguageProfile(), InputProcessorProfiles_EnableLanguageProfileByDefault(), InputProcessorProfiles_GetDefaultLanguageProfile(), InputProcessorProfiles_IsEnabledLanguageProfile(), InputProcessorProfiles_Register(), InputProcessorProfiles_SetDefaultLanguageProfile(), InputProcessorProfiles_Unregister(), LoadAndInitialize(), CComCatCachedCategory::LoadFromRegistry(), CFindFolder::MessageSFVCB(), MMDevice_Create(), MMDevPropStore_GetValue(), MMDevPropStore_OpenPropKey(), MSI_ProvideQualifiedComponentEx(), MsiDecomposeDescriptorW(), OleSetAutoConvert(), CSearchBar::OnSearchButtonClicked(), PB_Read(), query_feature_state(), CDummyPropertyBag::Read(), read_metadata_patterns(), register_categories(), register_coclasses(), register_codec(), register_converters(), register_decoders(), register_dsound_devices(), register_encoders(), register_interfaces(), register_key_guid(), register_mediatypes_extension(), register_mediatypes_parsing(), register_metadatareaders(), register_pixelformats(), register_server(), RegisterActiveObject(), RegisterComponent(), CLangBarItemList::SaveItem(), SdbInstall(), SdbUninstall(), ATL::CRegKey::SetGUIDValue(), SetupRegisterAllClasses(), SHDOCVW_GetShellInstanceObjectClassObject(), SHELL_QueryCLSIDValue(), StringFromCLSID(), StringFromGUID2A(), test_codec(), test_directshow_filter(), test_dmo(), test_dsound(), test_legacy_filter(), test_legacy_filter_registration(), test_lsa(), test_media_streams(), test_metadata_gif(), test_midiout(), test_OleDoAutoConvert(), test_OleRegGetUserType(), test_QueryPathOfRegTypeLib(), test_register_typelib(), test_StringFromGUID2(), test_stub(), test_vfw(), test_wavein(), test_waveout(), TLB_register_interface(), unregister_categories(), unregister_coclasses(), unregister_converters(), unregister_decoders(), unregister_encoders(), unregister_interfaces(), unregister_mediatypes_parsing(), unregister_metadatareaders(), unregister_pixelformats(), unregister_server(), UnregisterComponent(), and WICConvertBitmapSource().

SynchronizeHandle_AddRef()

static ULONG WINAPI SynchronizeHandle_AddRef ( ISynchronizeHandle *  iface )

static

Definition at line 898 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronizeHandle(iface);
    return ISynchronize_AddRef(&This->ISynchronize_iface);
}

SynchronizeHandle_GetHandle()

static HRESULT WINAPI SynchronizeHandle_GetHandle ( ISynchronizeHandle *  iface, HANDLE *  ph  )

static

Definition at line 910 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronizeHandle(iface);
 
    *ph = This->event;
    return S_OK;
}

SynchronizeHandle_QueryInterface()

static HRESULT WINAPI SynchronizeHandle_QueryInterface ( ISynchronizeHandle *  iface, REFIID  riid, void **  ppv  )

static

Definition at line 892 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronizeHandle(iface);
    return ISynchronize_QueryInterface(&This->ISynchronize_iface, riid, ppv);
}

SynchronizeHandle_Release()

static ULONG WINAPI SynchronizeHandle_Release ( ISynchronizeHandle *  iface )

static

Definition at line 904 of file compobj.c.

{
    MREImpl *This = impl_from_ISynchronizeHandle(iface);
    return ISynchronize_Release(&This->ISynchronize_iface);
}

unlock_init_spies()

static void unlock_init_spies ( struct oletls *  info )

static

Definition at line 1802 of file compobj.c.

{
    struct init_spy *spy, *next;
 
    if (--info->spies_lock) return;
 
    LIST_FOR_EACH_ENTRY_SAFE(spy, next, &info->spies, struct init_spy, entry)
    {
        if (spy->spy) continue;
        list_remove(&spy->entry);
        heap_free(spy);
    }
}

Referenced by CoInitializeEx(), and CoUninitialize().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

ole

)

Variable Documentation

apt_win_class

ATOM apt_win_class

static

Definition at line 483 of file compobj.c.

Referenced by DllMain(), and register_class().

apts

struct list apts = LIST_INIT( apts )

static

Definition at line 78 of file compobj.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().

class_cs_debug

CRITICAL_SECTION_DEBUG class_cs_debug

static

Initial value:

=
{
    0, 0, &csRegisteredClassList,
    { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
}

Definition at line 229 of file compobj.c.

classes_root_hkey

HKEY classes_root_hkey

static

Definition at line 349 of file compobj.c.

Referenced by create_classes_root_hkey(), and get_classes_root_hkey().

classes_rootW

const WCHAR classes_rootW[]

static

Initial value:

=
    {'\\','R','e','g','i','s','t','r','y','\\','M','a','c','h','i','n','e',
     '\\','S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s',0}

Definition at line 344 of file compobj.c.

Referenced by create_classes_root_hkey().

Context_Callback_Vtbl

const IContextCallbackVtbl Context_Callback_Vtbl

static

Initial value:

=
{
    Context_CC_QueryInterface,
    Context_CC_AddRef,
    Context_CC_Release,
    Context_CC_ContextCallback
}

Definition at line 4965 of file compobj.c.

Referenced by CoGetContextToken().

Context_Object_Vtbl

const IObjContextVtbl Context_Object_Vtbl

static

Initial value:

=
{
    Context_OC_QueryInterface,
    Context_OC_AddRef,
    Context_OC_Release,
    Context_OC_SetProperty,
    Context_OC_RemoveProperty,
    Context_OC_GetProperty,
    Context_OC_EnumContextProps,
    Context_OC_Reserved1,
    Context_OC_Reserved2,
    Context_OC_Reserved3,
    Context_OC_Reserved4,
    Context_OC_Reserved5,
    Context_OC_Reserved6,
    Context_OC_Reserved7
}

Definition at line 5065 of file compobj.c.

Referenced by CoGetContextToken().

Context_Threading_Vtbl

const IComThreadingInfoVtbl Context_Threading_Vtbl

static

Initial value:

=
{
    Context_CTI_QueryInterface,
    Context_CTI_AddRef,
    Context_CTI_Release,
    Context_CTI_GetCurrentApartmentType,
    Context_CTI_GetCurrentThreadType,
    Context_CTI_GetCurrentLogicalThreadId,
    Context_CTI_SetCurrentLogicalThreadId
}

Definition at line 4927 of file compobj.c.

Referenced by CoGetContextToken().

critsect_debug

CRITICAL_SECTION_DEBUG critsect_debug

static

Initial value:

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

Definition at line 81 of file compobj.c.

cs_registered_psclsid_list

static CRITICAL_SECTION cs_registered_psclsid_list = { &psclsid_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 174 of file compobj.c.

Referenced by CoGetPSClsid(), CoRegisterPSClsid(), and revoke_registered_psclsids().

csApartment

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

static

Definition at line 80 of file compobj.c.

Referenced by apartment_find_mta(), apartment_findfromoxid(), apartment_findfromtid(), apartment_findmain(), apartment_get_or_create(), apartment_release(), and DllMain().

csOpenDllList

static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 464 of file compobj.c.

Referenced by COMPOBJ_DllList_Add(), COMPOBJ_DllList_Free(), COMPOBJ_DllList_Get(), and COMPOBJ_DllList_ReleaseRef().

csRegisteredClassList

static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 }

static

Definition at line 228 of file compobj.c.

Referenced by CoAddRefServerProcess(), COM_GetRegisteredClassObject(), COM_RevokeAllClasses(), CoRegisterClassObject(), CoReleaseServerProcess(), CoRevokeClassObject(), DllMain(), and LocalServer_QueryService().

dll_cs_debug

CRITICAL_SECTION_DEBUG dll_cs_debug

static

Initial value:

=
{
    0, 0, &csOpenDllList,
    { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
}

Definition at line 465 of file compobj.c.

GlobalOptionsVtbl

const IGlobalOptionsVtbl GlobalOptionsVtbl

static

Initial value:

= {
    GlobalOptions_QueryInterface,
    GlobalOptions_AddRef,
    GlobalOptions_Release,
    GlobalOptions_Set,
    GlobalOptions_Query
}

Definition at line 5343 of file compobj.c.

Referenced by GlobalOptions_CreateInstance().

guid_conv_table

const BYTE guid_conv_table[256]

static

Initial value:

=
{
  0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, 
  0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
  0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             
}

Definition at line 2226 of file compobj.c.

Referenced by guid_from_string().

LocalServerVtbl

const IServiceProviderVtbl LocalServerVtbl

static

Initial value:

= {
    LocalServer_QueryInterface,
    LocalServer_AddRef,
    LocalServer_Release,
    LocalServer_QueryService
}

Definition at line 1018 of file compobj.c.

Referenced by get_local_server_stream().

MainApartment

APARTMENT* MainApartment

static

Definition at line 77 of file compobj.c.

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

MTA

APARTMENT* MTA

static

Definition at line 76 of file compobj.c.

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

openDllList

struct list openDllList = LIST_INIT(openDllList)

static

Definition at line 462 of file compobj.c.

Referenced by COMPOBJ_DllList_Add(), COMPOBJ_DllList_Free(), and COMPOBJ_DllList_Get().

psclsid_cs_debug

CRITICAL_SECTION_DEBUG psclsid_cs_debug

static

Initial value:

=
{
    0, 0, &cs_registered_psclsid_list,
    { &psclsid_cs_debug.ProcessLocksList, &psclsid_cs_debug.ProcessLocksList },
      0, 0, { (DWORD_PTR)(__FILE__ ": cs_registered_psclsid_list") }
}

Definition at line 175 of file compobj.c.

registered_psclsid_list

struct list registered_psclsid_list = LIST_INIT(registered_psclsid_list)

static

Definition at line 172 of file compobj.c.

Referenced by CoGetPSClsid(), CoRegisterPSClsid(), and revoke_registered_psclsids().

RegisteredClassList

struct list RegisteredClassList = LIST_INIT(RegisteredClassList)

static

Definition at line 226 of file compobj.c.

Referenced by COM_GetRegisteredClassObject(), COM_RevokeAllClasses(), CoRegisterClassObject(), CoRevokeClassObject(), and LocalServer_QueryService().

s_COMLockCount

LONG s_COMLockCount = 0

static

Definition at line 202 of file compobj.c.

Referenced by CoInitializeEx(), and CoUninitialize().

s_COMServerProcessReferences

LONG s_COMServerProcessReferences = 0

static

Definition at line 204 of file compobj.c.

Referenced by CoAddRefServerProcess(), and CoReleaseServerProcess().

SynchronizeHandleVtbl

const ISynchronizeHandleVtbl SynchronizeHandleVtbl

static

Initial value:

= {
    SynchronizeHandle_QueryInterface,
    SynchronizeHandle_AddRef,
    SynchronizeHandle_Release,
    SynchronizeHandle_GetHandle
}

Definition at line 918 of file compobj.c.

Referenced by ManualResetEvent_Construct().

vt_ISynchronize

ISynchronizeVtbl vt_ISynchronize

static

Initial value:

= {
    ISynchronize_fnQueryInterface,
    ISynchronize_fnAddRef,
    ISynchronize_fnRelease,
    ISynchronize_fnWait,
    ISynchronize_fnSignal,
    ISynchronize_fnReset
}

Definition at line 878 of file compobj.c.

Referenced by ManualResetEvent_Construct().

wszAptWinClass

const WCHAR wszAptWinClass[] = {'O','l','e','M','a','i','n','T','h','r','e','a','d','W','n','d','C','l','a','s','s',0}

static

Definition at line 481 of file compobj.c.

Referenced by apartment_createwindowifneeded(), and register_class().