git.oblomov.eu Git - wine/blob - 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  *   - Make all ole interface marshaling use NDR to be wire compatible with
  38  *     native DCOM
  39  *
  40  */
  41
  42 #include "config.h"
  43
  44 #include <stdarg.h>
  45 #include <stdio.h>
  46 #include <string.h>
  47 #include <assert.h>
  48
  49 #define COBJMACROS
  50 #define NONAMELESSUNION
  51 #define NONAMELESSSTRUCT
  52
  53 #include "windef.h"
  54 #include "winbase.h"
  55 #include "winerror.h"
  56 #include "winreg.h"
  57 #include "winuser.h"
  58 #include "objbase.h"
  59 #include "ole2.h"
  60 #include "ole2ver.h"
  61
  62 #include "compobj_private.h"
  63
  64 #include "wine/unicode.h"
  65 #include "wine/debug.h"
  66
  67 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  68
  69 HINSTANCE OLE32_hInstance = 0; /* FIXME: make static ... */
  70
  71 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
  72
  73 /****************************************************************************
  74  * This section defines variables internal to the COM module.
  75  *
  76  * TODO: Most of these things will have to be made thread-safe.
  77  */
  78
  79 static HRESULT COM_GetRegisteredClassObject(const struct apartment *apt, REFCLSID rclsid,
  80                                             DWORD dwClsContext, LPUNKNOWN*  ppUnk);
  81 static void COM_RevokeAllClasses(const struct apartment *apt);
  82 static HRESULT get_inproc_class_object(APARTMENT *apt, HKEY hkeydll, REFCLSID rclsid, REFIID riid, void **ppv);
  83
  84 static APARTMENT *MTA; /* protected by csApartment */
  85 static APARTMENT *MainApartment; /* the first STA apartment */
  86 static struct list apts = LIST_INIT( apts ); /* protected by csApartment */
  87
  88 static CRITICAL_SECTION csApartment;
  89 static CRITICAL_SECTION_DEBUG critsect_debug =
  90 {
  91     0, 0, &csApartment,
  92     { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
  93       0, 0, { (DWORD_PTR)(__FILE__ ": csApartment") }
  94 };
  95 static CRITICAL_SECTION csApartment = { &critsect_debug, -1, 0, 0, 0, 0 };
  96
  97 struct registered_psclsid
  98 {
  99     struct list entry;
 100     IID iid;
 101     CLSID clsid;
 102 };
 103
 104 /*
 105  * This lock count counts the number of times CoInitialize is called. It is
 106  * decreased every time CoUninitialize is called. When it hits 0, the COM
 107  * libraries are freed
 108  */
 109 static LONG s_COMLockCount = 0;
 110 /* Reference count used by CoAddRefServerProcess/CoReleaseServerProcess */
 111 static LONG s_COMServerProcessReferences = 0;
 112
 113 /*
 114  * This linked list contains the list of registered class objects. These
 115  * are mostly used to register the factories for out-of-proc servers of OLE
 116  * objects.
 117  *
 118  * TODO: Make this data structure aware of inter-process communication. This
 119  *       means that parts of this will be exported to the Wine Server.
 120  */
 121 typedef struct tagRegisteredClass
 122 {
 123   struct list entry;
 124   CLSID     classIdentifier;
 125   OXID      apartment_id;
 126   LPUNKNOWN classObject;
 127   DWORD     runContext;
 128   DWORD     connectFlags;
 129   DWORD     dwCookie;
 130   LPSTREAM  pMarshaledData; /* FIXME: only really need to store OXID and IPID */
 131   void     *RpcRegistration;
 132 } RegisteredClass;
 133
 134 static struct list RegisteredClassList = LIST_INIT(RegisteredClassList);
 135
 136 static CRITICAL_SECTION csRegisteredClassList;
 137 static CRITICAL_SECTION_DEBUG class_cs_debug =
 138 {
 139     0, 0, &csRegisteredClassList,
 140     { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
 141       0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
 142 };
 143 static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 };
 144
 145 /*****************************************************************************
 146  * This section contains OpenDllList definitions
 147  *
 148  * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
 149  * other functions that do LoadLibrary _without_ giving back a HMODULE.
 150  * Without this list these handles would never be freed.
 151  *
 152  * FIXME: a DLL that says OK when asked for unloading is unloaded in the
 153  * next unload-call but not before 600 sec.
 154  */
 155
 156 typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
 157 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
 158
 159 typedef struct tagOpenDll
 160 {
 161   LONG refs;
 162   LPWSTR library_name;
 163   HANDLE library;
 164   DllGetClassObjectFunc DllGetClassObject;
 165   DllCanUnloadNowFunc DllCanUnloadNow;
 166   struct list entry;
 167 } OpenDll;
 168
 169 static struct list openDllList = LIST_INIT(openDllList);
 170
 171 static CRITICAL_SECTION csOpenDllList;
 172 static CRITICAL_SECTION_DEBUG dll_cs_debug =
 173 {
 174     0, 0, &csOpenDllList,
 175     { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
 176       0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
 177 };
 178 static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 };
 179
 180 struct apartment_loaded_dll
 181 {
 182     struct list entry;
 183     OpenDll *dll;
 184     DWORD unload_time;
 185     BOOL multi_threaded;
 186 };
 187
 188 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',' ',
 189                                        '0','x','#','#','#','#','#','#','#','#',' ',0};
 190 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);
 191 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
 192                                         BOOL apartment_threaded,
 193                                         REFCLSID rclsid, REFIID riid, void **ppv);
 194 static void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay);
 195
 196 static HRESULT COMPOBJ_DllList_Add(LPCWSTR library_name, OpenDll **ret);
 197 static OpenDll *COMPOBJ_DllList_Get(LPCWSTR library_name);
 198 static void COMPOBJ_DllList_ReleaseRef(OpenDll *entry, BOOL free_entry);
 199
 200 static DWORD COM_RegReadPath(HKEY hkeyroot, const WCHAR *keyname, const WCHAR *valuename, WCHAR * dst, DWORD dstlen);
 201
 202 static void COMPOBJ_InitProcess( void )
 203 {
 204     WNDCLASSW wclass;
 205
 206     /* Dispatching to the correct thread in an apartment is done through
 207      * window messages rather than RPC transports. When an interface is
 208      * marshalled into another apartment in the same process, a window of the
 209      * following class is created. The *caller* of CoMarshalInterface (ie the
 210      * application) is responsible for pumping the message loop in that thread.
 211      * The WM_USER messages which point to the RPCs are then dispatched to
 212      * COM_AptWndProc by the user's code from the apartment in which the interface
 213      * was unmarshalled.
 214      */
 215     memset(&wclass, 0, sizeof(wclass));
 216     wclass.lpfnWndProc = apartment_wndproc;
 217     wclass.hInstance = OLE32_hInstance;
 218     wclass.lpszClassName = wszAptWinClass;
 219     RegisterClassW(&wclass);
 220 }
 221
 222 static void COMPOBJ_UninitProcess( void )
 223 {
 224     UnregisterClassW(wszAptWinClass, OLE32_hInstance);
 225 }
 226
 227 static void COM_TlsDestroy(void)
 228 {
 229     struct oletls *info = NtCurrentTeb()->ReservedForOle;
 230     if (info)
 231     {
 232         if (info->apt) apartment_release(info->apt);
 233         if (info->errorinfo) IErrorInfo_Release(info->errorinfo);
 234         if (info->state) IUnknown_Release(info->state);
 235         HeapFree(GetProcessHeap(), 0, info);
 236         NtCurrentTeb()->ReservedForOle = NULL;
 237     }
 238 }
 239
 240 /******************************************************************************
 241  * Manage apartments.
 242  */
 243
 244 /* allocates memory and fills in the necessary fields for a new apartment
 245  * object. must be called inside apartment cs */
 246 static APARTMENT *apartment_construct(DWORD model)
 247 {
 248     APARTMENT *apt;
 249
 250     TRACE("creating new apartment, model=%d\n", model);
 251
 252     apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
 253     apt->tid = GetCurrentThreadId();
 254
 255     list_init(&apt->proxies);
 256     list_init(&apt->stubmgrs);
 257     list_init(&apt->psclsids);
 258     list_init(&apt->loaded_dlls);
 259     apt->ipidc = 0;
 260     apt->refs = 1;
 261     apt->remunk_exported = FALSE;
 262     apt->oidc = 1;
 263     InitializeCriticalSection(&apt->cs);
 264     DEBUG_SET_CRITSEC_NAME(&apt->cs, "apartment");
 265
 266     apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
 267
 268     if (apt->multi_threaded)
 269     {
 270         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 271         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
 272     }
 273     else
 274     {
 275         /* FIXME: should be randomly generated by in an RPC call to rpcss */
 276         apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
 277     }
 278
 279     TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 280
 281     list_add_head(&apts, &apt->entry);
 282
 283     return apt;
 284 }
 285
 286 /* gets and existing apartment if one exists or otherwise creates an apartment
 287  * structure which stores OLE apartment-local information and stores a pointer
 288  * to it in the thread-local storage */
 289 static APARTMENT *apartment_get_or_create(DWORD model)
 290 {
 291     APARTMENT *apt = COM_CurrentApt();
 292
 293     if (!apt)
 294     {
 295         if (model & COINIT_APARTMENTTHREADED)
 296         {
 297             EnterCriticalSection(&csApartment);
 298
 299             apt = apartment_construct(model);
 300             if (!MainApartment)
 301             {
 302                 MainApartment = apt;
 303                 apt->main = TRUE;
 304                 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
 305             }
 306
 307             LeaveCriticalSection(&csApartment);
 308
 309             if (apt->main)
 310                 apartment_createwindowifneeded(apt);
 311         }
 312         else
 313         {
 314             EnterCriticalSection(&csApartment);
 315
 316             /* The multi-threaded apartment (MTA) contains zero or more threads interacting
 317              * with free threaded (ie thread safe) COM objects. There is only ever one MTA
 318              * in a process */
 319             if (MTA)
 320             {
 321                 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA->oxid));
 322                 apartment_addref(MTA);
 323             }
 324             else
 325                 MTA = apartment_construct(model);
 326
 327             apt = MTA;
 328
 329             LeaveCriticalSection(&csApartment);
 330         }
 331         COM_CurrentInfo()->apt = apt;
 332     }
 333
 334     return apt;
 335 }
 336
 337 static inline BOOL apartment_is_model(const APARTMENT *apt, DWORD model)
 338 {
 339     return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
 340 }
 341
 342 DWORD apartment_addref(struct apartment *apt)
 343 {
 344     DWORD refs = InterlockedIncrement(&apt->refs);
 345     TRACE("%s: before = %d\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
 346     return refs;
 347 }
 348
 349 DWORD apartment_release(struct apartment *apt)
 350 {
 351     DWORD ret;
 352
 353     EnterCriticalSection(&csApartment);
 354
 355     ret = InterlockedDecrement(&apt->refs);
 356     TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt->oxid), ret);
 357     /* destruction stuff that needs to happen under csApartment CS */
 358     if (ret == 0)
 359     {
 360         if (apt == MTA) MTA = NULL;
 361         else if (apt == MainApartment) MainApartment = NULL;
 362         list_remove(&apt->entry);
 363     }
 364
 365     LeaveCriticalSection(&csApartment);
 366
 367     if (ret == 0)
 368     {
 369         struct list *cursor, *cursor2;
 370
 371         TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
 372
 373         /* Release the references to the registered class objects */
 374         COM_RevokeAllClasses(apt);
 375
 376         /* no locking is needed for this apartment, because no other thread
 377          * can access it at this point */
 378
 379         apartment_disconnectproxies(apt);
 380
 381         if (apt->win) DestroyWindow(apt->win);
 382         if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
 383
 384         LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
 385         {
 386             struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
 387             /* release the implicit reference given by the fact that the
 388              * stub has external references (it must do since it is in the
 389              * stub manager list in the apartment and all non-apartment users
 390              * must have a ref on the apartment and so it cannot be destroyed).
 391              */
 392             stub_manager_int_release(stubmgr);
 393         }
 394
 395         LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->psclsids)
 396         {
 397             struct registered_psclsid *registered_psclsid =
 398                 LIST_ENTRY(cursor, struct registered_psclsid, entry);
 399
 400             list_remove(&registered_psclsid->entry);
 401             HeapFree(GetProcessHeap(), 0, registered_psclsid);
 402         }
 403
 404         /* if this assert fires, then another thread took a reference to a
 405          * stub manager without taking a reference to the containing
 406          * apartment, which it must do. */
 407         assert(list_empty(&apt->stubmgrs));
 408
 409         if (apt->filter) IUnknown_Release(apt->filter);
 410
 411         /* free as many unused libraries as possible... */
 412         apartment_freeunusedlibraries(apt, 0);
 413
 414         /* ... and free the memory for the apartment loaded dll entry and
 415          * release the dll list reference without freeing the library for the
 416          * rest */
 417         while ((cursor = list_head(&apt->loaded_dlls)))
 418         {
 419             struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
 420             COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
 421             list_remove(cursor);
 422             HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
 423         }
 424
 425         DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
 426         DeleteCriticalSection(&apt->cs);
 427
 428         HeapFree(GetProcessHeap(), 0, apt);
 429     }
 430
 431     return ret;
 432 }
 433
 434 /* The given OXID must be local to this process:
 435  *
 436  * The ref parameter is here mostly to ensure people remember that
 437  * they get one, you should normally take a ref for thread safety.
 438  */
 439 APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
 440 {
 441     APARTMENT *result = NULL;
 442     struct list *cursor;
 443
 444     EnterCriticalSection(&csApartment);
 445     LIST_FOR_EACH( cursor, &apts )
 446     {
 447         struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
 448         if (apt->oxid == oxid)
 449         {
 450             result = apt;
 451             if (ref) apartment_addref(result);
 452             break;
 453         }
 454     }
 455     LeaveCriticalSection(&csApartment);
 456
 457     return result;
 458 }
 459
 460 /* gets the apartment which has a given creator thread ID. The caller must
 461  * release the reference from the apartment as soon as the apartment pointer
 462  * is no longer required. */
 463 APARTMENT *apartment_findfromtid(DWORD tid)
 464 {
 465     APARTMENT *result = NULL;
 466     struct list *cursor;
 467
 468     EnterCriticalSection(&csApartment);
 469     LIST_FOR_EACH( cursor, &apts )
 470     {
 471         struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
 472         if (apt->tid == tid)
 473         {
 474             result = apt;
 475             apartment_addref(result);
 476             break;
 477         }
 478     }
 479     LeaveCriticalSection(&csApartment);
 480
 481     return result;
 482 }
 483
 484 /* gets the main apartment if it exists. The caller must
 485  * release the reference from the apartment as soon as the apartment pointer
 486  * is no longer required. */
 487 static APARTMENT *apartment_findmain(void)
 488 {
 489     APARTMENT *result;
 490
 491     EnterCriticalSection(&csApartment);
 492
 493     result = MainApartment;
 494     if (result) apartment_addref(result);
 495
 496     LeaveCriticalSection(&csApartment);
 497
 498     return result;
 499 }
 500
 501 struct host_object_params
 502 {
 503     HKEY hkeydll;
 504     CLSID clsid; /* clsid of object to marshal */
 505     IID iid; /* interface to marshal */
 506     HANDLE event; /* event signalling when ready for multi-threaded case */
 507     HRESULT hr; /* result for multi-threaded case */
 508     IStream *stream; /* stream that the object will be marshaled into */
 509     BOOL apartment_threaded; /* is the component purely apartment-threaded? */
 510 };
 511
 512 static HRESULT apartment_hostobject(struct apartment *apt,
 513                                     const struct host_object_params *params)
 514 {
 515     IUnknown *object;
 516     HRESULT hr;
 517     static const LARGE_INTEGER llZero;
 518     WCHAR dllpath[MAX_PATH+1];
 519
 520     TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
 521
 522     if (COM_RegReadPath(params->hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
 523     {
 524         /* failure: CLSID is not found in registry */
 525         WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
 526         return REGDB_E_CLASSNOTREG;
 527     }
 528
 529     hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded,
 530                                   &params->clsid, &params->iid, (void **)&object);
 531     if (FAILED(hr))
 532         return hr;
 533
 534     hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
 535     if (FAILED(hr))
 536         IUnknown_Release(object);
 537     IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
 538
 539     return hr;
 540 }
 541
 542 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 543 {
 544     switch (msg)
 545     {
 546     case DM_EXECUTERPC:
 547         RPC_ExecuteCall((struct dispatch_params *)lParam);
 548         return 0;
 549     case DM_HOSTOBJECT:
 550         return apartment_hostobject(COM_CurrentApt(), (const struct host_object_params *)lParam);
 551     default:
 552         return DefWindowProcW(hWnd, msg, wParam, lParam);
 553     }
 554 }
 555
 556 struct host_thread_params
 557 {
 558     COINIT threading_model;
 559     HANDLE ready_event;
 560     HWND apartment_hwnd;
 561 };
 562
 563 static DWORD CALLBACK apartment_hostobject_thread(LPVOID p)
 564 {
 565     struct host_thread_params *params = p;
 566     MSG msg;
 567     HRESULT hr;
 568     struct apartment *apt;
 569
 570     TRACE("\n");
 571
 572     hr = CoInitializeEx(NULL, params->threading_model);
 573     if (FAILED(hr)) return hr;
 574
 575     apt = COM_CurrentApt();
 576     if (params->threading_model == COINIT_APARTMENTTHREADED)
 577     {
 578         apartment_createwindowifneeded(apt);
 579         params->apartment_hwnd = apartment_getwindow(apt);
 580     }
 581     else
 582         params->apartment_hwnd = NULL;
 583
 584     /* force the message queue to be created before signaling parent thread */
 585     PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
 586
 587     SetEvent(params->ready_event);
 588     params = NULL; /* can't touch params after here as it may be invalid */
 589
 590     while (GetMessageW(&msg, NULL, 0, 0))
 591     {
 592         if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
 593         {
 594             struct host_object_params *params = (struct host_object_params *)msg.lParam;
 595             params->hr = apartment_hostobject(apt, params);
 596             SetEvent(params->event);
 597         }
 598         else
 599         {
 600             TranslateMessage(&msg);
 601             DispatchMessageW(&msg);
 602         }
 603     }
 604
 605     TRACE("exiting\n");
 606
 607     CoUninitialize();
 608
 609     return S_OK;
 610 }
 611
 612 static HRESULT apartment_hostobject_in_hostapt(struct apartment *apt, BOOL multi_threaded, BOOL main_apartment, HKEY hkeydll, REFCLSID rclsid, REFIID riid, void **ppv)
 613 {
 614     struct host_object_params params;
 615     HWND apartment_hwnd = NULL;
 616     DWORD apartment_tid = 0;
 617     HRESULT hr;
 618
 619     if (!multi_threaded && main_apartment)
 620     {
 621         APARTMENT *host_apt = apartment_findmain();
 622         if (host_apt)
 623         {
 624             apartment_hwnd = apartment_getwindow(host_apt);
 625             apartment_release(host_apt);
 626         }
 627     }
 628
 629     if (!apartment_hwnd)
 630     {
 631         EnterCriticalSection(&apt->cs);
 632
 633         if (!apt->host_apt_tid)
 634         {
 635             struct host_thread_params thread_params;
 636             HANDLE handles[2];
 637             DWORD wait_value;
 638
 639             thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
 640             handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
 641             thread_params.apartment_hwnd = NULL;
 642             handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
 643             if (!handles[1])
 644             {
 645                 CloseHandle(handles[0]);
 646                 LeaveCriticalSection(&apt->cs);
 647                 return E_OUTOFMEMORY;
 648             }
 649             wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
 650             CloseHandle(handles[0]);
 651             CloseHandle(handles[1]);
 652             if (wait_value == WAIT_OBJECT_0)
 653                 apt->host_apt_hwnd = thread_params.apartment_hwnd;
 654             else
 655             {
 656                 LeaveCriticalSection(&apt->cs);
 657                 return E_OUTOFMEMORY;
 658             }
 659         }
 660
 661         if (multi_threaded || !main_apartment)
 662         {
 663             apartment_hwnd = apt->host_apt_hwnd;
 664             apartment_tid = apt->host_apt_tid;
 665         }
 666
 667         LeaveCriticalSection(&apt->cs);
 668     }
 669
 670     /* another thread may have become the main apartment in the time it took
 671      * us to create the thread for the host apartment */
 672     if (!apartment_hwnd && !multi_threaded && main_apartment)
 673     {
 674         APARTMENT *host_apt = apartment_findmain();
 675         if (host_apt)
 676         {
 677             apartment_hwnd = apartment_getwindow(host_apt);
 678             apartment_release(host_apt);
 679         }
 680     }
 681
 682     params.hkeydll = hkeydll;
 683     params.clsid = *rclsid;
 684     params.iid = *riid;
 685     hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
 686     if (FAILED(hr))
 687         return hr;
 688     params.apartment_threaded = !multi_threaded;
 689     if (multi_threaded)
 690     {
 691         params.hr = S_OK;
 692         params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
 693         if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
 694             hr = E_OUTOFMEMORY;
 695         else
 696         {
 697             WaitForSingleObject(params.event, INFINITE);
 698             hr = params.hr;
 699         }
 700         CloseHandle(params.event);
 701     }
 702     else
 703     {
 704         if (!apartment_hwnd)
 705         {
 706             ERR("host apartment didn't create window\n");
 707             hr = E_OUTOFMEMORY;
 708         }
 709         else
 710             hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
 711     }
 712     if (SUCCEEDED(hr))
 713         hr = CoUnmarshalInterface(params.stream, riid, ppv);
 714     IStream_Release(params.stream);
 715     return hr;
 716 }
 717
 718 HRESULT apartment_createwindowifneeded(struct apartment *apt)
 719 {
 720     if (apt->multi_threaded)
 721         return S_OK;
 722
 723     if (!apt->win)
 724     {
 725         HWND hwnd = CreateWindowW(wszAptWinClass, NULL, 0,
 726                                   0, 0, 0, 0,
 727                                   0, 0, OLE32_hInstance, NULL);
 728         if (!hwnd)
 729         {
 730             ERR("CreateWindow failed with error %d\n", GetLastError());
 731             return HRESULT_FROM_WIN32(GetLastError());
 732         }
 733         if (InterlockedCompareExchangePointer((PVOID *)&apt->win, hwnd, NULL))
 734             /* someone beat us to it */
 735             DestroyWindow(hwnd);
 736     }
 737
 738     return S_OK;
 739 }
 740
 741 HWND apartment_getwindow(const struct apartment *apt)
 742 {
 743     assert(!apt->multi_threaded);
 744     return apt->win;
 745 }
 746
 747 void apartment_joinmta(void)
 748 {
 749     apartment_addref(MTA);
 750     COM_CurrentInfo()->apt = MTA;
 751 }
 752
 753 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
 754                                         BOOL apartment_threaded,
 755                                         REFCLSID rclsid, REFIID riid, void **ppv)
 756 {
 757     static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
 758     HRESULT hr = S_OK;
 759     BOOL found = FALSE;
 760     struct apartment_loaded_dll *apartment_loaded_dll;
 761
 762     if (!strcmpiW(dllpath, wszOle32))
 763     {
 764         /* we don't need to control the lifetime of this dll, so use the local
 765          * implementation of DllGetClassObject directly */
 766         TRACE("calling ole32!DllGetClassObject\n");
 767         hr = DllGetClassObject(rclsid, riid, ppv);
 768
 769         if (hr != S_OK)
 770             ERR("DllGetClassObject returned error 0x%08x\n", hr);
 771
 772         return hr;
 773     }
 774
 775     EnterCriticalSection(&apt->cs);
 776
 777     LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
 778         if (!strcmpiW(dllpath, apartment_loaded_dll->dll->library_name))
 779         {
 780             TRACE("found %s already loaded\n", debugstr_w(dllpath));
 781             found = TRUE;
 782             break;
 783         }
 784
 785     if (!found)
 786     {
 787         apartment_loaded_dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*apartment_loaded_dll));
 788         if (!apartment_loaded_dll)
 789             hr = E_OUTOFMEMORY;
 790         if (SUCCEEDED(hr))
 791         {
 792             apartment_loaded_dll->unload_time = 0;
 793             apartment_loaded_dll->multi_threaded = FALSE;
 794             hr = COMPOBJ_DllList_Add( dllpath, &apartment_loaded_dll->dll );
 795             if (FAILED(hr))
 796                 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
 797         }
 798         if (SUCCEEDED(hr))
 799         {
 800             TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
 801             list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
 802         }
 803     }
 804
 805     LeaveCriticalSection(&apt->cs);
 806
 807     if (SUCCEEDED(hr))
 808     {
 809         /* one component being multi-threaded overrides any number of
 810          * apartment-threaded components */
 811         if (!apartment_threaded)
 812             apartment_loaded_dll->multi_threaded = TRUE;
 813
 814         TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
 815         /* OK: get the ClassObject */
 816         hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
 817
 818         if (hr != S_OK)
 819             ERR("DllGetClassObject returned error 0x%08x\n", hr);
 820     }
 821
 822     return hr;
 823 }
 824
 825 static void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay)
 826 {
 827     struct apartment_loaded_dll *entry, *next;
 828     EnterCriticalSection(&apt->cs);
 829     LIST_FOR_EACH_ENTRY_SAFE(entry, next, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
 830     {
 831         if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
 832         {
 833             DWORD real_delay = delay;
 834
 835             if (real_delay == INFINITE)
 836             {
 837                 if (entry->multi_threaded)
 838                     real_delay = 10 * 60 * 1000; /* 10 minutes */
 839                 else
 840                     real_delay = 0;
 841             }
 842
 843             if (!real_delay || (entry->unload_time && (entry->unload_time < GetTickCount())))
 844             {
 845                 list_remove(&entry->entry);
 846                 COMPOBJ_DllList_ReleaseRef(entry->dll, TRUE);
 847                 HeapFree(GetProcessHeap(), 0, entry);
 848             }
 849             else
 850                 entry->unload_time = GetTickCount() + real_delay;
 851         }
 852         else if (entry->unload_time)
 853             entry->unload_time = 0;
 854     }
 855     LeaveCriticalSection(&apt->cs);
 856 }
 857
 858 /*****************************************************************************
 859  * This section contains OpenDllList implementation
 860  */
 861
 862 /* caller must ensure that library_name is not already in the open dll list */
 863 static HRESULT COMPOBJ_DllList_Add(LPCWSTR library_name, OpenDll **ret)
 864 {
 865     OpenDll *entry;
 866     int len;
 867     HRESULT hr = S_OK;
 868     HANDLE hLibrary;
 869     DllCanUnloadNowFunc DllCanUnloadNow;
 870     DllGetClassObjectFunc DllGetClassObject;
 871
 872     TRACE("\n");
 873
 874     *ret = COMPOBJ_DllList_Get(library_name);
 875     if (*ret) return S_OK;
 876
 877     /* do this outside the csOpenDllList to avoid creating a lock dependency on
 878      * the loader lock */
 879     hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
 880     if (!hLibrary)
 881     {
 882         ERR("couldn't load in-process dll %s\n", debugstr_w(library_name));
 883         /* failure: DLL could not be loaded */
 884         return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
 885     }
 886
 887     DllCanUnloadNow = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
 888     /* Note: failing to find DllCanUnloadNow is not a failure */
 889     DllGetClassObject = (void *)GetProcAddress(hLibrary, "DllGetClassObject");
 890     if (!DllGetClassObject)
 891     {
 892         /* failure: the dll did not export DllGetClassObject */
 893         ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name));
 894         FreeLibrary(hLibrary);
 895         return CO_E_DLLNOTFOUND;
 896     }
 897
 898     EnterCriticalSection( &csOpenDllList );
 899
 900     *ret = COMPOBJ_DllList_Get(library_name);
 901     if (*ret)
 902     {
 903         /* another caller to this function already added the dll while we
 904          * weren't in the critical section */
 905         FreeLibrary(hLibrary);
 906     }
 907     else
 908     {
 909         len = strlenW(library_name);
 910         entry = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
 911         if (entry)
 912             entry->library_name = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
 913         if (entry && entry->library_name)
 914         {
 915             memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
 916             entry->library = hLibrary;
 917             entry->refs = 1;
 918             entry->DllCanUnloadNow = DllCanUnloadNow;
 919             entry->DllGetClassObject = DllGetClassObject;
 920             list_add_tail(&openDllList, &entry->entry);
 921         }
 922         else
 923         {
 924             hr = E_OUTOFMEMORY;
 925             FreeLibrary(hLibrary);
 926         }
 927         *ret = entry;
 928     }
 929
 930     LeaveCriticalSection( &csOpenDllList );
 931
 932     return hr;
 933 }
 934
 935 static OpenDll *COMPOBJ_DllList_Get(LPCWSTR library_name)
 936 {
 937     OpenDll *ptr;
 938     OpenDll *ret = NULL;
 939     EnterCriticalSection(&csOpenDllList);
 940     LIST_FOR_EACH_ENTRY(ptr, &openDllList, OpenDll, entry)
 941     {
 942         if (!strcmpiW(library_name, ptr->library_name) &&
 943             (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroy if == 1 */)
 944         {
 945             ret = ptr;
 946             break;
 947         }
 948     }
 949     LeaveCriticalSection(&csOpenDllList);
 950     return ret;
 951 }
 952
 953 /* pass FALSE for free_entry to release a reference without destroying the
 954  * entry if it reaches zero or TRUE otherwise */
 955 static void COMPOBJ_DllList_ReleaseRef(OpenDll *entry, BOOL free_entry)
 956 {
 957     if (!InterlockedDecrement(&entry->refs) && free_entry)
 958     {
 959         EnterCriticalSection(&csOpenDllList);
 960         list_remove(&entry->entry);
 961         LeaveCriticalSection(&csOpenDllList);
 962
 963         TRACE("freeing %p\n", entry->library);
 964         FreeLibrary(entry->library);
 965
 966         HeapFree(GetProcessHeap(), 0, entry->library_name);
 967         HeapFree(GetProcessHeap(), 0, entry);
 968     }
 969 }
 970
 971 /* frees memory associated with active dll list */
 972 static void COMPOBJ_DllList_Free(void)
 973 {
 974     OpenDll *entry, *cursor2;
 975     EnterCriticalSection(&csOpenDllList);
 976     LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &openDllList, OpenDll, entry)
 977     {
 978         list_remove(&entry->entry);
 979
 980         HeapFree(GetProcessHeap(), 0, entry->library_name);
 981         HeapFree(GetProcessHeap(), 0, entry);
 982     }
 983     LeaveCriticalSection(&csOpenDllList);
 984 }
 985
 986 /******************************************************************************
 987  *           CoBuildVersion [OLE32.@]
 988  *           CoBuildVersion [COMPOBJ.1]
 989  *
 990  * Gets the build version of the DLL.
 991  *
 992  * PARAMS
 993  *
 994  * RETURNS
 995  *      Current build version, hiword is majornumber, loword is minornumber
 996  */
 997 DWORD WINAPI CoBuildVersion(void)
 998 {
 999     TRACE("Returning version %d, build %d.\n", rmm, rup);
1000     return (rmm<<16)+rup;
1001 }
1002
1003 /******************************************************************************
1004  *              CoInitialize    [OLE32.@]
1005  *
1006  * Initializes the COM libraries by calling CoInitializeEx with
1007  * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
1008  *
1009  * PARAMS
1010  *  lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1011  *
1012  * RETURNS
1013  *  Success: S_OK if not already initialized, S_FALSE otherwise.
1014  *  Failure: HRESULT code.
1015  *
1016  * SEE ALSO
1017  *   CoInitializeEx
1018  */
1019 HRESULT WINAPI CoInitialize(LPVOID lpReserved)
1020 {
1021   /*
1022    * Just delegate to the newer method.
1023    */
1024   return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
1025 }
1026
1027 /******************************************************************************
1028  *              CoInitializeEx  [OLE32.@]
1029  *
1030  * Initializes the COM libraries.
1031  *
1032  * PARAMS
1033  *  lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1034  *  dwCoInit   [I] One or more flags from the COINIT enumeration. See notes.
1035  *
1036  * RETURNS
1037  *  S_OK               if successful,
1038  *  S_FALSE            if this function was called already.
1039  *  RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
1040  *                     threading model.
1041  *
1042  * NOTES
1043  *
1044  * The behavior used to set the IMalloc used for memory management is
1045  * obsolete.
1046  * The dwCoInit parameter must specify one of the following apartment
1047  * threading models:
1048  *| COINIT_APARTMENTTHREADED - A single-threaded apartment (STA).
1049  *| COINIT_MULTITHREADED - A multi-threaded apartment (MTA).
1050  * The parameter may also specify zero or more of the following flags:
1051  *| COINIT_DISABLE_OLE1DDE - Don't use DDE for OLE1 support.
1052  *| COINIT_SPEED_OVER_MEMORY - Trade memory for speed.
1053  *
1054  * SEE ALSO
1055  *   CoUninitialize
1056  */
1057 HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
1058 {
1059   HRESULT hr = S_OK;
1060   APARTMENT *apt;
1061
1062   TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
1063
1064   if (lpReserved!=NULL)
1065   {
1066     ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
1067   }
1068
1069   /*
1070    * Check the lock count. If this is the first time going through the initialize
1071    * process, we have to initialize the libraries.
1072    *
1073    * And crank-up that lock count.
1074    */
1075   if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
1076   {
1077     /*
1078      * Initialize the various COM libraries and data structures.
1079      */
1080     TRACE("() - Initializing the COM libraries\n");
1081
1082     /* we may need to defer this until after apartment initialisation */
1083     RunningObjectTableImpl_Initialize();
1084   }
1085
1086   if (!(apt = COM_CurrentInfo()->apt))
1087   {
1088     apt = apartment_get_or_create(dwCoInit);
1089     if (!apt) return E_OUTOFMEMORY;
1090   }
1091   else if (!apartment_is_model(apt, dwCoInit))
1092   {
1093     /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
1094        code then we are probably using the wrong threading model to implement that API. */
1095     ERR("Attempt to change threading model of this apartment from %s to %s\n",
1096         apt->multi_threaded ? "multi-threaded" : "apartment threaded",
1097         dwCoInit & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded");
1098     return RPC_E_CHANGED_MODE;
1099   }
1100   else
1101     hr = S_FALSE;
1102
1103   COM_CurrentInfo()->inits++;
1104
1105   return hr;
1106 }
1107
1108 /***********************************************************************
1109  *           CoUninitialize   [OLE32.@]
1110  *
1111  * This method will decrement the refcount on the current apartment, freeing
1112  * the resources associated with it if it is the last thread in the apartment.
1113  * If the last apartment is freed, the function will additionally release
1114  * any COM resources associated with the process.
1115  *
1116  * PARAMS
1117  *
1118  * RETURNS
1119  *  Nothing.
1120  *
1121  * SEE ALSO
1122  *   CoInitializeEx
1123  */
1124 void WINAPI CoUninitialize(void)
1125 {
1126   struct oletls * info = COM_CurrentInfo();
1127   LONG lCOMRefCnt;
1128
1129   TRACE("()\n");
1130
1131   /* will only happen on OOM */
1132   if (!info) return;
1133
1134   /* sanity check */
1135   if (!info->inits)
1136   {
1137     ERR("Mismatched CoUninitialize\n");
1138     return;
1139   }
1140
1141   if (!--info->inits)
1142   {
1143     apartment_release(info->apt);
1144     info->apt = NULL;
1145   }
1146
1147   /*
1148    * Decrease the reference count.
1149    * If we are back to 0 locks on the COM library, make sure we free
1150    * all the associated data structures.
1151    */
1152   lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
1153   if (lCOMRefCnt==1)
1154   {
1155     TRACE("() - Releasing the COM libraries\n");
1156
1157     RunningObjectTableImpl_UnInitialize();
1158   }
1159   else if (lCOMRefCnt<1) {
1160     ERR( "CoUninitialize() - not CoInitialized.\n" );
1161     InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
1162   }
1163 }
1164
1165 /******************************************************************************
1166  *              CoDisconnectObject      [OLE32.@]
1167  *
1168  * Disconnects all connections to this object from remote processes. Dispatches
1169  * pending RPCs while blocking new RPCs from occurring, and then calls
1170  * IMarshal::DisconnectObject on the given object.
1171  *
1172  * Typically called when the object server is forced to shut down, for instance by
1173  * the user.
1174  *
1175  * PARAMS
1176  *  lpUnk    [I] The object whose stub should be disconnected.
1177  *  reserved [I] Reserved. Should be set to 0.
1178  *
1179  * RETURNS
1180  *  Success: S_OK.
1181  *  Failure: HRESULT code.
1182  *
1183  * SEE ALSO
1184  *  CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
1185  */
1186 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
1187 {
1188     HRESULT hr;
1189     IMarshal *marshal;
1190     APARTMENT *apt;
1191
1192     TRACE("(%p, 0x%08x)\n", lpUnk, reserved);
1193
1194     hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
1195     if (hr == S_OK)
1196     {
1197         hr = IMarshal_DisconnectObject(marshal, reserved);
1198         IMarshal_Release(marshal);
1199         return hr;
1200     }
1201
1202     apt = COM_CurrentApt();
1203     if (!apt)
1204         return CO_E_NOTINITIALIZED;
1205
1206     apartment_disconnectobject(apt, lpUnk);
1207
1208     /* Note: native is pretty broken here because it just silently
1209      * fails, without returning an appropriate error code if the object was
1210      * not found, making apps think that the object was disconnected, when
1211      * it actually wasn't */
1212
1213     return S_OK;
1214 }
1215
1216 /******************************************************************************
1217  *              CoCreateGuid [OLE32.@]
1218  *              CoCreateGuid [COMPOBJ.73]
1219  *
1220  * Simply forwards to UuidCreate in RPCRT4.
1221  *
1222  * PARAMS
1223  *  pguid [O] Points to the GUID to initialize.
1224  *
1225  * RETURNS
1226  *  Success: S_OK.
1227  *  Failure: HRESULT code.
1228  *
1229  * SEE ALSO
1230  *   UuidCreate
1231  */
1232 HRESULT WINAPI CoCreateGuid(GUID *pguid)
1233 {
1234     return UuidCreate(pguid);
1235 }
1236
1237 /******************************************************************************
1238  *              CLSIDFromString [OLE32.@]
1239  *              IIDFromString   [OLE32.@]
1240  *
1241  * Converts a unique identifier from its string representation into
1242  * the GUID struct.
1243  *
1244  * PARAMS
1245  *  idstr [I] The string representation of the GUID.
1246  *  id    [O] GUID converted from the string.
1247  *
1248  * RETURNS
1249  *   S_OK on success
1250  *   CO_E_CLASSSTRING if idstr is not a valid CLSID
1251  *
1252  * SEE ALSO
1253  *  StringFromCLSID
1254  */
1255 static HRESULT WINAPI __CLSIDFromString(LPCWSTR s, CLSID *id)
1256 {
1257   int   i;
1258   BYTE table[256];
1259
1260   if (!s) {
1261     memset( id, 0, sizeof (CLSID) );
1262     return S_OK;
1263   }
1264
1265   /* validate the CLSID string */
1266   if (strlenW(s) != 38)
1267     return CO_E_CLASSSTRING;
1268
1269   if ((s[0]!='{') || (s[9]!='-') || (s[14]!='-') || (s[19]!='-') || (s[24]!='-') || (s[37]!='}'))
1270     return CO_E_CLASSSTRING;
1271
1272   for (i=1; i<37; i++) {
1273     if ((i == 9)||(i == 14)||(i == 19)||(i == 24)) continue;
1274     if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
1275           ((s[i] >= 'a') && (s[i] <= 'f'))  ||
1276           ((s[i] >= 'A') && (s[i] <= 'F'))))
1277        return CO_E_CLASSSTRING;
1278   }
1279
1280   TRACE("%s -> %p\n", debugstr_w(s), id);
1281
1282   /* quick lookup table */
1283   memset(table, 0, 256);
1284
1285   for (i = 0; i < 10; i++) {
1286     table['0' + i] = i;
1287   }
1288   for (i = 0; i < 6; i++) {
1289     table['A' + i] = i+10;
1290     table['a' + i] = i+10;
1291   }
1292
1293   /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
1294
1295   id->Data1 = (table[s[1]] << 28 | table[s[2]] << 24 | table[s[3]] << 20 | table[s[4]] << 16 |
1296                table[s[5]] << 12 | table[s[6]] << 8  | table[s[7]] << 4  | table[s[8]]);
1297   id->Data2 = table[s[10]] << 12 | table[s[11]] << 8 | table[s[12]] << 4 | table[s[13]];
1298   id->Data3 = table[s[15]] << 12 | table[s[16]] << 8 | table[s[17]] << 4 | table[s[18]];
1299
1300   /* these are just sequential bytes */
1301   id->Data4[0] = table[s[20]] << 4 | table[s[21]];
1302   id->Data4[1] = table[s[22]] << 4 | table[s[23]];
1303   id->Data4[2] = table[s[25]] << 4 | table[s[26]];
1304   id->Data4[3] = table[s[27]] << 4 | table[s[28]];
1305   id->Data4[4] = table[s[29]] << 4 | table[s[30]];
1306   id->Data4[5] = table[s[31]] << 4 | table[s[32]];
1307   id->Data4[6] = table[s[33]] << 4 | table[s[34]];
1308   id->Data4[7] = table[s[35]] << 4 | table[s[36]];
1309
1310   return S_OK;
1311 }
1312
1313 /*****************************************************************************/
1314
1315 HRESULT WINAPI CLSIDFromString(LPOLESTR idstr, CLSID *id )
1316 {
1317     HRESULT ret;
1318
1319     if (!id)
1320         return E_INVALIDARG;
1321
1322     ret = __CLSIDFromString(idstr, id);
1323     if(ret != S_OK) { /* It appears a ProgID is also valid */
1324         ret = CLSIDFromProgID(idstr, id);
1325     }
1326     return ret;
1327 }
1328
1329 /* Converts a GUID into the respective string representation. */
1330 HRESULT WINE_StringFromCLSID(
1331         const CLSID *id,        /* [in] GUID to be converted */
1332         LPSTR idstr             /* [out] pointer to buffer to contain converted guid */
1333 ) {
1334   static const char hex[] = "0123456789ABCDEF";
1335   char *s;
1336   int   i;
1337
1338   if (!id)
1339         { ERR("called with id=Null\n");
1340           *idstr = 0x00;
1341           return E_FAIL;
1342         }
1343
1344   sprintf(idstr, "{%08X-%04X-%04X-%02X%02X-",
1345           id->Data1, id->Data2, id->Data3,
1346           id->Data4[0], id->Data4[1]);
1347   s = &idstr[25];
1348
1349   /* 6 hex bytes */
1350   for (i = 2; i < 8; i++) {
1351     *s++ = hex[id->Data4[i]>>4];
1352     *s++ = hex[id->Data4[i] & 0xf];
1353   }
1354
1355   *s++ = '}';
1356   *s++ = '\0';
1357
1358   TRACE("%p->%s\n", id, idstr);
1359
1360   return S_OK;
1361 }
1362
1363
1364 /******************************************************************************
1365  *              StringFromCLSID [OLE32.@]
1366  *              StringFromIID   [OLE32.@]
1367  *
1368  * Converts a GUID into the respective string representation.
1369  * The target string is allocated using the OLE IMalloc.
1370  *
1371  * PARAMS
1372  *  id    [I] the GUID to be converted.
1373  *  idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
1374  *
1375  * RETURNS
1376  *   S_OK
1377  *   E_FAIL
1378  *
1379  * SEE ALSO
1380  *  StringFromGUID2, CLSIDFromString
1381  */
1382 HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
1383 {
1384         char            buf[80];
1385         HRESULT       ret;
1386         LPMALLOC        mllc;
1387
1388         if ((ret = CoGetMalloc(0,&mllc)))
1389                 return ret;
1390
1391         ret=WINE_StringFromCLSID(id,buf);
1392         if (!ret) {
1393             DWORD len = MultiByteToWideChar( CP_ACP, 0, buf, -1, NULL, 0 );
1394             *idstr = IMalloc_Alloc( mllc, len * sizeof(WCHAR) );
1395             MultiByteToWideChar( CP_ACP, 0, buf, -1, *idstr, len );
1396         }
1397         return ret;
1398 }
1399
1400 /******************************************************************************
1401  *              StringFromGUID2 [OLE32.@]
1402  *              StringFromGUID2 [COMPOBJ.76]
1403  *
1404  * Modified version of StringFromCLSID that allows you to specify max
1405  * buffer size.
1406  *
1407  * PARAMS
1408  *  id   [I] GUID to convert to string.
1409  *  str  [O] Buffer where the result will be stored.
1410  *  cmax [I] Size of the buffer in characters.
1411  *
1412  * RETURNS
1413  *      Success: The length of the resulting string in characters.
1414  *  Failure: 0.
1415  */
1416 INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
1417 {
1418   char          xguid[80];
1419
1420   if (WINE_StringFromCLSID(id,xguid))
1421         return 0;
1422   return MultiByteToWideChar( CP_ACP, 0, xguid, -1, str, cmax );
1423 }
1424
1425 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
1426 HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
1427 {
1428     static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
1429     WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) - 1];
1430     LONG res;
1431     HKEY key;
1432
1433     strcpyW(path, wszCLSIDSlash);
1434     StringFromGUID2(clsid, path + strlenW(wszCLSIDSlash), CHARS_IN_GUID);
1435     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, keyname ? KEY_READ : access, &key);
1436     if (res == ERROR_FILE_NOT_FOUND)
1437         return REGDB_E_CLASSNOTREG;
1438     else if (res != ERROR_SUCCESS)
1439         return REGDB_E_READREGDB;
1440
1441     if (!keyname)
1442     {
1443         *subkey = key;
1444         return S_OK;
1445     }
1446
1447     res = RegOpenKeyExW(key, keyname, 0, access, subkey);
1448     RegCloseKey(key);
1449     if (res == ERROR_FILE_NOT_FOUND)
1450         return REGDB_E_KEYMISSING;
1451     else if (res != ERROR_SUCCESS)
1452         return REGDB_E_READREGDB;
1453
1454     return S_OK;
1455 }
1456
1457 /* open HKCR\\AppId\\{string form of appid clsid} key */
1458 HRESULT COM_OpenKeyForAppIdFromCLSID(REFCLSID clsid, REGSAM access, HKEY *subkey)
1459 {
1460     static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
1461     static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
1462     DWORD res;
1463     WCHAR buf[CHARS_IN_GUID];
1464     WCHAR keyname[ARRAYSIZE(szAppIdKey) + CHARS_IN_GUID];
1465     DWORD size;
1466     HKEY hkey;
1467     DWORD type;
1468     HRESULT hr;
1469
1470     /* read the AppID value under the class's key */
1471     hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
1472     if (FAILED(hr))
1473         return hr;
1474
1475     size = sizeof(buf);
1476     res = RegQueryValueExW(hkey, szAppId, NULL, &type, (LPBYTE)buf, &size);
1477     RegCloseKey(hkey);
1478     if (res == ERROR_FILE_NOT_FOUND)
1479         return REGDB_E_KEYMISSING;
1480     else if (res != ERROR_SUCCESS || type!=REG_SZ)
1481         return REGDB_E_READREGDB;
1482
1483     strcpyW(keyname, szAppIdKey);
1484     strcatW(keyname, buf);
1485     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, access, subkey);
1486     if (res == ERROR_FILE_NOT_FOUND)
1487         return REGDB_E_KEYMISSING;
1488     else if (res != ERROR_SUCCESS)
1489         return REGDB_E_READREGDB;
1490
1491     return S_OK;
1492 }
1493
1494 /******************************************************************************
1495  *               ProgIDFromCLSID [OLE32.@]
1496  *
1497  * Converts a class id into the respective program ID.
1498  *
1499  * PARAMS
1500  *  clsid        [I] Class ID, as found in registry.
1501  *  ppszProgID [O] Associated ProgID.
1502  *
1503  * RETURNS
1504  *   S_OK
1505  *   E_OUTOFMEMORY
1506  *   REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
1507  */
1508 HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *ppszProgID)
1509 {
1510     static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
1511     HKEY     hkey;
1512     HRESULT  ret;
1513     LONG progidlen = 0;
1514
1515     if (!ppszProgID)
1516     {
1517         ERR("ppszProgId isn't optional\n");
1518         return E_INVALIDARG;
1519     }
1520
1521     *ppszProgID = NULL;
1522     ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
1523     if (FAILED(ret))
1524         return ret;
1525
1526     if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
1527       ret = REGDB_E_CLASSNOTREG;
1528
1529     if (ret == S_OK)
1530     {
1531       *ppszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
1532       if (*ppszProgID)
1533       {
1534         if (RegQueryValueW(hkey, NULL, *ppszProgID, &progidlen))
1535           ret = REGDB_E_CLASSNOTREG;
1536       }
1537       else
1538         ret = E_OUTOFMEMORY;
1539     }
1540
1541     RegCloseKey(hkey);
1542     return ret;
1543 }
1544
1545 /******************************************************************************
1546  *              CLSIDFromProgID [OLE32.@]
1547  *
1548  * Converts a program id into the respective GUID.
1549  *
1550  * PARAMS
1551  *  progid [I] Unicode program ID, as found in registry.
1552  *  clsid  [O] Associated CLSID.
1553  *
1554  * RETURNS
1555  *      Success: S_OK
1556  *  Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
1557  */
1558 HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID clsid)
1559 {
1560     static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
1561     WCHAR buf2[CHARS_IN_GUID];
1562     LONG buf2len = sizeof(buf2);
1563     HKEY xhkey;
1564     WCHAR *buf;
1565
1566     if (!progid || !clsid)
1567     {
1568         ERR("neither progid (%p) nor clsid (%p) are optional\n", progid, clsid);
1569         return E_INVALIDARG;
1570     }
1571
1572     /* initialise clsid in case of failure */
1573     memset(clsid, 0, sizeof(*clsid));
1574
1575     buf = HeapAlloc( GetProcessHeap(),0,(strlenW(progid)+8) * sizeof(WCHAR) );
1576     strcpyW( buf, progid );
1577     strcatW( buf, clsidW );
1578     if (RegOpenKeyW(HKEY_CLASSES_ROOT,buf,&xhkey))
1579     {
1580         HeapFree(GetProcessHeap(),0,buf);
1581         WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
1582         return CO_E_CLASSSTRING;
1583     }
1584     HeapFree(GetProcessHeap(),0,buf);
1585
1586     if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
1587     {
1588         RegCloseKey(xhkey);
1589         WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
1590         return CO_E_CLASSSTRING;
1591     }
1592     RegCloseKey(xhkey);
1593     return CLSIDFromString(buf2,clsid);
1594 }
1595
1596
1597 /*****************************************************************************
1598  *             CoGetPSClsid [OLE32.@]
1599  *
1600  * Retrieves the CLSID of the proxy/stub factory that implements
1601  * IPSFactoryBuffer for the specified interface.
1602  *
1603  * PARAMS
1604  *  riid   [I] Interface whose proxy/stub CLSID is to be returned.
1605  *  pclsid [O] Where to store returned proxy/stub CLSID.
1606  *
1607  * RETURNS
1608  *   S_OK
1609  *   E_OUTOFMEMORY
1610  *   REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
1611  *
1612  * NOTES
1613  *
1614  * The standard marshaller activates the object with the CLSID
1615  * returned and uses the CreateProxy and CreateStub methods on its
1616  * IPSFactoryBuffer interface to construct the proxies and stubs for a
1617  * given object.
1618  *
1619  * CoGetPSClsid determines this CLSID by searching the
1620  * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
1621  * in the registry and any interface id registered by
1622  * CoRegisterPSClsid within the current process.
1623  *
1624  * BUGS
1625  *
1626  * Native returns S_OK for interfaces with a key in HKCR\Interface, but
1627  * without a ProxyStubClsid32 key and leaves garbage in pclsid. This should be
1628  * considered a bug in native unless an application depends on this (unlikely).
1629  *
1630  * SEE ALSO
1631  *  CoRegisterPSClsid.
1632  */
1633 HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
1634 {
1635     static const WCHAR wszInterface[] = {'I','n','t','e','r','f','a','c','e','\\',0};
1636     static const WCHAR wszPSC[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
1637     WCHAR path[ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1 + ARRAYSIZE(wszPSC)];
1638     WCHAR value[CHARS_IN_GUID];
1639     LONG len;
1640     HKEY hkey;
1641     APARTMENT *apt = COM_CurrentApt();
1642     struct registered_psclsid *registered_psclsid;
1643
1644     TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
1645
1646     if (!apt)
1647     {
1648         ERR("apartment not initialised\n");
1649         return CO_E_NOTINITIALIZED;
1650     }
1651
1652     if (!pclsid)
1653     {
1654         ERR("pclsid isn't optional\n");
1655         return E_INVALIDARG;
1656     }
1657
1658     EnterCriticalSection(&apt->cs);
1659
1660     LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
1661         if (IsEqualIID(&registered_psclsid->iid, riid))
1662         {
1663             *pclsid = registered_psclsid->clsid;
1664             LeaveCriticalSection(&apt->cs);
1665             return S_OK;
1666         }
1667
1668     LeaveCriticalSection(&apt->cs);
1669
1670     /* Interface\\{string form of riid}\\ProxyStubClsid32 */
1671     strcpyW(path, wszInterface);
1672     StringFromGUID2(riid, path + ARRAYSIZE(wszInterface) - 1, CHARS_IN_GUID);
1673     strcpyW(path + ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1, wszPSC);
1674
1675     /* Open the key.. */
1676     if (RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey))
1677     {
1678         WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
1679         return REGDB_E_IIDNOTREG;
1680     }
1681
1682     /* ... Once we have the key, query the registry to get the
1683        value of CLSID as a string, and convert it into a
1684        proper CLSID structure to be passed back to the app */
1685     len = sizeof(value);
1686     if (ERROR_SUCCESS != RegQueryValueW(hkey, NULL, value, &len))
1687     {
1688         RegCloseKey(hkey);
1689         return REGDB_E_IIDNOTREG;
1690     }
1691     RegCloseKey(hkey);
1692
1693     /* We have the CLSid we want back from the registry as a string, so
1694        lets convert it into a CLSID structure */
1695     if (CLSIDFromString(value, pclsid) != NOERROR)
1696         return REGDB_E_IIDNOTREG;
1697
1698     TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
1699     return S_OK;
1700 }
1701
1702 /*****************************************************************************
1703  *             CoRegisterPSClsid [OLE32.@]
1704  *
1705  * Register a proxy/stub CLSID for the given interface in the current process
1706  * only.
1707  *
1708  * PARAMS
1709  *  riid   [I] Interface whose proxy/stub CLSID is to be registered.
1710  *  rclsid [I] CLSID of the proxy/stub.
1711  *
1712  * RETURNS
1713  *   Success: S_OK
1714  *   Failure: E_OUTOFMEMORY
1715  *
1716  * NOTES
1717  *
1718  * This function does not add anything to the registry and the effects are
1719  * limited to the lifetime of the current process.
1720  *
1721  * SEE ALSO
1722  *  CoGetPSClsid.
1723  */
1724 HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid)
1725 {
1726     APARTMENT *apt = COM_CurrentApt();
1727     struct registered_psclsid *registered_psclsid;
1728
1729     TRACE("(%s, %s)\n", debugstr_guid(riid), debugstr_guid(rclsid));
1730
1731     if (!apt)
1732     {
1733         ERR("apartment not initialised\n");
1734         return CO_E_NOTINITIALIZED;
1735     }
1736
1737     EnterCriticalSection(&apt->cs);
1738
1739     LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
1740         if (IsEqualIID(&registered_psclsid->iid, riid))
1741         {
1742             registered_psclsid->clsid = *rclsid;
1743             LeaveCriticalSection(&apt->cs);
1744             return S_OK;
1745         }
1746
1747     registered_psclsid = HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid));
1748     if (!registered_psclsid)
1749     {
1750         LeaveCriticalSection(&apt->cs);
1751         return E_OUTOFMEMORY;
1752     }
1753
1754     registered_psclsid->iid = *riid;
1755     registered_psclsid->clsid = *rclsid;
1756     list_add_head(&apt->psclsids, &registered_psclsid->entry);
1757
1758     LeaveCriticalSection(&apt->cs);
1759
1760     return S_OK;
1761 }
1762
1763
1764 /***
1765  * COM_GetRegisteredClassObject
1766  *
1767  * This internal method is used to scan the registered class list to
1768  * find a class object.
1769  *
1770  * Params:
1771  *   rclsid        Class ID of the class to find.
1772  *   dwClsContext  Class context to match.
1773  *   ppv           [out] returns a pointer to the class object. Complying
1774  *                 to normal COM usage, this method will increase the
1775  *                 reference count on this object.
1776  */
1777 static HRESULT COM_GetRegisteredClassObject(const struct apartment *apt, REFCLSID rclsid,
1778                                             DWORD dwClsContext, LPUNKNOWN* ppUnk)
1779 {
1780   HRESULT hr = S_FALSE;
1781   RegisteredClass *curClass;
1782
1783   /*
1784    * Sanity check
1785    */
1786   assert(ppUnk!=0);
1787
1788   EnterCriticalSection( &csRegisteredClassList );
1789
1790   LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
1791   {
1792     /*
1793      * Check if we have a match on the class ID and context.
1794      */
1795     if ((apt->oxid == curClass->apartment_id) &&
1796         (dwClsContext & curClass->runContext) &&
1797         IsEqualGUID(&(curClass->classIdentifier), rclsid))
1798     {
1799       /*
1800        * We have a match, return the pointer to the class object.
1801        */
1802       *ppUnk = curClass->classObject;
1803
1804       IUnknown_AddRef(curClass->classObject);
1805
1806       hr = S_OK;
1807       break;
1808     }
1809   }
1810
1811   LeaveCriticalSection( &csRegisteredClassList );
1812
1813   return hr;
1814 }
1815
1816 /******************************************************************************
1817  *              CoRegisterClassObject   [OLE32.@]
1818  *
1819  * Registers the class object for a given class ID. Servers housed in EXE
1820  * files use this method instead of exporting DllGetClassObject to allow
1821  * other code to connect to their objects.
1822  *
1823  * PARAMS
1824  *  rclsid       [I] CLSID of the object to register.
1825  *  pUnk         [I] IUnknown of the object.
1826  *  dwClsContext [I] CLSCTX flags indicating the context in which to run the executable.
1827  *  flags        [I] REGCLS flags indicating how connections are made.
1828  *  lpdwRegister [I] A unique cookie that can be passed to CoRevokeClassObject.
1829  *
1830  * RETURNS
1831  *   S_OK on success,
1832  *   E_INVALIDARG if lpdwRegister or pUnk are NULL,
1833  *   CO_E_OBJISREG if the object is already registered. We should not return this.
1834  *
1835  * SEE ALSO
1836  *   CoRevokeClassObject, CoGetClassObject
1837  *
1838  * NOTES
1839  *  In-process objects are only registered for the current apartment.
1840  *  CoGetClassObject() and CoCreateInstance() will not return objects registered
1841  *  in other apartments.
1842  *
1843  * BUGS
1844  *  MSDN claims that multiple interface registrations are legal, but we
1845  *  can't do that with our current implementation.
1846  */
1847 HRESULT WINAPI CoRegisterClassObject(
1848     REFCLSID rclsid,
1849     LPUNKNOWN pUnk,
1850     DWORD dwClsContext,
1851     DWORD flags,
1852     LPDWORD lpdwRegister)
1853 {
1854   RegisteredClass* newClass;
1855   LPUNKNOWN        foundObject;
1856   HRESULT          hr;
1857   APARTMENT *apt;
1858
1859   TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
1860         debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
1861
1862   if ( (lpdwRegister==0) || (pUnk==0) )
1863     return E_INVALIDARG;
1864
1865   apt = COM_CurrentApt();
1866   if (!apt)
1867   {
1868       ERR("COM was not initialized\n");
1869       return CO_E_NOTINITIALIZED;
1870   }
1871
1872   *lpdwRegister = 0;
1873
1874   /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
1875    * differentiates the flag from REGCLS_MULTI_SEPARATE. */
1876   if (flags & REGCLS_MULTIPLEUSE)
1877     dwClsContext |= CLSCTX_INPROC_SERVER;
1878
1879   /*
1880    * First, check if the class is already registered.
1881    * If it is, this should cause an error.
1882    */
1883   hr = COM_GetRegisteredClassObject(apt, rclsid, dwClsContext, &foundObject);
1884   if (hr == S_OK) {
1885     if (flags & REGCLS_MULTIPLEUSE) {
1886       if (dwClsContext & CLSCTX_LOCAL_SERVER)
1887         hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
1888       IUnknown_Release(foundObject);
1889       return hr;
1890     }
1891     IUnknown_Release(foundObject);
1892     ERR("object already registered for class %s\n", debugstr_guid(rclsid));
1893     return CO_E_OBJISREG;
1894   }
1895
1896   newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
1897   if ( newClass == NULL )
1898     return E_OUTOFMEMORY;
1899
1900   newClass->classIdentifier = *rclsid;
1901   newClass->apartment_id    = apt->oxid;
1902   newClass->runContext      = dwClsContext;
1903   newClass->connectFlags    = flags;
1904   newClass->pMarshaledData  = NULL;
1905   newClass->RpcRegistration = NULL;
1906
1907   /*
1908    * Use the address of the chain node as the cookie since we are sure it's
1909    * unique. FIXME: not on 64-bit platforms.
1910    */
1911   newClass->dwCookie        = (DWORD)newClass;
1912
1913   /*
1914    * Since we're making a copy of the object pointer, we have to increase its
1915    * reference count.
1916    */
1917   newClass->classObject     = pUnk;
1918   IUnknown_AddRef(newClass->classObject);
1919
1920   EnterCriticalSection( &csRegisteredClassList );
1921   list_add_tail(&RegisteredClassList, &newClass->entry);
1922   LeaveCriticalSection( &csRegisteredClassList );
1923
1924   *lpdwRegister = newClass->dwCookie;
1925
1926   if (dwClsContext & CLSCTX_LOCAL_SERVER) {
1927       hr = CreateStreamOnHGlobal(0, TRUE, &newClass->pMarshaledData);
1928       if (hr) {
1929           FIXME("Failed to create stream on hglobal, %x\n", hr);
1930           return hr;
1931       }
1932       hr = CoMarshalInterface(newClass->pMarshaledData, &IID_IClassFactory,
1933                               newClass->classObject, MSHCTX_LOCAL, NULL,
1934                               MSHLFLAGS_TABLESTRONG);
1935       if (hr) {
1936           FIXME("CoMarshalInterface failed, %x!\n",hr);
1937           return hr;
1938       }
1939
1940       hr = RPC_StartLocalServer(&newClass->classIdentifier,
1941                                 newClass->pMarshaledData,
1942                                 flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
1943                                 &newClass->RpcRegistration);
1944   }
1945   return S_OK;
1946 }
1947
1948 static void COM_RevokeRegisteredClassObject(RegisteredClass *curClass)
1949 {
1950     list_remove(&curClass->entry);
1951
1952     if (curClass->runContext & CLSCTX_LOCAL_SERVER)
1953         RPC_StopLocalServer(curClass->RpcRegistration);
1954
1955     /*
1956      * Release the reference to the class object.
1957      */
1958     IUnknown_Release(curClass->classObject);
1959
1960     if (curClass->pMarshaledData)
1961     {
1962         LARGE_INTEGER zero;
1963         memset(&zero, 0, sizeof(zero));
1964         IStream_Seek(curClass->pMarshaledData, zero, STREAM_SEEK_SET, NULL);
1965         CoReleaseMarshalData(curClass->pMarshaledData);
1966         IStream_Release(curClass->pMarshaledData);
1967     }
1968
1969     HeapFree(GetProcessHeap(), 0, curClass);
1970 }
1971
1972 static void COM_RevokeAllClasses(const struct apartment *apt)
1973 {
1974   RegisteredClass *curClass, *cursor;
1975
1976   EnterCriticalSection( &csRegisteredClassList );
1977
1978   LIST_FOR_EACH_ENTRY_SAFE(curClass, cursor, &RegisteredClassList, RegisteredClass, entry)
1979   {
1980     if (curClass->apartment_id == apt->oxid)
1981       COM_RevokeRegisteredClassObject(curClass);
1982   }
1983
1984   LeaveCriticalSection( &csRegisteredClassList );
1985 }
1986
1987 /***********************************************************************
1988  *           CoRevokeClassObject [OLE32.@]
1989  *
1990  * Removes a class object from the class registry.
1991  *
1992  * PARAMS
1993  *  dwRegister [I] Cookie returned from CoRegisterClassObject().
1994  *
1995  * RETURNS
1996  *  Success: S_OK.
1997  *  Failure: HRESULT code.
1998  *
1999  * NOTES
2000  *  Must be called from the same apartment that called CoRegisterClassObject(),
2001  *  otherwise it will fail with RPC_E_WRONG_THREAD.
2002  *
2003  * SEE ALSO
2004  *  CoRegisterClassObject
2005  */
2006 HRESULT WINAPI CoRevokeClassObject(
2007         DWORD dwRegister)
2008 {
2009   HRESULT hr = E_INVALIDARG;
2010   RegisteredClass *curClass;
2011   APARTMENT *apt;
2012
2013   TRACE("(%08x)\n",dwRegister);
2014
2015   apt = COM_CurrentApt();
2016   if (!apt)
2017   {
2018     ERR("COM was not initialized\n");
2019     return CO_E_NOTINITIALIZED;
2020   }
2021
2022   EnterCriticalSection( &csRegisteredClassList );
2023
2024   LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
2025   {
2026     /*
2027      * Check if we have a match on the cookie.
2028      */
2029     if (curClass->dwCookie == dwRegister)
2030     {
2031       if (curClass->apartment_id == apt->oxid)
2032       {
2033           COM_RevokeRegisteredClassObject(curClass);
2034           hr = S_OK;
2035       }
2036       else
2037       {
2038           ERR("called from wrong apartment, should be called from %s\n",
2039               wine_dbgstr_longlong(curClass->apartment_id));
2040           hr = RPC_E_WRONG_THREAD;
2041       }
2042       break;
2043     }
2044   }
2045
2046   LeaveCriticalSection( &csRegisteredClassList );
2047
2048   return hr;
2049 }
2050
2051 /***********************************************************************
2052  *      COM_RegReadPath [internal]
2053  *
2054  *      Reads a registry value and expands it when necessary
2055  */
2056 static DWORD COM_RegReadPath(HKEY hkeyroot, const WCHAR *keyname, const WCHAR *valuename, WCHAR * dst, DWORD dstlen)
2057 {
2058         DWORD ret;
2059         HKEY key;
2060         DWORD keytype;
2061         WCHAR src[MAX_PATH];
2062         DWORD dwLength = dstlen * sizeof(WCHAR);
2063
2064         if((ret = RegOpenKeyExW(hkeyroot, keyname, 0, KEY_READ, &key)) == ERROR_SUCCESS) {
2065           if( (ret = RegQueryValueExW(key, NULL, NULL, &keytype, (LPBYTE)src, &dwLength)) == ERROR_SUCCESS ) {
2066             if (keytype == REG_EXPAND_SZ) {
2067               if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
2068             } else {
2069               lstrcpynW(dst, src, dstlen);
2070             }
2071           }
2072           RegCloseKey (key);
2073         }
2074         return ret;
2075 }
2076
2077 static void get_threading_model(HKEY key, LPWSTR value, DWORD len)
2078 {
2079     static const WCHAR wszThreadingModel[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
2080     DWORD keytype;
2081     DWORD ret;
2082     DWORD dwLength = len * sizeof(WCHAR);
2083
2084     ret = RegQueryValueExW(key, wszThreadingModel, NULL, &keytype, (LPBYTE)value, &dwLength);
2085     if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
2086         value[0] = '\0';
2087 }
2088
2089 static HRESULT get_inproc_class_object(APARTMENT *apt, HKEY hkeydll,
2090                                        REFCLSID rclsid, REFIID riid, void **ppv)
2091 {
2092     static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
2093     static const WCHAR wszFree[] = {'F','r','e','e',0};
2094     static const WCHAR wszBoth[] = {'B','o','t','h',0};
2095     WCHAR dllpath[MAX_PATH+1];
2096     WCHAR threading_model[10 /* strlenW(L"apartment")+1 */];
2097
2098     get_threading_model(hkeydll, threading_model, ARRAYSIZE(threading_model));
2099     /* "Apartment" */
2100     if (!strcmpiW(threading_model, wszApartment))
2101     {
2102         if (apt->multi_threaded)
2103             return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, hkeydll, rclsid, riid, ppv);
2104     }
2105     /* "Free" */
2106     else if (!strcmpiW(threading_model, wszFree))
2107     {
2108         if (!apt->multi_threaded)
2109             return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, hkeydll, rclsid, riid, ppv);
2110     }
2111     /* everything except "Apartment", "Free" and "Both" */
2112     else if (strcmpiW(threading_model, wszBoth))
2113     {
2114         /* everything else is main-threaded */
2115         if (threading_model[0])
2116             FIXME("unrecognised threading model %s for object %s, should be main-threaded?\n",
2117                 debugstr_w(threading_model), debugstr_guid(rclsid));
2118
2119         if (apt->multi_threaded || !apt->main)
2120             return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, hkeydll, rclsid, riid, ppv);
2121     }
2122
2123     if (COM_RegReadPath(hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
2124     {
2125         /* failure: CLSID is not found in registry */
2126         WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
2127         return REGDB_E_CLASSNOTREG;
2128     }
2129
2130     return apartment_getclassobject(apt, dllpath,
2131                                     !strcmpiW(threading_model, wszApartment),
2132                                     rclsid, riid, ppv);
2133 }
2134
2135 /***********************************************************************
2136  *           CoGetClassObject [OLE32.@]
2137  *
2138  * Creates an object of the specified class.
2139  *
2140  * PARAMS
2141  *  rclsid       [I] Class ID to create an instance of.
2142  *  dwClsContext [I] Flags to restrict the location of the created instance.
2143  *  pServerInfo  [I] Optional. Details for connecting to a remote server.
2144  *  iid          [I] The ID of the interface of the instance to return.
2145  *  ppv          [O] On returns, contains a pointer to the specified interface of the object.
2146  *
2147  * RETURNS
2148  *  Success: S_OK
2149  *  Failure: HRESULT code.
2150  *
2151  * NOTES
2152  *  The dwClsContext parameter can be one or more of the following:
2153  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2154  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2155  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2156  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2157  *
2158  * SEE ALSO
2159  *  CoCreateInstance()
2160  */
2161 HRESULT WINAPI CoGetClassObject(
2162     REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
2163     REFIID iid, LPVOID *ppv)
2164 {
2165     LPUNKNOWN   regClassObject;
2166     HRESULT     hres = E_UNEXPECTED;
2167     APARTMENT  *apt;
2168
2169     TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
2170
2171     if (!ppv)
2172         return E_INVALIDARG;
2173
2174     *ppv = NULL;
2175
2176     apt = COM_CurrentApt();
2177     if (!apt)
2178     {
2179         ERR("apartment not initialised\n");
2180         return CO_E_NOTINITIALIZED;
2181     }
2182
2183     if (pServerInfo) {
2184         FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo->pwszName));
2185         FIXME("\t\tpAuthInfo=%p\n",pServerInfo->pAuthInfo);
2186     }
2187
2188     /*
2189      * First, try and see if we can't match the class ID with one of the
2190      * registered classes.
2191      */
2192     if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
2193                                              &regClassObject))
2194     {
2195       /* Get the required interface from the retrieved pointer. */
2196       hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
2197
2198       /*
2199        * Since QI got another reference on the pointer, we want to release the
2200        * one we already have. If QI was unsuccessful, this will release the object. This
2201        * is good since we are not returning it in the "out" parameter.
2202        */
2203       IUnknown_Release(regClassObject);
2204
2205       return hres;
2206     }
2207
2208     /* First try in-process server */
2209     if (CLSCTX_INPROC_SERVER & dwClsContext)
2210     {
2211         static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
2212         HKEY hkey;
2213
2214         if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
2215             return FTMarshalCF_Create(iid, ppv);
2216
2217         hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
2218         if (FAILED(hres))
2219         {
2220             if (hres == REGDB_E_CLASSNOTREG)
2221                 ERR("class %s not registered\n", debugstr_guid(rclsid));
2222             else if (hres == REGDB_E_KEYMISSING)
2223             {
2224                 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
2225                 hres = REGDB_E_CLASSNOTREG;
2226             }
2227         }
2228
2229         if (SUCCEEDED(hres))
2230         {
2231             hres = get_inproc_class_object(apt, hkey, rclsid, iid, ppv);
2232             RegCloseKey(hkey);
2233         }
2234
2235         /* return if we got a class, otherwise fall through to one of the
2236          * other types */
2237         if (SUCCEEDED(hres))
2238             return hres;
2239     }
2240
2241     /* Next try in-process handler */
2242     if (CLSCTX_INPROC_HANDLER & dwClsContext)
2243     {
2244         static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
2245         HKEY hkey;
2246
2247         hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
2248         if (FAILED(hres))
2249         {
2250             if (hres == REGDB_E_CLASSNOTREG)
2251                 ERR("class %s not registered\n", debugstr_guid(rclsid));
2252             else if (hres == REGDB_E_KEYMISSING)
2253             {
2254                 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
2255                 hres = REGDB_E_CLASSNOTREG;
2256             }
2257         }
2258
2259         if (SUCCEEDED(hres))
2260         {
2261             hres = get_inproc_class_object(apt, hkey, rclsid, iid, ppv);
2262             RegCloseKey(hkey);
2263         }
2264
2265         /* return if we got a class, otherwise fall through to one of the
2266          * other types */
2267         if (SUCCEEDED(hres))
2268             return hres;
2269     }
2270
2271     /* Next try out of process */
2272     if (CLSCTX_LOCAL_SERVER & dwClsContext)
2273     {
2274         hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
2275         if (SUCCEEDED(hres))
2276             return hres;
2277     }
2278
2279     /* Finally try remote: this requires networked DCOM (a lot of work) */
2280     if (CLSCTX_REMOTE_SERVER & dwClsContext)
2281     {
2282         FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
2283         hres = E_NOINTERFACE;
2284     }
2285
2286     if (FAILED(hres))
2287         ERR("no class object %s could be created for context 0x%x\n",
2288             debugstr_guid(rclsid), dwClsContext);
2289     return hres;
2290 }
2291
2292 /***********************************************************************
2293  *        CoResumeClassObjects (OLE32.@)
2294  *
2295  * Resumes all class objects registered with REGCLS_SUSPENDED.
2296  *
2297  * RETURNS
2298  *  Success: S_OK.
2299  *  Failure: HRESULT code.
2300  */
2301 HRESULT WINAPI CoResumeClassObjects(void)
2302 {
2303        FIXME("stub\n");
2304         return S_OK;
2305 }
2306
2307 /***********************************************************************
2308  *           CoCreateInstance [OLE32.@]
2309  *
2310  * Creates an instance of the specified class.
2311  *
2312  * PARAMS
2313  *  rclsid       [I] Class ID to create an instance of.
2314  *  pUnkOuter    [I] Optional outer unknown to allow aggregation with another object.
2315  *  dwClsContext [I] Flags to restrict the location of the created instance.
2316  *  iid          [I] The ID of the interface of the instance to return.
2317  *  ppv          [O] On returns, contains a pointer to the specified interface of the instance.
2318  *
2319  * RETURNS
2320  *  Success: S_OK
2321  *  Failure: HRESULT code.
2322  *
2323  * NOTES
2324  *  The dwClsContext parameter can be one or more of the following:
2325  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2326  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2327  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2328  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2329  *
2330  * Aggregation is the concept of deferring the IUnknown of an object to another
2331  * object. This allows a separate object to behave as though it was part of
2332  * the object and to allow this the pUnkOuter parameter can be set. Note that
2333  * not all objects support having an outer of unknown.
2334  *
2335  * SEE ALSO
2336  *  CoGetClassObject()
2337  */
2338 HRESULT WINAPI CoCreateInstance(
2339         REFCLSID rclsid,
2340         LPUNKNOWN pUnkOuter,
2341         DWORD dwClsContext,
2342         REFIID iid,
2343         LPVOID *ppv)
2344 {
2345   HRESULT hres;
2346   LPCLASSFACTORY lpclf = 0;
2347
2348   TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
2349         pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
2350
2351   /*
2352    * Sanity check
2353    */
2354   if (ppv==0)
2355     return E_POINTER;
2356
2357   /*
2358    * Initialize the "out" parameter
2359    */
2360   *ppv = 0;
2361
2362   if (!COM_CurrentApt())
2363   {
2364       ERR("apartment not initialised\n");
2365       return CO_E_NOTINITIALIZED;
2366   }
2367
2368   /*
2369    * The Standard Global Interface Table (GIT) object is a process-wide singleton.
2370    * Rather than create a class factory, we can just check for it here
2371    */
2372   if (IsEqualIID(rclsid, &CLSID_StdGlobalInterfaceTable)) {
2373     if (StdGlobalInterfaceTableInstance == NULL)
2374       StdGlobalInterfaceTableInstance = StdGlobalInterfaceTable_Construct();
2375     hres = IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable*) StdGlobalInterfaceTableInstance, iid, ppv);
2376     if (hres) return hres;
2377
2378     TRACE("Retrieved GIT (%p)\n", *ppv);
2379     return S_OK;
2380   }
2381
2382   /*
2383    * Get a class factory to construct the object we want.
2384    */
2385   hres = CoGetClassObject(rclsid,
2386                           dwClsContext,
2387                           NULL,
2388                           &IID_IClassFactory,
2389                           (LPVOID)&lpclf);
2390
2391   if (FAILED(hres))
2392     return hres;
2393
2394   /*
2395    * Create the object and don't forget to release the factory
2396    */
2397         hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
2398         IClassFactory_Release(lpclf);
2399         if(FAILED(hres))
2400           FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n",
2401                 debugstr_guid(iid), debugstr_guid(rclsid),hres);
2402
2403         return hres;
2404 }
2405
2406 /***********************************************************************
2407  *           CoCreateInstanceEx [OLE32.@]
2408  */
2409 HRESULT WINAPI CoCreateInstanceEx(
2410   REFCLSID      rclsid,
2411   LPUNKNOWN     pUnkOuter,
2412   DWORD         dwClsContext,
2413   COSERVERINFO* pServerInfo,
2414   ULONG         cmq,
2415   MULTI_QI*     pResults)
2416 {
2417   IUnknown* pUnk = NULL;
2418   HRESULT   hr;
2419   ULONG     index;
2420   ULONG     successCount = 0;
2421
2422   /*
2423    * Sanity check
2424    */
2425   if ( (cmq==0) || (pResults==NULL))
2426     return E_INVALIDARG;
2427
2428   if (pServerInfo!=NULL)
2429     FIXME("() non-NULL pServerInfo not supported!\n");
2430
2431   /*
2432    * Initialize all the "out" parameters.
2433    */
2434   for (index = 0; index < cmq; index++)
2435   {
2436     pResults[index].pItf = NULL;
2437     pResults[index].hr   = E_NOINTERFACE;
2438   }
2439
2440   /*
2441    * Get the object and get its IUnknown pointer.
2442    */
2443   hr = CoCreateInstance(rclsid,
2444                         pUnkOuter,
2445                         dwClsContext,
2446                         &IID_IUnknown,
2447                         (VOID**)&pUnk);
2448
2449   if (hr)
2450     return hr;
2451
2452   /*
2453    * Then, query for all the interfaces requested.
2454    */
2455   for (index = 0; index < cmq; index++)
2456   {
2457     pResults[index].hr = IUnknown_QueryInterface(pUnk,
2458                                                  pResults[index].pIID,
2459                                                  (VOID**)&(pResults[index].pItf));
2460
2461     if (pResults[index].hr == S_OK)
2462       successCount++;
2463   }
2464
2465   /*
2466    * Release our temporary unknown pointer.
2467    */
2468   IUnknown_Release(pUnk);
2469
2470   if (successCount == 0)
2471     return E_NOINTERFACE;
2472
2473   if (successCount!=cmq)
2474     return CO_S_NOTALLINTERFACES;
2475
2476   return S_OK;
2477 }
2478
2479 /***********************************************************************
2480  *           CoLoadLibrary (OLE32.@)
2481  *
2482  * Loads a library.
2483  *
2484  * PARAMS
2485  *  lpszLibName [I] Path to library.
2486  *  bAutoFree   [I] Whether the library should automatically be freed.
2487  *
2488  * RETURNS
2489  *  Success: Handle to loaded library.
2490  *  Failure: NULL.
2491  *
2492  * SEE ALSO
2493  *  CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2494  */
2495 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
2496 {
2497     TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
2498
2499     return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
2500 }
2501
2502 /***********************************************************************
2503  *           CoFreeLibrary [OLE32.@]
2504  *
2505  * Unloads a library from memory.
2506  *
2507  * PARAMS
2508  *  hLibrary [I] Handle to library to unload.
2509  *
2510  * RETURNS
2511  *  Nothing
2512  *
2513  * SEE ALSO
2514  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2515  */
2516 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
2517 {
2518     FreeLibrary(hLibrary);
2519 }
2520
2521
2522 /***********************************************************************
2523  *           CoFreeAllLibraries [OLE32.@]
2524  *
2525  * Function for backwards compatibility only. Does nothing.
2526  *
2527  * RETURNS
2528  *  Nothing.
2529  *
2530  * SEE ALSO
2531  *  CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
2532  */
2533 void WINAPI CoFreeAllLibraries(void)
2534 {
2535     /* NOP */
2536 }
2537
2538 /***********************************************************************
2539  *           CoFreeUnusedLibrariesEx [OLE32.@]
2540  *
2541  * Frees any previously unused libraries whose delay has expired and marks
2542  * currently unused libraries for unloading. Unused are identified as those that
2543  * return S_OK from their DllCanUnloadNow function.
2544  *
2545  * PARAMS
2546  *  dwUnloadDelay [I] Unload delay in milliseconds.
2547  *  dwReserved    [I] Reserved. Set to 0.
2548  *
2549  * RETURNS
2550  *  Nothing.
2551  *
2552  * SEE ALSO
2553  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2554  */
2555 void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved)
2556 {
2557     struct apartment *apt = COM_CurrentApt();
2558     if (!apt)
2559     {
2560         ERR("apartment not initialised\n");
2561         return;
2562     }
2563
2564     apartment_freeunusedlibraries(apt, dwUnloadDelay);
2565 }
2566
2567 /***********************************************************************
2568  *           CoFreeUnusedLibraries [OLE32.@]
2569  *           CoFreeUnusedLibraries [COMPOBJ.17]
2570  *
2571  * Frees any unused libraries. Unused are identified as those that return
2572  * S_OK from their DllCanUnloadNow function.
2573  *
2574  * RETURNS
2575  *  Nothing.
2576  *
2577  * SEE ALSO
2578  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2579  */
2580 void WINAPI CoFreeUnusedLibraries(void)
2581 {
2582     CoFreeUnusedLibrariesEx(INFINITE, 0);
2583 }
2584
2585 /***********************************************************************
2586  *           CoFileTimeNow [OLE32.@]
2587  *           CoFileTimeNow [COMPOBJ.82]
2588  *
2589  * Retrieves the current time in FILETIME format.
2590  *
2591  * PARAMS
2592  *  lpFileTime [O] The current time.
2593  *
2594  * RETURNS
2595  *      S_OK.
2596  */
2597 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
2598 {
2599     GetSystemTimeAsFileTime( lpFileTime );
2600     return S_OK;
2601 }
2602
2603 /******************************************************************************
2604  *              CoLockObjectExternal    [OLE32.@]
2605  *
2606  * Increments or decrements the external reference count of a stub object.
2607  *
2608  * PARAMS
2609  *  pUnk                [I] Stub object.
2610  *  fLock               [I] If TRUE then increments the external ref-count,
2611  *                          otherwise decrements.
2612  *  fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2613  *                          calling CoDisconnectObject.
2614  *
2615  * RETURNS
2616  *  Success: S_OK.
2617  *  Failure: HRESULT code.
2618  *
2619  * NOTES
2620  *  If fLock is TRUE and an object is passed in that doesn't have a stub
2621  *  manager then a new stub manager is created for the object.
2622  */
2623 HRESULT WINAPI CoLockObjectExternal(
2624     LPUNKNOWN pUnk,
2625     BOOL fLock,
2626     BOOL fLastUnlockReleases)
2627 {
2628     struct stub_manager *stubmgr;
2629     struct apartment *apt;
2630
2631     TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2632           pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
2633
2634     apt = COM_CurrentApt();
2635     if (!apt) return CO_E_NOTINITIALIZED;
2636
2637     stubmgr = get_stub_manager_from_object(apt, pUnk);
2638
2639     if (stubmgr)
2640     {
2641         if (fLock)
2642             stub_manager_ext_addref(stubmgr, 1);
2643         else
2644             stub_manager_ext_release(stubmgr, 1, fLastUnlockReleases);
2645
2646         stub_manager_int_release(stubmgr);
2647
2648         return S_OK;
2649     }
2650     else if (fLock)
2651     {
2652         stubmgr = new_stub_manager(apt, pUnk);
2653
2654         if (stubmgr)
2655         {
2656             stub_manager_ext_addref(stubmgr, 1);
2657             stub_manager_int_release(stubmgr);
2658         }
2659
2660         return S_OK;
2661     }
2662     else
2663     {
2664         WARN("stub object not found %p\n", pUnk);
2665         /* Note: native is pretty broken here because it just silently
2666          * fails, without returning an appropriate error code, making apps
2667          * think that the object was disconnected, when it actually wasn't */
2668         return S_OK;
2669     }
2670 }
2671
2672 /***********************************************************************
2673  *           CoInitializeWOW (OLE32.@)
2674  *
2675  * WOW equivalent of CoInitialize?
2676  *
2677  * PARAMS
2678  *  x [I] Unknown.
2679  *  y [I] Unknown.
2680  *
2681  * RETURNS
2682  *  Unknown.
2683  */
2684 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
2685 {
2686     FIXME("(0x%08x,0x%08x),stub!\n",x,y);
2687     return 0;
2688 }
2689
2690 /***********************************************************************
2691  *           CoGetState [OLE32.@]
2692  *
2693  * Retrieves the thread state object previously stored by CoSetState().
2694  *
2695  * PARAMS
2696  *  ppv [I] Address where pointer to object will be stored.
2697  *
2698  * RETURNS
2699  *  Success: S_OK.
2700  *  Failure: E_OUTOFMEMORY.
2701  *
2702  * NOTES
2703  *  Crashes on all invalid ppv addresses, including NULL.
2704  *  If the function returns a non-NULL object then the caller must release its
2705  *  reference on the object when the object is no longer required.
2706  *
2707  * SEE ALSO
2708  *  CoSetState().
2709  */
2710 HRESULT WINAPI CoGetState(IUnknown ** ppv)
2711 {
2712     struct oletls *info = COM_CurrentInfo();
2713     if (!info) return E_OUTOFMEMORY;
2714
2715     *ppv = NULL;
2716
2717     if (info->state)
2718     {
2719         IUnknown_AddRef(info->state);
2720         *ppv = info->state;
2721         TRACE("apt->state=%p\n", info->state);
2722     }
2723
2724     return S_OK;
2725 }
2726
2727 /***********************************************************************
2728  *           CoSetState [OLE32.@]
2729  *
2730  * Sets the thread state object.
2731  *
2732  * PARAMS
2733  *  pv [I] Pointer to state object to be stored.
2734  *
2735  * NOTES
2736  *  The system keeps a reference on the object while the object stored.
2737  *
2738  * RETURNS
2739  *  Success: S_OK.
2740  *  Failure: E_OUTOFMEMORY.
2741  */
2742 HRESULT WINAPI CoSetState(IUnknown * pv)
2743 {
2744     struct oletls *info = COM_CurrentInfo();
2745     if (!info) return E_OUTOFMEMORY;
2746
2747     if (pv) IUnknown_AddRef(pv);
2748
2749     if (info->state)
2750     {
2751         TRACE("-- release %p now\n", info->state);
2752         IUnknown_Release(info->state);
2753     }
2754
2755     info->state = pv;
2756
2757     return S_OK;
2758 }
2759
2760
2761 /******************************************************************************
2762  *              CoTreatAsClass        [OLE32.@]
2763  *
2764  * Sets the TreatAs value of a class.
2765  *
2766  * PARAMS
2767  *  clsidOld [I] Class to set TreatAs value on.
2768  *  clsidNew [I] The class the clsidOld should be treated as.
2769  *
2770  * RETURNS
2771  *  Success: S_OK.
2772  *  Failure: HRESULT code.
2773  *
2774  * SEE ALSO
2775  *  CoGetTreatAsClass
2776  */
2777 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
2778 {
2779     static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
2780     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2781     HKEY hkey = NULL;
2782     WCHAR szClsidNew[CHARS_IN_GUID];
2783     HRESULT res = S_OK;
2784     WCHAR auto_treat_as[CHARS_IN_GUID];
2785     LONG auto_treat_as_size = sizeof(auto_treat_as);
2786     CLSID id;
2787
2788     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2789     if (FAILED(res))
2790         goto done;
2791     if (!memcmp( clsidOld, clsidNew, sizeof(*clsidOld) ))
2792     {
2793        if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
2794            !CLSIDFromString(auto_treat_as, &id))
2795        {
2796            if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
2797            {
2798                res = REGDB_E_WRITEREGDB;
2799                goto done;
2800            }
2801        }
2802        else
2803        {
2804            RegDeleteKeyW(hkey, wszTreatAs);
2805            goto done;
2806        }
2807     }
2808     else if (!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew)) &&
2809              !RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)))
2810     {
2811         res = REGDB_E_WRITEREGDB;
2812         goto done;
2813     }
2814
2815 done:
2816     if (hkey) RegCloseKey(hkey);
2817     return res;
2818 }
2819
2820 /******************************************************************************
2821  *              CoGetTreatAsClass        [OLE32.@]
2822  *
2823  * Gets the TreatAs value of a class.
2824  *
2825  * PARAMS
2826  *  clsidOld [I] Class to get the TreatAs value of.
2827  *  clsidNew [I] The class the clsidOld should be treated as.
2828  *
2829  * RETURNS
2830  *  Success: S_OK.
2831  *  Failure: HRESULT code.
2832  *
2833  * SEE ALSO
2834  *  CoSetTreatAsClass
2835  */
2836 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
2837 {
2838     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2839     HKEY hkey = NULL;
2840     WCHAR szClsidNew[CHARS_IN_GUID];
2841     HRESULT res = S_OK;
2842     LONG len = sizeof(szClsidNew);
2843
2844     FIXME("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
2845     memcpy(clsidNew,clsidOld,sizeof(CLSID)); /* copy over old value */
2846
2847     res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
2848     if (FAILED(res))
2849         goto done;
2850     if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
2851     {
2852         res = S_FALSE;
2853         goto done;
2854     }
2855     res = CLSIDFromString(szClsidNew,clsidNew);
2856     if (FAILED(res))
2857         ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
2858 done:
2859     if (hkey) RegCloseKey(hkey);
2860     return res;
2861 }
2862
2863 /******************************************************************************
2864  *              CoGetCurrentProcess     [OLE32.@]
2865  *              CoGetCurrentProcess     [COMPOBJ.34]
2866  *
2867  * Gets the current process ID.
2868  *
2869  * RETURNS
2870  *  The current process ID.
2871  *
2872  * NOTES
2873  *   Is DWORD really the correct return type for this function?
2874  */
2875 DWORD WINAPI CoGetCurrentProcess(void)
2876 {
2877         return GetCurrentProcessId();
2878 }
2879
2880 /******************************************************************************
2881  *              CoRegisterMessageFilter [OLE32.@]
2882  *
2883  * Registers a message filter.
2884  *
2885  * PARAMS
2886  *  lpMessageFilter [I] Pointer to interface.
2887  *  lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
2888  *
2889  * RETURNS
2890  *  Success: S_OK.
2891  *  Failure: HRESULT code.
2892  *
2893  * NOTES
2894  *  Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
2895  *  lpMessageFilter removes the message filter.
2896  *
2897  *  If lplpMessageFilter is not NULL the previous message filter will be
2898  *  returned in the memory pointer to this parameter and the caller is
2899  *  responsible for releasing the object.
2900  *
2901  *  The current thread be in an apartment otherwise the function will crash.
2902  */
2903 HRESULT WINAPI CoRegisterMessageFilter(
2904     LPMESSAGEFILTER lpMessageFilter,
2905     LPMESSAGEFILTER *lplpMessageFilter)
2906 {
2907     struct apartment *apt;
2908     IMessageFilter *lpOldMessageFilter;
2909
2910     TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
2911
2912     apt = COM_CurrentApt();
2913
2914     /* can't set a message filter in a multi-threaded apartment */
2915     if (!apt || apt->multi_threaded)
2916     {
2917         WARN("can't set message filter in MTA or uninitialized apt\n");
2918         return CO_E_NOT_SUPPORTED;
2919     }
2920
2921     if (lpMessageFilter)
2922         IMessageFilter_AddRef(lpMessageFilter);
2923
2924     EnterCriticalSection(&apt->cs);
2925
2926     lpOldMessageFilter = apt->filter;
2927     apt->filter = lpMessageFilter;
2928
2929     LeaveCriticalSection(&apt->cs);
2930
2931     if (lplpMessageFilter)
2932         *lplpMessageFilter = lpOldMessageFilter;
2933     else if (lpOldMessageFilter)
2934         IMessageFilter_Release(lpOldMessageFilter);
2935
2936     return S_OK;
2937 }
2938
2939 /***********************************************************************
2940  *           CoIsOle1Class [OLE32.@]
2941  *
2942  * Determines whether the specified class an OLE v1 class.
2943  *
2944  * PARAMS
2945  *  clsid [I] Class to test.
2946  *
2947  * RETURNS
2948  *  TRUE if the class is an OLE v1 class, or FALSE otherwise.
2949  */
2950 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
2951 {
2952   FIXME("%s\n", debugstr_guid(clsid));
2953   return FALSE;
2954 }
2955
2956 /***********************************************************************
2957  *           IsEqualGUID [OLE32.@]
2958  *
2959  * Compares two Unique Identifiers.
2960  *
2961  * PARAMS
2962  *  rguid1 [I] The first GUID to compare.
2963  *  rguid2 [I] The other GUID to compare.
2964  *
2965  * RETURNS
2966  *      TRUE if equal
2967  */
2968 #undef IsEqualGUID
2969 BOOL WINAPI IsEqualGUID(
2970      REFGUID rguid1,
2971      REFGUID rguid2)
2972 {
2973     return !memcmp(rguid1,rguid2,sizeof(GUID));
2974 }
2975
2976 /***********************************************************************
2977  *           CoInitializeSecurity [OLE32.@]
2978  */
2979 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
2980                                     SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
2981                                     void* pReserved1, DWORD dwAuthnLevel,
2982                                     DWORD dwImpLevel, void* pReserved2,
2983                                     DWORD dwCapabilities, void* pReserved3)
2984 {
2985   FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
2986         asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
2987         dwCapabilities, pReserved3);
2988   return S_OK;
2989 }
2990
2991 /***********************************************************************
2992  *           CoSuspendClassObjects [OLE32.@]
2993  *
2994  * Suspends all registered class objects to prevent further requests coming in
2995  * for those objects.
2996  *
2997  * RETURNS
2998  *  Success: S_OK.
2999  *  Failure: HRESULT code.
3000  */
3001 HRESULT WINAPI CoSuspendClassObjects(void)
3002 {
3003     FIXME("\n");
3004     return S_OK;
3005 }
3006
3007 /***********************************************************************
3008  *           CoAddRefServerProcess [OLE32.@]
3009  *
3010  * Helper function for incrementing the reference count of a local-server
3011  * process.
3012  *
3013  * RETURNS
3014  *  New reference count.
3015  *
3016  * SEE ALSO
3017  *  CoReleaseServerProcess().
3018  */
3019 ULONG WINAPI CoAddRefServerProcess(void)
3020 {
3021     ULONG refs;
3022
3023     TRACE("\n");
3024
3025     EnterCriticalSection(&csRegisteredClassList);
3026     refs = ++s_COMServerProcessReferences;
3027     LeaveCriticalSection(&csRegisteredClassList);
3028
3029     TRACE("refs before: %d\n", refs - 1);
3030
3031     return refs;
3032 }
3033
3034 /***********************************************************************
3035  *           CoReleaseServerProcess [OLE32.@]
3036  *
3037  * Helper function for decrementing the reference count of a local-server
3038  * process.
3039  *
3040  * RETURNS
3041  *  New reference count.
3042  *
3043  * NOTES
3044  *  When reference count reaches 0, this function suspends all registered
3045  *  classes so no new connections are accepted.
3046  *
3047  * SEE ALSO
3048  *  CoAddRefServerProcess(), CoSuspendClassObjects().
3049  */
3050 ULONG WINAPI CoReleaseServerProcess(void)
3051 {
3052     ULONG refs;
3053
3054     TRACE("\n");
3055
3056     EnterCriticalSection(&csRegisteredClassList);
3057
3058     refs = --s_COMServerProcessReferences;
3059     /* FIXME: if (!refs) COM_SuspendClassObjects(); */
3060
3061     LeaveCriticalSection(&csRegisteredClassList);
3062
3063     TRACE("refs after: %d\n", refs);
3064
3065     return refs;
3066 }
3067
3068 /***********************************************************************
3069  *           CoIsHandlerConnected [OLE32.@]
3070  *
3071  * Determines whether a proxy is connected to a remote stub.
3072  *
3073  * PARAMS
3074  *  pUnk [I] Pointer to object that may or may not be connected.
3075  *
3076  * RETURNS
3077  *  TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
3078  *  FALSE otherwise.
3079  */
3080 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
3081 {
3082     FIXME("%p\n", pUnk);
3083
3084     return TRUE;
3085 }
3086
3087 /***********************************************************************
3088  *           CoAllowSetForegroundWindow [OLE32.@]
3089  *
3090  */
3091 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
3092 {
3093     FIXME("(%p, %p): stub\n", pUnk, pvReserved);
3094     return S_OK;
3095 }
3096
3097 /***********************************************************************
3098  *           CoQueryProxyBlanket [OLE32.@]
3099  *
3100  * Retrieves the security settings being used by a proxy.
3101  *
3102  * PARAMS
3103  *  pProxy        [I] Pointer to the proxy object.
3104  *  pAuthnSvc     [O] The type of authentication service.
3105  *  pAuthzSvc     [O] The type of authorization service.
3106  *  ppServerPrincName [O] Optional. The server prinicple name.
3107  *  pAuthnLevel   [O] The authentication level.
3108  *  pImpLevel     [O] The impersonation level.
3109  *  ppAuthInfo    [O] Information specific to the authorization/authentication service.
3110  *  pCapabilities [O] Flags affecting the security behaviour.
3111  *
3112  * RETURNS
3113  *  Success: S_OK.
3114  *  Failure: HRESULT code.
3115  *
3116  * SEE ALSO
3117  *  CoCopyProxy, CoSetProxyBlanket.
3118  */
3119 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
3120     DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
3121     DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
3122 {
3123     IClientSecurity *pCliSec;
3124     HRESULT hr;
3125
3126     TRACE("%p\n", pProxy);
3127
3128     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3129     if (SUCCEEDED(hr))
3130     {
3131         hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
3132                                           pAuthzSvc, ppServerPrincName,
3133                                           pAuthnLevel, pImpLevel, ppAuthInfo,
3134                                           pCapabilities);
3135         IClientSecurity_Release(pCliSec);
3136     }
3137
3138     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3139     return hr;
3140 }
3141
3142 /***********************************************************************
3143  *           CoSetProxyBlanket [OLE32.@]
3144  *
3145  * Sets the security settings for a proxy.
3146  *
3147  * PARAMS
3148  *  pProxy       [I] Pointer to the proxy object.
3149  *  AuthnSvc     [I] The type of authentication service.
3150  *  AuthzSvc     [I] The type of authorization service.
3151  *  pServerPrincName [I] The server prinicple name.
3152  *  AuthnLevel   [I] The authentication level.
3153  *  ImpLevel     [I] The impersonation level.
3154  *  pAuthInfo    [I] Information specific to the authorization/authentication service.
3155  *  Capabilities [I] Flags affecting the security behaviour.
3156  *
3157  * RETURNS
3158  *  Success: S_OK.
3159  *  Failure: HRESULT code.
3160  *
3161  * SEE ALSO
3162  *  CoQueryProxyBlanket, CoCopyProxy.
3163  */
3164 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
3165     DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
3166     DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
3167 {
3168     IClientSecurity *pCliSec;
3169     HRESULT hr;
3170
3171     TRACE("%p\n", pProxy);
3172
3173     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3174     if (SUCCEEDED(hr))
3175     {
3176         hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
3177                                         AuthzSvc, pServerPrincName,
3178                                         AuthnLevel, ImpLevel, pAuthInfo,
3179                                         Capabilities);
3180         IClientSecurity_Release(pCliSec);
3181     }
3182
3183     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3184     return hr;
3185 }
3186
3187 /***********************************************************************
3188  *           CoCopyProxy [OLE32.@]
3189  *
3190  * Copies a proxy.
3191  *
3192  * PARAMS
3193  *  pProxy [I] Pointer to the proxy object.
3194  *  ppCopy [O] Copy of the proxy.
3195  *
3196  * RETURNS
3197  *  Success: S_OK.
3198  *  Failure: HRESULT code.
3199  *
3200  * SEE ALSO
3201  *  CoQueryProxyBlanket, CoSetProxyBlanket.
3202  */
3203 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
3204 {
3205     IClientSecurity *pCliSec;
3206     HRESULT hr;
3207
3208     TRACE("%p\n", pProxy);
3209
3210     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3211     if (SUCCEEDED(hr))
3212     {
3213         hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
3214         IClientSecurity_Release(pCliSec);
3215     }
3216
3217     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3218     return hr;
3219 }
3220
3221
3222 /***********************************************************************
3223  *           CoGetCallContext [OLE32.@]
3224  *
3225  * Gets the context of the currently executing server call in the current
3226  * thread.
3227  *
3228  * PARAMS
3229  *  riid [I] Context interface to return.
3230  *  ppv  [O] Pointer to memory that will receive the context on return.
3231  *
3232  * RETURNS
3233  *  Success: S_OK.
3234  *  Failure: HRESULT code.
3235  */
3236 HRESULT WINAPI CoGetCallContext(REFIID riid, void **ppv)
3237 {
3238     FIXME("(%s, %p): stub\n", debugstr_guid(riid), ppv);
3239
3240     *ppv = NULL;
3241     return E_NOINTERFACE;
3242 }
3243
3244 /***********************************************************************
3245  *           CoQueryClientBlanket [OLE32.@]
3246  *
3247  * Retrieves the authentication information about the client of the currently
3248  * executing server call in the current thread.
3249  *
3250  * PARAMS
3251  *  pAuthnSvc     [O] Optional. The type of authentication service.
3252  *  pAuthzSvc     [O] Optional. The type of authorization service.
3253  *  pServerPrincName [O] Optional. The server prinicple name.
3254  *  pAuthnLevel   [O] Optional. The authentication level.
3255  *  pImpLevel     [O] Optional. The impersonation level.
3256  *  pPrivs        [O] Optional. Information about the privileges of the client.
3257  *  pCapabilities [IO] Optional. Flags affecting the security behaviour.
3258  *
3259  * RETURNS
3260  *  Success: S_OK.
3261  *  Failure: HRESULT code.
3262  *
3263  * SEE ALSO
3264  *  CoImpersonateClient, CoRevertToSelf, CoGetCallContext.
3265  */
3266 HRESULT WINAPI CoQueryClientBlanket(
3267     DWORD *pAuthnSvc,
3268     DWORD *pAuthzSvc,
3269     OLECHAR **pServerPrincName,
3270     DWORD *pAuthnLevel,
3271     DWORD *pImpLevel,
3272     RPC_AUTHZ_HANDLE *pPrivs,
3273     DWORD *pCapabilities)
3274 {
3275     IServerSecurity *pSrvSec;
3276     HRESULT hr;
3277
3278     TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
3279         pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel,
3280         pPrivs, pCapabilities);
3281
3282     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3283     if (SUCCEEDED(hr))
3284     {
3285         hr = IServerSecurity_QueryBlanket(
3286             pSrvSec, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel,
3287             pImpLevel, pPrivs, pCapabilities);
3288         IServerSecurity_Release(pSrvSec);
3289     }
3290
3291     return hr;
3292 }
3293
3294 /***********************************************************************
3295  *           CoImpersonateClient [OLE32.@]
3296  *
3297  * Impersonates the client of the currently executing server call in the
3298  * current thread.
3299  *
3300  * PARAMS
3301  *  None.
3302  *
3303  * RETURNS
3304  *  Success: S_OK.
3305  *  Failure: HRESULT code.
3306  *
3307  * NOTES
3308  *  If this function fails then the current thread will not be impersonating
3309  *  the client and all actions will take place on behalf of the server.
3310  *  Therefore, it is important to check the return value from this function.
3311  *
3312  * SEE ALSO
3313  *  CoRevertToSelf, CoQueryClientBlanket, CoGetCallContext.
3314  */
3315 HRESULT WINAPI CoImpersonateClient(void)
3316 {
3317     IServerSecurity *pSrvSec;
3318     HRESULT hr;
3319
3320     TRACE("\n");
3321
3322     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3323     if (SUCCEEDED(hr))
3324     {
3325         hr = IServerSecurity_ImpersonateClient(pSrvSec);
3326         IServerSecurity_Release(pSrvSec);
3327     }
3328
3329     return hr;
3330 }
3331
3332 /***********************************************************************
3333  *           CoRevertToSelf [OLE32.@]
3334  *
3335  * Ends the impersonation of the client of the currently executing server
3336  * call in the current thread.
3337  *
3338  * PARAMS
3339  *  None.
3340  *
3341  * RETURNS
3342  *  Success: S_OK.
3343  *  Failure: HRESULT code.
3344  *
3345  * SEE ALSO
3346  *  CoImpersonateClient, CoQueryClientBlanket, CoGetCallContext.
3347  */
3348 HRESULT WINAPI CoRevertToSelf(void)
3349 {
3350     IServerSecurity *pSrvSec;
3351     HRESULT hr;
3352
3353     TRACE("\n");
3354
3355     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3356     if (SUCCEEDED(hr))
3357     {
3358         hr = IServerSecurity_RevertToSelf(pSrvSec);
3359         IServerSecurity_Release(pSrvSec);
3360     }
3361
3362     return hr;
3363 }
3364
3365 static BOOL COM_PeekMessage(struct apartment *apt, MSG *msg)
3366 {
3367     /* first try to retrieve messages for incoming COM calls to the apartment window */
3368     return PeekMessageW(msg, apt->win, WM_USER, WM_APP - 1, PM_REMOVE|PM_NOYIELD) ||
3369            /* next retrieve other messages necessary for the app to remain responsive */
3370            PeekMessageW(msg, NULL, 0, 0, PM_QS_PAINT|PM_QS_POSTMESSAGE|PM_REMOVE|PM_NOYIELD);
3371 }
3372
3373 /***********************************************************************
3374  *           CoWaitForMultipleHandles [OLE32.@]
3375  *
3376  * Waits for one or more handles to become signaled.
3377  *
3378  * PARAMS
3379  *  dwFlags   [I] Flags. See notes.
3380  *  dwTimeout [I] Timeout in milliseconds.
3381  *  cHandles  [I] Number of handles pointed to by pHandles.
3382  *  pHandles  [I] Handles to wait for.
3383  *  lpdwindex [O] Index of handle that was signaled.
3384  *
3385  * RETURNS
3386  *  Success: S_OK.
3387  *  Failure: RPC_S_CALLPENDING on timeout.
3388  *
3389  * NOTES
3390  *
3391  * The dwFlags parameter can be zero or more of the following:
3392  *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
3393  *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
3394  *
3395  * SEE ALSO
3396  *  MsgWaitForMultipleObjects, WaitForMultipleObjects.
3397  */
3398 HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout,
3399     ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex)
3400 {
3401     HRESULT hr = S_OK;
3402     DWORD start_time = GetTickCount();
3403     APARTMENT *apt = COM_CurrentApt();
3404     BOOL message_loop = apt && !apt->multi_threaded;
3405
3406     TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags, dwTimeout, cHandles,
3407         pHandles, lpdwindex);
3408
3409     while (TRUE)
3410     {
3411         DWORD now = GetTickCount();
3412         DWORD res;
3413
3414         if ((dwTimeout != INFINITE) && (start_time + dwTimeout >= now))
3415         {
3416             hr = RPC_S_CALLPENDING;
3417             break;
3418         }
3419
3420         if (message_loop)
3421         {
3422             DWORD wait_flags = (dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0 |
3423                     (dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0;
3424
3425             TRACE("waiting for rpc completion or window message\n");
3426
3427             res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
3428                 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3429                 QS_ALLINPUT, wait_flags);
3430
3431             if (res == WAIT_OBJECT_0 + cHandles)  /* messages available */
3432             {
3433                 MSG msg;
3434
3435                 /* call message filter */
3436
3437                 if (COM_CurrentApt()->filter)
3438                 {
3439                     PENDINGTYPE pendingtype =
3440                         COM_CurrentInfo()->pending_call_count_server ?
3441                             PENDINGTYPE_NESTED : PENDINGTYPE_TOPLEVEL;
3442                     DWORD be_handled = IMessageFilter_MessagePending(
3443                         COM_CurrentApt()->filter, 0 /* FIXME */,
3444                         now - start_time, pendingtype);
3445                     TRACE("IMessageFilter_MessagePending returned %d\n", be_handled);
3446                     switch (be_handled)
3447                     {
3448                     case PENDINGMSG_CANCELCALL:
3449                         WARN("call canceled\n");
3450                         hr = RPC_E_CALL_CANCELED;
3451                         break;
3452                     case PENDINGMSG_WAITNOPROCESS:
3453                     case PENDINGMSG_WAITDEFPROCESS:
3454                     default:
3455                         /* FIXME: MSDN is very vague about the difference
3456                          * between WAITNOPROCESS and WAITDEFPROCESS - there
3457                          * appears to be none, so it is possibly a left-over
3458                          * from the 16-bit world. */
3459                         break;
3460                     }
3461                 }
3462
3463                 /* note: using "if" here instead of "while" might seem less
3464                  * efficient, but only if we are optimising for quick delivery
3465                  * of pending messages, rather than quick completion of the
3466                  * COM call */
3467                 if (COM_PeekMessage(apt, &msg))
3468                 {
3469                     TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
3470                     TranslateMessage(&msg);
3471                     DispatchMessageW(&msg);
3472                     if (msg.message == WM_QUIT)
3473                     {
3474                         TRACE("resending WM_QUIT to outer message loop\n");
3475                         PostQuitMessage(msg.wParam);
3476                         /* no longer need to process messages */
3477                         message_loop = FALSE;
3478                     }
3479                 }
3480                 continue;
3481             }
3482         }
3483         else
3484         {
3485             TRACE("waiting for rpc completion\n");
3486
3487             res = WaitForMultipleObjectsEx(cHandles, pHandles,
3488                 (dwFlags & COWAIT_WAITALL) ? TRUE : FALSE,
3489                 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3490                 (dwFlags & COWAIT_ALERTABLE) ? TRUE : FALSE);
3491         }
3492
3493         if ((res >= WAIT_OBJECT_0) && (res < WAIT_OBJECT_0 + cHandles))
3494         {
3495             /* handle signaled, store index */
3496             *lpdwindex = (res - WAIT_OBJECT_0);
3497             break;
3498         }
3499         else if (res == WAIT_TIMEOUT)
3500         {
3501             hr = RPC_S_CALLPENDING;
3502             break;
3503         }
3504         else
3505         {
3506             ERR("Unexpected wait termination: %d, %d\n", res, GetLastError());
3507             hr = E_UNEXPECTED;
3508             break;
3509         }
3510     }
3511     TRACE("-- 0x%08x\n", hr);
3512     return hr;
3513 }
3514
3515
3516 /***********************************************************************
3517  *           CoGetObject [OLE32.@]
3518  *
3519  * Gets the object named by coverting the name to a moniker and binding to it.
3520  *
3521  * PARAMS
3522  *  pszName      [I] String representing the object.
3523  *  pBindOptions [I] Parameters affecting the binding to the named object.
3524  *  riid         [I] Interface to bind to on the objecct.
3525  *  ppv          [O] On output, the interface riid of the object represented
3526  *                   by pszName.
3527  *
3528  * RETURNS
3529  *  Success: S_OK.
3530  *  Failure: HRESULT code.
3531  *
3532  * SEE ALSO
3533  *  MkParseDisplayName.
3534  */
3535 HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions,
3536     REFIID riid, void **ppv)
3537 {
3538     IBindCtx *pbc;
3539     HRESULT hr;
3540
3541     *ppv = NULL;
3542
3543     hr = CreateBindCtx(0, &pbc);
3544     if (SUCCEEDED(hr))
3545     {
3546         if (pBindOptions)
3547             hr = IBindCtx_SetBindOptions(pbc, pBindOptions);
3548
3549         if (SUCCEEDED(hr))
3550         {
3551             ULONG chEaten;
3552             IMoniker *pmk;
3553
3554             hr = MkParseDisplayName(pbc, pszName, &chEaten, &pmk);
3555             if (SUCCEEDED(hr))
3556             {
3557                 hr = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppv);
3558                 IMoniker_Release(pmk);
3559             }
3560         }
3561
3562         IBindCtx_Release(pbc);
3563     }
3564     return hr;
3565 }
3566
3567 /***********************************************************************
3568  *           CoRegisterChannelHook [OLE32.@]
3569  *
3570  * Registers a process-wide hook that is called during ORPC calls.
3571  *
3572  * PARAMS
3573  *  guidExtension [I] GUID of the channel hook to register.
3574  *  pChannelHook  [I] Channel hook object to register.
3575  *
3576  * RETURNS
3577  *  Success: S_OK.
3578  *  Failure: HRESULT code.
3579  */
3580 HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *pChannelHook)
3581 {
3582     TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook);
3583
3584     return RPC_RegisterChannelHook(guidExtension, pChannelHook);
3585 }
3586
3587 typedef struct Context
3588 {
3589     const IComThreadingInfoVtbl *lpVtbl;
3590     LONG refs;
3591     APTTYPE apttype;
3592 } Context;
3593
3594 static HRESULT WINAPI Context_QueryInterface(IComThreadingInfo *iface, REFIID riid, LPVOID *ppv)
3595 {
3596     *ppv = NULL;
3597
3598     if (IsEqualIID(riid, &IID_IComThreadingInfo) ||
3599         IsEqualIID(riid, &IID_IUnknown))
3600     {
3601         *ppv = iface;
3602         IUnknown_AddRef(iface);
3603         return S_OK;
3604     }
3605
3606     FIXME("interface not implemented %s\n", debugstr_guid(riid));
3607     return E_NOINTERFACE;
3608 }
3609
3610 static ULONG WINAPI Context_AddRef(IComThreadingInfo *iface)
3611 {
3612     Context *This = (Context *)iface;
3613     return InterlockedIncrement(&This->refs);
3614 }
3615
3616 static ULONG WINAPI Context_Release(IComThreadingInfo *iface)
3617 {
3618     Context *This = (Context *)iface;
3619     ULONG refs = InterlockedDecrement(&This->refs);
3620     if (!refs)
3621         HeapFree(GetProcessHeap(), 0, This);
3622     return refs;
3623 }
3624
3625 static HRESULT WINAPI Context_GetCurrentApartmentType(IComThreadingInfo *iface, APTTYPE *apttype)
3626 {
3627     Context *This = (Context *)iface;
3628
3629     TRACE("(%p)\n", apttype);
3630
3631     *apttype = This->apttype;
3632     return S_OK;
3633 }
3634
3635 static HRESULT WINAPI Context_GetCurrentThreadType(IComThreadingInfo *iface, THDTYPE *thdtype)
3636 {
3637     Context *This = (Context *)iface;
3638
3639     TRACE("(%p)\n", thdtype);
3640
3641     switch (This->apttype)
3642     {
3643     case APTTYPE_STA:
3644     case APTTYPE_MAINSTA:
3645         *thdtype = THDTYPE_PROCESSMESSAGES;
3646         break;
3647     default:
3648         *thdtype = THDTYPE_BLOCKMESSAGES;
3649         break;
3650     }
3651     return S_OK;
3652 }
3653
3654 static HRESULT WINAPI Context_GetCurrentLogicalThreadId(IComThreadingInfo *iface, GUID *logical_thread_id)
3655 {
3656     FIXME("(%p): stub\n", logical_thread_id);
3657     return E_NOTIMPL;
3658 }
3659
3660 static HRESULT WINAPI Context_SetCurrentLogicalThreadId(IComThreadingInfo *iface, REFGUID logical_thread_id)
3661 {
3662     FIXME("(%s): stub\n", debugstr_guid(logical_thread_id));
3663     return E_NOTIMPL;
3664 }
3665
3666 static const IComThreadingInfoVtbl Context_Threading_Vtbl =
3667 {
3668     Context_QueryInterface,
3669     Context_AddRef,
3670     Context_Release,
3671     Context_GetCurrentApartmentType,
3672     Context_GetCurrentThreadType,
3673     Context_GetCurrentLogicalThreadId,
3674     Context_SetCurrentLogicalThreadId
3675 };
3676
3677 /***********************************************************************
3678  *           CoGetObjectContext [OLE32.@]
3679  *
3680  * Retrieves an object associated with the current context (i.e. apartment).
3681  *
3682  * PARAMS
3683  *  riid [I] ID of the interface of the object to retrieve.
3684  *  ppv  [O] Address where object will be stored on return.
3685  *
3686  * RETURNS
3687  *  Success: S_OK.
3688  *  Failure: HRESULT code.
3689  */
3690 HRESULT WINAPI CoGetObjectContext(REFIID riid, void **ppv)
3691 {
3692     APARTMENT *apt = COM_CurrentApt();
3693     Context *context;
3694     HRESULT hr;
3695
3696     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
3697
3698     *ppv = NULL;
3699     if (!apt)
3700     {
3701         ERR("apartment not initialised\n");
3702         return CO_E_NOTINITIALIZED;
3703     }
3704
3705     context = HeapAlloc(GetProcessHeap(), 0, sizeof(*context));
3706     if (!context)
3707         return E_OUTOFMEMORY;
3708
3709     context->lpVtbl = &Context_Threading_Vtbl;
3710     context->refs = 1;
3711     if (apt->multi_threaded)
3712         context->apttype = APTTYPE_MTA;
3713     else if (apt->main)
3714         context->apttype = APTTYPE_MAINSTA;
3715     else
3716         context->apttype = APTTYPE_STA;
3717
3718     hr = IUnknown_QueryInterface((IUnknown *)&context->lpVtbl, riid, ppv);
3719     IUnknown_Release((IUnknown *)&context->lpVtbl);
3720
3721     return hr;
3722 }
3723
3724 /***********************************************************************
3725  *              DllMain (OLE32.@)
3726  */
3727 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
3728 {
3729     TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
3730
3731     switch(fdwReason) {
3732     case DLL_PROCESS_ATTACH:
3733         OLE32_hInstance = hinstDLL;
3734         COMPOBJ_InitProcess();
3735         if (TRACE_ON(ole)) CoRegisterMallocSpy((LPVOID)-1);
3736         break;
3737
3738     case DLL_PROCESS_DETACH:
3739         if (TRACE_ON(ole)) CoRevokeMallocSpy();
3740         OLEDD_UnInitialize();
3741         COMPOBJ_UninitProcess();
3742         RPC_UnregisterAllChannelHooks();
3743         COMPOBJ_DllList_Free();
3744         OLE32_hInstance = 0;
3745         break;
3746
3747     case DLL_THREAD_DETACH:
3748         COM_TlsDestroy();
3749         break;
3750     }
3751     return TRUE;
3752 }
3753
3754 /* NOTE: DllRegisterServer and DllUnregisterServer are in regsvr.c */