#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "olectl.h"
#include "shlguid.h"
#include "shobjidl.h"
#include "wine/test.h"

Include dependency graph for marshal.c:

Classes
struct	tagDUALSTRINGARRAY

struct	tagSTDOBJREF

struct	tagOBJREF

struct	StubBufferWrapper

struct	ProxyBufferWrapper

struct	host_object_data

struct	ncu_params

struct	duo_marshal_data

struct	HeapUnknown

struct	local_server

struct	git_params

struct	implicit_mta_marshal_data

Macros
#define	_WIN32_DCOM

#define	COBJMACROS

#define	CONST_VTABLE

#define	DEFINE_EXPECT(func) static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

#define	SET_EXPECT(func) expect_ ## func = TRUE

#define	CHECK_EXPECT2(func)

#define	CHECK_EXPECT(func)

#define	CHECK_CALLED(func)

#define	ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %ld\n", cLocks)

#define	ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %ld\n", cLocks)

#define	ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error %#08lx\n", hr)

#define	ok_non_zero_external_conn() do {if (with_external_conn) ok(external_connections, "got no external connections\n");} while(0);

#define	ok_zero_external_conn() do {if (with_external_conn) ok(!external_connections, "got %ld external connections\n", external_connections);} while(0);

#define	ok_last_release_closes(b) do {if (with_external_conn) ok(last_release_closes == b, "got %d expected %d\n", last_release_closes, b);} while(0);

#define	OBJREF_SIGNATURE (0x574f454d)

#define	OBJREF_STANDARD (0x1)

#define	OBJREF_CUSTOM (0x4)

#define	EXTENTID_WineTest IID_IWineTest

#define	CLSID_WineTest IID_IWineTest

#define	RELEASEMARSHALDATA WM_USER

#define	NORMALEXTREFS 5

Typedefs
typedef struct tagDUALSTRINGARRAY	DUALSTRINGARRAY

typedef UINT64	OXID

typedef UINT64	OID

typedef GUID	IPID

typedef struct tagSTDOBJREF	STDOBJREF

typedef struct tagOBJREF	OBJREF

Functions
static	HRESULT (WINAPI *pDllGetClassObject)(REFCLSID

static void	test_cocreateinstance_proxy (void)

static void	LockModule (void)

static void	UnlockModule (void)

static HRESULT WINAPI	ExternalConnection_QueryInterface (IExternalConnection iface, REFIID riid, void *ppv)

static ULONG WINAPI	ExternalConnection_AddRef (IExternalConnection *iface)

static ULONG WINAPI	ExternalConnection_Release (IExternalConnection *iface)

static DWORD WINAPI	ExternalConnection_AddConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved)

static DWORD WINAPI	ExternalConnection_ReleaseConnection (IExternalConnection *iface, DWORD extconn, DWORD reserved, BOOL fLastReleaseCloses)

static HRESULT WINAPI	Test_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppvObj)

static ULONG WINAPI	Test_IUnknown_AddRef (LPUNKNOWN iface)

static ULONG WINAPI	Test_IUnknown_Release (LPUNKNOWN iface)

static ULONG WINAPI	TestCrash_IUnknown_Release (LPUNKNOWN iface)

static HRESULT WINAPI	Test_IClassFactory_QueryInterface (LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)

static ULONG WINAPI	Test_IClassFactory_AddRef (LPCLASSFACTORY iface)

static ULONG WINAPI	Test_IClassFactory_Release (LPCLASSFACTORY iface)

static HRESULT WINAPI	Test_IClassFactory_CreateInstance (LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)

static HRESULT WINAPI	Test_IClassFactory_LockServer (LPCLASSFACTORY iface, BOOL fLock)

	DEFINE_EXPECT (Invoke)

	DEFINE_EXPECT (Connect)

	DEFINE_EXPECT (CreateStub)

	DEFINE_EXPECT (CreateProxy)

	DEFINE_EXPECT (GetWindow)

	DEFINE_EXPECT (RpcStubBuffer_Disconnect)

	DEFINE_EXPECT (RpcProxyBuffer_Disconnect)

static HRESULT WINAPI	OleWindow_QueryInterface (IOleWindow iface, REFIID riid, void *ppv)

static ULONG WINAPI	OleWindow_AddRef (IOleWindow *iface)

static ULONG WINAPI	OleWindow_Release (IOleWindow *iface)

static HRESULT WINAPI	OleWindow_GetWindow (IOleWindow iface, HWND hwnd)

static HRESULT WINAPI	OleClientSite_QueryInterface (IOleClientSite iface, REFIID riid, void *ppv)

static ULONG WINAPI	OleClientSite_AddRef (IOleClientSite *iface)

static ULONG WINAPI	OleClientSite_Release (IOleClientSite *iface)

static StubBufferWrapper *	impl_from_IRpcStubBuffer (IRpcStubBuffer *iface)

static HRESULT WINAPI	RpcStubBuffer_QueryInterface (IRpcStubBuffer iface, REFIID riid, void *ppv)

static ULONG WINAPI	RpcStubBuffer_AddRef (IRpcStubBuffer *iface)

static ULONG WINAPI	RpcStubBuffer_Release (IRpcStubBuffer *iface)

static HRESULT WINAPI	RpcStubBuffer_Connect (IRpcStubBuffer iface, IUnknown pUnkServer)

static void WINAPI	RpcStubBuffer_Disconnect (IRpcStubBuffer *iface)

static HRESULT WINAPI	RpcStubBuffer_Invoke (IRpcStubBuffer iface, RPCOLEMESSAGE _prpcmsg, IRpcChannelBuffer *_pRpcChannelBuffer)

static IRpcStubBuffer *WINAPI	RpcStubBuffer_IsIIDSupported (IRpcStubBuffer *iface, REFIID riid)

static ULONG WINAPI	RpcStubBuffer_CountRefs (IRpcStubBuffer *iface)

static HRESULT WINAPI	RpcStubBuffer_DebugServerQueryInterface (IRpcStubBuffer iface, void *ppv)

static void WINAPI	RpcStubBuffer_DebugServerRelease (IRpcStubBuffer iface, void pv)

static ProxyBufferWrapper *	impl_from_IRpcProxyBuffer (IRpcProxyBuffer *iface)

static HRESULT WINAPI	RpcProxyBuffer_QueryInterface (IRpcProxyBuffer iface, REFIID riid, void *ppv)

static ULONG WINAPI	RpcProxyBuffer_AddRef (IRpcProxyBuffer *iface)

static ULONG WINAPI	RpcProxyBuffer_Release (IRpcProxyBuffer *iface)

static HRESULT WINAPI	RpcProxyBuffer_Connect (IRpcProxyBuffer iface, IRpcChannelBuffer pRpcChannelBuffer)

static void WINAPI	RpcProxyBuffer_Disconnect (IRpcProxyBuffer *iface)

static HRESULT WINAPI	PSFactoryBuffer_QueryInterface (IPSFactoryBuffer iface, REFIID riid, void *ppv)

static ULONG WINAPI	PSFactoryBuffer_AddRef (IPSFactoryBuffer *iface)

static ULONG WINAPI	PSFactoryBuffer_Release (IPSFactoryBuffer *iface)

static HRESULT WINAPI	PSFactoryBuffer_CreateProxy (IPSFactoryBuffer iface, IUnknown outer, REFIID riid, IRpcProxyBuffer ppProxy, void ppv)

static HRESULT WINAPI	PSFactoryBuffer_CreateStub (IPSFactoryBuffer iface, REFIID riid, IUnknown server, IRpcStubBuffer **ppStub)

static DWORD CALLBACK	host_object_proc (LPVOID p)

static DWORD	start_host_object2 (struct host_object_data object_data, HANDLE thread)

static DWORD	start_host_object (IStream stream, REFIID riid, IUnknown object, MSHLFLAGS marshal_flags, HANDLE *thread)

static void	release_host_object (DWORD tid, WPARAM wp)

static void	end_host_object (DWORD tid, HANDLE thread)

static void	test_no_marshaler (void)

static void	test_normal_marshal_and_release (void)

static void	test_normal_marshal_and_unmarshal (void)

static void	test_marshal_and_unmarshal_invalid (void)

static void	test_same_apartment_unmarshal_failure (void)

static void	test_interthread_marshal_and_unmarshal (void)

static void	test_proxy_marshal_and_unmarshal (void)

static void	test_proxy_marshal_and_unmarshal2 (void)

static void	test_proxy_marshal_and_unmarshal_weak (void)

static void	test_proxy_marshal_and_unmarshal_strong (void)

static void	test_marshal_stub_apartment_shutdown (void)

static void	test_marshal_proxy_apartment_shutdown (void)

static void	test_marshal_proxy_mta_apartment_shutdown (void)

static void	test_marshal_channel_buffer (void)

	DEFINE_EXPECT (CustomMarshal_GetUnmarshalClass)

	DEFINE_EXPECT (CustomMarshal_GetMarshalSizeMax)

	DEFINE_EXPECT (CustomMarshal_MarshalInterface)

static HRESULT WINAPI	CustomMarshal_QueryInterface (IMarshal iface, REFIID riid, void *ppv)

static ULONG WINAPI	CustomMarshal_AddRef (IMarshal *iface)

static ULONG WINAPI	CustomMarshal_Release (IMarshal *iface)

static HRESULT WINAPI	CustomMarshal_GetUnmarshalClass (IMarshal iface, REFIID riid, void pv, DWORD dwDestContext, void pvDestContext, DWORD mshlflags, CLSID clsid)

static HRESULT WINAPI	CustomMarshal_GetMarshalSizeMax (IMarshal iface, REFIID riid, void pv, DWORD dwDestContext, void pvDestContext, DWORD mshlflags, DWORD size)

static HRESULT WINAPI	CustomMarshal_MarshalInterface (IMarshal iface, IStream stream, REFIID riid, void pv, DWORD dwDestContext, void pvDestContext, DWORD mshlflags)

static HRESULT WINAPI	CustomMarshal_UnmarshalInterface (IMarshal iface, IStream stream, REFIID riid, void **ppv)

static HRESULT WINAPI	CustomMarshal_ReleaseMarshalData (IMarshal iface, IStream stream)

static HRESULT WINAPI	CustomMarshal_DisconnectObject (IMarshal *iface, DWORD res)

static void	test_StdMarshal_custom_marshaling (void)

static void	test_DfMarshal_custom_marshaling (void)

static void	test_CoGetStandardMarshal (void)

static DWORD CALLBACK	no_couninitialize_server_proc (LPVOID p)

static void	test_no_couninitialize_server (void)

static DWORD CALLBACK	no_couninitialize_client_proc (LPVOID p)

static void	test_no_couninitialize_client (void)

static DWORD CALLBACK	crash_couninitialize_proc (void *p)

static void	test_crash_couninitialize (void)

static void	test_tableweak_marshal_and_unmarshal_twice (void)

static void	test_tableweak_marshal_releasedata1 (void)

static void	test_tableweak_marshal_releasedata2 (void)

static DWORD CALLBACK	duo_marshal_thread_proc (void *p)

static void	test_tableweak_and_normal_marshal_and_unmarshal (void)

static void	test_tableweak_and_normal_marshal_and_releasedata (void)

static void	test_two_tableweak_marshal_and_releasedata (void)

static void	test_tablestrong_marshal_and_unmarshal_twice (void)

static void	test_lock_object_external (void)

static void	test_disconnect_stub (void)

static void	test_normal_marshal_and_unmarshal_twice (void)

static void	test_hresult_marshaling (void)

static DWORD CALLBACK	bad_thread_proc (LPVOID p)

static void	test_proxy_used_in_wrong_thread (void)

static HRESULT WINAPI	MessageFilter_QueryInterface (IMessageFilter iface, REFIID riid, void *ppvObj)

static ULONG WINAPI	MessageFilter_AddRef (IMessageFilter *iface)

static ULONG WINAPI	MessageFilter_Release (IMessageFilter *iface)

static DWORD WINAPI	MessageFilter_HandleInComingCall (IMessageFilter *iface, DWORD dwCallType, HTASK threadIDCaller, DWORD dwTickCount, LPINTERFACEINFO lpInterfaceInfo)

static DWORD WINAPI	MessageFilter_RetryRejectedCall (IMessageFilter *iface, HTASK threadIDCallee, DWORD dwTickCount, DWORD dwRejectType)

static DWORD WINAPI	MessageFilter_MessagePending (IMessageFilter *iface, HTASK threadIDCallee, DWORD dwTickCount, DWORD dwPendingType)

static void	test_message_filter (void)

static void	test_bad_marshal_stream (void)

static void	test_proxy_interfaces (void)

static HeapUnknown *	impl_from_IUnknown (IUnknown *iface)

static HRESULT WINAPI	HeapUnknown_QueryInterface (IUnknown iface, REFIID riid, void *ppv)

static ULONG WINAPI	HeapUnknown_AddRef (IUnknown *iface)

static ULONG WINAPI	HeapUnknown_Release (IUnknown *iface)

static void	test_proxybuffer (REFIID riid)

static void	test_stubbuffer (REFIID riid)

static HRESULT WINAPI	TestRE_IClassFactory_CreateInstance (LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)

static LRESULT CALLBACK	window_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)

static void	register_test_window (void)

static void	test_message_reentrancy (void)

static HRESULT WINAPI	TestMsg_IClassFactory_CreateInstance (LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)

static void	test_call_from_message (void)

static void	test_WM_QUIT_handling (void)

static SIZE_T	round_global_size (SIZE_T size)

static void	test_freethreadedmarshaldata (IStream pStream, MSHCTX mshctx, void ptr, DWORD mshlflags)

static void	test_freethreadedmarshaler (void)

static HRESULT	reg_unreg_wine_test_class (BOOL Register)

static void	test_inproc_handler (void)

static HRESULT WINAPI	Test_SMI_QueryInterface (IStdMarshalInfo iface, REFIID riid, LPVOID ppvObj)

static ULONG WINAPI	Test_SMI_AddRef (IStdMarshalInfo *iface)

static ULONG WINAPI	Test_SMI_Release (IStdMarshalInfo *iface)

static HRESULT WINAPI	Test_SMI_GetClassForHandler (IStdMarshalInfo iface, DWORD dwDestContext, void pvDestContext, CLSID *pClsid)

static void	test_handler_marshaling (void)

static void	test_client_security (void)

static void	LockModuleOOP (void)

static void	UnlockModuleOOP (void)

static HRESULT WINAPI	local_server_QueryInterface (IPersist iface, REFIID iid, void *obj)

static ULONG WINAPI	local_server_AddRef (IPersist *iface)

static ULONG WINAPI	local_server_Release (IPersist *iface)

static HRESULT WINAPI	local_server_GetClassID (IPersist iface, CLSID clsid)

static HRESULT WINAPI	TestOOP_IClassFactory_QueryInterface (LPCLASSFACTORY iface, REFIID riid, LPVOID *ppvObj)

static ULONG WINAPI	TestOOP_IClassFactory_AddRef (LPCLASSFACTORY iface)

static ULONG WINAPI	TestOOP_IClassFactory_Release (LPCLASSFACTORY iface)

static HRESULT WINAPI	TestOOP_IClassFactory_CreateInstance (LPCLASSFACTORY iface, LPUNKNOWN pUnkOuter, REFIID riid, LPVOID *ppvObj)

static HRESULT WINAPI	TestOOP_IClassFactory_LockServer (LPCLASSFACTORY iface, BOOL fLock)

static void	test_register_local_server (void)

static HANDLE	create_target_process (const char *arg)

static void	test_local_server (void)

static DWORD CALLBACK	get_global_interface_proc (LPVOID pv)

static void	test_globalinterfacetable (void)

static void	test_manualresetevent (void)

static DWORD CALLBACK	implicit_mta_unmarshal_proc (void *param)

static DWORD CALLBACK	implicit_mta_use_proc (void *param)

static DWORD CALLBACK	implicit_mta_marshal_proc (void *param)

static void	test_implicit_mta (void)

static HRESULT WINAPI	TestChannelHook_QueryInterface (IChannelHook iface, REFIID riid, void *ppv)

static ULONG WINAPI	TestChannelHook_AddRef (IChannelHook *iface)

static ULONG WINAPI	TestChannelHook_Release (IChannelHook *iface)

static void WINAPI	TestChannelHook_ClientGetSize (IChannelHook iface, REFGUID uExtent, REFIID riid, ULONG pDataSize)

static void WINAPI	TestChannelHook_ClientFillBuffer (IChannelHook iface, REFGUID uExtent, REFIID riid, ULONG pDataSize, void *pDataBuffer)

static void WINAPI	TestChannelHook_ClientNotify (IChannelHook iface, REFGUID uExtent, REFIID riid, ULONG cbDataSize, void pDataBuffer, DWORD lDataRep, HRESULT hrFault)

static void WINAPI	TestChannelHook_ServerNotify (IChannelHook iface, REFGUID uExtent, REFIID riid, ULONG cbDataSize, void pDataBuffer, DWORD lDataRep)

static void WINAPI	TestChannelHook_ServerGetSize (IChannelHook iface, REFGUID uExtent, REFIID riid, HRESULT hrFault, ULONG pDataSize)

static void WINAPI	TestChannelHook_ServerFillBuffer (IChannelHook iface, REFGUID uExtent, REFIID riid, ULONG pDataSize, void *pDataBuffer, HRESULT hrFault)

static void	test_channel_hook (void)

static DWORD CALLBACK	second_mta_thread_proc (void *param)

static void	test_mta_creation_thread_change_apartment (void)

	START_TEST (marshal)

Variables
static const GUID	CLSID_WineTestPSFactoryBuffer = { 0x22222222, 0x1234, 0x1234, { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 } }

static const GUID	CLSID_DfMarshal = { 0x0000030b, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } }

static const GUID	CLSID_ft_unmarshaler_1809 = {0x00000359, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}

static	REFIID

static	LPVOID

static const IID	IID_IWineTest

static const IID	IID_IRemUnknown

static const CLSID	CLSID_WineOOPTest

static const LARGE_INTEGER	ullZero

static LONG	cLocks

static BOOL	with_external_conn

static DWORD	external_connections

static BOOL	last_release_closes

static const IExternalConnectionVtbl	ExternalConnectionVtbl

static IExternalConnection	ExternalConnection = { &ExternalConnectionVtbl }

static const IUnknownVtbl	TestUnknown_Vtbl

static IUnknown	Test_Unknown = { &TestUnknown_Vtbl }

static const IUnknownVtbl	TestCrashUnknown_Vtbl

static IUnknown	TestCrash_Unknown = { &TestCrashUnknown_Vtbl }

static const IClassFactoryVtbl	TestClassFactory_Vtbl

static IClassFactory	Test_ClassFactory = { &TestClassFactory_Vtbl }

static const IOleWindowVtbl	OleWindowVtbl

static IOleWindow	Test_OleWindow = { &OleWindowVtbl }

static const IOleClientSiteVtbl	OleClientSiteVtbl

static IOleClientSite	Test_OleClientSite = { &OleClientSiteVtbl }

static const IRpcStubBufferVtbl	RpcStubBufferVtbl

static const IRpcProxyBufferVtbl	RpcProxyBufferVtbl

static IPSFactoryBuffer *	ps_factory_buffer

static IPSFactoryBufferVtbl	PSFactoryBufferVtbl

static IPSFactoryBuffer	PSFactoryBuffer = { &PSFactoryBufferVtbl }

static const CLSID *	unmarshal_class

static IMarshalVtbl	CustomMarshalVtbl

static IMarshal	CustomMarshal = { &CustomMarshalVtbl }

static BOOL	crash_thread_success

static const IMessageFilterVtbl	MessageFilter_Vtbl

static IMessageFilter	MessageFilter = { &MessageFilter_Vtbl }

static const IUnknownVtbl	HeapUnknown_Vtbl

static HWND	hwnd_app

static const IClassFactoryVtbl	TestREClassFactory_Vtbl

static IClassFactory	TestRE_ClassFactory = { &TestREClassFactory_Vtbl }

static IClassFactoryVtbl	TestMsgClassFactory_Vtbl

static IClassFactory	TestMsg_ClassFactory = { &TestMsgClassFactory_Vtbl }

static const IStdMarshalInfoVtbl	Test_SMI_Vtbl

static IStdMarshalInfo	Test_SMI = {&Test_SMI_Vtbl}

static HANDLE	heventShutdown

static const IPersistVtbl	local_server_persist_vtbl

struct local_server	local_server_class

static const IClassFactoryVtbl	TestClassFactoryOOP_Vtbl

static IClassFactory	TestOOP_ClassFactory = { &TestClassFactoryOOP_Vtbl }

static int	method

static GUID	causality

static const IChannelHookVtbl	TestChannelHookVtbl

static IChannelHook	TestChannelHook = { &TestChannelHookVtbl }

Macro Definition Documentation

◆ _WIN32_DCOM

#define _WIN32_DCOM

Definition at line 21 of file marshal.c.

◆ CHECK_CALLED

#define CHECK_CALLED ( func )

