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