marshal.c File Reference

#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 "wine/heap.h"

Include dependency graph for marshal.c:

Go to the source code of this file.

Classes
struct	tagDUALSTRINGARRAY
struct	tagSTDOBJREF
struct	tagOBJREF
struct	StubBufferWrapper
struct	host_object_data
struct	ncu_params
struct	duo_marshal_data
struct	HeapUnknown
struct	local_server
struct	git_params
struct	implicit_mta_marshal_data
struct	new_hook_info

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 %d\n", cLocks)
#define	ok_no_locks()   ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
#define	ok_ole_success(hr, func)   ok(hr == S_OK, #func " failed with error 0x%08x\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 %d 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 *pCoInitializeEx)(LPVOID lpReserved
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 (CreateStub)
	DEFINE_EXPECT (CreateProxy)
	DEFINE_EXPECT (GetWindow)
	DEFINE_EXPECT (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 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 const char *	debugstr_iid (REFIID riid)
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)
	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 DWORD	dwCoInit
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 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 BOOL	new_hook_struct
static int	method
static int	server_tid
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 56 of file marshal.c.

CHECK_EXPECT

#define CHECK_EXPECT

(

func

)

Value:

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

Definition at line 50 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 44 of file marshal.c.

CLSID_WineTest

#define CLSID_WineTest   IID_IWineTest

Definition at line 139 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 38 of file marshal.c.

EXTENTID_WineTest

#define EXTENTID_WineTest   IID_IWineTest

Definition at line 138 of file marshal.c.

NORMALEXTREFS

#define NORMALEXTREFS   5

Definition at line 900 of file marshal.c.

OBJREF_CUSTOM

#define OBJREF_CUSTOM   (0x4)

Definition at line 79 of file marshal.c.

OBJREF_SIGNATURE

#define OBJREF_SIGNATURE   (0x574f454d)

Definition at line 77 of file marshal.c.

OBJREF_STANDARD

#define OBJREF_STANDARD   (0x1)

Definition at line 78 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 75 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 %d\n", cLocks)

Definition at line 70 of file marshal.c.

ok_no_locks

#define ok_no_locks

(

)

ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)

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

ok_ole_success

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

Definition at line 72 of file marshal.c.

ok_zero_external_conn

#define ok_zero_external_conn

(

)

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

Definition at line 74 of file marshal.c.

RELEASEMARSHALDATA

#define RELEASEMARSHALDATA   WM_USER

Definition at line 600 of file marshal.c.

SET_EXPECT

#define SET_EXPECT

(

func

)

expect_ ## func = TRUE

Definition at line 41 of file marshal.c.

Typedef Documentation

DUALSTRINGARRAY

typedef struct tagDUALSTRINGARRAY DUALSTRINGARRAY

IPID

typedef GUID IPID

Definition at line 89 of file marshal.c.

OBJREF

typedef struct tagOBJREF OBJREF

OID

typedef UINT64 OID

Definition at line 88 of file marshal.c.

OXID

typedef UINT64 OXID