Value:

    do { \
        ok(called_ ## func, "expected " #func "\n"); \
        expect_ ## func = called_ ## func = FALSE; \
    }while(0)

Definition at line 55 of file marshal.c.

◆ CHECK_EXPECT

#define CHECK_EXPECT ( func )

Value:

    do { \
        CHECK_EXPECT2(func); \
        expect_ ## func = FALSE; \
    }while(0)

Definition at line 49 of file marshal.c.

◆ CHECK_EXPECT2

#define CHECK_EXPECT2 ( func )

Value:

    do { \
        ok(expect_ ##func, "unexpected call " #func "\n"); \
        called_ ## func = TRUE; \
    }while(0)

Definition at line 43 of file marshal.c.

◆ CLSID_WineTest

#define CLSID_WineTest IID_IWineTest

Definition at line 138 of file marshal.c.

◆ COBJMACROS

#define COBJMACROS

Definition at line 22 of file marshal.c.

◆ CONST_VTABLE

#define CONST_VTABLE

Definition at line 23 of file marshal.c.

◆ DEFINE_EXPECT

#define DEFINE_EXPECT ( func ) static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

Definition at line 37 of file marshal.c.

◆ EXTENTID_WineTest

#define EXTENTID_WineTest IID_IWineTest

Definition at line 137 of file marshal.c.

◆ NORMALEXTREFS

#define NORMALEXTREFS 5

Definition at line 984 of file marshal.c.

◆ OBJREF_CUSTOM

#define OBJREF_CUSTOM (0x4)

Definition at line 78 of file marshal.c.

◆ OBJREF_SIGNATURE

#define OBJREF_SIGNATURE (0x574f454d)

Definition at line 76 of file marshal.c.

◆ OBJREF_STANDARD

#define OBJREF_STANDARD (0x1)

Definition at line 77 of file marshal.c.

◆ ok_last_release_closes

#define ok_last_release_closes ( b ) do {if (with_external_conn) ok(last_release_closes == b, "got %d expected %d\n", last_release_closes, b);} while(0);

Definition at line 74 of file marshal.c.

◆ ok_more_than_one_lock

#define ok_more_than_one_lock ( ) ok(cLocks > 0, "Number of locks should be > 0, but actually is %ld\n", cLocks)

Definition at line 69 of file marshal.c.

◆ ok_no_locks

#define ok_no_locks ( ) ok(cLocks == 0, "Number of locks should be 0, but actually is %ld\n", cLocks)

Definition at line 70 of file marshal.c.

◆ ok_non_zero_external_conn

#define ok_non_zero_external_conn ( ) do {if (with_external_conn) ok(external_connections, "got no external connections\n");} while(0);

Definition at line 72 of file marshal.c.

◆ ok_ole_success

#define ok_ole_success	(	hr,
		func
	)	ok(hr == S_OK, #func " failed with error %#08lx\n", hr)

Definition at line 71 of file marshal.c.

◆ ok_zero_external_conn

#define ok_zero_external_conn ( ) do {if (with_external_conn) ok(!external_connections, "got %ld external connections\n", external_connections);} while(0);

Definition at line 73 of file marshal.c.

◆ RELEASEMARSHALDATA

#define RELEASEMARSHALDATA WM_USER

Definition at line 686 of file marshal.c.

◆ SET_EXPECT

#define SET_EXPECT ( func ) expect_ ## func = TRUE

Definition at line 40 of file marshal.c.

Typedef Documentation

◆ DUALSTRINGARRAY

typedef struct tagDUALSTRINGARRAY DUALSTRINGARRAY

◆ IPID

typedef GUID IPID

Definition at line 88 of file marshal.c.

◆ OBJREF

typedef struct tagOBJREF OBJREF

◆ OID

typedef UINT64 OID

Definition at line 87 of file marshal.c.

◆ OXID

typedef UINT64 OXID

Definition at line 86 of file marshal.c.

◆ STDOBJREF

typedef struct tagSTDOBJREF STDOBJREF

Function Documentation

◆ bad_thread_proc()

static DWORD CALLBACK bad_thread_proc ( LPVOID p )

static

Definition at line 2559 of file marshal.c.

{
    IClassFactory * cf = p;
    HRESULT hr;
    IUnknown * proxy = NULL;
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
    todo_wine ok(hr == CO_E_NOTINITIALIZED, "Got hr %#lx.\n", hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IMultiQI, (LPVOID *)&proxy);
    todo_wine ok(hr == RPC_E_WRONG_THREAD, "Got hr %#lx.\n", hr);
    if (SUCCEEDED(hr))
        IUnknown_Release(proxy);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
    todo_wine ok(hr == RPC_E_WRONG_THREAD, "Got hr %#lx.\n", hr);
    if (SUCCEEDED(hr))
        IUnknown_Release(proxy);
 
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
    if (proxy) IUnknown_Release(proxy);
    ok(hr == RPC_E_WRONG_THREAD,
        "COM should have failed with RPC_E_WRONG_THREAD on using proxy from wrong apartment, but instead returned 0x%08lx\n",
        hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
    todo_wine ok(hr == RPC_E_WRONG_THREAD, "Got hr %#lx.\n", hr);
 
    /* now be really bad and release the proxy from the wrong apartment */
    IClassFactory_Release(cf);
 
    CoUninitialize();
 
    return 0;
}

Referenced by test_proxy_used_in_wrong_thread().

◆ crash_couninitialize_proc()

static DWORD CALLBACK crash_couninitialize_proc ( void * p )

static

Definition at line 1874 of file marshal.c.

{
    IStream *stream;
    HRESULT hr;
 
    cLocks = 0;
 
    CoInitialize(NULL);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
 
    hr = CoReleaseMarshalData(stream);
    ok_ole_success(hr, CoReleaseMarshalData);
 
    ok_no_locks();
 
    hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
 
    trace("CoUninitialize >>>\n");
    CoUninitialize();
    trace("CoUninitialize <<<\n");
 
    ok_no_locks();
 
    IStream_Release(stream);
    crash_thread_success = TRUE;
    return 0;
}

Referenced by test_crash_couninitialize().

◆ create_target_process()

static HANDLE create_target_process ( const char * arg )

static

Definition at line 3878 of file marshal.c.

{
    char **argv;
    char cmdline[MAX_PATH];
    BOOL ret;
    PROCESS_INFORMATION pi;
    STARTUPINFOA si = { 0 };
    si.cb = sizeof(si);
 
    pi.hThread = NULL;
    pi.hProcess = NULL;
    winetest_get_mainargs( &argv );
    sprintf(cmdline, "\"%s\" %s %s", argv[0], argv[1], arg);
    ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
    ok(ret, "CreateProcess failed with error: %lu\n", GetLastError());
    if (pi.hThread) CloseHandle(pi.hThread);
    return pi.hProcess;
}

Referenced by test_local_server().

◆ CustomMarshal_AddRef()

static ULONG WINAPI CustomMarshal_AddRef ( IMarshal * iface )

static

Definition at line 1466 of file marshal.c.

{
    return 2;
}

◆ CustomMarshal_DisconnectObject()

static HRESULT WINAPI CustomMarshal_DisconnectObject	(	IMarshal *	iface,
		DWORD	res
	)

static

Definition at line 1535 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ CustomMarshal_GetMarshalSizeMax()

static HRESULT WINAPI CustomMarshal_GetMarshalSizeMax	(	IMarshal *	iface,
		REFIID	riid,
		void *	pv,
		DWORD	dwDestContext,
		void *	pvDestContext,
		DWORD	mshlflags,
		DWORD *	size
	)

static

Definition at line 1484 of file marshal.c.

{
    CHECK_EXPECT(CustomMarshal_GetMarshalSizeMax);
    ok(size != NULL, "size = NULL\n");
 
    *size = 0;
    return S_OK;
}

Referenced by CustomMarshal_GetMarshalSizeMax(), test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

◆ CustomMarshal_GetUnmarshalClass()

static HRESULT WINAPI CustomMarshal_GetUnmarshalClass	(	IMarshal *	iface,
		REFIID	riid,
		void *	pv,
		DWORD	dwDestContext,
		void *	pvDestContext,
		DWORD	mshlflags,
		CLSID *	clsid
	)

static

Definition at line 1476 of file marshal.c.

{
    CHECK_EXPECT2(CustomMarshal_GetUnmarshalClass);
    *clsid = *unmarshal_class;
    return S_OK;
}

Referenced by CustomMarshal_GetUnmarshalClass(), test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

◆ CustomMarshal_MarshalInterface()

static HRESULT WINAPI CustomMarshal_MarshalInterface	(	IMarshal *	iface,
		IStream *	stream,
		REFIID	riid,
		void *	pv,
		DWORD	dwDestContext,
		void *	pvDestContext,
		DWORD	mshlflags
	)

static

Definition at line 1494 of file marshal.c.

{
    IMarshal *std_marshal;
    STATSTG stat;
    HRESULT hr;
 
    CHECK_EXPECT(CustomMarshal_MarshalInterface);
 
    if(unmarshal_class != &CLSID_StdMarshal)
        return S_OK;
 
    hr = IStream_Stat(stream, &stat, STATFLAG_DEFAULT);
    ok_ole_success(hr, IStream_Stat);
    ok(stat.cbSize.LowPart == 0, "stream is not empty (%ld)\n", stat.cbSize.LowPart);
    ok(stat.cbSize.HighPart == 0, "stream is not empty (%ld)\n", stat.cbSize.HighPart);
 
    hr = CoGetStandardMarshal(riid, (IUnknown*)iface,
            dwDestContext, NULL, mshlflags, &std_marshal);
    ok_ole_success(hr, CoGetStandardMarshal);
    hr = IMarshal_MarshalInterface(std_marshal, stream, riid, pv,
            dwDestContext, pvDestContext, mshlflags);
    ok_ole_success(hr, IMarshal_MarshalInterface);
    IMarshal_Release(std_marshal);
 
    return S_OK;
}

Referenced by CustomMarshal_MarshalInterface(), test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

◆ CustomMarshal_QueryInterface()

static HRESULT WINAPI CustomMarshal_QueryInterface	(	IMarshal *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 1452 of file marshal.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IMarshal)) {
        *ppv = iface;
    }
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ CustomMarshal_Release()

static ULONG WINAPI CustomMarshal_Release ( IMarshal * iface )

static

Definition at line 1471 of file marshal.c.

{
    return 1;
}

◆ CustomMarshal_ReleaseMarshalData()

static HRESULT WINAPI CustomMarshal_ReleaseMarshalData	(	IMarshal *	iface,
		IStream *	stream
	)

static

Definition at line 1529 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ CustomMarshal_UnmarshalInterface()

static HRESULT WINAPI CustomMarshal_UnmarshalInterface	(	IMarshal *	iface,
		IStream *	stream,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 1522 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ DEFINE_EXPECT() [1/10]

DEFINE_EXPECT ( Connect )

◆ DEFINE_EXPECT() [2/10]

DEFINE_EXPECT ( CreateProxy )

◆ DEFINE_EXPECT() [3/10]

DEFINE_EXPECT ( CreateStub )

◆ DEFINE_EXPECT() [4/10]

DEFINE_EXPECT ( CustomMarshal_GetMarshalSizeMax )

◆ DEFINE_EXPECT() [5/10]

DEFINE_EXPECT ( CustomMarshal_GetUnmarshalClass )

◆ DEFINE_EXPECT() [6/10]

DEFINE_EXPECT ( CustomMarshal_MarshalInterface )

◆ DEFINE_EXPECT() [7/10]

DEFINE_EXPECT ( GetWindow )

◆ DEFINE_EXPECT() [8/10]

DEFINE_EXPECT ( Invoke )

◆ DEFINE_EXPECT() [9/10]

DEFINE_EXPECT ( RpcProxyBuffer_Disconnect )

◆ DEFINE_EXPECT() [10/10]

DEFINE_EXPECT ( RpcStubBuffer_Disconnect )

◆ duo_marshal_thread_proc()

static DWORD CALLBACK duo_marshal_thread_proc ( void * p )

static

Definition at line 2091 of file marshal.c.

{
    HRESULT hr;
    struct duo_marshal_data *data = p;
    HANDLE hQuitEvent = data->hQuitEvent;
    MSG msg;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = CoMarshalInterface(data->pStream1, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, data->marshal_flags1);
    ok_ole_success(hr, "CoMarshalInterface");
 
    hr = CoMarshalInterface(data->pStream2, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, data->marshal_flags2);
    ok_ole_success(hr, "CoMarshalInterface");
 
    /* force the message queue to be created before signaling parent thread */
    PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 
    SetEvent(data->hReadyEvent);
 
    while (WAIT_OBJECT_0 + 1 == MsgWaitForMultipleObjects(1, &hQuitEvent, FALSE, 10000, QS_ALLINPUT))
    {
        while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
        {
            if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
            {
                CoReleaseMarshalData(msg.wParam == 1 ? data->pStream1 : data->pStream2);
                SetEvent((HANDLE)msg.lParam);
            }
            else
                DispatchMessageA(&msg);
        }
    }
    CloseHandle(hQuitEvent);
 
    CoUninitialize();
 
    return 0;
}

Referenced by test_tableweak_and_normal_marshal_and_releasedata(), test_tableweak_and_normal_marshal_and_unmarshal(), and test_two_tableweak_marshal_and_releasedata().

◆ end_host_object()

static void end_host_object	(	DWORD	tid,
		HANDLE	thread
	)

static

Definition at line 784 of file marshal.c.

{
    BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
    ok(ret, "PostThreadMessage failed with error %ld\n", GetLastError());
    /* be careful of races - don't return until hosting thread has terminated */
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
}

◆ ExternalConnection_AddConnection()

static DWORD WINAPI ExternalConnection_AddConnection	(	IExternalConnection *	iface,
		DWORD	extconn,
		DWORD	reserved
	)

static

Definition at line 201 of file marshal.c.

{
    if (winetest_debug > 1) trace("add connection\n");
    return ++external_connections;
}

◆ ExternalConnection_AddRef()

static ULONG WINAPI ExternalConnection_AddRef ( IExternalConnection * iface )

static

Definition at line 191 of file marshal.c.

{
    return 2;
}

◆ ExternalConnection_QueryInterface()

static HRESULT WINAPI ExternalConnection_QueryInterface	(	IExternalConnection *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 184 of file marshal.c.

{
    ok(0, "unexpected call\n");
    *ppv = NULL;
    return E_NOINTERFACE;
}

◆ ExternalConnection_Release()

static ULONG WINAPI ExternalConnection_Release ( IExternalConnection * iface )

static

Definition at line 196 of file marshal.c.

{
    return 1;
}

◆ ExternalConnection_ReleaseConnection()

static DWORD WINAPI ExternalConnection_ReleaseConnection	(	IExternalConnection *	iface,
		DWORD	extconn,
		DWORD	reserved,
		BOOL	fLastReleaseCloses
	)

static

Definition at line 208 of file marshal.c.

{
    if (winetest_debug > 1) trace("release connection %d\n", fLastReleaseCloses);
    last_release_closes = fLastReleaseCloses;
    return --external_connections;
}

◆ get_global_interface_proc()

static DWORD CALLBACK get_global_interface_proc ( LPVOID pv )

static

Definition at line 4009 of file marshal.c.

{
    HRESULT hr;
    struct git_params *params = pv;
    IClassFactory *cf;
 
    hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(params->git, params->cookie, &IID_IClassFactory, (void **)&cf);
    ok(hr == CO_E_NOTINITIALIZED, "Got hr %#lx.\n", hr);
 
    CoInitialize(NULL);
 
    hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(params->git, params->cookie, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, IGlobalInterfaceTable_GetInterfaceFromGlobal);
 
    IClassFactory_Release(cf);
 
    CoUninitialize();
 
    return hr;
}

Referenced by test_globalinterfacetable().

◆ HeapUnknown_AddRef()

static ULONG WINAPI HeapUnknown_AddRef ( IUnknown * iface )

static

Definition at line 2868 of file marshal.c.

{
    HeapUnknown *This = impl_from_IUnknown(iface);
    return InterlockedIncrement((LONG*)&This->refs);
}

◆ HeapUnknown_QueryInterface()

static HRESULT WINAPI HeapUnknown_QueryInterface	(	IUnknown *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 2856 of file marshal.c.

{
    if (IsEqualIID(riid, &IID_IUnknown))
    {
        IUnknown_AddRef(iface);
        *ppv = iface;
        return S_OK;
    }
    *ppv = NULL;
    return E_NOINTERFACE;
}

◆ HeapUnknown_Release()

static ULONG WINAPI HeapUnknown_Release ( IUnknown * iface )

static

Definition at line 2874 of file marshal.c.

{
    HeapUnknown *This = impl_from_IUnknown(iface);
    ULONG refs = InterlockedDecrement((LONG*)&This->refs);
    if (!refs) HeapFree(GetProcessHeap(), 0, This);
    return refs;
}

◆ host_object_proc()

static DWORD CALLBACK host_object_proc ( LPVOID p )

static

Definition at line 702 of file marshal.c.

{
    struct host_object_data *data = p;
    DWORD registration_key;
    HRESULT hr;
    MSG msg;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    if(data->register_object) {
        hr = CoRegisterClassObject(data->register_clsid, data->register_object,
            CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &registration_key);
        ok(hr == S_OK, "CoRegisterClassObject failed: %08lx\n", hr);
    }
 
    if (data->filter)
    {
        IMessageFilter * prev_filter = NULL;
        hr = CoRegisterMessageFilter(data->filter, &prev_filter);
        if (prev_filter) IMessageFilter_Release(prev_filter);
        ok_ole_success(hr, CoRegisterMessageFilter);
    }
 
    hr = CoMarshalInterface(data->stream, data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
    ok_ole_success(hr, CoMarshalInterface);
 
    /* force the message queue to be created before signaling parent thread */
    PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 
    SetEvent(data->marshal_event);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
        {
            CoReleaseMarshalData(data->stream);
            SetEvent((HANDLE)msg.lParam);
        }
        else
            DispatchMessageA(&msg);
    }
 
    free(data);
 
    CoUninitialize();
 
    return hr;
}

Referenced by start_host_object2().

◆ HRESULT()

static HRESULT ( WINAPI * pDllGetClassObject )

static

◆ impl_from_IRpcProxyBuffer()

static ProxyBufferWrapper * impl_from_IRpcProxyBuffer ( IRpcProxyBuffer * iface )

static

Definition at line 543 of file marshal.c.

{
    return CONTAINING_RECORD(iface, ProxyBufferWrapper, IRpcProxyBuffer_iface);
}

Referenced by RpcProxyBuffer_AddRef(), RpcProxyBuffer_Connect(), RpcProxyBuffer_QueryInterface(), and RpcProxyBuffer_Release().

◆ impl_from_IRpcStubBuffer()

static StubBufferWrapper * impl_from_IRpcStubBuffer ( IRpcStubBuffer * iface )

static

Definition at line 435 of file marshal.c.

{
    return CONTAINING_RECORD(iface, StubBufferWrapper, IRpcStubBuffer_iface);
}

Referenced by RpcStubBuffer_AddRef(), RpcStubBuffer_Invoke(), RpcStubBuffer_QueryInterface(), and RpcStubBuffer_Release().

◆ impl_from_IUnknown()

static HeapUnknown * impl_from_IUnknown ( IUnknown * iface )

inlinestatic

Definition at line 2851 of file marshal.c.

{
    return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface);
}

Referenced by HeapUnknown_AddRef(), and HeapUnknown_Release().

◆ implicit_mta_marshal_proc()

static DWORD CALLBACK implicit_mta_marshal_proc ( void * param )

static

Definition at line 4257 of file marshal.c.

{
    struct implicit_mta_marshal_data *data = param;
    HRESULT hr;
 
    hr = CoMarshalInterface(data->stream, &IID_IClassFactory,
        (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    SetEvent(data->start);
 
    ok(!WaitForSingleObject(data->stop, 1000), "wait failed\n");
    return 0;
}

Referenced by test_implicit_mta().

◆ implicit_mta_unmarshal_proc()

static DWORD CALLBACK implicit_mta_unmarshal_proc ( void * param )

static

Definition at line 4194 of file marshal.c.

{
    IStream *stream = param;
    IClassFactory *cf;
    IUnknown *proxy;
    HRESULT hr;
 
    IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IUnknown_Release(proxy);
 
    /* But if we initialize an STA in this apartment, it becomes the wrong one. */
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok(hr == RPC_E_WRONG_THREAD, "got %#lx\n", hr);
 
    CoUninitialize();
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IClassFactory_Release(cf);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
    return 0;
}

Referenced by test_implicit_mta().

◆ implicit_mta_use_proc()

static DWORD CALLBACK implicit_mta_use_proc ( void * param )

static

Definition at line 4229 of file marshal.c.

{
    IClassFactory *cf = param;
    IUnknown *proxy;
    HRESULT hr;
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IUnknown_Release(proxy);
 
    /* But if we initialize an STA in this apartment, it becomes the wrong one. */
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok(hr == RPC_E_WRONG_THREAD, "got %#lx\n", hr);
 
    CoUninitialize();
    return 0;
}

Referenced by test_implicit_mta().

◆ local_server_AddRef()

static ULONG WINAPI local_server_AddRef ( IPersist * iface )

static

Definition at line 3723 of file marshal.c.

{
    return 2;
}

◆ local_server_GetClassID()

static HRESULT WINAPI local_server_GetClassID	(	IPersist *	iface,
		CLSID *	clsid
	)

static

Definition at line 3733 of file marshal.c.

{
    HRESULT hr;
 
    *clsid = IID_IUnknown;
 
    /* Test calling CoDisconnectObject within a COM call */
    hr = CoDisconnectObject((IUnknown *)iface, 0);
    ok(hr == S_OK, "got %08lx\n", hr);
 
    /* Initialize and uninitialize the apartment to show that we
     * remain in the autojoined mta */
    hr = CoInitializeEx( NULL, COINIT_MULTITHREADED );
    ok( hr == S_FALSE, "got %08lx\n", hr );
    CoUninitialize();
 
    return S_OK;
}

◆ local_server_QueryInterface()

static HRESULT WINAPI local_server_QueryInterface	(	IPersist *	iface,
		REFIID	iid,
		void **	obj
	)

static

Definition at line 3707 of file marshal.c.

{
    *obj = NULL;
 
    if (IsEqualGUID(iid, &IID_IUnknown) ||
        IsEqualGUID(iid, &IID_IPersist))
        *obj = iface;
 
    if (*obj)
    {
        IPersist_AddRef(iface);
        return S_OK;
    }
    return E_NOINTERFACE;
}

◆ local_server_Release()

static ULONG WINAPI local_server_Release ( IPersist * iface )

static

Definition at line 3728 of file marshal.c.

{
    return 1;
}

◆ LockModule()

static void LockModule ( void )

static

Definition at line 170 of file marshal.c.

{
    InterlockedIncrement(&cLocks);
}

Referenced by Test_IClassFactory_AddRef(), Test_IUnknown_AddRef(), and Test_SMI_AddRef().

◆ LockModuleOOP()

static void LockModuleOOP ( void )

static

Definition at line 3687 of file marshal.c.

{
    InterlockedIncrement(&cLocks); /* for test purposes only */
    CoAddRefServerProcess();
}

Referenced by TestOOP_IClassFactory_LockServer().

◆ MessageFilter_AddRef()

static ULONG WINAPI MessageFilter_AddRef ( IMessageFilter * iface )

static

Definition at line 2651 of file marshal.c.

{
    return 2; /* non-heap object */
}

◆ MessageFilter_HandleInComingCall()

static DWORD WINAPI MessageFilter_HandleInComingCall	(	IMessageFilter *	iface,
		DWORD	dwCallType,
		HTASK	threadIDCaller,
		DWORD	dwTickCount,
		LPINTERFACEINFO	lpInterfaceInfo
	)

static

Definition at line 2661 of file marshal.c.

{
    static int callcount = 0;
    DWORD ret;
    if (winetest_debug > 1) trace("HandleInComingCall()\n");
    switch (callcount)
    {
    case 0:
        ret = SERVERCALL_REJECTED;
        break;
    case 1:
        ret = SERVERCALL_RETRYLATER;
        break;
    default:
        ret = SERVERCALL_ISHANDLED;
        break;
    }
    callcount++;
    return ret;
}

◆ MessageFilter_MessagePending()

static DWORD WINAPI MessageFilter_MessagePending	(	IMessageFilter *	iface,
		HTASK	threadIDCallee,
		DWORD	dwTickCount,
		DWORD	dwPendingType
	)

static

Definition at line 2697 of file marshal.c.

{
    if (winetest_debug > 1) trace("MessagePending()\n");
    return PENDINGMSG_WAITNOPROCESS;
}

◆ MessageFilter_QueryInterface()

static HRESULT WINAPI MessageFilter_QueryInterface	(	IMessageFilter *	iface,
		REFIID	riid,
		void **	ppvObj
	)

static

Definition at line 2636 of file marshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IClassFactory))
    {
        *ppvObj = iface;
        IMessageFilter_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

◆ MessageFilter_Release()

static ULONG WINAPI MessageFilter_Release ( IMessageFilter * iface )

static

Definition at line 2656 of file marshal.c.

{
    return 1; /* non-heap object */
}

◆ MessageFilter_RetryRejectedCall()

static DWORD WINAPI MessageFilter_RetryRejectedCall	(	IMessageFilter *	iface,
		HTASK	threadIDCallee,
		DWORD	dwTickCount,
		DWORD	dwRejectType
	)

static

Definition at line 2687 of file marshal.c.

{
    if (winetest_debug > 1) trace("RetryRejectedCall()\n");
    return 0;
}

◆ no_couninitialize_client_proc()

static DWORD CALLBACK no_couninitialize_client_proc ( LPVOID p )

static

Definition at line 1815 of file marshal.c.

{
    struct ncu_params *ncu_params = p;
    HRESULT hr;
    IUnknown *pProxy = NULL;
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    hr = CoUnmarshalInterface(ncu_params->stream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(ncu_params->stream);
 
    ok_more_than_one_lock();
 
    /* die without calling CoUninitialize */
 
    return 0;
}

Referenced by test_no_couninitialize_client().

◆ no_couninitialize_server_proc()

static DWORD CALLBACK no_couninitialize_server_proc ( LPVOID p )

static

Definition at line 1742 of file marshal.c.

{
    struct ncu_params *ncu_params = p;
    HRESULT hr;
 
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    hr = CoMarshalInterface(ncu_params->stream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    SetEvent(ncu_params->marshal_event);
 
    ok( !WaitForSingleObject(ncu_params->unmarshal_event, 10000), "wait timed out\n" );
 
    /* die without calling CoUninitialize */
 
    return 0;
}

Referenced by test_no_couninitialize_server().

◆ OleClientSite_AddRef()

static ULONG WINAPI OleClientSite_AddRef ( IOleClientSite * iface )

static

Definition at line 410 of file marshal.c.

{
    return 2;
}

◆ OleClientSite_QueryInterface()

static HRESULT WINAPI OleClientSite_QueryInterface	(	IOleClientSite *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 394 of file marshal.c.

{
    if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleClientSite))
        *ppv = iface;
    else if (IsEqualGUID(riid, &IID_IOleWindow))
        *ppv = &Test_OleWindow;
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ OleClientSite_Release()

static ULONG WINAPI OleClientSite_Release ( IOleClientSite * iface )

static

Definition at line 415 of file marshal.c.

{
    return 1;
}

◆ OleWindow_AddRef()

static ULONG WINAPI OleWindow_AddRef ( IOleWindow * iface )

static

Definition at line 367 of file marshal.c.

{
    return 2;
}

◆ OleWindow_GetWindow()

static HRESULT WINAPI OleWindow_GetWindow	(	IOleWindow *	iface,
		HWND *	hwnd
	)

static

Definition at line 377 of file marshal.c.

{
    CHECK_EXPECT(GetWindow);
    *hwnd = (HWND)0xdeadbeef;
    return S_OK;
}

◆ OleWindow_QueryInterface()

static HRESULT WINAPI OleWindow_QueryInterface	(	IOleWindow *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 360 of file marshal.c.

{
    ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
    *ppv = NULL;
    return E_NOINTERFACE;
}

◆ OleWindow_Release()

static ULONG WINAPI OleWindow_Release ( IOleWindow * iface )

static

Definition at line 372 of file marshal.c.

{
    return 1;
}

◆ PSFactoryBuffer_AddRef()

static ULONG WINAPI PSFactoryBuffer_AddRef ( IPSFactoryBuffer * iface )

static

Definition at line 625 of file marshal.c.

{
    return 2;
}

◆ PSFactoryBuffer_CreateProxy()

static HRESULT WINAPI PSFactoryBuffer_CreateProxy	(	IPSFactoryBuffer *	iface,
		IUnknown *	outer,
		REFIID	riid,
		IRpcProxyBuffer **	ppProxy,
		void **	ppv
	)

static

Definition at line 635 of file marshal.c.

{
    ProxyBufferWrapper *proxy;
    HRESULT hr;
 
    CHECK_EXPECT(CreateProxy);
    proxy = malloc(sizeof(*proxy));
    proxy->IRpcProxyBuffer_iface.lpVtbl = &RpcProxyBufferVtbl;
    proxy->ref = 1;
 
    hr = IPSFactoryBuffer_CreateProxy(ps_factory_buffer, outer, riid, &proxy->buffer, ppv);
    ok(hr == S_OK, "CreateProxy failed: %08lx\n", hr);
 
    *ppProxy = &proxy->IRpcProxyBuffer_iface;
 
    return S_OK;
}

◆ PSFactoryBuffer_CreateStub()

static HRESULT WINAPI PSFactoryBuffer_CreateStub	(	IPSFactoryBuffer *	iface,
		REFIID	riid,
		IUnknown *	server,
		IRpcStubBuffer **	ppStub
	)

static

Definition at line 654 of file marshal.c.

{
    StubBufferWrapper *stub;
    HRESULT hr;
 
    CHECK_EXPECT(CreateStub);
 
    ok(server == (IUnknown*)&Test_OleClientSite, "unexpected server %p\n", server);
 
    stub = malloc(sizeof(*stub));
    stub->IRpcStubBuffer_iface.lpVtbl = &RpcStubBufferVtbl;
    stub->ref = 1;
 
    hr = IPSFactoryBuffer_CreateStub(ps_factory_buffer, riid, server, &stub->buffer);
    ok(hr == S_OK, "CreateStub failed: %08lx\n", hr);
 
    *ppStub = &stub->IRpcStubBuffer_iface;
    return S_OK;
}

◆ PSFactoryBuffer_QueryInterface()

static HRESULT WINAPI PSFactoryBuffer_QueryInterface	(	IPSFactoryBuffer *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 612 of file marshal.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPSFactoryBuffer))
        *ppv = iface;
    else
    {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ PSFactoryBuffer_Release()

static ULONG WINAPI PSFactoryBuffer_Release ( IPSFactoryBuffer * iface )

static

Definition at line 630 of file marshal.c.

{
    return 1;
}

◆ reg_unreg_wine_test_class()

static HRESULT reg_unreg_wine_test_class ( BOOL Register )

static

Definition at line 3428 of file marshal.c.

{
    HRESULT hr;
    char buffer[256];
    LPOLESTR pszClsid;
    HKEY hkey;
    DWORD dwDisposition;
    DWORD error;
 
    hr = StringFromCLSID(&CLSID_WineTest, &pszClsid);
    ok_ole_success(hr, "StringFromCLSID");
    strcpy(buffer, "CLSID\\");
    WideCharToMultiByte(CP_ACP, 0, pszClsid, -1, buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), NULL, NULL);
    CoTaskMemFree(pszClsid);
    strcat(buffer, "\\InprocHandler32");
    if (Register)
    {
        error = RegCreateKeyExA(HKEY_CLASSES_ROOT, buffer, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey, &dwDisposition);
        if (error == ERROR_ACCESS_DENIED)
        {
            skip("Not authorized to modify the Classes key\n");
            return E_FAIL;
        }
        ok(error == ERROR_SUCCESS, "RegCreateKeyEx failed with error %ld\n", error);
        if (error != ERROR_SUCCESS) hr = E_FAIL;
        error = RegSetValueExA(hkey, NULL, 0, REG_SZ, (const unsigned char *)"\"ole32.dll\"", strlen("\"ole32.dll\"") + 1);
        ok(error == ERROR_SUCCESS, "RegSetValueEx failed with error %ld\n", error);
        if (error != ERROR_SUCCESS) hr = E_FAIL;
        RegCloseKey(hkey);
    }
    else
    {
        RegDeleteKeyA(HKEY_CLASSES_ROOT, buffer);
        *strrchr(buffer, '\\') = '\0';
        RegDeleteKeyA(HKEY_CLASSES_ROOT, buffer);
    }
    return hr;
}

Referenced by test_handler_marshaling(), and test_inproc_handler().

◆ register_test_window()

static void register_test_window ( void )

static

Definition at line 3106 of file marshal.c.

{
    WNDCLASSA wndclass;
 
    memset(&wndclass, 0, sizeof(wndclass));
    wndclass.lpfnWndProc = window_proc;
    wndclass.lpszClassName = "WineCOMTest";
    RegisterClassA(&wndclass);
}

Referenced by START_TEST().

◆ release_host_object()

static void release_host_object	(	DWORD	tid,
		WPARAM	wp
	)

static

Definition at line 776 of file marshal.c.

{
    HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
    PostThreadMessageA(tid, RELEASEMARSHALDATA, wp, (LPARAM)event);
    ok( !WaitForSingleObject(event, 10000), "wait timed out\n" );
    CloseHandle(event);
}

Referenced by test_tablestrong_marshal_and_unmarshal_twice(), test_tableweak_and_normal_marshal_and_releasedata(), test_tableweak_and_normal_marshal_and_unmarshal(), test_tableweak_marshal_and_unmarshal_twice(), test_tableweak_marshal_releasedata1(), test_tableweak_marshal_releasedata2(), and test_two_tableweak_marshal_and_releasedata().

◆ round_global_size()

static SIZE_T round_global_size ( SIZE_T size )

static

Definition at line 3217 of file marshal.c.

{
    static SIZE_T global_size_alignment = -1;
    if (global_size_alignment == -1)
    {
        void *p = GlobalAlloc(GMEM_FIXED, 1);
        global_size_alignment = GlobalSize(p);
        GlobalFree(p);
    }
 
    return ((size + global_size_alignment - 1) & ~(global_size_alignment - 1));
}

Referenced by test_freethreadedmarshaldata().

◆ RpcProxyBuffer_AddRef()

static ULONG WINAPI RpcProxyBuffer_AddRef ( IRpcProxyBuffer * iface )

static

Definition at line 563 of file marshal.c.

{
    ProxyBufferWrapper *This = impl_from_IRpcProxyBuffer(iface);
    return InterlockedIncrement(&This->ref);
}

◆ RpcProxyBuffer_Connect()

static HRESULT WINAPI RpcProxyBuffer_Connect	(	IRpcProxyBuffer *	iface,
		IRpcChannelBuffer *	pRpcChannelBuffer
	)

static

Definition at line 580 of file marshal.c.

{
    ProxyBufferWrapper *This = impl_from_IRpcProxyBuffer(iface);
    void *dest_context_data;
    DWORD dest_context;
    HRESULT hr;
 
    CHECK_EXPECT(Connect);
 
    hr = IRpcChannelBuffer_GetDestCtx(pRpcChannelBuffer, &dest_context, &dest_context_data);
    ok(hr == S_OK, "GetDestCtx failed: %08lx\n", hr);
    ok(dest_context == MSHCTX_INPROC, "desc_context = %lx\n", dest_context);
    ok(!dest_context_data, "desc_context_data = %p\n", dest_context_data);
 
    return IRpcProxyBuffer_Connect(This->buffer, pRpcChannelBuffer);
}

◆ RpcProxyBuffer_Disconnect()

static void WINAPI RpcProxyBuffer_Disconnect ( IRpcProxyBuffer * iface )

static

Definition at line 597 of file marshal.c.

{
    CHECK_EXPECT(RpcProxyBuffer_Disconnect);
}

Referenced by RpcProxyBuffer_Disconnect(), and test_marshal_channel_buffer().

◆ RpcProxyBuffer_QueryInterface()

static HRESULT WINAPI RpcProxyBuffer_QueryInterface	(	IRpcProxyBuffer *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 548 of file marshal.c.

{
    ProxyBufferWrapper *This = impl_from_IRpcProxyBuffer(iface);
 
    if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRpcProxyBuffer, riid)) {
        *ppv = &This->IRpcProxyBuffer_iface;
    }else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ RpcProxyBuffer_Release()

static ULONG WINAPI RpcProxyBuffer_Release ( IRpcProxyBuffer * iface )

static

Definition at line 569 of file marshal.c.

{
    ProxyBufferWrapper *This = impl_from_IRpcProxyBuffer(iface);
    LONG ref = InterlockedDecrement(&This->ref);
    if(!ref) {
        IRpcProxyBuffer_Release(This->buffer);
        free(This);
    }
    return ref;
}

◆ RpcStubBuffer_AddRef()

static ULONG WINAPI RpcStubBuffer_AddRef ( IRpcStubBuffer * iface )

static

Definition at line 455 of file marshal.c.

{
    StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
    return InterlockedIncrement(&This->ref);
}

◆ RpcStubBuffer_Connect()

static HRESULT WINAPI RpcStubBuffer_Connect	(	IRpcStubBuffer *	iface,
		IUnknown *	pUnkServer
	)

static

Definition at line 472 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ RpcStubBuffer_CountRefs()

static ULONG WINAPI RpcStubBuffer_CountRefs ( IRpcStubBuffer * iface )

static

Definition at line 507 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ RpcStubBuffer_DebugServerQueryInterface()

static HRESULT WINAPI RpcStubBuffer_DebugServerQueryInterface	(	IRpcStubBuffer *	iface,
		void **	ppv
	)

static

Definition at line 513 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return E_NOTIMPL;
}

◆ RpcStubBuffer_DebugServerRelease()

static void WINAPI RpcStubBuffer_DebugServerRelease	(	IRpcStubBuffer *	iface,
		void *	pv
	)

static

Definition at line 519 of file marshal.c.

{
    ok(0, "unexpected call\n");
}

◆ RpcStubBuffer_Disconnect()

static void WINAPI RpcStubBuffer_Disconnect ( IRpcStubBuffer * iface )

static

Definition at line 478 of file marshal.c.

{
    CHECK_EXPECT(RpcStubBuffer_Disconnect);
}

Referenced by RpcStubBuffer_Disconnect(), and test_marshal_channel_buffer().

◆ RpcStubBuffer_Invoke()

static HRESULT WINAPI RpcStubBuffer_Invoke	(	IRpcStubBuffer *	iface,
		RPCOLEMESSAGE *	_prpcmsg,
		IRpcChannelBuffer *	_pRpcChannelBuffer
	)

static

Definition at line 483 of file marshal.c.

{
    StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
    void *dest_context_data;
    DWORD dest_context;
    HRESULT hr;
 
    CHECK_EXPECT(Invoke);
 
    hr = IRpcChannelBuffer_GetDestCtx(_pRpcChannelBuffer, &dest_context, &dest_context_data);
    ok(hr == S_OK, "GetDestCtx failed: %08lx\n", hr);
    ok(dest_context == MSHCTX_INPROC, "desc_context = %lx\n", dest_context);
    ok(!dest_context_data, "desc_context_data = %p\n", dest_context_data);
 
    return IRpcStubBuffer_Invoke(This->buffer, _prpcmsg, _pRpcChannelBuffer);
}

◆ RpcStubBuffer_IsIIDSupported()

static IRpcStubBuffer *WINAPI RpcStubBuffer_IsIIDSupported	(	IRpcStubBuffer *	iface,
		REFIID	riid
	)

static

Definition at line 501 of file marshal.c.

{
    ok(0, "unexpected call\n");
    return NULL;
}

◆ RpcStubBuffer_QueryInterface()

static HRESULT WINAPI RpcStubBuffer_QueryInterface	(	IRpcStubBuffer *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 440 of file marshal.c.

{
    StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
 
    if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRpcStubBuffer, riid)) {
        *ppv = &This->IRpcStubBuffer_iface;
    }else {
        *ppv = NULL;
        return E_NOINTERFACE;
    }
 
    IUnknown_AddRef((IUnknown*)*ppv);
    return S_OK;
}

◆ RpcStubBuffer_Release()

static ULONG WINAPI RpcStubBuffer_Release ( IRpcStubBuffer * iface )

static

Definition at line 461 of file marshal.c.

{
    StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
    LONG ref = InterlockedDecrement(&This->ref);
    if(!ref) {
        IRpcStubBuffer_Release(This->buffer);
        free(This);
    }
    return ref;
}

◆ second_mta_thread_proc()

static DWORD CALLBACK second_mta_thread_proc ( void * param )

static

Definition at line 4583 of file marshal.c.

{
    struct implicit_mta_marshal_data *data = param;
    HRESULT hr;
 
    /* Second thread now keeps MTA created on first thread alive. */
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
    hr = CoMarshalInterface(data->stream, &IID_IClassFactory,
        (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    SetEvent(data->start);
 
    ok(!WaitForSingleObject(data->stop, 1000), "wait failed\n");
    CoUninitialize();
    return 0;
}

Referenced by test_mta_creation_thread_change_apartment().

◆ start_host_object()

static DWORD start_host_object	(	IStream *	stream,
		REFIID	riid,
		IUnknown *	object,
		MSHLFLAGS	marshal_flags,
		HANDLE *	thread
	)

static

Definition at line 768 of file marshal.c.

{
    struct host_object_data object_data = { stream, riid, object, marshal_flags };
    return start_host_object2(&object_data, thread);
}

Referenced by test_call_from_message(), test_client_security(), test_handler_marshaling(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), test_marshal_and_unmarshal_invalid(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_marshal_stub_apartment_shutdown(), test_no_couninitialize_client(), test_proxy_interfaces(), test_proxy_marshal_and_unmarshal(), test_proxy_marshal_and_unmarshal2(), test_proxy_marshal_and_unmarshal_strong(), test_proxy_marshal_and_unmarshal_weak(), test_proxy_used_in_wrong_thread(), test_tablestrong_marshal_and_unmarshal_twice(), test_tableweak_marshal_and_unmarshal_twice(), test_tableweak_marshal_releasedata1(), test_tableweak_marshal_releasedata2(), and window_proc().

◆ start_host_object2()

static DWORD start_host_object2	(	struct host_object_data *	object_data,
		HANDLE *	thread
	)

static

Definition at line 751 of file marshal.c.

{
    DWORD tid = 0;
    struct host_object_data *data;
 
    data = malloc(sizeof(*data));
    *data = *object_data;
    data->marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
    *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
 
    /* wait for marshaling to complete before returning */
    ok( !WaitForSingleObject(data->marshal_event, 10000), "wait timed out\n" );
    CloseHandle(data->marshal_event);
 
    return tid;
}

Referenced by start_host_object(), test_channel_hook(), test_marshal_channel_buffer(), and test_message_filter().

◆ START_TEST()

START_TEST ( marshal )

Definition at line 4640 of file marshal.c.

{
    HMODULE hOle32 = GetModuleHandleA("ole32");
    int argc;
    char **argv;
 
    pDllGetClassObject = (void*)GetProcAddress(hOle32, "DllGetClassObject");
 
    argc = winetest_get_mainargs( &argv );
    if (argc > 2 && (!strcmp(argv[2], "-Embedding")))
    {
        CoInitializeEx(NULL, COINIT_MULTITHREADED);
        test_register_local_server();
        CoUninitialize();
 
        return;
    }
 
    register_test_window();
 
    test_cocreateinstance_proxy();
    test_implicit_mta();
    test_mta_creation_thread_change_apartment();
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    /* FIXME: test CoCreateInstanceEx */
 
    /* lifecycle management and marshaling tests */
    do
    {
        test_no_marshaler();
        test_normal_marshal_and_release();
        test_normal_marshal_and_unmarshal();
        test_marshal_and_unmarshal_invalid();
        test_same_apartment_unmarshal_failure();
        test_interthread_marshal_and_unmarshal();
        test_proxy_marshal_and_unmarshal();
        test_proxy_marshal_and_unmarshal2();
        test_proxy_marshal_and_unmarshal_weak();
        test_proxy_marshal_and_unmarshal_strong();
        test_marshal_stub_apartment_shutdown();
        test_marshal_proxy_apartment_shutdown();
        test_marshal_proxy_mta_apartment_shutdown();
        test_no_couninitialize_server();
        test_no_couninitialize_client();
        test_tableweak_marshal_and_unmarshal_twice();
        test_tableweak_marshal_releasedata1();
        test_tableweak_marshal_releasedata2();
        test_tableweak_and_normal_marshal_and_unmarshal();
        test_tableweak_and_normal_marshal_and_releasedata();
        test_two_tableweak_marshal_and_releasedata();
        test_tablestrong_marshal_and_unmarshal_twice();
        test_lock_object_external();
        test_disconnect_stub();
        test_normal_marshal_and_unmarshal_twice();
 
        with_external_conn = !with_external_conn;
    } while (with_external_conn);
 
    test_marshal_channel_buffer();
    test_StdMarshal_custom_marshaling();
    test_DfMarshal_custom_marshaling();
    test_CoGetStandardMarshal();
    test_hresult_marshaling();
    test_proxy_used_in_wrong_thread();
    test_message_filter();
    test_bad_marshal_stream();
    test_proxy_interfaces();
    test_stubbuffer(&IID_IClassFactory);
    test_proxybuffer(&IID_IClassFactory);
    test_message_reentrancy();
    test_call_from_message();
    test_WM_QUIT_handling();
    test_freethreadedmarshaler();
    test_inproc_handler();
    test_handler_marshaling();
    test_client_security();
 
    test_local_server();
 
    test_globalinterfacetable();
    test_manualresetevent();
    test_crash_couninitialize();
 
    /* must be last test as channel hooks can't be unregistered */
    test_channel_hook();
 
    CoUninitialize();
}

◆ test_bad_marshal_stream()

static void test_bad_marshal_stream ( void )

static

Definition at line 2770 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
 
    /* try to read beyond end of stream */
    hr = CoReleaseMarshalData(pStream);
    ok(hr == STG_E_READFAULT, "Should have failed with STG_E_READFAULT, but returned 0x%08lx instead\n", hr);
 
    /* now release for real */
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

◆ test_call_from_message()

static void test_call_from_message ( void )

static

Definition at line 3156 of file marshal.c.

{
    MSG msg;
    IStream *pStream;
    HRESULT hr;
    IClassFactory *proxy;
    DWORD tid;
    HANDLE thread;
    IUnknown *object;
 
    hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
    ok(hwnd_app != NULL, "Window creation failed\n");
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestMsg_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
    ok_ole_success(hr, CoReleaseMarshalData);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
 
    /* start message re-entrancy test */
    hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IClassFactory_Release(proxy);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
    DestroyWindow(hwnd_app);
}

Referenced by START_TEST().

◆ test_channel_hook()

static void test_channel_hook ( void )

static

Definition at line 4534 of file marshal.c.

{
    IClassFactory *cf = NULL;
    DWORD tid;
    IUnknown *proxy = NULL;
    HANDLE thread;
    HRESULT hr;
 
    struct host_object_data object_data = { NULL, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory,
                                            MSHLFLAGS_NORMAL, &MessageFilter };
 
    hr = CoRegisterChannelHook(&EXTENTID_WineTest, &TestChannelHook);
    ok_ole_success(hr, CoRegisterChannelHook);
 
    hr = CoRegisterMessageFilter(&MessageFilter, NULL);
    ok_ole_success(hr, CoRegisterMessageFilter);
 
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &object_data.stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object2(&object_data, &thread);
 
    ok_more_than_one_lock();
 
    IStream_Seek(object_data.stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(object_data.stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(object_data.stream);
 
    ok_more_than_one_lock();
 
    method = 3;
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    method = 5;
    IUnknown_Release(proxy);
 
    IClassFactory_Release(cf);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
 
    hr = CoRegisterMessageFilter(NULL, NULL);
    ok_ole_success(hr, CoRegisterMessageFilter);
}

Referenced by START_TEST().

◆ test_client_security()

static void test_client_security ( void )

static

Definition at line 3595 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IClassFactory *pProxy = NULL;
    IUnknown *pProxy2 = NULL;
    IUnknown *pUnknown1 = NULL;
    IUnknown *pUnknown2 = NULL;
    IClientSecurity *pCliSec = NULL;
    IMarshal *pMarshal;
    DWORD tid;
    HANDLE thread;
    static const LARGE_INTEGER ullZero;
    DWORD dwAuthnSvc;
    DWORD dwAuthzSvc;
    OLECHAR *pServerPrincName;
    DWORD dwAuthnLevel;
    DWORD dwImpLevel;
    void *pAuthInfo;
    DWORD dwCapabilities;
    void *pv;
 
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, "CreateStreamOnHGlobal");
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, "CoUnmarshalInterface");
    IStream_Release(pStream);
 
    hr = IClassFactory_QueryInterface(pProxy, &IID_IUnknown, (LPVOID*)&pUnknown1);
    ok_ole_success(hr, "IUnknown_QueryInterface IID_IUnknown");
 
    /* Does not work on Windows 10 19xx+ */
    if (SUCCEEDED(IClassFactory_QueryInterface(pProxy, &IID_IRemUnknown, (void **)&pProxy2)))
    {
        hr = IUnknown_QueryInterface(pProxy2, &IID_IUnknown, (void **)&pUnknown2);
        ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
 
        ok(pUnknown1 == pUnknown2, "both proxy's IUnknowns should be the same - %p, %p\n", pUnknown1, pUnknown2);
        IUnknown_Release(pUnknown2);
 
        IUnknown_Release(pProxy2);
    }
 
    hr = IClassFactory_QueryInterface(pProxy, &IID_IMarshal, (LPVOID*)&pMarshal);
    ok_ole_success(hr, "IUnknown_QueryInterface IID_IMarshal");
 
    hr = IClassFactory_QueryInterface(pProxy, &IID_IClientSecurity, (LPVOID*)&pCliSec);
    ok_ole_success(hr, "IUnknown_QueryInterface IID_IClientSecurity");
 
    hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pProxy, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket (all NULLs)");
 
    hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pMarshal, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
    todo_wine ok(hr == E_NOINTERFACE, "IClientSecurity_QueryBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
    hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pProxy, &dwAuthnSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImpLevel, &pAuthInfo, &dwCapabilities);
    todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket");
 
    hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pProxy, dwAuthnSvc, dwAuthzSvc, pServerPrincName, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, pAuthInfo, dwCapabilities);
    todo_wine ok_ole_success(hr, "IClientSecurity_SetBlanket");
 
    hr = IClassFactory_CreateInstance(pProxy, NULL, &IID_IWineTest, &pv);
    ok(hr == E_NOINTERFACE, "COM call should have succeeded instead of returning 0x%08lx\n", hr);
 
    hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pMarshal, dwAuthnSvc, dwAuthzSvc, pServerPrincName, dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities);
    todo_wine ok(hr == E_NOINTERFACE, "IClientSecurity_SetBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
    hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pProxy, 0xdeadbeef, dwAuthzSvc, pServerPrincName, dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities);
    todo_wine ok(hr == E_INVALIDARG, "IClientSecurity_SetBlanke with invalid dwAuthnSvc should have returned E_INVALIDARG instead of 0x%08lx\n", hr);
 
    CoTaskMemFree(pServerPrincName);
 
    hr = IClientSecurity_QueryBlanket(pCliSec, pUnknown1, &dwAuthnSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImpLevel, &pAuthInfo, &dwCapabilities);
    todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket(IUnknown)");
 
    CoTaskMemFree(pServerPrincName);
 
    IClassFactory_Release(pProxy);
    IUnknown_Release(pUnknown1);
    IMarshal_Release(pMarshal);
    IClientSecurity_Release(pCliSec);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_cocreateinstance_proxy()

static void test_cocreateinstance_proxy ( void )

static

Definition at line 148 of file marshal.c.

{
    IUnknown *pProxy;
    IMultiQI *pMQI;
    HRESULT hr;
 
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    hr = CoCreateInstance(&CLSID_ShellDesktop, NULL, CLSCTX_INPROC, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, CoCreateInstance);
    hr = IUnknown_QueryInterface(pProxy, &IID_IMultiQI, (void **)&pMQI);
    ok(hr == S_OK, "created object is not a proxy, so was created in the wrong apartment\n");
    if (hr == S_OK)
        IMultiQI_Release(pMQI);
    IUnknown_Release(pProxy);
 
    CoUninitialize();
}

Referenced by START_TEST().

◆ test_CoGetStandardMarshal()

static void test_CoGetStandardMarshal ( void )

static

Definition at line 1657 of file marshal.c.

{
    DUALSTRINGARRAY *dualstringarr;
    STDOBJREF *stdobjref;
    OBJREF objref;
    IMarshal *marshal;
    DWORD size, read;
    IStream *stream;
    IUnknown *unk;
    CLSID clsid;
    HRESULT hr;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = CoGetStandardMarshal(&IID_IUnknown, &Test_Unknown,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL, &marshal);
    ok_ole_success(hr, CoGetStandardMarshal);
 
    hr = IMarshal_GetUnmarshalClass(marshal, &IID_IUnknown, &Test_Unknown,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL, &clsid);
    ok_ole_success(hr, IMarshal_GetUnmarshalClass);
    ok(IsEqualGUID(&clsid, &CLSID_StdMarshal), "clsid = %s\n", wine_dbgstr_guid(&clsid));
 
    hr = IMarshal_GetMarshalSizeMax(marshal, &IID_IUnknown, &Test_Unknown,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL, &size);
    ok_ole_success(hr, IMarshal_GetMarshalSizeMax);
    hr = CoGetMarshalSizeMax(&read, &IID_IUnknown, &Test_Unknown,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoGetMarshalSizeMax);
    ok(size == read, "IMarshal_GetMarshalSizeMax size = %ld, expected %ld\n", size, read);
 
    hr = IMarshal_MarshalInterface(marshal, stream, &IID_IUnknown,
            &Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    size = FIELD_OFFSET(OBJREF, u_objref.u_standard.saResAddr.aStringArray);
    hr = IStream_Read(stream, &objref, size, &read);
    ok_ole_success(hr, IStream_Read);
    ok(read == size, "read = %ld, expected %ld\n", read, size);
    ok(objref.signature == OBJREF_SIGNATURE, "objref.signature = %lx\n",
            objref.signature);
    ok(objref.flags == OBJREF_STANDARD, "objref.flags = %lx\n", objref.flags);
    ok(IsEqualIID(&objref.iid, &IID_IUnknown), "objref.iid = %s\n",
            wine_dbgstr_guid(&objref.iid));
    stdobjref = &objref.u_objref.u_standard.std;
    ok(stdobjref->flags == 0, "stdobjref.flags = %ld\n", stdobjref->flags);
    ok(stdobjref->cPublicRefs == 5, "stdobjref.cPublicRefs = %ld\n",
            stdobjref->cPublicRefs);
    dualstringarr = &objref.u_objref.u_standard.saResAddr;
    ok(dualstringarr->wNumEntries == 0, "dualstringarr.wNumEntries = %d\n",
            dualstringarr->wNumEntries);
    ok(dualstringarr->wSecurityOffset == 0, "dualstringarr.wSecurityOffset = %d\n",
            dualstringarr->wSecurityOffset);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    hr = IMarshal_UnmarshalInterface(marshal, stream, &IID_IUnknown, (void**)&unk);
    ok_ole_success(hr, IMarshal_UnmarshalInterface);
    IUnknown_Release(unk);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    hr = IMarshal_MarshalInterface(marshal, stream, &IID_IUnknown,
            &Test_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    hr = IMarshal_ReleaseMarshalData(marshal, stream);
    ok_ole_success(hr, IMarshal_ReleaseMarshalData);
    IStream_Release(stream);
 
    IMarshal_Release(marshal);
}

Referenced by START_TEST().

◆ test_crash_couninitialize()

static void test_crash_couninitialize ( void )

static

Definition at line 1912 of file marshal.c.

{
    HANDLE thread;
    DWORD tid;
 
    crash_thread_success = FALSE;
    thread = CreateThread(NULL, 0, crash_couninitialize_proc, NULL, 0, &tid);
    ok(!WaitForSingleObject(thread, 10000), "wait timed out\n");
    CloseHandle(thread);
    ok(crash_thread_success, "Crash thread failed\n");
}

Referenced by START_TEST().

◆ test_DfMarshal_custom_marshaling()

static void test_DfMarshal_custom_marshaling ( void )

static

Definition at line 1608 of file marshal.c.

{
    DWORD size, read;
    IStream *stream;
    OBJREF objref;
    HRESULT hr;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    unmarshal_class = &CLSID_DfMarshal;
    SET_EXPECT(CustomMarshal_GetUnmarshalClass);
    SET_EXPECT(CustomMarshal_GetMarshalSizeMax);
    SET_EXPECT(CustomMarshal_MarshalInterface);
    hr = CoMarshalInterface(stream, &IID_IUnknown, (IUnknown*)&CustomMarshal,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
    CHECK_CALLED(CustomMarshal_GetUnmarshalClass);
    CHECK_CALLED(CustomMarshal_GetMarshalSizeMax);
    CHECK_CALLED(CustomMarshal_MarshalInterface);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    size = FIELD_OFFSET(OBJREF, u_objref.u_custom.pData);
    hr = IStream_Read(stream, &objref, size, &read);
    ok_ole_success(hr, IStream_Read);
    ok(read == size, "read = %ld, expected %ld\n", read, size);
    ok(objref.signature == OBJREF_SIGNATURE, "objref.signature = %lx\n",
            objref.signature);
    ok(objref.flags == OBJREF_CUSTOM, "objref.flags = %lx\n", objref.flags);
    ok(IsEqualIID(&objref.iid, &IID_IUnknown), "objref.iid = %s\n",
            wine_dbgstr_guid(&objref.iid));
    ok(IsEqualIID(&objref.u_objref.u_custom.clsid, &CLSID_DfMarshal),
            "custom.clsid = %s\n", wine_dbgstr_guid(&objref.u_objref.u_custom.clsid));
    ok(!objref.u_objref.u_custom.cbExtension, "custom.cbExtension = %ld\n",
            objref.u_objref.u_custom.cbExtension);
    ok(!objref.u_objref.u_custom.size, "custom.size = %ld\n",
            objref.u_objref.u_custom.size);
 
    IStream_Release(stream);
 
    SET_EXPECT(CustomMarshal_GetMarshalSizeMax);
    hr = CoGetMarshalSizeMax(&size, &IID_IUnknown, (IUnknown*)&CustomMarshal,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoGetMarshalSizeMax);
    CHECK_CALLED(CustomMarshal_GetMarshalSizeMax);
    ok(size == sizeof(OBJREF), "size = %ld, expected %d\n", size, (int)sizeof(OBJREF));
}

Referenced by START_TEST().

◆ test_disconnect_stub()

static void test_disconnect_stub ( void )

static

Definition at line 2449 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_non_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
 
    ok_no_locks();
    ok_non_zero_external_conn();
 
    hr = CoDisconnectObject(NULL, 0);
    ok( hr == E_INVALIDARG, "wrong status %lx\n", hr );
}

Referenced by START_TEST().

◆ test_freethreadedmarshaldata()

static void test_freethreadedmarshaldata	(	IStream *	pStream,
		MSHCTX	mshctx,
		void *	ptr,
		DWORD	mshlflags
	)

static

Definition at line 3230 of file marshal.c.

{
    HGLOBAL hglobal;
    DWORD size;
    char *marshal_data;
    HRESULT hr;
 
    hr = GetHGlobalFromStream(pStream, &hglobal);
    ok_ole_success(hr, GetHGlobalFromStream);
 
    size = GlobalSize(hglobal);
 
    marshal_data = GlobalLock(hglobal);
 
    if (mshctx == MSHCTX_INPROC)
    {
        DWORD expected_size = round_global_size(3*sizeof(DWORD) + sizeof(GUID));
        ok(size == expected_size, "expected size %lu, got %lu\n", expected_size, size);
 
        ok(*(DWORD *)marshal_data == mshlflags, "expected 0x%lx, but got 0x%lx for mshctx\n", mshlflags, *(DWORD *)marshal_data);
        marshal_data += sizeof(DWORD);
        ok(*(void **)marshal_data == ptr, "expected %p, but got %p for mshctx\n", ptr, *(void **)marshal_data);
        marshal_data += sizeof(void *);
        if (sizeof(void*) == 4 && size >= 3*sizeof(DWORD))
        {
            ok(*(DWORD *)marshal_data == 0, "expected 0x0, but got 0x%lx\n", *(DWORD *)marshal_data);
            marshal_data += sizeof(DWORD);
        }
        if (size >= 3*sizeof(DWORD) + sizeof(GUID) && winetest_debug > 1)
        {
            trace("got guid data: %s\n", wine_dbgstr_guid((GUID *)marshal_data));
        }
    }
    else
    {
        ok(size > sizeof(DWORD), "size should have been > sizeof(DWORD), not %ld\n", size);
        ok(*(DWORD *)marshal_data == 0x574f454d /* MEOW */,
            "marshal data should be filled by standard marshal and start with MEOW signature\n");
    }
 
    GlobalUnlock(hglobal);
}

Referenced by test_freethreadedmarshaler().

◆ test_freethreadedmarshaler()

static void test_freethreadedmarshaler ( void )

static

Definition at line 3273 of file marshal.c.

{
    DWORD size, expected_size;
    HRESULT hr;
    IUnknown *pFTUnknown;
    IMarshal *pFTMarshal;
    IStream *pStream;
    IUnknown *pProxy;
    static const LARGE_INTEGER llZero;
    CLSID clsid;
 
    cLocks = 0;
    hr = CoCreateFreeThreadedMarshaler(NULL, &pFTUnknown);
    ok_ole_success(hr, CoCreateFreeThreadedMarshaler);
    hr = IUnknown_QueryInterface(pFTUnknown, &IID_IMarshal, (void **)&pFTMarshal);
    ok_ole_success(hr, IUnknown_QueryInterface);
    IUnknown_Release(pFTUnknown);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    /* inproc normal marshaling */
 
    size = 0;
    expected_size = sizeof(DWORD) /* flags */ + sizeof(UINT64) + sizeof(GUID);
    hr = IMarshal_GetMarshalSizeMax(pFTMarshal, &IID_IClassFactory, &Test_ClassFactory, MSHCTX_INPROC,
            NULL, MSHLFLAGS_NORMAL, &size);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    ok(size == expected_size, "Unexpected marshal size %lu, expected %lu.\n", size, expected_size);
 
    hr = IMarshal_GetUnmarshalClass(pFTMarshal, &IID_IClassFactory,
            &Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL, &clsid);
    ok_ole_success(hr, IMarshal_GetUnmarshalClass);
    ok(IsEqualIID(&clsid, &CLSID_InProcFreeMarshaler), "clsid = %s\n",
            wine_dbgstr_guid(&clsid));
 
    hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
        &Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    ok_more_than_one_lock();
 
    test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_NORMAL);
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, IMarshal_UnmarshalInterface);
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
 
    /* inproc table-strong marshaling */
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
        (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, (void *)0xdeadbeef,
        MSHLFLAGS_TABLESTRONG);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    ok_more_than_one_lock();
 
    test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_TABLESTRONG);
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, IMarshal_UnmarshalInterface);
 
    IUnknown_Release(pProxy);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
    ok_ole_success(hr, IMarshal_ReleaseMarshalData);
 
    ok_no_locks();
 
    /* inproc table-weak marshaling */
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
        (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, (void *)0xdeadbeef,
        MSHLFLAGS_TABLEWEAK);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    ok_no_locks();
 
    test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_TABLEWEAK);
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, IMarshal_UnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
 
    /* inproc normal marshaling (for extraordinary cases) */
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
        &Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    ok_more_than_one_lock();
 
    /* this call shows that DisconnectObject does nothing */
    hr = IMarshal_DisconnectObject(pFTMarshal, 0);
    ok_ole_success(hr, IMarshal_DisconnectObject);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
    ok_ole_success(hr, IMarshal_ReleaseMarshalData);
 
    ok_no_locks();
 
    /* doesn't enforce marshaling rules here and allows us to unmarshal the
     * interface, even though it was freed above */
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, IMarshal_UnmarshalInterface);
 
    ok_no_locks();
 
    /* local normal marshaling */
 
    hr = IMarshal_GetUnmarshalClass(pFTMarshal, &IID_IClassFactory,
            &Test_ClassFactory, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL, &clsid);
    ok_ole_success(hr, IMarshal_GetUnmarshalClass);
    ok(IsEqualGUID(&clsid, &CLSID_StdMarshal) || IsEqualGUID(&clsid, &CLSID_ft_unmarshaler_1809) /* Win10 1809 */,
            "clsid = %s\n", wine_dbgstr_guid(&clsid));
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory, &Test_ClassFactory, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, IMarshal_MarshalInterface);
 
    ok_more_than_one_lock();
 
    test_freethreadedmarshaldata(pStream, MSHCTX_LOCAL, &Test_ClassFactory, MSHLFLAGS_NORMAL);
 
    IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
 
    ok_no_locks();
 
    IStream_Release(pStream);
    IMarshal_Release(pFTMarshal);
}

Referenced by START_TEST().

◆ test_globalinterfacetable()

static void test_globalinterfacetable ( void )

static

Definition at line 4030 of file marshal.c.

{
    HRESULT hr;
    IGlobalInterfaceTable *git;
    DWORD cookie;
    HANDLE thread;
    DWORD tid;
    struct git_params params;
    DWORD ret;
        IUnknown *object;
        IClassFactory *cf;
        ULONG ref;
 
    cLocks = 0;
 
    hr = pDllGetClassObject(&CLSID_StdGlobalInterfaceTable, &IID_IClassFactory, (void**)&cf);
    ok(hr == S_OK, "got 0x%08lx\n", hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IGlobalInterfaceTable, (void**)&object);
    ok(hr == E_NOINTERFACE, "got 0x%08lx\n", hr);
 
    IClassFactory_Release(cf);
 
    hr = CoCreateInstance(&CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, &IID_IGlobalInterfaceTable, (void **)&git);
    ok_ole_success(hr, CoCreateInstance);
 
    ref = IGlobalInterfaceTable_AddRef(git);
    ok(ref == 1, "ref=%ld\n", ref);
    ref = IGlobalInterfaceTable_AddRef(git);
    ok(ref == 1, "ref=%ld\n", ref);
 
    ref = IGlobalInterfaceTable_Release(git);
    ok(ref == 1, "ref=%ld\n", ref);
    ref = IGlobalInterfaceTable_Release(git);
    ok(ref == 1, "ref=%ld\n", ref);
 
    hr = IGlobalInterfaceTable_RegisterInterfaceInGlobal(git, (IUnknown *)&Test_ClassFactory, &IID_IClassFactory, &cookie);
    ok_ole_success(hr, IGlobalInterfaceTable_RegisterInterfaceInGlobal);
 
    ok_more_than_one_lock();
 
    params.cookie = cookie;
    params.git = git;
    /* note: params is on stack so we MUST wait for get_global_interface_proc
     * to exit before we can return */
    thread = CreateThread(NULL, 0, get_global_interface_proc, &params, 0, &tid);
 
    ret = MsgWaitForMultipleObjects(1, &thread, FALSE, 10000, QS_ALLINPUT);
    while (ret == WAIT_OBJECT_0 + 1)
    {
        MSG msg;
        while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
            DispatchMessageA(&msg);
        ret = MsgWaitForMultipleObjects(1, &thread, FALSE, 10000, QS_ALLINPUT);
    }
 
    CloseHandle(thread);
 
    /* test getting interface from global with different iid */
    hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(git, cookie, &IID_IUnknown, (void **)&object);
    ok_ole_success(hr, IGlobalInterfaceTable_GetInterfaceFromGlobal);
    IUnknown_Release(object);
 
    /* test getting interface from global with same iid */
    hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(git, cookie, &IID_IClassFactory, (void **)&object);
    ok_ole_success(hr, IGlobalInterfaceTable_GetInterfaceFromGlobal);
    IUnknown_Release(object);
 
    hr = IGlobalInterfaceTable_RevokeInterfaceFromGlobal(git, cookie);
    ok_ole_success(hr, IGlobalInterfaceTable_RevokeInterfaceFromGlobal);
 
    ok_no_locks();
 
    IGlobalInterfaceTable_Release(git);
 
    hr = CoGetClassObject(&CLSID_StdGlobalInterfaceTable, CLSCTX_INPROC_SERVER, NULL, &IID_IClassFactory, (void **)&cf);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IClassFactory_Release(cf);
}

Referenced by START_TEST().

◆ test_handler_marshaling()

static void test_handler_marshaling ( void )

static

Definition at line 3545 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pObject;
    DWORD tid;
    HANDLE thread;
    static const LARGE_INTEGER ullZero;
 
    if (FAILED(reg_unreg_wine_test_class(TRUE)))
        return;
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, "CreateStreamOnHGlobal");
    tid = start_host_object(pStream, &IID_IUnknown, (IUnknown*)&Test_SMI, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, "CoUnmarshalInterface");
    IStream_Release(pStream);
 
    if(hr == S_OK)
    {
        ok_more_than_one_lock();
 
        hr = IUnknown_QueryInterface(pProxy, &IID_IWineTest, (void **)&pObject);
        ok(hr == E_NOINTERFACE, "IUnknown_QueryInterface with unknown IID should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
        /* it's a handler as it supports IOleObject */
        hr = IUnknown_QueryInterface(pProxy, &IID_IOleObject, (void **)&pObject);
        todo_wine
        ok_ole_success(hr, "IUnknown_QueryInterface(&IID_IOleObject)");
        if (SUCCEEDED(hr)) IUnknown_Release(pObject);
 
        IUnknown_Release(pProxy);
 
        ok_no_locks();
    }
 
    end_host_object(tid, thread);
    reg_unreg_wine_test_class(FALSE);
 
    /* FIXME: test IPersist interface has the same effect as IStdMarshalInfo */
}

