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 %d\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 %d\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: %#x\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 %d\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 = %d\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 = %d\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->tid == tid)
 667         {
 668             result = apt;
 669             apartment_addref(result);
 670             break;
 671         }
 672     }
 673     LeaveCriticalSection(&apt_cs);
 674
 675     return result;
 676 }
 677
 678 /* gets the main apartment if it exists. The caller must
 679  * release the reference from the apartment as soon as the apartment pointer
 680  * is no longer required. */
 681 static struct apartment *apartment_findmain(void)
 682 {
 683     struct apartment *result;
 684
 685     EnterCriticalSection(&apt_cs);
 686
 687     result = main_sta;
 688     if (result) apartment_addref(result);
 689
 690     LeaveCriticalSection(&apt_cs);
 691
 692     return result;
 693 }
 694
 695 struct host_object_params
 696 {
 697     struct class_reg_data regdata;
 698     CLSID clsid; /* clsid of object to marshal */
 699     IID iid; /* interface to marshal */
 700     HANDLE event; /* event signalling when ready for multi-threaded case */
 701     HRESULT hr; /* result for multi-threaded case */
 702     IStream *stream; /* stream that the object will be marshaled into */
 703     BOOL apartment_threaded; /* is the component purely apartment-threaded? */
 704 };
 705
 706 /* Returns expanded dll path from the registry or activation context. */
 707 static BOOL get_object_dll_path(const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen)
 708 {
 709     DWORD ret;
 710
 711     if (regdata->origin == CLASS_REG_REGISTRY)
 712     {
 713         DWORD keytype;
 714         WCHAR src[MAX_PATH];
 715         DWORD dwLength = dstlen * sizeof(WCHAR);
 716
 717         if ((ret = RegQueryValueExW(regdata->u.hkey, NULL, NULL, &keytype, (BYTE*)src, &dwLength)) == ERROR_SUCCESS)
 718         {
 719             if (keytype == REG_EXPAND_SZ)
 720             {
 721                 if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
 722             }
 723             else
 724             {
 725                 const WCHAR *quote_start;
 726                 quote_start = wcschr(src, '\"');
 727                 if (quote_start)
 728                 {
 729                     const WCHAR *quote_end = wcschr(quote_start + 1, '\"');
 730                     if (quote_end)
 731                     {
 732                         memmove(src, quote_start + 1, (quote_end - quote_start - 1) * sizeof(WCHAR));
 733                         src[quote_end - quote_start - 1] = '\0';
 734                     }
 735                 }
 736                 lstrcpynW(dst, src, dstlen);
 737             }
 738         }
 739         return !ret;
 740     }
 741     else
 742     {
 743         ULONG_PTR cookie;
 744
 745         *dst = 0;
 746         ActivateActCtx(regdata->u.actctx.hactctx, &cookie);
 747         ret = SearchPathW(NULL, regdata->u.actctx.module_name, L".dll", dstlen, dst, NULL);
 748         DeactivateActCtx(0, cookie);
 749         return *dst != 0;
 750     }
 751 }
 752
 753 /* gets the specified class object by loading the appropriate DLL, if
 754  * necessary and calls the DllGetClassObject function for the DLL */
 755 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
 756                                         BOOL apartment_threaded,
 757                                         REFCLSID rclsid, REFIID riid, void **ppv)
 758 {
 759     HRESULT hr = S_OK;
 760     BOOL found = FALSE;
 761     struct apartment_loaded_dll *apartment_loaded_dll;
 762
 763     if (!wcsicmp(dllpath, L"ole32.dll"))
 764     {
 765         HRESULT (WINAPI *p_ole32_DllGetClassObject)(REFCLSID clsid, REFIID riid, void **obj);
 766
 767         p_ole32_DllGetClassObject = (void *)GetProcAddress(GetModuleHandleW(L"ole32.dll"), "DllGetClassObject");
 768
 769         /* we don't need to control the lifetime of this dll, so use the local
 770          * implementation of DllGetClassObject directly */
 771         TRACE("calling ole32!DllGetClassObject\n");
 772         hr = p_ole32_DllGetClassObject(rclsid, riid, ppv);
 773
 774         if (hr != S_OK)
 775             ERR("DllGetClassObject returned error 0x%08x for dll %s\n", hr, debugstr_w(dllpath));
 776
 777         return hr;
 778     }
 779
 780     EnterCriticalSection(&apt->cs);
 781
 782     LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
 783         if (!wcsicmp(dllpath, apartment_loaded_dll->dll->library_name))
 784         {
 785             TRACE("found %s already loaded\n", debugstr_w(dllpath));
 786             found = TRUE;
 787             break;
 788         }
 789
 790     if (!found)
 791     {
 792         apartment_loaded_dll = heap_alloc(sizeof(*apartment_loaded_dll));
 793         if (!apartment_loaded_dll)
 794             hr = E_OUTOFMEMORY;
 795         if (SUCCEEDED(hr))
 796         {
 797             apartment_loaded_dll->unload_time = 0;
 798             apartment_loaded_dll->multi_threaded = FALSE;
 799             hr = apartment_add_dll(dllpath, &apartment_loaded_dll->dll);
 800             if (FAILED(hr))
 801                 heap_free(apartment_loaded_dll);
 802         }
 803         if (SUCCEEDED(hr))
 804         {
 805             TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
 806             list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
 807         }
 808     }
 809
 810     LeaveCriticalSection(&apt->cs);
 811
 812     if (SUCCEEDED(hr))
 813     {
 814         /* one component being multi-threaded overrides any number of
 815          * apartment-threaded components */
 816         if (!apartment_threaded)
 817             apartment_loaded_dll->multi_threaded = TRUE;
 818
 819         TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
 820         /* OK: get the ClassObject */
 821         hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
 822
 823         if (hr != S_OK)
 824             ERR("DllGetClassObject returned error 0x%08x for dll %s\n", hr, debugstr_w(dllpath));
 825     }
 826
 827     return hr;
 828 }
 829
 830 static HRESULT apartment_hostobject(struct apartment *apt,
 831                                     const struct host_object_params *params);
 832
 833 struct host_thread_params
 834 {
 835     COINIT threading_model;
 836     HANDLE ready_event;
 837     HWND apartment_hwnd;
 838 };
 839
 840 /* thread for hosting an object to allow an object to appear to be created in
 841  * an apartment with an incompatible threading model */
 842 static DWORD CALLBACK apartment_hostobject_thread(void *p)
 843 {
 844     struct host_thread_params *params = p;
 845     MSG msg;
 846     HRESULT hr;
 847     struct apartment *apt;
 848
 849     TRACE("\n");
 850
 851     hr = CoInitializeEx(NULL, params->threading_model);
 852     if (FAILED(hr)) return hr;
 853
 854     apt = com_get_current_apt();
 855     if (params->threading_model == COINIT_APARTMENTTHREADED)
 856     {
 857         apartment_createwindowifneeded(apt);
 858         params->apartment_hwnd = apartment_getwindow(apt);
 859     }
 860     else
 861         params->apartment_hwnd = NULL;
 862
 863     /* force the message queue to be created before signaling parent thread */
 864     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 865
 866     SetEvent(params->ready_event);
 867     params = NULL; /* can't touch params after here as it may be invalid */
 868
 869     while (GetMessageW(&msg, NULL, 0, 0))
 870     {
 871         if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
 872         {
 873             struct host_object_params *obj_params = (struct host_object_params *)msg.lParam;
 874             obj_params->hr = apartment_hostobject(apt, obj_params);
 875             SetEvent(obj_params->event);
 876         }
 877         else
 878         {
 879             TranslateMessage(&msg);
 880             DispatchMessageW(&msg);
 881         }
 882     }
 883
 884     TRACE("exiting\n");
 885
 886     CoUninitialize();
 887
 888     return S_OK;
 889 }
 890
 891 /* finds or creates a host apartment, creates the object inside it and returns
 892  * a proxy to it so that the object can be used in the apartment of the
 893  * caller of this function */
 894 static HRESULT apartment_hostobject_in_hostapt(struct apartment *apt, BOOL multi_threaded,
 895         BOOL main_apartment, const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, void **ppv)
 896 {
 897     struct host_object_params params;
 898     HWND apartment_hwnd = NULL;
 899     DWORD apartment_tid = 0;
 900     HRESULT hr;
 901
 902     if (!multi_threaded && main_apartment)
 903     {
 904         struct apartment *host_apt = apartment_findmain();
 905         if (host_apt)
 906         {
 907             apartment_hwnd = apartment_getwindow(host_apt);
 908             apartment_release(host_apt);
 909         }
 910     }
 911
 912     if (!apartment_hwnd)
 913     {
 914         EnterCriticalSection(&apt->cs);
 915
 916         if (!apt->host_apt_tid)
 917         {
 918             struct host_thread_params thread_params;
 919             HANDLE handles[2];
 920             DWORD wait_value;
 921
 922             thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
 923             handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 924             thread_params.apartment_hwnd = NULL;
 925             handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
 926             if (!handles[1])
 927             {
 928                 CloseHandle(handles[0]);
 929                 LeaveCriticalSection(&apt->cs);
 930                 return E_OUTOFMEMORY;
 931             }
 932             wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 933             CloseHandle(handles[0]);
 934             CloseHandle(handles[1]);
 935             if (wait_value == WAIT_OBJECT_0)
 936                 apt->host_apt_hwnd = thread_params.apartment_hwnd;
 937             else
 938             {
 939                 LeaveCriticalSection(&apt->cs);
 940                 return E_OUTOFMEMORY;
 941             }
 942         }
 943
 944         if (multi_threaded || !main_apartment)
 945         {
 946             apartment_hwnd = apt->host_apt_hwnd;
 947             apartment_tid = apt->host_apt_tid;
 948         }
 949
 950         LeaveCriticalSection(&apt->cs);
 951     }
 952
 953     /* another thread may have become the main apartment in the time it took
 954      * us to create the thread for the host apartment */
 955     if (!apartment_hwnd && !multi_threaded && main_apartment)
 956     {
 957         struct apartment *host_apt = apartment_findmain();
 958         if (host_apt)
 959         {
 960             apartment_hwnd = apartment_getwindow(host_apt);
 961             apartment_release(host_apt);
 962         }
 963     }
 964
 965     params.regdata = *regdata;
 966     params.clsid = *rclsid;
 967     params.iid = *riid;
 968     hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
 969     if (FAILED(hr))
 970         return hr;
 971     params.apartment_threaded = !multi_threaded;
 972     if (multi_threaded)
 973     {
 974         params.hr = S_OK;
 975         params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
 976         if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
 977             hr = E_OUTOFMEMORY;
 978         else
 979         {
 980             WaitForSingleObject(params.event, INFINITE);
 981             hr = params.hr;
 982         }
 983         CloseHandle(params.event);
 984     }
 985     else
 986     {
 987         if (!apartment_hwnd)
 988         {
 989             ERR("host apartment didn't create window\n");
 990             hr = E_OUTOFMEMORY;
 991         }
 992         else
 993             hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
 994     }
 995     if (SUCCEEDED(hr))
 996         hr = CoUnmarshalInterface(params.stream, riid, ppv);
 997     IStream_Release(params.stream);
 998     return hr;
 999 }
