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_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    /* test CoLockObjectExternal doesn't release the last reference to an
     * object with fLastUnlockReleases as TRUE and there is a weak reference
     * on the object */
    hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
    ok_ole_success(hr, CoMarshalInterface);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, FALSE);
 
    ok_more_than_one_lock();
    ok_non_zero_external_conn();
 
    CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, FALSE);
 
    ok_more_than_one_lock();
    ok_zero_external_conn();
    ok_last_release_closes(FALSE);
 
    CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
 
    ok_no_locks();
 
    IStream_Release(pStream);
}

Referenced by START_TEST().

test_manualresetevent()

static void test_manualresetevent ( void  )

static

Definition at line 4044 of file marshal.c.

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

Referenced by START_TEST().

test_marshal_and_unmarshal_invalid()

static void test_marshal_and_unmarshal_invalid ( void  )

static

Definition at line 784 of file marshal.c.

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

Referenced by START_TEST().

test_marshal_channel_buffer()

static void test_marshal_channel_buffer ( void  )

static

Definition at line 1296 of file marshal.c.

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

Referenced by START_TEST().

test_marshal_proxy_apartment_shutdown()

static void test_marshal_proxy_apartment_shutdown ( void  )

static

Definition at line 1204 of file marshal.c.

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

Referenced by START_TEST().

test_marshal_proxy_mta_apartment_shutdown()

static void test_marshal_proxy_mta_apartment_shutdown ( void  )

static

Definition at line 1252 of file marshal.c.

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

Referenced by START_TEST().

test_marshal_stub_apartment_shutdown()

static void test_marshal_stub_apartment_shutdown ( void  )

static

Definition at line 1164 of file marshal.c.

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

Referenced by START_TEST().

test_message_filter()

static void test_message_filter ( void  )

static

Definition at line 2652 of file marshal.c.

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

Referenced by START_TEST().

test_message_reentrancy()

static void test_message_reentrancy ( void  )

static

Definition at line 3049 of file marshal.c.

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

Referenced by START_TEST().

test_no_couninitialize_client()

static void test_no_couninitialize_client ( void  )

static

Definition at line 1753 of file marshal.c.

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

Referenced by START_TEST().

test_no_couninitialize_server()

static void test_no_couninitialize_server ( void  )

static

Definition at line 1681 of file marshal.c.

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

Referenced by START_TEST().

test_no_marshaler()

static void test_no_marshaler ( void  )

static

Definition at line 711 of file marshal.c.

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

Referenced by START_TEST().

test_normal_marshal_and_release()

static void test_normal_marshal_and_release ( void  )

static

Definition at line 725 of file marshal.c.

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

Referenced by START_TEST().

test_normal_marshal_and_unmarshal()

static void test_normal_marshal_and_unmarshal ( void  )

static

Definition at line 752 of file marshal.c.

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

Referenced by START_TEST().

test_normal_marshal_and_unmarshal_twice()

static void test_normal_marshal_and_unmarshal_twice ( void  )

static

Definition at line 2410 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_interfaces()

static void test_proxy_interfaces ( void  )

static

Definition at line 2728 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_marshal_and_unmarshal()

static void test_proxy_marshal_and_unmarshal ( void  )

static

Definition at line 903 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_marshal_and_unmarshal2()

static void test_proxy_marshal_and_unmarshal2 ( void  )

static

Definition at line 978 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_marshal_and_unmarshal_strong()

static void test_proxy_marshal_and_unmarshal_strong ( void  )

static

Definition at line 1095 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_marshal_and_unmarshal_weak()

static void test_proxy_marshal_and_unmarshal_weak ( void  )

static

Definition at line 1042 of file marshal.c.

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

Referenced by START_TEST().

test_proxy_used_in_wrong_thread()

static void test_proxy_used_in_wrong_thread ( void  )

static

Definition at line 2527 of file marshal.c.

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

Referenced by START_TEST().

test_proxybuffer()

static void test_proxybuffer ( REFIID  riid )

static

Definition at line 2822 of file marshal.c.

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

Referenced by START_TEST().