Referenced by START_TEST().

◆ test_hresult_marshaling()

static void test_hresult_marshaling ( void )

static

Definition at line 2528 of file marshal.c.

{
    HRESULT hr;
    HRESULT hr_marshaled = 0;
    IStream *pStream = NULL;
    static const HRESULT E_DEADBEEF = 0xdeadbeef;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = CoMarshalHresult(pStream, E_DEADBEEF);
    ok_ole_success(hr, CoMarshalHresult);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = IStream_Read(pStream, &hr_marshaled, sizeof(HRESULT), NULL);
    ok_ole_success(hr, IStream_Read);
 
    ok(hr_marshaled == E_DEADBEEF, "Didn't marshal HRESULT as expected: got value 0x%08lx instead\n", hr_marshaled);
 
    hr_marshaled = 0;
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalHresult(pStream, &hr_marshaled);
    ok_ole_success(hr, CoUnmarshalHresult);
 
    ok(hr_marshaled == E_DEADBEEF, "Didn't marshal HRESULT as expected: got value 0x%08lx instead\n", hr_marshaled);
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

◆ Test_IClassFactory_AddRef()

static ULONG WINAPI Test_IClassFactory_AddRef ( LPCLASSFACTORY iface )

static

Definition at line 312 of file marshal.c.

{
    LockModule();
    return 2; /* non-heap-based object */
}

◆ Test_IClassFactory_CreateInstance()

static HRESULT WINAPI Test_IClassFactory_CreateInstance	(	LPCLASSFACTORY	iface,
		LPUNKNOWN	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 324 of file marshal.c.

{
    if (pUnkOuter) return CLASS_E_NOAGGREGATION;
    return IUnknown_QueryInterface(&Test_Unknown, riid, ppvObj);
}

◆ Test_IClassFactory_LockServer()

static HRESULT WINAPI Test_IClassFactory_LockServer	(	LPCLASSFACTORY	iface,
		BOOL	fLock
	)

static

Definition at line 334 of file marshal.c.

{
    return S_OK;
}

◆ Test_IClassFactory_QueryInterface()

static HRESULT WINAPI Test_IClassFactory_QueryInterface	(	LPCLASSFACTORY	iface,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 285 of file marshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IClassFactory) ||
        /* the only other interface Wine is currently able to marshal (for testing two proxies) */
        IsEqualGUID(riid, &IID_IRemUnknown))
    {
        *ppvObj = iface;
        IClassFactory_AddRef(iface);
        return S_OK;
    }
 
    if (with_external_conn && IsEqualGUID(riid, &IID_IExternalConnection))
    {
        *ppvObj = &ExternalConnection;
        return S_OK;
    }
 
    *ppvObj = NULL;
    return E_NOINTERFACE;
}

