ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/dlls/ole32/tests/marshal.c

2957 lines
89 KiB
C
Raw Blame History

/*
* Marshaling Tests
*
* Copyright 2004 Robert Shearman
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#define _WIN32_DCOM
#define COBJMACROS
#define CONST_VTABLE
#include <stdarg.h>
#include <stdio.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "shlguid.h"
#include "wine/test.h"
/* functions that are not present on all versions of Windows */
HRESULT (WINAPI * pCoInitializeEx)(LPVOID lpReserved, DWORD dwCoInit);
/* helper macros to make tests a bit leaner */
#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)
static const IID IID_IWineTest =
{
0x5201163f,
0x8164,
0x4fd0,
{0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
}; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
static const IID IID_IRemUnknown =
{
0x00000131,
0x0000,
0x0000,
{0xc0,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
};
#define EXTENTID_WineTest IID_IWineTest
#define CLSID_WineTest IID_IWineTest
static const CLSID CLSID_WineOOPTest =
{
0x5201163f,
0x8164,
0x4fd0,
{0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
}; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
static void test_cocreateinstance_proxy(void)
{
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();
}
static const LARGE_INTEGER ullZero;
static LONG cLocks;
static void LockModule(void)
{
InterlockedIncrement(&cLocks);
}
static void UnlockModule(void)
{
InterlockedDecrement(&cLocks);
}
static HRESULT WINAPI Test_IUnknown_QueryInterface(
LPUNKNOWN iface,
REFIID riid,
LPVOID *ppvObj)
{
if (ppvObj == NULL) return E_POINTER;
if (IsEqualGUID(riid, &IID_IUnknown))
{
*ppvObj = (LPVOID)iface;
IUnknown_AddRef(iface);
return S_OK;
}
*ppvObj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI Test_IUnknown_AddRef(LPUNKNOWN iface)
{
LockModule();
return 2; /* non-heap-based object */
}
static ULONG WINAPI Test_IUnknown_Release(LPUNKNOWN iface)
{
UnlockModule();
return 1; /* non-heap-based object */
}
static const IUnknownVtbl TestUnknown_Vtbl =
{
Test_IUnknown_QueryInterface,
Test_IUnknown_AddRef,
Test_IUnknown_Release,
};
static IUnknown Test_Unknown = { &TestUnknown_Vtbl };
static HRESULT WINAPI Test_IClassFactory_QueryInterface(
LPCLASSFACTORY iface,
REFIID riid,
LPVOID *ppvObj)
{
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 = (LPVOID)iface;
IClassFactory_AddRef(iface);
return S_OK;
}
*ppvObj = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI Test_IClassFactory_AddRef(LPCLASSFACTORY iface)
{
LockModule();
return 2; /* non-heap-based object */
}
static ULONG WINAPI Test_IClassFactory_Release(LPCLASSFACTORY iface)
{
UnlockModule();
return 1; /* non-heap-based object */
}
static HRESULT WINAPI Test_IClassFactory_CreateInstance(
LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID *ppvObj)
{
if (pUnkOuter) return CLASS_E_NOAGGREGATION;
return IUnknown_QueryInterface((IUnknown*)&Test_Unknown, riid, ppvObj);
}
static HRESULT WINAPI Test_IClassFactory_LockServer(
LPCLASSFACTORY iface,
BOOL fLock)
{
return S_OK;
}
static const IClassFactoryVtbl TestClassFactory_Vtbl =
{
Test_IClassFactory_QueryInterface,
Test_IClassFactory_AddRef,
Test_IClassFactory_Release,
Test_IClassFactory_CreateInstance,
Test_IClassFactory_LockServer
};
static IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl };
#define RELEASEMARSHALDATA WM_USER
struct host_object_data
{
IStream *stream;
IID iid;
IUnknown *object;
MSHLFLAGS marshal_flags;
HANDLE marshal_event;
IMessageFilter *filter;
};
static DWORD CALLBACK host_object_proc(LPVOID p)
{
struct host_object_data *data = (struct host_object_data *)p;
HRESULT hr;
MSG msg;
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
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 */
PeekMessage(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
SetEvent(data->marshal_event);
while (GetMessage(&msg, NULL, 0, 0))
{
if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
{
CoReleaseMarshalData(data->stream);
SetEvent((HANDLE)msg.lParam);
}
else
DispatchMessage(&msg);
}
HeapFree(GetProcessHeap(), 0, data);
CoUninitialize();
return hr;
}
static DWORD start_host_object2(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, IMessageFilter *filter, HANDLE *thread)
{
DWORD tid = 0;
HANDLE marshal_event = CreateEvent(NULL, FALSE, FALSE, NULL);
struct host_object_data *data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
data->stream = stream;
data->iid = *riid;
data->object = object;
data->marshal_flags = marshal_flags;
data->marshal_event = marshal_event;
data->filter = filter;
*thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
/* wait for marshaling to complete before returning */
WaitForSingleObject(marshal_event, INFINITE);
CloseHandle(marshal_event);
return tid;
}
static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
{
return start_host_object2(stream, riid, object, marshal_flags, NULL, thread);
}
/* asks thread to release the marshal data because it has to be done by the
* same thread that marshaled the interface in the first place. */
static void release_host_object(DWORD tid)
{
HANDLE event = CreateEvent(NULL, FALSE, FALSE, NULL);
PostThreadMessage(tid, RELEASEMARSHALDATA, 0, (LPARAM)event);
WaitForSingleObject(event, INFINITE);
CloseHandle(event);
}
static void end_host_object(DWORD tid, HANDLE thread)
{
BOOL ret = PostThreadMessage(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 */
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
}
/* tests failure case of interface not having a marshaler specified in the
* registry */
static void test_no_marshaler(void)
{
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);
}
/* tests normal marshal and then release without unmarshaling */
static void test_normal_marshal_and_release(void)
{
HRESULT hr;
IStream *pStream = NULL;
cLocks = 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();
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoReleaseMarshalData(pStream);
ok_ole_success(hr, CoReleaseMarshalData);
IStream_Release(pStream);
ok_no_locks();
}
/* tests success case of a same-thread marshal and unmarshal */
static void test_normal_marshal_and_unmarshal(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
cLocks = 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();
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();
IUnknown_Release(pProxy);
ok_no_locks();
}
/* tests failure case of unmarshaling a freed object */
static void test_marshal_and_unmarshal_invalid(void)
{
HRESULT hr;
IStream *pStream = NULL;
IClassFactory *pProxy = NULL;
DWORD tid;
void * dummy;
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 = CoReleaseMarshalData(pStream);
ok_ole_success(hr, CoReleaseMarshalData);
ok_no_locks();
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);
}
static void test_same_apartment_unmarshal_failure(void)
{
HRESULT hr;
IStream *pStream;
IUnknown *pProxy;
static const LARGE_INTEGER llZero;
cLocks = 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();
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();
IStream_Release(pStream);
}
/* tests success case of an interthread marshal */
static void test_interthread_marshal_and_unmarshal(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = 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_IClassFactory, (void **)&pProxy);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
ok_more_than_one_lock();
IUnknown_Release(pProxy);
ok_no_locks();
end_host_object(tid, thread);
}
/* the number of external references that Wine's proxy manager normally gives
* out, so we can test the border case of running out of references */
#define NORMALEXTREFS 5
/* tests success case of an interthread marshal and then marshaling the proxy */
static void test_proxy_marshal_and_unmarshal(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
IUnknown *pProxy2 = NULL;
DWORD tid;
HANDLE thread;
int i;
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_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();
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();
IStream_Release(pStream);
end_host_object(tid, thread);
}
/* tests success case of an interthread marshal and then marshaling the proxy
* using an iid that hasn't previously been unmarshaled */
static void test_proxy_marshal_and_unmarshal2(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
IUnknown *pProxy2 = NULL;
DWORD tid;
HANDLE thread;
cLocks = 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();
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();
IUnknown_Release(pProxy2);
ok_no_locks();
end_host_object(tid, thread);
}
/* tests success case of an interthread marshal and then table-weak-marshaling the proxy */
static void test_proxy_marshal_and_unmarshal_weak(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
IUnknown *pProxy2 = 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_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_TABLEWEAK);
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);
todo_wine
ok(hr == CO_E_OBJNOTREG, "CoUnmarshalInterface should return CO_E_OBJNOTREG instead of 0x%08x\n", hr);
ok_no_locks();
IStream_Release(pStream);
end_host_object(tid, thread);
}
/* tests success case of an interthread marshal and then table-strong-marshaling the proxy */
static void test_proxy_marshal_and_unmarshal_strong(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
IUnknown *pProxy2 = 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_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_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();
/* 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();
IUnknown_Release(pProxy2);
ok_more_than_one_lock();
end:
IStream_Release(pStream);
end_host_object(tid, thread);
ok_no_locks();
}
/* tests that stubs are released when the containing apartment is destroyed */
static void test_marshal_stub_apartment_shutdown(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = 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_IClassFactory, (void **)&pProxy);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
ok_more_than_one_lock();
end_host_object(tid, thread);
ok_no_locks();
IUnknown_Release(pProxy);
ok_no_locks();
}
/* tests that proxies are released when the containing apartment is destroyed */
static void test_marshal_proxy_apartment_shutdown(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = 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_IClassFactory, (void **)&pProxy);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
ok_more_than_one_lock();
CoUninitialize();
ok_no_locks();
IUnknown_Release(pProxy);
ok_no_locks();
end_host_object(tid, thread);
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
}
/* tests that proxies are released when the containing mta apartment is destroyed */
static void test_marshal_proxy_mta_apartment_shutdown(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
DWORD tid;
HANDLE thread;
CoUninitialize();
pCoInitializeEx(NULL, COINIT_MULTITHREADED);
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_IClassFactory, (void **)&pProxy);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
ok_more_than_one_lock();
CoUninitialize();
ok_no_locks();
IUnknown_Release(pProxy);
ok_no_locks();
end_host_object(tid, thread);
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
}
struct ncu_params
{
LPSTREAM stream;
HANDLE marshal_event;
HANDLE unmarshal_event;
};
/* helper for test_no_couninitialize_server */
static DWORD CALLBACK no_couninitialize_server_proc(LPVOID p)
{
struct ncu_params *ncu_params = (struct 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);
WaitForSingleObject(ncu_params->unmarshal_event, INFINITE);
/* die without calling CoUninitialize */
return 0;
}
/* tests apartment that an apartment with a stub is released without deadlock
* if the owning thread exits */
static void test_no_couninitialize_server(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
DWORD tid;
HANDLE thread;
struct ncu_params ncu_params;
cLocks = 0;
ncu_params.marshal_event = CreateEvent(NULL, TRUE, FALSE, NULL);
ncu_params.unmarshal_event = CreateEvent(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);
WaitForSingleObject(ncu_params.marshal_event, INFINITE);
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();
SetEvent(ncu_params.unmarshal_event);
WaitForSingleObject(thread, INFINITE);
ok_no_locks();
CloseHandle(thread);
CloseHandle(ncu_params.marshal_event);
CloseHandle(ncu_params.unmarshal_event);
IUnknown_Release(pProxy);
ok_no_locks();
}
/* STA -> STA call during DLL_THREAD_DETACH */
static DWORD CALLBACK no_couninitialize_client_proc(LPVOID p)
{
struct ncu_params *ncu_params = (struct 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;
}
/* tests STA -> STA call during DLL_THREAD_DETACH doesn't deadlock */
static void test_no_couninitialize_client(void)
{
HRESULT hr;
IStream *pStream = NULL;
DWORD tid;
DWORD host_tid;
HANDLE thread;
HANDLE host_thread;
struct ncu_params ncu_params;
cLocks = 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();
thread = CreateThread(NULL, 0, no_couninitialize_client_proc, &ncu_params, 0, &tid);
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
ok_no_locks();
end_host_object(host_tid, host_thread);
}
/* tests success case of a same-thread table-weak marshal, unmarshal, unmarshal */
static void test_tableweak_marshal_and_unmarshal_twice(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy1 = NULL;
IUnknown *pProxy2 = 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_TABLEWEAK, &thread);
ok_more_than_one_lock();
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);
IStream_Release(pStream);
ok_ole_success(hr, CoUnmarshalInterface);
ok_more_than_one_lock();
IUnknown_Release(pProxy1);
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();
end_host_object(tid, thread);
}
/* tests releasing after unmarshaling one object */
static void test_tableweak_marshal_releasedata1(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy1 = NULL;
IUnknown *pProxy2 = 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_TABLEWEAK, &thread);
ok_more_than_one_lock();
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();
/* 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);
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);
IStream_Release(pStream);
ok_more_than_one_lock();
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_no_locks();
end_host_object(tid, thread);
}
/* tests releasing after unmarshaling one object */
static void test_tableweak_marshal_releasedata2(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = 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_TABLEWEAK, &thread);
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);
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();
end_host_object(tid, thread);
}
/* tests success case of a same-thread table-strong marshal, unmarshal, unmarshal */
static void test_tablestrong_marshal_and_unmarshal_twice(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy1 = NULL;
IUnknown *pProxy2 = 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_TABLESTRONG, &thread);
ok_more_than_one_lock();
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);
IStream_Release(pStream);
ok_no_locks();
end_host_object(tid, thread);
}
/* tests CoLockObjectExternal */
static void test_lock_object_external(void)
{
HRESULT hr;
IStream *pStream = NULL;
cLocks = 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();
CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
ok_no_locks();
/* 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();
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoReleaseMarshalData(pStream);
ok_ole_success(hr, CoReleaseMarshalData);
IStream_Release(pStream);
ok_more_than_one_lock();
CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
ok_more_than_one_lock();
CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
ok_no_locks();
}
/* tests disconnecting stubs */
static void test_disconnect_stub(void)
{
HRESULT hr;
IStream *pStream = NULL;
cLocks = 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);
CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
ok_more_than_one_lock();
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoReleaseMarshalData(pStream);
ok_ole_success(hr, CoReleaseMarshalData);
IStream_Release(pStream);
ok_more_than_one_lock();
CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
ok_no_locks();
}
/* tests failure case of a same-thread marshal and unmarshal twice */
static void test_normal_marshal_and_unmarshal_twice(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy1 = NULL;
IUnknown *pProxy2 = NULL;
cLocks = 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();
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(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();
}
/* tests success case of marshaling and unmarshaling an HRESULT */
static void test_hresult_marshaling(void)
{
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);
}
/* helper for test_proxy_used_in_wrong_thread */
static DWORD CALLBACK bad_thread_proc(LPVOID p)
{
IClassFactory * cf = (IClassFactory *)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);
/* this statement causes Win9x DCOM to crash during CoUninitialize of
* other apartment, so don't test this on Win9x (signified by NT-only
* export of CoRegisterSurrogateEx) */
if (GetProcAddress(GetModuleHandle("ole32"), "CoRegisterSurrogateEx"))
/* now be really bad and release the proxy from the wrong apartment */
IUnknown_Release(cf);
else
skip("skipping test for releasing proxy from wrong apartment that will succeed, but cause a crash during CoUninitialize\n");
CoUninitialize();
return 0;
}
/* tests failure case of a using a proxy in the wrong apartment */
static void test_proxy_used_in_wrong_thread(void)
{
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 */
IClassFactory_QueryInterface(pProxy, &IID_IStream, (LPVOID *)&pStream);
/* create a thread that we can misbehave in */
thread = CreateThread(NULL, 0, bad_thread_proc, (LPVOID)pProxy, 0, &tid2);
WaitForSingleObject(thread, INFINITE);
CloseHandle(thread);
/* do release statement on Win9x that we should have done above */
if (!GetProcAddress(GetModuleHandle("ole32"), "CoRegisterSurrogateEx"))
IUnknown_Release(pProxy);
ok_no_locks();
end_host_object(tid, host_thread);
}
static HRESULT WINAPI MessageFilter_QueryInterface(IMessageFilter *iface, REFIID riid, void ** ppvObj)
{
if (ppvObj == NULL) return E_POINTER;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_IClassFactory))
{
*ppvObj = (LPVOID)iface;
IClassFactory_AddRef(iface);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI MessageFilter_AddRef(IMessageFilter *iface)
{
return 2; /* non-heap object */
}
static ULONG WINAPI MessageFilter_Release(IMessageFilter *iface)
{
return 1; /* non-heap object */
}
static DWORD WINAPI MessageFilter_HandleInComingCall(
IMessageFilter *iface,
DWORD dwCallType,
HTASK threadIDCaller,
DWORD dwTickCount,
LPINTERFACEINFO lpInterfaceInfo)
{
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;
}
static DWORD WINAPI MessageFilter_RetryRejectedCall(
IMessageFilter *iface,
HTASK threadIDCallee,
DWORD dwTickCount,
DWORD dwRejectType)
{
trace("RetryRejectedCall\n");
return 0;
}
static DWORD WINAPI MessageFilter_MessagePending(
IMessageFilter *iface,
HTASK threadIDCallee,
DWORD dwTickCount,
DWORD dwPendingType)
{
trace("MessagePending\n");
return PENDINGMSG_WAITNOPROCESS;
}
static const IMessageFilterVtbl MessageFilter_Vtbl =
{
MessageFilter_QueryInterface,
MessageFilter_AddRef,
MessageFilter_Release,
MessageFilter_HandleInComingCall,
MessageFilter_RetryRejectedCall,
MessageFilter_MessagePending
};
static IMessageFilter MessageFilter = { &MessageFilter_Vtbl };
static void test_message_filter(void)
{
HRESULT hr;
IStream *pStream = NULL;
IClassFactory *cf = NULL;
DWORD tid;
IUnknown *proxy = NULL;
IMessageFilter *prev_filter = NULL;
HANDLE thread;
cLocks = 0;
hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
ok_ole_success(hr, CreateStreamOnHGlobal);
tid = start_host_object2(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &MessageFilter, &thread);
ok_more_than_one_lock();
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&cf);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
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);
}
/* test failure case of trying to unmarshal from bad stream */
static void test_bad_marshal_stream(void)
{
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);
}
/* tests that proxies implement certain interfaces */
static void test_proxy_interfaces(void)
{
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);
}
typedef struct
{
const IUnknownVtbl *lpVtbl;
ULONG refs;
} HeapUnknown;
static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
{
if (IsEqualIID(riid, &IID_IUnknown))
{
IUnknown_AddRef(iface);
*ppv = (LPVOID)iface;
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
{
HeapUnknown *This = (HeapUnknown *)iface;
return InterlockedIncrement((LONG*)&This->refs);
}
static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
{
HeapUnknown *This = (HeapUnknown *)iface;
ULONG refs = InterlockedDecrement((LONG*)&This->refs);
if (!refs) HeapFree(GetProcessHeap(), 0, This);
return refs;
}
static const IUnknownVtbl HeapUnknown_Vtbl =
{
HeapUnknown_QueryInterface,
HeapUnknown_AddRef,
HeapUnknown_Release
};
static void test_proxybuffer(REFIID riid)
{
HRESULT hr;
IPSFactoryBuffer *psfb;
IRpcProxyBuffer *proxy;
LPVOID lpvtbl;
ULONG refs;
CLSID clsid;
HeapUnknown *pUnkOuter = HeapAlloc(GetProcessHeap(), 0, sizeof(*pUnkOuter));
pUnkOuter->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, (IUnknown*)pUnkOuter, 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((IUnknown *)pUnkOuter);
ok(refs == 1, "Ref count of outer unknown should have been 1 instead of %d\n", refs);
refs = IPSFactoryBuffer_Release(psfb);
if (0)
{
/* not reliable on native. maybe it leaks references! */
ok(refs == 0, "Ref-count leak of %d on IPSFactoryBuffer\n", refs);
}
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);
}
static void test_stubbuffer(REFIID riid)
{
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);
refs = IPSFactoryBuffer_Release(psfb);
if (0)
{
/* not reliable on native. maybe it leaks references */
ok(refs == 0, "Ref-count leak of %d on IPSFactoryBuffer\n", refs);
}
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);
}
static HWND hwnd_app;
static HRESULT WINAPI TestRE_IClassFactory_CreateInstance(
LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID *ppvObj)
{
DWORD_PTR res;
if (IsEqualIID(riid, &IID_IWineTest))
{
BOOL ret = SendMessageTimeout(hwnd_app, WM_NULL, 0, 0, SMTO_BLOCK, 5000, &res);
ok(ret, "Timed out sending a message to originating window during RPC call\n");
}
return S_FALSE;
}
static const IClassFactoryVtbl TestREClassFactory_Vtbl =
{
Test_IClassFactory_QueryInterface,
Test_IClassFactory_AddRef,
Test_IClassFactory_Release,
TestRE_IClassFactory_CreateInstance,
Test_IClassFactory_LockServer
};
IClassFactory TestRE_ClassFactory = { &TestREClassFactory_Vtbl };
static LRESULT CALLBACK window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
{
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);
IClassFactory_Release(proxy);
ok_no_locks();
end_host_object(tid, thread);
PostMessage(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 */
PostMessage(hwnd, WM_QUIT, 0, 0);
hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
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 DefWindowProc(hwnd, msg, wparam, lparam);
}
}
static void test_message_reentrancy(void)
{
WNDCLASS wndclass;
MSG msg;
memset(&wndclass, 0, sizeof(wndclass));
wndclass.lpfnWndProc = window_proc;
wndclass.lpszClassName = "WineCOMTest";
RegisterClass(&wndclass);
hwnd_app = CreateWindow("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 */
PostMessage(hwnd_app, WM_USER, 0, 0);
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
static HRESULT WINAPI TestMsg_IClassFactory_CreateInstance(
LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID *ppvObj)
{
*ppvObj = NULL;
SendMessage(hwnd_app, WM_USER+2, 0, 0);
return S_OK;
}
static IClassFactoryVtbl TestMsgClassFactory_Vtbl =
{
Test_IClassFactory_QueryInterface,
Test_IClassFactory_AddRef,
Test_IClassFactory_Release,
TestMsg_IClassFactory_CreateInstance,
Test_IClassFactory_LockServer
};
IClassFactory TestMsg_ClassFactory = { &TestMsgClassFactory_Vtbl };
static void test_call_from_message(void)
{
MSG msg;
IStream *pStream;
HRESULT hr;
IClassFactory *proxy;
DWORD tid;
HANDLE thread;
IUnknown *object;
hwnd_app = CreateWindow("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 (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
static void test_WM_QUIT_handling(void)
{
MSG msg;
hwnd_app = CreateWindow("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 */
PostMessage(hwnd_app, WM_USER+1, 0, 0);
while (GetMessage(&msg, NULL, 0, 0))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
static void test_freethreadedmarshaldata(IStream *pStream, MSHCTX mshctx, void *ptr, DWORD mshlflags)
{
HGLOBAL hglobal;
DWORD size;
char *marshal_data;
HRESULT hr;
hr = GetHGlobalFromStream(pStream, &hglobal);
ok_ole_success(hr, GetHGlobalFromStream);
size = GlobalSize(hglobal);
marshal_data = (char *)GlobalLock(hglobal);
if (mshctx == MSHCTX_INPROC)
{
DWORD expected_size = sizeof(DWORD) + sizeof(void *) + sizeof(DWORD) + sizeof(GUID);
ok(size == expected_size, "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 *);
ok(*(DWORD *)marshal_data == 0, "expected 0x0, but got 0x%x\n", *(DWORD *)marshal_data);
marshal_data += sizeof(DWORD);
trace("got guid data: {%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}\n",
((GUID *)marshal_data)->Data1, ((GUID *)marshal_data)->Data2, ((GUID *)marshal_data)->Data3,
((GUID *)marshal_data)->Data4[0], ((GUID *)marshal_data)->Data4[1], ((GUID *)marshal_data)->Data4[2], ((GUID *)marshal_data)->Data4[3],
((GUID *)marshal_data)->Data4[4], ((GUID *)marshal_data)->Data4[5], ((GUID *)marshal_data)->Data4[6], ((GUID *)marshal_data)->Data4[7]);
}
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);
}
static void test_freethreadedmarshaler(void)
{
HRESULT hr;
IUnknown *pFTUnknown;
IMarshal *pFTMarshal;
IStream *pStream;
IUnknown *pProxy;
static const LARGE_INTEGER llZero;
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_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
(IUnknown*)&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();
/* native doesn't allow us to unmarshal or release the stream data,
* presumably because it wants us to call CoMarshalInterface instead */
if (0)
{
/* local normal marshaling */
IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory, (IUnknown*)&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 = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
ok_ole_success(hr, IMarshal_ReleaseMarshalData);
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,
(IUnknown*)&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();
IStream_Release(pStream);
IMarshal_Release(pFTMarshal);
}
static void test_inproc_handler(void)
{
HRESULT hr;
IUnknown *pObject;
IUnknown *pObject2;
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");
error = RegCreateKeyEx(HKEY_CLASSES_ROOT, buffer, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey, &dwDisposition);
ok(error == ERROR_SUCCESS, "RegCreateKeyEx failed with error %d\n", error);
error = RegSetValueEx(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);
RegCloseKey(hkey);
hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&pObject);
todo_wine
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);
}
RegDeleteKey(HKEY_CLASSES_ROOT, buffer);
*strrchr(buffer, '\\') = '\0';
RegDeleteKey(HKEY_CLASSES_ROOT, buffer);
}
static HRESULT WINAPI Test_SMI_QueryInterface(
IStdMarshalInfo *iface,
REFIID riid,
LPVOID *ppvObj)
{
if (ppvObj == NULL) return E_POINTER;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_IStdMarshalInfo))
{
*ppvObj = (LPVOID)iface;
IClassFactory_AddRef(iface);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI Test_SMI_AddRef(IStdMarshalInfo *iface)
{
LockModule();
return 2; /* non-heap-based object */
}
static ULONG WINAPI Test_SMI_Release(IStdMarshalInfo *iface)
{
UnlockModule();
return 1; /* non-heap-based object */
}
static HRESULT WINAPI Test_SMI_GetClassForHandler(
IStdMarshalInfo *iface,
DWORD dwDestContext,
void *pvDestContext,
CLSID *pClsid)
{
*pClsid = CLSID_WineTest;
return S_OK;
}
static const IStdMarshalInfoVtbl Test_SMI_Vtbl =
{
Test_SMI_QueryInterface,
Test_SMI_AddRef,
Test_SMI_Release,
Test_SMI_GetClassForHandler
};
static IStdMarshalInfo Test_SMI = {&Test_SMI_Vtbl};
static void test_handler_marshaling(void)
{
HRESULT hr;
IStream *pStream = NULL;
IUnknown *pProxy = NULL;
IUnknown *pObject;
DWORD tid;
HANDLE thread;
static const LARGE_INTEGER ullZero;
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);
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);
/* FIXME: test IPersist interface has the same effect as IStdMarshalInfo */
}
static void test_client_security(void)
{
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 = IUnknown_QueryInterface(pProxy, &IID_IUnknown, (LPVOID*)&pUnknown1);
ok_ole_success(hr, "IUnknown_QueryInterface IID_IUnknown");
hr = IUnknown_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 = IUnknown_QueryInterface(pProxy, &IID_IMarshal, (LPVOID*)&pMarshal);
ok_ole_success(hr, "IUnknown_QueryInterface IID_IMarshal");
hr = IUnknown_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, (IUnknown *)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);
}
static HANDLE heventShutdown;
static void LockModuleOOP(void)
{
InterlockedIncrement(&cLocks); /* for test purposes only */
CoAddRefServerProcess();
}
static void UnlockModuleOOP(void)
{
InterlockedDecrement(&cLocks); /* for test purposes only */
if (!CoReleaseServerProcess())
SetEvent(heventShutdown);
}
static HWND hwnd_app;
static HRESULT WINAPI TestOOP_IClassFactory_QueryInterface(
LPCLASSFACTORY iface,
REFIID riid,
LPVOID *ppvObj)
{
if (ppvObj == NULL) return E_POINTER;
if (IsEqualGUID(riid, &IID_IUnknown) ||
IsEqualGUID(riid, &IID_IClassFactory))
{
*ppvObj = (LPVOID)iface;
IClassFactory_AddRef(iface);
return S_OK;
}
return E_NOINTERFACE;
}
static ULONG WINAPI TestOOP_IClassFactory_AddRef(LPCLASSFACTORY iface)
{
return 2; /* non-heap-based object */
}
static ULONG WINAPI TestOOP_IClassFactory_Release(LPCLASSFACTORY iface)
{
return 1; /* non-heap-based object */
}
static HRESULT WINAPI TestOOP_IClassFactory_CreateInstance(
LPCLASSFACTORY iface,
LPUNKNOWN pUnkOuter,
REFIID riid,
LPVOID *ppvObj)
{
if (IsEqualIID(riid, &IID_IClassFactory) || IsEqualIID(riid, &IID_IUnknown))
{
*ppvObj = iface;
return S_OK;
}
return CLASS_E_CLASSNOTAVAILABLE;
}
static HRESULT WINAPI TestOOP_IClassFactory_LockServer(
LPCLASSFACTORY iface,
BOOL fLock)
{
if (fLock)
LockModuleOOP();
else
UnlockModuleOOP();
return S_OK;
}
static const IClassFactoryVtbl TestClassFactoryOOP_Vtbl =
{
TestOOP_IClassFactory_QueryInterface,
TestOOP_IClassFactory_AddRef,
TestOOP_IClassFactory_Release,
TestOOP_IClassFactory_CreateInstance,
TestOOP_IClassFactory_LockServer
};
static IClassFactory TestOOP_ClassFactory = { &TestClassFactoryOOP_Vtbl };
static void test_register_local_server(void)
{
DWORD cookie;
HRESULT hr;
HANDLE ready_event;
HANDLE quit_event;
DWORD wait;
heventShutdown = CreateEvent(NULL, TRUE, FALSE, NULL);
hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory,
CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
ok_ole_success(hr, CoRegisterClassObject);
ready_event = CreateEvent(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
SetEvent(ready_event);
quit_event = CreateEvent(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
do
{
wait = MsgWaitForMultipleObjects(1, &quit_event, FALSE, INFINITE, QS_ALLINPUT);
if (wait == WAIT_OBJECT_0+1)
{
MSG msg;
BOOL ret = PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);
if (ret)
{
trace("Message 0x%x\n", msg.message);
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
}
while (wait == WAIT_OBJECT_0+1);
hr = CoRevokeClassObject(cookie);
ok_ole_success(hr, CoRevokeClassObject);
}
static HANDLE create_target_process(const char *arg)
{
char **argv;
char cmdline[MAX_PATH];
PROCESS_INFORMATION pi;
STARTUPINFO 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);
ok(CreateProcess(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL,
&si, &pi) != 0, "CreateProcess failed with error: %u\n", GetLastError());
if (pi.hThread) CloseHandle(pi.hThread);
return pi.hProcess;
}
/* tests functions commonly used by out of process COM servers */
static void test_local_server(void)
{
DWORD cookie;
HRESULT hr;
IClassFactory * cf;
DWORD ret;
HANDLE process;
HANDLE quit_event;
HANDLE ready_event;
heventShutdown = CreateEvent(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 == S_OK /* Win9x */,
"CoGetClassObject should have returned CO_E_SERVER_STOPPING 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 = CreateEvent(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
WaitForSingleObject(ready_event, INFINITE);
CloseHandle(ready_event);
hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IClassFactory, (void **)&cf);
ok_ole_success(hr, CoCreateInstance);
IClassFactory_Release(cf);
hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IClassFactory, (void **)&cf);
ok(hr == REGDB_E_CLASSNOTREG, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n");
quit_event = CreateEvent(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
SetEvent(quit_event);
WaitForSingleObject(process, INFINITE);
CloseHandle(quit_event);
CloseHandle(process);
}
struct git_params
{
DWORD cookie;
IGlobalInterfaceTable *git;
};
static DWORD CALLBACK get_global_interface_proc(LPVOID pv)
{
HRESULT hr;
struct git_params *params = (struct git_params *)pv;
IClassFactory *cf;
hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(params->git, params->cookie, &IID_IClassFactory, (void **)&cf);
ok(hr == CO_E_NOTINITIALIZED,
"IGlobalInterfaceTable_GetInterfaceFromGlobal should have failed with error CO_E_NOTINITIALIZED instead of 0x%08x\n",
hr);
CoInitialize(NULL);
hr = IGlobalInterfaceTable_GetInterfaceFromGlobal(params->git, params->cookie, &IID_IClassFactory, (void **)&cf);
ok_ole_success(hr, IGlobalInterfaceTable_GetInterfaceFromGlobal);
IClassFactory_Release(cf);
CoUninitialize();
return hr;
}
static void test_globalinterfacetable(void)
{
HRESULT hr;
IGlobalInterfaceTable *git;
DWORD cookie;
HANDLE thread;
DWORD tid;
struct git_params params;
DWORD ret;
IUnknown *object;
trace("test_globalinterfacetable\n");
cLocks = 0;
hr = CoCreateInstance(&CLSID_StdGlobalInterfaceTable, NULL, CLSCTX_INPROC_SERVER, &IID_IGlobalInterfaceTable, (void **)&git);
ok_ole_success(hr, CoCreateInstance);
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, INFINITE, QS_ALLINPUT);
while (ret == WAIT_OBJECT_0 + 1)
{
MSG msg;
while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
DispatchMessage(&msg);
ret = MsgWaitForMultipleObjects(1, &thread, FALSE, INFINITE, 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);
}
static const char *debugstr_iid(REFIID riid)
{
static char name[256];
HKEY hkeyInterface;
WCHAR bufferW[39];
char buffer[39];
LONG name_size = sizeof(name);
StringFromGUID2(riid, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
if (RegOpenKeyEx(HKEY_CLASSES_ROOT, "Interface", 0, KEY_QUERY_VALUE, &hkeyInterface) != ERROR_SUCCESS)
{
memcpy(name, buffer, sizeof(buffer));
goto done;
}
if (RegQueryValue(hkeyInterface, buffer, name, &name_size) != ERROR_SUCCESS)
{
memcpy(name, buffer, sizeof(buffer));
goto done;
}
RegCloseKey(hkeyInterface);
done:
return name;
}
static HRESULT WINAPI TestChannelHook_QueryInterface(IChannelHook *iface, REFIID riid, void **ppv)
{
if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IChannelHook))
{
*ppv = iface;
IUnknown_AddRef(iface);
return S_OK;
}
*ppv = NULL;
return E_NOINTERFACE;
}
static ULONG WINAPI TestChannelHook_AddRef(IChannelHook *iface)
{
return 2;
}
static ULONG WINAPI TestChannelHook_Release(IChannelHook *iface)
{
return 1;
}
static void WINAPI TestChannelHook_ClientGetSize(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
ULONG *pDataSize )
{
SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
trace("TestChannelHook_ClientGetBuffer\n");
trace("\t%s method %d\n", debugstr_iid(riid), info->iMethod);
trace("\tcid: %s\n", debugstr_iid(&info->uCausality));
ok(info->cbSize == sizeof(*info), "info->cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
ok(info->dwServerPid == GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
ok(!info->pObject, "info->pObject should be NULL\n");
ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
*pDataSize = 1;
}
static void WINAPI TestChannelHook_ClientFillBuffer(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
ULONG *pDataSize,
void *pDataBuffer )
{
SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
trace("TestChannelHook_ClientFillBuffer\n");
ok(info->cbSize == sizeof(*info), "info->cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
ok(info->dwServerPid == GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
ok(!info->pObject, "info->pObject should be NULL\n");
ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
*(unsigned char *)pDataBuffer = 0xcc;
*pDataSize = 1;
}
static void WINAPI TestChannelHook_ClientNotify(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void *pDataBuffer,
DWORD lDataRep,
HRESULT hrFault )
{
SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
trace("TestChannelHook_ClientNotify hrFault = 0x%08x\n", hrFault);
ok(info->cbSize == sizeof(*info), "info->cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
ok(info->dwServerPid == GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
todo_wine {
ok(info->pObject != NULL, "info->pObject shouldn't be NULL\n");
}
ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
}
static void WINAPI TestChannelHook_ServerNotify(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
ULONG cbDataSize,
void *pDataBuffer,
DWORD lDataRep )
{
SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
trace("TestChannelHook_ServerNotify\n");
ok(info->cbSize == sizeof(*info), "info->cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
ok(info->dwServerPid == GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
ok(info->pObject != NULL, "info->pObject shouldn't be NULL\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");
}
static void WINAPI TestChannelHook_ServerGetSize(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
HRESULT hrFault,
ULONG *pDataSize )
{
SChannelHookCallInfo *info = (SChannelHookCallInfo *)riid;
trace("TestChannelHook_ServerGetSize\n");
trace("\t%s method %d\n", debugstr_iid(riid), info->iMethod);
ok(info->cbSize == sizeof(*info), "info->cbSize was %d instead of %d\n", info->cbSize, (int)sizeof(*info));
ok(info->dwServerPid == GetCurrentProcessId(), "info->dwServerPid was 0x%x instead of 0x%x\n", info->dwServerPid, GetCurrentProcessId());
ok(info->pObject != NULL, "info->pObject shouldn't be NULL\n");
ok(IsEqualGUID(uExtent, &EXTENTID_WineTest), "uExtent wasn't correct\n");
if (hrFault != S_OK)
trace("\thrFault = 0x%08x\n", hrFault);
*pDataSize = 0;
}
static void WINAPI TestChannelHook_ServerFillBuffer(
IChannelHook *iface,
REFGUID uExtent,
REFIID riid,
ULONG *pDataSize,
void *pDataBuffer,
HRESULT hrFault )
{
trace("TestChannelHook_ServerFillBuffer\n");
ok(0, "TestChannelHook_ServerFillBuffer shouldn't be called\n");
}
static const IChannelHookVtbl TestChannelHookVtbl =
{
TestChannelHook_QueryInterface,
TestChannelHook_AddRef,
TestChannelHook_Release,
TestChannelHook_ClientGetSize,
TestChannelHook_ClientFillBuffer,
TestChannelHook_ClientNotify,
TestChannelHook_ServerNotify,
TestChannelHook_ServerGetSize,
TestChannelHook_ServerFillBuffer,
};
static IChannelHook TestChannelHook = { &TestChannelHookVtbl };
static void test_channel_hook(void)
{
IStream *pStream = NULL;
IClassFactory *cf = NULL;
DWORD tid;
IUnknown *proxy = NULL;
HANDLE thread;
HRESULT hr;
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, &pStream);
ok_ole_success(hr, CreateStreamOnHGlobal);
tid = start_host_object2(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &MessageFilter, &thread);
ok_more_than_one_lock();
IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&cf);
ok_ole_success(hr, CoUnmarshalInterface);
IStream_Release(pStream);
ok_more_than_one_lock();
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(NULL, NULL);
ok_ole_success(hr, CoRegisterMessageFilter);
}
START_TEST(marshal)
{
WNDCLASS wndclass;
HMODULE hOle32 = GetModuleHandle("ole32");
int argc;
char **argv;
if (!(pCoInitializeEx = (void*)GetProcAddress(hOle32, "CoInitializeEx"))) goto no_test;
argc = winetest_get_mainargs( &argv );
if (argc > 2 && (!strcmp(argv[2], "-Embedding")))
{
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
test_register_local_server();
CoUninitialize();
return;
}
/* register a window class used in several tests */
memset(&wndclass, 0, sizeof(wndclass));
wndclass.lpfnWndProc = window_proc;
wndclass.lpszClassName = "WineCOMTest";
RegisterClass(&wndclass);
test_cocreateinstance_proxy();
pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
/* FIXME: test CoCreateInstanceEx */
/* lifecycle management and marshaling tests */
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_tablestrong_marshal_and_unmarshal_twice();
test_lock_object_external();
test_disconnect_stub();
test_normal_marshal_and_unmarshal_twice();
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();
/* must be last test as channel hooks can't be unregistered */
test_channel_hook();
CoUninitialize();
return;
no_test:
trace("You need DCOM95 installed to run this test\n");
return;
}
Reference in New Issue View Git Blame Copy Permalink