dlls/combase/apartment.c

   1 /*
   2  *      Copyright 1995 Martin von Loewis
   3  *      Copyright 1998 Justin Bradford
   4  *      Copyright 1999 Francis Beaudet
   5  *      Copyright 1999 Sylvain St-Germain
   6  *      Copyright 2002 Marcus Meissner
   7  *      Copyright 2004 Mike Hearn
   8  *      Copyright 2005-2006 Robert Shearman (for CodeWeavers)
   9  *
  10  * This library is free software; you can redistribute it and/or
  11  * modify it under the terms of the GNU Lesser General Public
  12  * License as published by the Free Software Foundation; either
  13  * version 2.1 of the License, or (at your option) any later version.
  14  *
  15  * This library is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  * Lesser General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU Lesser General Public
  21  * License along with this library; if not, write to the Free Software
  22  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  23  *
  24  */
  25
  26 #include <stdarg.h>
  27 #include <assert.h>
  28
  29 #define COBJMACROS
  30 #define NONAMELESSUNION
  31
  32 #include "windef.h"
  33 #include "winbase.h"
  34 #include "servprov.h"
  35
  36 #include "combase_private.h"
  37
  38 #include "wine/debug.h"
  39 #include "wine/list.h"
  40
  41 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  42
  43 enum comclass_threadingmodel
  44 {
  45     ThreadingModel_Apartment = 1,
  46     ThreadingModel_Free      = 2,
  47     ThreadingModel_No        = 3,
  48     ThreadingModel_Both      = 4,
  49     ThreadingModel_Neutral   = 5
  50 };
  51
  52 static struct apartment *mta;
  53 static struct apartment *main_sta; /* the first STA */
  54 static struct list apts = LIST_INIT(apts);
  55
  56 static CRITICAL_SECTION apt_cs;
  57 static CRITICAL_SECTION_DEBUG apt_cs_debug =
  58 {
  59     0, 0, &apt_cs,
  60     { &apt_cs_debug.ProcessLocksList, &apt_cs_debug.ProcessLocksList },
  61       0, 0, { (DWORD_PTR)(__FILE__ ": apt_cs") }
  62 };
  63 static CRITICAL_SECTION apt_cs = { &apt_cs_debug, -1, 0, 0, 0, 0 };
  64
  65 static struct list dlls = LIST_INIT(dlls);
  66
  67 static CRITICAL_SECTION dlls_cs;
  68 static CRITICAL_SECTION_DEBUG dlls_cs_debug =
  69 {
  70     0, 0, &dlls_cs,
  71     { &dlls_cs_debug.ProcessLocksList, &dlls_cs_debug.ProcessLocksList },
  72       0, 0, { (DWORD_PTR)(__FILE__ ": dlls_cs") }
  73 };
  74 static CRITICAL_SECTION dlls_cs = { &dlls_cs_debug, -1, 0, 0, 0, 0 };
  75
  76 typedef HRESULT (WINAPI *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, void **obj);
  77 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
  78
  79 struct opendll
  80 {
  81     LONG refs;
  82     LPWSTR library_name;
  83     HANDLE library;
  84     DllGetClassObjectFunc DllGetClassObject;
  85     DllCanUnloadNowFunc DllCanUnloadNow;
  86     struct list entry;
  87 };
  88
  89 struct apartment_loaded_dll
  90 {
  91     struct list entry;
  92     struct opendll *dll;
  93     DWORD unload_time;
  94     BOOL multi_threaded;
  95 };
  96
  97 static struct opendll *apartment_get_dll(const WCHAR *library_name)
  98 {
  99     struct opendll *ptr, *ret = NULL;
 100
 101     EnterCriticalSection(&dlls_cs);
 102     LIST_FOR_EACH_ENTRY(ptr, &dlls, struct opendll, entry)
 103     {
 104         if (!wcsicmp(library_name, ptr->library_name) &&
 105             (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroyed if == 1 */)
 106         {
 107             ret = ptr;
 108             break;
 109         }
 110     }
 111     LeaveCriticalSection(&dlls_cs);
 112
 113     return ret;
 114 }
 115
 116 /* caller must ensure that library_name is not already in the open dll list */
 117 static HRESULT apartment_add_dll(const WCHAR *library_name, struct opendll **ret)
 118 {
 119     struct opendll *entry;
 120     int len;
 121     HRESULT hr = S_OK;
 122     HANDLE hLibrary;
 123     DllCanUnloadNowFunc DllCanUnloadNow;
 124     DllGetClassObjectFunc DllGetClassObject;
 125
 126     TRACE("%s\n", debugstr_w(library_name));
 127
 128     *ret = apartment_get_dll(library_name);
 129     if (*ret) return S_OK;
 130
 131     /* Load outside of dlls lock to avoid dependency on the loader lock */
 132     hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 133     if (!hLibrary)
 134     {
 135         ERR("couldn't load in-process dll %s\n", debugstr_w(library_name));
 136         /* failure: DLL could not be loaded */
 137         return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
 138     }
 139
 140     /* DllCanUnloadNow is optional */
 141     DllCanUnloadNow = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
 142     DllGetClassObject = (void *)GetProcAddress(hLibrary, "DllGetClassObject");
 143     if (!DllGetClassObject)
 144     {
 145         /* failure: the dll did not export DllGetClassObject */
 146         ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name));
 147         FreeLibrary(hLibrary);
 148         return CO_E_DLLNOTFOUND;
 149     }
 150
 151     EnterCriticalSection(&dlls_cs);
 152
 153     *ret = apartment_get_dll(library_name);
 154     if (*ret)
 155     {
 156         /* another caller to this function already added the dll while we
 157          * weren't in the critical section */
 158         FreeLibrary(hLibrary);
 159     }
 160     else
 161     {
 162         len = lstrlenW(library_name);
 163         entry = heap_alloc(sizeof(*entry));
 164         if (entry)
 165             entry->library_name = heap_alloc((len + 1) * sizeof(WCHAR));
 166         if (entry && entry->library_name)
 167         {
 168             memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
 169             entry->library = hLibrary;
 170             entry->refs = 1;
 171             entry->DllCanUnloadNow = DllCanUnloadNow;
 172             entry->DllGetClassObject = DllGetClassObject;
 173             list_add_tail(&dlls, &entry->entry);
 174             *ret = entry;
 175         }
 176         else
 177         {
 178             heap_free(entry);
 179             hr = E_OUTOFMEMORY;
 180             FreeLibrary(hLibrary);
 181         }
 182     }
 183
 184     LeaveCriticalSection(&dlls_cs);
 185
 186     return hr;
 187 }
 188
 189 /* pass FALSE for free_entry to release a reference without destroying the
 190  * entry if it reaches zero or TRUE otherwise */
 191 static void apartment_release_dll(struct opendll *entry, BOOL free_entry)
 192 {
 193     if (!InterlockedDecrement(&entry->refs) && free_entry)
 194     {
 195         EnterCriticalSection(&dlls_cs);
 196         list_remove(&entry->entry);
 197         LeaveCriticalSection(&dlls_cs);
 198
 199         TRACE("freeing %p\n", entry->library);
 200         FreeLibrary(entry->library);
 201
 202         heap_free(entry->library_name);
 203         heap_free(entry);
 204     }
 205 }
 206
 207 /* frees memory associated with active dll list */
 208 static void apartment_release_dlls(void)
 209 {
 210     struct opendll *entry, *cursor2;
 211     EnterCriticalSection(&dlls_cs);
 212     LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &dlls, struct opendll, entry)
 213     {
 214         list_remove(&entry->entry);
 215         heap_free(entry->library_name);
 216         heap_free(entry);
 217     }
 218     LeaveCriticalSection(&dlls_cs);
 219     DeleteCriticalSection(&dlls_cs);
 220 }
 221
 222 /*
 223  * This is a marshallable object exposing registered local servers.
 224  * IServiceProvider is used only because it happens meet requirements
 225  * and already has proxy/stub code. If more functionality is needed,
 226  * a custom interface may be used instead.
 227  */
 228 struct local_server
 229 {
 230     IServiceProvider IServiceProvider_iface;
 231     LONG refcount;
 232     struct apartment *apt;
 233     IStream *marshal_stream;
 234 };
 235
 236 static inline struct local_server *impl_from_IServiceProvider(IServiceProvider *iface)
 237 {
 238     return CONTAINING_RECORD(iface, struct local_server, IServiceProvider_iface);
 239 }
 240
 241 static HRESULT WINAPI local_server_QueryInterface(IServiceProvider *iface, REFIID riid, void **obj)
 242 {
 243     struct local_server *local_server = impl_from_IServiceProvider(iface);
 244
 245     TRACE("%p, %s, %p\n", iface, debugstr_guid(riid), obj);
 246
 247     if (IsEqualGUID(riid, &IID_IUnknown) ||
 248             IsEqualGUID(riid, &IID_IServiceProvider))
 249     {
 250         *obj = &local_server->IServiceProvider_iface;
 251     }
 252     else
 253     {
 254         *obj = NULL;
 255         return E_NOINTERFACE;
 256     }
 257
 258     IUnknown_AddRef((IUnknown *)*obj);
 259     return S_OK;
 260 }
 261
 262 static ULONG WINAPI local_server_AddRef(IServiceProvider *iface)
 263 {
 264     struct local_server *local_server = impl_from_IServiceProvider(iface);
 265     LONG refcount = InterlockedIncrement(&local_server->refcount);
 266
 267     TRACE("%p, refcount %ld\n", iface, refcount);
 268
 269     return refcount;
 270 }
 271
 272 static ULONG WINAPI local_server_Release(IServiceProvider *iface)
 273 {
 274     struct local_server *local_server = impl_from_IServiceProvider(iface);
 275     LONG refcount = InterlockedDecrement(&local_server->refcount);
 276
 277     TRACE("%p, refcount %ld\n", iface, refcount);
 278
 279     if (!refcount)
 280     {
 281         assert(!local_server->apt);
 282         heap_free(local_server);
 283     }
 284
 285     return refcount;
 286 }
 287
 288 static HRESULT WINAPI local_server_QueryService(IServiceProvider *iface, REFGUID guid, REFIID riid, void **obj)
 289 {
 290     struct local_server *local_server = impl_from_IServiceProvider(iface);
 291     struct apartment *apt = com_get_current_apt();
 292     HRESULT hr = E_FAIL;
 293     IUnknown *unk;
 294
 295     TRACE("%p, %s, %s, %p\n", iface, debugstr_guid(guid), debugstr_guid(riid), obj);
 296
 297     if (!local_server->apt)
 298         return E_UNEXPECTED;
 299
 300     if ((unk = com_get_registered_class_object(apt, guid, CLSCTX_LOCAL_SERVER)))
 301     {
 302         hr = IUnknown_QueryInterface(unk, riid, obj);
 303         IUnknown_Release(unk);
 304     }
 305
 306     return hr;
 307 }
 308
 309 static const IServiceProviderVtbl local_server_vtbl =
 310 {
 311     local_server_QueryInterface,
 312     local_server_AddRef,
 313     local_server_Release,
 314     local_server_QueryService
 315 };
 316
 317 HRESULT apartment_get_local_server_stream(struct apartment *apt, IStream **ret)
 318 {
 319     HRESULT hr = S_OK;
 320
 321     EnterCriticalSection(&apt->cs);
 322
 323     if (!apt->local_server)
 324     {
 325         struct local_server *obj;
 326
 327         obj = heap_alloc(sizeof(*obj));
 328         if (obj)
 329         {
 330             obj->IServiceProvider_iface.lpVtbl = &local_server_vtbl;
 331             obj->refcount = 1;
 332             obj->apt = apt;
 333
 334             hr = CreateStreamOnHGlobal(0, TRUE, &obj->marshal_stream);
 335             if (SUCCEEDED(hr))
 336             {
 337                 hr = CoMarshalInterface(obj->marshal_stream, &IID_IServiceProvider, (IUnknown *)&obj->IServiceProvider_iface,
 338                         MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
 339                 if (FAILED(hr))
 340                     IStream_Release(obj->marshal_stream);
 341             }
 342
 343             if (SUCCEEDED(hr))
 344                 apt->local_server = obj;
 345             else
 346                 heap_free(obj);
 347         }
 348         else
 349             hr = E_OUTOFMEMORY;
 350     }
 351
 352     if (SUCCEEDED(hr))
 353         hr = IStream_Clone(apt->local_server->marshal_stream, ret);
 354
 355     LeaveCriticalSection(&apt->cs);
 356
 357     if (FAILED(hr))
 358         ERR("Failed: %#lx\n", hr);
 359
 360     return hr;
 361 }
 362
 363 /* Creates new apartment for given model */
 364 static struct apartment *apartment_construct(DWORD model)
 365 {
 366     struct apartment *apt;
 367
 368     TRACE("creating new apartment, model %ld\n", model);
 369
 370     apt = heap_alloc_zero(sizeof(*apt));
 371     apt->tid = GetCurrentThreadId();
 372
 373     list_init(&apt->proxies);
 374     list_init(&apt->stubmgrs);
 375     list_init(&apt->loaded_dlls);
 376     list_init(&apt->usage_cookies);
 377     apt->ipidc = 0;
 378     apt->refs = 1;
 379     apt->remunk_exported = FALSE;
 380     apt->oidc = 1;
 381     InitializeCriticalSection(&apt->cs);
 382     apt->cs.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": apartment");
 383
 384     apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
 385
 386     if (apt->multi_threaded)
 387     {
 388         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 389         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
 390     }
 391     else
 392     {
 393         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 394         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
 395     }
 396
 397     TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 398
 399     list_add_head(&apts, &apt->entry);
 400
 401     return apt;
 402 }
 403
 404 /* Frees unused libraries loaded into apartment */
 405 void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay)
 406 {
 407     struct apartment_loaded_dll *entry, *next;
 408
 409     EnterCriticalSection(&apt->cs);
 410     LIST_FOR_EACH_ENTRY_SAFE(entry, next, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
 411     {
 412         if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
 413         {
 414             DWORD real_delay = delay;
 415
 416             if (real_delay == INFINITE)
 417             {
 418                 /* DLLs that return multi-threaded objects aren't unloaded
 419                  * straight away to cope for programs that have races between
 420                  * last object destruction and threads in the DLLs that haven't
 421                  * finished, despite DllCanUnloadNow returning S_OK */
 422                 if (entry->multi_threaded)
 423                     real_delay = 10 * 60 * 1000; /* 10 minutes */
 424                 else
 425                     real_delay = 0;
 426             }
 427
 428             if (!real_delay || (entry->unload_time && ((int)(GetTickCount() - entry->unload_time) > 0)))
 429             {
 430                 list_remove(&entry->entry);
 431                 apartment_release_dll(entry->dll, TRUE);
 432                 heap_free(entry);
 433             }
 434             else
 435             {
 436                 entry->unload_time = GetTickCount() + real_delay;
 437                 if (!entry->unload_time) entry->unload_time = 1;
 438             }
 439         }
 440         else if (entry->unload_time)
 441             entry->unload_time = 0;
 442     }
 443     LeaveCriticalSection(&apt->cs);
 444 }
 445
 446 void apartment_release(struct apartment *apt)
 447 {
 448     DWORD refcount;
 449
 450     EnterCriticalSection(&apt_cs);
 451
 452     refcount = InterlockedDecrement(&apt->refs);
 453     TRACE("%s: after = %ld\n", wine_dbgstr_longlong(apt->oxid), refcount);
 454
 455     if (apt->being_destroyed)
 456     {
 457         LeaveCriticalSection(&apt_cs);
 458         return;
 459     }
 460
 461     /* destruction stuff that needs to happen under global */
 462     if (!refcount)
 463     {
 464         apt->being_destroyed = TRUE;
 465         if (apt == mta) mta = NULL;
 466         else if (apt == main_sta) main_sta = NULL;
 467         list_remove(&apt->entry);
 468     }
 469
 470     LeaveCriticalSection(&apt_cs);
 471
 472     if (!refcount)
 473     {
 474         struct list *cursor, *cursor2;
 475
 476         TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
 477
 478         if (apt->local_server)
 479         {
 480             struct local_server *local_server = apt->local_server;
 481             LARGE_INTEGER zero;
 482
 483             memset(&zero, 0, sizeof(zero));
 484             IStream_Seek(local_server->marshal_stream, zero, STREAM_SEEK_SET, NULL);
 485             CoReleaseMarshalData(local_server->marshal_stream);
 486             IStream_Release(local_server->marshal_stream);
 487             local_server->marshal_stream = NULL;
 488
 489             apt->local_server = NULL;
 490             local_server->apt = NULL;
 491             IServiceProvider_Release(&local_server->IServiceProvider_iface);
 492         }
 493
 494         /* Release the references to the registered class objects */
 495         apartment_revoke_all_classes(apt);
 496
 497         /* no locking is needed for this apartment, because no other thread
 498          * can access it at this point */
 499
 500         apartment_disconnectproxies(apt);
 501
 502         if (apt->win) DestroyWindow(apt->win);
 503         if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
 504
 505         LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
 506         {
 507             struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
 508             /* release the implicit reference given by the fact that the
 509              * stub has external references (it must do since it is in the
 510              * stub manager list in the apartment and all non-apartment users
 511              * must have a ref on the apartment and so it cannot be destroyed).
 512              */
 513             stub_manager_int_release(stubmgr);
 514         }
 515
 516         /* if this assert fires, then another thread took a reference to a
 517          * stub manager without taking a reference to the containing
 518          * apartment, which it must do. */
 519         assert(list_empty(&apt->stubmgrs));
 520
 521         if (apt->filter) IMessageFilter_Release(apt->filter);
 522
 523         /* free as many unused libraries as possible... */
 524         apartment_freeunusedlibraries(apt, 0);
 525
 526         /* ... and free the memory for the apartment loaded dll entry and
 527          * release the dll list reference without freeing the library for the
 528          * rest */
 529         while ((cursor = list_head(&apt->loaded_dlls)))
 530         {
 531             struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
 532             apartment_release_dll(apartment_loaded_dll->dll, FALSE);
 533             list_remove(cursor);
 534             heap_free(apartment_loaded_dll);
 535         }
 536
 537         apt->cs.DebugInfo->Spare[0] = 0;
 538         DeleteCriticalSection(&apt->cs);
 539
 540         heap_free(apt);
 541     }
 542 }
 543
 544 static DWORD apartment_addref(struct apartment *apt)
 545 {
 546     DWORD refs = InterlockedIncrement(&apt->refs);
 547     TRACE("%s: before = %ld\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
 548     return refs;
 549 }
 550
 551 /* Gets existing apartment or creates a new one and enters it */
 552 static struct apartment *apartment_get_or_create(DWORD model)
 553 {
 554     struct apartment *apt = com_get_current_apt();
 555     struct tlsdata *data;
 556
 557     if (!apt)
 558     {
 559         com_get_tlsdata(&data);
 560
 561         if (model & COINIT_APARTMENTTHREADED)
 562         {
 563             EnterCriticalSection(&apt_cs);
 564
 565             apt = apartment_construct(model);
 566             if (!main_sta)
 567             {
 568                 main_sta = apt;
 569                 apt->main = TRUE;
 570                 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 571             }
 572
 573             data->flags |= OLETLS_APARTMENTTHREADED;
 574             if (model & COINIT_DISABLE_OLE1DDE)
 575                 data->flags |= OLETLS_DISABLE_OLE1DDE;
 576
 577             LeaveCriticalSection(&apt_cs);
 578
 579             if (apt->main)
 580                 apartment_createwindowifneeded(apt);
 581         }
 582         else
 583         {
 584             EnterCriticalSection(&apt_cs);
 585
 586             /* The multi-threaded apartment (MTA) contains zero or more threads interacting
 587              * with free threaded (ie thread safe) COM objects. There is only ever one MTA
 588              * in a process */
 589             if (mta)
 590             {
 591                 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(mta->oxid));
 592                 apartment_addref(mta);
 593             }
 594             else
 595                 mta = apartment_construct(model);
 596
 597             data->flags |= OLETLS_MULTITHREADED | OLETLS_DISABLE_OLE1DDE;
 598
 599             apt = mta;
 600
 601             LeaveCriticalSection(&apt_cs);
 602         }
 603         data->apt = apt;
 604     }
 605
 606     return apt;
 607 }
 608
 609 struct apartment * apartment_get_mta(void)
 610 {
 611     struct apartment *apt;
 612
 613     EnterCriticalSection(&apt_cs);
 614
 615     if ((apt = mta))
 616         apartment_addref(apt);
 617
 618     LeaveCriticalSection(&apt_cs);
 619
 620     return apt;
 621 }
 622
 623 /* Return the current apartment if it exists, or, failing that, the MTA. Caller
 624  * must free the returned apartment in either case. */
 625 struct apartment * apartment_get_current_or_mta(void)
 626 {
 627     struct apartment *apt = com_get_current_apt();
 628     if (apt)
 629     {
 630         apartment_addref(apt);
 631         return apt;
 632     }
 633     return apartment_get_mta();
 634 }
 635
 636 /* The given OXID must be local to this process */
 637 struct apartment * apartment_findfromoxid(OXID oxid)
 638 {
 639     struct apartment *result = NULL, *apt;
 640
 641     EnterCriticalSection(&apt_cs);
 642     LIST_FOR_EACH_ENTRY(apt, &apts, struct apartment, entry)
 643     {
 644         if (apt->oxid == oxid)
 645         {
 646             result = apt;
 647             apartment_addref(result);
 648             break;
 649         }
 650     }
 651     LeaveCriticalSection(&apt_cs);
 652
 653     return result;
 654 }
 655
 656 /* gets the apartment which has a given creator thread ID. The caller must
 657  * release the reference from the apartment as soon as the apartment pointer
 658  * is no longer required. */
 659 struct apartment * apartment_findfromtid(DWORD tid)
 660 {
 661     struct apartment *result = NULL, *apt;
 662
 663     EnterCriticalSection(&apt_cs);
 664     LIST_FOR_EACH_ENTRY(apt, &apts, struct apartment, entry)
 665     {
 666         if (apt != mta && apt->tid == tid)
 667         {
 668             result = apt;
 669             apartment_addref(result);
 670             break;
 671         }
 672     }
 673
 674     if (!result && mta && mta->tid == tid)
 675     {
 676         result = mta;
 677         apartment_addref(result);
 678     }
 679
 680     LeaveCriticalSection(&apt_cs);
 681
 682     return result;
 683 }
 684
 685 /* gets the main apartment if it exists. The caller must
 686  * release the reference from the apartment as soon as the apartment pointer
 687  * is no longer required. */
 688 static struct apartment *apartment_findmain(void)
 689 {
 690     struct apartment *result;
 691
 692     EnterCriticalSection(&apt_cs);
 693
 694     result = main_sta;
 695     if (result) apartment_addref(result);
 696
 697     LeaveCriticalSection(&apt_cs);
 698
 699     return result;
 700 }
 701
 702 struct host_object_params
 703 {
 704     struct class_reg_data regdata;
 705     CLSID clsid; /* clsid of object to marshal */
 706     IID iid; /* interface to marshal */
 707     HANDLE event; /* event signalling when ready for multi-threaded case */
 708     HRESULT hr; /* result for multi-threaded case */
 709     IStream *stream; /* stream that the object will be marshaled into */
 710     BOOL apartment_threaded; /* is the component purely apartment-threaded? */
 711 };
 712
 713 /* Returns expanded dll path from the registry or activation context. */
 714 static BOOL get_object_dll_path(const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen)
 715 {
 716     DWORD ret;
 717
 718     if (regdata->origin == CLASS_REG_REGISTRY)
 719     {
 720         DWORD keytype;
 721         WCHAR src[MAX_PATH];
 722         DWORD dwLength = dstlen * sizeof(WCHAR);
 723
 724         if ((ret = RegQueryValueExW(regdata->u.hkey, NULL, NULL, &keytype, (BYTE*)src, &dwLength)) == ERROR_SUCCESS)
 725         {
 726             if (keytype == REG_EXPAND_SZ)
 727             {
 728                 if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
 729             }
 730             else
 731             {
 732                 const WCHAR *quote_start;
 733                 quote_start = wcschr(src, '\"');
 734                 if (quote_start)
 735                 {
 736                     const WCHAR *quote_end = wcschr(quote_start + 1, '\"');
 737                     if (quote_end)
 738                     {
 739                         memmove(src, quote_start + 1, (quote_end - quote_start - 1) * sizeof(WCHAR));
 740                         src[quote_end - quote_start - 1] = '\0';
 741                     }
 742                 }
 743                 lstrcpynW(dst, src, dstlen);
 744             }
 745         }
 746         return !ret;
 747     }
 748     else
 749     {
 750         ULONG_PTR cookie;
 751
 752         *dst = 0;
 753         ActivateActCtx(regdata->u.actctx.hactctx, &cookie);
 754         ret = SearchPathW(NULL, regdata->u.actctx.module_name, L".dll", dstlen, dst, NULL);
 755         DeactivateActCtx(0, cookie);
 756         return *dst != 0;
 757     }
 758 }
 759
 760 /* gets the specified class object by loading the appropriate DLL, if
 761  * necessary and calls the DllGetClassObject function for the DLL */
 762 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
 763                                         BOOL apartment_threaded,
 764                                         REFCLSID rclsid, REFIID riid, void **ppv)
 765 {
 766     HRESULT hr = S_OK;
 767     BOOL found = FALSE;
 768     struct apartment_loaded_dll *apartment_loaded_dll;
 769
 770     if (!wcsicmp(dllpath, L"ole32.dll"))
 771     {
 772         HRESULT (WINAPI *p_ole32_DllGetClassObject)(REFCLSID clsid, REFIID riid, void **obj);
 773
 774         p_ole32_DllGetClassObject = (void *)GetProcAddress(GetModuleHandleW(L"ole32.dll"), "DllGetClassObject");
 775
 776         /* we don't need to control the lifetime of this dll, so use the local
 777          * implementation of DllGetClassObject directly */
 778         TRACE("calling ole32!DllGetClassObject\n");
 779         hr = p_ole32_DllGetClassObject(rclsid, riid, ppv);
 780
 781         if (hr != S_OK)
 782             ERR("DllGetClassObject returned error %#lx for dll %s\n", hr, debugstr_w(dllpath));
 783
 784         return hr;
 785     }
 786
 787     EnterCriticalSection(&apt->cs);
 788
 789     LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
 790         if (!wcsicmp(dllpath, apartment_loaded_dll->dll->library_name))
 791         {
 792             TRACE("found %s already loaded\n", debugstr_w(dllpath));
 793             found = TRUE;
 794             break;
 795         }
 796
 797     if (!found)
 798     {
 799         apartment_loaded_dll = heap_alloc(sizeof(*apartment_loaded_dll));
 800         if (!apartment_loaded_dll)
 801             hr = E_OUTOFMEMORY;
 802         if (SUCCEEDED(hr))
 803         {
 804             apartment_loaded_dll->unload_time = 0;
 805             apartment_loaded_dll->multi_threaded = FALSE;
 806             hr = apartment_add_dll(dllpath, &apartment_loaded_dll->dll);
 807             if (FAILED(hr))
 808                 heap_free(apartment_loaded_dll);
 809         }
 810         if (SUCCEEDED(hr))
 811         {
 812             TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
 813             list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
 814         }
 815     }
 816
 817     LeaveCriticalSection(&apt->cs);
 818
 819     if (SUCCEEDED(hr))
 820     {
 821         /* one component being multi-threaded overrides any number of
 822          * apartment-threaded components */
 823         if (!apartment_threaded)
 824             apartment_loaded_dll->multi_threaded = TRUE;
 825
 826         TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
 827         /* OK: get the ClassObject */
 828         hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
 829
 830         if (hr != S_OK)
 831             ERR("DllGetClassObject returned error %#lx for dll %s\n", hr, debugstr_w(dllpath));
 832     }
 833
 834     return hr;
 835 }
 836
 837 static HRESULT apartment_hostobject(struct apartment *apt,
 838                                     const struct host_object_params *params);
 839
 840 struct host_thread_params
 841 {
 842     COINIT threading_model;
 843     HANDLE ready_event;
 844     HWND apartment_hwnd;
 845 };
 846
 847 /* thread for hosting an object to allow an object to appear to be created in
 848  * an apartment with an incompatible threading model */
 849 static DWORD CALLBACK apartment_hostobject_thread(void *p)
 850 {
 851     struct host_thread_params *params = p;
 852     MSG msg;
 853     HRESULT hr;
 854     struct apartment *apt;
 855
 856     TRACE("\n");
 857
 858     hr = CoInitializeEx(NULL, params->threading_model);
 859     if (FAILED(hr)) return hr;
 860
 861     apt = com_get_current_apt();
 862     if (params->threading_model == COINIT_APARTMENTTHREADED)
 863     {
 864         apartment_createwindowifneeded(apt);
 865         params->apartment_hwnd = apartment_getwindow(apt);
 866     }
 867     else
 868         params->apartment_hwnd = NULL;
 869
 870     /* force the message queue to be created before signaling parent thread */
 871     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 872
 873     SetEvent(params->ready_event);
 874     params = NULL; /* can't touch params after here as it may be invalid */
 875
 876     while (GetMessageW(&msg, NULL, 0, 0))
 877     {
 878         if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
 879         {
 880             struct host_object_params *obj_params = (struct host_object_params *)msg.lParam;
 881             obj_params->hr = apartment_hostobject(apt, obj_params);
 882             SetEvent(obj_params->event);
 883         }
 884         else
 885         {
 886             TranslateMessage(&msg);
 887             DispatchMessageW(&msg);
 888         }
 889     }
 890
 891     TRACE("exiting\n");
 892
 893     CoUninitialize();
 894
 895     return S_OK;
 896 }
 897
 898 /* finds or creates a host apartment, creates the object inside it and returns
 899  * a proxy to it so that the object can be used in the apartment of the
 900  * caller of this function */
 901 static HRESULT apartment_hostobject_in_hostapt(struct apartment *apt, BOOL multi_threaded,
 902         BOOL main_apartment, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, void **ppv)
 903 {
 904     struct host_object_params params;
 905     HWND apartment_hwnd = NULL;
 906     DWORD apartment_tid = 0;
 907     HRESULT hr;
 908
 909     if (!multi_threaded && main_apartment)
 910     {
 911         struct apartment *host_apt = apartment_findmain();
 912         if (host_apt)
 913         {
 914             apartment_hwnd = apartment_getwindow(host_apt);
 915             apartment_release(host_apt);
 916         }
 917     }
 918
 919     if (!apartment_hwnd)
 920     {
 921         EnterCriticalSection(&apt->cs);
 922
 923         if (!apt->host_apt_tid)
 924         {
 925             struct host_thread_params thread_params;
 926             HANDLE handles[2];
 927             DWORD wait_value;
 928
 929             thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
 930             handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 931             thread_params.apartment_hwnd = NULL;
 932             handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
 933             if (!handles[1])
 934             {
 935                 CloseHandle(handles[0]);
 936                 LeaveCriticalSection(&apt->cs);
 937                 return E_OUTOFMEMORY;
 938             }
 939             wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 940             CloseHandle(handles[0]);
 941             CloseHandle(handles[1]);
 942             if (wait_value == WAIT_OBJECT_0)
 943                 apt->host_apt_hwnd = thread_params.apartment_hwnd;
 944             else
 945             {
 946                 LeaveCriticalSection(&apt->cs);
 947                 return E_OUTOFMEMORY;
 948             }
 949         }
 950
 951         if (multi_threaded || !main_apartment)
 952         {
 953             apartment_hwnd = apt->host_apt_hwnd;
 954             apartment_tid = apt->host_apt_tid;
 955         }
 956
 957         LeaveCriticalSection(&apt->cs);
 958     }
 959
 960     /* another thread may have become the main apartment in the time it took
 961      * us to create the thread for the host apartment */
 962     if (!apartment_hwnd && !multi_threaded && main_apartment)
 963     {
 964         struct apartment *host_apt = apartment_findmain();
 965         if (host_apt)
 966         {
 967             apartment_hwnd = apartment_getwindow(host_apt);
 968             apartment_release(host_apt);
 969         }
 970     }
 971
 972     params.regdata = *regdata;
 973     params.clsid = *rclsid;
 974     params.iid = *riid;
 975     hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
 976     if (FAILED(hr))
 977         return hr;
 978     params.apartment_threaded = !multi_threaded;
 979     if (multi_threaded)
 980     {
 981         params.hr = S_OK;
 982         params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
 983         if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
 984             hr = E_OUTOFMEMORY;
 985         else
 986         {
 987             WaitForSingleObject(params.event, INFINITE);
 988             hr = params.hr;
 989         }
 990         CloseHandle(params.event);
 991     }
 992     else
 993     {
 994         if (!apartment_hwnd)
 995         {
 996             ERR("host apartment didn't create window\n");
 997             hr = E_OUTOFMEMORY;
 998         }
 999         else
1000             hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
1001     }
1002     if (SUCCEEDED(hr))
1003         hr = CoUnmarshalInterface(params.stream, riid, ppv);
1004     IStream_Release(params.stream);
1005     return hr;
1006 }
1007
1008 static enum comclass_threadingmodel get_threading_model(const struct class_reg_data *data)
1009 {
1010     if (data->origin == CLASS_REG_REGISTRY)
1011     {
1012         WCHAR threading_model[10 /* lstrlenW(L"apartment")+1 */];
1013         DWORD dwLength = sizeof(threading_model);
1014         DWORD keytype;
1015         DWORD ret;
1016
1017         ret = RegQueryValueExW(data->u.hkey, L"ThreadingModel", NULL, &keytype, (BYTE*)threading_model, &dwLength);
1018         if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
1019             threading_model[0] = '\0';
1020
1021         if (!wcsicmp(threading_model, L"Apartment")) return ThreadingModel_Apartment;
1022         if (!wcsicmp(threading_model, L"Free")) return ThreadingModel_Free;
1023         if (!wcsicmp(threading_model, L"Both")) return ThreadingModel_Both;
1024
1025         /* there's not specific handling for this case */
1026         if (threading_model[0]) return ThreadingModel_Neutral;
1027         return ThreadingModel_No;
1028     }
1029     else
1030         return data->u.actctx.threading_model;
1031 }
1032
1033 HRESULT apartment_get_inproc_class_object(struct apartment *apt, const struct class_reg_data *regdata,
1034         REFCLSID rclsid, REFIID riid, DWORD class_context, void **ppv)
1035 {
1036     WCHAR dllpath[MAX_PATH+1];
1037     BOOL apartment_threaded;
1038
1039     if (!(class_context & CLSCTX_PS_DLL))
1040     {
1041         enum comclass_threadingmodel model = get_threading_model(regdata);
1042
1043         if (model == ThreadingModel_Apartment)
1044         {
1045             apartment_threaded = TRUE;
1046             if (apt->multi_threaded)
1047                 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, regdata, rclsid, riid, ppv);
1048         }
1049         else if (model == ThreadingModel_Free)
1050         {
1051             apartment_threaded = FALSE;
1052             if (!apt->multi_threaded)
1053                 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, regdata, rclsid, riid, ppv);
1054         }
1055         /* everything except "Apartment", "Free" and "Both" */
1056         else if (model != ThreadingModel_Both)
1057         {
1058             apartment_threaded = TRUE;
1059             /* everything else is main-threaded */
1060             if (model != ThreadingModel_No)
1061                 FIXME("unrecognised threading model %d for object %s, should be main-threaded?\n", model, debugstr_guid(rclsid));
1062
1063             if (apt->multi_threaded || !apt->main)
1064                 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, regdata, rclsid, riid, ppv);
1065         }
1066         else
1067             apartment_threaded = FALSE;
1068     }
1069     else
1070         apartment_threaded = !apt->multi_threaded;
1071
1072     if (!get_object_dll_path(regdata, dllpath, ARRAY_SIZE(dllpath)))
1073     {
1074         /* failure: CLSID is not found in registry */
1075         WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
1076         return REGDB_E_CLASSNOTREG;
1077     }
1078
1079     return apartment_getclassobject(apt, dllpath, apartment_threaded, rclsid, riid, ppv);
1080 }
1081
1082 static HRESULT apartment_hostobject(struct apartment *apt, const struct host_object_params *params)
1083 {
1084     static const LARGE_INTEGER llZero;
1085     WCHAR dllpath[MAX_PATH+1];
1086     IUnknown *object;
1087     HRESULT hr;
1088
1089     TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
1090
1091     if (!get_object_dll_path(&params->regdata, dllpath, ARRAY_SIZE(dllpath)))
1092     {
1093         /* failure: CLSID is not found in registry */
1094         WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
1095         return REGDB_E_CLASSNOTREG;
1096     }
1097
1098     hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded, &params->clsid, &params->iid, (void **)&object);
1099     if (FAILED(hr))
1100         return hr;
1101
1102     hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1103     if (FAILED(hr))
1104         IUnknown_Release(object);
1105     IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
1106
1107     return hr;
1108 }
1109
1110 struct dispatch_params;
1111
1112 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1113 {
1114     switch (msg)
1115     {
1116     case DM_EXECUTERPC:
1117         rpc_execute_call((struct dispatch_params *)lParam);
1118         return 0;
1119     case DM_HOSTOBJECT:
1120         return apartment_hostobject(com_get_current_apt(), (const struct host_object_params *)lParam);
1121     default:
1122         return DefWindowProcW(hWnd, msg, wParam, lParam);
1123     }
1124 }
1125
1126 static BOOL apartment_is_model(const struct apartment *apt, DWORD model)
1127 {
1128     return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
1129 }
1130
1131 HRESULT enter_apartment(struct tlsdata *data, DWORD model)
1132 {
1133     HRESULT hr = S_OK;
1134
1135     if (!data->apt)
1136     {
1137         if (!apartment_get_or_create(model))
1138             return E_OUTOFMEMORY;
1139     }
1140     else if (!apartment_is_model(data->apt, model))
1141     {
1142         WARN("Attempt to change threading model of this apartment from %s to %s\n",
1143               data->apt->multi_threaded ? "multi-threaded" : "apartment threaded",
1144               model & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded" );
1145         return RPC_E_CHANGED_MODE;
1146     }
1147     else
1148         hr = S_FALSE;
1149
1150     data->inits++;
1151
1152     return hr;
1153 }
1154
1155 void leave_apartment(struct tlsdata *data)
1156 {
1157     if (!--data->inits)
1158     {
1159         if (data->ole_inits)
1160             WARN( "Uninitializing apartment while Ole is still initialized\n" );
1161         apartment_release(data->apt);
1162         data->apt = NULL;
1163         data->flags &= ~(OLETLS_DISABLE_OLE1DDE | OLETLS_APARTMENTTHREADED | OLETLS_MULTITHREADED);
1164     }
1165 }
1166
1167 struct mta_cookie
1168 {
1169     struct list entry;
1170 };
1171
1172 HRESULT apartment_increment_mta_usage(CO_MTA_USAGE_COOKIE *cookie)
1173 {
1174     struct mta_cookie *mta_cookie;
1175
1176     *cookie = NULL;
1177
1178     if (!(mta_cookie = heap_alloc(sizeof(*mta_cookie))))
1179         return E_OUTOFMEMORY;
1180
1181     EnterCriticalSection(&apt_cs);
1182
1183     if (mta)
1184         apartment_addref(mta);
1185     else
1186         mta = apartment_construct(COINIT_MULTITHREADED);
1187     list_add_head(&mta->usage_cookies, &mta_cookie->entry);
1188
1189     LeaveCriticalSection(&apt_cs);
1190
1191     *cookie = (CO_MTA_USAGE_COOKIE)mta_cookie;
1192
1193     return S_OK;
1194 }
1195
1196 void apartment_decrement_mta_usage(CO_MTA_USAGE_COOKIE cookie)
1197 {
1198     struct mta_cookie *mta_cookie = (struct mta_cookie *)cookie;
1199
1200     EnterCriticalSection(&apt_cs);
1201
1202     if (mta)
1203     {
1204         struct mta_cookie *cur;
1205
1206         LIST_FOR_EACH_ENTRY(cur, &mta->usage_cookies, struct mta_cookie, entry)
1207         {
1208             if (mta_cookie == cur)
1209             {
1210                 list_remove(&cur->entry);
1211                 heap_free(cur);
1212                 apartment_release(mta);
1213                 break;
1214             }
1215         }
1216     }
1217
1218     LeaveCriticalSection(&apt_cs);
1219 }
1220
1221 static const WCHAR aptwinclassW[] = L"OleMainThreadWndClass";
1222 static ATOM apt_win_class;
1223
1224 static BOOL WINAPI register_class( INIT_ONCE *once, void *param, void **context )
1225 {
1226     WNDCLASSW wclass;
1227
1228     /* Dispatching to the correct thread in an apartment is done through
1229      * window messages rather than RPC transports. When an interface is
1230      * marshalled into another apartment in the same process, a window of the
1231      * following class is created. The *caller* of CoMarshalInterface (i.e., the
1232      * application) is responsible for pumping the message loop in that thread.
1233      * The WM_USER messages which point to the RPCs are then dispatched to
1234      * apartment_wndproc by the user's code from the apartment in which the
1235      * interface was unmarshalled.
1236      */
1237     memset(&wclass, 0, sizeof(wclass));
1238     wclass.lpfnWndProc = apartment_wndproc;
1239     wclass.hInstance = hProxyDll;
1240     wclass.lpszClassName = aptwinclassW;
1241     apt_win_class = RegisterClassW(&wclass);
1242     return TRUE;
1243 }
1244
1245 /* create a window for the apartment or return the current one if one has
1246  * already been created */
1247 HRESULT apartment_createwindowifneeded(struct apartment *apt)
1248 {
1249     static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
1250
1251     if (apt->multi_threaded)
1252         return S_OK;
1253
1254     if (!apt->win)
1255     {
1256         HWND hwnd;
1257
1258         InitOnceExecuteOnce( &class_init_once, register_class, NULL, NULL );
1259
1260         hwnd = CreateWindowW(aptwinclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, hProxyDll, NULL);
1261         if (!hwnd)
1262         {
1263             ERR("CreateWindow failed with error %ld\n", GetLastError());
1264             return HRESULT_FROM_WIN32(GetLastError());
1265         }
1266         if (InterlockedCompareExchangePointer((void **)&apt->win, hwnd, NULL))
1267             /* someone beat us to it */
1268             DestroyWindow(hwnd);
1269     }
1270
1271     return S_OK;
1272 }
1273
1274 /* retrieves the window for the main- or apartment-threaded apartment */
1275 HWND apartment_getwindow(const struct apartment *apt)
1276 {
1277     assert(!apt->multi_threaded);
1278     return apt->win;
1279 }
1280
1281 OXID apartment_getoxid(const struct apartment *apt)
1282 {
1283     return apt->oxid;
1284 }
1285
1286 void apartment_global_cleanup(void)
1287 {
1288     if (apt_win_class)
1289         UnregisterClassW((const WCHAR *)MAKEINTATOM(apt_win_class), hProxyDll);
1290     apartment_release_dlls();
1291     DeleteCriticalSection(&apt_cs);
1292 }