test_register_local_server()

static void test_register_local_server ( void  )

static

Definition at line 3754 of file marshal.c.

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

Referenced by START_TEST().

test_same_apartment_unmarshal_failure()

static void test_same_apartment_unmarshal_failure ( void  )

static

Definition at line 830 of file marshal.c.

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

Referenced by START_TEST().

Test_SMI_AddRef()

static ULONG WINAPI Test_SMI_AddRef ( IStdMarshalInfo *  iface )

static

Definition at line 3440 of file marshal.c.

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

Test_SMI_GetClassForHandler()

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

static

Definition at line 3452 of file marshal.c.

{
    *pClsid = CLSID_WineTest;
    return S_OK;
}

Test_SMI_QueryInterface()

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

static

Definition at line 3422 of file marshal.c.

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

Test_SMI_Release()

static ULONG WINAPI Test_SMI_Release ( IStdMarshalInfo *  iface )

static

Definition at line 3446 of file marshal.c.

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

test_StdMarshal_custom_marshaling()

static void test_StdMarshal_custom_marshaling ( void  )

static

Definition at line 1474 of file marshal.c.

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

Referenced by START_TEST().

test_stubbuffer()

static void test_stubbuffer ( REFIID  riid )

static

Definition at line 2860 of file marshal.c.

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

Referenced by START_TEST().

test_tablestrong_marshal_and_unmarshal_twice()

static void test_tablestrong_marshal_and_unmarshal_twice ( void  )

static

Definition at line 2221 of file marshal.c.

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

Referenced by START_TEST().

test_tableweak_and_normal_marshal_and_releasedata()

static void test_tableweak_and_normal_marshal_and_releasedata ( void  )

static

Definition at line 2125 of file marshal.c.

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

Referenced by START_TEST().

test_tableweak_and_normal_marshal_and_unmarshal()

static void test_tableweak_and_normal_marshal_and_unmarshal ( void  )

static

Definition at line 2055 of file marshal.c.

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

Referenced by START_TEST().

test_tableweak_marshal_and_unmarshal_twice()

static void test_tableweak_marshal_and_unmarshal_twice ( void  )

static

Definition at line 1848 of file marshal.c.

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

Referenced by START_TEST().

test_tableweak_marshal_releasedata1()

static void test_tableweak_marshal_releasedata1 ( void  )

static

Definition at line 1904 of file marshal.c.

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

Referenced by START_TEST().

test_tableweak_marshal_releasedata2()

static void test_tableweak_marshal_releasedata2 ( void  )

static

Definition at line 1965 of file marshal.c.

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

Referenced by START_TEST().

test_two_tableweak_marshal_and_releasedata()

static void test_two_tableweak_marshal_and_releasedata ( void  )

static

Definition at line 2175 of file marshal.c.

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

Referenced by START_TEST().

test_WM_QUIT_handling()

static void test_WM_QUIT_handling ( void  )

static

Definition at line 3133 of file marshal.c.

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

Referenced by START_TEST().

TestChannelHook_AddRef()

static ULONG WINAPI TestChannelHook_AddRef ( IChannelHook *  iface )

static

Definition at line 4319 of file marshal.c.

{
    return 2;
}

TestChannelHook_ClientFillBuffer()

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

static