◆ Test_IClassFactory_Release()

static ULONG WINAPI Test_IClassFactory_Release ( LPCLASSFACTORY iface )

static

Definition at line 318 of file marshal.c.

{
    UnlockModule();
    return 1; /* non-heap-based object */
}

◆ test_implicit_mta()

static void test_implicit_mta ( void )

static

Definition at line 4272 of file marshal.c.

{
    struct implicit_mta_marshal_data data;
    HANDLE host_thread, thread;
    IClassFactory *cf;
    IUnknown *proxy;
    IStream *stream;
    HRESULT hr;
    DWORD tid;
 
    cLocks = 0;
    external_connections = 0;
 
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    /* Firstly: we can unmarshal and use an object while in the implicit MTA. */
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(stream, &IID_IClassFactory, (IUnknown *)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    thread = CreateThread(NULL, 0, implicit_mta_unmarshal_proc, stream, 0, NULL);
    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");
    CloseHandle(thread);
 
    IStream_Release(stream);
    end_host_object(tid, host_thread);
 
    /* Secondly: we can unmarshal an object into the real MTA and then use it
     * from the implicit MTA. */
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(stream, &IID_IClassFactory, (IUnknown *)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    thread = CreateThread(NULL, 0, implicit_mta_use_proc, cf, 0, NULL);
    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");
    CloseHandle(thread);
 
    IClassFactory_Release(cf);
    IStream_Release(stream);
 
    ok_no_locks();
    ok_non_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(tid, host_thread);
 
    /* Thirdly: we can marshal an object from the implicit MTA and then
     * unmarshal it into the real one. */
    data.start = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.stop  = CreateEventA(NULL, FALSE, FALSE, NULL);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    thread = CreateThread(NULL, 0, implicit_mta_marshal_proc, &data, 0, NULL);
    ok(!WaitForSingleObject(data.start, 1000), "wait failed\n");
 
    IStream_Seek(data.stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(data.stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IUnknown_Release(proxy);
 
    SetEvent(data.stop);
    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");
    CloseHandle(thread);
 
    IStream_Release(data.stream);
 
    CoUninitialize();
}

Referenced by START_TEST().

◆ test_inproc_handler()

static void test_inproc_handler ( void )

static

Definition at line 3467 of file marshal.c.

{
    HRESULT hr;
    IUnknown *pObject;
    IUnknown *pObject2;
 
    if (FAILED(reg_unreg_wine_test_class(TRUE)))
        return;
 
    hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&pObject);
    ok_ole_success(hr, "CoCreateInstance");
 
    if (SUCCEEDED(hr))
    {
        hr = IUnknown_QueryInterface(pObject, &IID_IWineTest, (void **)&pObject2);
        ok(hr == E_NOINTERFACE, "IUnknown_QueryInterface on handler for invalid interface returned 0x%08lx instead of E_NOINTERFACE\n", hr);
 
        /* it's a handler as it supports IOleObject */
        hr = IUnknown_QueryInterface(pObject, &IID_IOleObject, (void **)&pObject2);
        ok_ole_success(hr, "IUnknown_QueryInterface(&IID_IOleObject)");
        IUnknown_Release(pObject2);
 
        IUnknown_Release(pObject);
    }
 
    reg_unreg_wine_test_class(FALSE);
}

Referenced by START_TEST().

◆ test_interthread_marshal_and_unmarshal()

static void test_interthread_marshal_and_unmarshal ( void )

static

Definition at line 947 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ Test_IUnknown_AddRef()

static ULONG WINAPI Test_IUnknown_AddRef ( LPUNKNOWN iface )

static

Definition at line 245 of file marshal.c.

{
    LockModule();
    return 2; /* non-heap-based object */
}

◆ Test_IUnknown_QueryInterface()

static HRESULT WINAPI Test_IUnknown_QueryInterface	(	LPUNKNOWN	iface,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 227 of file marshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown))
    {
        *ppvObj = iface;
        IUnknown_AddRef(iface);
        return S_OK;
    }
 
    *ppvObj = NULL;
    return E_NOINTERFACE;
}

◆ Test_IUnknown_Release()

static ULONG WINAPI Test_IUnknown_Release ( LPUNKNOWN iface )

static

Definition at line 251 of file marshal.c.

{
    UnlockModule();
    return 1; /* non-heap-based object */
}

◆ test_local_server()

static void test_local_server ( void )

static

Definition at line 3898 of file marshal.c.

{
    DWORD cookie;
    HRESULT hr;
    IClassFactory * cf;
    IPersist *persist;
    DWORD ret;
    HANDLE process;
    HANDLE quit_event;
    HANDLE ready_event;
    HANDLE repeat_event;
    CLSID clsid;
 
    heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL);
 
    cLocks = 0;
 
    /* Start the object suspended */
    hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory,
        CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE | REGCLS_SUSPENDED, &cookie);
    ok_ole_success(hr, CoRegisterClassObject);
 
    /* ... and CoGetClassObject does not find it and fails when it looks for the
     * class in the registry */
    hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER,
        NULL, &IID_IClassFactory, (LPVOID*)&cf);
    todo_wine ok(hr == REGDB_E_CLASSNOTREG, "Got hr %#lx.\n", hr);
 
    /* Resume the object suspended above ... */
    hr = CoResumeClassObjects();
    ok_ole_success(hr, CoResumeClassObjects);
 
    /* ... and now it should succeed */
    hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER,
        NULL, &IID_IClassFactory, (LPVOID*)&cf);
    ok_ole_success(hr, CoGetClassObject);
 
    /* Now check the locking is working */
    /* NOTE: we are accessing the class directly, not through a proxy */
 
    ok_no_locks();
 
    hr = IClassFactory_LockServer(cf, TRUE);
    ok_ole_success(hr, IClassFactory_LockServer);
 
    ok_more_than_one_lock();
    
    IClassFactory_LockServer(cf, FALSE);
    ok_ole_success(hr, IClassFactory_LockServer);
 
    ok_no_locks();
 
    IClassFactory_Release(cf);
 
    /* wait for shutdown signal */
    ret = WaitForSingleObject(heventShutdown, 0);
    ok(ret != WAIT_TIMEOUT, "Server didn't shut down\n");
 
    /* try to connect again after SCM has suspended registered class objects */
    hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, NULL,
        &IID_IClassFactory, (LPVOID*)&cf);
    todo_wine ok(hr == CO_E_SERVER_STOPPING || hr == REGDB_E_CLASSNOTREG /* Win10 1709+ */, "Got hr %#lx.\n", hr);
 
    hr = CoRevokeClassObject(cookie);
    ok_ole_success(hr, CoRevokeClassObject);
 
    CloseHandle(heventShutdown);
 
    process = create_target_process("-Embedding");
    ok(process != NULL, "couldn't start local server process, error was %ld\n", GetLastError());
 
    ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
    ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" );
 
    hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
    ok_ole_success(hr, CoCreateInstance);
 
    IPersist_Release(persist);
 
    hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
    ok(hr == REGDB_E_CLASSNOTREG, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n");
 
    /* Re-register the class and try calling CoDisconnectObject from within a call to that object */
    repeat_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event");
    SetEvent(repeat_event);
    CloseHandle(repeat_event);
 
    ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" );
    CloseHandle(ready_event);
 
    hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
    ok_ole_success(hr, CoCreateInstance);
 
    /* GetClassID will call CoDisconnectObject */
    IPersist_GetClassID(persist, &clsid);
    IPersist_Release(persist);
 
    quit_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
    SetEvent(quit_event);
 
    wait_child_process( process );
    CloseHandle(quit_event);
    CloseHandle(process);
}

