dlls/ole32/tests/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 }