Definition at line 4384 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
    trace("TestChannelHook_ClientFillBuffer\n");
 
    if (!new_hook_struct)
    {
        ok(info->cbSize == sizeof(*info), "cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %d should be %d\n", info->iMethod, method);
        ok(!info->pObject, "pObject should be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
    else
    {
        struct new_hook_info *new_info = (struct new_hook_info *)riid;
        ok(new_info->server_pid == GetCurrentProcessId(), "server pid was 0x%x instead of 0x%x\n", new_info->server_pid,
           GetCurrentProcessId());
        ok(new_info->server_tid == server_tid, "server tid was 0x%x instead of 0x%x\n", new_info->server_tid,
           server_tid);
        ok(new_info->method == method, "method was %d instead of %d\n", new_info->method, method);
        ok(IsEqualGUID(&new_info->causality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
 
    *(unsigned char *)pDataBuffer = 0xcc;
    *pDataSize = 1;
}

TestChannelHook_ClientGetSize()

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

static

Definition at line 4342 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
    trace("TestChannelHook_ClientGetSize\n");
    trace("\t%s\n", debugstr_iid(riid));
    if (info->cbSize != sizeof(*info))
        new_hook_struct = TRUE;
 
    if (!new_hook_struct)
    {
        ok(info->cbSize == sizeof(*info), "cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %d should be %d\n", info->iMethod, method);
        ok(!info->pObject, "pObject should be NULL\n");
        if (method == 3)
            causality = info->uCausality;
        else
            ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
    else
    {
        struct new_hook_info *new_info = (struct new_hook_info *)riid;
        ok(new_info->server_pid == GetCurrentProcessId(), "server pid was 0x%x instead of 0x%x\n", new_info->server_pid,
           GetCurrentProcessId());
        ok(new_info->server_tid == server_tid, "server tid was 0x%x instead of 0x%x\n", new_info->server_tid,
           server_tid);
        ok(new_info->method == method, "method was %d instead of %d\n", new_info->method, method);
        if (method == 3)
            causality = new_info->causality;
        else
            ok(IsEqualGUID(&new_info->causality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
 
    *pDataSize = 1;
}

TestChannelHook_ClientNotify()

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

static

Definition at line 4419 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
    trace("TestChannelHook_ClientNotify hrFault = 0x%08x\n", hrFault);
 
    if (!new_hook_struct)
    {
        ok(info->cbSize == sizeof(*info), "cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %d should be %d\n", info->iMethod, method);
        todo_wine {
            ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        }
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
    else
    {
        struct new_hook_info *new_info = (struct new_hook_info *)riid;
        ok(new_info->server_pid == GetCurrentProcessId(), "server pid was 0x%x instead of 0x%x\n", new_info->server_pid,
           GetCurrentProcessId());
        ok(new_info->server_tid == server_tid, "server tid was 0x%x instead of 0x%x\n", new_info->server_tid,
           server_tid);
        ok(new_info->method == method, "method was %d instead of %d\n", new_info->method, method);
        ok(IsEqualGUID(&new_info->causality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
}

TestChannelHook_QueryInterface()

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

static

Definition at line 4306 of file marshal.c.

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

TestChannelHook_Release()

static ULONG WINAPI TestChannelHook_Release ( IChannelHook *  iface )

static

Definition at line 4324 of file marshal.c.

{
    return 1;
}

TestChannelHook_ServerFillBuffer()

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

static

Definition at line 4526 of file marshal.c.

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

TestChannelHook_ServerGetSize()

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

static

Definition at line 4490 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
    trace("TestChannelHook_ServerGetSize\n");
    trace("\t%s\n", debugstr_iid(riid));
    if (!new_hook_struct)
    {
        ok(info->cbSize == sizeof(*info), "cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %d should be %d\n", info->iMethod, method);
        ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
    else
    {
        struct new_hook_info *new_info = (struct new_hook_info *)riid;
        ok(new_info->server_pid == GetCurrentProcessId(), "server pid was 0x%x instead of 0x%x\n", new_info->server_pid,
           GetCurrentProcessId());
        ok(new_info->server_tid == server_tid, "server tid was 0x%x instead of 0x%x\n", new_info->server_tid,
           server_tid);
        ok(new_info->method == method, "method was %d instead of %d\n", new_info->method, method);
        ok(IsEqualGUID(&new_info->causality, &causality), "causality wasn't correct\n");
    }
 
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
    if (hrFault != S_OK)
        trace("\thrFault = 0x%08x\n", hrFault);
 
    *pDataSize = 0;
}

TestChannelHook_ServerNotify()

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

static

Definition at line 4455 of file marshal.c.

{
    SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
    trace("TestChannelHook_ServerNotify\n");
 
    if (!new_hook_struct)
    {
        ok(info->cbSize == sizeof(*info), "cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
        ok(info->dwServerPid == GetCurrentProcessId(), "dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
        ok(info->iMethod == method, "iMethod was %d should be %d\n", info->iMethod, method);
        ok(info->pObject != NULL, "pObject shouldn't be NULL\n");
        ok(IsEqualGUID(&info->uCausality, &causality), "causality wasn't correct\n");
    }
    else
    {
        struct new_hook_info *new_info = (struct new_hook_info *)riid;
        ok(new_info->server_pid == GetCurrentProcessId(), "server pid was 0x%x instead of 0x%x\n", new_info->server_pid,
           GetCurrentProcessId());
        ok(new_info->server_tid == server_tid, "server tid was 0x%x instead of 0x%x\n", new_info->server_tid,
           server_tid);
        ok(new_info->method == method, "method was %d instead of %d\n", new_info->method, method);
        ok(IsEqualGUID(&new_info->causality, &causality), "causality wasn't correct\n");
    }
 
    ok(cbDataSize == 1, "cbDataSize should have been 1 instead of %d\n", cbDataSize);
    ok(*(unsigned char *)pDataBuffer == 0xcc, "pDataBuffer should have contained 0xcc instead of 0x%x\n", *(unsigned char *)pDataBuffer);
    ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
}

TestCrash_IUnknown_Release()

static ULONG WINAPI TestCrash_IUnknown_Release ( LPUNKNOWN  iface )

static

Definition at line 267 of file marshal.c.

{
    UnlockModule();
    if(!cLocks) {
        trace("crashing...\n");
        *(int**)0xc = 0;
    }
    return 1; /* non-heap-based object */
}

TestMsg_IClassFactory_CreateInstance()

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

static

Definition at line 3067 of file marshal.c.

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

TestOOP_IClassFactory_AddRef()

static ULONG WINAPI TestOOP_IClassFactory_AddRef ( LPCLASSFACTORY  iface )

static

Definition at line 3708 of file marshal.c.

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

TestOOP_IClassFactory_CreateInstance()

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

static

Definition at line 3718 of file marshal.c.

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

TestOOP_IClassFactory_LockServer()

static HRESULT WINAPI TestOOP_IClassFactory_LockServer ( LPCLASSFACTORY  iface, BOOL  fLock  )

static

Definition at line 3732 of file marshal.c.

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

TestOOP_IClassFactory_QueryInterface()

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

static

Definition at line 3690 of file marshal.c.

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

TestOOP_IClassFactory_Release()

static ULONG WINAPI TestOOP_IClassFactory_Release ( LPCLASSFACTORY  iface )

static

Definition at line 3713 of file marshal.c.

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

TestRE_IClassFactory_CreateInstance()

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

static

Definition at line 2894 of file marshal.c.

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

UnlockModule()

static void UnlockModule ( void  )

static

Definition at line 176 of file marshal.c.

{
    InterlockedDecrement(&cLocks);
}

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

UnlockModuleOOP()

static void UnlockModuleOOP ( void  )

static

Definition at line 3618 of file marshal.c.

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

Referenced by TestOOP_IClassFactory_LockServer().

window_proc()

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

static

Definition at line 2921 of file marshal.c.

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

Referenced by register_test_window().

Variable Documentation

causality

GUID causality

static

Definition at line 4331 of file marshal.c.

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

cLocks

LONG cLocks

static

Definition at line 169 of file marshal.c.

Referenced by crash_couninitialize_proc(), LockModule(), LockModuleOOP(), test_channel_hook(), test_client_security(), test_disconnect_stub(), test_freethreadedmarshaler(), test_globalinterfacetable(), test_handler_marshaling(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), test_local_server(), test_lock_object_external(), test_marshal_and_unmarshal_invalid(), test_marshal_channel_buffer(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_marshal_stub_apartment_shutdown(), test_message_filter(), test_no_couninitialize_client(), test_no_couninitialize_server(), test_normal_marshal_and_release(), test_normal_marshal_and_unmarshal(), test_normal_marshal_and_unmarshal_twice(), test_proxy_interfaces(), test_proxy_marshal_and_unmarshal(), test_proxy_marshal_and_unmarshal2(), test_proxy_marshal_and_unmarshal_strong(), test_proxy_marshal_and_unmarshal_weak(), test_proxy_used_in_wrong_thread(), test_same_apartment_unmarshal_failure(), test_stubbuffer(), test_tablestrong_marshal_and_unmarshal_twice(), test_tableweak_and_normal_marshal_and_releasedata(), test_tableweak_and_normal_marshal_and_unmarshal(), test_tableweak_marshal_and_unmarshal_twice(), test_tableweak_marshal_releasedata1(), test_tableweak_marshal_releasedata2(), test_two_tableweak_marshal_and_releasedata(), TestCrash_IUnknown_Release(), UnlockModule(), UnlockModuleOOP(), and window_proc().

CLSID_DfMarshal

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

static

Definition at line 63 of file marshal.c.

Referenced by DllGetClassObject(), and test_DfMarshal_custom_marshaling().

CLSID_WineOOPTest

const CLSID CLSID_WineOOPTest

static

Initial value:

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

Definition at line 141 of file marshal.c.

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

CLSID_WineTestPSFactoryBuffer

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

static

Definition at line 62 of file marshal.c.

Referenced by test_marshal_channel_buffer().

crash_thread_success

BOOL crash_thread_success

static

Definition at line 1790 of file marshal.c.

Referenced by crash_couninitialize_proc(), and test_crash_couninitialize().

CustomMarshal

IMarshal CustomMarshal = { &CustomMarshalVtbl }

static

Definition at line 1472 of file marshal.c.

Referenced by test_DfMarshal_custom_marshaling(), and test_StdMarshal_custom_marshaling().

CustomMarshalVtbl

IMarshalVtbl CustomMarshalVtbl

static

Initial value:

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

Definition at line 1459 of file marshal.c.

dwCoInit

DWORD dwCoInit

Definition at line 66 of file marshal.c.

external_connections

DWORD external_connections

static

Definition at line 182 of file marshal.c.

Referenced by ExternalConnection_AddConnection(), ExternalConnection_ReleaseConnection(), test_disconnect_stub(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), test_lock_object_external(), test_marshal_and_unmarshal_invalid(), test_marshal_channel_buffer(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_marshal_stub_apartment_shutdown(), test_no_couninitialize_client(), test_no_couninitialize_server(), test_normal_marshal_and_release(), test_normal_marshal_and_unmarshal(), test_normal_marshal_and_unmarshal_twice(), test_proxy_marshal_and_unmarshal(), test_proxy_marshal_and_unmarshal2(), test_proxy_marshal_and_unmarshal_strong(), test_proxy_marshal_and_unmarshal_weak(), test_same_apartment_unmarshal_failure(), 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().

ExternalConnection

IExternalConnection ExternalConnection = { &ExternalConnectionVtbl }

static

Definition at line 225 of file marshal.c.

Referenced by Test_IClassFactory_QueryInterface().

ExternalConnectionVtbl

const IExternalConnectionVtbl ExternalConnectionVtbl

static

Initial value:

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

Definition at line 217 of file marshal.c.

HeapUnknown_Vtbl

const IUnknownVtbl HeapUnknown_Vtbl

static

Initial value:

=
{
    HeapUnknown_QueryInterface,
    HeapUnknown_AddRef,
    HeapUnknown_Release
}

Definition at line 2815 of file marshal.c.

Referenced by test_proxybuffer().

heventShutdown

HANDLE heventShutdown

static

Definition at line 3610 of file marshal.c.

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

hwnd_app

static HWND hwnd_app

static

Definition at line 2892 of file marshal.c.

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

IID_IRemUnknown

const IID IID_IRemUnknown

static

Initial value:

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

Definition at line 130 of file marshal.c.

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

IID_IWineTest

const IID IID_IWineTest

static

Initial value:

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

Definition at line 122 of file marshal.c.

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

last_release_closes

BOOL last_release_closes

static

Definition at line 183 of file marshal.c.

Referenced by ExternalConnection_ReleaseConnection().

local_server_class

struct local_server local_server_class

Initial value:

=
{
    {&local_server_persist_vtbl}
}

Definition at line 3685 of file marshal.c.

Referenced by TestOOP_IClassFactory_CreateInstance().

local_server_persist_vtbl

const IPersistVtbl local_server_persist_vtbl

static

Initial value:

=
{
    local_server_QueryInterface,
    local_server_AddRef,
    local_server_Release,
    local_server_GetClassID
}

Definition at line 3677 of file marshal.c.

LPVOID

LPVOID

Definition at line 67 of file marshal.c.

MessageFilter

IMessageFilter MessageFilter = { &MessageFilter_Vtbl }

static

Definition at line 2650 of file marshal.c.

Referenced by test_channel_hook(), and test_message_filter().

MessageFilter_Vtbl

const IMessageFilterVtbl MessageFilter_Vtbl

static

Initial value:

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

Definition at line 2640 of file marshal.c.

method

int method

static

Definition at line 4330 of file marshal.c.

new_hook_struct

BOOL new_hook_struct

static

Definition at line 4329 of file marshal.c.

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

OleClientSiteVtbl

const IOleClientSiteVtbl OleClientSiteVtbl

static

Initial value:

= {
    OleClientSite_QueryInterface,
    OleClientSite_AddRef,
    OleClientSite_Release,
    
}

Definition at line 419 of file marshal.c.

OleWindowVtbl

const IOleWindowVtbl OleWindowVtbl

static

Initial value:

= {
    OleWindow_QueryInterface,
    OleWindow_AddRef,
    OleWindow_Release,
    OleWindow_GetWindow,
    
}

Definition at line 383 of file marshal.c.

ps_factory_buffer

IPSFactoryBuffer* ps_factory_buffer

static

Definition at line 536 of file marshal.c.

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

PSFactoryBuffer

static IPSFactoryBuffer PSFactoryBuffer = { &PSFactoryBufferVtbl }

static

Definition at line 598 of file marshal.c.

Referenced by test_marshal_channel_buffer().

PSFactoryBufferVtbl

IPSFactoryBufferVtbl PSFactoryBufferVtbl

static

Initial value:

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

Definition at line 589 of file marshal.c.

REFIID

REFIID

Definition at line 67 of file marshal.c.

RpcStubBufferVtbl

const IRpcStubBufferVtbl RpcStubBufferVtbl

static

Initial value:

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

Definition at line 523 of file marshal.c.

Referenced by PSFactoryBuffer_CreateStub().

server_tid

int server_tid

static

Definition at line 4330 of file marshal.c.

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

Test_ClassFactory

IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl }

static

Definition at line 351 of file marshal.c.

Referenced by duo_marshal_thread_proc(), implicit_mta_marshal_proc(), no_couninitialize_server_proc(), test_bad_marshal_stream(), test_channel_hook(), test_client_security(), test_disconnect_stub(), test_freethreadedmarshaler(), test_globalinterfacetable(), test_implicit_mta(), test_interthread_marshal_and_unmarshal(), test_lock_object_external(), test_marshal_and_unmarshal_invalid(), test_marshal_proxy_apartment_shutdown(), test_marshal_proxy_mta_apartment_shutdown(), test_marshal_stub_apartment_shutdown(), test_message_filter(), test_no_couninitialize_client(), test_no_marshaler(), test_normal_marshal_and_release(), test_normal_marshal_and_unmarshal(), test_normal_marshal_and_unmarshal_twice(), test_proxy_interfaces(), test_proxy_marshal_and_unmarshal(), test_proxy_marshal_and_unmarshal2(), test_proxy_marshal_and_unmarshal_strong(), test_proxy_marshal_and_unmarshal_weak(), test_proxy_used_in_wrong_thread(), test_same_apartment_unmarshal_failure(), test_stubbuffer(), test_tablestrong_marshal_and_unmarshal_twice(), test_tableweak_marshal_and_unmarshal_twice(), test_tableweak_marshal_releasedata1(), test_tableweak_marshal_releasedata2(), and window_proc().

Test_OleClientSite

IOleClientSite Test_OleClientSite = { &OleClientSiteVtbl }

static

Definition at line 426 of file marshal.c.

Referenced by PSFactoryBuffer_CreateStub(), and test_marshal_channel_buffer().

Test_OleWindow

IOleWindow Test_OleWindow = { &OleWindowVtbl }

static

Definition at line 391 of file marshal.c.

Referenced by OleClientSite_QueryInterface().

Test_SMI

IStdMarshalInfo Test_SMI = {&Test_SMI_Vtbl}

static

Definition at line 3470 of file marshal.c.

Referenced by test_handler_marshaling().

Test_SMI_Vtbl

const IStdMarshalInfoVtbl Test_SMI_Vtbl

static

Initial value:

=
{
    Test_SMI_QueryInterface,
    Test_SMI_AddRef,
    Test_SMI_Release,
    Test_SMI_GetClassForHandler
}

Definition at line 3462 of file marshal.c.

Test_Unknown

IUnknown Test_Unknown = { &TestUnknown_Vtbl }

static

Definition at line 265 of file marshal.c.

Referenced by test_CoGetStandardMarshal(), and Test_IClassFactory_CreateInstance().

TestChannelHook

IChannelHook TestChannelHook = { &TestChannelHookVtbl }

static

Definition at line 4551 of file marshal.c.

Referenced by test_channel_hook().

TestChannelHookVtbl

const IChannelHookVtbl TestChannelHookVtbl

static

Initial value:

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

Definition at line 4538 of file marshal.c.

TestClassFactory_Vtbl

const IClassFactoryVtbl TestClassFactory_Vtbl

static

Initial value:

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

Definition at line 342 of file marshal.c.

TestClassFactoryOOP_Vtbl

const IClassFactoryVtbl TestClassFactoryOOP_Vtbl

static

Initial value:

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

Definition at line 3743 of file marshal.c.

TestCrash_Unknown

IUnknown TestCrash_Unknown = { &TestCrashUnknown_Vtbl }

static

Definition at line 284 of file marshal.c.

Referenced by crash_couninitialize_proc().

TestCrashUnknown_Vtbl

const IUnknownVtbl TestCrashUnknown_Vtbl

static

Initial value:

=
{
    Test_IUnknown_QueryInterface,
    Test_IUnknown_AddRef,
    TestCrash_IUnknown_Release,
}

Definition at line 277 of file marshal.c.

TestMsg_ClassFactory

IClassFactory TestMsg_ClassFactory = { &TestMsgClassFactory_Vtbl }

static

Definition at line 3087 of file marshal.c.

Referenced by test_call_from_message().

TestMsgClassFactory_Vtbl

IClassFactoryVtbl TestMsgClassFactory_Vtbl

static

Initial value:

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

Definition at line 3078 of file marshal.c.

TestOOP_ClassFactory

IClassFactory TestOOP_ClassFactory = { &TestClassFactoryOOP_Vtbl }

static

Definition at line 3752 of file marshal.c.

Referenced by test_local_server(), and test_register_local_server().

TestRE_ClassFactory

IClassFactory TestRE_ClassFactory = { &TestREClassFactory_Vtbl }

static

Definition at line 2919 of file marshal.c.

Referenced by window_proc().

TestREClassFactory_Vtbl

const IClassFactoryVtbl TestREClassFactory_Vtbl

static

Initial value:

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

Definition at line 2910 of file marshal.c.

TestUnknown_Vtbl

const IUnknownVtbl TestUnknown_Vtbl

static

Initial value:

=
{
    Test_IUnknown_QueryInterface,
    Test_IUnknown_AddRef,
    Test_IUnknown_Release,
}

Definition at line 258 of file marshal.c.

ullZero

const LARGE_INTEGER ullZero

static

Definition at line 168 of file marshal.c.

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

unmarshal_class

const CLSID* unmarshal_class

static

Definition at line 1365 of file marshal.c.

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

with_external_conn

BOOL with_external_conn

static

Definition at line 181 of file marshal.c.

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