Referenced by START_TEST().

◆ test_lock_object_external()

static void test_lock_object_external ( void )

static

Definition at line 2351 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
 
    cLocks = 0;
    external_connections = 0;
 
    /* test the stub manager creation aspect of CoLockObjectExternal when the
     * object hasn't been marshaled yet */
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
 
    ok_no_locks();
    ok_non_zero_external_conn();
    external_connections = 0;
 
    /* test our empty stub manager being handled correctly in
     * CoMarshalInterface */
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    /* test CoLockObjectExternal releases reference to object with
     * fLastUnlockReleases as TRUE and there are only strong references on
     * the object */
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, FALSE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, FALSE);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    /* test CoLockObjectExternal doesn't release the last reference to an
     * object with fLastUnlockReleases as TRUE and there is a weak reference
     * on the object */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, FALSE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, FALSE);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
 
    ok_no_locks();
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

◆ test_manualresetevent()

static void test_manualresetevent ( void )

static

Definition at line 4110 of file marshal.c.

{
    ISynchronizeHandle *sync_handle;
    ISynchronize *psync1, *psync2;
    IClassFactory *factory;
    IUnknown *punk;
    HANDLE handle;
    LONG ref;
    HRESULT hr;
 
    hr = pDllGetClassObject(&CLSID_ManualResetEvent, &IID_IClassFactory, (void **)&factory);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IClassFactory_Release(factory);
 
    hr = CoGetClassObject(&CLSID_ManualResetEvent, CLSCTX_INPROC_SERVER, NULL, &IID_IClassFactory, (void **)&factory);
    ok(hr == S_OK, "Unexpected hr %#lx.\n", hr);
    IClassFactory_Release(factory);
 
    hr = CoCreateInstance(&CLSID_ManualResetEvent, NULL, CLSCTX_INPROC_SERVER, &IID_IUnknown, (void**)&punk);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    ok(!!punk, "Got NULL.\n");
    IUnknown_Release(punk);
 
    hr = CoCreateInstance(&CLSID_ManualResetEvent, NULL, CLSCTX_INPROC_SERVER, &IID_ISynchronize, (void**)&psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    ok(!!psync1, "Got NULL.\n");
 
    hr = ISynchronize_Wait(psync1, 0, 5);
    ok(hr == RPC_S_CALLPENDING, "Got 0x%08lx\n", hr);
 
    hr = ISynchronize_Reset(psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Signal(psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Wait(psync1, 0, 5);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Wait(psync1, 0, 5);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Reset(psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Wait(psync1, 0, 5);
    ok(hr == RPC_S_CALLPENDING, "Got 0x%08lx\n", hr);
 
    hr = CoCreateInstance(&CLSID_ManualResetEvent, NULL, CLSCTX_INPROC_SERVER, &IID_ISynchronize, (void**)&psync2);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    ok(!!psync2, "Got NULL.\n");
    ok(psync1 != psync2, "psync1 == psync2.\n");
 
    hr = ISynchronize_QueryInterface(psync2, &IID_ISynchronizeHandle, (void**)&sync_handle);
    ok(hr == S_OK, "QueryInterface(IID_ISynchronizeHandle) failed: %08lx\n", hr);
 
    handle = NULL;
    hr = ISynchronizeHandle_GetHandle(sync_handle, &handle);
    ok(hr == S_OK, "GetHandle failed: %08lx\n", hr);
    ok(handle != NULL && handle != INVALID_HANDLE_VALUE, "handle = %p\n", handle);
 
    ISynchronizeHandle_Release(sync_handle);
 
    hr = ISynchronize_Wait(psync2, 0, 5);
    ok(hr == RPC_S_CALLPENDING, "Got 0x%08lx\n", hr);
 
    hr = ISynchronize_Reset(psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Reset(psync2);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Signal(psync1);
    ok(hr == S_OK, "Got 0x%08lx\n", hr);
    hr = ISynchronize_Wait(psync2, 0, 5);
    ok(hr == RPC_S_CALLPENDING, "Got 0x%08lx\n", hr);
 
    ref = ISynchronize_AddRef(psync1);
    ok(ref == 2, "Got ref: %ld\n", ref);
    ref = ISynchronize_AddRef(psync1);
    ok(ref == 3, "Got ref: %ld\n", ref);
    ref = ISynchronize_Release(psync1);
    ok(ref == 2, "Got nonzero ref: %ld\n", ref);
    ref = ISynchronize_Release(psync2);
    ok(!ref, "Got nonzero ref: %ld\n", ref);
    ref = ISynchronize_Release(psync1);
    ok(ref == 1, "Got nonzero ref: %ld\n", ref);
    ref = ISynchronize_Release(psync1);
    ok(!ref, "Got nonzero ref: %ld\n", ref);
}

Referenced by START_TEST().

◆ test_marshal_and_unmarshal_invalid()

static void test_marshal_and_unmarshal_invalid ( void )

static

Definition at line 868 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IClassFactory *pProxy = NULL;
    DWORD tid;
    void * dummy;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    todo_wine { ok_ole_success(hr, CoUnmarshalInterface); }
 
    ok_no_locks();
 
    if (pProxy)
    {
        hr = IClassFactory_CreateInstance(pProxy, NULL, &IID_IUnknown, &dummy);
        ok(hr == RPC_E_DISCONNECTED, "Remote call should have returned RPC_E_DISCONNECTED, instead of 0x%08lx\n", hr);
 
        IClassFactory_Release(pProxy);
    }
 
    IStream_Release(pStream);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_marshal_channel_buffer()

static void test_marshal_channel_buffer ( void )

static

Definition at line 1373 of file marshal.c.

{
    DWORD registration_key;
    IUnknown *proxy = NULL;
    IOleWindow *ole_window;
    HWND hwnd;
    CLSID clsid;
    DWORD tid;
    HANDLE thread;
    HRESULT hr;
 
    struct host_object_data object_data = { NULL, &IID_IOleClientSite, (IUnknown*)&Test_OleClientSite,
                                            MSHLFLAGS_NORMAL, NULL, (IUnknown*)&PSFactoryBuffer,
                                            &CLSID_WineTestPSFactoryBuffer };
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CoGetPSClsid(&IID_IOleWindow, &clsid);
    ok_ole_success(hr, "CoGetPSClsid");
 
    hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer,
        (void **)&ps_factory_buffer);
    ok_ole_success(hr, "CoGetClassObject");
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &object_data.stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object2(&object_data, &thread);
 
    IStream_Seek(object_data.stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(object_data.stream, &IID_IUnknown, (void **)&proxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(object_data.stream);
 
    hr = CoRegisterClassObject(&CLSID_WineTestPSFactoryBuffer, (IUnknown *)&PSFactoryBuffer,
        CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &registration_key);
    ok(hr == S_OK, "CoRegisterClassObject failed: %08lx\n", hr);
 
    hr = CoRegisterPSClsid(&IID_IOleWindow, &CLSID_WineTestPSFactoryBuffer);
    ok(hr == S_OK, "CoRegisterPSClsid failed: %08lx\n", hr);
 
    SET_EXPECT(CreateStub);
    SET_EXPECT(CreateProxy);
    SET_EXPECT(Connect);
    hr = IUnknown_QueryInterface(proxy, &IID_IOleWindow, (void**)&ole_window);
    ok(hr == S_OK, "Could not get IOleWindow iface: %08lx\n", hr);
    CHECK_CALLED(CreateStub);
    CHECK_CALLED(CreateProxy);
    CHECK_CALLED(Connect);
 
    SET_EXPECT(Invoke);
    SET_EXPECT(GetWindow);
    hr = IOleWindow_GetWindow(ole_window, &hwnd);
    ok(hr == S_OK, "GetWindow failed: %08lx\n", hr);
    ok((DWORD)(DWORD_PTR)hwnd == 0xdeadbeef, "hwnd = %p\n", hwnd);
    CHECK_CALLED(Invoke);
    CHECK_CALLED(GetWindow);
 
    IOleWindow_Release(ole_window);
 
    SET_EXPECT(RpcStubBuffer_Disconnect);
    SET_EXPECT(RpcProxyBuffer_Disconnect);
    IUnknown_Release(proxy);
    todo_wine
    CHECK_CALLED(RpcStubBuffer_Disconnect);
    todo_wine
    CHECK_CALLED(RpcProxyBuffer_Disconnect);
 
    hr = CoRevokeClassObject(registration_key);
    ok(hr == S_OK, "CoRevokeClassObject failed: %08lx\n", hr);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_marshal_proxy_apartment_shutdown()

static void test_marshal_proxy_apartment_shutdown ( void )

static

Definition at line 1281 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IClassFactory *proxy;
    IUnknown *unk;
    ULONG ref;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoUninitialize();
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&unk);
    ok(hr == CO_E_OBJNOTCONNECTED, "got %#lx\n", hr);
 
    ref = IClassFactory_Release(proxy);
    ok(!ref, "got %ld refs\n", ref);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
}

Referenced by START_TEST().

◆ test_marshal_proxy_mta_apartment_shutdown()

static void test_marshal_proxy_mta_apartment_shutdown ( void )

static

Definition at line 1329 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid;
    HANDLE thread;
 
    CoUninitialize();
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoUninitialize();
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
}

Referenced by START_TEST().

◆ test_marshal_stub_apartment_shutdown()

static void test_marshal_stub_apartment_shutdown ( void )

static

Definition at line 1241 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    end_host_object(tid, thread);
 
    ok_no_locks();
todo_wine {
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
}
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
}

Referenced by START_TEST().

◆ test_message_filter()

static void test_message_filter ( void )

static

Definition at line 2719 of file marshal.c.

{
    HRESULT hr;
    IClassFactory *cf = NULL;
    DWORD tid;
    IUnknown *proxy = NULL;
    IMessageFilter *prev_filter = NULL;
    HANDLE thread;
 
    struct host_object_data object_data = { NULL, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory,
                                            MSHLFLAGS_NORMAL, &MessageFilter };
 
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &object_data.stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object2(&object_data, &thread);
 
    ok_more_than_one_lock();
 
    IStream_Seek(object_data.stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(object_data.stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(object_data.stream);
 
    ok_more_than_one_lock();
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
    ok(hr == RPC_E_CALL_REJECTED, "Call should have returned RPC_E_CALL_REJECTED, but return 0x%08lx instead\n", hr);
    if (proxy) IUnknown_Release(proxy);
    proxy = NULL;
 
    hr = CoRegisterMessageFilter(&MessageFilter, &prev_filter);
    ok_ole_success(hr, CoRegisterMessageFilter);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IUnknown_Release(proxy);
 
    IClassFactory_Release(cf);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
 
    hr = CoRegisterMessageFilter(prev_filter, NULL);
    ok_ole_success(hr, CoRegisterMessageFilter);
}

Referenced by START_TEST().

◆ test_message_reentrancy()

static void test_message_reentrancy ( void )

static

Definition at line 3116 of file marshal.c.

{
    MSG msg;
 
    hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
    ok(hwnd_app != NULL, "Window creation failed\n");
 
    /* start message re-entrancy test */
    PostMessageA(hwnd_app, WM_USER, 0, 0);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
    DestroyWindow(hwnd_app);
}

Referenced by START_TEST().

◆ test_mta_creation_thread_change_apartment()

static void test_mta_creation_thread_change_apartment ( void )

static

Definition at line 4601 of file marshal.c.

{
    struct implicit_mta_marshal_data data;
    IClassFactory *cf;
    IUnknown *proxy;
    HANDLE thread;
    HRESULT hr;
 
    CoInitializeEx(NULL, COINIT_MULTITHREADED);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    data.start = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.stop  = CreateEventA(NULL, FALSE, FALSE, NULL);
 
    thread = CreateThread(NULL, 0, second_mta_thread_proc, &data, 0, NULL);
    ok(!WaitForSingleObject(data.start, 1000), "wait failed\n");
    CoUninitialize();
 
    CoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
 
    IStream_Seek(data.stream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(data.stream, &IID_IClassFactory, (void **)&cf);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (void **)&proxy);
    ok_ole_success(hr, IClassFactory_CreateInstance);
 
    IUnknown_Release(proxy);
    IStream_Release(data.stream);
 
    SetEvent(data.stop);
    ok(!WaitForSingleObject(thread, 1000), "wait failed\n");
    CloseHandle(thread);
 
    CoUninitialize();
}

Referenced by START_TEST().

◆ test_no_couninitialize_client()

static void test_no_couninitialize_client ( void )

static

Definition at line 1835 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    DWORD tid;
    DWORD host_tid;
    HANDLE thread;
    HANDLE host_thread;
    struct ncu_params ncu_params;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    ncu_params.stream = pStream;
 
    /* NOTE: assumes start_host_object uses an STA to host the object, as MTAs
     * always deadlock when called from within DllMain */
    host_tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown *)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    thread = CreateThread(NULL, 0, no_couninitialize_client_proc, &ncu_params, 0, &tid);
 
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(host_tid, host_thread);
}

Referenced by START_TEST().

◆ test_no_couninitialize_server()

static void test_no_couninitialize_server ( void )

static

Definition at line 1763 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid;
    HANDLE thread;
    struct ncu_params ncu_params;
 
    cLocks = 0;
    external_connections = 0;
 
    ncu_params.marshal_event = CreateEventA(NULL, TRUE, FALSE, NULL);
    ncu_params.unmarshal_event = CreateEventA(NULL, TRUE, FALSE, NULL);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    ncu_params.stream = pStream;
 
    thread = CreateThread(NULL, 0, no_couninitialize_server_proc, &ncu_params, 0, &tid);
 
    ok( !WaitForSingleObject(ncu_params.marshal_event, 10000), "wait timed out\n" );
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    SetEvent(ncu_params.unmarshal_event);
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
 
    ok_no_locks();
todo_wine {
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
}
 
    CloseHandle(thread);
    CloseHandle(ncu_params.marshal_event);
    CloseHandle(ncu_params.unmarshal_event);
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
}

Referenced by START_TEST().

◆ test_no_marshaler()

static void test_no_marshaler ( void )

static

Definition at line 795 of file marshal.c.

{
    IStream *pStream;
    HRESULT hr;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IWineTest, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok(hr == E_NOINTERFACE, "CoMarshalInterface should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

◆ test_normal_marshal_and_release()

static void test_normal_marshal_and_release ( void )

static

Definition at line 809 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoReleaseMarshalData(pStream);
    ok_ole_success(hr, CoReleaseMarshalData);
    IStream_Release(pStream);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
}

Referenced by START_TEST().

◆ test_normal_marshal_and_unmarshal()

static void test_normal_marshal_and_unmarshal ( void )

static

Definition at line 836 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
}

Referenced by START_TEST().

◆ test_normal_marshal_and_unmarshal_twice()

static void test_normal_marshal_and_unmarshal_twice ( void )

static

Definition at line 2487 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy1 = NULL;
    IUnknown *pProxy2 = NULL;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok(hr == CO_E_OBJNOTCONNECTED,
        "CoUnmarshalInterface should have failed with error CO_E_OBJNOTCONNECTED for double unmarshal, instead of 0x%08lx\n", hr);
 
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
 
    IUnknown_Release(pProxy1);
 
    ok_no_locks();
}

Referenced by START_TEST().

◆ test_proxy_interfaces()

static void test_proxy_interfaces ( void )

static

Definition at line 2795 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pOtherUnknown = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IUnknown, (LPVOID*)&pOtherUnknown);
    ok_ole_success(hr, IUnknown_QueryInterface IID_IUnknown);
    if (hr == S_OK) IUnknown_Release(pOtherUnknown);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (LPVOID*)&pOtherUnknown);
    ok_ole_success(hr, IUnknown_QueryInterface IID_IClientSecurity);
    if (hr == S_OK) IUnknown_Release(pOtherUnknown);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IMultiQI, (LPVOID*)&pOtherUnknown);
    ok_ole_success(hr, IUnknown_QueryInterface IID_IMultiQI);
    if (hr == S_OK) IUnknown_Release(pOtherUnknown);
 
    hr = IUnknown_QueryInterface(pProxy, &IID_IMarshal, (LPVOID*)&pOtherUnknown);
    ok_ole_success(hr, IUnknown_QueryInterface IID_IMarshal);
    if (hr == S_OK) IUnknown_Release(pOtherUnknown);
 
    /* IMarshal2 is also supported on NT-based systems, but is pretty much
     * useless as it has no more methods over IMarshal that it inherits from. */
 
    IUnknown_Release(pProxy);
 
    ok_no_locks();
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_proxy_marshal_and_unmarshal()