1000
1001 static enum comclass_threadingmodel get_threading_model(const struct class_reg_data *data)
1002 {
1003     if (data->origin == CLASS_REG_REGISTRY)
1004     {
1005         WCHAR threading_model[10 /* lstrlenW(L"apartment")+1 */];
1006         DWORD dwLength = sizeof(threading_model);
1007         DWORD keytype;
1008         DWORD ret;
1009
1010         ret = RegQueryValueExW(data->u.hkey, L"ThreadingModel", NULL, &keytype, (BYTE*)threading_model, &dwLength);
1011         if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
1012             threading_model[0] = '\0';
1013
1014         if (!wcsicmp(threading_model, L"Apartment")) return ThreadingModel_Apartment;
1015         if (!wcsicmp(threading_model, L"Free")) return ThreadingModel_Free;
1016         if (!wcsicmp(threading_model, L"Both")) return ThreadingModel_Both;
1017
1018         /* there's not specific handling for this case */
1019         if (threading_model[0]) return ThreadingModel_Neutral;
1020         return ThreadingModel_No;
1021     }
1022     else
1023         return data->u.actctx.threading_model;
1024 }
1025
1026 HRESULT apartment_get_inproc_class_object(struct apartment *apt, const struct class_reg_data *regdata,
1027         REFCLSID rclsid, REFIID riid, DWORD class_context, void **ppv)
1028 {
1029     WCHAR dllpath[MAX_PATH+1];
1030     BOOL apartment_threaded;
1031
1032     if (!(class_context & CLSCTX_PS_DLL))
1033     {
1034         enum comclass_threadingmodel model = get_threading_model(regdata);
1035
1036         if (model == ThreadingModel_Apartment)
1037         {
1038             apartment_threaded = TRUE;
1039             if (apt->multi_threaded)
1040                 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, regdata, rclsid, riid, ppv);
1041         }
1042         else if (model == ThreadingModel_Free)
1043         {
1044             apartment_threaded = FALSE;
1045             if (!apt->multi_threaded)
1046                 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, regdata, rclsid, riid, ppv);
1047         }
1048         /* everything except "Apartment", "Free" and "Both" */
1049         else if (model != ThreadingModel_Both)
1050         {
1051             apartment_threaded = TRUE;
1052             /* everything else is main-threaded */
1053             if (model != ThreadingModel_No)
1054                 FIXME("unrecognised threading model %d for object %s, should be main-threaded?\n", model, debugstr_guid(rclsid));
1055
1056             if (apt->multi_threaded || !apt->main)
1057                 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, regdata, rclsid, riid, ppv);
1058         }
1059         else
1060             apartment_threaded = FALSE;
1061     }
1062     else
1063         apartment_threaded = !apt->multi_threaded;
1064
1065     if (!get_object_dll_path(regdata, dllpath, ARRAY_SIZE(dllpath)))
1066     {
1067         /* failure: CLSID is not found in registry */
1068         WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
1069         return REGDB_E_CLASSNOTREG;
1070     }
1071
1072     return apartment_getclassobject(apt, dllpath, apartment_threaded, rclsid, riid, ppv);
1073 }
1074
1075 static HRESULT apartment_hostobject(struct apartment *apt, const struct host_object_params *params)
1076 {
1077     static const LARGE_INTEGER llZero;
1078     WCHAR dllpath[MAX_PATH+1];
1079     IUnknown *object;
1080     HRESULT hr;
1081
1082     TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
1083
1084     if (!get_object_dll_path(&params->regdata, dllpath, ARRAY_SIZE(dllpath)))
1085     {
1086         /* failure: CLSID is not found in registry */
1087         WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
1088         return REGDB_E_CLASSNOTREG;
1089     }
1090
1091     hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded, &params->clsid, &params->iid, (void **)&object);
1092     if (FAILED(hr))
1093         return hr;
1094
1095     hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1096     if (FAILED(hr))
1097         IUnknown_Release(object);
1098     IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
1099
1100     return hr;
1101 }
1102
1103 struct dispatch_params;
1104
1105 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1106 {
1107     switch (msg)
1108     {
1109     case DM_EXECUTERPC:
1110         rpc_execute_call((struct dispatch_params *)lParam);
1111         return 0;
1112     case DM_HOSTOBJECT:
1113         return apartment_hostobject(com_get_current_apt(), (const struct host_object_params *)lParam);
1114     default:
1115         return DefWindowProcW(hWnd, msg, wParam, lParam);
1116     }
1117 }
1118
1119 static BOOL apartment_is_model(const struct apartment *apt, DWORD model)
1120 {
1121     return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
1122 }
1123
1124 HRESULT enter_apartment(struct tlsdata *data, DWORD model)
1125 {
1126     HRESULT hr = S_OK;
1127
1128     if (!data->apt)
1129     {
1130         if (!apartment_get_or_create(model))
1131             return E_OUTOFMEMORY;
1132     }
1133     else if (!apartment_is_model(data->apt, model))
1134     {
1135         WARN("Attempt to change threading model of this apartment from %s to %s\n",
1136               data->apt->multi_threaded ? "multi-threaded" : "apartment threaded",
1137               model & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded" );
1138         return RPC_E_CHANGED_MODE;
1139     }
1140     else
1141         hr = S_FALSE;
1142
1143     data->inits++;
1144
1145     return hr;
1146 }
1147
1148 void leave_apartment(struct tlsdata *data)
1149 {
1150     if (!--data->inits)
1151     {
1152         if (data->ole_inits)
1153             WARN( "Uninitializing apartment while Ole is still initialized\n" );
1154         apartment_release(data->apt);
1155         data->apt = NULL;
1156         data->flags &= ~(OLETLS_DISABLE_OLE1DDE | OLETLS_APARTMENTTHREADED | OLETLS_MULTITHREADED);
1157     }
1158 }
1159
1160 struct mta_cookie
1161 {
1162     struct list entry;
1163 };
1164
1165 HRESULT apartment_increment_mta_usage(CO_MTA_USAGE_COOKIE *cookie)
1166 {
1167     struct mta_cookie *mta_cookie;
1168
1169     *cookie = NULL;
1170
1171     if (!(mta_cookie = heap_alloc(sizeof(*mta_cookie))))
1172         return E_OUTOFMEMORY;
1173
1174     EnterCriticalSection(&apt_cs);
1175
1176     if (mta)
1177         apartment_addref(mta);
1178     else
1179         mta = apartment_construct(COINIT_MULTITHREADED);
1180     list_add_head(&mta->usage_cookies, &mta_cookie->entry);
1181
1182     LeaveCriticalSection(&apt_cs);
1183
1184     *cookie = (CO_MTA_USAGE_COOKIE)mta_cookie;
1185
1186     return S_OK;
1187 }
1188
1189 void apartment_decrement_mta_usage(CO_MTA_USAGE_COOKIE cookie)
1190 {
1191     struct mta_cookie *mta_cookie = (struct mta_cookie *)cookie;
1192
1193     EnterCriticalSection(&apt_cs);
1194
1195     if (mta)
1196     {
1197         struct mta_cookie *cur;
1198
1199         LIST_FOR_EACH_ENTRY(cur, &mta->usage_cookies, struct mta_cookie, entry)
1200         {
1201             if (mta_cookie == cur)
1202             {
1203                 list_remove(&cur->entry);
1204                 heap_free(cur);
1205                 apartment_release(mta);
1206                 break;
1207             }
1208         }
1209     }
1210
1211     LeaveCriticalSection(&apt_cs);
1212 }
1213
1214 static const WCHAR aptwinclassW[] = L"OleMainThreadWndClass";
1215 static ATOM apt_win_class;
1216
1217 static BOOL WINAPI register_class( INIT_ONCE *once, void *param, void **context )
1218 {
1219     WNDCLASSW wclass;
1220
1221     /* Dispatching to the correct thread in an apartment is done through
1222      * window messages rather than RPC transports. When an interface is
1223      * marshalled into another apartment in the same process, a window of the
1224      * following class is created. The *caller* of CoMarshalInterface (i.e., the
1225      * application) is responsible for pumping the message loop in that thread.
1226      * The WM_USER messages which point to the RPCs are then dispatched to
1227      * apartment_wndproc by the user's code from the apartment in which the
1228      * interface was unmarshalled.
1229      */
1230     memset(&wclass, 0, sizeof(wclass));
1231     wclass.lpfnWndProc = apartment_wndproc;
1232     wclass.hInstance = hProxyDll;
1233     wclass.lpszClassName = aptwinclassW;
1234     apt_win_class = RegisterClassW(&wclass);
1235     return TRUE;
1236 }
1237
1238 /* create a window for the apartment or return the current one if one has
1239  * already been created */
1240 HRESULT apartment_createwindowifneeded(struct apartment *apt)
1241 {
1242     static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
1243
1244     if (apt->multi_threaded)
1245         return S_OK;
1246
1247     if (!apt->win)
1248     {
1249         HWND hwnd;
1250
1251         InitOnceExecuteOnce( &class_init_once, register_class, NULL, NULL );
1252
1253         hwnd = CreateWindowW(aptwinclassW, NULL, 0, 0, 0, 0, 0, HWND_MESSAGE, 0, hProxyDll, NULL);
1254         if (!hwnd)
1255         {
1256             ERR("CreateWindow failed with error %d\n", GetLastError());
1257             return HRESULT_FROM_WIN32(GetLastError());
1258         }
1259         if (InterlockedCompareExchangePointer((void **)&apt->win, hwnd, NULL))
1260             /* someone beat us to it */
1261             DestroyWindow(hwnd);
1262     }
1263
1264     return S_OK;
1265 }
1266
1267 /* retrieves the window for the main- or apartment-threaded apartment */
1268 HWND apartment_getwindow(const struct apartment *apt)
1269 {
1270     assert(!apt->multi_threaded);
1271     return apt->win;
1272 }
1273
1274 OXID apartment_getoxid(const struct apartment *apt)
1275 {
1276     return apt->oxid;
1277 }
1278
1279 void apartment_global_cleanup(void)
1280 {
1281     if (apt_win_class)
1282         UnregisterClassW((const WCHAR *)MAKEINTATOM(apt_win_class), hProxyDll);
1283     apartment_release_dlls();
1284     DeleteCriticalSection(&apt_cs);
1285 }