dlls/ole32/compobj.c

   1 /*
   2  *      COMPOBJ library
   3  *
   4  *      Copyright 1995  Martin von Loewis
   5  *      Copyright 1998  Justin Bradford
   6  *      Copyright 1999  Francis Beaudet
   7  *      Copyright 1999  Sylvain St-Germain
   8  *      Copyright 2002  Marcus Meissner
   9  *      Copyright 2004  Mike Hearn
  10  *      Copyright 2005-2006 Robert Shearman (for CodeWeavers)
  11  *
  12  * This library is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU Lesser General Public
  14  * License as published by the Free Software Foundation; either
  15  * version 2.1 of the License, or (at your option) any later version.
  16  *
  17  * This library is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20  * Lesser General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU Lesser General Public
  23  * License along with this library; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  25  *
  26  * Note
  27  * 1. COINIT_MULTITHREADED is 0; it is the lack of COINIT_APARTMENTTHREADED
  28  *    Therefore do not test against COINIT_MULTITHREADED
  29  *
  30  * TODO list:           (items bunched together depend on each other)
  31  *
  32  *   - Implement the service control manager (in rpcss) to keep track
  33  *     of registered class objects: ISCM::ServerRegisterClsid et al
  34  *   - Implement the OXID resolver so we don't need magic endpoint names for
  35  *     clients and servers to meet up
  36  *
  37  */
  38
  39 #include "config.h"
  40
  41 #include <stdarg.h>
  42 #include <stdio.h>
  43 #include <string.h>
  44 #include <assert.h>
  45
  46 #define COBJMACROS
  47 #define NONAMELESSUNION
  48 #define NONAMELESSSTRUCT
  49
  50 #include "ntstatus.h"
  51 #define WIN32_NO_STATUS
  52 #include "windef.h"
  53 #include "winbase.h"
  54 #include "winerror.h"
  55 #include "winreg.h"
  56 #include "winuser.h"
  57 #define USE_COM_CONTEXT_DEF
  58 #include "objbase.h"
  59 #include "ole2.h"
  60 #include "ole2ver.h"
  61 #include "ctxtcall.h"
  62 #include "dde.h"
  63 #include "servprov.h"
  64
  65 #include "initguid.h"
  66 #include "compobj_private.h"
  67 #include "moniker.h"
  68
  69 #include "wine/unicode.h"
  70 #include "wine/debug.h"
  71
  72 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  73
  74 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
  75
  76 /****************************************************************************
  77  * This section defines variables internal to the COM module.
  78  */
  79
  80 static APARTMENT *MTA; /* protected by csApartment */
  81 static APARTMENT *MainApartment; /* the first STA apartment */
  82 static struct list apts = LIST_INIT( apts ); /* protected by csApartment */
  83
  84 static CRITICAL_SECTION csApartment;
  85 static CRITICAL_SECTION_DEBUG critsect_debug =
  86 {
  87     0, 0, &csApartment,
  88     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  89       0, 0, { (DWORD_PTR)(__FILE__ ": csApartment") }
  90 };
  91 static CRITICAL_SECTION csApartment = { &critsect_debug, -1, 0, 0, 0, 0 };
  92
  93 enum comclass_threadingmodel
  94 {
  95     ThreadingModel_Apartment = 1,
  96     ThreadingModel_Free      = 2,
  97     ThreadingModel_No        = 3,
  98     ThreadingModel_Both      = 4,
  99     ThreadingModel_Neutral   = 5
 100 };
 101
 102 enum comclass_miscfields
 103 {
 104     MiscStatus          = 1,
 105     MiscStatusIcon      = 2,
 106     MiscStatusContent   = 4,
 107     MiscStatusThumbnail = 8,
 108     MiscStatusDocPrint  = 16
 109 };
 110
 111 struct comclassredirect_data
 112 {
 113     ULONG size;
 114     BYTE  res;
 115     BYTE  miscmask;
 116     BYTE  res1[2];
 117     DWORD model;
 118     GUID  clsid;
 119     GUID  alias;
 120     GUID  clsid2;
 121     GUID  tlbid;
 122     ULONG name_len;
 123     ULONG name_offset;
 124     ULONG progid_len;
 125     ULONG progid_offset;
 126     ULONG clrdata_len;
 127     ULONG clrdata_offset;
 128     DWORD miscstatus;
 129     DWORD miscstatuscontent;
 130     DWORD miscstatusthumbnail;
 131     DWORD miscstatusicon;
 132     DWORD miscstatusdocprint;
 133 };
 134
 135 struct ifacepsredirect_data
 136 {
 137     ULONG size;
 138     DWORD mask;
 139     GUID  iid;
 140     ULONG nummethods;
 141     GUID  tlbid;
 142     GUID  base;
 143     ULONG name_len;
 144     ULONG name_offset;
 145 };
 146
 147 struct progidredirect_data
 148 {
 149     ULONG size;
 150     DWORD reserved;
 151     ULONG clsid_offset;
 152 };
 153
 154 struct class_reg_data
 155 {
 156     union
 157     {
 158         struct
 159         {
 160             struct comclassredirect_data *data;
 161             void *section;
 162             HANDLE hactctx;
 163         } actctx;
 164         HKEY hkey;
 165     } u;
 166     BOOL hkey;
 167 };
 168
 169 struct registered_psclsid
 170 {
 171     struct list entry;
 172     IID iid;
 173     CLSID clsid;
 174 };
 175
 176 /*
 177  * This is a marshallable object exposing registered local servers.
 178  * IServiceProvider is used only because it happens meet requirements
 179  * and already has proxy/stub code. If more functionality is needed,
 180  * a custom interface may be used instead.
 181  */
 182 struct LocalServer
 183 {
 184     IServiceProvider IServiceProvider_iface;
 185     LONG ref;
 186     APARTMENT *apt;
 187     IStream *marshal_stream;
 188 };
 189
 190 /*
 191  * This lock count counts the number of times CoInitialize is called. It is
 192  * decreased every time CoUninitialize is called. When it hits 0, the COM
 193  * libraries are freed
 194  */
 195 static LONG s_COMLockCount = 0;
 196 /* Reference count used by CoAddRefServerProcess/CoReleaseServerProcess */
 197 static LONG s_COMServerProcessReferences = 0;
 198
 199 /*
 200  * This linked list contains the list of registered class objects. These
 201  * are mostly used to register the factories for out-of-proc servers of OLE
 202  * objects.
 203  *
 204  * TODO: Make this data structure aware of inter-process communication. This
 205  *       means that parts of this will be exported to rpcss.
 206  */
 207 typedef struct tagRegisteredClass
 208 {
 209   struct list entry;
 210   CLSID     classIdentifier;
 211   OXID      apartment_id;
 212   LPUNKNOWN classObject;
 213   DWORD     runContext;
 214   DWORD     connectFlags;
 215   DWORD     dwCookie;
 216   void     *RpcRegistration;
 217 } RegisteredClass;
 218
 219 static struct list RegisteredClassList = LIST_INIT(RegisteredClassList);
 220
 221 static CRITICAL_SECTION csRegisteredClassList;
 222 static CRITICAL_SECTION_DEBUG class_cs_debug =
 223 {
 224     0, 0, &csRegisteredClassList,
 225     { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
 226       0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
 227 };
 228 static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 };
 229
 230 static inline enum comclass_miscfields dvaspect_to_miscfields(DWORD aspect)
 231 {
 232     switch (aspect)
 233     {
 234     case DVASPECT_CONTENT:
 235         return MiscStatusContent;
 236     case DVASPECT_THUMBNAIL:
 237         return MiscStatusThumbnail;
 238     case DVASPECT_ICON:
 239         return MiscStatusIcon;
 240     case DVASPECT_DOCPRINT:
 241         return MiscStatusDocPrint;
 242     default:
 243         return MiscStatus;
 244     };
 245 }
 246
 247 BOOL actctx_get_miscstatus(const CLSID *clsid, DWORD aspect, DWORD *status)
 248 {
 249     ACTCTX_SECTION_KEYED_DATA data;
 250
 251     data.cbSize = sizeof(data);
 252     if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
 253                               clsid, &data))
 254     {
 255         struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
 256         enum comclass_miscfields misc = dvaspect_to_miscfields(aspect);
 257
 258         if (!(comclass->miscmask & misc))
 259         {
 260             if (!(comclass->miscmask & MiscStatus))
 261             {
 262                 *status = 0;
 263                 return TRUE;
 264             }
 265             misc = MiscStatus;
 266         }
 267
 268         switch (misc)
 269         {
 270         case MiscStatus:
 271             *status = comclass->miscstatus;
 272             break;
 273         case MiscStatusIcon:
 274             *status = comclass->miscstatusicon;
 275             break;
 276         case MiscStatusContent:
 277             *status = comclass->miscstatuscontent;
 278             break;
 279         case MiscStatusThumbnail:
 280             *status = comclass->miscstatusthumbnail;
 281             break;
 282         case MiscStatusDocPrint:
 283             *status = comclass->miscstatusdocprint;
 284             break;
 285         default:
 286            ;
 287         };
 288
 289         return TRUE;
 290     }
 291     else
 292         return FALSE;
 293 }
 294
 295 /* wrapper for NtCreateKey that creates the key recursively if necessary */
 296 static NTSTATUS create_key( HKEY *retkey, ACCESS_MASK access, OBJECT_ATTRIBUTES *attr )
 297 {
 298     NTSTATUS status = NtCreateKey( (HANDLE *)retkey, access, attr, 0, NULL, 0, NULL );
 299
 300     if (status == STATUS_OBJECT_NAME_NOT_FOUND)
 301     {
 302         HANDLE subkey, root = attr->RootDirectory;
 303         WCHAR *buffer = attr->ObjectName->Buffer;
 304         DWORD attrs, pos = 0, i = 0, len = attr->ObjectName->Length / sizeof(WCHAR);
 305         UNICODE_STRING str;
 306
 307         while (i < len && buffer[i] != '\\') i++;
 308         if (i == len) return status;
 309
 310         attrs = attr->Attributes;
 311         attr->ObjectName = &str;
 312
 313         while (i < len)
 314         {
 315             str.Buffer = buffer + pos;
 316             str.Length = (i - pos) * sizeof(WCHAR);
 317             status = NtCreateKey( &subkey, access, attr, 0, NULL, 0, NULL );
 318             if (attr->RootDirectory != root) NtClose( attr->RootDirectory );
 319             if (status) return status;
 320             attr->RootDirectory = subkey;
 321             while (i < len && buffer[i] == '\\') i++;
 322             pos = i;
 323             while (i < len && buffer[i] != '\\') i++;
 324         }
 325         str.Buffer = buffer + pos;
 326         str.Length = (i - pos) * sizeof(WCHAR);
 327         attr->Attributes = attrs;
 328         status = NtCreateKey( (PHANDLE)retkey, access, attr, 0, NULL, 0, NULL );
 329         if (attr->RootDirectory != root) NtClose( attr->RootDirectory );
 330     }
 331     return status;
 332 }
 333
 334 static const WCHAR classes_rootW[] =
 335     {'M','a','c','h','i','n','e','\\','S','o','f','t','w','a','r','e','\\','C','l','a','s','s','e','s',0};
 336
 337 static HKEY classes_root_hkey;
 338
 339 /* create the special HKEY_CLASSES_ROOT key */
 340 static HKEY create_classes_root_hkey(DWORD access)
 341 {
 342     HKEY hkey, ret = 0;
 343     OBJECT_ATTRIBUTES attr;
 344     UNICODE_STRING name;
 345
 346     attr.Length = sizeof(attr);
 347     attr.RootDirectory = 0;
 348     attr.ObjectName = &name;
 349     attr.Attributes = 0;
 350     attr.SecurityDescriptor = NULL;
 351     attr.SecurityQualityOfService = NULL;
 352     RtlInitUnicodeString( &name, classes_rootW );
 353     if (create_key( &hkey, access, &attr )) return 0;
 354     TRACE( "%s -> %p\n", debugstr_w(attr.ObjectName->Buffer), hkey );
 355
 356     if (!(access & KEY_WOW64_64KEY))
 357     {
 358         if (!(ret = InterlockedCompareExchangePointer( (void **)&classes_root_hkey, hkey, 0 )))
 359             ret = hkey;
 360         else
 361             NtClose( hkey );  /* somebody beat us to it */
 362     }
 363     else
 364         ret = hkey;
 365     return ret;
 366 }
 367
 368 /* map the hkey from special root to normal key if necessary */
 369 static inline HKEY get_classes_root_hkey( HKEY hkey, REGSAM access )
 370 {
 371     HKEY ret = hkey;
 372     const BOOL is_win64 = sizeof(void*) > sizeof(int);
 373     const BOOL force_wow32 = is_win64 && (access & KEY_WOW64_32KEY);
 374
 375     if (hkey == HKEY_CLASSES_ROOT &&
 376         ((access & KEY_WOW64_64KEY) || !(ret = classes_root_hkey)))
 377         ret = create_classes_root_hkey(MAXIMUM_ALLOWED | (access & KEY_WOW64_64KEY));
 378     if (force_wow32 && ret && ret == classes_root_hkey)
 379     {
 380         static const WCHAR wow6432nodeW[] = {'W','o','w','6','4','3','2','N','o','d','e',0};
 381         access &= ~KEY_WOW64_32KEY;
 382         if (create_classes_key(classes_root_hkey, wow6432nodeW, access, &hkey))
 383             return 0;
 384         ret = hkey;
 385     }
 386
 387     return ret;
 388 }
 389
 390 LSTATUS create_classes_key( HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey )
 391 {
 392     OBJECT_ATTRIBUTES attr;
 393     UNICODE_STRING nameW;
 394
 395     if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 396
 397     attr.Length = sizeof(attr);
 398     attr.RootDirectory = hkey;
 399     attr.ObjectName = &nameW;
 400     attr.Attributes = 0;
 401     attr.SecurityDescriptor = NULL;
 402     attr.SecurityQualityOfService = NULL;
 403     RtlInitUnicodeString( &nameW, name );
 404
 405     return RtlNtStatusToDosError( create_key( retkey, access, &attr ) );
 406 }
 407
 408 LSTATUS open_classes_key( HKEY hkey, const WCHAR *name, REGSAM access, HKEY *retkey )
 409 {
 410     OBJECT_ATTRIBUTES attr;
 411     UNICODE_STRING nameW;
 412
 413     if (!(hkey = get_classes_root_hkey( hkey, access ))) return ERROR_INVALID_HANDLE;
 414
 415     attr.Length = sizeof(attr);
 416     attr.RootDirectory = hkey;
 417     attr.ObjectName = &nameW;
 418     attr.Attributes = 0;
 419     attr.SecurityDescriptor = NULL;
 420     attr.SecurityQualityOfService = NULL;
 421     RtlInitUnicodeString( &nameW, name );
 422
 423     return RtlNtStatusToDosError( NtOpenKey( (HANDLE *)retkey, access, &attr ) );
 424 }
 425
 426 /*****************************************************************************
 427  * This section contains OpenDllList definitions
 428  *
 429  * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
 430  * other functions that do LoadLibrary _without_ giving back a HMODULE.
 431  * Without this list these handles would never be freed.
 432  *
 433  * FIXME: a DLL that says OK when asked for unloading is unloaded in the
 434  * next unload-call but not before 600 sec.
 435  */
 436
 437 typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
 438 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
 439
 440 typedef struct tagOpenDll
 441 {
 442   LONG refs;
 443   LPWSTR library_name;
 444   HANDLE library;
 445   DllGetClassObjectFunc DllGetClassObject;
 446   DllCanUnloadNowFunc DllCanUnloadNow;
 447   struct list entry;
 448 } OpenDll;
 449
 450 static struct list openDllList = LIST_INIT(openDllList);
 451
 452 static CRITICAL_SECTION csOpenDllList;
 453 static CRITICAL_SECTION_DEBUG dll_cs_debug =
 454 {
 455     0, 0, &csOpenDllList,
 456     { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
 457       0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
 458 };
 459 static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 };
 460
 461 struct apartment_loaded_dll
 462 {
 463     struct list entry;
 464     OpenDll *dll;
 465     DWORD unload_time;
 466     BOOL multi_threaded;
 467 };
 468
 469 static const WCHAR wszAptWinClass[] = {'O','l','e','M','a','i','n','T','h','r','e','a','d','W','n','d','C','l','a','s','s',' ',
 470                                        '0','x','#','#','#','#','#','#','#','#',' ',0};
 471
 472 /*****************************************************************************
 473  * This section contains OpenDllList implementation
 474  */
 475
 476 static OpenDll *COMPOBJ_DllList_Get(LPCWSTR library_name)
 477 {
 478     OpenDll *ptr;
 479     OpenDll *ret = NULL;
 480     EnterCriticalSection(&csOpenDllList);
 481     LIST_FOR_EACH_ENTRY(ptr, &openDllList, OpenDll, entry)
 482     {
 483         if (!strcmpiW(library_name, ptr->library_name) &&
 484             (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroy if == 1 */)
 485         {
 486             ret = ptr;
 487             break;
 488         }
 489     }
 490     LeaveCriticalSection(&csOpenDllList);
 491     return ret;
 492 }
 493
 494 /* caller must ensure that library_name is not already in the open dll list */
 495 static HRESULT COMPOBJ_DllList_Add(LPCWSTR library_name, OpenDll **ret)
 496 {
 497     OpenDll *entry;
 498     int len;
 499     HRESULT hr = S_OK;
 500     HANDLE hLibrary;
 501     DllCanUnloadNowFunc DllCanUnloadNow;
 502     DllGetClassObjectFunc DllGetClassObject;
 503
 504     TRACE("%s\n", debugstr_w(library_name));
 505
 506     *ret = COMPOBJ_DllList_Get(library_name);
 507     if (*ret) return S_OK;
 508
 509     /* do this outside the csOpenDllList to avoid creating a lock dependency on
 510      * the loader lock */
 511     hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 512     if (!hLibrary)
 513     {
 514         ERR("couldn't load in-process dll %s\n", debugstr_w(library_name));
 515         /* failure: DLL could not be loaded */
 516         return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
 517     }
 518
 519     DllCanUnloadNow = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
 520     /* Note: failing to find DllCanUnloadNow is not a failure */
 521     DllGetClassObject = (void *)GetProcAddress(hLibrary, "DllGetClassObject");
 522     if (!DllGetClassObject)
 523     {
 524         /* failure: the dll did not export DllGetClassObject */
 525         ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name));
 526         FreeLibrary(hLibrary);
 527         return CO_E_DLLNOTFOUND;
 528     }
 529
 530     EnterCriticalSection( &csOpenDllList );
 531
 532     *ret = COMPOBJ_DllList_Get(library_name);
 533     if (*ret)
 534     {
 535         /* another caller to this function already added the dll while we
 536          * weren't in the critical section */
 537         FreeLibrary(hLibrary);
 538     }
 539     else
 540     {
 541         len = strlenW(library_name);
 542         entry = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
 543         if (entry)
 544             entry->library_name = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 545         if (entry && entry->library_name)
 546         {
 547             memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
 548             entry->library = hLibrary;
 549             entry->refs = 1;
 550             entry->DllCanUnloadNow = DllCanUnloadNow;
 551             entry->DllGetClassObject = DllGetClassObject;
 552             list_add_tail(&openDllList, &entry->entry);
 553             *ret = entry;
 554         }
 555         else
 556         {
 557             HeapFree(GetProcessHeap(), 0, entry);
 558             hr = E_OUTOFMEMORY;
 559             FreeLibrary(hLibrary);
 560         }
 561     }
 562
 563     LeaveCriticalSection( &csOpenDllList );
 564
 565     return hr;
 566 }
 567
 568 /* pass FALSE for free_entry to release a reference without destroying the
 569  * entry if it reaches zero or TRUE otherwise */
 570 static void COMPOBJ_DllList_ReleaseRef(OpenDll *entry, BOOL free_entry)
 571 {
 572     if (!InterlockedDecrement(&entry->refs) && free_entry)
 573     {
 574         EnterCriticalSection(&csOpenDllList);
 575         list_remove(&entry->entry);
 576         LeaveCriticalSection(&csOpenDllList);
 577
 578         TRACE("freeing %p\n", entry->library);
 579         FreeLibrary(entry->library);
 580
 581         HeapFree(GetProcessHeap(), 0, entry->library_name);
 582         HeapFree(GetProcessHeap(), 0, entry);
 583     }
 584 }
 585
 586 /* frees memory associated with active dll list */
 587 static void COMPOBJ_DllList_Free(void)
 588 {
 589     OpenDll *entry, *cursor2;
 590     EnterCriticalSection(&csOpenDllList);
 591     LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &openDllList, OpenDll, entry)
 592     {
 593         list_remove(&entry->entry);
 594
 595         HeapFree(GetProcessHeap(), 0, entry->library_name);
 596         HeapFree(GetProcessHeap(), 0, entry);
 597     }
 598     LeaveCriticalSection(&csOpenDllList);
 599     DeleteCriticalSection(&csOpenDllList);
 600 }
 601
 602 /******************************************************************************
 603  * Manage apartments.
 604  */
 605
 606 static DWORD apartment_addref(struct apartment *apt)
 607 {
 608     DWORD refs = InterlockedIncrement(&apt->refs);
 609     TRACE("%s: before = %d\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
 610     return refs;
 611 }
 612
 613 /* allocates memory and fills in the necessary fields for a new apartment
 614  * object. must be called inside apartment cs */
 615 static APARTMENT *apartment_construct(DWORD model)
 616 {
 617     APARTMENT *apt;
 618
 619     TRACE("creating new apartment, model=%d\n", model);
 620
 621     apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
 622     apt->tid = GetCurrentThreadId();
 623
 624     list_init(&apt->proxies);
 625     list_init(&apt->stubmgrs);
 626     list_init(&apt->psclsids);
 627     list_init(&apt->loaded_dlls);
 628     apt->ipidc = 0;
 629     apt->refs = 1;
 630     apt->remunk_exported = FALSE;
 631     apt->oidc = 1;
 632     InitializeCriticalSection(&apt->cs);
 633     DEBUG_SET_CRITSEC_NAME(&apt->cs, "apartment");
 634
 635     apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
 636
 637     if (apt->multi_threaded)
 638     {
 639         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 640         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
 641     }
 642     else
 643     {
 644         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 645         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
 646     }
 647
 648     TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 649
 650     list_add_head(&apts, &apt->entry);
 651
 652     return apt;
 653 }
 654
 655 /* gets and existing apartment if one exists or otherwise creates an apartment
 656  * structure which stores OLE apartment-local information and stores a pointer
 657  * to it in the thread-local storage */
 658 static APARTMENT *apartment_get_or_create(DWORD model)
 659 {
 660     APARTMENT *apt = COM_CurrentApt();
 661
 662     if (!apt)
 663     {
 664         if (model & COINIT_APARTMENTTHREADED)
 665         {
 666             EnterCriticalSection(&csApartment);
 667
 668             apt = apartment_construct(model);
 669             if (!MainApartment)
 670             {
 671                 MainApartment = apt;
 672                 apt->main = TRUE;
 673                 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 674             }
 675
 676             LeaveCriticalSection(&csApartment);
 677
 678             if (apt->main)
 679                 apartment_createwindowifneeded(apt);
 680         }
 681         else
 682         {
 683             EnterCriticalSection(&csApartment);
 684
 685             /* The multi-threaded apartment (MTA) contains zero or more threads interacting
 686              * with free threaded (ie thread safe) COM objects. There is only ever one MTA
 687              * in a process */
 688             if (MTA)
 689             {
 690                 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA->oxid));
 691                 apartment_addref(MTA);
 692             }
 693             else
 694                 MTA = apartment_construct(model);
 695
 696             apt = MTA;
 697
 698             LeaveCriticalSection(&csApartment);
 699         }
 700         COM_CurrentInfo()->apt = apt;
 701     }
 702
 703     return apt;
 704 }
 705
 706 static inline BOOL apartment_is_model(const APARTMENT *apt, DWORD model)
 707 {
 708     return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
 709 }
 710
 711 static void COM_RevokeRegisteredClassObject(RegisteredClass *curClass)
 712 {
 713     list_remove(&curClass->entry);
 714
 715     if (curClass->runContext & CLSCTX_LOCAL_SERVER)
 716         RPC_StopLocalServer(curClass->RpcRegistration);
 717
 718     IUnknown_Release(curClass->classObject);
 719     HeapFree(GetProcessHeap(), 0, curClass);
 720 }
 721
 722 static void COM_RevokeAllClasses(const struct apartment *apt)
 723 {
 724   RegisteredClass *curClass, *cursor;
 725
 726   EnterCriticalSection( &csRegisteredClassList );
 727
 728   LIST_FOR_EACH_ENTRY_SAFE(curClass, cursor, &RegisteredClassList, RegisteredClass, entry)
 729   {
 730     if (curClass->apartment_id == apt->oxid)
 731       COM_RevokeRegisteredClassObject(curClass);
 732   }
 733
 734   LeaveCriticalSection( &csRegisteredClassList );
 735 }
 736
 737 /******************************************************************************
 738  * Implementation of the manual reset event object. (CLSID_ManualResetEvent)
 739  */
 740
 741 typedef struct ManualResetEvent {
 742     ISynchronize        ISynchronize_iface;
 743     ISynchronizeHandle  ISynchronizeHandle_iface;
 744     LONG ref;
 745     HANDLE event;
 746 } MREImpl;
 747
 748 static inline MREImpl *impl_from_ISynchronize(ISynchronize *iface)
 749 {
 750     return CONTAINING_RECORD(iface, MREImpl, ISynchronize_iface);
 751 }
 752
 753 static HRESULT WINAPI ISynchronize_fnQueryInterface(ISynchronize *iface, REFIID riid, void **ppv)
 754 {
 755     MREImpl *This = impl_from_ISynchronize(iface);
 756
 757     TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppv);
 758
 759     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ISynchronize)) {
 760         *ppv = &This->ISynchronize_iface;
 761     }else if(IsEqualGUID(riid, &IID_ISynchronizeHandle)) {
 762         *ppv = &This->ISynchronizeHandle_iface;
 763     }else {
 764         ERR("Unknown interface %s requested.\n", debugstr_guid(riid));
 765         *ppv = NULL;
 766         return E_NOINTERFACE;
 767     }
 768
 769     IUnknown_AddRef((IUnknown*)*ppv);
 770     return S_OK;
 771 }
 772
 773 static ULONG WINAPI ISynchronize_fnAddRef(ISynchronize *iface)
 774 {
 775     MREImpl *This = impl_from_ISynchronize(iface);
 776     LONG ref = InterlockedIncrement(&This->ref);
 777     TRACE("%p - ref %d\n", This, ref);
 778
 779     return ref;
 780 }
 781
 782 static ULONG WINAPI ISynchronize_fnRelease(ISynchronize *iface)
 783 {
 784     MREImpl *This = impl_from_ISynchronize(iface);
 785     LONG ref = InterlockedDecrement(&This->ref);
 786     TRACE("%p - ref %d\n", This, ref);
 787
 788     if(!ref)
 789     {
 790         CloseHandle(This->event);
 791         HeapFree(GetProcessHeap(), 0, This);
 792     }
 793
 794     return ref;
 795 }
 796
 797 static HRESULT WINAPI ISynchronize_fnWait(ISynchronize *iface, DWORD dwFlags, DWORD dwMilliseconds)
 798 {
 799     MREImpl *This = impl_from_ISynchronize(iface);
 800     UINT index;
 801     TRACE("%p (%08x, %08x)\n", This, dwFlags, dwMilliseconds);
 802     return CoWaitForMultipleHandles(dwFlags, dwMilliseconds, 1, &This->event, &index);
 803 }
 804
 805 static HRESULT WINAPI ISynchronize_fnSignal(ISynchronize *iface)
 806 {
 807     MREImpl *This = impl_from_ISynchronize(iface);
 808     TRACE("%p\n", This);
 809     SetEvent(This->event);
 810     return S_OK;
 811 }
 812
 813 static HRESULT WINAPI ISynchronize_fnReset(ISynchronize *iface)
 814 {
 815     MREImpl *This = impl_from_ISynchronize(iface);
 816     TRACE("%p\n", This);
 817     ResetEvent(This->event);
 818     return S_OK;
 819 }
 820
 821 static ISynchronizeVtbl vt_ISynchronize = {
 822     ISynchronize_fnQueryInterface,
 823     ISynchronize_fnAddRef,
 824     ISynchronize_fnRelease,
 825     ISynchronize_fnWait,
 826     ISynchronize_fnSignal,
 827     ISynchronize_fnReset
 828 };
 829
 830 static inline MREImpl *impl_from_ISynchronizeHandle(ISynchronizeHandle *iface)
 831 {
 832     return CONTAINING_RECORD(iface, MREImpl, ISynchronizeHandle_iface);
 833 }
 834
 835 static HRESULT WINAPI SynchronizeHandle_QueryInterface(ISynchronizeHandle *iface, REFIID riid, void **ppv)
 836 {
 837     MREImpl *This = impl_from_ISynchronizeHandle(iface);
 838     return ISynchronize_QueryInterface(&This->ISynchronize_iface, riid, ppv);
 839 }
 840
 841 static ULONG WINAPI SynchronizeHandle_AddRef(ISynchronizeHandle *iface)
 842 {
 843     MREImpl *This = impl_from_ISynchronizeHandle(iface);
 844     return ISynchronize_AddRef(&This->ISynchronize_iface);
 845 }
 846
 847 static ULONG WINAPI SynchronizeHandle_Release(ISynchronizeHandle *iface)
 848 {
 849     MREImpl *This = impl_from_ISynchronizeHandle(iface);
 850     return ISynchronize_Release(&This->ISynchronize_iface);
 851 }
 852
 853 static HRESULT WINAPI SynchronizeHandle_GetHandle(ISynchronizeHandle *iface, HANDLE *ph)
 854 {
 855     MREImpl *This = impl_from_ISynchronizeHandle(iface);
 856
 857     *ph = This->event;
 858     return S_OK;
 859 }
 860
 861 static const ISynchronizeHandleVtbl SynchronizeHandleVtbl = {
 862     SynchronizeHandle_QueryInterface,
 863     SynchronizeHandle_AddRef,
 864     SynchronizeHandle_Release,
 865     SynchronizeHandle_GetHandle
 866 };
 867
 868 static HRESULT ManualResetEvent_Construct(IUnknown *punkouter, REFIID iid, void **ppv)
 869 {
 870     MREImpl *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MREImpl));
 871     HRESULT hr;
 872
 873     if(punkouter)
 874         FIXME("Aggregation not implemented.\n");
 875
 876     This->ref = 1;
 877     This->ISynchronize_iface.lpVtbl = &vt_ISynchronize;
 878     This->ISynchronizeHandle_iface.lpVtbl = &SynchronizeHandleVtbl;
 879     This->event = CreateEventW(NULL, TRUE, FALSE, NULL);
 880
 881     hr = ISynchronize_QueryInterface(&This->ISynchronize_iface, iid, ppv);
 882     ISynchronize_Release(&This->ISynchronize_iface);
 883     return hr;
 884 }
 885
 886 static inline LocalServer *impl_from_IServiceProvider(IServiceProvider *iface)
 887 {
 888     return CONTAINING_RECORD(iface, LocalServer, IServiceProvider_iface);
 889 }
 890
 891 static HRESULT WINAPI LocalServer_QueryInterface(IServiceProvider *iface, REFIID riid, void **ppv)
 892 {
 893     LocalServer *This = impl_from_IServiceProvider(iface);
 894
 895     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), ppv);
 896
 897     if(IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IServiceProvider)) {
 898         *ppv = &This->IServiceProvider_iface;
 899     }else {
 900         *ppv = NULL;
 901         return E_NOINTERFACE;
 902     }
 903
 904     IUnknown_AddRef((IUnknown*)*ppv);
 905     return S_OK;
 906 }
 907
 908 static ULONG WINAPI LocalServer_AddRef(IServiceProvider *iface)
 909 {
 910     LocalServer *This = impl_from_IServiceProvider(iface);
 911     LONG ref = InterlockedIncrement(&This->ref);
 912
 913     TRACE("(%p) ref=%d\n", This, ref);
 914
 915     return ref;
 916 }
 917
 918 static ULONG WINAPI LocalServer_Release(IServiceProvider *iface)
 919 {
 920     LocalServer *This = impl_from_IServiceProvider(iface);
 921     LONG ref = InterlockedDecrement(&This->ref);
 922
 923     TRACE("(%p) ref=%d\n", This, ref);
 924
 925     if(!ref) {
 926         assert(!This->apt);
 927         HeapFree(GetProcessHeap(), 0, This);
 928     }
 929
 930     return ref;
 931 }
 932
 933 static HRESULT WINAPI LocalServer_QueryService(IServiceProvider *iface, REFGUID guid, REFIID riid, void **ppv)
 934 {
 935     LocalServer *This = impl_from_IServiceProvider(iface);
 936     APARTMENT *apt = COM_CurrentApt();
 937     RegisteredClass *iter;
 938     HRESULT hres = E_FAIL;
 939
 940     TRACE("(%p)->(%s %s %p)\n", This, debugstr_guid(guid), debugstr_guid(riid), ppv);
 941
 942     if(!This->apt)
 943         return E_UNEXPECTED;
 944
 945     EnterCriticalSection(&csRegisteredClassList);
 946
 947     LIST_FOR_EACH_ENTRY(iter, &RegisteredClassList, RegisteredClass, entry) {
 948         if(iter->apartment_id == apt->oxid
 949            && (iter->runContext & CLSCTX_LOCAL_SERVER)
 950            && IsEqualGUID(&iter->classIdentifier, guid)) {
 951             hres = IUnknown_QueryInterface(iter->classObject, riid, ppv);
 952             break;
 953         }
 954     }
 955
 956     LeaveCriticalSection( &csRegisteredClassList );
 957
 958     return hres;
 959 }
 960
 961 static const IServiceProviderVtbl LocalServerVtbl = {
 962     LocalServer_QueryInterface,
 963     LocalServer_AddRef,
 964     LocalServer_Release,
 965     LocalServer_QueryService
 966 };
 967
 968 static HRESULT get_local_server_stream(APARTMENT *apt, IStream **ret)
 969 {
 970     HRESULT hres = S_OK;
 971
 972     EnterCriticalSection(&apt->cs);
 973
 974     if(!apt->local_server) {
 975         LocalServer *obj;
 976
 977         obj = heap_alloc(sizeof(*obj));
 978         if(obj) {
 979             obj->IServiceProvider_iface.lpVtbl = &LocalServerVtbl;
 980             obj->ref = 1;
 981             obj->apt = apt;
 982
 983             hres = CreateStreamOnHGlobal(0, TRUE, &obj->marshal_stream);
 984             if(SUCCEEDED(hres)) {
 985                 hres = CoMarshalInterface(obj->marshal_stream, &IID_IServiceProvider, (IUnknown*)&obj->IServiceProvider_iface,
 986                         MSHCTX_LOCAL, NULL, MSHLFLAGS_TABLESTRONG);
 987                 if(FAILED(hres))
 988                     IStream_Release(obj->marshal_stream);
 989             }
 990
 991             if(SUCCEEDED(hres))
 992                 apt->local_server = obj;
 993             else
 994                 heap_free(obj);
 995         }else {
 996             hres = E_OUTOFMEMORY;
 997         }
 998     }
 999
1000     if(SUCCEEDED(hres))
1001         hres = IStream_Clone(apt->local_server->marshal_stream, ret);
1002
1003     LeaveCriticalSection(&apt->cs);
1004
1005     if(FAILED(hres))
1006         ERR("Failed: %08x\n", hres);
1007     return hres;
1008 }
1009
1010 /***********************************************************************
1011  *           CoRevokeClassObject [OLE32.@]
1012  *
1013  * Removes a class object from the class registry.
1014  *
1015  * PARAMS
1016  *  dwRegister [I] Cookie returned from CoRegisterClassObject().
1017  *
1018  * RETURNS
1019  *  Success: S_OK.
1020  *  Failure: HRESULT code.
1021  *
1022  * NOTES
1023  *  Must be called from the same apartment that called CoRegisterClassObject(),
1024  *  otherwise it will fail with RPC_E_WRONG_THREAD.
1025  *
1026  * SEE ALSO
1027  *  CoRegisterClassObject
1028  */
1029 HRESULT WINAPI CoRevokeClassObject(
1030         DWORD dwRegister)
1031 {
1032   HRESULT hr = E_INVALIDARG;
1033   RegisteredClass *curClass;
1034   APARTMENT *apt;
1035
1036   TRACE("(%08x)\n",dwRegister);
1037
1038   apt = COM_CurrentApt();
1039   if (!apt)
1040   {
1041     ERR("COM was not initialized\n");
1042     return CO_E_NOTINITIALIZED;
1043   }
1044
1045   EnterCriticalSection( &csRegisteredClassList );
1046
1047   LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
1048   {
1049     /*
1050      * Check if we have a match on the cookie.
1051      */
1052     if (curClass->dwCookie == dwRegister)
1053     {
1054       if (curClass->apartment_id == apt->oxid)
1055       {
1056           COM_RevokeRegisteredClassObject(curClass);
1057           hr = S_OK;
1058       }
1059       else
1060       {
1061           ERR("called from wrong apartment, should be called from %s\n",
1062               wine_dbgstr_longlong(curClass->apartment_id));
1063           hr = RPC_E_WRONG_THREAD;
1064       }
1065       break;
1066     }
1067   }
1068
1069   LeaveCriticalSection( &csRegisteredClassList );
1070
1071   return hr;
1072 }
1073
1074 /* frees unused libraries loaded by apartment_getclassobject by calling the
1075  * DLL's DllCanUnloadNow entry point */
1076 static void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay)
1077 {
1078     struct apartment_loaded_dll *entry, *next;
1079     EnterCriticalSection(&apt->cs);
1080     LIST_FOR_EACH_ENTRY_SAFE(entry, next, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
1081     {
1082         if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
1083         {
1084             DWORD real_delay = delay;
1085
1086             if (real_delay == INFINITE)
1087             {
1088                 /* DLLs that return multi-threaded objects aren't unloaded
1089                  * straight away to cope for programs that have races between
1090                  * last object destruction and threads in the DLLs that haven't
1091                  * finished, despite DllCanUnloadNow returning S_OK */
1092                 if (entry->multi_threaded)
1093                     real_delay = 10 * 60 * 1000; /* 10 minutes */
1094                 else
1095                     real_delay = 0;
1096             }
1097
1098             if (!real_delay || (entry->unload_time && ((int)(GetTickCount() - entry->unload_time) > 0)))
1099             {
1100                 list_remove(&entry->entry);
1101                 COMPOBJ_DllList_ReleaseRef(entry->dll, TRUE);
1102                 HeapFree(GetProcessHeap(), 0, entry);
1103             }
1104             else
1105             {
1106                 entry->unload_time = GetTickCount() + real_delay;
1107                 if (!entry->unload_time) entry->unload_time = 1;
1108             }
1109         }
1110         else if (entry->unload_time)
1111             entry->unload_time = 0;
1112     }
1113     LeaveCriticalSection(&apt->cs);
1114 }
1115
1116 DWORD apartment_release(struct apartment *apt)
1117 {
1118     DWORD ret;
1119
1120     EnterCriticalSection(&csApartment);
1121
1122     ret = InterlockedDecrement(&apt->refs);
1123     TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt->oxid), ret);
1124     /* destruction stuff that needs to happen under csApartment CS */
1125     if (ret == 0)
1126     {
1127         if (apt == MTA) MTA = NULL;
1128         else if (apt == MainApartment) MainApartment = NULL;
1129         list_remove(&apt->entry);
1130     }
1131
1132     LeaveCriticalSection(&csApartment);
1133
1134     if (ret == 0)
1135     {
1136         struct list *cursor, *cursor2;
1137
1138         TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
1139
1140         if(apt->local_server) {
1141             LocalServer *local_server = apt->local_server;
1142             LARGE_INTEGER zero;
1143
1144             memset(&zero, 0, sizeof(zero));
1145             IStream_Seek(local_server->marshal_stream, zero, STREAM_SEEK_SET, NULL);
1146             CoReleaseMarshalData(local_server->marshal_stream);
1147             IStream_Release(local_server->marshal_stream);
1148             local_server->marshal_stream = NULL;
1149
1150             apt->local_server = NULL;
1151             local_server->apt = NULL;
1152             IServiceProvider_Release(&local_server->IServiceProvider_iface);
1153         }
1154
1155         /* Release the references to the registered class objects */
1156         COM_RevokeAllClasses(apt);
1157
1158         /* no locking is needed for this apartment, because no other thread
1159          * can access it at this point */
1160
1161         apartment_disconnectproxies(apt);
1162
1163         if (apt->win) DestroyWindow(apt->win);
1164         if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
1165
1166         LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
1167         {
1168             struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
1169             /* release the implicit reference given by the fact that the
1170              * stub has external references (it must do since it is in the
1171              * stub manager list in the apartment and all non-apartment users
1172              * must have a ref on the apartment and so it cannot be destroyed).
1173              */
1174             stub_manager_int_release(stubmgr);
1175         }
1176
1177         LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->psclsids)
1178         {
1179             struct registered_psclsid *registered_psclsid =
1180                 LIST_ENTRY(cursor, struct registered_psclsid, entry);
1181
1182             list_remove(&registered_psclsid->entry);
1183             HeapFree(GetProcessHeap(), 0, registered_psclsid);
1184         }
1185
1186         /* if this assert fires, then another thread took a reference to a
1187          * stub manager without taking a reference to the containing
1188          * apartment, which it must do. */
1189         assert(list_empty(&apt->stubmgrs));
1190
1191         if (apt->filter) IMessageFilter_Release(apt->filter);
1192
1193         /* free as many unused libraries as possible... */
1194         apartment_freeunusedlibraries(apt, 0);
1195
1196         /* ... and free the memory for the apartment loaded dll entry and
1197          * release the dll list reference without freeing the library for the
1198          * rest */
1199         while ((cursor = list_head(&apt->loaded_dlls)))
1200         {
1201             struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
1202             COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
1203             list_remove(cursor);
1204             HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
1205         }
1206
1207         DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
1208         DeleteCriticalSection(&apt->cs);
1209
1210         HeapFree(GetProcessHeap(), 0, apt);
1211     }
1212
1213     return ret;
1214 }
1215
1216 /* The given OXID must be local to this process:
1217  *
1218  * The ref parameter is here mostly to ensure people remember that
1219  * they get one, you should normally take a ref for thread safety.
1220  */
1221 APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
1222 {
1223     APARTMENT *result = NULL;
1224     struct list *cursor;
1225
1226     EnterCriticalSection(&csApartment);
1227     LIST_FOR_EACH( cursor, &apts )
1228     {
1229         struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
1230         if (apt->oxid == oxid)
1231         {
1232             result = apt;
1233             if (ref) apartment_addref(result);
1234             break;
1235         }
1236     }
1237     LeaveCriticalSection(&csApartment);
1238
1239     return result;
1240 }
1241
1242 /* gets the apartment which has a given creator thread ID. The caller must
1243  * release the reference from the apartment as soon as the apartment pointer
1244  * is no longer required. */
1245 APARTMENT *apartment_findfromtid(DWORD tid)
1246 {
1247     APARTMENT *result = NULL;
1248     struct list *cursor;
1249
1250     EnterCriticalSection(&csApartment);
1251     LIST_FOR_EACH( cursor, &apts )
1252     {
1253         struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
1254         if (apt->tid == tid)
1255         {
1256             result = apt;
1257             apartment_addref(result);
1258             break;
1259         }
1260     }
1261     LeaveCriticalSection(&csApartment);
1262
1263     return result;
1264 }
1265
1266 /* gets the main apartment if it exists. The caller must
1267  * release the reference from the apartment as soon as the apartment pointer
1268  * is no longer required. */
1269 static APARTMENT *apartment_findmain(void)
1270 {
1271     APARTMENT *result;
1272
1273     EnterCriticalSection(&csApartment);
1274
1275     result = MainApartment;
1276     if (result) apartment_addref(result);
1277
1278     LeaveCriticalSection(&csApartment);
1279
1280     return result;
1281 }
1282
1283 /* gets the multi-threaded apartment if it exists. The caller must
1284  * release the reference from the apartment as soon as the apartment pointer
1285  * is no longer required. */
1286 static APARTMENT *apartment_find_multi_threaded(void)
1287 {
1288     APARTMENT *result = NULL;
1289     struct list *cursor;
1290
1291     EnterCriticalSection(&csApartment);
1292
1293     LIST_FOR_EACH( cursor, &apts )
1294     {
1295         struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
1296         if (apt->multi_threaded)
1297         {
1298             result = apt;
1299             apartment_addref(result);
1300             break;
1301         }
1302     }
1303
1304     LeaveCriticalSection(&csApartment);
1305     return result;
1306 }
1307
1308 /* gets the specified class object by loading the appropriate DLL, if
1309  * necessary and calls the DllGetClassObject function for the DLL */
1310 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
1311                                         BOOL apartment_threaded,
1312                                         REFCLSID rclsid, REFIID riid, void **ppv)
1313 {
1314     static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
1315     HRESULT hr = S_OK;
1316     BOOL found = FALSE;
1317     struct apartment_loaded_dll *apartment_loaded_dll;
1318
1319     if (!strcmpiW(dllpath, wszOle32))
1320     {
1321         /* we don't need to control the lifetime of this dll, so use the local
1322          * implementation of DllGetClassObject directly */
1323         TRACE("calling ole32!DllGetClassObject\n");
1324         hr = DllGetClassObject(rclsid, riid, ppv);
1325
1326         if (hr != S_OK)
1327             ERR("DllGetClassObject returned error 0x%08x\n", hr);
1328
1329         return hr;
1330     }
1331
1332     EnterCriticalSection(&apt->cs);
1333
1334     LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
1335         if (!strcmpiW(dllpath, apartment_loaded_dll->dll->library_name))
1336         {
1337             TRACE("found %s already loaded\n", debugstr_w(dllpath));
1338             found = TRUE;
1339             break;
1340         }
1341
1342     if (!found)
1343     {
1344         apartment_loaded_dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*apartment_loaded_dll));
1345         if (!apartment_loaded_dll)
1346             hr = E_OUTOFMEMORY;
1347         if (SUCCEEDED(hr))
1348         {
1349             apartment_loaded_dll->unload_time = 0;
1350             apartment_loaded_dll->multi_threaded = FALSE;
1351             hr = COMPOBJ_DllList_Add( dllpath, &apartment_loaded_dll->dll );
1352             if (FAILED(hr))
1353                 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
1354         }
1355         if (SUCCEEDED(hr))
1356         {
1357             TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
1358             list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
1359         }
1360     }
1361
1362     LeaveCriticalSection(&apt->cs);
1363
1364     if (SUCCEEDED(hr))
1365     {
1366         /* one component being multi-threaded overrides any number of
1367          * apartment-threaded components */
1368         if (!apartment_threaded)
1369             apartment_loaded_dll->multi_threaded = TRUE;
1370
1371         TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
1372         /* OK: get the ClassObject */
1373         hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
1374
1375         if (hr != S_OK)
1376             ERR("DllGetClassObject returned error 0x%08x\n", hr);
1377     }
1378
1379     return hr;
1380 }
1381
1382 /***********************************************************************
1383  *      COM_RegReadPath [internal]
1384  *
1385  *      Reads a registry value and expands it when necessary
1386  */
1387 static DWORD COM_RegReadPath(const struct class_reg_data *regdata, WCHAR *dst, DWORD dstlen)
1388 {
1389     DWORD ret;
1390
1391     if (regdata->hkey)
1392     {
1393         DWORD keytype;
1394         WCHAR src[MAX_PATH];
1395         DWORD dwLength = dstlen * sizeof(WCHAR);
1396
1397         if( (ret = RegQueryValueExW(regdata->u.hkey, NULL, NULL, &keytype, (BYTE*)src, &dwLength)) == ERROR_SUCCESS ) {
1398             if (keytype == REG_EXPAND_SZ) {
1399               if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
1400             } else {
1401               const WCHAR *quote_start;
1402               quote_start = strchrW(src, '\"');
1403               if (quote_start) {
1404                 const WCHAR *quote_end = strchrW(quote_start + 1, '\"');
1405                 if (quote_end) {
1406                   memmove(src, quote_start + 1,
1407                           (quote_end - quote_start - 1) * sizeof(WCHAR));
1408                   src[quote_end - quote_start - 1] = '\0';
1409                 }
1410               }
1411               lstrcpynW(dst, src, dstlen);
1412             }
1413         }
1414         return ret;
1415     }
1416     else
1417     {
1418         ULONG_PTR cookie;
1419         WCHAR *nameW;
1420
1421         *dst = 0;
1422         nameW = (WCHAR*)((BYTE*)regdata->u.actctx.section + regdata->u.actctx.data->name_offset);
1423         ActivateActCtx(regdata->u.actctx.hactctx, &cookie);
1424         ret = SearchPathW(NULL, nameW, NULL, dstlen, dst, NULL);
1425         DeactivateActCtx(0, cookie);
1426         return !*dst;
1427     }
1428 }
1429
1430 struct host_object_params
1431 {
1432     struct class_reg_data regdata;
1433     CLSID clsid; /* clsid of object to marshal */
1434     IID iid; /* interface to marshal */
1435     HANDLE event; /* event signalling when ready for multi-threaded case */
1436     HRESULT hr; /* result for multi-threaded case */
1437     IStream *stream; /* stream that the object will be marshaled into */
1438     BOOL apartment_threaded; /* is the component purely apartment-threaded? */
1439 };
1440
1441 static HRESULT apartment_hostobject(struct apartment *apt,
1442                                     const struct host_object_params *params)
1443 {
1444     IUnknown *object;
1445     HRESULT hr;
1446     static const LARGE_INTEGER llZero;
1447     WCHAR dllpath[MAX_PATH+1];
1448
1449     TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
1450
1451     if (COM_RegReadPath(&params->regdata, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
1452     {
1453         /* failure: CLSID is not found in registry */
1454         WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
1455         return REGDB_E_CLASSNOTREG;
1456     }
1457
1458     hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded,
1459                                   &params->clsid, &params->iid, (void **)&object);
1460     if (FAILED(hr))
1461         return hr;
1462
1463     hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
1464     if (FAILED(hr))
1465         IUnknown_Release(object);
1466     IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
1467
1468     return hr;
1469 }
1470
1471 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1472 {
1473     switch (msg)
1474     {
1475     case DM_EXECUTERPC:
1476         RPC_ExecuteCall((struct dispatch_params *)lParam);
1477         return 0;
1478     case DM_HOSTOBJECT:
1479         return apartment_hostobject(COM_CurrentApt(), (const struct host_object_params *)lParam);
1480     default:
1481         return DefWindowProcW(hWnd, msg, wParam, lParam);
1482     }
1483 }
1484
1485 struct host_thread_params
1486 {
1487     COINIT threading_model;
1488     HANDLE ready_event;
1489     HWND apartment_hwnd;
1490 };
1491
1492 /* thread for hosting an object to allow an object to appear to be created in
1493  * an apartment with an incompatible threading model */
1494 static DWORD CALLBACK apartment_hostobject_thread(LPVOID p)
1495 {
1496     struct host_thread_params *params = p;
1497     MSG msg;
1498     HRESULT hr;
1499     struct apartment *apt;
1500
1501     TRACE("\n");
1502
1503     hr = CoInitializeEx(NULL, params->threading_model);
1504     if (FAILED(hr)) return hr;
1505
1506     apt = COM_CurrentApt();
1507     if (params->threading_model == COINIT_APARTMENTTHREADED)
1508     {
1509         apartment_createwindowifneeded(apt);
1510         params->apartment_hwnd = apartment_getwindow(apt);
1511     }
1512     else
1513         params->apartment_hwnd = NULL;
1514
1515     /* force the message queue to be created before signaling parent thread */
1516     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
1517
1518     SetEvent(params->ready_event);
1519     params = NULL; /* can't touch params after here as it may be invalid */
1520
1521     while (GetMessageW(&msg, NULL, 0, 0))
1522     {
1523         if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
1524         {
1525             struct host_object_params *obj_params = (struct host_object_params *)msg.lParam;
1526             obj_params->hr = apartment_hostobject(apt, obj_params);
1527             SetEvent(obj_params->event);
1528         }
1529         else
1530         {
1531             TranslateMessage(&msg);
1532             DispatchMessageW(&msg);
1533         }
1534     }
1535
1536     TRACE("exiting\n");
1537
1538     CoUninitialize();
1539
1540     return S_OK;
1541 }
1542
1543 /* finds or creates a host apartment, creates the object inside it and returns
1544  * a proxy to it so that the object can be used in the apartment of the
1545  * caller of this function */
1546 static HRESULT apartment_hostobject_in_hostapt(
1547     struct apartment *apt, BOOL multi_threaded, BOOL main_apartment,
1548     const struct class_reg_data *regdata, REFCLSID rclsid, REFIID riid, void **ppv)
1549 {
1550     struct host_object_params params;
1551     HWND apartment_hwnd = NULL;
1552     DWORD apartment_tid = 0;
1553     HRESULT hr;
1554
1555     if (!multi_threaded && main_apartment)
1556     {
1557         APARTMENT *host_apt = apartment_findmain();
1558         if (host_apt)
1559         {
1560             apartment_hwnd = apartment_getwindow(host_apt);
1561             apartment_release(host_apt);
1562         }
1563     }
1564
1565     if (!apartment_hwnd)
1566     {
1567         EnterCriticalSection(&apt->cs);
1568
1569         if (!apt->host_apt_tid)
1570         {
1571             struct host_thread_params thread_params;
1572             HANDLE handles[2];
1573             DWORD wait_value;
1574
1575             thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
1576             handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1577             thread_params.apartment_hwnd = NULL;
1578             handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
1579             if (!handles[1])
1580             {
1581                 CloseHandle(handles[0]);
1582                 LeaveCriticalSection(&apt->cs);
1583                 return E_OUTOFMEMORY;
1584             }
1585             wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
1586             CloseHandle(handles[0]);
1587             CloseHandle(handles[1]);
1588             if (wait_value == WAIT_OBJECT_0)
1589                 apt->host_apt_hwnd = thread_params.apartment_hwnd;
1590             else
1591             {
1592                 LeaveCriticalSection(&apt->cs);
1593                 return E_OUTOFMEMORY;
1594             }
1595         }
1596
1597         if (multi_threaded || !main_apartment)
1598         {
1599             apartment_hwnd = apt->host_apt_hwnd;
1600             apartment_tid = apt->host_apt_tid;
1601         }
1602
1603         LeaveCriticalSection(&apt->cs);
1604     }
1605
1606     /* another thread may have become the main apartment in the time it took
1607      * us to create the thread for the host apartment */
1608     if (!apartment_hwnd && !multi_threaded && main_apartment)
1609     {
1610         APARTMENT *host_apt = apartment_findmain();
1611         if (host_apt)
1612         {
1613             apartment_hwnd = apartment_getwindow(host_apt);
1614             apartment_release(host_apt);
1615         }
1616     }
1617
1618     params.regdata = *regdata;
1619     params.clsid = *rclsid;
1620     params.iid = *riid;
1621     hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
1622     if (FAILED(hr))
1623         return hr;
1624     params.apartment_threaded = !multi_threaded;
1625     if (multi_threaded)
1626     {
1627         params.hr = S_OK;
1628         params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
1629         if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
1630             hr = E_OUTOFMEMORY;
1631         else
1632         {
1633             WaitForSingleObject(params.event, INFINITE);
1634             hr = params.hr;
1635         }
1636         CloseHandle(params.event);
1637     }
1638     else
1639     {
1640         if (!apartment_hwnd)
1641         {
1642             ERR("host apartment didn't create window\n");
1643             hr = E_OUTOFMEMORY;
1644         }
1645         else
1646             hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
1647     }
1648     if (SUCCEEDED(hr))
1649         hr = CoUnmarshalInterface(params.stream, riid, ppv);
1650     IStream_Release(params.stream);
1651     return hr;
1652 }
1653
1654 static BOOL WINAPI register_class( INIT_ONCE *once, void *param, void **context )
1655 {
1656     WNDCLASSW wclass;
1657
1658     /* Dispatching to the correct thread in an apartment is done through
1659      * window messages rather than RPC transports. When an interface is
1660      * marshalled into another apartment in the same process, a window of the
1661      * following class is created. The *caller* of CoMarshalInterface (i.e., the
1662      * application) is responsible for pumping the message loop in that thread.
1663      * The WM_USER messages which point to the RPCs are then dispatched to
1664      * apartment_wndproc by the user's code from the apartment in which the
1665      * interface was unmarshalled.
1666      */
1667     memset(&wclass, 0, sizeof(wclass));
1668     wclass.lpfnWndProc = apartment_wndproc;
1669     wclass.hInstance = hProxyDll;
1670     wclass.lpszClassName = wszAptWinClass;
1671     RegisterClassW(&wclass);
1672     return TRUE;
1673 }
1674
1675 /* create a window for the apartment or return the current one if one has
1676  * already been created */
1677 HRESULT apartment_createwindowifneeded(struct apartment *apt)
1678 {
1679     static INIT_ONCE class_init_once = INIT_ONCE_STATIC_INIT;
1680
1681     if (apt->multi_threaded)
1682         return S_OK;
1683
1684     if (!apt->win)
1685     {
1686         HWND hwnd;
1687
1688         InitOnceExecuteOnce( &class_init_once, register_class, NULL, NULL );
1689
1690         hwnd = CreateWindowW(wszAptWinClass, NULL, 0, 0, 0, 0, 0,
1691                              HWND_MESSAGE, 0, hProxyDll, NULL);
1692         if (!hwnd)
1693         {
1694             ERR("CreateWindow failed with error %d\n", GetLastError());
1695             return HRESULT_FROM_WIN32(GetLastError());
1696         }
1697         if (InterlockedCompareExchangePointer((PVOID *)&apt->win, hwnd, NULL))
1698             /* someone beat us to it */
1699             DestroyWindow(hwnd);
1700     }
1701
1702     return S_OK;
1703 }
1704
1705 /* retrieves the window for the main- or apartment-threaded apartment */
1706 HWND apartment_getwindow(const struct apartment *apt)
1707 {
1708     assert(!apt->multi_threaded);
1709     return apt->win;
1710 }
1711
1712 void apartment_joinmta(void)
1713 {
1714     apartment_addref(MTA);
1715     COM_CurrentInfo()->apt = MTA;
1716 }
1717
1718 static void COM_TlsDestroy(void)
1719 {
1720     struct oletls *info = NtCurrentTeb()->ReservedForOle;
1721     if (info)
1722     {
1723         if (info->apt) apartment_release(info->apt);
1724         if (info->errorinfo) IErrorInfo_Release(info->errorinfo);
1725         if (info->state) IUnknown_Release(info->state);
1726         if (info->spy) IInitializeSpy_Release(info->spy);
1727         if (info->context_token) IObjContext_Release(info->context_token);
1728         HeapFree(GetProcessHeap(), 0, info);
1729         NtCurrentTeb()->ReservedForOle = NULL;
1730     }
1731 }
1732
1733 /******************************************************************************
1734  *           CoBuildVersion [OLE32.@]
1735  *
1736  * Gets the build version of the DLL.
1737  *
1738  * PARAMS
1739  *
1740  * RETURNS
1741  *      Current build version, hiword is majornumber, loword is minornumber
1742  */
1743 DWORD WINAPI CoBuildVersion(void)
1744 {
1745     TRACE("Returning version %d, build %d.\n", rmm, rup);
1746     return (rmm<<16)+rup;
1747 }
1748
1749 /******************************************************************************
1750  *              CoRegisterInitializeSpy [OLE32.@]
1751  *
1752  * Add a Spy that watches CoInitializeEx calls
1753  *
1754  * PARAMS
1755  *  spy [I] Pointer to IUnknown interface that will be QueryInterface'd.
1756  *  cookie [II] cookie receiver
1757  *
1758  * RETURNS
1759  *  Success: S_OK if not already initialized, S_FALSE otherwise.
1760  *  Failure: HRESULT code.
1761  *
1762  * SEE ALSO
1763  *   CoInitializeEx
1764  */
1765 HRESULT WINAPI CoRegisterInitializeSpy(IInitializeSpy *spy, ULARGE_INTEGER *cookie)
1766 {
1767     struct oletls *info = COM_CurrentInfo();
1768     HRESULT hr;
1769
1770     TRACE("(%p, %p)\n", spy, cookie);
1771
1772     if (!spy || !cookie || !info)
1773     {
1774         if (!info)
1775             WARN("Could not allocate tls\n");
1776         return E_INVALIDARG;
1777     }
1778
1779     if (info->spy)
1780     {
1781         FIXME("Already registered?\n");
1782         return E_UNEXPECTED;
1783     }
1784
1785     hr = IInitializeSpy_QueryInterface(spy, &IID_IInitializeSpy, (void **) &info->spy);
1786     if (SUCCEEDED(hr))
1787     {
1788         cookie->QuadPart = (DWORD_PTR)spy;
1789         return S_OK;
1790     }
1791     return hr;
1792 }
1793
1794 /******************************************************************************
1795  *              CoRevokeInitializeSpy [OLE32.@]
1796  *
1797  * Remove a spy that previously watched CoInitializeEx calls
1798  *
1799  * PARAMS
1800  *  cookie [I] The cookie obtained from a previous CoRegisterInitializeSpy call
1801  *
1802  * RETURNS
1803  *  Success: S_OK if a spy is removed
1804  *  Failure: E_INVALIDARG
1805  *
1806  * SEE ALSO
1807  *   CoInitializeEx
1808  */
1809 HRESULT WINAPI CoRevokeInitializeSpy(ULARGE_INTEGER cookie)
1810 {
1811     struct oletls *info = COM_CurrentInfo();
1812     TRACE("(%s)\n", wine_dbgstr_longlong(cookie.QuadPart));
1813
1814     if (!info || !info->spy || cookie.QuadPart != (DWORD_PTR)info->spy)
1815         return E_INVALIDARG;
1816
1817     IInitializeSpy_Release(info->spy);
1818     info->spy = NULL;
1819     return S_OK;
1820 }
1821
1822
1823 /******************************************************************************
1824  *              CoInitialize    [OLE32.@]
1825  *
1826  * Initializes the COM libraries by calling CoInitializeEx with
1827  * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
1828  *
1829  * PARAMS
1830  *  lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1831  *
1832  * RETURNS
1833  *  Success: S_OK if not already initialized, S_FALSE otherwise.
1834  *  Failure: HRESULT code.
1835  *
1836  * SEE ALSO
1837  *   CoInitializeEx
1838  */
1839 HRESULT WINAPI CoInitialize(LPVOID lpReserved)
1840 {
1841   /*
1842    * Just delegate to the newer method.
1843    */
1844   return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
1845 }
1846
1847 /******************************************************************************
1848  *              CoInitializeEx  [OLE32.@]
1849  *
1850  * Initializes the COM libraries.
1851  *
1852  * PARAMS
1853  *  lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1854  *  dwCoInit   [I] One or more flags from the COINIT enumeration. See notes.
1855  *
1856  * RETURNS
1857  *  S_OK               if successful,
1858  *  S_FALSE            if this function was called already.
1859  *  RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
1860  *                     threading model.
1861  *
1862  * NOTES
1863  *
1864  * The behavior used to set the IMalloc used for memory management is
1865  * obsolete.
1866  * The dwCoInit parameter must specify one of the following apartment
1867  * threading models:
1868  *| COINIT_APARTMENTTHREADED - A single-threaded apartment (STA).
1869  *| COINIT_MULTITHREADED - A multi-threaded apartment (MTA).
1870  * The parameter may also specify zero or more of the following flags:
1871  *| COINIT_DISABLE_OLE1DDE - Don't use DDE for OLE1 support.
1872  *| COINIT_SPEED_OVER_MEMORY - Trade memory for speed.
1873  *
1874  * SEE ALSO
1875  *   CoUninitialize
1876  */
1877 HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
1878 {
1879   struct oletls *info = COM_CurrentInfo();
1880   HRESULT hr = S_OK;
1881   APARTMENT *apt;
1882
1883   TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
1884
1885   if (lpReserved!=NULL)
1886   {
1887     ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
1888   }
1889
1890   /*
1891    * Check the lock count. If this is the first time going through the initialize
1892    * process, we have to initialize the libraries.
1893    *
1894    * And crank-up that lock count.
1895    */
1896   if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
1897   {
1898     /*
1899      * Initialize the various COM libraries and data structures.
1900      */
1901     TRACE("() - Initializing the COM libraries\n");
1902
1903     /* we may need to defer this until after apartment initialisation */
1904     RunningObjectTableImpl_Initialize();
1905   }
1906
1907   if (info->spy)
1908       IInitializeSpy_PreInitialize(info->spy, dwCoInit, info->inits);
1909
1910   if (!(apt = info->apt))
1911   {
1912     apt = apartment_get_or_create(dwCoInit);
1913     if (!apt) return E_OUTOFMEMORY;
1914   }
1915   else if (!apartment_is_model(apt, dwCoInit))
1916   {
1917     /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
1918        code then we are probably using the wrong threading model to implement that API. */
1919     ERR("Attempt to change threading model of this apartment from %s to %s\n",
1920         apt->multi_threaded ? "multi-threaded" : "apartment threaded",
1921         dwCoInit & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded");
1922     return RPC_E_CHANGED_MODE;
1923   }
1924   else
1925     hr = S_FALSE;
1926
1927   info->inits++;
1928
1929   if (info->spy)
1930       IInitializeSpy_PostInitialize(info->spy, hr, dwCoInit, info->inits);
1931
1932   return hr;
1933 }
1934
1935 /***********************************************************************
1936  *           CoUninitialize   [OLE32.@]
1937  *
1938  * This method will decrement the refcount on the current apartment, freeing
1939  * the resources associated with it if it is the last thread in the apartment.
1940  * If the last apartment is freed, the function will additionally release
1941  * any COM resources associated with the process.
1942  *
1943  * PARAMS
1944  *
1945  * RETURNS
1946  *  Nothing.
1947  *
1948  * SEE ALSO
1949  *   CoInitializeEx
1950  */
1951 void WINAPI DECLSPEC_HOTPATCH CoUninitialize(void)
1952 {
1953   struct oletls * info = COM_CurrentInfo();
1954   LONG lCOMRefCnt;
1955
1956   TRACE("()\n");
1957
1958   /* will only happen on OOM */
1959   if (!info) return;
1960
1961   if (info->spy)
1962       IInitializeSpy_PreUninitialize(info->spy, info->inits);
1963
1964   /* sanity check */
1965   if (!info->inits)
1966   {
1967     ERR("Mismatched CoUninitialize\n");
1968
1969     if (info->spy)
1970         IInitializeSpy_PostUninitialize(info->spy, info->inits);
1971     return;
1972   }
1973
1974   if (!--info->inits)
1975   {
1976     apartment_release(info->apt);
1977     info->apt = NULL;
1978   }
1979
1980   /*
1981    * Decrease the reference count.
1982    * If we are back to 0 locks on the COM library, make sure we free
1983    * all the associated data structures.
1984    */
1985   lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
1986   if (lCOMRefCnt==1)
1987   {
1988     TRACE("() - Releasing the COM libraries\n");
1989
1990     RunningObjectTableImpl_UnInitialize();
1991   }
1992   else if (lCOMRefCnt<1) {
1993     ERR( "CoUninitialize() - not CoInitialized.\n" );
1994     InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
1995   }
1996   if (info->spy)
1997       IInitializeSpy_PostUninitialize(info->spy, info->inits);
1998 }
1999
2000 /******************************************************************************
2001  *              CoDisconnectObject      [OLE32.@]
2002  *
2003  * Disconnects all connections to this object from remote processes. Dispatches
2004  * pending RPCs while blocking new RPCs from occurring, and then calls
2005  * IMarshal::DisconnectObject on the given object.
2006  *
2007  * Typically called when the object server is forced to shut down, for instance by
2008  * the user.
2009  *
2010  * PARAMS
2011  *  lpUnk    [I] The object whose stub should be disconnected.
2012  *  reserved [I] Reserved. Should be set to 0.
2013  *
2014  * RETURNS
2015  *  Success: S_OK.
2016  *  Failure: HRESULT code.
2017  *
2018  * SEE ALSO
2019  *  CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
2020  */
2021 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
2022 {
2023     HRESULT hr;
2024     IMarshal *marshal;
2025     APARTMENT *apt;
2026
2027     TRACE("(%p, 0x%08x)\n", lpUnk, reserved);
2028
2029     if (!lpUnk) return E_INVALIDARG;
2030
2031     hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
2032     if (hr == S_OK)
2033     {
2034         hr = IMarshal_DisconnectObject(marshal, reserved);
2035         IMarshal_Release(marshal);
2036         return hr;
2037     }
2038
2039     apt = COM_CurrentApt();
2040     if (!apt)
2041         return CO_E_NOTINITIALIZED;
2042
2043     apartment_disconnectobject(apt, lpUnk);
2044
2045     /* Note: native is pretty broken here because it just silently
2046      * fails, without returning an appropriate error code if the object was
2047      * not found, making apps think that the object was disconnected, when
2048      * it actually wasn't */
2049
2050     return S_OK;
2051 }
2052
2053 /******************************************************************************
2054  *              CoCreateGuid [OLE32.@]
2055  *
2056  * Simply forwards to UuidCreate in RPCRT4.
2057  *
2058  * PARAMS
2059  *  pguid [O] Points to the GUID to initialize.
2060  *
2061  * RETURNS
2062  *  Success: S_OK.
2063  *  Failure: HRESULT code.
2064  *
2065  * SEE ALSO
2066  *   UuidCreate
2067  */
2068 HRESULT WINAPI CoCreateGuid(GUID *pguid)
2069 {
2070     DWORD status;
2071
2072     if(!pguid) return E_INVALIDARG;
2073
2074     status = UuidCreate(pguid);
2075     if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY) return S_OK;
2076     return HRESULT_FROM_WIN32( status );
2077 }
2078
2079 static inline BOOL is_valid_hex(WCHAR c)
2080 {
2081     if (!(((c >= '0') && (c <= '9'))  ||
2082           ((c >= 'a') && (c <= 'f'))  ||
2083           ((c >= 'A') && (c <= 'F'))))
2084         return FALSE;
2085     return TRUE;
2086 }
2087
2088 static const BYTE guid_conv_table[256] =
2089 {
2090   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
2091   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
2092   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
2093   0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
2094   0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
2095   0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
2096   0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             /* 0x60 */
2097 };
2098
2099 /* conversion helper for CLSIDFromString/IIDFromString */
2100 static BOOL guid_from_string(LPCWSTR s, GUID *id)
2101 {
2102   int   i;
2103
2104   if (!s || s[0]!='{') {
2105     memset( id, 0, sizeof (CLSID) );
2106     if(!s) return TRUE;
2107     return FALSE;
2108   }
2109
2110   TRACE("%s -> %p\n", debugstr_w(s), id);
2111
2112   /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
2113
2114   id->Data1 = 0;
2115   for (i = 1; i < 9; i++) {
2116     if (!is_valid_hex(s[i])) return FALSE;
2117     id->Data1 = (id->Data1 << 4) | guid_conv_table[s[i]];
2118   }
2119   if (s[9]!='-') return FALSE;
2120
2121   id->Data2 = 0;
2122   for (i = 10; i < 14; i++) {
2123     if (!is_valid_hex(s[i])) return FALSE;
2124     id->Data2 = (id->Data2 << 4) | guid_conv_table[s[i]];
2125   }
2126   if (s[14]!='-') return FALSE;
2127
2128   id->Data3 = 0;
2129   for (i = 15; i < 19; i++) {
2130     if (!is_valid_hex(s[i])) return FALSE;
2131     id->Data3 = (id->Data3 << 4) | guid_conv_table[s[i]];
2132   }
2133   if (s[19]!='-') return FALSE;
2134
2135   for (i = 20; i < 37; i+=2) {
2136     if (i == 24) {
2137       if (s[i]!='-') return FALSE;
2138       i++;
2139     }
2140     if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
2141     id->Data4[(i-20)/2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
2142   }
2143
2144   if (s[37] == '}' && s[38] == '\0')
2145     return TRUE;
2146
2147   return FALSE;
2148 }
2149
2150 /*****************************************************************************/
2151
2152 static HRESULT clsid_from_string_reg(LPCOLESTR progid, CLSID *clsid)
2153 {
2154     static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
2155     WCHAR buf2[CHARS_IN_GUID];
2156     LONG buf2len = sizeof(buf2);
2157     HKEY xhkey;
2158     WCHAR *buf;
2159
2160     memset(clsid, 0, sizeof(*clsid));
2161     buf = HeapAlloc( GetProcessHeap(),0,(strlenW(progid)+8) * sizeof(WCHAR) );
2162     if (!buf) return E_OUTOFMEMORY;
2163     strcpyW( buf, progid );
2164     strcatW( buf, clsidW );
2165     if (open_classes_key(HKEY_CLASSES_ROOT, buf, MAXIMUM_ALLOWED, &xhkey))
2166     {
2167         HeapFree(GetProcessHeap(),0,buf);
2168         WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
2169         return CO_E_CLASSSTRING;
2170     }
2171     HeapFree(GetProcessHeap(),0,buf);
2172
2173     if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
2174     {
2175         RegCloseKey(xhkey);
2176         WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
2177         return CO_E_CLASSSTRING;
2178     }
2179     RegCloseKey(xhkey);
2180     return guid_from_string(buf2, clsid) ? S_OK : CO_E_CLASSSTRING;
2181 }
2182
2183 /******************************************************************************
2184  *              CLSIDFromString [OLE32.@]
2185  *
2186  * Converts a unique identifier from its string representation into
2187  * the GUID struct.
2188  *
2189  * PARAMS
2190  *  idstr [I] The string representation of the GUID.
2191  *  id    [O] GUID converted from the string.
2192  *
2193  * RETURNS
2194  *   S_OK on success
2195  *   CO_E_CLASSSTRING if idstr is not a valid CLSID
2196  *
2197  * SEE ALSO
2198  *  StringFromCLSID
2199  */
2200 HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id )
2201 {
2202     HRESULT ret = CO_E_CLASSSTRING;
2203     CLSID tmp_id;
2204
2205     if (!id)
2206         return E_INVALIDARG;
2207
2208     if (guid_from_string(idstr, id))
2209         return S_OK;
2210
2211     /* It appears a ProgID is also valid */
2212     ret = clsid_from_string_reg(idstr, &tmp_id);
2213     if(SUCCEEDED(ret))
2214         *id = tmp_id;
2215
2216     return ret;
2217 }
2218
2219 /******************************************************************************
2220  *              IIDFromString   [OLE32.@]
2221  *
2222  * Converts a interface identifier from its string representation into
2223  * the IID struct.
2224  *
2225  * PARAMS
2226  *  idstr [I] The string representation of the GUID.
2227  *  id    [O] IID converted from the string.
2228  *
2229  * RETURNS
2230  *   S_OK on success
2231  *   CO_E_IIDSTRING if idstr is not a valid IID
2232  *
2233  * SEE ALSO
2234  *  StringFromIID
2235  */
2236 HRESULT WINAPI IIDFromString(LPCOLESTR s, IID *iid)
2237 {
2238   TRACE("%s -> %p\n", debugstr_w(s), iid);
2239
2240   if (!s)
2241   {
2242       memset(iid, 0, sizeof(*iid));
2243       return S_OK;
2244   }
2245
2246   /* length mismatch is a special case */
2247   if (strlenW(s) + 1 != CHARS_IN_GUID)
2248       return E_INVALIDARG;
2249
2250   if (s[0] != '{')
2251       return CO_E_IIDSTRING;
2252
2253   return guid_from_string(s, iid) ? S_OK : CO_E_IIDSTRING;
2254 }
2255
2256 /******************************************************************************
2257  *              StringFromCLSID [OLE32.@]
2258  *              StringFromIID   [OLE32.@]
2259  *
2260  * Converts a GUID into the respective string representation.
2261  * The target string is allocated using the OLE IMalloc.
2262  *
2263  * PARAMS
2264  *  id    [I] the GUID to be converted.
2265  *  idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
2266  *
2267  * RETURNS
2268  *   S_OK
2269  *   E_FAIL
2270  *
2271  * SEE ALSO
2272  *  StringFromGUID2, CLSIDFromString
2273  */
2274 HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
2275 {
2276     if (!(*idstr = CoTaskMemAlloc(CHARS_IN_GUID * sizeof(WCHAR)))) return E_OUTOFMEMORY;
2277     StringFromGUID2( id, *idstr, CHARS_IN_GUID );
2278     return S_OK;
2279 }
2280
2281 /******************************************************************************
2282  *              StringFromGUID2 [OLE32.@]
2283  *
2284  * Modified version of StringFromCLSID that allows you to specify max
2285  * buffer size.
2286  *
2287  * PARAMS
2288  *  id   [I] GUID to convert to string.
2289  *  str  [O] Buffer where the result will be stored.
2290  *  cmax [I] Size of the buffer in characters.
2291  *
2292  * RETURNS
2293  *      Success: The length of the resulting string in characters.
2294  *  Failure: 0.
2295  */
2296 INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
2297 {
2298     static const WCHAR formatW[] = { '{','%','0','8','X','-','%','0','4','X','-',
2299                                      '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
2300                                      '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
2301                                      '%','0','2','X','%','0','2','X','}',0 };
2302     if (!id || cmax < CHARS_IN_GUID) return 0;
2303     sprintfW( str, formatW, id->Data1, id->Data2, id->Data3,
2304               id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
2305               id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
2306     return CHARS_IN_GUID;
2307 }
2308
2309 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
2310 HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
2311 {
2312     static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
2313     WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) - 1];
2314     LONG res;
2315     HKEY key;
2316
2317     strcpyW(path, wszCLSIDSlash);
2318     StringFromGUID2(clsid, path + strlenW(wszCLSIDSlash), CHARS_IN_GUID);
2319     res = open_classes_key(HKEY_CLASSES_ROOT, path, keyname ? KEY_READ : access, &key);
2320     if (res == ERROR_FILE_NOT_FOUND)
2321         return REGDB_E_CLASSNOTREG;
2322     else if (res != ERROR_SUCCESS)
2323         return REGDB_E_READREGDB;
2324
2325     if (!keyname)
2326     {
2327         *subkey = key;
2328         return S_OK;
2329     }
2330
2331     res = open_classes_key(key, keyname, access, subkey);
2332     RegCloseKey(key);
2333     if (res == ERROR_FILE_NOT_FOUND)
2334         return REGDB_E_KEYMISSING;
2335     else if (res != ERROR_SUCCESS)
2336         return REGDB_E_READREGDB;
2337
2338     return S_OK;
2339 }
2340
2341 /* open HKCR\\AppId\\{string form of appid clsid} key */
2342 HRESULT COM_OpenKeyForAppIdFromCLSID(REFCLSID clsid, REGSAM access, HKEY *subkey)
2343 {
2344     static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
2345     static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
2346     DWORD res;
2347     WCHAR buf[CHARS_IN_GUID];
2348     WCHAR keyname[ARRAYSIZE(szAppIdKey) + CHARS_IN_GUID];
2349     DWORD size;
2350     HKEY hkey;
2351     DWORD type;
2352     HRESULT hr;
2353
2354     /* read the AppID value under the class's key */
2355     hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
2356     if (FAILED(hr))
2357         return hr;
2358
2359     size = sizeof(buf);
2360     res = RegQueryValueExW(hkey, szAppId, NULL, &type, (LPBYTE)buf, &size);
2361     RegCloseKey(hkey);
2362     if (res == ERROR_FILE_NOT_FOUND)
2363         return REGDB_E_KEYMISSING;
2364     else if (res != ERROR_SUCCESS || type!=REG_SZ)
2365         return REGDB_E_READREGDB;
2366
2367     strcpyW(keyname, szAppIdKey);
2368     strcatW(keyname, buf);
2369     res = open_classes_key(HKEY_CLASSES_ROOT, keyname, access, subkey);
2370     if (res == ERROR_FILE_NOT_FOUND)
2371         return REGDB_E_KEYMISSING;
2372     else if (res != ERROR_SUCCESS)
2373         return REGDB_E_READREGDB;
2374
2375     return S_OK;
2376 }
2377
2378 /******************************************************************************
2379  *               ProgIDFromCLSID [OLE32.@]
2380  *
2381  * Converts a class id into the respective program ID.
2382  *
2383  * PARAMS
2384  *  clsid        [I] Class ID, as found in registry.
2385  *  ppszProgID [O] Associated ProgID.
2386  *
2387  * RETURNS
2388  *   S_OK
2389  *   E_OUTOFMEMORY
2390  *   REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
2391  */
2392 HRESULT WINAPI DECLSPEC_HOTPATCH ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *ppszProgID)
2393 {
2394     static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
2395     ACTCTX_SECTION_KEYED_DATA data;
2396     HKEY     hkey;
2397     HRESULT  ret;
2398     LONG progidlen = 0;
2399
2400     if (!ppszProgID)
2401         return E_INVALIDARG;
2402
2403     *ppszProgID = NULL;
2404
2405     data.cbSize = sizeof(data);
2406     if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
2407                               clsid, &data))
2408     {
2409         struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
2410         if (comclass->progid_len)
2411         {
2412             WCHAR *ptrW;
2413
2414             *ppszProgID = CoTaskMemAlloc(comclass->progid_len + sizeof(WCHAR));
2415             if (!*ppszProgID) return E_OUTOFMEMORY;
2416
2417             ptrW = (WCHAR*)((BYTE*)comclass + comclass->progid_offset);
2418             memcpy(*ppszProgID, ptrW, comclass->progid_len + sizeof(WCHAR));
2419             return S_OK;
2420         }
2421         else
2422             return REGDB_E_CLASSNOTREG;
2423     }
2424
2425     ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
2426     if (FAILED(ret))
2427         return ret;
2428
2429     if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
2430       ret = REGDB_E_CLASSNOTREG;
2431
2432     if (ret == S_OK)
2433     {
2434       *ppszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
2435       if (*ppszProgID)
2436       {
2437         if (RegQueryValueW(hkey, NULL, *ppszProgID, &progidlen)) {
2438           ret = REGDB_E_CLASSNOTREG;
2439           CoTaskMemFree(*ppszProgID);
2440           *ppszProgID = NULL;
2441         }
2442       }
2443       else
2444         ret = E_OUTOFMEMORY;
2445     }
2446
2447     RegCloseKey(hkey);
2448     return ret;
2449 }
2450
2451 /******************************************************************************
2452  *              CLSIDFromProgID [OLE32.@]
2453  *
2454  * Converts a program id into the respective GUID.
2455  *
2456  * PARAMS
2457  *  progid [I] Unicode program ID, as found in registry.
2458  *  clsid  [O] Associated CLSID.
2459  *
2460  * RETURNS
2461  *      Success: S_OK
2462  *  Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
2463  */
2464 HRESULT WINAPI DECLSPEC_HOTPATCH CLSIDFromProgID(LPCOLESTR progid, LPCLSID clsid)
2465 {
2466     ACTCTX_SECTION_KEYED_DATA data;
2467
2468     if (!progid || !clsid)
2469         return E_INVALIDARG;
2470
2471     data.cbSize = sizeof(data);
2472     if (FindActCtxSectionStringW(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_PROGID_REDIRECTION,
2473                                  progid, &data))
2474     {
2475         struct progidredirect_data *progiddata = (struct progidredirect_data*)data.lpData;
2476         CLSID *alias = (CLSID*)((BYTE*)data.lpSectionBase + progiddata->clsid_offset);
2477         *clsid = *alias;
2478         return S_OK;
2479     }
2480
2481     return clsid_from_string_reg(progid, clsid);
2482 }
2483
2484 /******************************************************************************
2485  *              CLSIDFromProgIDEx [OLE32.@]
2486  */
2487 HRESULT WINAPI CLSIDFromProgIDEx(LPCOLESTR progid, LPCLSID clsid)
2488 {
2489     FIXME("%s,%p: semi-stub\n", debugstr_w(progid), clsid);
2490
2491     return CLSIDFromProgID(progid, clsid);
2492 }
2493
2494 static HRESULT get_ps_clsid_from_registry(const WCHAR* path, REGSAM access, CLSID *pclsid)
2495 {
2496     HKEY hkey;
2497     WCHAR value[CHARS_IN_GUID];
2498     DWORD len;
2499
2500     access |= KEY_READ;
2501
2502     if (open_classes_key(HKEY_CLASSES_ROOT, path, access, &hkey))
2503         return REGDB_E_IIDNOTREG;
2504
2505     len = sizeof(value);
2506     if (ERROR_SUCCESS != RegQueryValueExW(hkey, NULL, NULL, NULL, (BYTE *)value, &len))
2507         return REGDB_E_IIDNOTREG;
2508     RegCloseKey(hkey);
2509
2510     if (CLSIDFromString(value, pclsid) != NOERROR)
2511         return REGDB_E_IIDNOTREG;
2512
2513     return S_OK;
2514 }
2515
2516 /*****************************************************************************
2517  *             CoGetPSClsid [OLE32.@]
2518  *
2519  * Retrieves the CLSID of the proxy/stub factory that implements
2520  * IPSFactoryBuffer for the specified interface.
2521  *
2522  * PARAMS
2523  *  riid   [I] Interface whose proxy/stub CLSID is to be returned.
2524  *  pclsid [O] Where to store returned proxy/stub CLSID.
2525  *
2526  * RETURNS
2527  *   S_OK
2528  *   E_OUTOFMEMORY
2529  *   REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
2530  *
2531  * NOTES
2532  *
2533  * The standard marshaller activates the object with the CLSID
2534  * returned and uses the CreateProxy and CreateStub methods on its
2535  * IPSFactoryBuffer interface to construct the proxies and stubs for a
2536  * given object.
2537  *
2538  * CoGetPSClsid determines this CLSID by searching the
2539  * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
2540  * in the registry and any interface id registered by
2541  * CoRegisterPSClsid within the current process.
2542  *
2543  * BUGS
2544  *
2545  * Native returns S_OK for interfaces with a key in HKCR\Interface, but
2546  * without a ProxyStubClsid32 key and leaves garbage in pclsid. This should be
2547  * considered a bug in native unless an application depends on this (unlikely).
2548  *
2549  * SEE ALSO
2550  *  CoRegisterPSClsid.
2551  */
2552 HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
2553 {
2554     static const WCHAR wszInterface[] = {'I','n','t','e','r','f','a','c','e','\\',0};
2555     static const WCHAR wszPSC[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
2556     WCHAR path[ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1 + ARRAYSIZE(wszPSC)];
2557     APARTMENT *apt = COM_CurrentApt();
2558     struct registered_psclsid *registered_psclsid;
2559     ACTCTX_SECTION_KEYED_DATA data;
2560     HRESULT hr;
2561     REGSAM opposite = (sizeof(void*) > sizeof(int)) ? KEY_WOW64_32KEY : KEY_WOW64_64KEY;
2562     BOOL is_wow64;
2563
2564     TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
2565
2566     if (!apt)
2567     {
2568         ERR("apartment not initialised\n");
2569         return CO_E_NOTINITIALIZED;
2570     }
2571
2572     if (!pclsid)
2573         return E_INVALIDARG;
2574
2575     EnterCriticalSection(&apt->cs);
2576
2577     LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
2578         if (IsEqualIID(&registered_psclsid->iid, riid))
2579         {
2580             *pclsid = registered_psclsid->clsid;
2581             LeaveCriticalSection(&apt->cs);
2582             return S_OK;
2583         }
2584
2585     LeaveCriticalSection(&apt->cs);
2586
2587     data.cbSize = sizeof(data);
2588     if (FindActCtxSectionGuid(0, NULL, ACTIVATION_CONTEXT_SECTION_COM_INTERFACE_REDIRECTION,
2589                               riid, &data))
2590     {
2591         struct ifacepsredirect_data *ifaceps = (struct ifacepsredirect_data*)data.lpData;
2592         *pclsid = ifaceps->iid;
2593         return S_OK;
2594     }
2595
2596     /* Interface\\{string form of riid}\\ProxyStubClsid32 */
2597     strcpyW(path, wszInterface);
2598     StringFromGUID2(riid, path + ARRAYSIZE(wszInterface) - 1, CHARS_IN_GUID);
2599     strcpyW(path + ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1, wszPSC);
2600
2601     hr = get_ps_clsid_from_registry(path, 0, pclsid);
2602     if (FAILED(hr) && (opposite == KEY_WOW64_32KEY ||
2603                        (IsWow64Process(GetCurrentProcess(), &is_wow64) && is_wow64)))
2604         hr = get_ps_clsid_from_registry(path, opposite, pclsid);
2605
2606     if (hr == S_OK)
2607         TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
2608     else
2609         WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
2610
2611     return hr;
2612 }
2613
2614 /*****************************************************************************
2615  *             CoRegisterPSClsid [OLE32.@]
2616  *
2617  * Register a proxy/stub CLSID for the given interface in the current process
2618  * only.
2619  *
2620  * PARAMS
2621  *  riid   [I] Interface whose proxy/stub CLSID is to be registered.
2622  *  rclsid [I] CLSID of the proxy/stub.
2623  *
2624  * RETURNS
2625  *   Success: S_OK
2626  *   Failure: E_OUTOFMEMORY
2627  *
2628  * NOTES
2629  *
2630  * This function does not add anything to the registry and the effects are
2631  * limited to the lifetime of the current process.
2632  *
2633  * SEE ALSO
2634  *  CoGetPSClsid.
2635  */
2636 HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid)
2637 {
2638     APARTMENT *apt = COM_CurrentApt();
2639     struct registered_psclsid *registered_psclsid;
2640
2641     TRACE("(%s, %s)\n", debugstr_guid(riid), debugstr_guid(rclsid));
2642
2643     if (!apt)
2644     {
2645         ERR("apartment not initialised\n");
2646         return CO_E_NOTINITIALIZED;
2647     }
2648
2649     EnterCriticalSection(&apt->cs);
2650
2651     LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
2652         if (IsEqualIID(&registered_psclsid->iid, riid))
2653         {
2654             registered_psclsid->clsid = *rclsid;
2655             LeaveCriticalSection(&apt->cs);
2656             return S_OK;
2657         }
2658
2659     registered_psclsid = HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid));
2660     if (!registered_psclsid)
2661     {
2662         LeaveCriticalSection(&apt->cs);
2663         return E_OUTOFMEMORY;
2664     }
2665
2666     registered_psclsid->iid = *riid;
2667     registered_psclsid->clsid = *rclsid;
2668     list_add_head(&apt->psclsids, &registered_psclsid->entry);
2669
2670     LeaveCriticalSection(&apt->cs);
2671
2672     return S_OK;
2673 }
2674
2675
2676 /***
2677  * COM_GetRegisteredClassObject
2678  *
2679  * This internal method is used to scan the registered class list to
2680  * find a class object.
2681  *
2682  * Params:
2683  *   rclsid        Class ID of the class to find.
2684  *   dwClsContext  Class context to match.
2685  *   ppv           [out] returns a pointer to the class object. Complying
2686  *                 to normal COM usage, this method will increase the
2687  *                 reference count on this object.
2688  */
2689 static HRESULT COM_GetRegisteredClassObject(const struct apartment *apt, REFCLSID rclsid,
2690                                             DWORD dwClsContext, LPUNKNOWN* ppUnk)
2691 {
2692   HRESULT hr = S_FALSE;
2693   RegisteredClass *curClass;
2694
2695   EnterCriticalSection( &csRegisteredClassList );
2696
2697   LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
2698   {
2699     /*
2700      * Check if we have a match on the class ID and context.
2701      */
2702     if ((apt->oxid == curClass->apartment_id) &&
2703         (dwClsContext & curClass->runContext) &&
2704         IsEqualGUID(&(curClass->classIdentifier), rclsid))
2705     {
2706       /*
2707        * We have a match, return the pointer to the class object.
2708        */
2709       *ppUnk = curClass->classObject;
2710
2711       IUnknown_AddRef(curClass->classObject);
2712
2713       hr = S_OK;
2714       break;
2715     }
2716   }
2717
2718   LeaveCriticalSection( &csRegisteredClassList );
2719
2720   return hr;
2721 }
2722
2723 /******************************************************************************
2724  *              CoRegisterClassObject   [OLE32.@]
2725  *
2726  * Registers the class object for a given class ID. Servers housed in EXE
2727  * files use this method instead of exporting DllGetClassObject to allow
2728  * other code to connect to their objects.
2729  *
2730  * PARAMS
2731  *  rclsid       [I] CLSID of the object to register.
2732  *  pUnk         [I] IUnknown of the object.
2733  *  dwClsContext [I] CLSCTX flags indicating the context in which to run the executable.
2734  *  flags        [I] REGCLS flags indicating how connections are made.
2735  *  lpdwRegister [I] A unique cookie that can be passed to CoRevokeClassObject.
2736  *
2737  * RETURNS
2738  *   S_OK on success,
2739  *   E_INVALIDARG if lpdwRegister or pUnk are NULL,
2740  *   CO_E_OBJISREG if the object is already registered. We should not return this.
2741  *
2742  * SEE ALSO
2743  *   CoRevokeClassObject, CoGetClassObject
2744  *
2745  * NOTES
2746  *  In-process objects are only registered for the current apartment.
2747  *  CoGetClassObject() and CoCreateInstance() will not return objects registered
2748  *  in other apartments.
2749  *
2750  * BUGS
2751  *  MSDN claims that multiple interface registrations are legal, but we
2752  *  can't do that with our current implementation.
2753  */
2754 HRESULT WINAPI CoRegisterClassObject(
2755     REFCLSID rclsid,
2756     LPUNKNOWN pUnk,
2757     DWORD dwClsContext,
2758     DWORD flags,
2759     LPDWORD lpdwRegister)
2760 {
2761   static LONG next_cookie;
2762   RegisteredClass* newClass;
2763   LPUNKNOWN        foundObject;
2764   HRESULT          hr;
2765   APARTMENT *apt;
2766
2767   TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
2768         debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
2769
2770   if ( (lpdwRegister==0) || (pUnk==0) )
2771     return E_INVALIDARG;
2772
2773   apt = COM_CurrentApt();
2774   if (!apt)
2775   {
2776       ERR("COM was not initialized\n");
2777       return CO_E_NOTINITIALIZED;
2778   }
2779
2780   *lpdwRegister = 0;
2781
2782   /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
2783    * differentiates the flag from REGCLS_MULTI_SEPARATE. */
2784   if (flags & REGCLS_MULTIPLEUSE)
2785     dwClsContext |= CLSCTX_INPROC_SERVER;
2786
2787   /*
2788    * First, check if the class is already registered.
2789    * If it is, this should cause an error.
2790    */
2791   hr = COM_GetRegisteredClassObject(apt, rclsid, dwClsContext, &foundObject);
2792   if (hr == S_OK) {
2793     if (flags & REGCLS_MULTIPLEUSE) {
2794       if (dwClsContext & CLSCTX_LOCAL_SERVER)
2795         hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
2796       IUnknown_Release(foundObject);
2797       return hr;
2798     }
2799     IUnknown_Release(foundObject);
2800     ERR("object already registered for class %s\n", debugstr_guid(rclsid));
2801     return CO_E_OBJISREG;
2802   }
2803
2804   newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
2805   if ( newClass == NULL )
2806     return E_OUTOFMEMORY;
2807
2808   newClass->classIdentifier = *rclsid;
2809   newClass->apartment_id    = apt->oxid;
2810   newClass->runContext      = dwClsContext;
2811   newClass->connectFlags    = flags;
2812   newClass->RpcRegistration = NULL;
2813
2814   if (!(newClass->dwCookie = InterlockedIncrement( &next_cookie )))
2815       newClass->dwCookie = InterlockedIncrement( &next_cookie );
2816
2817   /*
2818    * Since we're making a copy of the object pointer, we have to increase its
2819    * reference count.
2820    */
2821   newClass->classObject     = pUnk;
2822   IUnknown_AddRef(newClass->classObject);
2823
2824   EnterCriticalSection( &csRegisteredClassList );
2825   list_add_tail(&RegisteredClassList, &newClass->entry);
2826   LeaveCriticalSection( &csRegisteredClassList );
2827
2828   *lpdwRegister = newClass->dwCookie;
2829
2830   if (dwClsContext & CLSCTX_LOCAL_SERVER) {
2831       IStream *marshal_stream;
2832
2833       hr = get_local_server_stream(apt, &marshal_stream);
2834       if(FAILED(hr))
2835           return hr;
2836
2837       hr = RPC_StartLocalServer(&newClass->classIdentifier,
2838                                 marshal_stream,
2839                                 flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
2840                                 &newClass->RpcRegistration);
2841       IStream_Release(marshal_stream);
2842   }
2843   return S_OK;
2844 }
2845
2846 static enum comclass_threadingmodel get_threading_model(const struct class_reg_data *data)
2847 {
2848     if (data->hkey)
2849     {
2850         static const WCHAR wszThreadingModel[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
2851         static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
2852         static const WCHAR wszFree[] = {'F','r','e','e',0};
2853         static const WCHAR wszBoth[] = {'B','o','t','h',0};
2854         WCHAR threading_model[10 /* strlenW(L"apartment")+1 */];
2855         DWORD dwLength = sizeof(threading_model);
2856         DWORD keytype;
2857         DWORD ret;
2858
2859         ret = RegQueryValueExW(data->u.hkey, wszThreadingModel, NULL, &keytype, (BYTE*)threading_model, &dwLength);
2860         if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
2861             threading_model[0] = '\0';
2862
2863         if (!strcmpiW(threading_model, wszApartment)) return ThreadingModel_Apartment;
2864         if (!strcmpiW(threading_model, wszFree)) return ThreadingModel_Free;
2865         if (!strcmpiW(threading_model, wszBoth)) return ThreadingModel_Both;
2866
2867         /* there's not specific handling for this case */
2868         if (threading_model[0]) return ThreadingModel_Neutral;
2869         return ThreadingModel_No;
2870     }
2871     else
2872         return data->u.actctx.data->model;
2873 }
2874
2875 static HRESULT get_inproc_class_object(APARTMENT *apt, const struct class_reg_data *regdata,
2876                                        REFCLSID rclsid, REFIID riid,
2877                                        BOOL hostifnecessary, void **ppv)
2878 {
2879     WCHAR dllpath[MAX_PATH+1];
2880     BOOL apartment_threaded;
2881
2882     if (hostifnecessary)
2883     {
2884         enum comclass_threadingmodel model = get_threading_model(regdata);
2885
2886         if (model == ThreadingModel_Apartment)
2887         {
2888             apartment_threaded = TRUE;
2889             if (apt->multi_threaded)
2890                 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, regdata, rclsid, riid, ppv);
2891         }
2892         else if (model == ThreadingModel_Free)
2893         {
2894             apartment_threaded = FALSE;
2895             if (!apt->multi_threaded)
2896                 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, regdata, rclsid, riid, ppv);
2897         }
2898         /* everything except "Apartment", "Free" and "Both" */
2899         else if (model != ThreadingModel_Both)
2900         {
2901             apartment_threaded = TRUE;
2902             /* everything else is main-threaded */
2903             if (model != ThreadingModel_No)
2904                 FIXME("unrecognised threading model %d for object %s, should be main-threaded?\n", model, debugstr_guid(rclsid));
2905
2906             if (apt->multi_threaded || !apt->main)
2907                 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, regdata, rclsid, riid, ppv);
2908         }
2909         else
2910             apartment_threaded = FALSE;
2911     }
2912     else
2913         apartment_threaded = !apt->multi_threaded;
2914
2915     if (COM_RegReadPath(regdata, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
2916     {
2917         /* failure: CLSID is not found in registry */
2918         WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
2919         return REGDB_E_CLASSNOTREG;
2920     }
2921
2922     return apartment_getclassobject(apt, dllpath, apartment_threaded,
2923                                     rclsid, riid, ppv);
2924 }
2925
2926 /***********************************************************************
2927  *           CoGetClassObject [OLE32.@]
2928  *
2929  * Creates an object of the specified class.
2930  *
2931  * PARAMS
2932  *  rclsid       [I] Class ID to create an instance of.
2933  *  dwClsContext [I] Flags to restrict the location of the created instance.
2934  *  pServerInfo  [I] Optional. Details for connecting to a remote server.
2935  *  iid          [I] The ID of the interface of the instance to return.
2936  *  ppv          [O] On returns, contains a pointer to the specified interface of the object.
2937  *
2938  * RETURNS
2939  *  Success: S_OK
2940  *  Failure: HRESULT code.
2941  *
2942  * NOTES
2943  *  The dwClsContext parameter can be one or more of the following:
2944  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2945  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2946  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2947  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2948  *
2949  * SEE ALSO
2950  *  CoCreateInstance()
2951  */
2952 HRESULT WINAPI DECLSPEC_HOTPATCH CoGetClassObject(
2953     REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
2954     REFIID iid, LPVOID *ppv)
2955 {
2956     struct class_reg_data clsreg;
2957     IUnknown *regClassObject;
2958     HRESULT     hres = E_UNEXPECTED;
2959     APARTMENT  *apt;
2960     BOOL release_apt = FALSE;
2961
2962     TRACE("CLSID: %s,IID: %s\n", debugstr_guid(rclsid), debugstr_guid(iid));
2963
2964     if (!ppv)
2965         return E_INVALIDARG;
2966
2967     *ppv = NULL;
2968
2969     if (!(apt = COM_CurrentApt()))
2970     {
2971         if (!(apt = apartment_find_multi_threaded()))
2972         {
2973             ERR("apartment not initialised\n");
2974             return CO_E_NOTINITIALIZED;
2975         }
2976         release_apt = TRUE;
2977     }
2978
2979     if (pServerInfo) {
2980         FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
2981               debugstr_w(pServerInfo->pwszName), pServerInfo->pAuthInfo);
2982     }
2983
2984     if (CLSCTX_INPROC_SERVER & dwClsContext)
2985     {
2986         if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
2987         {
2988             if (release_apt) apartment_release(apt);
2989             return FTMarshalCF_Create(iid, ppv);
2990         }
2991     }
2992
2993     if (CLSCTX_INPROC & dwClsContext)
2994     {
2995         ACTCTX_SECTION_KEYED_DATA data;
2996
2997         data.cbSize = sizeof(data);
2998         /* search activation context first */
2999         if (FindActCtxSectionGuid(FIND_ACTCTX_SECTION_KEY_RETURN_HACTCTX, NULL,
3000                                   ACTIVATION_CONTEXT_SECTION_COM_SERVER_REDIRECTION,
3001                                   rclsid, &data))
3002         {
3003             struct comclassredirect_data *comclass = (struct comclassredirect_data*)data.lpData;
3004
3005             clsreg.u.actctx.hactctx = data.hActCtx;
3006             clsreg.u.actctx.data = data.lpData;
3007             clsreg.u.actctx.section = data.lpSectionBase;
3008             clsreg.hkey = FALSE;
3009
3010             hres = get_inproc_class_object(apt, &clsreg, &comclass->clsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
3011             ReleaseActCtx(data.hActCtx);
3012             if (release_apt) apartment_release(apt);
3013             return hres;
3014         }
3015     }
3016
3017     /*
3018      * First, try and see if we can't match the class ID with one of the
3019      * registered classes.
3020      */
3021     if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
3022                                              &regClassObject))
3023     {
3024       /* Get the required interface from the retrieved pointer. */
3025       hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
3026
3027       /*
3028        * Since QI got another reference on the pointer, we want to release the
3029        * one we already have. If QI was unsuccessful, this will release the object. This
3030        * is good since we are not returning it in the "out" parameter.
3031        */
3032       IUnknown_Release(regClassObject);
3033       if (release_apt) apartment_release(apt);
3034       return hres;
3035     }
3036
3037     /* First try in-process server */
3038     if (CLSCTX_INPROC_SERVER & dwClsContext)
3039     {
3040         static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
3041         HKEY hkey;
3042
3043         hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
3044         if (FAILED(hres))
3045         {
3046             if (hres == REGDB_E_CLASSNOTREG)
3047                 ERR("class %s not registered\n", debugstr_guid(rclsid));
3048             else if (hres == REGDB_E_KEYMISSING)
3049             {
3050                 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
3051                 hres = REGDB_E_CLASSNOTREG;
3052             }
3053         }
3054
3055         if (SUCCEEDED(hres))
3056         {
3057             clsreg.u.hkey = hkey;
3058             clsreg.hkey = TRUE;
3059
3060             hres = get_inproc_class_object(apt, &clsreg, rclsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
3061             RegCloseKey(hkey);
3062         }
3063
3064         /* return if we got a class, otherwise fall through to one of the
3065          * other types */
3066         if (SUCCEEDED(hres))
3067         {
3068             if (release_apt) apartment_release(apt);
3069             return hres;
3070         }
3071     }
3072
3073     /* Next try in-process handler */
3074     if (CLSCTX_INPROC_HANDLER & dwClsContext)
3075     {
3076         static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
3077         HKEY hkey;
3078
3079         hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
3080         if (FAILED(hres))
3081         {
3082             if (hres == REGDB_E_CLASSNOTREG)
3083                 ERR("class %s not registered\n", debugstr_guid(rclsid));
3084             else if (hres == REGDB_E_KEYMISSING)
3085             {
3086                 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
3087                 hres = REGDB_E_CLASSNOTREG;
3088             }
3089         }
3090
3091         if (SUCCEEDED(hres))
3092         {
3093             clsreg.u.hkey = hkey;
3094             clsreg.hkey = TRUE;
3095
3096             hres = get_inproc_class_object(apt, &clsreg, rclsid, iid, !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
3097             RegCloseKey(hkey);
3098         }
3099
3100         /* return if we got a class, otherwise fall through to one of the
3101          * other types */
3102         if (SUCCEEDED(hres))
3103         {
3104             if (release_apt) apartment_release(apt);
3105             return hres;
3106         }
3107     }
3108     if (release_apt) apartment_release(apt);
3109
3110     /* Next try out of process */
3111     if (CLSCTX_LOCAL_SERVER & dwClsContext)
3112     {
3113         hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
3114         if (SUCCEEDED(hres))
3115             return hres;
3116     }
3117
3118     /* Finally try remote: this requires networked DCOM (a lot of work) */
3119     if (CLSCTX_REMOTE_SERVER & dwClsContext)
3120     {
3121         FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
3122         hres = REGDB_E_CLASSNOTREG;
3123     }
3124
3125     if (FAILED(hres))
3126         ERR("no class object %s could be created for context 0x%x\n",
3127             debugstr_guid(rclsid), dwClsContext);
3128     return hres;
3129 }
3130
3131 /***********************************************************************
3132  *        CoResumeClassObjects (OLE32.@)
3133  *
3134  * Resumes all class objects registered with REGCLS_SUSPENDED.
3135  *
3136  * RETURNS
3137  *  Success: S_OK.
3138  *  Failure: HRESULT code.
3139  */
3140 HRESULT WINAPI CoResumeClassObjects(void)
3141 {
3142        FIXME("stub\n");
3143         return S_OK;
3144 }
3145
3146 /***********************************************************************
3147  *           CoCreateInstance [OLE32.@]
3148  *
3149  * Creates an instance of the specified class.
3150  *
3151  * PARAMS
3152  *  rclsid       [I] Class ID to create an instance of.
3153  *  pUnkOuter    [I] Optional outer unknown to allow aggregation with another object.
3154  *  dwClsContext [I] Flags to restrict the location of the created instance.
3155  *  iid          [I] The ID of the interface of the instance to return.
3156  *  ppv          [O] On returns, contains a pointer to the specified interface of the instance.
3157  *
3158  * RETURNS
3159  *  Success: S_OK
3160  *  Failure: HRESULT code.
3161  *
3162  * NOTES
3163  *  The dwClsContext parameter can be one or more of the following:
3164  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
3165  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
3166  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
3167  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
3168  *
3169  * Aggregation is the concept of deferring the IUnknown of an object to another
3170  * object. This allows a separate object to behave as though it was part of
3171  * the object and to allow this the pUnkOuter parameter can be set. Note that
3172  * not all objects support having an outer of unknown.
3173  *
3174  * SEE ALSO
3175  *  CoGetClassObject()
3176  */
3177 HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstance(
3178     REFCLSID rclsid,
3179     LPUNKNOWN pUnkOuter,
3180     DWORD dwClsContext,
3181     REFIID iid,
3182     LPVOID *ppv)
3183 {
3184     HRESULT hres;
3185     LPCLASSFACTORY lpclf = 0;
3186     APARTMENT *apt;
3187     CLSID clsid;
3188
3189     TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
3190           pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
3191
3192     if (ppv==0)
3193         return E_POINTER;
3194
3195     hres = CoGetTreatAsClass(rclsid, &clsid);
3196     if(FAILED(hres))
3197         clsid = *rclsid;
3198
3199     *ppv = 0;
3200
3201     if (!(apt = COM_CurrentApt()))
3202     {
3203         if (!(apt = apartment_find_multi_threaded()))
3204         {
3205             ERR("apartment not initialised\n");
3206             return CO_E_NOTINITIALIZED;
3207         }
3208         apartment_release(apt);
3209     }
3210
3211     /*
3212      * The Standard Global Interface Table (GIT) object is a process-wide singleton.
3213      */
3214     if (IsEqualIID(&clsid, &CLSID_StdGlobalInterfaceTable))
3215     {
3216         IGlobalInterfaceTable *git = get_std_git();
3217         hres = IGlobalInterfaceTable_QueryInterface(git, iid, ppv);
3218         if (hres != S_OK) return hres;
3219
3220         TRACE("Retrieved GIT (%p)\n", *ppv);
3221         return S_OK;
3222     }
3223
3224     if (IsEqualCLSID(&clsid, &CLSID_ManualResetEvent))
3225         return ManualResetEvent_Construct(pUnkOuter, iid, ppv);
3226
3227     /*
3228      * Get a class factory to construct the object we want.
3229      */
3230     hres = CoGetClassObject(&clsid,
3231                             dwClsContext,
3232                             NULL,
3233                             &IID_IClassFactory,
3234                             (LPVOID)&lpclf);
3235
3236     if (FAILED(hres))
3237         return hres;
3238
3239     /*
3240      * Create the object and don't forget to release the factory
3241      */
3242     hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
3243     IClassFactory_Release(lpclf);
3244     if (FAILED(hres))
3245     {
3246         if (hres == CLASS_E_NOAGGREGATION && pUnkOuter)
3247             FIXME("Class %s does not support aggregation\n", debugstr_guid(&clsid));
3248         else
3249             FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n",
3250                   debugstr_guid(iid),
3251                   debugstr_guid(&clsid),hres);
3252     }
3253
3254     return hres;
3255 }
3256
3257 static void init_multi_qi(DWORD count, MULTI_QI *mqi)
3258 {
3259   ULONG i;
3260
3261   for (i = 0; i < count; i++)
3262   {
3263       mqi[i].pItf = NULL;
3264       mqi[i].hr = E_NOINTERFACE;
3265   }
3266 }
3267
3268 static HRESULT return_multi_qi(IUnknown *unk, DWORD count, MULTI_QI *mqi)
3269 {
3270   ULONG index, fetched = 0;
3271
3272   for (index = 0; index < count; index++)
3273   {
3274     mqi[index].hr = IUnknown_QueryInterface(unk, mqi[index].pIID, (void**)&mqi[index].pItf);
3275     if (mqi[index].hr == S_OK)
3276       fetched++;
3277   }
3278
3279   IUnknown_Release(unk);
3280
3281   if (fetched == 0)
3282     return E_NOINTERFACE;
3283
3284   return fetched == count ? S_OK : CO_S_NOTALLINTERFACES;
3285 }
3286
3287 /***********************************************************************
3288  *           CoCreateInstanceEx [OLE32.@]
3289  */
3290 HRESULT WINAPI DECLSPEC_HOTPATCH CoCreateInstanceEx(
3291   REFCLSID      rclsid,
3292   LPUNKNOWN     pUnkOuter,
3293   DWORD         dwClsContext,
3294   COSERVERINFO* pServerInfo,
3295   ULONG         cmq,
3296   MULTI_QI*     pResults)
3297 {
3298   IUnknown* pUnk = NULL;
3299   HRESULT   hr;
3300
3301   /*
3302    * Sanity check
3303    */
3304   if ( (cmq==0) || (pResults==NULL))
3305     return E_INVALIDARG;
3306
3307   if (pServerInfo!=NULL)
3308     FIXME("() non-NULL pServerInfo not supported!\n");
3309
3310   init_multi_qi(cmq, pResults);
3311
3312   /*
3313    * Get the object and get its IUnknown pointer.
3314    */
3315   hr = CoCreateInstance(rclsid,
3316                         pUnkOuter,
3317                         dwClsContext,
3318                         &IID_IUnknown,
3319                         (VOID**)&pUnk);
3320
3321   if (hr != S_OK)
3322     return hr;
3323
3324   return return_multi_qi(pUnk, cmq, pResults);
3325 }
3326
3327 /***********************************************************************
3328  *           CoGetInstanceFromFile [OLE32.@]
3329  */
3330 HRESULT WINAPI CoGetInstanceFromFile(
3331   COSERVERINFO *server_info,
3332   CLSID        *rclsid,
3333   IUnknown     *outer,
3334   DWORD         cls_context,
3335   DWORD         grfmode,
3336   OLECHAR      *filename,
3337   DWORD         count,
3338   MULTI_QI     *results
3339 )
3340 {
3341   IPersistFile *pf = NULL;
3342   IUnknown* unk = NULL;
3343   CLSID clsid;
3344   HRESULT hr;
3345
3346   if (count == 0 || !results)
3347     return E_INVALIDARG;
3348
3349   if (server_info)
3350     FIXME("() non-NULL server_info not supported\n");
3351
3352   init_multi_qi(count, results);
3353
3354   /* optionally get CLSID from a file */
3355   if (!rclsid)
3356   {
3357     hr = GetClassFile(filename, &clsid);
3358     if (FAILED(hr))
3359     {
3360       ERR("failed to get CLSID from a file\n");
3361       return hr;
3362     }
3363
3364     rclsid = &clsid;
3365   }
3366
3367   hr = CoCreateInstance(rclsid,
3368                         outer,
3369                         cls_context,
3370                         &IID_IUnknown,
3371                         (void**)&unk);
3372
3373   if (hr != S_OK)
3374     return hr;
3375
3376   /* init from file */
3377   hr = IUnknown_QueryInterface(unk, &IID_IPersistFile, (void**)&pf);
3378   if (FAILED(hr))
3379       ERR("failed to get IPersistFile\n");
3380
3381   if (pf)
3382   {
3383       IPersistFile_Load(pf, filename, grfmode);
3384       IPersistFile_Release(pf);
3385   }
3386
3387   return return_multi_qi(unk, count, results);
3388 }
3389
3390 /***********************************************************************
3391  *           CoGetInstanceFromIStorage [OLE32.@]
3392  */
3393 HRESULT WINAPI CoGetInstanceFromIStorage(
3394   COSERVERINFO *server_info,
3395   CLSID        *rclsid,
3396   IUnknown     *outer,
3397   DWORD         cls_context,
3398   IStorage     *storage,
3399   DWORD         count,
3400   MULTI_QI     *results
3401 )
3402 {
3403   IPersistStorage *ps = NULL;
3404   IUnknown* unk = NULL;
3405   STATSTG stat;
3406   HRESULT hr;
3407
3408   if (count == 0 || !results || !storage)
3409     return E_INVALIDARG;
3410
3411   if (server_info)
3412     FIXME("() non-NULL server_info not supported\n");
3413
3414   init_multi_qi(count, results);
3415
3416   /* optionally get CLSID from a file */
3417   if (!rclsid)
3418   {
3419     memset(&stat.clsid, 0, sizeof(stat.clsid));
3420     hr = IStorage_Stat(storage, &stat, STATFLAG_NONAME);
3421     if (FAILED(hr))
3422     {
3423       ERR("failed to get CLSID from a file\n");
3424       return hr;
3425     }
3426
3427     rclsid = &stat.clsid;
3428   }
3429
3430   hr = CoCreateInstance(rclsid,
3431                         outer,
3432                         cls_context,
3433                         &IID_IUnknown,
3434                         (void**)&unk);
3435
3436   if (hr != S_OK)
3437     return hr;
3438
3439   /* init from IStorage */
3440   hr = IUnknown_QueryInterface(unk, &IID_IPersistStorage, (void**)&ps);
3441   if (FAILED(hr))
3442       ERR("failed to get IPersistStorage\n");
3443
3444   if (ps)
3445   {
3446       IPersistStorage_Load(ps, storage);
3447       IPersistStorage_Release(ps);
3448   }
3449
3450   return return_multi_qi(unk, count, results);
3451 }
3452
3453 /***********************************************************************
3454  *           CoLoadLibrary (OLE32.@)
3455  *
3456  * Loads a library.
3457  *
3458  * PARAMS
3459  *  lpszLibName [I] Path to library.
3460  *  bAutoFree   [I] Whether the library should automatically be freed.
3461  *
3462  * RETURNS
3463  *  Success: Handle to loaded library.
3464  *  Failure: NULL.
3465  *
3466  * SEE ALSO
3467  *  CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
3468  */
3469 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
3470 {
3471     TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
3472
3473     return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
3474 }
3475
3476 /***********************************************************************
3477  *           CoFreeLibrary [OLE32.@]
3478  *
3479  * Unloads a library from memory.
3480  *
3481  * PARAMS
3482  *  hLibrary [I] Handle to library to unload.
3483  *
3484  * RETURNS
3485  *  Nothing
3486  *
3487  * SEE ALSO
3488  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
3489  */
3490 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
3491 {
3492     FreeLibrary(hLibrary);
3493 }
3494
3495
3496 /***********************************************************************
3497  *           CoFreeAllLibraries [OLE32.@]
3498  *
3499  * Function for backwards compatibility only. Does nothing.
3500  *
3501  * RETURNS
3502  *  Nothing.
3503  *
3504  * SEE ALSO
3505  *  CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
3506  */
3507 void WINAPI CoFreeAllLibraries(void)
3508 {
3509     /* NOP */
3510 }
3511
3512 /***********************************************************************
3513  *           CoFreeUnusedLibrariesEx [OLE32.@]
3514  *
3515  * Frees any previously unused libraries whose delay has expired and marks
3516  * currently unused libraries for unloading. Unused are identified as those that
3517  * return S_OK from their DllCanUnloadNow function.
3518  *
3519  * PARAMS
3520  *  dwUnloadDelay [I] Unload delay in milliseconds.
3521  *  dwReserved    [I] Reserved. Set to 0.
3522  *
3523  * RETURNS
3524  *  Nothing.
3525  *
3526  * SEE ALSO
3527  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
3528  */
3529 void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved)
3530 {
3531     struct apartment *apt = COM_CurrentApt();
3532     if (!apt)
3533     {
3534         ERR("apartment not initialised\n");
3535         return;
3536     }
3537
3538     apartment_freeunusedlibraries(apt, dwUnloadDelay);
3539 }
3540
3541 /***********************************************************************
3542  *           CoFreeUnusedLibraries [OLE32.@]
3543  *
3544  * Frees any unused libraries. Unused are identified as those that return
3545  * S_OK from their DllCanUnloadNow function.
3546  *
3547  * RETURNS
3548  *  Nothing.
3549  *
3550  * SEE ALSO
3551  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
3552  */
3553 void WINAPI DECLSPEC_HOTPATCH CoFreeUnusedLibraries(void)
3554 {
3555     CoFreeUnusedLibrariesEx(INFINITE, 0);
3556 }
3557
3558 /***********************************************************************
3559  *           CoFileTimeNow [OLE32.@]
3560  *
3561  * Retrieves the current time in FILETIME format.
3562  *
3563  * PARAMS
3564  *  lpFileTime [O] The current time.
3565  *
3566  * RETURNS
3567  *      S_OK.
3568  */
3569 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
3570 {
3571     GetSystemTimeAsFileTime( lpFileTime );
3572     return S_OK;
3573 }
3574
3575 /******************************************************************************
3576  *              CoLockObjectExternal    [OLE32.@]
3577  *
3578  * Increments or decrements the external reference count of a stub object.
3579  *
3580  * PARAMS
3581  *  pUnk                [I] Stub object.
3582  *  fLock               [I] If TRUE then increments the external ref-count,
3583  *                          otherwise decrements.
3584  *  fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
3585  *                          calling CoDisconnectObject.
3586  *
3587  * RETURNS
3588  *  Success: S_OK.
3589  *  Failure: HRESULT code.
3590  *
3591  * NOTES
3592  *  If fLock is TRUE and an object is passed in that doesn't have a stub
3593  *  manager then a new stub manager is created for the object.
3594  */
3595 HRESULT WINAPI CoLockObjectExternal(
3596     LPUNKNOWN pUnk,
3597     BOOL fLock,
3598     BOOL fLastUnlockReleases)
3599 {
3600     struct stub_manager *stubmgr;
3601     struct apartment *apt;
3602
3603     TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
3604           pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
3605
3606     apt = COM_CurrentApt();
3607     if (!apt) return CO_E_NOTINITIALIZED;
3608
3609     stubmgr = get_stub_manager_from_object(apt, pUnk);
3610
3611     if (stubmgr)
3612     {
3613         if (fLock)
3614             stub_manager_ext_addref(stubmgr, 1, FALSE);
3615         else
3616             stub_manager_ext_release(stubmgr, 1, FALSE, fLastUnlockReleases);
3617
3618         stub_manager_int_release(stubmgr);
3619
3620         return S_OK;
3621     }
3622     else if (fLock)
3623     {
3624         stubmgr = new_stub_manager(apt, pUnk);
3625
3626         if (stubmgr)
3627         {
3628             stub_manager_ext_addref(stubmgr, 1, FALSE);
3629             stub_manager_int_release(stubmgr);
3630         }
3631
3632         return S_OK;
3633     }
3634     else
3635     {
3636         WARN("stub object not found %p\n", pUnk);
3637         /* Note: native is pretty broken here because it just silently
3638          * fails, without returning an appropriate error code, making apps
3639          * think that the object was disconnected, when it actually wasn't */
3640         return S_OK;
3641     }
3642 }
3643
3644 /***********************************************************************
3645  *           CoInitializeWOW (OLE32.@)
3646  *
3647  * WOW equivalent of CoInitialize?
3648  *
3649  * PARAMS
3650  *  x [I] Unknown.
3651  *  y [I] Unknown.
3652  *
3653  * RETURNS
3654  *  Unknown.
3655  */
3656 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
3657 {
3658     FIXME("(0x%08x,0x%08x),stub!\n",x,y);
3659     return 0;
3660 }
3661
3662 /***********************************************************************
3663  *           CoGetState [OLE32.@]
3664  *
3665  * Retrieves the thread state object previously stored by CoSetState().
3666  *
3667  * PARAMS
3668  *  ppv [I] Address where pointer to object will be stored.
3669  *
3670  * RETURNS
3671  *  Success: S_OK.
3672  *  Failure: E_OUTOFMEMORY.
3673  *
3674  * NOTES
3675  *  Crashes on all invalid ppv addresses, including NULL.
3676  *  If the function returns a non-NULL object then the caller must release its
3677  *  reference on the object when the object is no longer required.
3678  *
3679  * SEE ALSO
3680  *  CoSetState().
3681  */
3682 HRESULT WINAPI CoGetState(IUnknown ** ppv)
3683 {
3684     struct oletls *info = COM_CurrentInfo();
3685     if (!info) return E_OUTOFMEMORY;
3686
3687     *ppv = NULL;
3688
3689     if (info->state)
3690     {
3691         IUnknown_AddRef(info->state);
3692         *ppv = info->state;
3693         TRACE("apt->state=%p\n", info->state);
3694     }
3695
3696     return S_OK;
3697 }
3698
3699 /***********************************************************************
3700  *           CoSetState [OLE32.@]
3701  *
3702  * Sets the thread state object.
3703  *
3704  * PARAMS
3705  *  pv [I] Pointer to state object to be stored.
3706  *
3707  * NOTES
3708  *  The system keeps a reference on the object while the object stored.
3709  *
3710  * RETURNS
3711  *  Success: S_OK.
3712  *  Failure: E_OUTOFMEMORY.
3713  */
3714 HRESULT WINAPI CoSetState(IUnknown * pv)
3715 {
3716     struct oletls *info = COM_CurrentInfo();
3717     if (!info) return E_OUTOFMEMORY;
3718
3719     if (pv) IUnknown_AddRef(pv);
3720
3721     if (info->state)
3722     {
3723         TRACE("-- release %p now\n", info->state);
3724         IUnknown_Release(info->state);
3725     }
3726
3727     info->state = pv;
3728
3729     return S_OK;
3730 }
3731
3732
3733 /******************************************************************************
3734  *              CoTreatAsClass        [OLE32.@]
3735  *
3736  * Sets the TreatAs value of a class.
3737  *
3738  * PARAMS
3739  *  clsidOld [I] Class to set TreatAs value on.
3740  *  clsidNew [I] The class the clsidOld should be treated as.
3741  *
3742  * RETURNS
3743  *  Success: S_OK.
3744  *  Failure: HRESULT code.
3745  *
3746  * SEE ALSO
3747  *  CoGetTreatAsClass
3748  */
3749 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
3750 {
3751     static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
3752     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
3753     HKEY hkey = NULL;
3754     WCHAR szClsidNew[CHARS_IN_GUID];
3755     HRESULT res = S_OK;
3756     WCHAR auto_treat_as[CHARS_IN_GUID];
3757     LONG auto_treat_as_size = sizeof(auto_treat_as);
3758     CLSID id;
3759
3760     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
3761     if (FAILED(res))
3762         goto done;
3763
3764     if (IsEqualGUID( clsidOld, clsidNew ))
3765     {
3766        if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
3767            CLSIDFromString(auto_treat_as, &id) == S_OK)
3768        {
3769            if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
3770            {
3771                res = REGDB_E_WRITEREGDB;
3772                goto done;
3773            }
3774        }
3775        else
3776        {
3777            if(RegDeleteKeyW(hkey, wszTreatAs))
3778                res = REGDB_E_WRITEREGDB;
3779            goto done;
3780        }
3781     }
3782     else
3783     {
3784         if(IsEqualGUID(clsidNew, &CLSID_NULL)){
3785            RegDeleteKeyW(hkey, wszTreatAs);
3786         }else{
3787             if(!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew))){
3788                 WARN("StringFromGUID2 failed\n");
3789                 res = E_FAIL;
3790                 goto done;
3791             }
3792
3793             if(RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)) != ERROR_SUCCESS){
3794                 WARN("RegSetValue failed\n");
3795                 res = REGDB_E_WRITEREGDB;
3796                 goto done;
3797             }
3798         }
3799     }
3800
3801 done:
3802     if (hkey) RegCloseKey(hkey);
3803     return res;
3804 }
3805
3806 /******************************************************************************
3807  *              CoGetTreatAsClass        [OLE32.@]
3808  *
3809  * Gets the TreatAs value of a class.
3810  *
3811  * PARAMS
3812  *  clsidOld [I] Class to get the TreatAs value of.
3813  *  clsidNew [I] The class the clsidOld should be treated as.
3814  *
3815  * RETURNS
3816  *  Success: S_OK.
3817  *  Failure: HRESULT code.
3818  *
3819  * SEE ALSO
3820  *  CoSetTreatAsClass
3821  */
3822 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
3823 {
3824     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
3825     HKEY hkey = NULL;
3826     WCHAR szClsidNew[CHARS_IN_GUID];
3827     HRESULT res = S_OK;
3828     LONG len = sizeof(szClsidNew);
3829
3830     TRACE("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
3831     *clsidNew = *clsidOld; /* copy over old value */
3832
3833     res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
3834     if (FAILED(res))
3835     {
3836         res = S_FALSE;
3837         goto done;
3838     }
3839     if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
3840     {
3841         res = S_FALSE;
3842         goto done;
3843     }
3844     res = CLSIDFromString(szClsidNew,clsidNew);
3845     if (FAILED(res))
3846         ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
3847 done:
3848     if (hkey) RegCloseKey(hkey);
3849     return res;
3850 }
3851
3852 /******************************************************************************
3853  *              CoGetCurrentProcess     [OLE32.@]
3854  *
3855  * Gets the current process ID.
3856  *
3857  * RETURNS
3858  *  The current process ID.
3859  *
3860  * NOTES
3861  *   Is DWORD really the correct return type for this function?
3862  */
3863 DWORD WINAPI CoGetCurrentProcess(void)
3864 {
3865         return GetCurrentProcessId();
3866 }
3867
3868 /******************************************************************************
3869  *              CoRegisterMessageFilter [OLE32.@]
3870  *
3871  * Registers a message filter.
3872  *
3873  * PARAMS
3874  *  lpMessageFilter [I] Pointer to interface.
3875  *  lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
3876  *
3877  * RETURNS
3878  *  Success: S_OK.
3879  *  Failure: HRESULT code.
3880  *
3881  * NOTES
3882  *  Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
3883  *  lpMessageFilter removes the message filter.
3884  *
3885  *  If lplpMessageFilter is not NULL the previous message filter will be
3886  *  returned in the memory pointer to this parameter and the caller is
3887  *  responsible for releasing the object.
3888  *
3889  *  The current thread be in an apartment otherwise the function will crash.
3890  */
3891 HRESULT WINAPI CoRegisterMessageFilter(
3892     LPMESSAGEFILTER lpMessageFilter,
3893     LPMESSAGEFILTER *lplpMessageFilter)
3894 {
3895     struct apartment *apt;
3896     IMessageFilter *lpOldMessageFilter;
3897
3898     TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
3899
3900     apt = COM_CurrentApt();
3901
3902     /* can't set a message filter in a multi-threaded apartment */
3903     if (!apt || apt->multi_threaded)
3904     {
3905         WARN("can't set message filter in MTA or uninitialized apt\n");
3906         return CO_E_NOT_SUPPORTED;
3907     }
3908
3909     if (lpMessageFilter)
3910         IMessageFilter_AddRef(lpMessageFilter);
3911
3912     EnterCriticalSection(&apt->cs);
3913
3914     lpOldMessageFilter = apt->filter;
3915     apt->filter = lpMessageFilter;
3916
3917     LeaveCriticalSection(&apt->cs);
3918
3919     if (lplpMessageFilter)
3920         *lplpMessageFilter = lpOldMessageFilter;
3921     else if (lpOldMessageFilter)
3922         IMessageFilter_Release(lpOldMessageFilter);
3923
3924     return S_OK;
3925 }
3926
3927 /***********************************************************************
3928  *           CoIsOle1Class [OLE32.@]
3929  *
3930  * Determines whether the specified class an OLE v1 class.
3931  *
3932  * PARAMS
3933  *  clsid [I] Class to test.
3934  *
3935  * RETURNS
3936  *  TRUE if the class is an OLE v1 class, or FALSE otherwise.
3937  */
3938 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
3939 {
3940   FIXME("%s\n", debugstr_guid(clsid));
3941   return FALSE;
3942 }
3943
3944 /***********************************************************************
3945  *           IsEqualGUID [OLE32.@]
3946  *
3947  * Compares two Unique Identifiers.
3948  *
3949  * PARAMS
3950  *  rguid1 [I] The first GUID to compare.
3951  *  rguid2 [I] The other GUID to compare.
3952  *
3953  * RETURNS
3954  *      TRUE if equal
3955  */
3956 #undef IsEqualGUID
3957 BOOL WINAPI IsEqualGUID(
3958      REFGUID rguid1,
3959      REFGUID rguid2)
3960 {
3961     return !memcmp(rguid1,rguid2,sizeof(GUID));
3962 }
3963
3964 /***********************************************************************
3965  *           CoInitializeSecurity [OLE32.@]
3966  */
3967 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
3968                                     SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
3969                                     void* pReserved1, DWORD dwAuthnLevel,
3970                                     DWORD dwImpLevel, void* pReserved2,
3971                                     DWORD dwCapabilities, void* pReserved3)
3972 {
3973   FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
3974         asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
3975         dwCapabilities, pReserved3);
3976   return S_OK;
3977 }
3978
3979 /***********************************************************************
3980  *           CoSuspendClassObjects [OLE32.@]
3981  *
3982  * Suspends all registered class objects to prevent further requests coming in
3983  * for those objects.
3984  *
3985  * RETURNS
3986  *  Success: S_OK.
3987  *  Failure: HRESULT code.
3988  */
3989 HRESULT WINAPI CoSuspendClassObjects(void)
3990 {
3991     FIXME("\n");
3992     return S_OK;
3993 }
3994
3995 /***********************************************************************
3996  *           CoAddRefServerProcess [OLE32.@]
3997  *
3998  * Helper function for incrementing the reference count of a local-server
3999  * process.
4000  *
4001  * RETURNS
4002  *  New reference count.
4003  *
4004  * SEE ALSO
4005  *  CoReleaseServerProcess().
4006  */
4007 ULONG WINAPI CoAddRefServerProcess(void)
4008 {
4009     ULONG refs;
4010
4011     TRACE("\n");
4012
4013     EnterCriticalSection(&csRegisteredClassList);
4014     refs = ++s_COMServerProcessReferences;
4015     LeaveCriticalSection(&csRegisteredClassList);
4016
4017     TRACE("refs before: %d\n", refs - 1);
4018
4019     return refs;
4020 }
4021
4022 /***********************************************************************
4023  *           CoReleaseServerProcess [OLE32.@]
4024  *
4025  * Helper function for decrementing the reference count of a local-server
4026  * process.
4027  *
4028  * RETURNS
4029  *  New reference count.
4030  *
4031  * NOTES
4032  *  When reference count reaches 0, this function suspends all registered
4033  *  classes so no new connections are accepted.
4034  *
4035  * SEE ALSO
4036  *  CoAddRefServerProcess(), CoSuspendClassObjects().
4037  */
4038 ULONG WINAPI CoReleaseServerProcess(void)
4039 {
4040     ULONG refs;
4041
4042     TRACE("\n");
4043
4044     EnterCriticalSection(&csRegisteredClassList);
4045
4046     refs = --s_COMServerProcessReferences;
4047     /* FIXME: if (!refs) COM_SuspendClassObjects(); */
4048
4049     LeaveCriticalSection(&csRegisteredClassList);
4050
4051     TRACE("refs after: %d\n", refs);
4052
4053     return refs;
4054 }
4055
4056 /***********************************************************************
4057  *           CoIsHandlerConnected [OLE32.@]
4058  *
4059  * Determines whether a proxy is connected to a remote stub.
4060  *
4061  * PARAMS
4062  *  pUnk [I] Pointer to object that may or may not be connected.
4063  *
4064  * RETURNS
4065  *  TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
4066  *  FALSE otherwise.
4067  */
4068 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
4069 {
4070     FIXME("%p\n", pUnk);
4071
4072     return TRUE;
4073 }
4074
4075 /***********************************************************************
4076  *           CoAllowSetForegroundWindow [OLE32.@]
4077  *
4078  */
4079 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
4080 {
4081     FIXME("(%p, %p): stub\n", pUnk, pvReserved);
4082     return S_OK;
4083 }
4084
4085 /***********************************************************************
4086  *           CoQueryProxyBlanket [OLE32.@]
4087  *
4088  * Retrieves the security settings being used by a proxy.
4089  *
4090  * PARAMS
4091  *  pProxy        [I] Pointer to the proxy object.
4092  *  pAuthnSvc     [O] The type of authentication service.
4093  *  pAuthzSvc     [O] The type of authorization service.
4094  *  ppServerPrincName [O] Optional. The server prinicple name.
4095  *  pAuthnLevel   [O] The authentication level.
4096  *  pImpLevel     [O] The impersonation level.
4097  *  ppAuthInfo    [O] Information specific to the authorization/authentication service.
4098  *  pCapabilities [O] Flags affecting the security behaviour.
4099  *
4100  * RETURNS
4101  *  Success: S_OK.
4102  *  Failure: HRESULT code.
4103  *
4104  * SEE ALSO
4105  *  CoCopyProxy, CoSetProxyBlanket.
4106  */
4107 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
4108     DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
4109     DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
4110 {
4111     IClientSecurity *pCliSec;
4112     HRESULT hr;
4113
4114     TRACE("%p\n", pProxy);
4115
4116     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
4117     if (SUCCEEDED(hr))
4118     {
4119         hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
4120                                           pAuthzSvc, ppServerPrincName,
4121                                           pAuthnLevel, pImpLevel, ppAuthInfo,
4122                                           pCapabilities);
4123         IClientSecurity_Release(pCliSec);
4124     }
4125
4126     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
4127     return hr;
4128 }
4129
4130 /***********************************************************************
4131  *           CoSetProxyBlanket [OLE32.@]
4132  *
4133  * Sets the security settings for a proxy.
4134  *
4135  * PARAMS
4136  *  pProxy       [I] Pointer to the proxy object.
4137  *  AuthnSvc     [I] The type of authentication service.
4138  *  AuthzSvc     [I] The type of authorization service.
4139  *  pServerPrincName [I] The server prinicple name.
4140  *  AuthnLevel   [I] The authentication level.
4141  *  ImpLevel     [I] The impersonation level.
4142  *  pAuthInfo    [I] Information specific to the authorization/authentication service.
4143  *  Capabilities [I] Flags affecting the security behaviour.
4144  *
4145  * RETURNS
4146  *  Success: S_OK.
4147  *  Failure: HRESULT code.
4148  *
4149  * SEE ALSO
4150  *  CoQueryProxyBlanket, CoCopyProxy.
4151  */
4152 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
4153     DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
4154     DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
4155 {
4156     IClientSecurity *pCliSec;
4157     HRESULT hr;
4158
4159     TRACE("%p\n", pProxy);
4160
4161     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
4162     if (SUCCEEDED(hr))
4163     {
4164         hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
4165                                         AuthzSvc, pServerPrincName,
4166                                         AuthnLevel, ImpLevel, pAuthInfo,
4167                                         Capabilities);
4168         IClientSecurity_Release(pCliSec);
4169     }
4170
4171     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
4172     return hr;
4173 }
4174
4175 /***********************************************************************
4176  *           CoCopyProxy [OLE32.@]
4177  *
4178  * Copies a proxy.
4179  *
4180  * PARAMS
4181  *  pProxy [I] Pointer to the proxy object.
4182  *  ppCopy [O] Copy of the proxy.
4183  *
4184  * RETURNS
4185  *  Success: S_OK.
4186  *  Failure: HRESULT code.
4187  *
4188  * SEE ALSO
4189  *  CoQueryProxyBlanket, CoSetProxyBlanket.
4190  */
4191 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
4192 {
4193     IClientSecurity *pCliSec;
4194     HRESULT hr;
4195
4196     TRACE("%p\n", pProxy);
4197
4198     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
4199     if (SUCCEEDED(hr))
4200     {
4201         hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
4202         IClientSecurity_Release(pCliSec);
4203     }
4204
4205     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
4206     return hr;
4207 }
4208
4209
4210 /***********************************************************************
4211  *           CoGetCallContext [OLE32.@]
4212  *
4213  * Gets the context of the currently executing server call in the current
4214  * thread.
4215  *
4216  * PARAMS
4217  *  riid [I] Context interface to return.
4218  *  ppv  [O] Pointer to memory that will receive the context on return.
4219  *
4220  * RETURNS
4221  *  Success: S_OK.
4222  *  Failure: HRESULT code.
4223  */
4224 HRESULT WINAPI CoGetCallContext(REFIID riid, void **ppv)
4225 {
4226     struct oletls *info = COM_CurrentInfo();
4227
4228     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
4229
4230     if (!info)
4231         return E_OUTOFMEMORY;
4232
4233     if (!info->call_state)
4234         return RPC_E_CALL_COMPLETE;
4235
4236     return IUnknown_QueryInterface(info->call_state, riid, ppv);
4237 }
4238
4239 /***********************************************************************
4240  *           CoSwitchCallContext [OLE32.@]
4241  *
4242  * Switches the context of the currently executing server call in the current
4243  * thread.
4244  *
4245  * PARAMS
4246  *  pObject     [I] Pointer to new context object
4247  *  ppOldObject [O] Pointer to memory that will receive old context object pointer
4248  *
4249  * RETURNS
4250  *  Success: S_OK.
4251  *  Failure: HRESULT code.
4252  */
4253 HRESULT WINAPI CoSwitchCallContext(IUnknown *pObject, IUnknown **ppOldObject)
4254 {
4255     struct oletls *info = COM_CurrentInfo();
4256
4257     TRACE("(%p, %p)\n", pObject, ppOldObject);
4258
4259     if (!info)
4260         return E_OUTOFMEMORY;
4261
4262     *ppOldObject = info->call_state;
4263     info->call_state = pObject; /* CoSwitchCallContext does not addref nor release objects */
4264
4265     return S_OK;
4266 }
4267
4268 /***********************************************************************
4269  *           CoQueryClientBlanket [OLE32.@]
4270  *
4271  * Retrieves the authentication information about the client of the currently
4272  * executing server call in the current thread.
4273  *
4274  * PARAMS
4275  *  pAuthnSvc     [O] Optional. The type of authentication service.
4276  *  pAuthzSvc     [O] Optional. The type of authorization service.
4277  *  pServerPrincName [O] Optional. The server prinicple name.
4278  *  pAuthnLevel   [O] Optional. The authentication level.
4279  *  pImpLevel     [O] Optional. The impersonation level.
4280  *  pPrivs        [O] Optional. Information about the privileges of the client.
4281  *  pCapabilities [IO] Optional. Flags affecting the security behaviour.
4282  *
4283  * RETURNS
4284  *  Success: S_OK.
4285  *  Failure: HRESULT code.
4286  *
4287  * SEE ALSO
4288  *  CoImpersonateClient, CoRevertToSelf, CoGetCallContext.
4289  */
4290 HRESULT WINAPI CoQueryClientBlanket(
4291     DWORD *pAuthnSvc,
4292     DWORD *pAuthzSvc,
4293     OLECHAR **pServerPrincName,
4294     DWORD *pAuthnLevel,
4295     DWORD *pImpLevel,
4296     RPC_AUTHZ_HANDLE *pPrivs,
4297     DWORD *pCapabilities)
4298 {
4299     IServerSecurity *pSrvSec;
4300     HRESULT hr;
4301
4302     TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
4303         pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel,
4304         pPrivs, pCapabilities);
4305
4306     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
4307     if (SUCCEEDED(hr))
4308     {
4309         hr = IServerSecurity_QueryBlanket(
4310             pSrvSec, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel,
4311             pImpLevel, pPrivs, pCapabilities);
4312         IServerSecurity_Release(pSrvSec);
4313     }
4314
4315     return hr;
4316 }
4317
4318 /***********************************************************************
4319  *           CoImpersonateClient [OLE32.@]
4320  *
4321  * Impersonates the client of the currently executing server call in the
4322  * current thread.
4323  *
4324  * PARAMS
4325  *  None.
4326  *
4327  * RETURNS
4328  *  Success: S_OK.
4329  *  Failure: HRESULT code.
4330  *
4331  * NOTES
4332  *  If this function fails then the current thread will not be impersonating
4333  *  the client and all actions will take place on behalf of the server.
4334  *  Therefore, it is important to check the return value from this function.
4335  *
4336  * SEE ALSO
4337  *  CoRevertToSelf, CoQueryClientBlanket, CoGetCallContext.
4338  */
4339 HRESULT WINAPI CoImpersonateClient(void)
4340 {
4341     IServerSecurity *pSrvSec;
4342     HRESULT hr;
4343
4344     TRACE("\n");
4345
4346     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
4347     if (SUCCEEDED(hr))
4348     {
4349         hr = IServerSecurity_ImpersonateClient(pSrvSec);
4350         IServerSecurity_Release(pSrvSec);
4351     }
4352
4353     return hr;
4354 }
4355
4356 /***********************************************************************
4357  *           CoRevertToSelf [OLE32.@]
4358  *
4359  * Ends the impersonation of the client of the currently executing server
4360  * call in the current thread.
4361  *
4362  * PARAMS
4363  *  None.
4364  *
4365  * RETURNS
4366  *  Success: S_OK.
4367  *  Failure: HRESULT code.
4368  *
4369  * SEE ALSO
4370  *  CoImpersonateClient, CoQueryClientBlanket, CoGetCallContext.
4371  */
4372 HRESULT WINAPI CoRevertToSelf(void)
4373 {
4374     IServerSecurity *pSrvSec;
4375     HRESULT hr;
4376
4377     TRACE("\n");
4378
4379     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
4380     if (SUCCEEDED(hr))
4381     {
4382         hr = IServerSecurity_RevertToSelf(pSrvSec);
4383         IServerSecurity_Release(pSrvSec);
4384     }
4385
4386     return hr;
4387 }
4388
4389 static BOOL COM_PeekMessage(struct apartment *apt, MSG *msg)
4390 {
4391     /* first try to retrieve messages for incoming COM calls to the apartment window */
4392     return PeekMessageW(msg, apt->win, 0, 0, PM_REMOVE|PM_NOYIELD) ||
4393            /* next retrieve other messages necessary for the app to remain responsive */
4394            PeekMessageW(msg, NULL, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE|PM_NOYIELD) ||
4395            PeekMessageW(msg, NULL, 0, 0, PM_QS_PAINT|PM_QS_SENDMESSAGE|PM_REMOVE|PM_NOYIELD);
4396 }
4397
4398 /***********************************************************************
4399  *           CoWaitForMultipleHandles [OLE32.@]
4400  *
4401  * Waits for one or more handles to become signaled.
4402  *
4403  * PARAMS
4404  *  dwFlags   [I] Flags. See notes.
4405  *  dwTimeout [I] Timeout in milliseconds.
4406  *  cHandles  [I] Number of handles pointed to by pHandles.
4407  *  pHandles  [I] Handles to wait for.
4408  *  lpdwindex [O] Index of handle that was signaled.
4409  *
4410  * RETURNS
4411  *  Success: S_OK.
4412  *  Failure: RPC_S_CALLPENDING on timeout.
4413  *
4414  * NOTES
4415  *
4416  * The dwFlags parameter can be zero or more of the following:
4417  *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
4418  *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
4419  *
4420  * SEE ALSO
4421  *  MsgWaitForMultipleObjects, WaitForMultipleObjects.
4422  */
4423 HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout,
4424     ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex)
4425 {
4426     HRESULT hr = S_OK;
4427     DWORD start_time = GetTickCount();
4428     APARTMENT *apt = COM_CurrentApt();
4429     BOOL message_loop = apt && !apt->multi_threaded;
4430     BOOL check_apc = (dwFlags & COWAIT_ALERTABLE) != 0;
4431
4432     TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags, dwTimeout, cHandles,
4433         pHandles, lpdwindex);
4434
4435     if (!lpdwindex)
4436         return E_INVALIDARG;
4437
4438     *lpdwindex = 0;
4439
4440     if (!pHandles)
4441         return E_INVALIDARG;
4442
4443     if (!cHandles)
4444         return RPC_E_NO_SYNC;
4445
4446     while (TRUE)
4447     {
4448         DWORD now = GetTickCount();
4449         DWORD res;
4450
4451         if (now - start_time > dwTimeout)
4452         {
4453             hr = RPC_S_CALLPENDING;
4454             break;
4455         }
4456
4457         if (message_loop)
4458         {
4459             DWORD wait_flags = ((dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0) |
4460                     ((dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0);
4461
4462             TRACE("waiting for rpc completion or window message\n");
4463
4464             res = WAIT_TIMEOUT;
4465
4466             if (check_apc)
4467             {
4468                 res = WaitForMultipleObjectsEx(cHandles, pHandles,
4469                     (dwFlags & COWAIT_WAITALL) != 0, 0, TRUE);
4470                 check_apc = FALSE;
4471             }
4472
4473             if (res == WAIT_TIMEOUT)
4474                 res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
4475                     (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
4476                     QS_SENDMESSAGE | QS_ALLPOSTMESSAGE | QS_PAINT, wait_flags);
4477
4478             if (res == WAIT_OBJECT_0 + cHandles)  /* messages available */
4479             {
4480                 MSG msg;
4481                 int count = 0;
4482
4483                 /* call message filter */
4484
4485                 if (COM_CurrentApt()->filter)
4486                 {
4487                     PENDINGTYPE pendingtype =
4488                         COM_CurrentInfo()->pending_call_count_server ?
4489                             PENDINGTYPE_NESTED : PENDINGTYPE_TOPLEVEL;
4490                     DWORD be_handled = IMessageFilter_MessagePending(
4491                         COM_CurrentApt()->filter, 0 /* FIXME */,
4492                         now - start_time, pendingtype);
4493                     TRACE("IMessageFilter_MessagePending returned %d\n", be_handled);
4494                     switch (be_handled)
4495                     {
4496                     case PENDINGMSG_CANCELCALL:
4497                         WARN("call canceled\n");
4498                         hr = RPC_E_CALL_CANCELED;
4499                         break;
4500                     case PENDINGMSG_WAITNOPROCESS:
4501                     case PENDINGMSG_WAITDEFPROCESS:
4502                     default:
4503                         /* FIXME: MSDN is very vague about the difference
4504                          * between WAITNOPROCESS and WAITDEFPROCESS - there
4505                          * appears to be none, so it is possibly a left-over
4506                          * from the 16-bit world. */
4507                         break;
4508                     }
4509                 }
4510
4511                 /* some apps (e.g. Visio 2010) don't handle WM_PAINT properly and loop forever,
4512                  * so after processing 100 messages we go back to checking the wait handles */
4513                 while (count++ < 100 && COM_PeekMessage(apt, &msg))
4514                 {
4515                     TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
4516                     TranslateMessage(&msg);
4517                     DispatchMessageW(&msg);
4518                     if (msg.message == WM_QUIT)
4519                     {
4520                         TRACE("resending WM_QUIT to outer message loop\n");
4521                         PostQuitMessage(msg.wParam);
4522                         /* no longer need to process messages */
4523                         message_loop = FALSE;
4524                         break;
4525                     }
4526                 }
4527                 continue;
4528             }
4529         }
4530         else
4531         {
4532             TRACE("waiting for rpc completion\n");
4533
4534             res = WaitForMultipleObjectsEx(cHandles, pHandles, (dwFlags & COWAIT_WAITALL) != 0,
4535                 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
4536                 (dwFlags & COWAIT_ALERTABLE) != 0);
4537         }
4538
4539         switch (res)
4540         {
4541         case WAIT_TIMEOUT:
4542             hr = RPC_S_CALLPENDING;
4543             break;
4544         case WAIT_FAILED:
4545             hr = HRESULT_FROM_WIN32( GetLastError() );
4546             break;
4547         default:
4548             *lpdwindex = res;
4549             break;
4550         }
4551         break;
4552     }
4553     TRACE("-- 0x%08x\n", hr);
4554     return hr;
4555 }
4556
4557
4558 /***********************************************************************
4559  *           CoGetObject [OLE32.@]
4560  *
4561  * Gets the object named by converting the name to a moniker and binding to it.
4562  *
4563  * PARAMS
4564  *  pszName      [I] String representing the object.
4565  *  pBindOptions [I] Parameters affecting the binding to the named object.
4566  *  riid         [I] Interface to bind to on the objecct.
4567  *  ppv          [O] On output, the interface riid of the object represented
4568  *                   by pszName.
4569  *
4570  * RETURNS
4571  *  Success: S_OK.
4572  *  Failure: HRESULT code.
4573  *
4574  * SEE ALSO
4575  *  MkParseDisplayName.
4576  */
4577 HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions,
4578     REFIID riid, void **ppv)
4579 {
4580     IBindCtx *pbc;
4581     HRESULT hr;
4582
4583     *ppv = NULL;
4584
4585     hr = CreateBindCtx(0, &pbc);
4586     if (SUCCEEDED(hr))
4587     {
4588         if (pBindOptions)
4589             hr = IBindCtx_SetBindOptions(pbc, pBindOptions);
4590
4591         if (SUCCEEDED(hr))
4592         {
4593             ULONG chEaten;
4594             IMoniker *pmk;
4595
4596             hr = MkParseDisplayName(pbc, pszName, &chEaten, &pmk);
4597             if (SUCCEEDED(hr))
4598             {
4599                 hr = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppv);
4600                 IMoniker_Release(pmk);
4601             }
4602         }
4603
4604         IBindCtx_Release(pbc);
4605     }
4606     return hr;
4607 }
4608
4609 /***********************************************************************
4610  *           CoRegisterChannelHook [OLE32.@]
4611  *
4612  * Registers a process-wide hook that is called during ORPC calls.
4613  *
4614  * PARAMS
4615  *  guidExtension [I] GUID of the channel hook to register.
4616  *  pChannelHook  [I] Channel hook object to register.
4617  *
4618  * RETURNS
4619  *  Success: S_OK.
4620  *  Failure: HRESULT code.
4621  */
4622 HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *pChannelHook)
4623 {
4624     TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook);
4625
4626     return RPC_RegisterChannelHook(guidExtension, pChannelHook);
4627 }
4628
4629 typedef struct Context
4630 {
4631     IComThreadingInfo IComThreadingInfo_iface;
4632     IContextCallback IContextCallback_iface;
4633     IObjContext IObjContext_iface;
4634     LONG refs;
4635     APTTYPE apttype;
4636 } Context;
4637
4638 static inline Context *impl_from_IComThreadingInfo( IComThreadingInfo *iface )
4639 {
4640         return CONTAINING_RECORD(iface, Context, IComThreadingInfo_iface);
4641 }
4642
4643 static inline Context *impl_from_IContextCallback( IContextCallback *iface )
4644 {
4645         return CONTAINING_RECORD(iface, Context, IContextCallback_iface);
4646 }
4647
4648 static inline Context *impl_from_IObjContext( IObjContext *iface )
4649 {
4650         return CONTAINING_RECORD(iface, Context, IObjContext_iface);
4651 }
4652
4653 static HRESULT Context_QueryInterface(Context *iface, REFIID riid, LPVOID *ppv)
4654 {
4655     *ppv = NULL;
4656
4657     if (IsEqualIID(riid, &IID_IComThreadingInfo) ||
4658         IsEqualIID(riid, &IID_IUnknown))
4659     {
4660         *ppv = &iface->IComThreadingInfo_iface;
4661     }
4662     else if (IsEqualIID(riid, &IID_IContextCallback))
4663     {
4664         *ppv = &iface->IContextCallback_iface;
4665     }
4666     else if (IsEqualIID(riid, &IID_IObjContext))
4667     {
4668         *ppv = &iface->IObjContext_iface;
4669     }
4670
4671     if (*ppv)
4672     {
4673         IUnknown_AddRef((IUnknown*)*ppv);
4674         return S_OK;
4675     }
4676
4677     FIXME("interface not implemented %s\n", debugstr_guid(riid));
4678     return E_NOINTERFACE;
4679 }
4680
4681 static ULONG Context_AddRef(Context *This)
4682 {
4683     return InterlockedIncrement(&This->refs);
4684 }
4685
4686 static ULONG Context_Release(Context *This)
4687 {
4688     ULONG refs = InterlockedDecrement(&This->refs);
4689     if (!refs)
4690         HeapFree(GetProcessHeap(), 0, This);
4691     return refs;
4692 }
4693
4694 static HRESULT WINAPI Context_CTI_QueryInterface(IComThreadingInfo *iface, REFIID riid, LPVOID *ppv)
4695 {
4696     Context *This = impl_from_IComThreadingInfo(iface);
4697     return Context_QueryInterface(This, riid, ppv);
4698 }
4699
4700 static ULONG WINAPI Context_CTI_AddRef(IComThreadingInfo *iface)
4701 {
4702     Context *This = impl_from_IComThreadingInfo(iface);
4703     return Context_AddRef(This);
4704 }
4705
4706 static ULONG WINAPI Context_CTI_Release(IComThreadingInfo *iface)
4707 {
4708     Context *This = impl_from_IComThreadingInfo(iface);
4709     return Context_Release(This);
4710 }
4711
4712 static HRESULT WINAPI Context_CTI_GetCurrentApartmentType(IComThreadingInfo *iface, APTTYPE *apttype)
4713 {
4714     Context *This = impl_from_IComThreadingInfo(iface);
4715
4716     TRACE("(%p)\n", apttype);
4717
4718     *apttype = This->apttype;
4719     return S_OK;
4720 }
4721
4722 static HRESULT WINAPI Context_CTI_GetCurrentThreadType(IComThreadingInfo *iface, THDTYPE *thdtype)
4723 {
4724     Context *This = impl_from_IComThreadingInfo(iface);
4725
4726     TRACE("(%p)\n", thdtype);
4727
4728     switch (This->apttype)
4729     {
4730     case APTTYPE_STA:
4731     case APTTYPE_MAINSTA:
4732         *thdtype = THDTYPE_PROCESSMESSAGES;
4733         break;
4734     default:
4735         *thdtype = THDTYPE_BLOCKMESSAGES;
4736         break;
4737     }
4738     return S_OK;
4739 }
4740
4741 static HRESULT WINAPI Context_CTI_GetCurrentLogicalThreadId(IComThreadingInfo *iface, GUID *logical_thread_id)
4742 {
4743     FIXME("(%p): stub\n", logical_thread_id);
4744     return E_NOTIMPL;
4745 }
4746
4747 static HRESULT WINAPI Context_CTI_SetCurrentLogicalThreadId(IComThreadingInfo *iface, REFGUID logical_thread_id)
4748 {
4749     FIXME("(%s): stub\n", debugstr_guid(logical_thread_id));
4750     return E_NOTIMPL;
4751 }
4752
4753 static const IComThreadingInfoVtbl Context_Threading_Vtbl =
4754 {
4755     Context_CTI_QueryInterface,
4756     Context_CTI_AddRef,
4757     Context_CTI_Release,
4758     Context_CTI_GetCurrentApartmentType,
4759     Context_CTI_GetCurrentThreadType,
4760     Context_CTI_GetCurrentLogicalThreadId,
4761     Context_CTI_SetCurrentLogicalThreadId
4762 };
4763
4764 static HRESULT WINAPI Context_CC_QueryInterface(IContextCallback *iface, REFIID riid, LPVOID *ppv)
4765 {
4766     Context *This = impl_from_IContextCallback(iface);
4767     return Context_QueryInterface(This, riid, ppv);
4768 }
4769
4770 static ULONG WINAPI Context_CC_AddRef(IContextCallback *iface)
4771 {
4772     Context *This = impl_from_IContextCallback(iface);
4773     return Context_AddRef(This);
4774 }
4775
4776 static ULONG WINAPI Context_CC_Release(IContextCallback *iface)
4777 {
4778     Context *This = impl_from_IContextCallback(iface);
4779     return Context_Release(This);
4780 }
4781
4782 static HRESULT WINAPI Context_CC_ContextCallback(IContextCallback *iface, PFNCONTEXTCALL pCallback,
4783                             ComCallData *param, REFIID riid, int method, IUnknown *punk)
4784 {
4785     Context *This = impl_from_IContextCallback(iface);
4786
4787     FIXME("(%p/%p)->(%p, %p, %s, %d, %p)\n", This, iface, pCallback, param, debugstr_guid(riid), method, punk);
4788     return E_NOTIMPL;
4789 }
4790
4791 static const IContextCallbackVtbl Context_Callback_Vtbl =
4792 {
4793     Context_CC_QueryInterface,
4794     Context_CC_AddRef,
4795     Context_CC_Release,
4796     Context_CC_ContextCallback
4797 };
4798
4799 static HRESULT WINAPI Context_OC_QueryInterface(IObjContext *iface, REFIID riid, LPVOID *ppv)
4800 {
4801     Context *This = impl_from_IObjContext(iface);
4802     return Context_QueryInterface(This, riid, ppv);
4803 }
4804
4805 static ULONG WINAPI Context_OC_AddRef(IObjContext *iface)
4806 {
4807     Context *This = impl_from_IObjContext(iface);
4808     return Context_AddRef(This);
4809 }
4810
4811 static ULONG WINAPI Context_OC_Release(IObjContext *iface)
4812 {
4813     Context *This = impl_from_IObjContext(iface);
4814     return Context_Release(This);
4815 }
4816
4817 static HRESULT WINAPI Context_OC_SetProperty(IObjContext *iface, REFGUID propid, CPFLAGS flags, IUnknown *punk)
4818 {
4819     Context *This = impl_from_IObjContext(iface);
4820
4821     FIXME("(%p/%p)->(%s, %x, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
4822     return E_NOTIMPL;
4823 }
4824
4825 static HRESULT WINAPI Context_OC_RemoveProperty(IObjContext *iface, REFGUID propid)
4826 {
4827     Context *This = impl_from_IObjContext(iface);
4828
4829     FIXME("(%p/%p)->(%s)\n", This, iface, debugstr_guid(propid));
4830     return E_NOTIMPL;
4831 }
4832
4833 static HRESULT WINAPI Context_OC_GetProperty(IObjContext *iface, REFGUID propid, CPFLAGS *flags, IUnknown **punk)
4834 {
4835     Context *This = impl_from_IObjContext(iface);
4836
4837     FIXME("(%p/%p)->(%s, %p, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
4838     return E_NOTIMPL;
4839 }
4840
4841 static HRESULT WINAPI Context_OC_EnumContextProps(IObjContext *iface, IEnumContextProps **props)
4842 {
4843     Context *This = impl_from_IObjContext(iface);
4844
4845     FIXME("(%p/%p)->(%p)\n", This, iface, props);
4846     return E_NOTIMPL;
4847 }
4848
4849 static void WINAPI Context_OC_Reserved1(IObjContext *iface)
4850 {
4851     Context *This = impl_from_IObjContext(iface);
4852     FIXME("(%p/%p)\n", This, iface);
4853 }
4854
4855 static void WINAPI Context_OC_Reserved2(IObjContext *iface)
4856 {
4857     Context *This = impl_from_IObjContext(iface);
4858     FIXME("(%p/%p)\n", This, iface);
4859 }
4860
4861 static void WINAPI Context_OC_Reserved3(IObjContext *iface)
4862 {
4863     Context *This = impl_from_IObjContext(iface);
4864     FIXME("(%p/%p)\n", This, iface);
4865 }
4866
4867 static void WINAPI Context_OC_Reserved4(IObjContext *iface)
4868 {
4869     Context *This = impl_from_IObjContext(iface);
4870     FIXME("(%p/%p)\n", This, iface);
4871 }
4872
4873 static void WINAPI Context_OC_Reserved5(IObjContext *iface)
4874 {
4875     Context *This = impl_from_IObjContext(iface);
4876     FIXME("(%p/%p)\n", This, iface);
4877 }
4878
4879 static void WINAPI Context_OC_Reserved6(IObjContext *iface)
4880 {
4881     Context *This = impl_from_IObjContext(iface);
4882     FIXME("(%p/%p)\n", This, iface);
4883 }
4884
4885 static void WINAPI Context_OC_Reserved7(IObjContext *iface)
4886 {
4887     Context *This = impl_from_IObjContext(iface);
4888     FIXME("(%p/%p)\n", This, iface);
4889 }
4890
4891 static const IObjContextVtbl Context_Object_Vtbl =
4892 {
4893     Context_OC_QueryInterface,
4894     Context_OC_AddRef,
4895     Context_OC_Release,
4896     Context_OC_SetProperty,
4897     Context_OC_RemoveProperty,
4898     Context_OC_GetProperty,
4899     Context_OC_EnumContextProps,
4900     Context_OC_Reserved1,
4901     Context_OC_Reserved2,
4902     Context_OC_Reserved3,
4903     Context_OC_Reserved4,
4904     Context_OC_Reserved5,
4905     Context_OC_Reserved6,
4906     Context_OC_Reserved7
4907 };
4908
4909 /***********************************************************************
4910  *           CoGetObjectContext [OLE32.@]
4911  *
4912  * Retrieves an object associated with the current context (i.e. apartment).
4913  *
4914  * PARAMS
4915  *  riid [I] ID of the interface of the object to retrieve.
4916  *  ppv  [O] Address where object will be stored on return.
4917  *
4918  * RETURNS
4919  *  Success: S_OK.
4920  *  Failure: HRESULT code.
4921  */
4922 HRESULT WINAPI CoGetObjectContext(REFIID riid, void **ppv)
4923 {
4924     APARTMENT *apt = COM_CurrentApt();
4925     Context *context;
4926     HRESULT hr;
4927
4928     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
4929
4930     *ppv = NULL;
4931     if (!apt)
4932     {
4933         if (!(apt = apartment_find_multi_threaded()))
4934         {
4935             ERR("apartment not initialised\n");
4936             return CO_E_NOTINITIALIZED;
4937         }
4938         apartment_release(apt);
4939     }
4940
4941     context = HeapAlloc(GetProcessHeap(), 0, sizeof(*context));
4942     if (!context)
4943         return E_OUTOFMEMORY;
4944
4945     context->IComThreadingInfo_iface.lpVtbl = &Context_Threading_Vtbl;
4946     context->IContextCallback_iface.lpVtbl = &Context_Callback_Vtbl;
4947     context->IObjContext_iface.lpVtbl = &Context_Object_Vtbl;
4948     context->refs = 1;
4949     if (apt->multi_threaded)
4950         context->apttype = APTTYPE_MTA;
4951     else if (apt->main)
4952         context->apttype = APTTYPE_MAINSTA;
4953     else
4954         context->apttype = APTTYPE_STA;
4955
4956     hr = IUnknown_QueryInterface((IUnknown *)&context->IComThreadingInfo_iface, riid, ppv);
4957     IUnknown_Release((IUnknown *)&context->IComThreadingInfo_iface);
4958
4959     return hr;
4960 }
4961
4962
4963 /***********************************************************************
4964  *           CoGetContextToken [OLE32.@]
4965  */
4966 HRESULT WINAPI CoGetContextToken( ULONG_PTR *token )
4967 {
4968     struct oletls *info = COM_CurrentInfo();
4969
4970     TRACE("(%p)\n", token);
4971
4972     if (!info)
4973         return E_OUTOFMEMORY;
4974
4975     if (!info->apt)
4976     {
4977         APARTMENT *apt;
4978         if (!(apt = apartment_find_multi_threaded()))
4979         {
4980             ERR("apartment not initialised\n");
4981             return CO_E_NOTINITIALIZED;
4982         }
4983         apartment_release(apt);
4984     }
4985
4986     if (!token)
4987         return E_POINTER;
4988
4989     if (!info->context_token)
4990     {
4991         HRESULT hr;
4992         IObjContext *ctx;
4993
4994         hr = CoGetObjectContext(&IID_IObjContext, (void **)&ctx);
4995         if (FAILED(hr)) return hr;
4996         info->context_token = ctx;
4997     }
4998
4999     *token = (ULONG_PTR)info->context_token;
5000     TRACE("apt->context_token=%p\n", info->context_token);
5001
5002     return S_OK;
5003 }
5004
5005 /***********************************************************************
5006  *           CoGetDefaultContext [OLE32.@]
5007  */
5008 HRESULT WINAPI CoGetDefaultContext(APTTYPE type, REFIID riid, LPVOID *ppv)
5009 {
5010     FIXME("%d %s %p stub\n", type, debugstr_guid(riid), ppv);
5011     return E_NOINTERFACE;
5012 }
5013
5014 HRESULT Handler_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
5015 {
5016     static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
5017     HKEY hkey;
5018     HRESULT hres;
5019
5020     hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
5021     if (SUCCEEDED(hres))
5022     {
5023         struct class_reg_data regdata;
5024         WCHAR dllpath[MAX_PATH+1];
5025
5026         regdata.u.hkey = hkey;
5027         regdata.hkey = TRUE;
5028
5029         if (COM_RegReadPath(&regdata, dllpath, ARRAYSIZE(dllpath)) == ERROR_SUCCESS)
5030         {
5031             static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
5032             if (!strcmpiW(dllpath, wszOle32))
5033             {
5034                 RegCloseKey(hkey);
5035                 return HandlerCF_Create(rclsid, riid, ppv);
5036             }
5037         }
5038         else
5039             WARN("not creating object for inproc handler path %s\n", debugstr_w(dllpath));
5040         RegCloseKey(hkey);
5041     }
5042
5043     return CLASS_E_CLASSNOTAVAILABLE;
5044 }
5045
5046 /***********************************************************************
5047  *              DllMain (OLE32.@)
5048  */
5049 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID reserved)
5050 {
5051     TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, reserved);
5052
5053     switch(fdwReason) {
5054     case DLL_PROCESS_ATTACH:
5055         hProxyDll = hinstDLL;
5056         break;
5057
5058     case DLL_PROCESS_DETACH:
5059         if (reserved) break;
5060         release_std_git();
5061         UnregisterClassW( wszAptWinClass, hProxyDll );
5062         RPC_UnregisterAllChannelHooks();
5063         COMPOBJ_DllList_Free();
5064         DeleteCriticalSection(&csRegisteredClassList);
5065         DeleteCriticalSection(&csApartment);
5066         break;
5067
5068     case DLL_THREAD_DETACH:
5069         COM_TlsDestroy();
5070         break;
5071     }
5072     return TRUE;
5073 }
5074
5075 /***********************************************************************
5076  *              DllRegisterServer (OLE32.@)
5077  */
5078 HRESULT WINAPI DllRegisterServer(void)
5079 {
5080     return OLE32_DllRegisterServer();
5081 }
5082
5083 /***********************************************************************
5084  *              DllUnregisterServer (OLE32.@)
5085  */
5086 HRESULT WINAPI DllUnregisterServer(void)
5087 {
5088     return OLE32_DllUnregisterServer();
5089 }