static void test_proxy_marshal_and_unmarshal ( void )

static

Definition at line 987 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
    int i;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    /* marshal the proxy */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
 
    /* marshal 5 more times to exhaust the normal external references of 5 */
    for (i = 0; i < NORMALEXTREFS; i++)
    {
        hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
        ok_ole_success(hr, CoMarshalInterface);
    }
 
    ok_more_than_one_lock();
 
    /* release the original proxy to test that we successfully keep the
     * original object alive */
    IUnknown_Release(pProxy);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxy2);
 
    /* unmarshal all of the proxies to check that the object stub still exists */
    for (i = 0; i < NORMALEXTREFS; i++)
    {
        hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
        ok_ole_success(hr, CoUnmarshalInterface);
 
        IUnknown_Release(pProxy2);
    }
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    IStream_Release(pStream);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_proxy_marshal_and_unmarshal2()

static void test_proxy_marshal_and_unmarshal2 ( void )

static

Definition at line 1062 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IUnknown, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    /* marshal the proxy */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    /* unmarshal the second proxy to the object */
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    /* now the proxies should be as follows:
     *  pProxy -> &Test_ClassFactory
     *  pProxy2 -> &Test_ClassFactory
     * they should NOT be as follows:
     *  pProxy -> &Test_ClassFactory
     *  pProxy2 -> pProxy
     * the above can only really be tested by looking in +ole traces
     */
 
    ok_more_than_one_lock();
 
    IUnknown_Release(pProxy);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxy2);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_proxy_marshal_and_unmarshal_strong()

static void test_proxy_marshal_and_unmarshal_strong ( void )

static

Definition at line 1179 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    /* marshal the proxy */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
    ok(hr == S_OK, "Got hr %#lx.\n", hr);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    /* release the original proxy to test that we successfully keep the
     * original object alive */
    IUnknown_Release(pProxy);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxy2);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Release(pStream);
 
    end_host_object(tid, thread);
 
    ok_no_locks();
todo_wine {
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
}
}

Referenced by START_TEST().

◆ test_proxy_marshal_and_unmarshal_weak()

static void test_proxy_marshal_and_unmarshal_weak ( void )

static

Definition at line 1126 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    /* marshal the proxy */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    /* release the original proxy to test that we successfully keep the
     * original object alive */
    IUnknown_Release(pProxy);
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    todo_wine
    ok(hr == CO_E_OBJNOTREG, "CoUnmarshalInterface should return CO_E_OBJNOTREG instead of 0x%08lx\n", hr);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    IStream_Release(pStream);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_proxy_used_in_wrong_thread()

static void test_proxy_used_in_wrong_thread ( void )

static

Definition at line 2598 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid, tid2;
    HANDLE thread;
    HANDLE host_thread;
 
    cLocks = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
 
    ok_more_than_one_lock();
    
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
 
    /* do a call that will fail, but result in IRemUnknown being used by the proxy */
    IUnknown_QueryInterface(pProxy, &IID_IStream, (LPVOID *)&pStream);
 
    /* create a thread that we can misbehave in */
    thread = CreateThread(NULL, 0, bad_thread_proc, pProxy, 0, &tid2);
 
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
 
    ok_no_locks();
 
    end_host_object(tid, host_thread);
}

Referenced by START_TEST().

◆ test_proxybuffer()

static void test_proxybuffer ( REFIID riid )

static

Definition at line 2889 of file marshal.c.

{
    HRESULT hr;
    IPSFactoryBuffer *psfb;
    IRpcProxyBuffer *proxy;
    LPVOID lpvtbl;
    ULONG refs;
    CLSID clsid;
    HeapUnknown *pUnkOuter = HeapAlloc(GetProcessHeap(), 0, sizeof(*pUnkOuter));
 
    pUnkOuter->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
    pUnkOuter->refs = 1;
 
    hr = CoGetPSClsid(riid, &clsid);
    ok_ole_success(hr, CoGetPSClsid);
 
    hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (LPVOID*)&psfb);
    ok_ole_success(hr, CoGetClassObject);
 
    hr = IPSFactoryBuffer_CreateProxy(psfb, &pUnkOuter->IUnknown_iface, riid, &proxy, &lpvtbl);
    ok_ole_success(hr, IPSFactoryBuffer_CreateProxy);
    ok(lpvtbl != NULL, "IPSFactoryBuffer_CreateProxy succeeded, but returned a NULL vtable!\n");
 
    /* release our reference to the outer unknown object - the PS factory
     * buffer will have AddRef's it in the CreateProxy call */
    refs = IUnknown_Release(&pUnkOuter->IUnknown_iface);
    ok(refs == 1, "Ref count of outer unknown should have been 1 instead of %ld\n", refs);
 
    /* Not checking return, unreliable on native. Maybe it leaks references? */
    IPSFactoryBuffer_Release(psfb);
 
    refs = IUnknown_Release((IUnknown *)lpvtbl);
    ok(refs == 0, "Ref-count leak of %ld on IRpcProxyBuffer\n", refs);
 
    refs = IRpcProxyBuffer_Release(proxy);
    ok(refs == 0, "Ref-count leak of %ld on IRpcProxyBuffer\n", refs);
}

Referenced by START_TEST().

◆ test_register_local_server()

static void test_register_local_server ( void )

static

Definition at line 3829 of file marshal.c.

{
    DWORD cookie;
    HRESULT hr;
    HANDLE ready_event;
    DWORD wait;
    HANDLE handles[2];
 
    heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL);
    ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
    handles[0] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
    handles[1] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event");
 
again:
    hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory,
                               CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
    ok_ole_success(hr, CoRegisterClassObject);
 
    SetEvent(ready_event);
 
    do
    {
        wait = MsgWaitForMultipleObjects(2, handles, FALSE, 30000, QS_ALLINPUT);
        if (wait == WAIT_OBJECT_0+2)
        {
            MSG msg;
 
            if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessageA(&msg);
            }
        }
        else if (wait == WAIT_OBJECT_0+1)
        {
            hr = CoRevokeClassObject(cookie);
            ok_ole_success(hr, CoRevokeClassObject);
            goto again;
        }
    }
    while (wait == WAIT_OBJECT_0+2);
 
    ok( wait == WAIT_OBJECT_0, "quit event wait timed out\n" );
    hr = CoRevokeClassObject(cookie);
    ok_ole_success(hr, CoRevokeClassObject);
    CloseHandle(handles[0]);
    CloseHandle(handles[1]);
}

Referenced by START_TEST().

◆ test_same_apartment_unmarshal_failure()

static void test_same_apartment_unmarshal_failure ( void )

static