Definition at line 87 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 2482 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,
       "COM should have failed with CO_E_NOTINITIALIZED on using proxy without apartment, but instead returned 0x%08x\n",
       hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IMultiQI, (LPVOID *)&proxy);
    /* Win9x returns S_OK, whilst NT returns RPC_E_WRONG_THREAD */
    trace("call to proxy's QueryInterface for local interface without apartment returned 0x%08x\n", hr);
    if (SUCCEEDED(hr))
        IUnknown_Release(proxy);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
    /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
    trace("call to proxy's QueryInterface without apartment returned 0x%08x\n", hr);
    if (SUCCEEDED(hr))
        IUnknown_Release(proxy);
 
    pCoInitializeEx(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%08x\n",
        hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
    /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
    trace("call to proxy's QueryInterface from wrong apartment returned 0x%08x\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 1792 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 3804 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: %u\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 1384 of file marshal.c.

{
    return 2;
}

CustomMarshal_DisconnectObject()

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

static

Definition at line 1453 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 1402 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 1394 of file marshal.c.

{
    CHECK_EXPECT(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 1412 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(U(stat.cbSize).LowPart == 0, "stream is not empty (%d)\n", U(stat.cbSize).LowPart);
    ok(U(stat.cbSize).HighPart == 0, "stream is not empty (%d)\n", U(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 1370 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 1389 of file marshal.c.

{
    return 1;
}

CustomMarshal_ReleaseMarshalData()

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

static

Definition at line 1447 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 1440 of file marshal.c.

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

debugstr_iid()

static const char * debugstr_iid ( REFIID  riid )

static

Definition at line 4282 of file marshal.c.

{
    static char name[256];
    HKEY hkeyInterface;
    WCHAR bufferW[39];
    char buffer[39];
    LONG name_size = sizeof(name);
    StringFromGUID2(riid, bufferW, ARRAY_SIZE(bufferW));
    WideCharToMultiByte(CP_ACP, 0, bufferW, ARRAY_SIZE(bufferW), buffer, sizeof(buffer), NULL, NULL);
    if (RegOpenKeyExA(HKEY_CLASSES_ROOT, "Interface", 0, KEY_QUERY_VALUE, &hkeyInterface) != ERROR_SUCCESS)
    {
        memcpy(name, buffer, sizeof(buffer));
        goto done;
    }
    if (RegQueryValueA(hkeyInterface, buffer, name, &name_size) != ERROR_SUCCESS)
    {
        memcpy(name, buffer, sizeof(buffer));
        goto done;
    }
    RegCloseKey(hkeyInterface);
done:
    return name;
}

Referenced by TestChannelHook_ClientGetSize(), and TestChannelHook_ServerGetSize().

DEFINE_EXPECT() [1/8]

DEFINE_EXPECT

(

CreateProxy

)

DEFINE_EXPECT() [2/8]

DEFINE_EXPECT

(

CreateStub

)

DEFINE_EXPECT() [3/8]

DEFINE_EXPECT

(

CustomMarshal_GetMarshalSizeMax

)

DEFINE_EXPECT() [4/8]

DEFINE_EXPECT

(

CustomMarshal_GetUnmarshalClass

)

DEFINE_EXPECT() [5/8]

DEFINE_EXPECT

(

CustomMarshal_MarshalInterface

)

DEFINE_EXPECT() [6/8]

DEFINE_EXPECT

(

Disconnect

)

DEFINE_EXPECT() [7/8]

DEFINE_EXPECT

(

GetWindow

)

DEFINE_EXPECT() [8/8]

DEFINE_EXPECT

(

Invoke

)

duo_marshal_thread_proc()

static DWORD CALLBACK duo_marshal_thread_proc ( void *  p )

static

Definition at line 2014 of file marshal.c.

{
    HRESULT hr;
    struct duo_marshal_data *data = p;
    HANDLE hQuitEvent = data->hQuitEvent;
    MSG msg;
 
    pCoInitializeEx(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 700 of file marshal.c.

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

Referenced by test_call_from_message(), test_channel_hook(), test_client_security(), test_handler_marshaling(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), 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_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().

ExternalConnection_AddConnection()

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

static

Definition at line 202 of file marshal.c.

{
    trace("add connection\n");
    return ++external_connections;
}

ExternalConnection_AddRef()

static ULONG WINAPI ExternalConnection_AddRef ( IExternalConnection *  iface )

static

Definition at line 192 of file marshal.c.

{
    return 2;
}

ExternalConnection_QueryInterface()

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

static

Definition at line 185 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 197 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 209 of file marshal.c.

{
    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 3940 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 ||
        broken(hr == E_UNEXPECTED) /* win2k */ ||
        broken(hr == S_OK) /* NT 4 */,
        "IGlobalInterfaceTable_GetInterfaceFromGlobal should have failed with error CO_E_NOTINITIALIZED or E_UNEXPECTED instead of 0x%08x\n",
        hr);
    if (hr == S_OK)
        IClassFactory_Release(cf);
 
    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 2801 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 2789 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 2807 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 618 of file marshal.c.

{
    struct host_object_data *data = p;
    DWORD registration_key;
    HRESULT hr;
    MSG msg;
 
    pCoInitializeEx(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: %08x\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);
    }
 
    HeapFree(GetProcessHeap(), 0, data);
 
    CoUninitialize();
 
    return hr;
}

Referenced by start_host_object2().

HRESULT()

static HRESULT ( WINAPI *  pCoInitializeEx )

static

impl_from_IRpcStubBuffer()

static StubBufferWrapper * impl_from_IRpcStubBuffer ( IRpcStubBuffer *  iface )

static

Definition at line 434 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 2784 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 4182 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 4119 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 %#x\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 4154 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 %#x\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 3648 of file marshal.c.

{
    return 2;
}

local_server_GetClassID()

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

static

Definition at line 3658 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 %08x\n", hr);
 
    /* Initialize and uninitialize the apartment to show that we
     * remain in the autojoined mta */
    hr = pCoInitializeEx( NULL, COINIT_MULTITHREADED );
    ok( hr == S_FALSE, "got %08x\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 3632 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 3653 of file marshal.c.

{
    return 1;
}

LockModule()

static void LockModule ( void  )

static

Definition at line 171 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 3612 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 2584 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 2594 of file marshal.c.

{
    static int callcount = 0;
    DWORD ret;
    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 2630 of file marshal.c.

{
    trace("MessagePending\n");
    return PENDINGMSG_WAITNOPROCESS;
}

MessageFilter_QueryInterface()

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

static

Definition at line 2569 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 2589 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 2620 of file marshal.c.

{
    trace("RetryRejectedCall\n");
    return 0;
}

no_couninitialize_client_proc()

static DWORD CALLBACK no_couninitialize_client_proc ( LPVOID  p )

static

Definition at line 1733 of file marshal.c.

{
    struct ncu_params *ncu_params = p;
    HRESULT hr;
    IUnknown *pProxy = NULL;
 
    pCoInitializeEx(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 1660 of file marshal.c.

{
    struct ncu_params *ncu_params = p;
    HRESULT hr;
 
    pCoInitializeEx(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 409 of file marshal.c.

{
    return 2;
}

OleClientSite_QueryInterface()

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

static

Definition at line 393 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 414 of file marshal.c.

{
    return 1;
}

OleWindow_AddRef()

static ULONG WINAPI OleWindow_AddRef ( IOleWindow *  iface )

static

Definition at line 366 of file marshal.c.

{
    return 2;
}

OleWindow_GetWindow()

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

static

Definition at line 376 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 359 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 371 of file marshal.c.

{
    return 1;
}

PSFactoryBuffer_AddRef()

static ULONG WINAPI PSFactoryBuffer_AddRef ( IPSFactoryBuffer *  iface )

static

Definition at line 551 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 561 of file marshal.c.

{
    CHECK_EXPECT(CreateProxy);
    return IPSFactoryBuffer_CreateProxy(ps_factory_buffer, outer, riid, ppProxy, ppv);
}

PSFactoryBuffer_CreateStub()

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

static

Definition at line 568 of file marshal.c.

{
    StubBufferWrapper *stub;
    HRESULT hr;
 
    CHECK_EXPECT(CreateStub);
 
    ok(server == (IUnknown*)&Test_OleClientSite, "unexpected server %p\n", server);
 
    stub = heap_alloc(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: %08x\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 538 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 556 of file marshal.c.

{
    return 1;
}

reg_unreg_wine_test_class()

static HRESULT reg_unreg_wine_test_class ( BOOL  Register )

static

Definition at line 3355 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 %d\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 %d\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 3039 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 692 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 3150 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().

RpcStubBuffer_AddRef()

static ULONG WINAPI RpcStubBuffer_AddRef ( IRpcStubBuffer *  iface )

static

Definition at line 454 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 471 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 506 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 512 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 518 of file marshal.c.

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

RpcStubBuffer_Disconnect()

static void WINAPI RpcStubBuffer_Disconnect ( IRpcStubBuffer *  iface )

static

Definition at line 477 of file marshal.c.

{
    CHECK_EXPECT(Disconnect);
}

RpcStubBuffer_Invoke()

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

static

Definition at line 482 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: %08x\n", hr);
    ok(dest_context == MSHCTX_INPROC, "desc_context = %x\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 500 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 439 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 460 of file marshal.c.

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

start_host_object()

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

static

Definition at line 684 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 667 of file marshal.c.

{
    DWORD tid = 0;
    struct host_object_data *data;
 
    data = HeapAlloc(GetProcessHeap(), 0, 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 4603 of file marshal.c.

{
    HMODULE hOle32 = GetModuleHandleA("ole32");
    int argc;
    char **argv;
 
    if (!GetProcAddress(hOle32, "CoRegisterSurrogateEx")) {
        win_skip("skipping test on win9x\n");
        return;
    }
 
    pCoInitializeEx = (void*)GetProcAddress(hOle32, "CoInitializeEx");
    pDllGetClassObject = (void*)GetProcAddress(hOle32, "DllGetClassObject");
 
    argc = winetest_get_mainargs( &argv );
    if (argc > 2 && (!strcmp(argv[2], "-Embedding")))
    {
        pCoInitializeEx(NULL, COINIT_MULTITHREADED);
        test_register_local_server();
        CoUninitialize();
 
        return;
    }
 
    register_test_window();
 
    test_cocreateinstance_proxy();
    test_implicit_mta();
 
    pCoInitializeEx(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 2703 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%08x 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 3089 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 4553 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);
    server_tid = tid;
 
    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 3522 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");
 
    hr = IClassFactory_QueryInterface(pProxy, &IID_IRemUnknown, (LPVOID*)&pProxy2);
    ok_ole_success(hr, "IUnknown_QueryInterface IID_IStream");
 
    hr = IUnknown_QueryInterface(pProxy2, &IID_IUnknown, (LPVOID*)&pUnknown2);
    ok_ole_success(hr, "IUnknown_QueryInterface IID_IUnknown");
 
    ok(pUnknown1 == pUnknown2, "both proxy's IUnknowns should be the same - %p, %p\n", pUnknown1, pUnknown2);
 
    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%08x\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%08x\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%08x\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%08x\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(pProxy2);
    IUnknown_Release(pUnknown1);
    IUnknown_Release(pUnknown2);
    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 149 of file marshal.c.

{
    IUnknown *pProxy;
    IMultiQI *pMQI;
    HRESULT hr;
 
    pCoInitializeEx(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 1575 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 = %d, expected %d\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 = %d, expected %d\n", read, size);
    ok(objref.signature == OBJREF_SIGNATURE, "objref.signature = %x\n",
            objref.signature);
    ok(objref.flags == OBJREF_STANDARD, "objref.flags = %x\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 = %d\n", stdobjref->flags);
    ok(stdobjref->cPublicRefs == 5, "stdobjref.cPublicRefs = %d\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 1830 of file marshal.c.

{
    HANDLE thread;
    DWORD tid;
 
    if(!GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateActCtxW")) {
        win_skip("Skipping crash tests on win2k.\n");
        return;
    }
 
    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 1526 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 = %d, expected %d\n", read, size);
    ok(objref.signature == OBJREF_SIGNATURE, "objref.signature = %x\n",
            objref.signature);
    ok(objref.flags == OBJREF_CUSTOM, "objref.flags = %x\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 = %d\n",
            objref.u_objref.u_custom.cbExtension);
    ok(!objref.u_objref.u_custom.size, "custom.size = %d\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 = %d, expected %d\n", size, (int)sizeof(OBJREF));
}

Referenced by START_TEST().

test_disconnect_stub()

static void test_disconnect_stub ( void  )

static

Definition at line 2372 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 %x\n", hr );
}

Referenced by START_TEST().

test_freethreadedmarshaldata()

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

static

Definition at line 3163 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 ||
           broken(size == (2*sizeof(DWORD))) /* Win9x & NT4 */,
           "size should have been %d instead of %d\n", expected_size, size);
 
        ok(*(DWORD *)marshal_data == mshlflags, "expected 0x%x, but got 0x%x 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%x\n", *(DWORD *)marshal_data);
            marshal_data += sizeof(DWORD);
        }
        if (size >= 3*sizeof(DWORD) + sizeof(GUID))
        {
            trace("got guid data: %s\n", wine_dbgstr_guid((GUID *)marshal_data));
        }
    }
    else
    {
        ok(size > sizeof(DWORD), "size should have been > sizeof(DWORD), not %d\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 3208 of file marshal.c.

{
    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 */
 
    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(IsEqualIID(&clsid, &CLSID_StdMarshal), "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 3967 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;
 
        trace("test_globalinterfacetable\n");
    cLocks = 0;
 
    hr = pDllGetClassObject(&CLSID_StdGlobalInterfaceTable, &IID_IClassFactory, (void**)&cf);
    ok(hr == S_OK, "got 0x%08x\n", hr);
 
    hr = IClassFactory_QueryInterface(cf, &IID_IGlobalInterfaceTable, (void**)&object);
    ok(hr == E_NOINTERFACE, "got 0x%08x\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=%d\n", ref);
    ref = IGlobalInterfaceTable_AddRef(git);
    ok(ref == 1, "ref=%d\n", ref);
 
    ref = IGlobalInterfaceTable_Release(git);
    ok(ref == 1, "ref=%d\n", ref);
    ref = IGlobalInterfaceTable_Release(git);
    ok(ref == 1, "ref=%d\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);
}

Referenced by START_TEST().

test_handler_marshaling()

static void test_handler_marshaling ( void  )

static

Definition at line 3472 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%08x\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 2451 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%08x 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%08x 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 313 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 325 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 335 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 286 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 319 of file marshal.c.

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

test_implicit_mta()

static void test_implicit_mta ( void  )

static

Definition at line 4197 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 3394 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%08x 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 863 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 246 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 228 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 252 of file marshal.c.

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

test_local_server()

static void test_local_server ( void  )

static

Definition at line 3824 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);
    ok(hr == REGDB_E_CLASSNOTREG || /* NT */
       hr == S_OK /* Win9x */,
        "CoGetClassObject should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\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);
    ok(hr == CO_E_SERVER_STOPPING || /* NT */
       hr == REGDB_E_CLASSNOTREG || /* win2k */
       hr == S_OK /* Win9x */,
        "CoGetClassObject should have returned CO_E_SERVER_STOPPING or REGDB_E_CLASSNOTREG instead of 0x%08x\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 %d\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);
 
    winetest_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 2274 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_ze