[OLE32_WINETEST] Fix MSVC build.
[reactos.git] / modules / rostests / winetests / ole32 / marshal.c
1 /*
2 * Marshaling Tests
3 *
4 * Copyright 2004 Robert Shearman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #define _WIN32_DCOM
22 #define COBJMACROS
23 #define CONST_VTABLE
24
25 #include <stdarg.h>
26 #include <stdio.h>
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "objbase.h"
31 #include "olectl.h"
32 #include "shlguid.h"
33 #include "shobjidl.h"
34 #include "initguid.h"
35
36 #include "wine/test.h"
37 #include "wine/heap.h"
38
39 #define DEFINE_EXPECT(func) \
40 static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
41
42 #define SET_EXPECT(func) \
43 expect_ ## func = TRUE
44
45 #define CHECK_EXPECT2(func) \
46 do { \
47 ok(expect_ ##func, "unexpected call " #func "\n"); \
48 called_ ## func = TRUE; \
49 }while(0)
50
51 #define CHECK_EXPECT(func) \
52 do { \
53 CHECK_EXPECT2(func); \
54 expect_ ## func = FALSE; \
55 }while(0)
56
57 #define CHECK_CALLED(func) \
58 do { \
59 ok(called_ ## func, "expected " #func "\n"); \
60 expect_ ## func = called_ ## func = FALSE; \
61 }while(0)
62
63 DEFINE_GUID(CLSID_StdGlobalInterfaceTable,0x00000323,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
64 DEFINE_GUID(CLSID_ManualResetEvent, 0x0000032c,0x0000,0x0000,0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46);
65
66 static const GUID CLSID_WineTestPSFactoryBuffer = { 0x22222222, 0x1234, 0x1234, { 0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc, 0xde, 0xf0 } };
67
68 /* functions that are not present on all versions of Windows */
69 static HRESULT (WINAPI * pCoInitializeEx)(LPVOID lpReserved, DWORD dwCoInit);
70 static HRESULT (WINAPI *pDllGetClassObject)(REFCLSID,REFIID,LPVOID);
71
72 /* helper macros to make tests a bit leaner */
73 #define ok_more_than_one_lock() ok(cLocks > 0, "Number of locks should be > 0, but actually is %d\n", cLocks)
74 #define ok_no_locks() ok(cLocks == 0, "Number of locks should be 0, but actually is %d\n", cLocks)
75 #define ok_ole_success(hr, func) ok(hr == S_OK, #func " failed with error 0x%08x\n", hr)
76 #define ok_non_zero_external_conn() do {if (with_external_conn) ok(external_connections, "got no external connections\n");} while(0);
77 #define ok_zero_external_conn() do {if (with_external_conn) ok(!external_connections, "got %d external connections\n", external_connections);} while(0);
78 #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);
79
80 static const IID IID_IWineTest =
81 {
82 0x5201163f,
83 0x8164,
84 0x4fd0,
85 {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
86 }; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
87
88 static const IID IID_IRemUnknown =
89 {
90 0x00000131,
91 0x0000,
92 0x0000,
93 {0xc0,0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}
94 };
95
96 #define EXTENTID_WineTest IID_IWineTest
97 #define CLSID_WineTest IID_IWineTest
98
99 static const CLSID CLSID_WineOOPTest =
100 {
101 0x5201163f,
102 0x8164,
103 0x4fd0,
104 {0xa1, 0xa2, 0x5d, 0x5a, 0x36, 0x54, 0xd3, 0xbd}
105 }; /* 5201163f-8164-4fd0-a1a2-5d5a3654d3bd */
106
107 static void test_cocreateinstance_proxy(void)
108 {
109 IUnknown *pProxy;
110 IMultiQI *pMQI;
111 HRESULT hr;
112
113 pCoInitializeEx(NULL, COINIT_MULTITHREADED);
114
115 hr = CoCreateInstance(&CLSID_ShellDesktop, NULL, CLSCTX_INPROC, &IID_IUnknown, (void **)&pProxy);
116 ok_ole_success(hr, CoCreateInstance);
117 hr = IUnknown_QueryInterface(pProxy, &IID_IMultiQI, (void **)&pMQI);
118 ok(hr == S_OK, "created object is not a proxy, so was created in the wrong apartment\n");
119 if (hr == S_OK)
120 IMultiQI_Release(pMQI);
121 IUnknown_Release(pProxy);
122
123 CoUninitialize();
124 }
125
126 static const LARGE_INTEGER ullZero;
127 static LONG cLocks;
128
129 static void LockModule(void)
130 {
131 InterlockedIncrement(&cLocks);
132 }
133
134 static void UnlockModule(void)
135 {
136 InterlockedDecrement(&cLocks);
137 }
138
139 static BOOL with_external_conn;
140 static DWORD external_connections;
141 static BOOL last_release_closes;
142
143 static HRESULT WINAPI ExternalConnection_QueryInterface(IExternalConnection *iface, REFIID riid, void **ppv)
144 {
145 ok(0, "unexpected call\n");
146 *ppv = NULL;
147 return E_NOINTERFACE;
148 }
149
150 static ULONG WINAPI ExternalConnection_AddRef(IExternalConnection *iface)
151 {
152 return 2;
153 }
154
155 static ULONG WINAPI ExternalConnection_Release(IExternalConnection *iface)
156 {
157 return 1;
158 }
159
160 static DWORD WINAPI ExternalConnection_AddConnection(IExternalConnection *iface, DWORD extconn, DWORD reserved)
161 {
162 trace("add connection\n");
163 return ++external_connections;
164 }
165
166
167 static DWORD WINAPI ExternalConnection_ReleaseConnection(IExternalConnection *iface, DWORD extconn,
168 DWORD reserved, BOOL fLastReleaseCloses)
169 {
170 trace("release connection %d\n", fLastReleaseCloses);
171 last_release_closes = fLastReleaseCloses;
172 return --external_connections;
173 }
174
175 static const IExternalConnectionVtbl ExternalConnectionVtbl = {
176 ExternalConnection_QueryInterface,
177 ExternalConnection_AddRef,
178 ExternalConnection_Release,
179 ExternalConnection_AddConnection,
180 ExternalConnection_ReleaseConnection
181 };
182
183 static IExternalConnection ExternalConnection = { &ExternalConnectionVtbl };
184
185
186 static HRESULT WINAPI Test_IUnknown_QueryInterface(
187 LPUNKNOWN iface,
188 REFIID riid,
189 LPVOID *ppvObj)
190 {
191 if (ppvObj == NULL) return E_POINTER;
192
193 if (IsEqualGUID(riid, &IID_IUnknown))
194 {
195 *ppvObj = iface;
196 IUnknown_AddRef(iface);
197 return S_OK;
198 }
199
200 *ppvObj = NULL;
201 return E_NOINTERFACE;
202 }
203
204 static ULONG WINAPI Test_IUnknown_AddRef(LPUNKNOWN iface)
205 {
206 LockModule();
207 return 2; /* non-heap-based object */
208 }
209
210 static ULONG WINAPI Test_IUnknown_Release(LPUNKNOWN iface)
211 {
212 UnlockModule();
213 return 1; /* non-heap-based object */
214 }
215
216 static const IUnknownVtbl TestUnknown_Vtbl =
217 {
218 Test_IUnknown_QueryInterface,
219 Test_IUnknown_AddRef,
220 Test_IUnknown_Release,
221 };
222
223 static IUnknown Test_Unknown = { &TestUnknown_Vtbl };
224
225 static ULONG WINAPI TestCrash_IUnknown_Release(LPUNKNOWN iface)
226 {
227 UnlockModule();
228 if(!cLocks) {
229 trace("crashing...\n");
230 *(int**)0xc = 0;
231 }
232 return 1; /* non-heap-based object */
233 }
234
235 static const IUnknownVtbl TestCrashUnknown_Vtbl =
236 {
237 Test_IUnknown_QueryInterface,
238 Test_IUnknown_AddRef,
239 TestCrash_IUnknown_Release,
240 };
241
242 static IUnknown TestCrash_Unknown = { &TestCrashUnknown_Vtbl };
243
244 static HRESULT WINAPI Test_IClassFactory_QueryInterface(
245 LPCLASSFACTORY iface,
246 REFIID riid,
247 LPVOID *ppvObj)
248 {
249 if (ppvObj == NULL) return E_POINTER;
250
251 if (IsEqualGUID(riid, &IID_IUnknown) ||
252 IsEqualGUID(riid, &IID_IClassFactory) ||
253 /* the only other interface Wine is currently able to marshal (for testing two proxies) */
254 IsEqualGUID(riid, &IID_IRemUnknown))
255 {
256 *ppvObj = iface;
257 IClassFactory_AddRef(iface);
258 return S_OK;
259 }
260
261 if (with_external_conn && IsEqualGUID(riid, &IID_IExternalConnection))
262 {
263 *ppvObj = &ExternalConnection;
264 return S_OK;
265 }
266
267 *ppvObj = NULL;
268 return E_NOINTERFACE;
269 }
270
271 static ULONG WINAPI Test_IClassFactory_AddRef(LPCLASSFACTORY iface)
272 {
273 LockModule();
274 return 2; /* non-heap-based object */
275 }
276
277 static ULONG WINAPI Test_IClassFactory_Release(LPCLASSFACTORY iface)
278 {
279 UnlockModule();
280 return 1; /* non-heap-based object */
281 }
282
283 static HRESULT WINAPI Test_IClassFactory_CreateInstance(
284 LPCLASSFACTORY iface,
285 LPUNKNOWN pUnkOuter,
286 REFIID riid,
287 LPVOID *ppvObj)
288 {
289 if (pUnkOuter) return CLASS_E_NOAGGREGATION;
290 return IUnknown_QueryInterface((IUnknown*)&Test_Unknown, riid, ppvObj);
291 }
292
293 static HRESULT WINAPI Test_IClassFactory_LockServer(
294 LPCLASSFACTORY iface,
295 BOOL fLock)
296 {
297 return S_OK;
298 }
299
300 static const IClassFactoryVtbl TestClassFactory_Vtbl =
301 {
302 Test_IClassFactory_QueryInterface,
303 Test_IClassFactory_AddRef,
304 Test_IClassFactory_Release,
305 Test_IClassFactory_CreateInstance,
306 Test_IClassFactory_LockServer
307 };
308
309 static IClassFactory Test_ClassFactory = { &TestClassFactory_Vtbl };
310
311 DEFINE_EXPECT(Invoke);
312 DEFINE_EXPECT(CreateStub);
313 DEFINE_EXPECT(CreateProxy);
314 DEFINE_EXPECT(GetWindow);
315 DEFINE_EXPECT(Disconnect);
316
317 static HRESULT WINAPI OleWindow_QueryInterface(IOleWindow *iface, REFIID riid, void **ppv)
318 {
319 ok(0, "unexpected call %s\n", wine_dbgstr_guid(riid));
320 *ppv = NULL;
321 return E_NOINTERFACE;
322 }
323
324 static ULONG WINAPI OleWindow_AddRef(IOleWindow *iface)
325 {
326 return 2;
327 }
328
329 static ULONG WINAPI OleWindow_Release(IOleWindow *iface)
330 {
331 return 1;
332 }
333
334 static HRESULT WINAPI OleWindow_GetWindow(IOleWindow *iface, HWND *hwnd)
335 {
336 CHECK_EXPECT(GetWindow);
337 *hwnd = (HWND)0xdeadbeef;
338 return S_OK;
339 }
340
341 static const IOleWindowVtbl OleWindowVtbl = {
342 OleWindow_QueryInterface,
343 OleWindow_AddRef,
344 OleWindow_Release,
345 OleWindow_GetWindow,
346 /* not needed */
347 };
348
349 static IOleWindow Test_OleWindow = { &OleWindowVtbl };
350
351 static HRESULT WINAPI OleClientSite_QueryInterface(IOleClientSite *iface, REFIID riid, void **ppv)
352 {
353 if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IOleClientSite))
354 *ppv = iface;
355 else if (IsEqualGUID(riid, &IID_IOleWindow))
356 *ppv = &Test_OleWindow;
357 else
358 {
359 *ppv = NULL;
360 return E_NOINTERFACE;
361 }
362
363 IUnknown_AddRef((IUnknown*)*ppv);
364 return S_OK;
365 }
366
367 static ULONG WINAPI OleClientSite_AddRef(IOleClientSite *iface)
368 {
369 return 2;
370 }
371
372 static ULONG WINAPI OleClientSite_Release(IOleClientSite *iface)
373 {
374 return 1;
375 }
376
377 static const IOleClientSiteVtbl OleClientSiteVtbl = {
378 OleClientSite_QueryInterface,
379 OleClientSite_AddRef,
380 OleClientSite_Release,
381 /* we don't need the rest, we never call it */
382 };
383
384 static IOleClientSite Test_OleClientSite = { &OleClientSiteVtbl };
385
386 typedef struct {
387 IRpcStubBuffer IRpcStubBuffer_iface;
388 LONG ref;
389 IRpcStubBuffer *buffer;
390 } StubBufferWrapper;
391
392 static StubBufferWrapper *impl_from_IRpcStubBuffer(IRpcStubBuffer *iface)
393 {
394 return CONTAINING_RECORD(iface, StubBufferWrapper, IRpcStubBuffer_iface);
395 }
396
397 static HRESULT WINAPI RpcStubBuffer_QueryInterface(IRpcStubBuffer *iface, REFIID riid, void **ppv)
398 {
399 StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
400
401 if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRpcStubBuffer, riid)) {
402 *ppv = &This->IRpcStubBuffer_iface;
403 }else {
404 *ppv = NULL;
405 return E_NOINTERFACE;
406 }
407
408 IUnknown_AddRef((IUnknown*)*ppv);
409 return S_OK;
410 }
411
412 static ULONG WINAPI RpcStubBuffer_AddRef(IRpcStubBuffer *iface)
413 {
414 StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
415 return InterlockedIncrement(&This->ref);
416 }
417
418 static ULONG WINAPI RpcStubBuffer_Release(IRpcStubBuffer *iface)
419 {
420 StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
421 LONG ref = InterlockedDecrement(&This->ref);
422 if(!ref) {
423 IRpcStubBuffer_Release(This->buffer);
424 heap_free(This);
425 }
426 return ref;
427 }
428
429 static HRESULT WINAPI RpcStubBuffer_Connect(IRpcStubBuffer *iface, IUnknown *pUnkServer)
430 {
431 ok(0, "unexpected call\n");
432 return E_NOTIMPL;
433 }
434
435 static void WINAPI RpcStubBuffer_Disconnect(IRpcStubBuffer *iface)
436 {
437 CHECK_EXPECT(Disconnect);
438 }
439
440 static HRESULT WINAPI RpcStubBuffer_Invoke(IRpcStubBuffer *iface, RPCOLEMESSAGE *_prpcmsg,
441 IRpcChannelBuffer *_pRpcChannelBuffer)
442 {
443 StubBufferWrapper *This = impl_from_IRpcStubBuffer(iface);
444 void *dest_context_data;
445 DWORD dest_context;
446 HRESULT hr;
447
448 CHECK_EXPECT(Invoke);
449
450 hr = IRpcChannelBuffer_GetDestCtx(_pRpcChannelBuffer, &dest_context, &dest_context_data);
451 ok(hr == S_OK, "GetDestCtx failed: %08x\n", hr);
452 ok(dest_context == MSHCTX_INPROC, "desc_context = %x\n", dest_context);
453 ok(!dest_context_data, "desc_context_data = %p\n", dest_context_data);
454
455 return IRpcStubBuffer_Invoke(This->buffer, _prpcmsg, _pRpcChannelBuffer);
456 }
457
458 static IRpcStubBuffer *WINAPI RpcStubBuffer_IsIIDSupported(IRpcStubBuffer *iface, REFIID riid)
459 {
460 ok(0, "unexpected call\n");
461 return NULL;
462 }
463
464 static ULONG WINAPI RpcStubBuffer_CountRefs(IRpcStubBuffer *iface)
465 {
466 ok(0, "unexpected call\n");
467 return E_NOTIMPL;
468 }
469
470 static HRESULT WINAPI RpcStubBuffer_DebugServerQueryInterface(IRpcStubBuffer *iface, void **ppv)
471 {
472 ok(0, "unexpected call\n");
473 return E_NOTIMPL;
474 }
475
476 static void WINAPI RpcStubBuffer_DebugServerRelease(IRpcStubBuffer *iface, void *pv)
477 {
478 ok(0, "unexpected call\n");
479 }
480
481 static const IRpcStubBufferVtbl RpcStubBufferVtbl = {
482 RpcStubBuffer_QueryInterface,
483 RpcStubBuffer_AddRef,
484 RpcStubBuffer_Release,
485 RpcStubBuffer_Connect,
486 RpcStubBuffer_Disconnect,
487 RpcStubBuffer_Invoke,
488 RpcStubBuffer_IsIIDSupported,
489 RpcStubBuffer_CountRefs,
490 RpcStubBuffer_DebugServerQueryInterface,
491 RpcStubBuffer_DebugServerRelease
492 };
493
494 static IPSFactoryBuffer *ps_factory_buffer;
495
496 static HRESULT WINAPI PSFactoryBuffer_QueryInterface(IPSFactoryBuffer *iface, REFIID riid, void **ppv)
497 {
498 if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IPSFactoryBuffer))
499 *ppv = iface;
500 else
501 {
502 *ppv = NULL;
503 return E_NOINTERFACE;
504 }
505 IUnknown_AddRef((IUnknown*)*ppv);
506 return S_OK;
507 }
508
509 static ULONG WINAPI PSFactoryBuffer_AddRef(IPSFactoryBuffer *iface)
510 {
511 return 2;
512 }
513
514 static ULONG WINAPI PSFactoryBuffer_Release(IPSFactoryBuffer *iface)
515 {
516 return 1;
517 }
518
519 static HRESULT WINAPI PSFactoryBuffer_CreateProxy(IPSFactoryBuffer *iface, IUnknown *outer,
520 REFIID riid, IRpcProxyBuffer **ppProxy, void **ppv)
521 {
522 CHECK_EXPECT(CreateProxy);
523 return IPSFactoryBuffer_CreateProxy(ps_factory_buffer, outer, riid, ppProxy, ppv);
524 }
525
526 static HRESULT WINAPI PSFactoryBuffer_CreateStub(IPSFactoryBuffer *iface, REFIID riid,
527 IUnknown *server, IRpcStubBuffer **ppStub)
528 {
529 StubBufferWrapper *stub;
530 HRESULT hr;
531
532 CHECK_EXPECT(CreateStub);
533
534 ok(server == (IUnknown*)&Test_OleClientSite, "unexpected server %p\n", server);
535
536 stub = heap_alloc(sizeof(*stub));
537 stub->IRpcStubBuffer_iface.lpVtbl = &RpcStubBufferVtbl;
538 stub->ref = 1;
539
540 hr = IPSFactoryBuffer_CreateStub(ps_factory_buffer, riid, server, &stub->buffer);
541 ok(hr == S_OK, "CreateStub failed: %08x\n", hr);
542
543 *ppStub = &stub->IRpcStubBuffer_iface;
544 return S_OK;
545 }
546
547 static IPSFactoryBufferVtbl PSFactoryBufferVtbl =
548 {
549 PSFactoryBuffer_QueryInterface,
550 PSFactoryBuffer_AddRef,
551 PSFactoryBuffer_Release,
552 PSFactoryBuffer_CreateProxy,
553 PSFactoryBuffer_CreateStub
554 };
555
556 static IPSFactoryBuffer PSFactoryBuffer = { &PSFactoryBufferVtbl };
557
558 #define RELEASEMARSHALDATA WM_USER
559
560 struct host_object_data
561 {
562 IStream *stream;
563 const IID *iid;
564 IUnknown *object;
565 MSHLFLAGS marshal_flags;
566 IMessageFilter *filter;
567 IUnknown *register_object;
568 const CLSID *register_clsid;
569 HANDLE marshal_event;
570 };
571
572 #ifndef __REACTOS__ /* FIXME: Inspect */
573 static IPSFactoryBuffer PSFactoryBuffer;
574 #endif
575
576 static DWORD CALLBACK host_object_proc(LPVOID p)
577 {
578 struct host_object_data *data = p;
579 DWORD registration_key;
580 HRESULT hr;
581 MSG msg;
582
583 pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
584
585 if(data->register_object) {
586 hr = CoRegisterClassObject(data->register_clsid, data->register_object,
587 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &registration_key);
588 ok(hr == S_OK, "CoRegisterClassObject failed: %08x\n", hr);
589 }
590
591 if (data->filter)
592 {
593 IMessageFilter * prev_filter = NULL;
594 hr = CoRegisterMessageFilter(data->filter, &prev_filter);
595 if (prev_filter) IMessageFilter_Release(prev_filter);
596 ok_ole_success(hr, CoRegisterMessageFilter);
597 }
598
599 hr = CoMarshalInterface(data->stream, data->iid, data->object, MSHCTX_INPROC, NULL, data->marshal_flags);
600 ok_ole_success(hr, CoMarshalInterface);
601
602 /* force the message queue to be created before signaling parent thread */
603 PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
604
605 SetEvent(data->marshal_event);
606
607 while (GetMessageA(&msg, NULL, 0, 0))
608 {
609 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
610 {
611 CoReleaseMarshalData(data->stream);
612 SetEvent((HANDLE)msg.lParam);
613 }
614 else
615 DispatchMessageA(&msg);
616 }
617
618 HeapFree(GetProcessHeap(), 0, data);
619
620 CoUninitialize();
621
622 return hr;
623 }
624
625 static DWORD start_host_object2(struct host_object_data *object_data, HANDLE *thread)
626 {
627 DWORD tid = 0;
628 struct host_object_data *data;
629
630 data = HeapAlloc(GetProcessHeap(), 0, sizeof(*data));
631 *data = *object_data;
632 data->marshal_event = CreateEventA(NULL, FALSE, FALSE, NULL);
633 *thread = CreateThread(NULL, 0, host_object_proc, data, 0, &tid);
634
635 /* wait for marshaling to complete before returning */
636 ok( !WaitForSingleObject(data->marshal_event, 10000), "wait timed out\n" );
637 CloseHandle(data->marshal_event);
638
639 return tid;
640 }
641
642 static DWORD start_host_object(IStream *stream, REFIID riid, IUnknown *object, MSHLFLAGS marshal_flags, HANDLE *thread)
643 {
644 struct host_object_data object_data = { stream, riid, object, marshal_flags };
645 return start_host_object2(&object_data, thread);
646 }
647
648 /* asks thread to release the marshal data because it has to be done by the
649 * same thread that marshaled the interface in the first place. */
650 static void release_host_object(DWORD tid, WPARAM wp)
651 {
652 HANDLE event = CreateEventA(NULL, FALSE, FALSE, NULL);
653 PostThreadMessageA(tid, RELEASEMARSHALDATA, wp, (LPARAM)event);
654 ok( !WaitForSingleObject(event, 10000), "wait timed out\n" );
655 CloseHandle(event);
656 }
657
658 static void end_host_object(DWORD tid, HANDLE thread)
659 {
660 BOOL ret = PostThreadMessageA(tid, WM_QUIT, 0, 0);
661 ok(ret, "PostThreadMessage failed with error %d\n", GetLastError());
662 /* be careful of races - don't return until hosting thread has terminated */
663 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
664 CloseHandle(thread);
665 }
666
667 /* tests failure case of interface not having a marshaler specified in the
668 * registry */
669 static void test_no_marshaler(void)
670 {
671 IStream *pStream;
672 HRESULT hr;
673
674 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
675 ok_ole_success(hr, CreateStreamOnHGlobal);
676 hr = CoMarshalInterface(pStream, &IID_IWineTest, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
677 ok(hr == E_NOINTERFACE, "CoMarshalInterface should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
678
679 IStream_Release(pStream);
680 }
681
682 /* tests normal marshal and then release without unmarshaling */
683 static void test_normal_marshal_and_release(void)
684 {
685 HRESULT hr;
686 IStream *pStream = NULL;
687
688 cLocks = 0;
689 external_connections = 0;
690
691 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
692 ok_ole_success(hr, CreateStreamOnHGlobal);
693 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
694 ok_ole_success(hr, CoMarshalInterface);
695
696 ok_more_than_one_lock();
697 ok_non_zero_external_conn();
698
699 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
700 hr = CoReleaseMarshalData(pStream);
701 ok_ole_success(hr, CoReleaseMarshalData);
702 IStream_Release(pStream);
703
704 ok_no_locks();
705 ok_zero_external_conn();
706 ok_last_release_closes(TRUE);
707 }
708
709 /* tests success case of a same-thread marshal and unmarshal */
710 static void test_normal_marshal_and_unmarshal(void)
711 {
712 HRESULT hr;
713 IStream *pStream = NULL;
714 IUnknown *pProxy = NULL;
715
716 cLocks = 0;
717 external_connections = 0;
718
719 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
720 ok_ole_success(hr, CreateStreamOnHGlobal);
721 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
722 ok_ole_success(hr, CoMarshalInterface);
723
724 ok_more_than_one_lock();
725 ok_non_zero_external_conn();
726
727 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
728 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
729 ok_ole_success(hr, CoUnmarshalInterface);
730 IStream_Release(pStream);
731
732 ok_more_than_one_lock();
733 ok_zero_external_conn();
734 ok_last_release_closes(FALSE);
735
736 IUnknown_Release(pProxy);
737
738 ok_no_locks();
739 }
740
741 /* tests failure case of unmarshaling a freed object */
742 static void test_marshal_and_unmarshal_invalid(void)
743 {
744 HRESULT hr;
745 IStream *pStream = NULL;
746 IClassFactory *pProxy = NULL;
747 DWORD tid;
748 void * dummy;
749 HANDLE thread;
750
751 cLocks = 0;
752 external_connections = 0;
753
754 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
755 ok_ole_success(hr, CreateStreamOnHGlobal);
756 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
757
758 ok_more_than_one_lock();
759 ok_non_zero_external_conn();
760
761 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
762 hr = CoReleaseMarshalData(pStream);
763 ok_ole_success(hr, CoReleaseMarshalData);
764
765 ok_no_locks();
766 ok_zero_external_conn();
767 ok_last_release_closes(TRUE);
768
769 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
770 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
771 todo_wine { ok_ole_success(hr, CoUnmarshalInterface); }
772
773 ok_no_locks();
774
775 if (pProxy)
776 {
777 hr = IClassFactory_CreateInstance(pProxy, NULL, &IID_IUnknown, &dummy);
778 ok(hr == RPC_E_DISCONNECTED, "Remote call should have returned RPC_E_DISCONNECTED, instead of 0x%08x\n", hr);
779
780 IClassFactory_Release(pProxy);
781 }
782
783 IStream_Release(pStream);
784
785 end_host_object(tid, thread);
786 }
787
788 static void test_same_apartment_unmarshal_failure(void)
789 {
790 HRESULT hr;
791 IStream *pStream;
792 IUnknown *pProxy;
793 static const LARGE_INTEGER llZero;
794
795 cLocks = 0;
796 external_connections = 0;
797
798 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
799 ok_ole_success(hr, CreateStreamOnHGlobal);
800
801 hr = CoMarshalInterface(pStream, &IID_IUnknown, (IUnknown *)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
802 ok_ole_success(hr, CoMarshalInterface);
803
804 ok_more_than_one_lock();
805 ok_non_zero_external_conn();
806
807 hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
808 ok_ole_success(hr, IStream_Seek);
809
810 hr = CoUnmarshalInterface(pStream, &IID_IParseDisplayName, (void **)&pProxy);
811 ok(hr == E_NOINTERFACE, "CoUnmarshalInterface should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
812
813 ok_no_locks();
814 ok_zero_external_conn();
815 ok_last_release_closes(FALSE);
816
817 IStream_Release(pStream);
818 }
819
820 /* tests success case of an interthread marshal */
821 static void test_interthread_marshal_and_unmarshal(void)
822 {
823 HRESULT hr;
824 IStream *pStream = NULL;
825 IUnknown *pProxy = NULL;
826 DWORD tid;
827 HANDLE thread;
828
829 cLocks = 0;
830 external_connections = 0;
831
832 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
833 ok_ole_success(hr, CreateStreamOnHGlobal);
834 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
835
836 ok_more_than_one_lock();
837 ok_non_zero_external_conn();
838
839 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
840 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
841 ok_ole_success(hr, CoUnmarshalInterface);
842 IStream_Release(pStream);
843
844 ok_more_than_one_lock();
845 ok_non_zero_external_conn();
846
847 IUnknown_Release(pProxy);
848
849 ok_no_locks();
850 ok_zero_external_conn();
851 ok_last_release_closes(TRUE);
852
853 end_host_object(tid, thread);
854 }
855
856 /* the number of external references that Wine's proxy manager normally gives
857 * out, so we can test the border case of running out of references */
858 #define NORMALEXTREFS 5
859
860 /* tests success case of an interthread marshal and then marshaling the proxy */
861 static void test_proxy_marshal_and_unmarshal(void)
862 {
863 HRESULT hr;
864 IStream *pStream = NULL;
865 IUnknown *pProxy = NULL;
866 IUnknown *pProxy2 = NULL;
867 DWORD tid;
868 HANDLE thread;
869 int i;
870
871 cLocks = 0;
872 external_connections = 0;
873
874 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
875 ok_ole_success(hr, CreateStreamOnHGlobal);
876 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
877
878 ok_more_than_one_lock();
879 ok_non_zero_external_conn();
880
881 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
882 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
883 ok_ole_success(hr, CoUnmarshalInterface);
884
885 ok_more_than_one_lock();
886
887 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
888 /* marshal the proxy */
889 hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
890 ok_ole_success(hr, CoMarshalInterface);
891
892 ok_more_than_one_lock();
893
894 /* marshal 5 more times to exhaust the normal external references of 5 */
895 for (i = 0; i < NORMALEXTREFS; i++)
896 {
897 hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
898 ok_ole_success(hr, CoMarshalInterface);
899 }
900
901 ok_more_than_one_lock();
902
903 /* release the original proxy to test that we successfully keep the
904 * original object alive */
905 IUnknown_Release(pProxy);
906
907 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
908 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
909 ok_ole_success(hr, CoUnmarshalInterface);
910
911 ok_more_than_one_lock();
912 ok_non_zero_external_conn();
913
914 IUnknown_Release(pProxy2);
915
916 /* unmarshal all of the proxies to check that the object stub still exists */
917 for (i = 0; i < NORMALEXTREFS; i++)
918 {
919 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
920 ok_ole_success(hr, CoUnmarshalInterface);
921
922 IUnknown_Release(pProxy2);
923 }
924
925 ok_no_locks();
926 ok_zero_external_conn();
927 ok_last_release_closes(TRUE);
928
929 IStream_Release(pStream);
930
931 end_host_object(tid, thread);
932 }
933
934 /* tests success case of an interthread marshal and then marshaling the proxy
935 * using an iid that hasn't previously been unmarshaled */
936 static void test_proxy_marshal_and_unmarshal2(void)
937 {
938 HRESULT hr;
939 IStream *pStream = NULL;
940 IUnknown *pProxy = NULL;
941 IUnknown *pProxy2 = NULL;
942 DWORD tid;
943 HANDLE thread;
944
945 cLocks = 0;
946 external_connections = 0;
947
948 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
949 ok_ole_success(hr, CreateStreamOnHGlobal);
950 tid = start_host_object(pStream, &IID_IUnknown, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
951
952 ok_more_than_one_lock();
953 ok_non_zero_external_conn();
954
955 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
956 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
957 ok_ole_success(hr, CoUnmarshalInterface);
958
959 ok_more_than_one_lock();
960
961 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
962 /* marshal the proxy */
963 hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
964 ok_ole_success(hr, CoMarshalInterface);
965
966 ok_more_than_one_lock();
967
968 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
969 /* unmarshal the second proxy to the object */
970 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
971 ok_ole_success(hr, CoUnmarshalInterface);
972 IStream_Release(pStream);
973
974 /* now the proxies should be as follows:
975 * pProxy -> &Test_ClassFactory
976 * pProxy2 -> &Test_ClassFactory
977 * they should NOT be as follows:
978 * pProxy -> &Test_ClassFactory
979 * pProxy2 -> pProxy
980 * the above can only really be tested by looking in +ole traces
981 */
982
983 ok_more_than_one_lock();
984
985 IUnknown_Release(pProxy);
986
987 ok_more_than_one_lock();
988 ok_non_zero_external_conn();
989
990 IUnknown_Release(pProxy2);
991
992 ok_no_locks();
993 ok_zero_external_conn();
994 ok_last_release_closes(TRUE);
995
996 end_host_object(tid, thread);
997 }
998
999 /* tests success case of an interthread marshal and then table-weak-marshaling the proxy */
1000 static void test_proxy_marshal_and_unmarshal_weak(void)
1001 {
1002 HRESULT hr;
1003 IStream *pStream = NULL;
1004 IUnknown *pProxy = NULL;
1005 IUnknown *pProxy2 = NULL;
1006 DWORD tid;
1007 HANDLE thread;
1008
1009 cLocks = 0;
1010 external_connections = 0;
1011
1012 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1013 ok_ole_success(hr, CreateStreamOnHGlobal);
1014 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
1015
1016 ok_more_than_one_lock();
1017 ok_non_zero_external_conn();
1018
1019 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1020 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1021 ok_ole_success(hr, CoUnmarshalInterface);
1022
1023 ok_more_than_one_lock();
1024 ok_non_zero_external_conn();
1025
1026 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1027 /* marshal the proxy */
1028 hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
1029 ok_ole_success(hr, CoMarshalInterface);
1030
1031 ok_more_than_one_lock();
1032 ok_non_zero_external_conn();
1033
1034 /* release the original proxy to test that we successfully keep the
1035 * original object alive */
1036 IUnknown_Release(pProxy);
1037
1038 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1039 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
1040 todo_wine
1041 ok(hr == CO_E_OBJNOTREG, "CoUnmarshalInterface should return CO_E_OBJNOTREG instead of 0x%08x\n", hr);
1042
1043 ok_no_locks();
1044 ok_zero_external_conn();
1045 ok_last_release_closes(TRUE);
1046
1047 IStream_Release(pStream);
1048
1049 end_host_object(tid, thread);
1050 }
1051
1052 /* tests success case of an interthread marshal and then table-strong-marshaling the proxy */
1053 static void test_proxy_marshal_and_unmarshal_strong(void)
1054 {
1055 HRESULT hr;
1056 IStream *pStream = NULL;
1057 IUnknown *pProxy = NULL;
1058 IUnknown *pProxy2 = NULL;
1059 DWORD tid;
1060 HANDLE thread;
1061
1062 cLocks = 0;
1063 external_connections = 0;
1064
1065 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1066 ok_ole_success(hr, CreateStreamOnHGlobal);
1067 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
1068
1069 ok_more_than_one_lock();
1070 ok_non_zero_external_conn();
1071
1072 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1073 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1074 ok_ole_success(hr, CoUnmarshalInterface);
1075
1076 ok_more_than_one_lock();
1077 ok_non_zero_external_conn();
1078
1079 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1080 /* marshal the proxy */
1081 hr = CoMarshalInterface(pStream, &IID_IClassFactory, pProxy, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLESTRONG);
1082 ok(hr == S_OK /* WinNT */ || hr == E_INVALIDARG /* Win9x */,
1083 "CoMarshalInterface should have return S_OK or E_INVALIDARG instead of 0x%08x\n", hr);
1084 if (FAILED(hr))
1085 {
1086 IUnknown_Release(pProxy);
1087 goto end;
1088 }
1089
1090 ok_more_than_one_lock();
1091 ok_non_zero_external_conn();
1092
1093 /* release the original proxy to test that we successfully keep the
1094 * original object alive */
1095 IUnknown_Release(pProxy);
1096
1097 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1098 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
1099 ok_ole_success(hr, CoUnmarshalInterface);
1100
1101 ok_more_than_one_lock();
1102 ok_non_zero_external_conn();
1103
1104 IUnknown_Release(pProxy2);
1105
1106 ok_more_than_one_lock();
1107 ok_non_zero_external_conn();
1108
1109 end:
1110 IStream_Release(pStream);
1111
1112 end_host_object(tid, thread);
1113
1114 ok_no_locks();
1115 todo_wine {
1116 ok_zero_external_conn();
1117 ok_last_release_closes(FALSE);
1118 }
1119 }
1120
1121 /* tests that stubs are released when the containing apartment is destroyed */
1122 static void test_marshal_stub_apartment_shutdown(void)
1123 {
1124 HRESULT hr;
1125 IStream *pStream = NULL;
1126 IUnknown *pProxy = NULL;
1127 DWORD tid;
1128 HANDLE thread;
1129
1130 cLocks = 0;
1131 external_connections = 0;
1132
1133 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1134 ok_ole_success(hr, CreateStreamOnHGlobal);
1135 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
1136
1137 ok_more_than_one_lock();
1138 ok_non_zero_external_conn();
1139
1140 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1141 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1142 ok_ole_success(hr, CoUnmarshalInterface);
1143 IStream_Release(pStream);
1144
1145 ok_more_than_one_lock();
1146 ok_non_zero_external_conn();
1147
1148 end_host_object(tid, thread);
1149
1150 ok_no_locks();
1151 todo_wine {
1152 ok_zero_external_conn();
1153 ok_last_release_closes(FALSE);
1154 }
1155
1156 IUnknown_Release(pProxy);
1157
1158 ok_no_locks();
1159 }
1160
1161 /* tests that proxies are released when the containing apartment is destroyed */
1162 static void test_marshal_proxy_apartment_shutdown(void)
1163 {
1164 HRESULT hr;
1165 IStream *pStream = NULL;
1166 IUnknown *pProxy = NULL;
1167 DWORD tid;
1168 HANDLE thread;
1169
1170 cLocks = 0;
1171 external_connections = 0;
1172
1173 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1174 ok_ole_success(hr, CreateStreamOnHGlobal);
1175 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
1176
1177 ok_more_than_one_lock();
1178 ok_non_zero_external_conn();
1179
1180 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1181 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1182 ok_ole_success(hr, CoUnmarshalInterface);
1183 IStream_Release(pStream);
1184
1185 ok_more_than_one_lock();
1186 ok_non_zero_external_conn();
1187
1188 CoUninitialize();
1189
1190 ok_no_locks();
1191 ok_zero_external_conn();
1192 ok_last_release_closes(TRUE);
1193
1194 IUnknown_Release(pProxy);
1195
1196 ok_no_locks();
1197
1198 end_host_object(tid, thread);
1199
1200 pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1201 }
1202
1203 /* tests that proxies are released when the containing mta apartment is destroyed */
1204 static void test_marshal_proxy_mta_apartment_shutdown(void)
1205 {
1206 HRESULT hr;
1207 IStream *pStream = NULL;
1208 IUnknown *pProxy = NULL;
1209 DWORD tid;
1210 HANDLE thread;
1211
1212 CoUninitialize();
1213 pCoInitializeEx(NULL, COINIT_MULTITHREADED);
1214
1215 cLocks = 0;
1216 external_connections = 0;
1217
1218 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1219 ok_ole_success(hr, CreateStreamOnHGlobal);
1220 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
1221
1222 ok_more_than_one_lock();
1223 ok_non_zero_external_conn();
1224
1225 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1226 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1227 ok_ole_success(hr, CoUnmarshalInterface);
1228 IStream_Release(pStream);
1229
1230 ok_more_than_one_lock();
1231 ok_non_zero_external_conn();
1232
1233 CoUninitialize();
1234
1235 ok_no_locks();
1236 ok_zero_external_conn();
1237 ok_last_release_closes(TRUE);
1238
1239 IUnknown_Release(pProxy);
1240
1241 ok_no_locks();
1242
1243 end_host_object(tid, thread);
1244
1245 pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1246 }
1247
1248 static void test_marshal_channel_buffer(void)
1249 {
1250 DWORD registration_key;
1251 IUnknown *proxy = NULL;
1252 IOleWindow *ole_window;
1253 HWND hwnd;
1254 CLSID clsid;
1255 DWORD tid;
1256 HANDLE thread;
1257 HRESULT hr;
1258
1259 struct host_object_data object_data = { NULL, &IID_IOleClientSite, (IUnknown*)&Test_OleClientSite,
1260 MSHLFLAGS_NORMAL, NULL, (IUnknown*)&PSFactoryBuffer,
1261 &CLSID_WineTestPSFactoryBuffer };
1262
1263 cLocks = 0;
1264 external_connections = 0;
1265
1266 hr = CoGetPSClsid(&IID_IOleWindow, &clsid);
1267 ok_ole_success(hr, "CoGetPSClsid");
1268
1269 hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer,
1270 (void **)&ps_factory_buffer);
1271 ok_ole_success(hr, "CoGetClassObject");
1272
1273 hr = CreateStreamOnHGlobal(NULL, TRUE, &object_data.stream);
1274 ok_ole_success(hr, CreateStreamOnHGlobal);
1275 tid = start_host_object2(&object_data, &thread);
1276
1277 IStream_Seek(object_data.stream, ullZero, STREAM_SEEK_SET, NULL);
1278 hr = CoUnmarshalInterface(object_data.stream, &IID_IUnknown, (void **)&proxy);
1279 ok_ole_success(hr, CoUnmarshalInterface);
1280 IStream_Release(object_data.stream);
1281
1282 hr = CoRegisterClassObject(&CLSID_WineTestPSFactoryBuffer, (IUnknown *)&PSFactoryBuffer,
1283 CLSCTX_INPROC_SERVER, REGCLS_MULTIPLEUSE, &registration_key);
1284 ok(hr == S_OK, "CoRegisterClassObject failed: %08x\n", hr);
1285
1286 hr = CoRegisterPSClsid(&IID_IOleWindow, &CLSID_WineTestPSFactoryBuffer);
1287 ok(hr == S_OK, "CoRegisterPSClsid failed: %08x\n", hr);
1288
1289 SET_EXPECT(CreateStub);
1290 SET_EXPECT(CreateProxy);
1291 hr = IUnknown_QueryInterface(proxy, &IID_IOleWindow, (void**)&ole_window);
1292 ok(hr == S_OK, "Could not get IOleWindow iface: %08x\n", hr);
1293 CHECK_CALLED(CreateStub);
1294 CHECK_CALLED(CreateProxy);
1295
1296 SET_EXPECT(Invoke);
1297 SET_EXPECT(GetWindow);
1298 hr = IOleWindow_GetWindow(ole_window, &hwnd);
1299 ok(hr == S_OK, "GetWindow failed: %08x\n", hr);
1300 ok(hwnd == (HWND)0xdeadbeef, "hwnd = %p\n", hwnd);
1301 CHECK_CALLED(Invoke);
1302 CHECK_CALLED(GetWindow);
1303
1304 IOleWindow_Release(ole_window);
1305
1306 SET_EXPECT(Disconnect);
1307 IUnknown_Release(proxy);
1308 todo_wine
1309 CHECK_CALLED(Disconnect);
1310
1311 hr = CoRevokeClassObject(registration_key);
1312 ok(hr == S_OK, "CoRevokeClassObject failed: %08x\n", hr);
1313
1314 end_host_object(tid, thread);
1315 }
1316
1317 struct ncu_params
1318 {
1319 LPSTREAM stream;
1320 HANDLE marshal_event;
1321 HANDLE unmarshal_event;
1322 };
1323
1324 /* helper for test_no_couninitialize_server */
1325 static DWORD CALLBACK no_couninitialize_server_proc(LPVOID p)
1326 {
1327 struct ncu_params *ncu_params = p;
1328 HRESULT hr;
1329
1330 pCoInitializeEx(NULL, COINIT_MULTITHREADED);
1331
1332 hr = CoMarshalInterface(ncu_params->stream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1333 ok_ole_success(hr, CoMarshalInterface);
1334
1335 SetEvent(ncu_params->marshal_event);
1336
1337 ok( !WaitForSingleObject(ncu_params->unmarshal_event, 10000), "wait timed out\n" );
1338
1339 /* die without calling CoUninitialize */
1340
1341 return 0;
1342 }
1343
1344 /* tests apartment that an apartment with a stub is released without deadlock
1345 * if the owning thread exits */
1346 static void test_no_couninitialize_server(void)
1347 {
1348 HRESULT hr;
1349 IStream *pStream = NULL;
1350 IUnknown *pProxy = NULL;
1351 DWORD tid;
1352 HANDLE thread;
1353 struct ncu_params ncu_params;
1354
1355 cLocks = 0;
1356 external_connections = 0;
1357
1358 ncu_params.marshal_event = CreateEventA(NULL, TRUE, FALSE, NULL);
1359 ncu_params.unmarshal_event = CreateEventA(NULL, TRUE, FALSE, NULL);
1360
1361 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1362 ok_ole_success(hr, CreateStreamOnHGlobal);
1363 ncu_params.stream = pStream;
1364
1365 thread = CreateThread(NULL, 0, no_couninitialize_server_proc, &ncu_params, 0, &tid);
1366
1367 ok( !WaitForSingleObject(ncu_params.marshal_event, 10000), "wait timed out\n" );
1368 ok_more_than_one_lock();
1369 ok_non_zero_external_conn();
1370
1371 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1372 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1373 ok_ole_success(hr, CoUnmarshalInterface);
1374 IStream_Release(pStream);
1375
1376 ok_more_than_one_lock();
1377 ok_non_zero_external_conn();
1378
1379 SetEvent(ncu_params.unmarshal_event);
1380 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1381
1382 ok_no_locks();
1383 todo_wine {
1384 ok_zero_external_conn();
1385 ok_last_release_closes(FALSE);
1386 }
1387
1388 CloseHandle(thread);
1389 CloseHandle(ncu_params.marshal_event);
1390 CloseHandle(ncu_params.unmarshal_event);
1391
1392 IUnknown_Release(pProxy);
1393
1394 ok_no_locks();
1395 }
1396
1397 /* STA -> STA call during DLL_THREAD_DETACH */
1398 static DWORD CALLBACK no_couninitialize_client_proc(LPVOID p)
1399 {
1400 struct ncu_params *ncu_params = p;
1401 HRESULT hr;
1402 IUnknown *pProxy = NULL;
1403
1404 pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1405
1406 hr = CoUnmarshalInterface(ncu_params->stream, &IID_IClassFactory, (void **)&pProxy);
1407 ok_ole_success(hr, CoUnmarshalInterface);
1408 IStream_Release(ncu_params->stream);
1409
1410 ok_more_than_one_lock();
1411
1412 /* die without calling CoUninitialize */
1413
1414 return 0;
1415 }
1416
1417 /* tests STA -> STA call during DLL_THREAD_DETACH doesn't deadlock */
1418 static void test_no_couninitialize_client(void)
1419 {
1420 HRESULT hr;
1421 IStream *pStream = NULL;
1422 DWORD tid;
1423 DWORD host_tid;
1424 HANDLE thread;
1425 HANDLE host_thread;
1426 struct ncu_params ncu_params;
1427
1428 cLocks = 0;
1429 external_connections = 0;
1430
1431 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1432 ok_ole_success(hr, CreateStreamOnHGlobal);
1433 ncu_params.stream = pStream;
1434
1435 /* NOTE: assumes start_host_object uses an STA to host the object, as MTAs
1436 * always deadlock when called from within DllMain */
1437 host_tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown *)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
1438 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1439
1440 ok_more_than_one_lock();
1441 ok_non_zero_external_conn();
1442
1443 thread = CreateThread(NULL, 0, no_couninitialize_client_proc, &ncu_params, 0, &tid);
1444
1445 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1446 CloseHandle(thread);
1447
1448 ok_no_locks();
1449 ok_zero_external_conn();
1450 ok_last_release_closes(TRUE);
1451
1452 end_host_object(host_tid, host_thread);
1453 }
1454
1455 static BOOL crash_thread_success;
1456
1457 static DWORD CALLBACK crash_couninitialize_proc(void *p)
1458 {
1459 IStream *stream;
1460 HRESULT hr;
1461
1462 cLocks = 0;
1463
1464 CoInitialize(NULL);
1465
1466 hr = CreateStreamOnHGlobal(NULL, TRUE, &stream);
1467 ok_ole_success(hr, CreateStreamOnHGlobal);
1468
1469 hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1470 ok_ole_success(hr, CoMarshalInterface);
1471
1472 IStream_Seek(stream, ullZero, STREAM_SEEK_SET, NULL);
1473
1474 hr = CoReleaseMarshalData(stream);
1475 ok_ole_success(hr, CoReleaseMarshalData);
1476
1477 ok_no_locks();
1478
1479 hr = CoMarshalInterface(stream, &IID_IUnknown, &TestCrash_Unknown, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1480 ok_ole_success(hr, CoMarshalInterface);
1481
1482 ok_more_than_one_lock();
1483
1484 trace("CoUninitialize >>>\n");
1485 CoUninitialize();
1486 trace("CoUninitialize <<<\n");
1487
1488 ok_no_locks();
1489
1490 IStream_Release(stream);
1491 crash_thread_success = TRUE;
1492 return 0;
1493 }
1494
1495 static void test_crash_couninitialize(void)
1496 {
1497 HANDLE thread;
1498 DWORD tid;
1499
1500 if(!GetProcAddress(GetModuleHandleA("kernel32.dll"), "CreateActCtxW")) {
1501 win_skip("Skipping crash tests on win2k.\n");
1502 return;
1503 }
1504
1505 crash_thread_success = FALSE;
1506 thread = CreateThread(NULL, 0, crash_couninitialize_proc, NULL, 0, &tid);
1507 ok(!WaitForSingleObject(thread, 10000), "wait timed out\n");
1508 CloseHandle(thread);
1509 ok(crash_thread_success, "Crash thread failed\n");
1510 }
1511
1512 /* tests success case of a same-thread table-weak marshal, unmarshal, unmarshal */
1513 static void test_tableweak_marshal_and_unmarshal_twice(void)
1514 {
1515 HRESULT hr;
1516 IStream *pStream = NULL;
1517 IUnknown *pProxy1 = NULL;
1518 IUnknown *pProxy2 = NULL;
1519 DWORD tid;
1520 HANDLE thread;
1521
1522 cLocks = 0;
1523 external_connections = 0;
1524
1525 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1526 ok_ole_success(hr, CreateStreamOnHGlobal);
1527 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
1528
1529 ok_more_than_one_lock();
1530 ok_zero_external_conn();
1531
1532 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1533 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
1534 ok_ole_success(hr, CoUnmarshalInterface);
1535
1536 ok_more_than_one_lock();
1537 ok_non_zero_external_conn();
1538
1539 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1540 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
1541 ok_ole_success(hr, CoUnmarshalInterface);
1542
1543 ok_more_than_one_lock();
1544
1545 IUnknown_Release(pProxy1);
1546 ok_non_zero_external_conn();
1547 IUnknown_Release(pProxy2);
1548 ok_zero_external_conn();
1549 ok_last_release_closes(TRUE);
1550
1551 /* When IExternalConnection is present COM's lifetime management
1552 * behaviour is altered; the remaining weak ref prevents stub shutdown. */
1553 if (with_external_conn)
1554 {
1555 ok_more_than_one_lock();
1556 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1557 release_host_object(tid, 0);
1558 }
1559
1560 /* Without IExternalConnection this line is shows the difference between weak and strong table marshaling
1561 * weak has cLocks == 0, strong has cLocks > 0. */
1562 ok_no_locks();
1563
1564 IStream_Release(pStream);
1565 end_host_object(tid, thread);
1566 }
1567
1568 /* tests releasing after unmarshaling one object */
1569 static void test_tableweak_marshal_releasedata1(void)
1570 {
1571 HRESULT hr;
1572 IStream *pStream = NULL;
1573 IUnknown *pProxy1 = NULL;
1574 IUnknown *pProxy2 = NULL;
1575 DWORD tid;
1576 HANDLE thread;
1577
1578 cLocks = 0;
1579 external_connections = 0;
1580
1581 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1582 ok_ole_success(hr, CreateStreamOnHGlobal);
1583 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
1584
1585 ok_more_than_one_lock();
1586 ok_zero_external_conn();
1587
1588 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1589 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
1590 ok_ole_success(hr, CoUnmarshalInterface);
1591
1592 ok_more_than_one_lock();
1593 ok_non_zero_external_conn();
1594
1595 /* release the remaining reference on the object by calling
1596 * CoReleaseMarshalData in the hosting thread */
1597 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1598 release_host_object(tid, 0);
1599
1600 ok_more_than_one_lock();
1601 ok_non_zero_external_conn();
1602
1603 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1604 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
1605 ok_ole_success(hr, CoUnmarshalInterface);
1606 IStream_Release(pStream);
1607
1608 ok_more_than_one_lock();
1609 ok_non_zero_external_conn();
1610
1611 IUnknown_Release(pProxy1);
1612
1613 if (pProxy2)
1614 {
1615 ok_non_zero_external_conn();
1616 IUnknown_Release(pProxy2);
1617 }
1618
1619 /* this line is shows the difference between weak and strong table marshaling:
1620 * weak has cLocks == 0
1621 * strong has cLocks > 0 */
1622 ok_no_locks();
1623 ok_zero_external_conn();
1624 ok_last_release_closes(TRUE);
1625
1626 end_host_object(tid, thread);
1627 }
1628
1629 /* tests releasing after unmarshaling one object */
1630 static void test_tableweak_marshal_releasedata2(void)
1631 {
1632 HRESULT hr;
1633 IStream *pStream = NULL;
1634 IUnknown *pProxy = NULL;
1635 DWORD tid;
1636 HANDLE thread;
1637
1638 cLocks = 0;
1639 external_connections = 0;
1640
1641 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1642 ok_ole_success(hr, CreateStreamOnHGlobal);
1643 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLEWEAK, &thread);
1644
1645 ok_more_than_one_lock();
1646 ok_zero_external_conn();
1647
1648 /* release the remaining reference on the object by calling
1649 * CoReleaseMarshalData in the hosting thread */
1650 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1651 release_host_object(tid, 0);
1652
1653 ok_no_locks();
1654
1655 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1656 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
1657 todo_wine
1658 {
1659 ok(hr == CO_E_OBJNOTREG,
1660 "CoUnmarshalInterface should have failed with CO_E_OBJNOTREG, but returned 0x%08x instead\n",
1661 hr);
1662 }
1663 IStream_Release(pStream);
1664
1665 ok_no_locks();
1666 ok_zero_external_conn();
1667
1668 end_host_object(tid, thread);
1669 }
1670
1671 struct duo_marshal_data
1672 {
1673 MSHLFLAGS marshal_flags1, marshal_flags2;
1674 IStream *pStream1, *pStream2;
1675 HANDLE hReadyEvent;
1676 HANDLE hQuitEvent;
1677 };
1678
1679 static DWORD CALLBACK duo_marshal_thread_proc(void *p)
1680 {
1681 HRESULT hr;
1682 struct duo_marshal_data *data = p;
1683 HANDLE hQuitEvent = data->hQuitEvent;
1684 MSG msg;
1685
1686 pCoInitializeEx(NULL, COINIT_APARTMENTTHREADED);
1687
1688 hr = CoMarshalInterface(data->pStream1, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, data->marshal_flags1);
1689 ok_ole_success(hr, "CoMarshalInterface");
1690
1691 hr = CoMarshalInterface(data->pStream2, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, data->marshal_flags2);
1692 ok_ole_success(hr, "CoMarshalInterface");
1693
1694 /* force the message queue to be created before signaling parent thread */
1695 PeekMessageA(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
1696
1697 SetEvent(data->hReadyEvent);
1698
1699 while (WAIT_OBJECT_0 + 1 == MsgWaitForMultipleObjects(1, &hQuitEvent, FALSE, 10000, QS_ALLINPUT))
1700 {
1701 while (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
1702 {
1703 if (msg.hwnd == NULL && msg.message == RELEASEMARSHALDATA)
1704 {
1705 CoReleaseMarshalData(msg.wParam == 1 ? data->pStream1 : data->pStream2);
1706 SetEvent((HANDLE)msg.lParam);
1707 }
1708 else
1709 DispatchMessageA(&msg);
1710 }
1711 }
1712 CloseHandle(hQuitEvent);
1713
1714 CoUninitialize();
1715
1716 return 0;
1717 }
1718
1719 /* tests interaction between table-weak and normal marshalling of an object */
1720 static void test_tableweak_and_normal_marshal_and_unmarshal(void)
1721 {
1722 HRESULT hr;
1723 IUnknown *pProxyWeak = NULL;
1724 IUnknown *pProxyNormal = NULL;
1725 DWORD tid;
1726 HANDLE thread;
1727 struct duo_marshal_data data;
1728
1729 cLocks = 0;
1730 external_connections = 0;
1731
1732 data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1733 data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1734 data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
1735 data.marshal_flags2 = MSHLFLAGS_NORMAL;
1736 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
1737 ok_ole_success(hr, CreateStreamOnHGlobal);
1738 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
1739 ok_ole_success(hr, CreateStreamOnHGlobal);
1740
1741 thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
1742 ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
1743 CloseHandle(data.hReadyEvent);
1744
1745 ok_more_than_one_lock();
1746 ok_non_zero_external_conn();
1747
1748 /* weak */
1749 IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
1750 hr = CoUnmarshalInterface(data.pStream1, &IID_IClassFactory, (void **)&pProxyWeak);
1751 ok_ole_success(hr, CoUnmarshalInterface);
1752
1753 ok_more_than_one_lock();
1754
1755 /* normal */
1756 IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
1757 hr = CoUnmarshalInterface(data.pStream2, &IID_IClassFactory, (void **)&pProxyNormal);
1758 ok_ole_success(hr, CoUnmarshalInterface);
1759
1760 ok_more_than_one_lock();
1761
1762 IUnknown_Release(pProxyNormal);
1763
1764 ok_more_than_one_lock();
1765 ok_non_zero_external_conn();
1766
1767 IUnknown_Release(pProxyWeak);
1768
1769 ok_zero_external_conn();
1770 ok_last_release_closes(TRUE);
1771
1772 /* When IExternalConnection is present COM's lifetime management
1773 * behaviour is altered; the remaining weak ref prevents stub shutdown. */
1774 if (with_external_conn)
1775 {
1776 ok_more_than_one_lock();
1777 IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
1778 release_host_object(tid, 1);
1779 }
1780 ok_no_locks();
1781
1782 IStream_Release(data.pStream1);
1783 IStream_Release(data.pStream2);
1784
1785 SetEvent(data.hQuitEvent);
1786 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1787 CloseHandle(thread);
1788 }
1789
1790 static void test_tableweak_and_normal_marshal_and_releasedata(void)
1791 {
1792 HRESULT hr;
1793 DWORD tid;
1794 HANDLE thread;
1795 struct duo_marshal_data data;
1796
1797 cLocks = 0;
1798 external_connections = 0;
1799
1800 data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1801 data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1802 data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
1803 data.marshal_flags2 = MSHLFLAGS_NORMAL;
1804 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
1805 ok_ole_success(hr, CreateStreamOnHGlobal);
1806 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
1807 ok_ole_success(hr, CreateStreamOnHGlobal);
1808
1809 thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
1810 ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
1811 CloseHandle(data.hReadyEvent);
1812
1813 ok_more_than_one_lock();
1814 ok_non_zero_external_conn();
1815
1816 /* release normal - which in the non-external conn case will free the object despite the weak ref. */
1817 IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
1818 release_host_object(tid, 2);
1819
1820 ok_zero_external_conn();
1821 ok_last_release_closes(TRUE);
1822
1823 if (with_external_conn)
1824 {
1825 ok_more_than_one_lock();
1826 IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
1827 release_host_object(tid, 1);
1828 }
1829
1830 ok_no_locks();
1831
1832 IStream_Release(data.pStream1);
1833 IStream_Release(data.pStream2);
1834
1835 SetEvent(data.hQuitEvent);
1836 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1837 CloseHandle(thread);
1838 }
1839
1840 static void test_two_tableweak_marshal_and_releasedata(void)
1841 {
1842 HRESULT hr;
1843 DWORD tid;
1844 HANDLE thread;
1845 struct duo_marshal_data data;
1846
1847 cLocks = 0;
1848 external_connections = 0;
1849
1850 data.hReadyEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1851 data.hQuitEvent = CreateEventA(NULL, FALSE, FALSE, NULL);
1852 data.marshal_flags1 = MSHLFLAGS_TABLEWEAK;
1853 data.marshal_flags2 = MSHLFLAGS_TABLEWEAK;
1854 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream1);
1855 ok_ole_success(hr, CreateStreamOnHGlobal);
1856 hr = CreateStreamOnHGlobal(NULL, TRUE, &data.pStream2);
1857 ok_ole_success(hr, CreateStreamOnHGlobal);
1858
1859 thread = CreateThread(NULL, 0, duo_marshal_thread_proc, &data, 0, &tid);
1860 ok( !WaitForSingleObject(data.hReadyEvent, 10000), "wait timed out\n" );
1861 CloseHandle(data.hReadyEvent);
1862
1863 ok_more_than_one_lock();
1864 ok_zero_external_conn();
1865
1866 /* release one weak ref - the remaining weak ref will keep the obj alive */
1867 IStream_Seek(data.pStream1, ullZero, STREAM_SEEK_SET, NULL);
1868 release_host_object(tid, 1);
1869
1870 ok_more_than_one_lock();
1871
1872 IStream_Seek(data.pStream2, ullZero, STREAM_SEEK_SET, NULL);
1873 release_host_object(tid, 2);
1874
1875 ok_no_locks();
1876
1877 IStream_Release(data.pStream1);
1878 IStream_Release(data.pStream2);
1879
1880 SetEvent(data.hQuitEvent);
1881 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
1882 CloseHandle(thread);
1883 }
1884
1885 /* tests success case of a same-thread table-strong marshal, unmarshal, unmarshal */
1886 static void test_tablestrong_marshal_and_unmarshal_twice(void)
1887 {
1888 HRESULT hr;
1889 IStream *pStream = NULL;
1890 IUnknown *pProxy1 = NULL;
1891 IUnknown *pProxy2 = NULL;
1892 DWORD tid;
1893 HANDLE thread;
1894
1895 cLocks = 0;
1896 external_connections = 0;
1897
1898 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1899 ok_ole_success(hr, CreateStreamOnHGlobal);
1900 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_TABLESTRONG, &thread);
1901
1902 ok_more_than_one_lock();
1903 ok_non_zero_external_conn();
1904
1905 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1906 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
1907 ok_ole_success(hr, CoUnmarshalInterface);
1908
1909 ok_more_than_one_lock();
1910
1911 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1912 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
1913 ok_ole_success(hr, CoUnmarshalInterface);
1914
1915 ok_more_than_one_lock();
1916
1917 if (pProxy1) IUnknown_Release(pProxy1);
1918 if (pProxy2) IUnknown_Release(pProxy2);
1919
1920 /* this line is shows the difference between weak and strong table marshaling:
1921 * weak has cLocks == 0
1922 * strong has cLocks > 0 */
1923 ok_more_than_one_lock();
1924
1925 /* release the remaining reference on the object by calling
1926 * CoReleaseMarshalData in the hosting thread */
1927 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1928 release_host_object(tid, 0);
1929 IStream_Release(pStream);
1930
1931 ok_no_locks();
1932 ok_zero_external_conn();
1933 ok_last_release_closes(TRUE);
1934
1935 end_host_object(tid, thread);
1936 }
1937
1938 /* tests CoLockObjectExternal */
1939 static void test_lock_object_external(void)
1940 {
1941 HRESULT hr;
1942 IStream *pStream = NULL;
1943
1944 cLocks = 0;
1945 external_connections = 0;
1946
1947 /* test the stub manager creation aspect of CoLockObjectExternal when the
1948 * object hasn't been marshaled yet */
1949 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
1950
1951 ok_more_than_one_lock();
1952 ok_non_zero_external_conn();
1953
1954 CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
1955
1956 ok_no_locks();
1957 ok_non_zero_external_conn();
1958 external_connections = 0;
1959
1960 /* test our empty stub manager being handled correctly in
1961 * CoMarshalInterface */
1962 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
1963
1964 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1965 ok_ole_success(hr, CreateStreamOnHGlobal);
1966 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1967 ok_ole_success(hr, CoMarshalInterface);
1968
1969 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
1970
1971 ok_more_than_one_lock();
1972 ok_non_zero_external_conn();
1973
1974 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1975 hr = CoReleaseMarshalData(pStream);
1976 ok_ole_success(hr, CoReleaseMarshalData);
1977 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
1978
1979 ok_more_than_one_lock();
1980 ok_non_zero_external_conn();
1981 ok_last_release_closes(TRUE);
1982
1983 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
1984
1985 ok_more_than_one_lock();
1986 ok_non_zero_external_conn();
1987 ok_last_release_closes(TRUE);
1988
1989 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, TRUE);
1990
1991 ok_no_locks();
1992 ok_zero_external_conn();
1993 ok_last_release_closes(TRUE);
1994
1995 /* test CoLockObjectExternal releases reference to object with
1996 * fLastUnlockReleases as TRUE and there are only strong references on
1997 * the object */
1998 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, FALSE);
1999
2000 ok_more_than_one_lock();
2001 ok_non_zero_external_conn();
2002
2003 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, FALSE);
2004
2005 ok_no_locks();
2006 ok_zero_external_conn();
2007 ok_last_release_closes(FALSE);
2008
2009 /* test CoLockObjectExternal doesn't release the last reference to an
2010 * object with fLastUnlockReleases as TRUE and there is a weak reference
2011 * on the object */
2012 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_TABLEWEAK);
2013 ok_ole_success(hr, CoMarshalInterface);
2014
2015 ok_more_than_one_lock();
2016 ok_zero_external_conn();
2017
2018 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, FALSE);
2019
2020 ok_more_than_one_lock();
2021 ok_non_zero_external_conn();
2022
2023 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, FALSE, FALSE);
2024
2025 ok_more_than_one_lock();
2026 ok_zero_external_conn();
2027 ok_last_release_closes(FALSE);
2028
2029 CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
2030
2031 ok_no_locks();
2032
2033 IStream_Release(pStream);
2034 }
2035
2036 /* tests disconnecting stubs */
2037 static void test_disconnect_stub(void)
2038 {
2039 HRESULT hr;
2040 IStream *pStream = NULL;
2041
2042 cLocks = 0;
2043 external_connections = 0;
2044
2045 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2046 ok_ole_success(hr, CreateStreamOnHGlobal);
2047 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2048 ok_ole_success(hr, CoMarshalInterface);
2049
2050 ok_non_zero_external_conn();
2051
2052 CoLockObjectExternal((IUnknown*)&Test_ClassFactory, TRUE, TRUE);
2053
2054 ok_more_than_one_lock();
2055 ok_non_zero_external_conn();
2056
2057 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2058 hr = CoReleaseMarshalData(pStream);
2059 ok_ole_success(hr, CoReleaseMarshalData);
2060 IStream_Release(pStream);
2061
2062 ok_more_than_one_lock();
2063 ok_non_zero_external_conn();
2064
2065 CoDisconnectObject((IUnknown*)&Test_ClassFactory, 0);
2066
2067 ok_no_locks();
2068 ok_non_zero_external_conn();
2069
2070 hr = CoDisconnectObject(NULL, 0);
2071 ok( hr == E_INVALIDARG, "wrong status %x\n", hr );
2072 }
2073
2074 /* tests failure case of a same-thread marshal and unmarshal twice */
2075 static void test_normal_marshal_and_unmarshal_twice(void)
2076 {
2077 HRESULT hr;
2078 IStream *pStream = NULL;
2079 IUnknown *pProxy1 = NULL;
2080 IUnknown *pProxy2 = NULL;
2081
2082 cLocks = 0;
2083 external_connections = 0;
2084
2085 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2086 ok_ole_success(hr, CreateStreamOnHGlobal);
2087 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2088 ok_ole_success(hr, CoMarshalInterface);
2089
2090 ok_more_than_one_lock();
2091 ok_non_zero_external_conn();
2092
2093 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2094 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy1);
2095 ok_ole_success(hr, CoUnmarshalInterface);
2096
2097 ok_more_than_one_lock();
2098 ok_zero_external_conn();
2099 ok_last_release_closes(FALSE);
2100
2101 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2102 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy2);
2103 ok(hr == CO_E_OBJNOTCONNECTED,
2104 "CoUnmarshalInterface should have failed with error CO_E_OBJNOTCONNECTED for double unmarshal, instead of 0x%08x\n", hr);
2105
2106 IStream_Release(pStream);
2107
2108 ok_more_than_one_lock();
2109
2110 IUnknown_Release(pProxy1);
2111
2112 ok_no_locks();
2113 }
2114
2115 /* tests success case of marshaling and unmarshaling an HRESULT */
2116 static void test_hresult_marshaling(void)
2117 {
2118 HRESULT hr;
2119 HRESULT hr_marshaled = 0;
2120 IStream *pStream = NULL;
2121 static const HRESULT E_DEADBEEF = 0xdeadbeef;
2122
2123 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2124 ok_ole_success(hr, CreateStreamOnHGlobal);
2125
2126 hr = CoMarshalHresult(pStream, E_DEADBEEF);
2127 ok_ole_success(hr, CoMarshalHresult);
2128
2129 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2130 hr = IStream_Read(pStream, &hr_marshaled, sizeof(HRESULT), NULL);
2131 ok_ole_success(hr, IStream_Read);
2132
2133 ok(hr_marshaled == E_DEADBEEF, "Didn't marshal HRESULT as expected: got value 0x%08x instead\n", hr_marshaled);
2134
2135 hr_marshaled = 0;
2136 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2137 hr = CoUnmarshalHresult(pStream, &hr_marshaled);
2138 ok_ole_success(hr, CoUnmarshalHresult);
2139
2140 ok(hr_marshaled == E_DEADBEEF, "Didn't marshal HRESULT as expected: got value 0x%08x instead\n", hr_marshaled);
2141
2142 IStream_Release(pStream);
2143 }
2144
2145
2146 /* helper for test_proxy_used_in_wrong_thread */
2147 static DWORD CALLBACK bad_thread_proc(LPVOID p)
2148 {
2149 IClassFactory * cf = p;
2150 HRESULT hr;
2151 IUnknown * proxy = NULL;
2152
2153 hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
2154 todo_wine
2155 ok(hr == CO_E_NOTINITIALIZED,
2156 "COM should have failed with CO_E_NOTINITIALIZED on using proxy without apartment, but instead returned 0x%08x\n",
2157 hr);
2158
2159 hr = IClassFactory_QueryInterface(cf, &IID_IMultiQI, (LPVOID *)&proxy);
2160 /* Win9x returns S_OK, whilst NT returns RPC_E_WRONG_THREAD */
2161 trace("call to proxy's QueryInterface for local interface without apartment returned 0x%08x\n", hr);
2162 if (SUCCEEDED(hr))
2163 IUnknown_Release(proxy);
2164
2165 hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
2166 /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
2167 trace("call to proxy's QueryInterface without apartment returned 0x%08x\n", hr);
2168 if (SUCCEEDED(hr))
2169 IUnknown_Release(proxy);
2170
2171 pCoInitializeEx(NULL, COINIT_MULTITHREADED);
2172
2173 hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
2174 if (proxy) IUnknown_Release(proxy);
2175 ok(hr == RPC_E_WRONG_THREAD,
2176 "COM should have failed with RPC_E_WRONG_THREAD on using proxy from wrong apartment, but instead returned 0x%08x\n",
2177 hr);
2178
2179 hr = IClassFactory_QueryInterface(cf, &IID_IStream, (LPVOID *)&proxy);
2180 /* Win9x returns E_NOINTERFACE, whilst NT returns RPC_E_WRONG_THREAD */
2181 trace("call to proxy's QueryInterface from wrong apartment returned 0x%08x\n", hr);
2182
2183 /* now be really bad and release the proxy from the wrong apartment */
2184 IClassFactory_Release(cf);
2185
2186 CoUninitialize();
2187
2188 return 0;
2189 }
2190
2191 /* tests failure case of a using a proxy in the wrong apartment */
2192 static void test_proxy_used_in_wrong_thread(void)
2193 {
2194 HRESULT hr;
2195 IStream *pStream = NULL;
2196 IUnknown *pProxy = NULL;
2197 DWORD tid, tid2;
2198 HANDLE thread;
2199 HANDLE host_thread;
2200
2201 cLocks = 0;
2202
2203 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2204 ok_ole_success(hr, CreateStreamOnHGlobal);
2205 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &host_thread);
2206
2207 ok_more_than_one_lock();
2208
2209 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2210 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
2211 ok_ole_success(hr, CoUnmarshalInterface);
2212 IStream_Release(pStream);
2213
2214 ok_more_than_one_lock();
2215
2216 /* do a call that will fail, but result in IRemUnknown being used by the proxy */
2217 IUnknown_QueryInterface(pProxy, &IID_IStream, (LPVOID *)&pStream);
2218
2219 /* create a thread that we can misbehave in */
2220 thread = CreateThread(NULL, 0, bad_thread_proc, pProxy, 0, &tid2);
2221
2222 ok( !WaitForSingleObject(thread, 10000), "wait timed out\n" );
2223 CloseHandle(thread);
2224
2225 /* do release statement on Win9x that we should have done above */
2226 if (!GetProcAddress(GetModuleHandleA("ole32"), "CoRegisterSurrogateEx"))
2227 IUnknown_Release(pProxy);
2228
2229 ok_no_locks();
2230
2231 end_host_object(tid, host_thread);
2232 }
2233
2234 static HRESULT WINAPI MessageFilter_QueryInterface(IMessageFilter *iface, REFIID riid, void ** ppvObj)
2235 {
2236 if (ppvObj == NULL) return E_POINTER;
2237
2238 if (IsEqualGUID(riid, &IID_IUnknown) ||
2239 IsEqualGUID(riid, &IID_IClassFactory))
2240 {
2241 *ppvObj = iface;
2242 IMessageFilter_AddRef(iface);
2243 return S_OK;
2244 }
2245
2246 return E_NOINTERFACE;
2247 }
2248
2249 static ULONG WINAPI MessageFilter_AddRef(IMessageFilter *iface)
2250 {
2251 return 2; /* non-heap object */
2252 }
2253
2254 static ULONG WINAPI MessageFilter_Release(IMessageFilter *iface)
2255 {
2256 return 1; /* non-heap object */
2257 }
2258
2259 static DWORD WINAPI MessageFilter_HandleInComingCall(
2260 IMessageFilter *iface,
2261 DWORD dwCallType,
2262 HTASK threadIDCaller,
2263 DWORD dwTickCount,
2264 LPINTERFACEINFO lpInterfaceInfo)
2265 {
2266 static int callcount = 0;
2267 DWORD ret;
2268 trace("HandleInComingCall\n");
2269 switch (callcount)
2270 {
2271 case 0:
2272 ret = SERVERCALL_REJECTED;
2273 break;
2274 case 1:
2275 ret = SERVERCALL_RETRYLATER;
2276 break;
2277 default:
2278 ret = SERVERCALL_ISHANDLED;
2279 break;
2280 }
2281 callcount++;
2282 return ret;
2283 }
2284
2285 static DWORD WINAPI MessageFilter_RetryRejectedCall(
2286 IMessageFilter *iface,
2287 HTASK threadIDCallee,
2288 DWORD dwTickCount,
2289 DWORD dwRejectType)
2290 {
2291 trace("RetryRejectedCall\n");
2292 return 0;
2293 }
2294
2295 static DWORD WINAPI MessageFilter_MessagePending(
2296 IMessageFilter *iface,
2297 HTASK threadIDCallee,
2298 DWORD dwTickCount,
2299 DWORD dwPendingType)
2300 {
2301 trace("MessagePending\n");
2302 return PENDINGMSG_WAITNOPROCESS;
2303 }
2304
2305 static const IMessageFilterVtbl MessageFilter_Vtbl =
2306 {
2307 MessageFilter_QueryInterface,
2308 MessageFilter_AddRef,
2309 MessageFilter_Release,
2310 MessageFilter_HandleInComingCall,
2311 MessageFilter_RetryRejectedCall,
2312 MessageFilter_MessagePending
2313 };
2314
2315 static IMessageFilter MessageFilter = { &MessageFilter_Vtbl };
2316
2317 static void test_message_filter(void)
2318 {
2319 HRESULT hr;
2320 IClassFactory *cf = NULL;
2321 DWORD tid;
2322 IUnknown *proxy = NULL;
2323 IMessageFilter *prev_filter = NULL;
2324 HANDLE thread;
2325
2326 struct host_object_data object_data = { NULL, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory,
2327 MSHLFLAGS_NORMAL, &MessageFilter };
2328
2329 cLocks = 0;
2330
2331 hr = CreateStreamOnHGlobal(NULL, TRUE, &object_data.stream);
2332 ok_ole_success(hr, CreateStreamOnHGlobal);
2333 tid = start_host_object2(&object_data, &thread);
2334
2335 ok_more_than_one_lock();
2336
2337 IStream_Seek(object_data.stream, ullZero, STREAM_SEEK_SET, NULL);
2338 hr = CoUnmarshalInterface(object_data.stream, &IID_IClassFactory, (void **)&cf);
2339 ok_ole_success(hr, CoUnmarshalInterface);
2340 IStream_Release(object_data.stream);
2341
2342 ok_more_than_one_lock();
2343
2344 hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
2345 ok(hr == RPC_E_CALL_REJECTED, "Call should have returned RPC_E_CALL_REJECTED, but return 0x%08x instead\n", hr);
2346 if (proxy) IUnknown_Release(proxy);
2347 proxy = NULL;
2348
2349 hr = CoRegisterMessageFilter(&MessageFilter, &prev_filter);
2350 ok_ole_success(hr, CoRegisterMessageFilter);
2351
2352 hr = IClassFactory_CreateInstance(cf, NULL, &IID_IUnknown, (LPVOID*)&proxy);
2353 ok_ole_success(hr, IClassFactory_CreateInstance);
2354
2355 IUnknown_Release(proxy);
2356
2357 IClassFactory_Release(cf);
2358
2359 ok_no_locks();
2360
2361 end_host_object(tid, thread);
2362
2363 hr = CoRegisterMessageFilter(prev_filter, NULL);
2364 ok_ole_success(hr, CoRegisterMessageFilter);
2365 }
2366
2367 /* test failure case of trying to unmarshal from bad stream */
2368 static void test_bad_marshal_stream(void)
2369 {
2370 HRESULT hr;
2371 IStream *pStream = NULL;
2372
2373 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2374 ok_ole_success(hr, CreateStreamOnHGlobal);
2375 hr = CoMarshalInterface(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2376 ok_ole_success(hr, CoMarshalInterface);
2377
2378 ok_more_than_one_lock();
2379
2380 /* try to read beyond end of stream */
2381 hr = CoReleaseMarshalData(pStream);
2382 ok(hr == STG_E_READFAULT, "Should have failed with STG_E_READFAULT, but returned 0x%08x instead\n", hr);
2383
2384 /* now release for real */
2385 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2386 hr = CoReleaseMarshalData(pStream);
2387 ok_ole_success(hr, CoReleaseMarshalData);
2388
2389 IStream_Release(pStream);
2390 }
2391
2392 /* tests that proxies implement certain interfaces */
2393 static void test_proxy_interfaces(void)
2394 {
2395 HRESULT hr;
2396 IStream *pStream = NULL;
2397 IUnknown *pProxy = NULL;
2398 IUnknown *pOtherUnknown = NULL;
2399 DWORD tid;
2400 HANDLE thread;
2401
2402 cLocks = 0;
2403
2404 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2405 ok_ole_success(hr, CreateStreamOnHGlobal);
2406 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
2407
2408 ok_more_than_one_lock();
2409
2410 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2411 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
2412 ok_ole_success(hr, CoUnmarshalInterface);
2413 IStream_Release(pStream);
2414
2415 ok_more_than_one_lock();
2416
2417 hr = IUnknown_QueryInterface(pProxy, &IID_IUnknown, (LPVOID*)&pOtherUnknown);
2418 ok_ole_success(hr, IUnknown_QueryInterface IID_IUnknown);
2419 if (hr == S_OK) IUnknown_Release(pOtherUnknown);
2420
2421 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (LPVOID*)&pOtherUnknown);
2422 ok_ole_success(hr, IUnknown_QueryInterface IID_IClientSecurity);
2423 if (hr == S_OK) IUnknown_Release(pOtherUnknown);
2424
2425 hr = IUnknown_QueryInterface(pProxy, &IID_IMultiQI, (LPVOID*)&pOtherUnknown);
2426 ok_ole_success(hr, IUnknown_QueryInterface IID_IMultiQI);
2427 if (hr == S_OK) IUnknown_Release(pOtherUnknown);
2428
2429 hr = IUnknown_QueryInterface(pProxy, &IID_IMarshal, (LPVOID*)&pOtherUnknown);
2430 ok_ole_success(hr, IUnknown_QueryInterface IID_IMarshal);
2431 if (hr == S_OK) IUnknown_Release(pOtherUnknown);
2432
2433 /* IMarshal2 is also supported on NT-based systems, but is pretty much
2434 * useless as it has no more methods over IMarshal that it inherits from. */
2435
2436 IUnknown_Release(pProxy);
2437
2438 ok_no_locks();
2439
2440 end_host_object(tid, thread);
2441 }
2442
2443 typedef struct
2444 {
2445 IUnknown IUnknown_iface;
2446 ULONG refs;
2447 } HeapUnknown;
2448
2449 static inline HeapUnknown *impl_from_IUnknown(IUnknown *iface)
2450 {
2451 return CONTAINING_RECORD(iface, HeapUnknown, IUnknown_iface);
2452 }
2453
2454 static HRESULT WINAPI HeapUnknown_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
2455 {
2456 if (IsEqualIID(riid, &IID_IUnknown))
2457 {
2458 IUnknown_AddRef(iface);
2459 *ppv = iface;
2460 return S_OK;
2461 }
2462 *ppv = NULL;
2463 return E_NOINTERFACE;
2464 }
2465
2466 static ULONG WINAPI HeapUnknown_AddRef(IUnknown *iface)
2467 {
2468 HeapUnknown *This = impl_from_IUnknown(iface);
2469 return InterlockedIncrement((LONG*)&This->refs);
2470 }
2471
2472 static ULONG WINAPI HeapUnknown_Release(IUnknown *iface)
2473 {
2474 HeapUnknown *This = impl_from_IUnknown(iface);
2475 ULONG refs = InterlockedDecrement((LONG*)&This->refs);
2476 if (!refs) HeapFree(GetProcessHeap(), 0, This);
2477 return refs;
2478 }
2479
2480 static const IUnknownVtbl HeapUnknown_Vtbl =
2481 {
2482 HeapUnknown_QueryInterface,
2483 HeapUnknown_AddRef,
2484 HeapUnknown_Release
2485 };
2486
2487 static void test_proxybuffer(REFIID riid)
2488 {
2489 HRESULT hr;
2490 IPSFactoryBuffer *psfb;
2491 IRpcProxyBuffer *proxy;
2492 LPVOID lpvtbl;
2493 ULONG refs;
2494 CLSID clsid;
2495 HeapUnknown *pUnkOuter = HeapAlloc(GetProcessHeap(), 0, sizeof(*pUnkOuter));
2496
2497 pUnkOuter->IUnknown_iface.lpVtbl = &HeapUnknown_Vtbl;
2498 pUnkOuter->refs = 1;
2499
2500 hr = CoGetPSClsid(riid, &clsid);
2501 ok_ole_success(hr, CoGetPSClsid);
2502
2503 hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (LPVOID*)&psfb);
2504 ok_ole_success(hr, CoGetClassObject);
2505
2506 hr = IPSFactoryBuffer_CreateProxy(psfb, &pUnkOuter->IUnknown_iface, riid, &proxy, &lpvtbl);
2507 ok_ole_success(hr, IPSFactoryBuffer_CreateProxy);
2508 ok(lpvtbl != NULL, "IPSFactoryBuffer_CreateProxy succeeded, but returned a NULL vtable!\n");
2509
2510 /* release our reference to the outer unknown object - the PS factory
2511 * buffer will have AddRef's it in the CreateProxy call */
2512 refs = IUnknown_Release(&pUnkOuter->IUnknown_iface);
2513 ok(refs == 1, "Ref count of outer unknown should have been 1 instead of %d\n", refs);
2514
2515 /* Not checking return, unreliable on native. Maybe it leaks references? */
2516 IPSFactoryBuffer_Release(psfb);
2517
2518 refs = IUnknown_Release((IUnknown *)lpvtbl);
2519 ok(refs == 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs);
2520
2521 refs = IRpcProxyBuffer_Release(proxy);
2522 ok(refs == 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs);
2523 }
2524
2525 static void test_stubbuffer(REFIID riid)
2526 {
2527 HRESULT hr;
2528 IPSFactoryBuffer *psfb;
2529 IRpcStubBuffer *stub;
2530 ULONG refs;
2531 CLSID clsid;
2532
2533 cLocks = 0;
2534
2535 hr = CoGetPSClsid(riid, &clsid);
2536 ok_ole_success(hr, CoGetPSClsid);
2537
2538 hr = CoGetClassObject(&clsid, CLSCTX_INPROC_SERVER, NULL, &IID_IPSFactoryBuffer, (LPVOID*)&psfb);
2539 ok_ole_success(hr, CoGetClassObject);
2540
2541 hr = IPSFactoryBuffer_CreateStub(psfb, riid, (IUnknown*)&Test_ClassFactory, &stub);
2542 ok_ole_success(hr, IPSFactoryBuffer_CreateStub);
2543
2544 /* Not checking return, unreliable on native. Maybe it leaks references? */
2545 IPSFactoryBuffer_Release(psfb);
2546
2547 ok_more_than_one_lock();
2548
2549 IRpcStubBuffer_Disconnect(stub);
2550
2551 ok_no_locks();
2552
2553 refs = IRpcStubBuffer_Release(stub);
2554 ok(refs == 0, "Ref-count leak of %d on IRpcProxyBuffer\n", refs);
2555 }
2556
2557 static HWND hwnd_app;
2558
2559 static HRESULT WINAPI TestRE_IClassFactory_CreateInstance(
2560 LPCLASSFACTORY iface,
2561 LPUNKNOWN pUnkOuter,
2562 REFIID riid,
2563 LPVOID *ppvObj)
2564 {
2565 DWORD_PTR res;
2566 if (IsEqualIID(riid, &IID_IWineTest))
2567 {
2568 BOOL ret = SendMessageTimeoutA(hwnd_app, WM_NULL, 0, 0, SMTO_BLOCK, 5000, &res);
2569 ok(ret, "Timed out sending a message to originating window during RPC call\n");
2570 }
2571 *ppvObj = NULL;
2572 return S_FALSE;
2573 }
2574
2575 static const IClassFactoryVtbl TestREClassFactory_Vtbl =
2576 {
2577 Test_IClassFactory_QueryInterface,
2578 Test_IClassFactory_AddRef,
2579 Test_IClassFactory_Release,
2580 TestRE_IClassFactory_CreateInstance,
2581 Test_IClassFactory_LockServer
2582 };
2583
2584 static IClassFactory TestRE_ClassFactory = { &TestREClassFactory_Vtbl };
2585
2586 static LRESULT CALLBACK window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
2587 {
2588 switch (msg)
2589 {
2590 case WM_USER:
2591 {
2592 HRESULT hr;
2593 IStream *pStream = NULL;
2594 IClassFactory *proxy = NULL;
2595 IUnknown *object;
2596 DWORD tid;
2597 HANDLE thread;
2598
2599 cLocks = 0;
2600
2601 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2602 ok_ole_success(hr, CreateStreamOnHGlobal);
2603 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestRE_ClassFactory, MSHLFLAGS_NORMAL, &thread);
2604
2605 ok_more_than_one_lock();
2606
2607 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2608 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
2609 ok_ole_success(hr, CoReleaseMarshalData);
2610 IStream_Release(pStream);
2611
2612 ok_more_than_one_lock();
2613
2614 /* note the use of the magic IID_IWineTest value to tell remote thread
2615 * to try to send a message back to us */
2616 hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IWineTest, (void **)&object);
2617 ok(hr == S_FALSE, "expected S_FALSE, got %d\n", hr);
2618
2619 IClassFactory_Release(proxy);
2620
2621 ok_no_locks();
2622
2623 end_host_object(tid, thread);
2624
2625 PostMessageA(hwnd, WM_QUIT, 0, 0);
2626
2627 return 0;
2628 }
2629 case WM_USER+1:
2630 {
2631 HRESULT hr;
2632 IStream *pStream = NULL;
2633 IClassFactory *proxy = NULL;
2634 IUnknown *object;
2635 DWORD tid;
2636 HANDLE thread;
2637
2638 cLocks = 0;
2639
2640 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2641 ok_ole_success(hr, CreateStreamOnHGlobal);
2642 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestRE_ClassFactory, MSHLFLAGS_NORMAL, &thread);
2643
2644 ok_more_than_one_lock();
2645
2646 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2647 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
2648 ok_ole_success(hr, CoReleaseMarshalData);
2649 IStream_Release(pStream);
2650
2651 ok_more_than_one_lock();
2652
2653 /* post quit message before a doing a COM call to show that a pending
2654 * WM_QUIT message doesn't stop the call from succeeding */
2655 PostMessageA(hwnd, WM_QUIT, 0, 0);
2656 hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
2657 ok(hr == S_FALSE, "IClassFactory_CreateInstance returned 0x%08x, expected S_FALSE\n", hr);
2658
2659 IClassFactory_Release(proxy);
2660
2661 ok_no_locks();
2662
2663 end_host_object(tid, thread);
2664
2665 return 0;
2666 }
2667 case WM_USER+2:
2668 {
2669 HRESULT hr;
2670 IStream *pStream = NULL;
2671 IClassFactory *proxy = NULL;
2672 IUnknown *object;
2673 DWORD tid;
2674 HANDLE thread;
2675
2676 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2677 ok_ole_success(hr, CreateStreamOnHGlobal);
2678 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
2679
2680 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2681 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
2682 ok_ole_success(hr, CoReleaseMarshalData);
2683 IStream_Release(pStream);
2684
2685 /* shows that COM calls executed during the processing of sent
2686 * messages should fail */
2687 hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
2688 ok(hr == RPC_E_CANTCALLOUT_ININPUTSYNCCALL,
2689 "COM call during processing of sent message should return RPC_E_CANTCALLOUT_ININPUTSYNCCALL instead of 0x%08x\n", hr);
2690
2691 IClassFactory_Release(proxy);
2692
2693 end_host_object(tid, thread);
2694
2695 PostQuitMessage(0);
2696
2697 return 0;
2698 }
2699 default:
2700 return DefWindowProcA(hwnd, msg, wparam, lparam);
2701 }
2702 }
2703
2704 static void register_test_window(void)
2705 {
2706 WNDCLASSA wndclass;
2707
2708 memset(&wndclass, 0, sizeof(wndclass));
2709 wndclass.lpfnWndProc = window_proc;
2710 wndclass.lpszClassName = "WineCOMTest";
2711 RegisterClassA(&wndclass);
2712 }
2713
2714 static void test_message_reentrancy(void)
2715 {
2716 MSG msg;
2717
2718 hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
2719 ok(hwnd_app != NULL, "Window creation failed\n");
2720
2721 /* start message re-entrancy test */
2722 PostMessageA(hwnd_app, WM_USER, 0, 0);
2723
2724 while (GetMessageA(&msg, NULL, 0, 0))
2725 {
2726 TranslateMessage(&msg);
2727 DispatchMessageA(&msg);
2728 }
2729 DestroyWindow(hwnd_app);
2730 }
2731
2732 static HRESULT WINAPI TestMsg_IClassFactory_CreateInstance(
2733 LPCLASSFACTORY iface,
2734 LPUNKNOWN pUnkOuter,
2735 REFIID riid,
2736 LPVOID *ppvObj)
2737 {
2738 *ppvObj = NULL;
2739 SendMessageA(hwnd_app, WM_USER+2, 0, 0);
2740 return S_OK;
2741 }
2742
2743 static IClassFactoryVtbl TestMsgClassFactory_Vtbl =
2744 {
2745 Test_IClassFactory_QueryInterface,
2746 Test_IClassFactory_AddRef,
2747 Test_IClassFactory_Release,
2748 TestMsg_IClassFactory_CreateInstance,
2749 Test_IClassFactory_LockServer
2750 };
2751
2752 static IClassFactory TestMsg_ClassFactory = { &TestMsgClassFactory_Vtbl };
2753
2754 static void test_call_from_message(void)
2755 {
2756 MSG msg;
2757 IStream *pStream;
2758 HRESULT hr;
2759 IClassFactory *proxy;
2760 DWORD tid;
2761 HANDLE thread;
2762 IUnknown *object;
2763
2764 hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
2765 ok(hwnd_app != NULL, "Window creation failed\n");
2766
2767 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2768 ok_ole_success(hr, CreateStreamOnHGlobal);
2769 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&TestMsg_ClassFactory, MSHLFLAGS_NORMAL, &thread);
2770
2771 ok_more_than_one_lock();
2772
2773 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
2774 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&proxy);
2775 ok_ole_success(hr, CoReleaseMarshalData);
2776 IStream_Release(pStream);
2777
2778 ok_more_than_one_lock();
2779
2780 /* start message re-entrancy test */
2781 hr = IClassFactory_CreateInstance(proxy, NULL, &IID_IUnknown, (void **)&object);
2782 ok_ole_success(hr, IClassFactory_CreateInstance);
2783
2784 IClassFactory_Release(proxy);
2785
2786 ok_no_locks();
2787
2788 end_host_object(tid, thread);
2789
2790 while (GetMessageA(&msg, NULL, 0, 0))
2791 {
2792 TranslateMessage(&msg);
2793 DispatchMessageA(&msg);
2794 }
2795 DestroyWindow(hwnd_app);
2796 }
2797
2798 static void test_WM_QUIT_handling(void)
2799 {
2800 MSG msg;
2801
2802 hwnd_app = CreateWindowA("WineCOMTest", NULL, 0, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, NULL, 0);
2803 ok(hwnd_app != NULL, "Window creation failed\n");
2804
2805 /* start WM_QUIT handling test */
2806 PostMessageA(hwnd_app, WM_USER+1, 0, 0);
2807
2808 while (GetMessageA(&msg, NULL, 0, 0))
2809 {
2810 TranslateMessage(&msg);
2811 DispatchMessageA(&msg);
2812 }
2813 }
2814
2815 static SIZE_T round_global_size(SIZE_T size)
2816 {
2817 static SIZE_T global_size_alignment = -1;
2818 if (global_size_alignment == -1)
2819 {
2820 void *p = GlobalAlloc(GMEM_FIXED, 1);
2821 global_size_alignment = GlobalSize(p);
2822 GlobalFree(p);
2823 }
2824
2825 return ((size + global_size_alignment - 1) & ~(global_size_alignment - 1));
2826 }
2827
2828 static void test_freethreadedmarshaldata(IStream *pStream, MSHCTX mshctx, void *ptr, DWORD mshlflags)
2829 {
2830 HGLOBAL hglobal;
2831 DWORD size;
2832 char *marshal_data;
2833 HRESULT hr;
2834
2835 hr = GetHGlobalFromStream(pStream, &hglobal);
2836 ok_ole_success(hr, GetHGlobalFromStream);
2837
2838 size = GlobalSize(hglobal);
2839
2840 marshal_data = GlobalLock(hglobal);
2841
2842 if (mshctx == MSHCTX_INPROC)
2843 {
2844 DWORD expected_size = round_global_size(3*sizeof(DWORD) + sizeof(GUID));
2845 ok(size == expected_size ||
2846 broken(size == (2*sizeof(DWORD))) /* Win9x & NT4 */,
2847 "size should have been %d instead of %d\n", expected_size, size);
2848
2849 ok(*(DWORD *)marshal_data == mshlflags, "expected 0x%x, but got 0x%x for mshctx\n", mshlflags, *(DWORD *)marshal_data);
2850 marshal_data += sizeof(DWORD);
2851 ok(*(void **)marshal_data == ptr, "expected %p, but got %p for mshctx\n", ptr, *(void **)marshal_data);
2852 marshal_data += sizeof(void *);
2853 if (sizeof(void*) == 4 && size >= 3*sizeof(DWORD))
2854 {
2855 ok(*(DWORD *)marshal_data == 0, "expected 0x0, but got 0x%x\n", *(DWORD *)marshal_data);
2856 marshal_data += sizeof(DWORD);
2857 }
2858 if (size >= 3*sizeof(DWORD) + sizeof(GUID))
2859 {
2860 trace("got guid data: %s\n", wine_dbgstr_guid((GUID *)marshal_data));
2861 }
2862 }
2863 else
2864 {
2865 ok(size > sizeof(DWORD), "size should have been > sizeof(DWORD), not %d\n", size);
2866 ok(*(DWORD *)marshal_data == 0x574f454d /* MEOW */,
2867 "marshal data should be filled by standard marshal and start with MEOW signature\n");
2868 }
2869
2870 GlobalUnlock(hglobal);
2871 }
2872
2873 static void test_freethreadedmarshaler(void)
2874 {
2875 HRESULT hr;
2876 IUnknown *pFTUnknown;
2877 IMarshal *pFTMarshal;
2878 IStream *pStream;
2879 IUnknown *pProxy;
2880 static const LARGE_INTEGER llZero;
2881
2882 cLocks = 0;
2883 hr = CoCreateFreeThreadedMarshaler(NULL, &pFTUnknown);
2884 ok_ole_success(hr, CoCreateFreeThreadedMarshaler);
2885 hr = IUnknown_QueryInterface(pFTUnknown, &IID_IMarshal, (void **)&pFTMarshal);
2886 ok_ole_success(hr, IUnknown_QueryInterface);
2887 IUnknown_Release(pFTUnknown);
2888
2889 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
2890 ok_ole_success(hr, CreateStreamOnHGlobal);
2891
2892 /* inproc normal marshaling */
2893
2894 hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
2895 &Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2896 ok_ole_success(hr, IMarshal_MarshalInterface);
2897
2898 ok_more_than_one_lock();
2899
2900 test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_NORMAL);
2901
2902 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2903 hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
2904 ok_ole_success(hr, IMarshal_UnmarshalInterface);
2905
2906 IUnknown_Release(pProxy);
2907
2908 ok_no_locks();
2909
2910 /* native doesn't allow us to unmarshal or release the stream data,
2911 * presumably because it wants us to call CoMarshalInterface instead */
2912 if (0)
2913 {
2914 /* local normal marshaling */
2915
2916 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2917 hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory, &Test_ClassFactory, MSHCTX_LOCAL, NULL, MSHLFLAGS_NORMAL);
2918 ok_ole_success(hr, IMarshal_MarshalInterface);
2919
2920 ok_more_than_one_lock();
2921
2922 test_freethreadedmarshaldata(pStream, MSHCTX_LOCAL, &Test_ClassFactory, MSHLFLAGS_NORMAL);
2923
2924 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2925 hr = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
2926 ok_ole_success(hr, IMarshal_ReleaseMarshalData);
2927
2928 ok_no_locks();
2929 }
2930
2931 /* inproc table-strong marshaling */
2932
2933 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2934 hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
2935 (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, (void *)0xdeadbeef,
2936 MSHLFLAGS_TABLESTRONG);
2937 ok_ole_success(hr, IMarshal_MarshalInterface);
2938
2939 ok_more_than_one_lock();
2940
2941 test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_TABLESTRONG);
2942
2943 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2944 hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
2945 ok_ole_success(hr, IMarshal_UnmarshalInterface);
2946
2947 IUnknown_Release(pProxy);
2948
2949 ok_more_than_one_lock();
2950
2951 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2952 hr = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
2953 ok_ole_success(hr, IMarshal_ReleaseMarshalData);
2954
2955 ok_no_locks();
2956
2957 /* inproc table-weak marshaling */
2958
2959 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2960 hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
2961 (IUnknown*)&Test_ClassFactory, MSHCTX_INPROC, (void *)0xdeadbeef,
2962 MSHLFLAGS_TABLEWEAK);
2963 ok_ole_success(hr, IMarshal_MarshalInterface);
2964
2965 ok_no_locks();
2966
2967 test_freethreadedmarshaldata(pStream, MSHCTX_INPROC, &Test_ClassFactory, MSHLFLAGS_TABLEWEAK);
2968
2969 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2970 hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
2971 ok_ole_success(hr, IMarshal_UnmarshalInterface);
2972
2973 ok_more_than_one_lock();
2974
2975 IUnknown_Release(pProxy);
2976
2977 ok_no_locks();
2978
2979 /* inproc normal marshaling (for extraordinary cases) */
2980
2981 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2982 hr = IMarshal_MarshalInterface(pFTMarshal, pStream, &IID_IClassFactory,
2983 &Test_ClassFactory, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
2984 ok_ole_success(hr, IMarshal_MarshalInterface);
2985
2986 ok_more_than_one_lock();
2987
2988 /* this call shows that DisconnectObject does nothing */
2989 hr = IMarshal_DisconnectObject(pFTMarshal, 0);
2990 ok_ole_success(hr, IMarshal_DisconnectObject);
2991
2992 ok_more_than_one_lock();
2993
2994 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
2995 hr = IMarshal_ReleaseMarshalData(pFTMarshal, pStream);
2996 ok_ole_success(hr, IMarshal_ReleaseMarshalData);
2997
2998 ok_no_locks();
2999
3000 /* doesn't enforce marshaling rules here and allows us to unmarshal the
3001 * interface, even though it was freed above */
3002 IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
3003 hr = IMarshal_UnmarshalInterface(pFTMarshal, pStream, &IID_IUnknown, (void **)&pProxy);
3004 ok_ole_success(hr, IMarshal_UnmarshalInterface);
3005
3006 ok_no_locks();
3007
3008 IStream_Release(pStream);
3009 IMarshal_Release(pFTMarshal);
3010 }
3011
3012 static HRESULT reg_unreg_wine_test_class(BOOL Register)
3013 {
3014 HRESULT hr;
3015 char buffer[256];
3016 LPOLESTR pszClsid;
3017 HKEY hkey;
3018 DWORD dwDisposition;
3019 DWORD error;
3020
3021 hr = StringFromCLSID(&CLSID_WineTest, &pszClsid);
3022 ok_ole_success(hr, "StringFromCLSID");
3023 strcpy(buffer, "CLSID\\");
3024 WideCharToMultiByte(CP_ACP, 0, pszClsid, -1, buffer + strlen(buffer), sizeof(buffer) - strlen(buffer), NULL, NULL);
3025 CoTaskMemFree(pszClsid);
3026 strcat(buffer, "\\InprocHandler32");
3027 if (Register)
3028 {
3029 error = RegCreateKeyExA(HKEY_CLASSES_ROOT, buffer, 0, NULL, 0, KEY_SET_VALUE, NULL, &hkey, &dwDisposition);
3030 if (error == ERROR_ACCESS_DENIED)
3031 {
3032 skip("Not authorized to modify the Classes key\n");
3033 return E_FAIL;
3034 }
3035 ok(error == ERROR_SUCCESS, "RegCreateKeyEx failed with error %d\n", error);
3036 if (error != ERROR_SUCCESS) hr = E_FAIL;
3037 error = RegSetValueExA(hkey, NULL, 0, REG_SZ, (const unsigned char *)"\"ole32.dll\"", strlen("\"ole32.dll\"") + 1);
3038 ok(error == ERROR_SUCCESS, "RegSetValueEx failed with error %d\n", error);
3039 if (error != ERROR_SUCCESS) hr = E_FAIL;
3040 RegCloseKey(hkey);
3041 }
3042 else
3043 {
3044 RegDeleteKeyA(HKEY_CLASSES_ROOT, buffer);
3045 *strrchr(buffer, '\\') = '\0';
3046 RegDeleteKeyA(HKEY_CLASSES_ROOT, buffer);
3047 }
3048 return hr;
3049 }
3050
3051 static void test_inproc_handler(void)
3052 {
3053 HRESULT hr;
3054 IUnknown *pObject;
3055 IUnknown *pObject2;
3056
3057 if (FAILED(reg_unreg_wine_test_class(TRUE)))
3058 return;
3059
3060 hr = CoCreateInstance(&CLSID_WineTest, NULL, CLSCTX_INPROC_HANDLER, &IID_IUnknown, (void **)&pObject);
3061 ok_ole_success(hr, "CoCreateInstance");
3062
3063 if (SUCCEEDED(hr))
3064 {
3065 hr = IUnknown_QueryInterface(pObject, &IID_IWineTest, (void **)&pObject2);
3066 ok(hr == E_NOINTERFACE, "IUnknown_QueryInterface on handler for invalid interface returned 0x%08x instead of E_NOINTERFACE\n", hr);
3067
3068 /* it's a handler as it supports IOleObject */
3069 hr = IUnknown_QueryInterface(pObject, &IID_IOleObject, (void **)&pObject2);
3070 ok_ole_success(hr, "IUnknown_QueryInterface(&IID_IOleObject)");
3071 IUnknown_Release(pObject2);
3072
3073 IUnknown_Release(pObject);
3074 }
3075
3076 reg_unreg_wine_test_class(FALSE);
3077 }
3078
3079 static HRESULT WINAPI Test_SMI_QueryInterface(
3080 IStdMarshalInfo *iface,
3081 REFIID riid,
3082 LPVOID *ppvObj)
3083 {
3084 if (ppvObj == NULL) return E_POINTER;
3085
3086 if (IsEqualGUID(riid, &IID_IUnknown) ||
3087 IsEqualGUID(riid, &IID_IStdMarshalInfo))
3088 {
3089 *ppvObj = iface;
3090 IStdMarshalInfo_AddRef(iface);
3091 return S_OK;
3092 }
3093
3094 return E_NOINTERFACE;
3095 }
3096
3097 static ULONG WINAPI Test_SMI_AddRef(IStdMarshalInfo *iface)
3098 {
3099 LockModule();
3100 return 2; /* non-heap-based object */
3101 }
3102
3103 static ULONG WINAPI Test_SMI_Release(IStdMarshalInfo *iface)
3104 {
3105 UnlockModule();
3106 return 1; /* non-heap-based object */
3107 }
3108
3109 static HRESULT WINAPI Test_SMI_GetClassForHandler(
3110 IStdMarshalInfo *iface,
3111 DWORD dwDestContext,
3112 void *pvDestContext,
3113 CLSID *pClsid)
3114 {
3115 *pClsid = CLSID_WineTest;
3116 return S_OK;
3117 }
3118
3119 static const IStdMarshalInfoVtbl Test_SMI_Vtbl =
3120 {
3121 Test_SMI_QueryInterface,
3122 Test_SMI_AddRef,
3123 Test_SMI_Release,
3124 Test_SMI_GetClassForHandler
3125 };
3126
3127 static IStdMarshalInfo Test_SMI = {&Test_SMI_Vtbl};
3128
3129 static void test_handler_marshaling(void)
3130 {
3131 HRESULT hr;
3132 IStream *pStream = NULL;
3133 IUnknown *pProxy = NULL;
3134 IUnknown *pObject;
3135 DWORD tid;
3136 HANDLE thread;
3137 static const LARGE_INTEGER ullZero;
3138
3139 if (FAILED(reg_unreg_wine_test_class(TRUE)))
3140 return;
3141 cLocks = 0;
3142
3143 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
3144 ok_ole_success(hr, "CreateStreamOnHGlobal");
3145 tid = start_host_object(pStream, &IID_IUnknown, (IUnknown*)&Test_SMI, MSHLFLAGS_NORMAL, &thread);
3146
3147 ok_more_than_one_lock();
3148
3149 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
3150 hr = CoUnmarshalInterface(pStream, &IID_IUnknown, (void **)&pProxy);
3151 ok_ole_success(hr, "CoUnmarshalInterface");
3152 IStream_Release(pStream);
3153
3154 if(hr == S_OK)
3155 {
3156 ok_more_than_one_lock();
3157
3158 hr = IUnknown_QueryInterface(pProxy, &IID_IWineTest, (void **)&pObject);
3159 ok(hr == E_NOINTERFACE, "IUnknown_QueryInterface with unknown IID should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
3160
3161 /* it's a handler as it supports IOleObject */
3162 hr = IUnknown_QueryInterface(pProxy, &IID_IOleObject, (void **)&pObject);
3163 todo_wine
3164 ok_ole_success(hr, "IUnknown_QueryInterface(&IID_IOleObject)");
3165 if (SUCCEEDED(hr)) IUnknown_Release(pObject);
3166
3167 IUnknown_Release(pProxy);
3168
3169 ok_no_locks();
3170 }
3171
3172 end_host_object(tid, thread);
3173 reg_unreg_wine_test_class(FALSE);
3174
3175 /* FIXME: test IPersist interface has the same effect as IStdMarshalInfo */
3176 }
3177
3178
3179 static void test_client_security(void)
3180 {
3181 HRESULT hr;
3182 IStream *pStream = NULL;
3183 IClassFactory *pProxy = NULL;
3184 IUnknown *pProxy2 = NULL;
3185 IUnknown *pUnknown1 = NULL;
3186 IUnknown *pUnknown2 = NULL;
3187 IClientSecurity *pCliSec = NULL;
3188 IMarshal *pMarshal;
3189 DWORD tid;
3190 HANDLE thread;
3191 static const LARGE_INTEGER ullZero;
3192 DWORD dwAuthnSvc;
3193 DWORD dwAuthzSvc;
3194 OLECHAR *pServerPrincName;
3195 DWORD dwAuthnLevel;
3196 DWORD dwImpLevel;
3197 void *pAuthInfo;
3198 DWORD dwCapabilities;
3199 void *pv;
3200
3201 cLocks = 0;
3202
3203 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
3204 ok_ole_success(hr, "CreateStreamOnHGlobal");
3205 tid = start_host_object(pStream, &IID_IClassFactory, (IUnknown*)&Test_ClassFactory, MSHLFLAGS_NORMAL, &thread);
3206
3207 IStream_Seek(pStream, ullZero, STREAM_SEEK_SET, NULL);
3208 hr = CoUnmarshalInterface(pStream, &IID_IClassFactory, (void **)&pProxy);
3209 ok_ole_success(hr, "CoUnmarshalInterface");
3210 IStream_Release(pStream);
3211
3212 hr = IClassFactory_QueryInterface(pProxy, &IID_IUnknown, (LPVOID*)&pUnknown1);
3213 ok_ole_success(hr, "IUnknown_QueryInterface IID_IUnknown");
3214
3215 hr = IClassFactory_QueryInterface(pProxy, &IID_IRemUnknown, (LPVOID*)&pProxy2);
3216 ok_ole_success(hr, "IUnknown_QueryInterface IID_IStream");
3217
3218 hr = IUnknown_QueryInterface(pProxy2, &IID_IUnknown, (LPVOID*)&pUnknown2);
3219 ok_ole_success(hr, "IUnknown_QueryInterface IID_IUnknown");
3220
3221 ok(pUnknown1 == pUnknown2, "both proxy's IUnknowns should be the same - %p, %p\n", pUnknown1, pUnknown2);
3222
3223 hr = IClassFactory_QueryInterface(pProxy, &IID_IMarshal, (LPVOID*)&pMarshal);
3224 ok_ole_success(hr, "IUnknown_QueryInterface IID_IMarshal");
3225
3226 hr = IClassFactory_QueryInterface(pProxy, &IID_IClientSecurity, (LPVOID*)&pCliSec);
3227 ok_ole_success(hr, "IUnknown_QueryInterface IID_IClientSecurity");
3228
3229 hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pProxy, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3230 todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket (all NULLs)");
3231
3232 hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pMarshal, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3233 todo_wine ok(hr == E_NOINTERFACE, "IClientSecurity_QueryBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
3234
3235 hr = IClientSecurity_QueryBlanket(pCliSec, (IUnknown *)pProxy, &dwAuthnSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImpLevel, &pAuthInfo, &dwCapabilities);
3236 todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket");
3237
3238 hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pProxy, dwAuthnSvc, dwAuthzSvc, pServerPrincName, dwAuthnLevel, RPC_C_IMP_LEVEL_IMPERSONATE, pAuthInfo, dwCapabilities);
3239 todo_wine ok_ole_success(hr, "IClientSecurity_SetBlanket");
3240
3241 hr = IClassFactory_CreateInstance(pProxy, NULL, &IID_IWineTest, &pv);
3242 ok(hr == E_NOINTERFACE, "COM call should have succeeded instead of returning 0x%08x\n", hr);
3243
3244 hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pMarshal, dwAuthnSvc, dwAuthzSvc, pServerPrincName, dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities);
3245 todo_wine ok(hr == E_NOINTERFACE, "IClientSecurity_SetBlanket with local interface should have returned E_NOINTERFACE instead of 0x%08x\n", hr);
3246
3247 hr = IClientSecurity_SetBlanket(pCliSec, (IUnknown *)pProxy, 0xdeadbeef, dwAuthzSvc, pServerPrincName, dwAuthnLevel, dwImpLevel, pAuthInfo, dwCapabilities);
3248 todo_wine ok(hr == E_INVALIDARG, "IClientSecurity_SetBlanke with invalid dwAuthnSvc should have returned E_INVALIDARG instead of 0x%08x\n", hr);
3249
3250 CoTaskMemFree(pServerPrincName);
3251
3252 hr = IClientSecurity_QueryBlanket(pCliSec, pUnknown1, &dwAuthnSvc, &dwAuthzSvc, &pServerPrincName, &dwAuthnLevel, &dwImpLevel, &pAuthInfo, &dwCapabilities);
3253 todo_wine ok_ole_success(hr, "IClientSecurity_QueryBlanket(IUnknown)");
3254
3255 CoTaskMemFree(pServerPrincName);
3256
3257 IClassFactory_Release(pProxy);
3258 IUnknown_Release(pProxy2);
3259 IUnknown_Release(pUnknown1);
3260 IUnknown_Release(pUnknown2);
3261 IMarshal_Release(pMarshal);
3262 IClientSecurity_Release(pCliSec);
3263
3264 end_host_object(tid, thread);
3265 }
3266
3267 static HANDLE heventShutdown;
3268
3269 static void LockModuleOOP(void)
3270 {
3271 InterlockedIncrement(&cLocks); /* for test purposes only */
3272 CoAddRefServerProcess();
3273 }
3274
3275 static void UnlockModuleOOP(void)
3276 {
3277 InterlockedDecrement(&cLocks); /* for test purposes only */
3278 if (!CoReleaseServerProcess())
3279 SetEvent(heventShutdown);
3280 }
3281
3282 static HWND hwnd_app;
3283
3284 struct local_server
3285 {
3286 IPersist IPersist_iface; /* a nice short interface */
3287 };
3288
3289 static HRESULT WINAPI local_server_QueryInterface(IPersist *iface, REFIID iid, void **obj)
3290 {
3291 *obj = NULL;
3292
3293 if (IsEqualGUID(iid, &IID_IUnknown) ||
3294 IsEqualGUID(iid, &IID_IPersist))
3295 *obj = iface;
3296
3297 if (*obj)
3298 {
3299 IPersist_AddRef(iface);
3300 return S_OK;
3301 }
3302 return E_NOINTERFACE;
3303 }
3304
3305 static ULONG WINAPI local_server_AddRef(IPersist *iface)
3306 {
3307 return 2;
3308 }
3309
3310 static ULONG WINAPI local_server_Release(IPersist *iface)
3311 {
3312 return 1;
3313 }
3314
3315 static HRESULT WINAPI local_server_GetClassID(IPersist *iface, CLSID *clsid)
3316 {
3317 HRESULT hr;
3318
3319 *clsid = IID_IUnknown;
3320
3321 /* Test calling CoDisconnectObject within a COM call */
3322 hr = CoDisconnectObject((IUnknown *)iface, 0);
3323 ok(hr == S_OK, "got %08x\n", hr);
3324
3325 /* Initialize and uninitialize the apartment to show that we
3326 * remain in the autojoined mta */
3327 hr = pCoInitializeEx( NULL, COINIT_MULTITHREADED );
3328 ok( hr == S_FALSE, "got %08x\n", hr );
3329 CoUninitialize();
3330
3331 return S_OK;
3332 }
3333
3334 static const IPersistVtbl local_server_persist_vtbl =
3335 {
3336 local_server_QueryInterface,
3337 local_server_AddRef,
3338 local_server_Release,
3339 local_server_GetClassID
3340 };
3341
3342 struct local_server local_server_class =
3343 {
3344 {&local_server_persist_vtbl}
3345 };
3346
3347 static HRESULT WINAPI TestOOP_IClassFactory_QueryInterface(
3348 LPCLASSFACTORY iface,
3349 REFIID riid,
3350 LPVOID *ppvObj)
3351 {
3352 if (ppvObj == NULL) return E_POINTER;
3353
3354 if (IsEqualGUID(riid, &IID_IUnknown) ||
3355 IsEqualGUID(riid, &IID_IClassFactory))
3356 {
3357 *ppvObj = iface;
3358 IClassFactory_AddRef(iface);
3359 return S_OK;
3360 }
3361
3362 return E_NOINTERFACE;
3363 }
3364
3365 static ULONG WINAPI TestOOP_IClassFactory_AddRef(LPCLASSFACTORY iface)
3366 {
3367 return 2; /* non-heap-based object */
3368 }
3369
3370 static ULONG WINAPI TestOOP_IClassFactory_Release(LPCLASSFACTORY iface)
3371 {
3372 return 1; /* non-heap-based object */
3373 }
3374
3375 static HRESULT WINAPI TestOOP_IClassFactory_CreateInstance(
3376 LPCLASSFACTORY iface,
3377 LPUNKNOWN pUnkOuter,
3378 REFIID riid,
3379 LPVOID *ppvObj)
3380 {
3381 IPersist *persist = &local_server_class.IPersist_iface;
3382 HRESULT hr;
3383 IPersist_AddRef( persist );
3384 hr = IPersist_QueryInterface( persist, riid, ppvObj );
3385 IPersist_Release( persist );
3386 return hr;
3387 }
3388
3389 static HRESULT WINAPI TestOOP_IClassFactory_LockServer(
3390 LPCLASSFACTORY iface,
3391 BOOL fLock)
3392 {
3393 if (fLock)
3394 LockModuleOOP();
3395 else
3396 UnlockModuleOOP();
3397 return S_OK;
3398 }
3399
3400 static const IClassFactoryVtbl TestClassFactoryOOP_Vtbl =
3401 {
3402 TestOOP_IClassFactory_QueryInterface,
3403 TestOOP_IClassFactory_AddRef,
3404 TestOOP_IClassFactory_Release,
3405 TestOOP_IClassFactory_CreateInstance,
3406 TestOOP_IClassFactory_LockServer
3407 };
3408
3409 static IClassFactory TestOOP_ClassFactory = { &TestClassFactoryOOP_Vtbl };
3410
3411 static void test_register_local_server(void)
3412 {
3413 DWORD cookie;
3414 HRESULT hr;
3415 HANDLE ready_event;
3416 DWORD wait;
3417 HANDLE handles[2];
3418
3419 heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL);
3420 ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
3421 handles[0] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
3422 handles[1] = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event");
3423
3424 again:
3425 hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory,
3426 CLSCTX_LOCAL_SERVER, REGCLS_SINGLEUSE, &cookie);
3427 ok_ole_success(hr, CoRegisterClassObject);
3428
3429 SetEvent(ready_event);
3430
3431 do
3432 {
3433 wait = MsgWaitForMultipleObjects(2, handles, FALSE, 30000, QS_ALLINPUT);
3434 if (wait == WAIT_OBJECT_0+2)
3435 {
3436 MSG msg;
3437
3438 if (PeekMessageA(&msg, NULL, 0, 0, PM_REMOVE))
3439 {
3440 trace("Message 0x%x\n", msg.message);
3441 TranslateMessage(&msg);
3442 DispatchMessageA(&msg);
3443 }
3444 }
3445 else if (wait == WAIT_OBJECT_0+1)
3446 {
3447 hr = CoRevokeClassObject(cookie);
3448 ok_ole_success(hr, CoRevokeClassObject);
3449 goto again;
3450 }
3451 }
3452 while (wait == WAIT_OBJECT_0+2);
3453
3454 ok( wait == WAIT_OBJECT_0, "quit event wait timed out\n" );
3455 hr = CoRevokeClassObject(cookie);
3456 ok_ole_success(hr, CoRevokeClassObject);
3457 CloseHandle(handles[0]);
3458 CloseHandle(handles[1]);
3459 }
3460
3461 static HANDLE create_target_process(const char *arg)
3462 {
3463 char **argv;
3464 char cmdline[MAX_PATH];
3465 BOOL ret;
3466 PROCESS_INFORMATION pi;
3467 STARTUPINFOA si = { 0 };
3468 si.cb = sizeof(si);
3469
3470 pi.hThread = NULL;
3471 pi.hProcess = NULL;
3472 winetest_get_mainargs( &argv );
3473 sprintf(cmdline, "\"%s\" %s %s", argv[0], argv[1], arg);
3474 ret = CreateProcessA(argv[0], cmdline, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi);
3475 ok(ret, "CreateProcess failed with error: %u\n", GetLastError());
3476 if (pi.hThread) CloseHandle(pi.hThread);
3477 return pi.hProcess;
3478 }
3479
3480 /* tests functions commonly used by out of process COM servers */
3481 static void test_local_server(void)
3482 {
3483 DWORD cookie;
3484 HRESULT hr;
3485 IClassFactory * cf;
3486 IPersist *persist;
3487 DWORD ret;
3488 HANDLE process;
3489 HANDLE quit_event;
3490 HANDLE ready_event;
3491 HANDLE repeat_event;
3492 CLSID clsid;
3493
3494 heventShutdown = CreateEventA(NULL, TRUE, FALSE, NULL);
3495
3496 cLocks = 0;
3497
3498 /* Start the object suspended */
3499 hr = CoRegisterClassObject(&CLSID_WineOOPTest, (IUnknown *)&TestOOP_ClassFactory,
3500 CLSCTX_LOCAL_SERVER, REGCLS_MULTIPLEUSE | REGCLS_SUSPENDED, &cookie);
3501 ok_ole_success(hr, CoRegisterClassObject);
3502
3503 /* ... and CoGetClassObject does not find it and fails when it looks for the
3504 * class in the registry */
3505 hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER,
3506 NULL, &IID_IClassFactory, (LPVOID*)&cf);
3507 ok(hr == REGDB_E_CLASSNOTREG || /* NT */
3508 hr == S_OK /* Win9x */,
3509 "CoGetClassObject should have returned REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
3510
3511 /* Resume the object suspended above ... */
3512 hr = CoResumeClassObjects();
3513 ok_ole_success(hr, CoResumeClassObjects);
3514
3515 /* ... and now it should succeed */
3516 hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER,
3517 NULL, &IID_IClassFactory, (LPVOID*)&cf);
3518 ok_ole_success(hr, CoGetClassObject);
3519
3520 /* Now check the locking is working */
3521 /* NOTE: we are accessing the class directly, not through a proxy */
3522
3523 ok_no_locks();
3524
3525 hr = IClassFactory_LockServer(cf, TRUE);
3526 ok_ole_success(hr, IClassFactory_LockServer);
3527
3528 ok_more_than_one_lock();
3529
3530 IClassFactory_LockServer(cf, FALSE);
3531 ok_ole_success(hr, IClassFactory_LockServer);
3532
3533 ok_no_locks();
3534
3535 IClassFactory_Release(cf);
3536
3537 /* wait for shutdown signal */
3538 ret = WaitForSingleObject(heventShutdown, 0);
3539 ok(ret != WAIT_TIMEOUT, "Server didn't shut down\n");
3540
3541 /* try to connect again after SCM has suspended registered class objects */
3542 hr = CoGetClassObject(&CLSID_WineOOPTest, CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER, NULL,
3543 &IID_IClassFactory, (LPVOID*)&cf);
3544 ok(hr == CO_E_SERVER_STOPPING || /* NT */
3545 hr == REGDB_E_CLASSNOTREG || /* win2k */
3546 hr == S_OK /* Win9x */,
3547 "CoGetClassObject should have returned CO_E_SERVER_STOPPING or REGDB_E_CLASSNOTREG instead of 0x%08x\n", hr);
3548
3549 hr = CoRevokeClassObject(cookie);
3550 ok_ole_success(hr, CoRevokeClassObject);
3551
3552 CloseHandle(heventShutdown);
3553
3554 process = create_target_process("-Embedding");
3555 ok(process != NULL, "couldn't start local server process, error was %d\n", GetLastError());
3556
3557 ready_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Ready Event");
3558 ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" );
3559
3560 hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
3561 ok_ole_success(hr, CoCreateInstance);
3562
3563 IPersist_Release(persist);
3564
3565 hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
3566 ok(hr == REGDB_E_CLASSNOTREG, "Second CoCreateInstance on REGCLS_SINGLEUSE object should have failed\n");
3567
3568 /* Re-register the class and try calling CoDisconnectObject from within a call to that object */
3569 repeat_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Repeat Event");
3570 SetEvent(repeat_event);
3571 CloseHandle(repeat_event);
3572
3573 ok( !WaitForSingleObject(ready_event, 10000), "wait timed out\n" );
3574 CloseHandle(ready_event);
3575
3576 hr = CoCreateInstance(&CLSID_WineOOPTest, NULL, CLSCTX_LOCAL_SERVER, &IID_IPersist, (void **)&persist);
3577 ok_ole_success(hr, CoCreateInstance);
3578
3579 /* GetClassID will call CoDisconnectObject */
3580 IPersist_GetClassID(persist, &clsid);
3581 IPersist_Release(persist);
3582
3583 quit_event = CreateEventA(NULL, FALSE, FALSE, "Wine COM Test Quit Event");
3584 SetEvent(quit_event);
3585
3586 winetest_wait_child_process( process );
3587 <