Definition at line 914 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream;
    IUnknown *pProxy;
    static const LARGE_INTEGER llZero;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    hr = CoMarshalInterface(pStream, &IID_IUnknown, (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
 
    hr = CoUnmarshalInterface(pStream, &IID_IParseDisplayName, (void **)&pProxy);
    ok(hr == E_NOINTERFACE, "CoUnmarshalInterface should have returned E_NOINTERFACE instead of 0x%08lx\n", hr);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

◆ Test_SMI_AddRef()

static ULONG WINAPI Test_SMI_AddRef ( IStdMarshalInfo * iface )

static

Definition at line 3513 of file marshal.c.

{
    LockModule();
    return 2; /* non-heap-based object */
}

◆ Test_SMI_GetClassForHandler()

static HRESULT WINAPI Test_SMI_GetClassForHandler	(	IStdMarshalInfo *	iface,
		DWORD	dwDestContext,
		void *	pvDestContext,
		CLSID *	pClsid
	)

static

Definition at line 3525 of file marshal.c.

{
    *pClsid = CLSID_WineTest;
    return S_OK;
}

◆ Test_SMI_QueryInterface()

static HRESULT WINAPI Test_SMI_QueryInterface	(	IStdMarshalInfo *	iface,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 3495 of file marshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IStdMarshalInfo))
    {
        *ppvObj = iface;
        IStdMarshalInfo_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

◆ Test_SMI_Release()

static ULONG WINAPI Test_SMI_Release ( IStdMarshalInfo * iface )

static

Definition at line 3519 of file marshal.c.

{
    UnlockModule();
    return 1; /* non-heap-based object */
}

◆ test_StdMarshal_custom_marshaling()

static void test_StdMarshal_custom_marshaling ( void )

static

Definition at line 1556 of file marshal.c.

{
    IStream *stream;
    IUnknown *unk;
    DWORD size;
    HRESULT hr;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    unmarshal_class = &CLSID_StdMarshal;
    SET_EXPECT(CustomMarshal_GetUnmarshalClass);
    SET_EXPECT(CustomMarshal_MarshalInterface);
    hr = CoMarshalInterface(stream, &IID_IUnknown, (IUnknown*)&CustomMarshal,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
    CHECK_CALLED(CustomMarshal_GetUnmarshalClass);
    CHECK_CALLED(CustomMarshal_MarshalInterface);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    hr = CoUnmarshalInterface(stream, &IID_IUnknown, (void**)&unk);
    ok_ole_success(hr, CoUnmarshalInterface);
    ok(unk == (IUnknown*)&CustomMarshal, "unk != &CustomMarshal\n");
    IUnknown_Release(unk);
    IStream_Release(stream);
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    SET_EXPECT(CustomMarshal_GetUnmarshalClass);
    SET_EXPECT(CustomMarshal_MarshalInterface);
    hr = CoMarshalInterface(stream, &IID_IUnknown, (IUnknown*)&CustomMarshal,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoMarshalInterface);
    CHECK_CALLED(CustomMarshal_GetUnmarshalClass);
    CHECK_CALLED(CustomMarshal_MarshalInterface);
 
    hr = IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
    ok_ole_success(hr, IStream_Seek);
    hr = CoReleaseMarshalData(stream);
    ok_ole_success(hr, CoReleaseMarshalData);
    IStream_Release(stream);
 
    SET_EXPECT(CustomMarshal_GetMarshalSizeMax);
    hr = CoGetMarshalSizeMax(&size, &IID_IUnknown, (IUnknown*)&CustomMarshal,
            MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
    ok_ole_success(hr, CoGetMarshalSizeMax);
    CHECK_CALLED(CustomMarshal_GetMarshalSizeMax);
    ok(size == sizeof(OBJREF), "size = %ld, expected %d\n", size, (int)sizeof(OBJREF));
}

Referenced by START_TEST().

◆ test_stubbuffer()

static void test_stubbuffer ( REFIID riid )

static

Definition at line 2927 of file marshal.c.

{
    HRESULT hr;
    IPSFactoryBuffer *psfb;
    IRpcStubBuffer *stub;
    ULONG refs;
    CLSID clsid;
 
    cLocks = 0;
 
    hr = CoGetPSClsid(riid, &clsid);
    ok_ole_success(hr, CoGetPSClsid);
 
    hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (LPVOID*)&psfb);
    ok_ole_success(hr, CoGetClassObject);
 
    hr = IPSFactoryBuffer_CreateStub(psfb, riid, (IUnknown*)&Test_ClassFactory, &stub);
    ok_ole_success(hr, IPSFactoryBuffer_CreateStub);
 
    /* Not checking return, unreliable on native. Maybe it leaks references? */
    IPSFactoryBuffer_Release(psfb);
 
    ok_more_than_one_lock();
 
    IRpcStubBuffer_Disconnect(stub);
 
    ok_no_locks();
 
    refs = IRpcStubBuffer_Release(stub);
    ok(refs == 0, "Ref-count leak of %ld on IRpcProxyBuffer\n", refs);
}

Referenced by START_TEST().

◆ test_tablestrong_marshal_and_unmarshal_twice()

static void test_tablestrong_marshal_and_unmarshal_twice ( void )

static

Definition at line 2298 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy1 = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLESTRONG, &thread);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    if (pProxy1) IUnknown_Release(pProxy1);
    if (pProxy2) IUnknown_Release(pProxy2);
 
    /* this line is shows the difference between weak and strong table marshaling:
     *  weak has cLocks == 0
     *  strong has cLocks > 0 */
    ok_more_than_one_lock();
 
    /* release the remaining reference on the object by calling
     * CoReleaseMarshalData in the hosting thread */
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 0);
    IStream_Release(pStream);
 
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_tableweak_and_normal_marshal_and_releasedata()

static void test_tableweak_and_normal_marshal_and_releasedata ( void )

static

Definition at line 2202 of file marshal.c.

{
    HRESULT hr;
    DWORD tid;
    HANDLE thread;
    struct duo_marshal_data data;
 
    cLocks = 0;
    external_connections = 0;
 
    data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
    data.marshal_flags2 = MSHLFLAGS_NORMAL;
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
    ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
    CloseHandle(data.hReadyEvent);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    /* release normal - which in the non-external conn case will free the object despite the weak ref. */
    IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 2);
 
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    if (with_external_conn)
    {
        ok_more_than_one_lock();
        IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
        release_host_object(tid, 1);
    }
 
    ok_no_locks();
 
    IStream_Release(data.pStream1);
    IStream_Release(data.pStream2);
 
    SetEvent(data.hQuitEvent);
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
}

Referenced by START_TEST().

◆ test_tableweak_and_normal_marshal_and_unmarshal()

static void test_tableweak_and_normal_marshal_and_unmarshal ( void )

static

Definition at line 2132 of file marshal.c.

{
    HRESULT hr;
    IUnknown *pProxyWeak = NULL;
    IUnknown *pProxyNormal = NULL;
    DWORD tid;
    HANDLE thread;
    struct duo_marshal_data data;
 
    cLocks = 0;
    external_connections = 0;
 
    data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
    data.marshal_flags2 = MSHLFLAGS_NORMAL;
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
    ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
    CloseHandle(data.hReadyEvent);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    /* weak */
    IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(data.pStream1, &IID_IClassFactory, (void **)&pProxyWeak);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    /* normal */
    IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(data.pStream2, &IID_IClassFactory, (void **)&pProxyNormal);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IUnknown_Release(pProxyNormal);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxyWeak);
 
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    /* When IExternalConnection is present COM's lifetime management
     * behaviour is altered; the remaining weak ref prevents stub shutdown. */
    if (with_external_conn)
    {
        ok_more_than_one_lock();
        IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
        release_host_object(tid, 1);
    }
    ok_no_locks();
 
    IStream_Release(data.pStream1);
    IStream_Release(data.pStream2);
 
    SetEvent(data.hQuitEvent);
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
}

Referenced by START_TEST().

◆ test_tableweak_marshal_and_unmarshal_twice()

static void test_tableweak_marshal_and_unmarshal_twice ( void )

static

Definition at line 1925 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy1 = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
 
    IUnknown_Release(pProxy1);
    ok_non_zero_external_conn();
    IUnknown_Release(pProxy2);
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    /* When IExternalConnection is present COM's lifetime management
     * behaviour is altered; the remaining weak ref prevents stub shutdown. */
    if (with_external_conn)
    {
        ok_more_than_one_lock();
        IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
        release_host_object(tid, 0);
    }
 
    /* Without IExternalConnection this line is shows the difference between weak and strong table marshaling
     * weak has cLocks == 0, strong has cLocks > 0. */
    ok_no_locks();
 
    IStream_Release(pStream);
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_tableweak_marshal_releasedata1()

static void test_tableweak_marshal_releasedata1 ( void )

static

Definition at line 1981 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy1 = NULL;
    IUnknown *pProxy2 = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
    ok_ole_success(hr, CoUnmarshalInterface);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    /* release the remaining reference on the object by calling
     * CoReleaseMarshalData in the hosting thread */
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 0);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
    ok_ole_success(hr, CoUnmarshalInterface);
    IStream_Release(pStream);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    IUnknown_Release(pProxy1);
 
    if (pProxy2)
    {
        ok_non_zero_external_conn();
        IUnknown_Release(pProxy2);
    }
 
    /* this line is shows the difference between weak and strong table marshaling:
     *  weak has cLocks == 0
     *  strong has cLocks > 0 */
    ok_no_locks();
    ok_zero_external_conn();
    ok_last_release_closes(TRUE);
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_tableweak_marshal_releasedata2()

static void test_tableweak_marshal_releasedata2 ( void )

static

Definition at line 2042 of file marshal.c.

{
    HRESULT hr;
    IStream *pStream = NULL;
    IUnknown *pProxy = NULL;
    DWORD tid;
    HANDLE thread;
 
    cLocks = 0;
    external_connections = 0;
 
    hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    /* release the remaining reference on the object by calling
     * CoReleaseMarshalData in the hosting thread */
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 0);
 
    ok_no_locks();
 
    IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
    hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
    todo_wine
    {
    ok(hr == CO_E_OBJNOTREG,
       "CoUnmarshalInterface should have failed with CO_E_OBJNOTREG, but returned 0x%08lx instead\n",
       hr);
    }
    IStream_Release(pStream);
 
    ok_no_locks();
    ok_zero_external_conn();
 
    end_host_object(tid, thread);
}

Referenced by START_TEST().

◆ test_two_tableweak_marshal_and_releasedata()

static void test_two_tableweak_marshal_and_releasedata ( void )

static

Definition at line 2252 of file marshal.c.

{
    HRESULT hr;
    DWORD tid;
    HANDLE thread;
    struct duo_marshal_data data;
 
    cLocks = 0;
    external_connections = 0;
 
    data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
    data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
    data.marshal_flags2 = MSHLFLAGS_TABLEWEAK;
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
    ok_ole_success(hr, CreateStreamOnHGlobal);
    hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
    ok_ole_success(hr, CreateStreamOnHGlobal);
 
    thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
    ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
    CloseHandle(data.hReadyEvent);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    /* release one weak ref - the remaining weak ref will keep the obj alive */
    IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 1);
 
    ok_more_than_one_lock();
 
    IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
    release_host_object(tid, 2);
 
    ok_no_locks();
 
    IStream_Release(data.pStream1);
    IStream_Release(data.pStream2);
 
    SetEvent(data.hQuitEvent);
    ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
    CloseHandle(thread);
}

Referenced by START_TEST().

◆ test_WM_QUIT_handling()

static void test_WM_QUIT_handling ( void )

static

Definition at line 3200 of file marshal.c.

{
    MSG msg;
 
    hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
    ok(hwnd_app != NULL, "Window creation failed\n");
 
    /* start WM_QUIT handling test */
    PostMessageA(hwnd_app, WM_USER+1, 0, 0);
 
    while (GetMessageA(&msg, NULL, 0, 0))
    {
        TranslateMessage(&msg);
        DispatchMessageA(&msg);
    }
}

Referenced by START_TEST().

◆ TestChannelHook_AddRef()

static ULONG WINAPI TestChannelHook_AddRef ( IChannelHook * iface )

static

Definition at line 4370 of file marshal.c.

{
    return 2;
}

◆ TestChannelHook_ClientFillBuffer()

static void WINAPI TestChannelHook_ClientFillBuffer	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		ULONG *	pDataSize,
		void *	pDataBuffer
	)

static

Definition at line 4409 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
 
    if (winetest_debug > 1) trace("IChannelHook::ClientFillBuffer()\n");
 
    if (info->cbSize == sizeof(*info))
    {
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%lx instead of 0x%lx\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %ld should be %d\n", info->iMethod, method);
        ok(!info->pObject, "pObject should be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
 
    *(unsigned char *)pDataBuffer = 0xcc;
    *pDataSize = 1;
}

◆ TestChannelHook_ClientGetSize()

static void WINAPI TestChannelHook_ClientGetSize	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		ULONG *	pDataSize
	)

static

Definition at line 4383 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
 
    if (winetest_debug > 1) trace("IChannelHook::ClientGetSize(iid %s)\n", debugstr_guid(riid));
 
    if (info->cbSize == sizeof(*info))
    {
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%lx instead of 0x%lx\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %ld should be %d\n", info->iMethod, method);
        ok(!info->pObject, "pObject should be NULL\n");
        if (method == 3)
            causality = info->uCausality;
        else
            ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
 
    *pDataSize = 1;
}

◆ TestChannelHook_ClientNotify()

static void WINAPI TestChannelHook_ClientNotify	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		ULONG	cbDataSize,
		void *	pDataBuffer,
		DWORD	lDataRep,
		HRESULT	hrFault
	)

static

Definition at line 4434 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
 
    if (winetest_debug > 1) trace("IChannelHook::ClientNotify(hr %#lx)\n", hrFault);
 
    if (info->cbSize == sizeof(*info))
    {
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%lx instead of 0x%lx\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %ld should be %d\n", info->iMethod, method);
        todo_wine {
            ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        }
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
}

◆ TestChannelHook_QueryInterface()

static HRESULT WINAPI TestChannelHook_QueryInterface	(	IChannelHook *	iface,
		REFIID	riid,
		void **	ppv
	)

static

Definition at line 4357 of file marshal.c.

{
    if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IChannelHook))
    {
        *ppv = iface;
        IChannelHook_AddRef(iface);
        return S_OK;
    }
 
    *ppv = NULL;
    return E_NOINTERFACE;
}

◆ TestChannelHook_Release()

static ULONG WINAPI TestChannelHook_Release ( IChannelHook * iface )

static

Definition at line 4375 of file marshal.c.

{
    return 1;
}

◆ TestChannelHook_ServerFillBuffer()

static void WINAPI TestChannelHook_ServerFillBuffer	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		ULONG *	pDataSize,
		void *	pDataBuffer,
		HRESULT	hrFault
	)

static

Definition at line 4508 of file marshal.c.

{
    ok(0, "TestChannelHook_ServerFillBuffer shouldn't be called\n");
}

◆ TestChannelHook_ServerGetSize()

static void WINAPI TestChannelHook_ServerGetSize	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		HRESULT	hrFault,
		ULONG *	pDataSize
	)

static

Definition at line 4485 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
 
    if (winetest_debug > 1) trace("IChannelHook::ServerGetSize(iid %s, hr %#lx)\n", debugstr_guid(riid), hrFault);
 
    if (info->cbSize == sizeof(*info))
    {
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%lx instead of 0x%lx\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %ld should be %d\n", info->iMethod, method);
        ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
    *pDataSize = 0;
}

◆ TestChannelHook_ServerNotify()

static void WINAPI TestChannelHook_ServerNotify	(	IChannelHook *	iface,
		REFGUID	uExtent,
		REFIID	riid,
		ULONG	cbDataSize,
		void *	pDataBuffer,
		DWORD	lDataRep
	)

static

Definition at line 4460 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
 
    if (winetest_debug > 1) trace("IChannelHook::ServerNotify()\n");
 
    if (info->cbSize == sizeof(*info))
    {
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%lx instead of 0x%lx\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %ld should be %d\n", info->iMethod, method);
        ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
 
    ok(cbDataSize == 1, "cbDataSize should have been 1 instead of %ld\n", cbDataSize);
    ok(*(unsigned char *)pDataBuffer == 0xcc, "pDataBuffer should have contained 0xcc instead of 0x%x\n", *(unsigned char *)pDataBuffer);
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
}

◆ TestCrash_IUnknown_Release()

static ULONG WINAPI TestCrash_IUnknown_Release ( LPUNKNOWN iface )

static

Definition at line 266 of file marshal.c.

{
    UnlockModule();
    if(!cLocks) {
        trace("crashing...\n");
        RaiseException( EXCEPTION_ACCESS_VIOLATION, EXCEPTION_NONCONTINUABLE, 0, NULL );
    }
    return 1; /* non-heap-based object */
}

◆ TestMsg_IClassFactory_CreateInstance()

static HRESULT WINAPI TestMsg_IClassFactory_CreateInstance	(	LPCLASSFACTORY	iface,
		LPUNKNOWN	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 3134 of file marshal.c.

{
    *ppvObj = NULL;
    SendMessageA(hwnd_app, WM_USER+2, 0, 0);
    return S_OK;
}

◆ TestOOP_IClassFactory_AddRef()

static ULONG WINAPI TestOOP_IClassFactory_AddRef ( LPCLASSFACTORY iface )

static

Definition at line 3783 of file marshal.c.

{
    return 2; /* non-heap-based object */
}

◆ TestOOP_IClassFactory_CreateInstance()

static HRESULT WINAPI TestOOP_IClassFactory_CreateInstance	(	LPCLASSFACTORY	iface,
		LPUNKNOWN	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 3793 of file marshal.c.

{
    IPersist *persist = &local_server_class.IPersist_iface;
    HRESULT hr;
    IPersist_AddRef( persist );
    hr = IPersist_QueryInterface( persist, riid, ppvObj );
    IPersist_Release( persist );
    return hr;
}

◆ TestOOP_IClassFactory_LockServer()

static HRESULT WINAPI TestOOP_IClassFactory_LockServer	(	LPCLASSFACTORY	iface,
		BOOL	fLock
	)

static

Definition at line 3807 of file marshal.c.

{
    if (fLock)
        LockModuleOOP();
    else
        UnlockModuleOOP();
    return S_OK;
}

◆ TestOOP_IClassFactory_QueryInterface()

static HRESULT WINAPI TestOOP_IClassFactory_QueryInterface	(	LPCLASSFACTORY	iface,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 3765 of file marshal.c.

{
    if (ppvObj == NULL) return E_POINTER;
 
    if (IsEqualGUID(riid, &IID_IUnknown) ||
        IsEqualGUID(riid, &IID_IClassFactory))
    {
        *ppvObj = iface;
        IClassFactory_AddRef(iface);
        return S_OK;
    }
 
    return E_NOINTERFACE;
}

◆ TestOOP_IClassFactory_Release()

static ULONG WINAPI TestOOP_IClassFactory_Release ( LPCLASSFACTORY iface )

static

Definition at line 3788 of file marshal.c.

{
    return 1; /* non-heap-based object */
}

◆ TestRE_IClassFactory_CreateInstance()

static HRESULT WINAPI TestRE_IClassFactory_CreateInstance	(	LPCLASSFACTORY	iface,
		LPUNKNOWN	pUnkOuter,
		REFIID	riid,
		LPVOID *	ppvObj
	)

static

Definition at line 2961 of file marshal.c.

{
    DWORD_PTR res;
    if (IsEqualIID(riid, &IID_IWineTest))
    {
        BOOL ret = SendMessageTimeoutA(hwnd_app, WM_NULL, 0, 0, SMTO_BLOCK, 5000, &res);
        ok(ret, "Timed out sending a message to originating window during RPC call\n");
    }
    *ppvObj = NULL;
    return S_FALSE;
}

◆ UnlockModule()

static void UnlockModule ( void )

static

Definition at line 175 of file marshal.c.

{
    InterlockedDecrement(&cLocks);
}

Referenced by Test_IClassFactory_Release(), Test_IUnknown_Release(), Test_SMI_Release(), and TestCrash_IUnknown_Release().

◆ UnlockModuleOOP()

static void UnlockModuleOOP ( void )

static

Definition at line 3693 of file marshal.c.

{
    InterlockedDecrement(&cLocks); /* for test purposes only */
    if (!CoReleaseServerProcess())
        SetEvent(heventShutdown);
}

Referenced by TestOOP_IClassFactory_LockServer().

◆ window_proc()

static LRESULT CALLBACK window_proc	(	HWND	hwnd,
		UINT	msg,
		WPARAM	wparam,
		LPARAM	lparam
	)

static

Definition at line 2988 of file marshal.c.

{
    switch (msg)
    {
    case WM_USER:
    {
        HRESULT hr;
        IStream *pStream = NULL;
        IClassFactory *proxy = NULL;
        IUnknown *object;
        DWORD tid;
        HANDLE thread;
 
        cLocks = 0;
 
        hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
        ok_ole_success(hr, CreateStreamOnHGlobal);
        tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestRE_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
        ok_more_than_one_lock();
 
        IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
        hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
        ok_ole_success(hr, CoReleaseMarshalData);
        IStream_Release(pStream);
 
        ok_more_than_one_lock();
 
        /* note the use of the magic IID_IWineTest value to tell remote thread
         * to try to send a message back to us */
        hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IWineTest, (void **)&object);
        ok(hr == S_FALSE, "expected S_FALSE, got %ld\n", hr);
 
        IClassFactory_Release(proxy);
 
        ok_no_locks();
 
        end_host_object(tid, thread);
 
        PostMessageA(hwnd, WM_QUIT, 0, 0);
 
        return 0;
    }
    case WM_USER+1:
    {
        HRESULT hr;
        IStream *pStream = NULL;
        IClassFactory *proxy = NULL;
        IUnknown *object;
        DWORD tid;
        HANDLE thread;
 
        cLocks = 0;
 
        hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
        ok_ole_success(hr, CreateStreamOnHGlobal);
        tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestRE_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
        ok_more_than_one_lock();
 
        IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
        hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
        ok_ole_success(hr, CoReleaseMarshalData);
        IStream_Release(pStream);
 
        ok_more_than_one_lock();
 
        /* post quit message before a doing a COM call to show that a pending
        * WM_QUIT message doesn't stop the call from succeeding */
        PostMessageA(hwnd, WM_QUIT, 0, 0);
        hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
    ok(hr == S_FALSE, "IClassFactory_CreateInstance returned 0x%08lx, expected S_FALSE\n", hr);
 
        IClassFactory_Release(proxy);
 
        ok_no_locks();
 
        end_host_object(tid, thread);
 
        return 0;
    }
    case WM_USER+2:
    {
        HRESULT hr;
        IStream *pStream = NULL;
        IClassFactory *proxy = NULL;
        IUnknown *object;
        DWORD tid;
        HANDLE thread;
 
        hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
        ok_ole_success(hr, CreateStreamOnHGlobal);
        tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
 
        IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
        hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
        ok_ole_success(hr, CoReleaseMarshalData);
        IStream_Release(pStream);
 
        /* shows that COM calls executed during the processing of sent
         * messages should fail */
        hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
        ok(hr == RPC_E_CANTCALLOUT_ININPUTSYNCCALL,
           "COM call during processing of sent message should return RPC_E_CANTCALLOUT_ININPUTSYNCCALL instead of 0x%08lx\n", hr);
 
        IClassFactory_Release(proxy);
 
        end_host_object(tid, thread);
 
        PostQuitMessage(0);
 
        return 0;
    }
    default:
        return DefWindowProcA(hwnd, msg, wparam, lparam);
    }
}

Referenced by register_test_window().

Variable Documentation

◆ causality

GUID causality

static

Definition at line 4381 of file marshal.c.

Referenced by TestChannelHook_ClientFillBuffer(), TestChannelHook_ClientGetSize(), TestChannelHook_ClientNotify(), TestChannelHook_ServerGetSize(), and TestChannelHook_ServerNotify().

◆ cLocks

LONG cLocks

static

Definition at line 168 of file marshal.c.

◆ CLSID_DfMarshal

const GUID CLSID_DfMarshal = { 0x0000030b, 0x0000, 0x0000, { 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 } }

static

Definition at line 62 of file marshal.c.

Referenced by DllGetClassObject(), and test_DfMarshal_custom_marshaling().

◆ CLSID_ft_unmarshaler_1809

const GUID CLSID_ft_unmarshaler_1809 = {0x00000359, 0x0000, 0x0000, {0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}}

static

Definition at line 63 of file marshal.c.

Referenced by test_freethreadedmarshaler().

◆ CLSID_WineOOPTest

const CLSID CLSID_WineOOPTest

static

Initial value:

=
{
    0x5201163f,
    0x8164,
    0x4fd0,
    {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
}

Definition at line 140 of file marshal.c.

Referenced by DllGetClassObject(), get_class_object(), get_class_object_proxy_thread(), implicit_mta_proc(), register_class_object_thread(), test_CoCreateInstanceEx(), test_CoCreateInstanceFromApp(), test_CoRegisterClassObject(), test_local_server(), test_register_local_server(), and test_registered_object_thread_affinity().

◆ CLSID_WineTestPSFactoryBuffer

const GUID CLSID_WineTestPSFactoryBuffer = { 0x22222222, 0x1234, 0x1234, { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 } }

static

Definition at line 61 of file marshal.c.

Referenced by test_marshal_channel_buffer().

◆ crash_thread_success

BOOL crash_thread_success

static

Definition at line 1872 of file marshal.c.

Referenced by crash_couninitialize_proc(), and test_crash_couninitialize().

◆ CustomMarshal

IMarshal CustomMarshal = { &CustomMarshalVtbl }

static

Definition at line 1554 of file marshal.c.

Referenced by test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

◆ CustomMarshalVtbl

IMarshalVtbl CustomMarshalVtbl

static

Initial value:

=
{
    CustomMarshal_QueryInterface,
    CustomMarshal_AddRef,
    CustomMarshal_Release,
    CustomMarshal_GetUnmarshalClass,
    CustomMarshal_GetMarshalSizeMax,
    CustomMarshal_MarshalInterface,
    CustomMarshal_UnmarshalInterface,
    CustomMarshal_ReleaseMarshalData,
    CustomMarshal_DisconnectObject
}

Definition at line 1541 of file marshal.c.

◆ external_connections

DWORD external_connections

static

Definition at line 181 of file marshal.c.

◆ ExternalConnection

IExternalConnection ExternalConnection = { &ExternalConnectionVtbl }

static

Definition at line 224 of file marshal.c.

Referenced by Test_IClassFactory_QueryInterface().

◆ ExternalConnectionVtbl

const IExternalConnectionVtbl ExternalConnectionVtbl

static

Initial value:

= {
    ExternalConnection_QueryInterface,
    ExternalConnection_AddRef,
    ExternalConnection_Release,
    ExternalConnection_AddConnection,
    ExternalConnection_ReleaseConnection
}

Definition at line 216 of file marshal.c.

◆ HeapUnknown_Vtbl

const IUnknownVtbl HeapUnknown_Vtbl

static

Initial value:

=
{
    HeapUnknown_QueryInterface,
    HeapUnknown_AddRef,
    HeapUnknown_Release
}

Definition at line 2882 of file marshal.c.

Referenced by test_proxybuffer().

◆ heventShutdown

HANDLE heventShutdown

static

Definition at line 3685 of file marshal.c.

Referenced by test_local_server(), test_register_local_server(), and UnlockModuleOOP().

◆ hwnd_app

static HWND hwnd_app

static

Definition at line 2959 of file marshal.c.

Referenced by test_call_from_message(), test_message_reentrancy(), test_WM_QUIT_handling(), TestMsg_IClassFactory_CreateInstance(), and TestRE_IClassFactory_CreateInstance().

◆ IID_IRemUnknown

const IID IID_IRemUnknown

static

Initial value:

=
{
    0x00000131,
    0x0000,
    0x0000,
    {0xc0,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
}

Definition at line 129 of file marshal.c.

Referenced by proxy_manager_get_remunknown(), RemUnknown_QueryInterface(), start_apartment_remote_unknown(), test_client_security(), and Test_IClassFactory_QueryInterface().

◆ IID_IWineTest

const IID IID_IWineTest

static

Initial value:

=
{
    0x5201163f,
    0x8164,
    0x4fd0,
    {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
}

Definition at line 121 of file marshal.c.

Referenced by implicit_mta_proc(), register_ps_clsid_thread(), test_client_security(), test_CoGetPSClsid(), test_CoRegisterPSClsid(), test_handler_marshaling(), test_inproc_handler(), Test_IUnknown_QueryInterface(), test_no_marshaler(), TestRE_IClassFactory_CreateInstance(), and window_proc().

◆ last_release_closes

BOOL last_release_closes

static

Definition at line 182 of file marshal.c.

Referenced by ExternalConnection_ReleaseConnection().

◆ local_server_class

struct local_server local_server_class

Initial value:

=
{
    {&local_server_persist_vtbl}
}

Definition at line 3760 of file marshal.c.

Referenced by TestOOP_IClassFactory_CreateInstance().

◆ local_server_persist_vtbl

const IPersistVtbl local_server_persist_vtbl

static

Initial value:

=
{
    local_server_QueryInterface,
    local_server_AddRef,
    local_server_Release,
    local_server_GetClassID
}

Definition at line 3752 of file marshal.c.

◆ LPVOID

LPVOID

Definition at line 66 of file marshal.c.

◆ MessageFilter

IMessageFilter MessageFilter = { &MessageFilter_Vtbl }

static

Definition at line 2717 of file marshal.c.

Referenced by test_channel_hook(), and test_message_filter().

◆ MessageFilter_Vtbl

const IMessageFilterVtbl MessageFilter_Vtbl

static

Initial value:

=
{
    MessageFilter_QueryInterface,
    MessageFilter_AddRef,
    MessageFilter_Release,
    MessageFilter_HandleInComingCall,
    MessageFilter_RetryRejectedCall,
    MessageFilter_MessagePending
}

Definition at line 2707 of file marshal.c.

◆ method

int method

static

Definition at line 4380 of file marshal.c.

◆ OleClientSiteVtbl

const IOleClientSiteVtbl OleClientSiteVtbl

static

Initial value:

= {
    OleClientSite_QueryInterface,
    OleClientSite_AddRef,
    OleClientSite_Release,
    
}

Definition at line 420 of file marshal.c.

◆ OleWindowVtbl

const IOleWindowVtbl OleWindowVtbl

static

Initial value:

= {
    OleWindow_QueryInterface,
    OleWindow_AddRef,
    OleWindow_Release,
    OleWindow_GetWindow,
    
}

Definition at line 384 of file marshal.c.

◆ ps_factory_buffer

IPSFactoryBuffer* ps_factory_buffer

static

Definition at line 610 of file marshal.c.

Referenced by PSFactoryBuffer_CreateProxy(), PSFactoryBuffer_CreateStub(), and test_marshal_channel_buffer().

◆ PSFactoryBuffer

static IPSFactoryBuffer PSFactoryBuffer = { &PSFactoryBufferVtbl }

static

Definition at line 684 of file marshal.c.

Referenced by test_marshal_channel_buffer().

◆ PSFactoryBufferVtbl

IPSFactoryBufferVtbl PSFactoryBufferVtbl

static

Initial value:

=
{
    PSFactoryBuffer_QueryInterface,
    PSFactoryBuffer_AddRef,
    PSFactoryBuffer_Release,
    PSFactoryBuffer_CreateProxy,
    PSFactoryBuffer_CreateStub
}

Definition at line 675 of file marshal.c.

◆ REFIID

REFIID

Definition at line 66 of file marshal.c.

◆ RpcProxyBufferVtbl

const IRpcProxyBufferVtbl RpcProxyBufferVtbl

static

Initial value:

= {
    RpcProxyBuffer_QueryInterface,
    RpcProxyBuffer_AddRef,
    RpcProxyBuffer_Release,
    RpcProxyBuffer_Connect,
    RpcProxyBuffer_Disconnect,
}

Definition at line 602 of file marshal.c.

Referenced by PSFactoryBuffer_CreateProxy().

◆ RpcStubBufferVtbl

const IRpcStubBufferVtbl RpcStubBufferVtbl

static

Initial value:

= {
    RpcStubBuffer_QueryInterface,
    RpcStubBuffer_AddRef,
    RpcStubBuffer_Release,
    RpcStubBuffer_Connect,
    RpcStubBuffer_Disconnect,
    RpcStubBuffer_Invoke,
    RpcStubBuffer_IsIIDSupported,
    RpcStubBuffer_CountRefs,
    RpcStubBuffer_DebugServerQueryInterface,
    RpcStubBuffer_DebugServerRelease
}

Definition at line 524 of file marshal.c.

Referenced by PSFactoryBuffer_CreateStub().

◆ Test_ClassFactory

IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl }

static

Definition at line 350 of file marshal.c.

◆ Test_OleClientSite

IOleClientSite Test_OleClientSite = { &OleClientSiteVtbl }

static

Definition at line 427 of file marshal.c.

Referenced by PSFactoryBuffer_CreateStub(), and test_marshal_channel_buffer().

◆ Test_OleWindow

IOleWindow Test_OleWindow = { &OleWindowVtbl }

static

Definition at line 392 of file marshal.c.

Referenced by OleClientSite_QueryInterface().

◆ Test_SMI

IStdMarshalInfo Test_SMI = {&Test_SMI_Vtbl}

static

Definition at line 3543 of file marshal.c.

Referenced by test_handler_marshaling().

◆ Test_SMI_Vtbl

const IStdMarshalInfoVtbl Test_SMI_Vtbl

static

Initial value:

=
{
    Test_SMI_QueryInterface,
    Test_SMI_AddRef,
    Test_SMI_Release,
    Test_SMI_GetClassForHandler
}

Definition at line 3535 of file marshal.c.

◆ Test_Unknown

IUnknown Test_Unknown = { &TestUnknown_Vtbl }

static

Definition at line 264 of file marshal.c.

Referenced by test_CoGetStandardMarshal(), and Test_IClassFactory_CreateInstance().

◆ TestChannelHook

IChannelHook TestChannelHook = { &TestChannelHookVtbl }

static

Definition at line 4532 of file marshal.c.

Referenced by test_channel_hook().

◆ TestChannelHookVtbl

const IChannelHookVtbl TestChannelHookVtbl

static

Initial value:

=
{
    TestChannelHook_QueryInterface,
    TestChannelHook_AddRef,
    TestChannelHook_Release,
    TestChannelHook_ClientGetSize,
    TestChannelHook_ClientFillBuffer,
    TestChannelHook_ClientNotify,
    TestChannelHook_ServerNotify,
    TestChannelHook_ServerGetSize,
    TestChannelHook_ServerFillBuffer,
}

Definition at line 4519 of file marshal.c.

◆ TestClassFactory_Vtbl

const IClassFactoryVtbl TestClassFactory_Vtbl

static

Initial value:

=
{
    Test_IClassFactory_QueryInterface,
    Test_IClassFactory_AddRef,
    Test_IClassFactory_Release,
    Test_IClassFactory_CreateInstance,
    Test_IClassFactory_LockServer
}

Definition at line 341 of file marshal.c.

◆ TestClassFactoryOOP_Vtbl

const IClassFactoryVtbl TestClassFactoryOOP_Vtbl

static

Initial value:

=
{
    TestOOP_IClassFactory_QueryInterface,
    TestOOP_IClassFactory_AddRef,
    TestOOP_IClassFactory_Release,
    TestOOP_IClassFactory_CreateInstance,
    TestOOP_IClassFactory_LockServer
}

Definition at line 3818 of file marshal.c.

◆ TestCrash_Unknown

IUnknown TestCrash_Unknown = { &TestCrashUnknown_Vtbl }

static

Definition at line 283 of file marshal.c.

Referenced by crash_couninitialize_proc().

◆ TestCrashUnknown_Vtbl

const IUnknownVtbl TestCrashUnknown_Vtbl

static

Initial value:

=
{
    Test_IUnknown_QueryInterface,
    Test_IUnknown_AddRef,
    TestCrash_IUnknown_Release,
}

Definition at line 276 of file marshal.c.

◆ TestMsg_ClassFactory

IClassFactory TestMsg_ClassFactory = { &TestMsgClassFactory_Vtbl }

static

Definition at line 3154 of file marshal.c.

Referenced by test_call_from_message().

◆ TestMsgClassFactory_Vtbl

IClassFactoryVtbl TestMsgClassFactory_Vtbl

static

Initial value:

=
{
    Test_IClassFactory_QueryInterface,
    Test_IClassFactory_AddRef,
    Test_IClassFactory_Release,
    TestMsg_IClassFactory_CreateInstance,
    Test_IClassFactory_LockServer
}

Definition at line 3145 of file marshal.c.

◆ TestOOP_ClassFactory

IClassFactory TestOOP_ClassFactory = { &TestClassFactoryOOP_Vtbl }

static

Definition at line 3827 of file marshal.c.

Referenced by test_local_server(), and test_register_local_server().

◆ TestRE_ClassFactory

IClassFactory TestRE_ClassFactory = { &TestREClassFactory_Vtbl }

static

Definition at line 2986 of file marshal.c.

Referenced by window_proc().

◆ TestREClassFactory_Vtbl

const IClassFactoryVtbl TestREClassFactory_Vtbl

static

Initial value:

=
{
    Test_IClassFactory_QueryInterface,
    Test_IClassFactory_AddRef,
    Test_IClassFactory_Release,
    TestRE_IClassFactory_CreateInstance,
    Test_IClassFactory_LockServer
}

Definition at line 2977 of file marshal.c.

◆ TestUnknown_Vtbl

const IUnknownVtbl TestUnknown_Vtbl

static

Initial value:

=
{
    Test_IUnknown_QueryInterface,
    Test_IUnknown_AddRef,
    Test_IUnknown_Release,
}

Definition at line 257 of file marshal.c.

◆ ullZero

const LARGE_INTEGER ullZero

static

Definition at line 167 of file marshal.c.

Referenced by crash_couninitialize_proc(), implicit_mta_unmarshal_proc(), test_bad_marshal_stream(), test_call_from_message(), test_channel_hook(), test_client_security(), test_CoGetStandardMarshal(), test_DfMarshal_custom_marshaling(), test_disconnect_stub(), test_handler_marshaling(), test_hresult_marshaling(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), test_lock_object_external(), test_marshal_and_unmarshal_invalid(), test_marshal_channel_buffer(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_marshal_stub_apartment_shutdown(), test_message_filter(), test_mta_creation_thread_change_apartment(), test_no_couninitialize_client(), test_no_couninitialize_server(), test_normal_marshal_and_release(), test_normal_marshal_and_unmarshal(), test_normal_marshal_and_unmarshal_twice(), test_proxy_interfaces(), test_proxy_marshal_and_unmarshal(), test_proxy_marshal_and_unmarshal2(), test_proxy_marshal_and_unmarshal_strong(), test_proxy_marshal_and_unmarshal_weak(), test_proxy_used_in_wrong_thread(), test_StdMarshal_custom_marshaling(), test_tablestrong_marshal_and_unmarshal_twice(), test_tableweak_and_normal_marshal_and_releasedata(), test_tableweak_and_normal_marshal_and_unmarshal(), test_tableweak_marshal_and_unmarshal_twice(), test_tableweak_marshal_releasedata1(), test_tableweak_marshal_releasedata2(), test_two_tableweak_marshal_and_releasedata(), and window_proc().

◆ unmarshal_class

const CLSID* unmarshal_class

static

Definition at line 1447 of file marshal.c.

Referenced by CustomMarshal_GetUnmarshalClass(), CustomMarshal_MarshalInterface(), test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

◆ with_external_conn

BOOL with_external_conn

static

Definition at line 180 of file marshal.c.

Referenced by START_TEST(), Test_IClassFactory_QueryInterface(), test_tableweak_and_normal_marshal_and_releasedata(), test_tableweak_and_normal_marshal_and_unmarshal(), and test_tableweak_marshal_and_unmarshal_twice().

Classes

Macros

Typedefs

Functions

Variables

Macro Definition Documentation

◆ _WIN32_DCOM

◆ CHECK_CALLED

◆ CHECK_EXPECT

◆ CHECK_EXPECT2

◆ CLSID_WineTest

◆ COBJMACROS

◆ CONST_VTABLE

◆ DEFINE_EXPECT

◆ EXTENTID_WineTest

◆ NORMALEXTREFS

◆ OBJREF_CUSTOM

◆ OBJREF_SIGNATURE

◆ OBJREF_STANDARD

◆ ok_last_release_closes

◆ ok_more_than_one_lock

◆ ok_no_locks

◆ ok_non_zero_external_conn

◆ ok_ole_success

◆ ok_zero_external_conn

◆ RELEASEMARSHALDATA

◆ SET_EXPECT

Typedef Documentation

◆ DUALSTRINGARRAY

◆ IPID

◆ OBJREF

◆ OID

◆ OXID

◆ STDOBJREF

Function Documentation

◆ bad_thread_proc()

◆ crash_couninitialize_proc()

◆ create_target_process()

◆ CustomMarshal_AddRef()

◆ CustomMarshal_DisconnectObject()

◆ CustomMarshal_GetMarshalSizeMax()

◆ CustomMarshal_GetUnmarshalClass()

◆ CustomMarshal_MarshalInterface()

◆ CustomMarshal_QueryInterface()

◆ CustomMarshal_Release()

◆ CustomMarshal_ReleaseMarshalData()

◆ CustomMarshal_UnmarshalInterface()

◆ DEFINE_EXPECT() [1/10]

◆ DEFINE_EXPECT() [2/10]

◆ DEFINE_EXPECT() [3/10]

◆ DEFINE_EXPECT() [4/10]

◆ DEFINE_EXPECT() [5/10]

◆ DEFINE_EXPECT() [6/10]

◆ DEFINE_EXPECT() [7/10]

◆ DEFINE_EXPECT() [8/10]

◆ DEFINE_EXPECT() [9/10]

◆ DEFINE_EXPECT() [10/10]

◆ duo_marshal_thread_proc()

◆ end_host_object()

◆ ExternalConnection_AddConnection()

◆ ExternalConnection_AddRef()

◆ ExternalConnection_QueryInterface()

◆ ExternalConnection_Release()

◆ ExternalConnection_ReleaseConnection()

◆ get_global_interface_proc()

◆ HeapUnknown_AddRef()

◆ HeapUnknown_QueryInterface()

◆ HeapUnknown_Release()

◆ host_object_proc()

◆ HRESULT()

◆ impl_from_IRpcProxyBuffer()

◆ impl_from_IRpcStubBuffer()

◆ impl_from_IUnknown()

◆ implicit_mta_marshal_proc()

◆ implicit_mta_unmarshal_proc()

◆ implicit_mta_use_proc()

◆ local_server_AddRef()

◆ local_server_GetClassID()

◆ local_server_QueryInterface()

◆ local_server_Release()