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, BOOL hostifnecessary, 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,
2091                                        BOOL hostifnecessary, void **ppv)
2092 {
2093     WCHAR dllpath[MAX_PATH+1];
2094     BOOL apartment_threaded;
2095
2096     if (hostifnecessary)
2097     {
2098         static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
2099         static const WCHAR wszFree[] = {'F','r','e','e',0};
2100         static const WCHAR wszBoth[] = {'B','o','t','h',0};
2101         WCHAR threading_model[10 /* strlenW(L"apartment")+1 */];
2102
2103         get_threading_model(hkeydll, threading_model, ARRAYSIZE(threading_model));
2104         /* "Apartment" */
2105         if (!strcmpiW(threading_model, wszApartment))
2106         {
2107             apartment_threaded = TRUE;
2108             if (apt->multi_threaded)
2109                 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, hkeydll, rclsid, riid, ppv);
2110         }
2111         /* "Free" */
2112         else if (!strcmpiW(threading_model, wszFree))
2113         {
2114             apartment_threaded = FALSE;
2115             if (!apt->multi_threaded)
2116                 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, hkeydll, rclsid, riid, ppv);
2117         }
2118         /* everything except "Apartment", "Free" and "Both" */
2119         else if (strcmpiW(threading_model, wszBoth))
2120         {
2121             apartment_threaded = TRUE;
2122             /* everything else is main-threaded */
2123             if (threading_model[0])
2124                 FIXME("unrecognised threading model %s for object %s, should be main-threaded?\n",
2125                     debugstr_w(threading_model), debugstr_guid(rclsid));
2126
2127             if (apt->multi_threaded || !apt->main)
2128                 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, hkeydll, rclsid, riid, ppv);
2129         }
2130         else
2131             apartment_threaded = FALSE;
2132     }
2133     else
2134         apartment_threaded = !apt->multi_threaded;
2135
2136     if (COM_RegReadPath(hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
2137     {
2138         /* failure: CLSID is not found in registry */
2139         WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
2140         return REGDB_E_CLASSNOTREG;
2141     }
2142
2143     return apartment_getclassobject(apt, dllpath, apartment_threaded,
2144                                     rclsid, riid, ppv);
2145 }
2146
2147 /***********************************************************************
2148  *           CoGetClassObject [OLE32.@]
2149  *
2150  * Creates an object of the specified class.
2151  *
2152  * PARAMS
2153  *  rclsid       [I] Class ID to create an instance of.
2154  *  dwClsContext [I] Flags to restrict the location of the created instance.
2155  *  pServerInfo  [I] Optional. Details for connecting to a remote server.
2156  *  iid          [I] The ID of the interface of the instance to return.
2157  *  ppv          [O] On returns, contains a pointer to the specified interface of the object.
2158  *
2159  * RETURNS
2160  *  Success: S_OK
2161  *  Failure: HRESULT code.
2162  *
2163  * NOTES
2164  *  The dwClsContext parameter can be one or more of the following:
2165  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2166  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2167  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2168  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2169  *
2170  * SEE ALSO
2171  *  CoCreateInstance()
2172  */
2173 HRESULT WINAPI CoGetClassObject(
2174     REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
2175     REFIID iid, LPVOID *ppv)
2176 {
2177     LPUNKNOWN   regClassObject;
2178     HRESULT     hres = E_UNEXPECTED;
2179     APARTMENT  *apt;
2180
2181     TRACE("\n\tCLSID:\t%s,\n\tIID:\t%s\n", debugstr_guid(rclsid), debugstr_guid(iid));
2182
2183     if (!ppv)
2184         return E_INVALIDARG;
2185
2186     *ppv = NULL;
2187
2188     apt = COM_CurrentApt();
2189     if (!apt)
2190     {
2191         ERR("apartment not initialised\n");
2192         return CO_E_NOTINITIALIZED;
2193     }
2194
2195     if (pServerInfo) {
2196         FIXME("\tpServerInfo: name=%s\n",debugstr_w(pServerInfo->pwszName));
2197         FIXME("\t\tpAuthInfo=%p\n",pServerInfo->pAuthInfo);
2198     }
2199
2200     /*
2201      * First, try and see if we can't match the class ID with one of the
2202      * registered classes.
2203      */
2204     if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
2205                                              &regClassObject))
2206     {
2207       /* Get the required interface from the retrieved pointer. */
2208       hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
2209
2210       /*
2211        * Since QI got another reference on the pointer, we want to release the
2212        * one we already have. If QI was unsuccessful, this will release the object. This
2213        * is good since we are not returning it in the "out" parameter.
2214        */
2215       IUnknown_Release(regClassObject);
2216
2217       return hres;
2218     }
2219
2220     /* First try in-process server */
2221     if (CLSCTX_INPROC_SERVER & dwClsContext)
2222     {
2223         static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
2224         HKEY hkey;
2225
2226         if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
2227             return FTMarshalCF_Create(iid, ppv);
2228
2229         hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
2230         if (FAILED(hres))
2231         {
2232             if (hres == REGDB_E_CLASSNOTREG)
2233                 ERR("class %s not registered\n", debugstr_guid(rclsid));
2234             else if (hres == REGDB_E_KEYMISSING)
2235             {
2236                 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
2237                 hres = REGDB_E_CLASSNOTREG;
2238             }
2239         }
2240
2241         if (SUCCEEDED(hres))
2242         {
2243             hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2244                 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2245             RegCloseKey(hkey);
2246         }
2247
2248         /* return if we got a class, otherwise fall through to one of the
2249          * other types */
2250         if (SUCCEEDED(hres))
2251             return hres;
2252     }
2253
2254     /* Next try in-process handler */
2255     if (CLSCTX_INPROC_HANDLER & dwClsContext)
2256     {
2257         static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
2258         HKEY hkey;
2259
2260         hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
2261         if (FAILED(hres))
2262         {
2263             if (hres == REGDB_E_CLASSNOTREG)
2264                 ERR("class %s not registered\n", debugstr_guid(rclsid));
2265             else if (hres == REGDB_E_KEYMISSING)
2266             {
2267                 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
2268                 hres = REGDB_E_CLASSNOTREG;
2269             }
2270         }
2271
2272         if (SUCCEEDED(hres))
2273         {
2274             hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2275                 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2276             RegCloseKey(hkey);
2277         }
2278
2279         /* return if we got a class, otherwise fall through to one of the
2280          * other types */
2281         if (SUCCEEDED(hres))
2282             return hres;
2283     }
2284
2285     /* Next try out of process */
2286     if (CLSCTX_LOCAL_SERVER & dwClsContext)
2287     {
2288         hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
2289         if (SUCCEEDED(hres))
2290             return hres;
2291     }
2292
2293     /* Finally try remote: this requires networked DCOM (a lot of work) */
2294     if (CLSCTX_REMOTE_SERVER & dwClsContext)
2295     {
2296         FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
2297         hres = E_NOINTERFACE;
2298     }
2299
2300     if (FAILED(hres))
2301         ERR("no class object %s could be created for context 0x%x\n",
2302             debugstr_guid(rclsid), dwClsContext);
2303     return hres;
2304 }
2305
2306 /***********************************************************************
2307  *        CoResumeClassObjects (OLE32.@)
2308  *
2309  * Resumes all class objects registered with REGCLS_SUSPENDED.
2310  *
2311  * RETURNS
2312  *  Success: S_OK.
2313  *  Failure: HRESULT code.
2314  */
2315 HRESULT WINAPI CoResumeClassObjects(void)
2316 {
2317        FIXME("stub\n");
2318         return S_OK;
2319 }
2320
2321 /***********************************************************************
2322  *           CoCreateInstance [OLE32.@]
2323  *
2324  * Creates an instance of the specified class.
2325  *
2326  * PARAMS
2327  *  rclsid       [I] Class ID to create an instance of.
2328  *  pUnkOuter    [I] Optional outer unknown to allow aggregation with another object.
2329  *  dwClsContext [I] Flags to restrict the location of the created instance.
2330  *  iid          [I] The ID of the interface of the instance to return.
2331  *  ppv          [O] On returns, contains a pointer to the specified interface of the instance.
2332  *
2333  * RETURNS
2334  *  Success: S_OK
2335  *  Failure: HRESULT code.
2336  *
2337  * NOTES
2338  *  The dwClsContext parameter can be one or more of the following:
2339  *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2340  *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2341  *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2342  *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2343  *
2344  * Aggregation is the concept of deferring the IUnknown of an object to another
2345  * object. This allows a separate object to behave as though it was part of
2346  * the object and to allow this the pUnkOuter parameter can be set. Note that
2347  * not all objects support having an outer of unknown.
2348  *
2349  * SEE ALSO
2350  *  CoGetClassObject()
2351  */
2352 HRESULT WINAPI CoCreateInstance(
2353         REFCLSID rclsid,
2354         LPUNKNOWN pUnkOuter,
2355         DWORD dwClsContext,
2356         REFIID iid,
2357         LPVOID *ppv)
2358 {
2359   HRESULT hres;
2360   LPCLASSFACTORY lpclf = 0;
2361
2362   TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
2363         pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
2364
2365   /*
2366    * Sanity check
2367    */
2368   if (ppv==0)
2369     return E_POINTER;
2370
2371   /*
2372    * Initialize the "out" parameter
2373    */
2374   *ppv = 0;
2375
2376   if (!COM_CurrentApt())
2377   {
2378       ERR("apartment not initialised\n");
2379       return CO_E_NOTINITIALIZED;
2380   }
2381
2382   /*
2383    * The Standard Global Interface Table (GIT) object is a process-wide singleton.
2384    * Rather than create a class factory, we can just check for it here
2385    */
2386   if (IsEqualIID(rclsid, &CLSID_StdGlobalInterfaceTable)) {
2387     if (StdGlobalInterfaceTableInstance == NULL)
2388       StdGlobalInterfaceTableInstance = StdGlobalInterfaceTable_Construct();
2389     hres = IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable*) StdGlobalInterfaceTableInstance, iid, ppv);
2390     if (hres) return hres;
2391
2392     TRACE("Retrieved GIT (%p)\n", *ppv);
2393     return S_OK;
2394   }
2395
2396   /*
2397    * Get a class factory to construct the object we want.
2398    */
2399   hres = CoGetClassObject(rclsid,
2400                           dwClsContext,
2401                           NULL,
2402                           &IID_IClassFactory,
2403                           (LPVOID)&lpclf);
2404
2405   if (FAILED(hres))
2406     return hres;
2407
2408   /*
2409    * Create the object and don't forget to release the factory
2410    */
2411         hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
2412         IClassFactory_Release(lpclf);
2413         if(FAILED(hres))
2414           FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n",
2415                 debugstr_guid(iid), debugstr_guid(rclsid),hres);
2416
2417         return hres;
2418 }
2419
2420 /***********************************************************************
2421  *           CoCreateInstanceEx [OLE32.@]
2422  */
2423 HRESULT WINAPI CoCreateInstanceEx(
2424   REFCLSID      rclsid,
2425   LPUNKNOWN     pUnkOuter,
2426   DWORD         dwClsContext,
2427   COSERVERINFO* pServerInfo,
2428   ULONG         cmq,
2429   MULTI_QI*     pResults)
2430 {
2431   IUnknown* pUnk = NULL;
2432   HRESULT   hr;
2433   ULONG     index;
2434   ULONG     successCount = 0;
2435
2436   /*
2437    * Sanity check
2438    */
2439   if ( (cmq==0) || (pResults==NULL))
2440     return E_INVALIDARG;
2441
2442   if (pServerInfo!=NULL)
2443     FIXME("() non-NULL pServerInfo not supported!\n");
2444
2445   /*
2446    * Initialize all the "out" parameters.
2447    */
2448   for (index = 0; index < cmq; index++)
2449   {
2450     pResults[index].pItf = NULL;
2451     pResults[index].hr   = E_NOINTERFACE;
2452   }
2453
2454   /*
2455    * Get the object and get its IUnknown pointer.
2456    */
2457   hr = CoCreateInstance(rclsid,
2458                         pUnkOuter,
2459                         dwClsContext,
2460                         &IID_IUnknown,
2461                         (VOID**)&pUnk);
2462
2463   if (hr)
2464     return hr;
2465
2466   /*
2467    * Then, query for all the interfaces requested.
2468    */
2469   for (index = 0; index < cmq; index++)
2470   {
2471     pResults[index].hr = IUnknown_QueryInterface(pUnk,
2472                                                  pResults[index].pIID,
2473                                                  (VOID**)&(pResults[index].pItf));
2474
2475     if (pResults[index].hr == S_OK)
2476       successCount++;
2477   }
2478
2479   /*
2480    * Release our temporary unknown pointer.
2481    */
2482   IUnknown_Release(pUnk);
2483
2484   if (successCount == 0)
2485     return E_NOINTERFACE;
2486
2487   if (successCount!=cmq)
2488     return CO_S_NOTALLINTERFACES;
2489
2490   return S_OK;
2491 }
2492
2493 /***********************************************************************
2494  *           CoLoadLibrary (OLE32.@)
2495  *
2496  * Loads a library.
2497  *
2498  * PARAMS
2499  *  lpszLibName [I] Path to library.
2500  *  bAutoFree   [I] Whether the library should automatically be freed.
2501  *
2502  * RETURNS
2503  *  Success: Handle to loaded library.
2504  *  Failure: NULL.
2505  *
2506  * SEE ALSO
2507  *  CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2508  */
2509 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
2510 {
2511     TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
2512
2513     return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
2514 }
2515
2516 /***********************************************************************
2517  *           CoFreeLibrary [OLE32.@]
2518  *
2519  * Unloads a library from memory.
2520  *
2521  * PARAMS
2522  *  hLibrary [I] Handle to library to unload.
2523  *
2524  * RETURNS
2525  *  Nothing
2526  *
2527  * SEE ALSO
2528  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2529  */
2530 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
2531 {
2532     FreeLibrary(hLibrary);
2533 }
2534
2535
2536 /***********************************************************************
2537  *           CoFreeAllLibraries [OLE32.@]
2538  *
2539  * Function for backwards compatibility only. Does nothing.
2540  *
2541  * RETURNS
2542  *  Nothing.
2543  *
2544  * SEE ALSO
2545  *  CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
2546  */
2547 void WINAPI CoFreeAllLibraries(void)
2548 {
2549     /* NOP */
2550 }
2551
2552 /***********************************************************************
2553  *           CoFreeUnusedLibrariesEx [OLE32.@]
2554  *
2555  * Frees any previously unused libraries whose delay has expired and marks
2556  * currently unused libraries for unloading. Unused are identified as those that
2557  * return S_OK from their DllCanUnloadNow function.
2558  *
2559  * PARAMS
2560  *  dwUnloadDelay [I] Unload delay in milliseconds.
2561  *  dwReserved    [I] Reserved. Set to 0.
2562  *
2563  * RETURNS
2564  *  Nothing.
2565  *
2566  * SEE ALSO
2567  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2568  */
2569 void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved)
2570 {
2571     struct apartment *apt = COM_CurrentApt();
2572     if (!apt)
2573     {
2574         ERR("apartment not initialised\n");
2575         return;
2576     }
2577
2578     apartment_freeunusedlibraries(apt, dwUnloadDelay);
2579 }
2580
2581 /***********************************************************************
2582  *           CoFreeUnusedLibraries [OLE32.@]
2583  *           CoFreeUnusedLibraries [COMPOBJ.17]
2584  *
2585  * Frees any unused libraries. Unused are identified as those that return
2586  * S_OK from their DllCanUnloadNow function.
2587  *
2588  * RETURNS
2589  *  Nothing.
2590  *
2591  * SEE ALSO
2592  *  CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2593  */
2594 void WINAPI CoFreeUnusedLibraries(void)
2595 {
2596     CoFreeUnusedLibrariesEx(INFINITE, 0);
2597 }
2598
2599 /***********************************************************************
2600  *           CoFileTimeNow [OLE32.@]
2601  *           CoFileTimeNow [COMPOBJ.82]
2602  *
2603  * Retrieves the current time in FILETIME format.
2604  *
2605  * PARAMS
2606  *  lpFileTime [O] The current time.
2607  *
2608  * RETURNS
2609  *      S_OK.
2610  */
2611 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
2612 {
2613     GetSystemTimeAsFileTime( lpFileTime );
2614     return S_OK;
2615 }
2616
2617 /******************************************************************************
2618  *              CoLockObjectExternal    [OLE32.@]
2619  *
2620  * Increments or decrements the external reference count of a stub object.
2621  *
2622  * PARAMS
2623  *  pUnk                [I] Stub object.
2624  *  fLock               [I] If TRUE then increments the external ref-count,
2625  *                          otherwise decrements.
2626  *  fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2627  *                          calling CoDisconnectObject.
2628  *
2629  * RETURNS
2630  *  Success: S_OK.
2631  *  Failure: HRESULT code.
2632  *
2633  * NOTES
2634  *  If fLock is TRUE and an object is passed in that doesn't have a stub
2635  *  manager then a new stub manager is created for the object.
2636  */
2637 HRESULT WINAPI CoLockObjectExternal(
2638     LPUNKNOWN pUnk,
2639     BOOL fLock,
2640     BOOL fLastUnlockReleases)
2641 {
2642     struct stub_manager *stubmgr;
2643     struct apartment *apt;
2644
2645     TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2646           pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
2647
2648     apt = COM_CurrentApt();
2649     if (!apt) return CO_E_NOTINITIALIZED;
2650
2651     stubmgr = get_stub_manager_from_object(apt, pUnk);
2652
2653     if (stubmgr)
2654     {
2655         if (fLock)
2656             stub_manager_ext_addref(stubmgr, 1);
2657         else
2658             stub_manager_ext_release(stubmgr, 1, fLastUnlockReleases);
2659
2660         stub_manager_int_release(stubmgr);
2661
2662         return S_OK;
2663     }
2664     else if (fLock)
2665     {
2666         stubmgr = new_stub_manager(apt, pUnk);
2667
2668         if (stubmgr)
2669         {
2670             stub_manager_ext_addref(stubmgr, 1);
2671             stub_manager_int_release(stubmgr);
2672         }
2673
2674         return S_OK;
2675     }
2676     else
2677     {
2678         WARN("stub object not found %p\n", pUnk);
2679         /* Note: native is pretty broken here because it just silently
2680          * fails, without returning an appropriate error code, making apps
2681          * think that the object was disconnected, when it actually wasn't */
2682         return S_OK;
2683     }
2684 }
2685
2686 /***********************************************************************
2687  *           CoInitializeWOW (OLE32.@)
2688  *
2689  * WOW equivalent of CoInitialize?
2690  *
2691  * PARAMS
2692  *  x [I] Unknown.
2693  *  y [I] Unknown.
2694  *
2695  * RETURNS
2696  *  Unknown.
2697  */
2698 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
2699 {
2700     FIXME("(0x%08x,0x%08x),stub!\n",x,y);
2701     return 0;
2702 }
2703
2704 /***********************************************************************
2705  *           CoGetState [OLE32.@]
2706  *
2707  * Retrieves the thread state object previously stored by CoSetState().
2708  *
2709  * PARAMS
2710  *  ppv [I] Address where pointer to object will be stored.
2711  *
2712  * RETURNS
2713  *  Success: S_OK.
2714  *  Failure: E_OUTOFMEMORY.
2715  *
2716  * NOTES
2717  *  Crashes on all invalid ppv addresses, including NULL.
2718  *  If the function returns a non-NULL object then the caller must release its
2719  *  reference on the object when the object is no longer required.
2720  *
2721  * SEE ALSO
2722  *  CoSetState().
2723  */
2724 HRESULT WINAPI CoGetState(IUnknown ** ppv)
2725 {
2726     struct oletls *info = COM_CurrentInfo();
2727     if (!info) return E_OUTOFMEMORY;
2728
2729     *ppv = NULL;
2730
2731     if (info->state)
2732     {
2733         IUnknown_AddRef(info->state);
2734         *ppv = info->state;
2735         TRACE("apt->state=%p\n", info->state);
2736     }
2737
2738     return S_OK;
2739 }
2740
2741 /***********************************************************************
2742  *           CoSetState [OLE32.@]
2743  *
2744  * Sets the thread state object.
2745  *
2746  * PARAMS
2747  *  pv [I] Pointer to state object to be stored.
2748  *
2749  * NOTES
2750  *  The system keeps a reference on the object while the object stored.
2751  *
2752  * RETURNS
2753  *  Success: S_OK.
2754  *  Failure: E_OUTOFMEMORY.
2755  */
2756 HRESULT WINAPI CoSetState(IUnknown * pv)
2757 {
2758     struct oletls *info = COM_CurrentInfo();
2759     if (!info) return E_OUTOFMEMORY;
2760
2761     if (pv) IUnknown_AddRef(pv);
2762
2763     if (info->state)
2764     {
2765         TRACE("-- release %p now\n", info->state);
2766         IUnknown_Release(info->state);
2767     }
2768
2769     info->state = pv;
2770
2771     return S_OK;
2772 }
2773
2774
2775 /******************************************************************************
2776  *              CoTreatAsClass        [OLE32.@]
2777  *
2778  * Sets the TreatAs value of a class.
2779  *
2780  * PARAMS
2781  *  clsidOld [I] Class to set TreatAs value on.
2782  *  clsidNew [I] The class the clsidOld should be treated as.
2783  *
2784  * RETURNS
2785  *  Success: S_OK.
2786  *  Failure: HRESULT code.
2787  *
2788  * SEE ALSO
2789  *  CoGetTreatAsClass
2790  */
2791 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
2792 {
2793     static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
2794     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2795     HKEY hkey = NULL;
2796     WCHAR szClsidNew[CHARS_IN_GUID];
2797     HRESULT res = S_OK;
2798     WCHAR auto_treat_as[CHARS_IN_GUID];
2799     LONG auto_treat_as_size = sizeof(auto_treat_as);
2800     CLSID id;
2801
2802     res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
2803     if (FAILED(res))
2804         goto done;
2805     if (!memcmp( clsidOld, clsidNew, sizeof(*clsidOld) ))
2806     {
2807        if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
2808            !CLSIDFromString(auto_treat_as, &id))
2809        {
2810            if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
2811            {
2812                res = REGDB_E_WRITEREGDB;
2813                goto done;
2814            }
2815        }
2816        else
2817        {
2818            RegDeleteKeyW(hkey, wszTreatAs);
2819            goto done;
2820        }
2821     }
2822     else if (!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew)) &&
2823              !RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)))
2824     {
2825         res = REGDB_E_WRITEREGDB;
2826         goto done;
2827     }
2828
2829 done:
2830     if (hkey) RegCloseKey(hkey);
2831     return res;
2832 }
2833
2834 /******************************************************************************
2835  *              CoGetTreatAsClass        [OLE32.@]
2836  *
2837  * Gets the TreatAs value of a class.
2838  *
2839  * PARAMS
2840  *  clsidOld [I] Class to get the TreatAs value of.
2841  *  clsidNew [I] The class the clsidOld should be treated as.
2842  *
2843  * RETURNS
2844  *  Success: S_OK.
2845  *  Failure: HRESULT code.
2846  *
2847  * SEE ALSO
2848  *  CoSetTreatAsClass
2849  */
2850 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
2851 {
2852     static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
2853     HKEY hkey = NULL;
2854     WCHAR szClsidNew[CHARS_IN_GUID];
2855     HRESULT res = S_OK;
2856     LONG len = sizeof(szClsidNew);
2857
2858     FIXME("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
2859     memcpy(clsidNew,clsidOld,sizeof(CLSID)); /* copy over old value */
2860
2861     res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
2862     if (FAILED(res))
2863         goto done;
2864     if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
2865     {
2866         res = S_FALSE;
2867         goto done;
2868     }
2869     res = CLSIDFromString(szClsidNew,clsidNew);
2870     if (FAILED(res))
2871         ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
2872 done:
2873     if (hkey) RegCloseKey(hkey);
2874     return res;
2875 }
2876
2877 /******************************************************************************
2878  *              CoGetCurrentProcess     [OLE32.@]
2879  *              CoGetCurrentProcess     [COMPOBJ.34]
2880  *
2881  * Gets the current process ID.
2882  *
2883  * RETURNS
2884  *  The current process ID.
2885  *
2886  * NOTES
2887  *   Is DWORD really the correct return type for this function?
2888  */
2889 DWORD WINAPI CoGetCurrentProcess(void)
2890 {
2891         return GetCurrentProcessId();
2892 }
2893
2894 /******************************************************************************
2895  *              CoRegisterMessageFilter [OLE32.@]
2896  *
2897  * Registers a message filter.
2898  *
2899  * PARAMS
2900  *  lpMessageFilter [I] Pointer to interface.
2901  *  lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
2902  *
2903  * RETURNS
2904  *  Success: S_OK.
2905  *  Failure: HRESULT code.
2906  *
2907  * NOTES
2908  *  Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
2909  *  lpMessageFilter removes the message filter.
2910  *
2911  *  If lplpMessageFilter is not NULL the previous message filter will be
2912  *  returned in the memory pointer to this parameter and the caller is
2913  *  responsible for releasing the object.
2914  *
2915  *  The current thread be in an apartment otherwise the function will crash.
2916  */
2917 HRESULT WINAPI CoRegisterMessageFilter(
2918     LPMESSAGEFILTER lpMessageFilter,
2919     LPMESSAGEFILTER *lplpMessageFilter)
2920 {
2921     struct apartment *apt;
2922     IMessageFilter *lpOldMessageFilter;
2923
2924     TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
2925
2926     apt = COM_CurrentApt();
2927
2928     /* can't set a message filter in a multi-threaded apartment */
2929     if (!apt || apt->multi_threaded)
2930     {
2931         WARN("can't set message filter in MTA or uninitialized apt\n");
2932         return CO_E_NOT_SUPPORTED;
2933     }
2934
2935     if (lpMessageFilter)
2936         IMessageFilter_AddRef(lpMessageFilter);
2937
2938     EnterCriticalSection(&apt->cs);
2939
2940     lpOldMessageFilter = apt->filter;
2941     apt->filter = lpMessageFilter;
2942
2943     LeaveCriticalSection(&apt->cs);
2944
2945     if (lplpMessageFilter)
2946         *lplpMessageFilter = lpOldMessageFilter;
2947     else if (lpOldMessageFilter)
2948         IMessageFilter_Release(lpOldMessageFilter);
2949
2950     return S_OK;
2951 }
2952
2953 /***********************************************************************
2954  *           CoIsOle1Class [OLE32.@]
2955  *
2956  * Determines whether the specified class an OLE v1 class.
2957  *
2958  * PARAMS
2959  *  clsid [I] Class to test.
2960  *
2961  * RETURNS
2962  *  TRUE if the class is an OLE v1 class, or FALSE otherwise.
2963  */
2964 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
2965 {
2966   FIXME("%s\n", debugstr_guid(clsid));
2967   return FALSE;
2968 }
2969
2970 /***********************************************************************
2971  *           IsEqualGUID [OLE32.@]
2972  *
2973  * Compares two Unique Identifiers.
2974  *
2975  * PARAMS
2976  *  rguid1 [I] The first GUID to compare.
2977  *  rguid2 [I] The other GUID to compare.
2978  *
2979  * RETURNS
2980  *      TRUE if equal
2981  */
2982 #undef IsEqualGUID
2983 BOOL WINAPI IsEqualGUID(
2984      REFGUID rguid1,
2985      REFGUID rguid2)
2986 {
2987     return !memcmp(rguid1,rguid2,sizeof(GUID));
2988 }
2989
2990 /***********************************************************************
2991  *           CoInitializeSecurity [OLE32.@]
2992  */
2993 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
2994                                     SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
2995                                     void* pReserved1, DWORD dwAuthnLevel,
2996                                     DWORD dwImpLevel, void* pReserved2,
2997                                     DWORD dwCapabilities, void* pReserved3)
2998 {
2999   FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
3000         asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
3001         dwCapabilities, pReserved3);
3002   return S_OK;
3003 }
3004
3005 /***********************************************************************
3006  *           CoSuspendClassObjects [OLE32.@]
3007  *
3008  * Suspends all registered class objects to prevent further requests coming in
3009  * for those objects.
3010  *
3011  * RETURNS
3012  *  Success: S_OK.
3013  *  Failure: HRESULT code.
3014  */
3015 HRESULT WINAPI CoSuspendClassObjects(void)
3016 {
3017     FIXME("\n");
3018     return S_OK;
3019 }
3020
3021 /***********************************************************************
3022  *           CoAddRefServerProcess [OLE32.@]
3023  *
3024  * Helper function for incrementing the reference count of a local-server
3025  * process.
3026  *
3027  * RETURNS
3028  *  New reference count.
3029  *
3030  * SEE ALSO
3031  *  CoReleaseServerProcess().
3032  */
3033 ULONG WINAPI CoAddRefServerProcess(void)
3034 {
3035     ULONG refs;
3036
3037     TRACE("\n");
3038
3039     EnterCriticalSection(&csRegisteredClassList);
3040     refs = ++s_COMServerProcessReferences;
3041     LeaveCriticalSection(&csRegisteredClassList);
3042
3043     TRACE("refs before: %d\n", refs - 1);
3044
3045     return refs;
3046 }
3047
3048 /***********************************************************************
3049  *           CoReleaseServerProcess [OLE32.@]
3050  *
3051  * Helper function for decrementing the reference count of a local-server
3052  * process.
3053  *
3054  * RETURNS
3055  *  New reference count.
3056  *
3057  * NOTES
3058  *  When reference count reaches 0, this function suspends all registered
3059  *  classes so no new connections are accepted.
3060  *
3061  * SEE ALSO
3062  *  CoAddRefServerProcess(), CoSuspendClassObjects().
3063  */
3064 ULONG WINAPI CoReleaseServerProcess(void)
3065 {
3066     ULONG refs;
3067
3068     TRACE("\n");
3069
3070     EnterCriticalSection(&csRegisteredClassList);
3071
3072     refs = --s_COMServerProcessReferences;
3073     /* FIXME: if (!refs) COM_SuspendClassObjects(); */
3074
3075     LeaveCriticalSection(&csRegisteredClassList);
3076
3077     TRACE("refs after: %d\n", refs);
3078
3079     return refs;
3080 }
3081
3082 /***********************************************************************
3083  *           CoIsHandlerConnected [OLE32.@]
3084  *
3085  * Determines whether a proxy is connected to a remote stub.
3086  *
3087  * PARAMS
3088  *  pUnk [I] Pointer to object that may or may not be connected.
3089  *
3090  * RETURNS
3091  *  TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
3092  *  FALSE otherwise.
3093  */
3094 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
3095 {
3096     FIXME("%p\n", pUnk);
3097
3098     return TRUE;
3099 }
3100
3101 /***********************************************************************
3102  *           CoAllowSetForegroundWindow [OLE32.@]
3103  *
3104  */
3105 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
3106 {
3107     FIXME("(%p, %p): stub\n", pUnk, pvReserved);
3108     return S_OK;
3109 }
3110
3111 /***********************************************************************
3112  *           CoQueryProxyBlanket [OLE32.@]
3113  *
3114  * Retrieves the security settings being used by a proxy.
3115  *
3116  * PARAMS
3117  *  pProxy        [I] Pointer to the proxy object.
3118  *  pAuthnSvc     [O] The type of authentication service.
3119  *  pAuthzSvc     [O] The type of authorization service.
3120  *  ppServerPrincName [O] Optional. The server prinicple name.
3121  *  pAuthnLevel   [O] The authentication level.
3122  *  pImpLevel     [O] The impersonation level.
3123  *  ppAuthInfo    [O] Information specific to the authorization/authentication service.
3124  *  pCapabilities [O] Flags affecting the security behaviour.
3125  *
3126  * RETURNS
3127  *  Success: S_OK.
3128  *  Failure: HRESULT code.
3129  *
3130  * SEE ALSO
3131  *  CoCopyProxy, CoSetProxyBlanket.
3132  */
3133 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
3134     DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
3135     DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
3136 {
3137     IClientSecurity *pCliSec;
3138     HRESULT hr;
3139
3140     TRACE("%p\n", pProxy);
3141
3142     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3143     if (SUCCEEDED(hr))
3144     {
3145         hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
3146                                           pAuthzSvc, ppServerPrincName,
3147                                           pAuthnLevel, pImpLevel, ppAuthInfo,
3148                                           pCapabilities);
3149         IClientSecurity_Release(pCliSec);
3150     }
3151
3152     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3153     return hr;
3154 }
3155
3156 /***********************************************************************
3157  *           CoSetProxyBlanket [OLE32.@]
3158  *
3159  * Sets the security settings for a proxy.
3160  *
3161  * PARAMS
3162  *  pProxy       [I] Pointer to the proxy object.
3163  *  AuthnSvc     [I] The type of authentication service.
3164  *  AuthzSvc     [I] The type of authorization service.
3165  *  pServerPrincName [I] The server prinicple name.
3166  *  AuthnLevel   [I] The authentication level.
3167  *  ImpLevel     [I] The impersonation level.
3168  *  pAuthInfo    [I] Information specific to the authorization/authentication service.
3169  *  Capabilities [I] Flags affecting the security behaviour.
3170  *
3171  * RETURNS
3172  *  Success: S_OK.
3173  *  Failure: HRESULT code.
3174  *
3175  * SEE ALSO
3176  *  CoQueryProxyBlanket, CoCopyProxy.
3177  */
3178 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
3179     DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
3180     DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
3181 {
3182     IClientSecurity *pCliSec;
3183     HRESULT hr;
3184
3185     TRACE("%p\n", pProxy);
3186
3187     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3188     if (SUCCEEDED(hr))
3189     {
3190         hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
3191                                         AuthzSvc, pServerPrincName,
3192                                         AuthnLevel, ImpLevel, pAuthInfo,
3193                                         Capabilities);
3194         IClientSecurity_Release(pCliSec);
3195     }
3196
3197     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3198     return hr;
3199 }
3200
3201 /***********************************************************************
3202  *           CoCopyProxy [OLE32.@]
3203  *
3204  * Copies a proxy.
3205  *
3206  * PARAMS
3207  *  pProxy [I] Pointer to the proxy object.
3208  *  ppCopy [O] Copy of the proxy.
3209  *
3210  * RETURNS
3211  *  Success: S_OK.
3212  *  Failure: HRESULT code.
3213  *
3214  * SEE ALSO
3215  *  CoQueryProxyBlanket, CoSetProxyBlanket.
3216  */
3217 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
3218 {
3219     IClientSecurity *pCliSec;
3220     HRESULT hr;
3221
3222     TRACE("%p\n", pProxy);
3223
3224     hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3225     if (SUCCEEDED(hr))
3226     {
3227         hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
3228         IClientSecurity_Release(pCliSec);
3229     }
3230
3231     if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3232     return hr;
3233 }
3234
3235
3236 /***********************************************************************
3237  *           CoGetCallContext [OLE32.@]
3238  *
3239  * Gets the context of the currently executing server call in the current
3240  * thread.
3241  *
3242  * PARAMS
3243  *  riid [I] Context interface to return.
3244  *  ppv  [O] Pointer to memory that will receive the context on return.
3245  *
3246  * RETURNS
3247  *  Success: S_OK.
3248  *  Failure: HRESULT code.
3249  */
3250 HRESULT WINAPI CoGetCallContext(REFIID riid, void **ppv)
3251 {
3252     FIXME("(%s, %p): stub\n", debugstr_guid(riid), ppv);
3253
3254     *ppv = NULL;
3255     return E_NOINTERFACE;
3256 }
3257
3258 /***********************************************************************
3259  *           CoQueryClientBlanket [OLE32.@]
3260  *
3261  * Retrieves the authentication information about the client of the currently
3262  * executing server call in the current thread.
3263  *
3264  * PARAMS
3265  *  pAuthnSvc     [O] Optional. The type of authentication service.
3266  *  pAuthzSvc     [O] Optional. The type of authorization service.
3267  *  pServerPrincName [O] Optional. The server prinicple name.
3268  *  pAuthnLevel   [O] Optional. The authentication level.
3269  *  pImpLevel     [O] Optional. The impersonation level.
3270  *  pPrivs        [O] Optional. Information about the privileges of the client.
3271  *  pCapabilities [IO] Optional. Flags affecting the security behaviour.
3272  *
3273  * RETURNS
3274  *  Success: S_OK.
3275  *  Failure: HRESULT code.
3276  *
3277  * SEE ALSO
3278  *  CoImpersonateClient, CoRevertToSelf, CoGetCallContext.
3279  */
3280 HRESULT WINAPI CoQueryClientBlanket(
3281     DWORD *pAuthnSvc,
3282     DWORD *pAuthzSvc,
3283     OLECHAR **pServerPrincName,
3284     DWORD *pAuthnLevel,
3285     DWORD *pImpLevel,
3286     RPC_AUTHZ_HANDLE *pPrivs,
3287     DWORD *pCapabilities)
3288 {
3289     IServerSecurity *pSrvSec;
3290     HRESULT hr;
3291
3292     TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
3293         pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel,
3294         pPrivs, pCapabilities);
3295
3296     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3297     if (SUCCEEDED(hr))
3298     {
3299         hr = IServerSecurity_QueryBlanket(
3300             pSrvSec, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel,
3301             pImpLevel, pPrivs, pCapabilities);
3302         IServerSecurity_Release(pSrvSec);
3303     }
3304
3305     return hr;
3306 }
3307
3308 /***********************************************************************
3309  *           CoImpersonateClient [OLE32.@]
3310  *
3311  * Impersonates the client of the currently executing server call in the
3312  * current thread.
3313  *
3314  * PARAMS
3315  *  None.
3316  *
3317  * RETURNS
3318  *  Success: S_OK.
3319  *  Failure: HRESULT code.
3320  *
3321  * NOTES
3322  *  If this function fails then the current thread will not be impersonating
3323  *  the client and all actions will take place on behalf of the server.
3324  *  Therefore, it is important to check the return value from this function.
3325  *
3326  * SEE ALSO
3327  *  CoRevertToSelf, CoQueryClientBlanket, CoGetCallContext.
3328  */
3329 HRESULT WINAPI CoImpersonateClient(void)
3330 {
3331     IServerSecurity *pSrvSec;
3332     HRESULT hr;
3333
3334     TRACE("\n");
3335
3336     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3337     if (SUCCEEDED(hr))
3338     {
3339         hr = IServerSecurity_ImpersonateClient(pSrvSec);
3340         IServerSecurity_Release(pSrvSec);
3341     }
3342
3343     return hr;
3344 }
3345
3346 /***********************************************************************
3347  *           CoRevertToSelf [OLE32.@]
3348  *
3349  * Ends the impersonation of the client of the currently executing server
3350  * call in the current thread.
3351  *
3352  * PARAMS
3353  *  None.
3354  *
3355  * RETURNS
3356  *  Success: S_OK.
3357  *  Failure: HRESULT code.
3358  *
3359  * SEE ALSO
3360  *  CoImpersonateClient, CoQueryClientBlanket, CoGetCallContext.
3361  */
3362 HRESULT WINAPI CoRevertToSelf(void)
3363 {
3364     IServerSecurity *pSrvSec;
3365     HRESULT hr;
3366
3367     TRACE("\n");
3368
3369     hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3370     if (SUCCEEDED(hr))
3371     {
3372         hr = IServerSecurity_RevertToSelf(pSrvSec);
3373         IServerSecurity_Release(pSrvSec);
3374     }
3375
3376     return hr;
3377 }
3378
3379 static BOOL COM_PeekMessage(struct apartment *apt, MSG *msg)
3380 {
3381     /* first try to retrieve messages for incoming COM calls to the apartment window */
3382     return PeekMessageW(msg, apt->win, WM_USER, WM_APP - 1, PM_REMOVE|PM_NOYIELD) ||
3383            /* next retrieve other messages necessary for the app to remain responsive */
3384            PeekMessageW(msg, NULL, 0, 0, PM_QS_PAINT|PM_QS_POSTMESSAGE|PM_REMOVE|PM_NOYIELD);
3385 }
3386
3387 /***********************************************************************
3388  *           CoWaitForMultipleHandles [OLE32.@]
3389  *
3390  * Waits for one or more handles to become signaled.
3391  *
3392  * PARAMS
3393  *  dwFlags   [I] Flags. See notes.
3394  *  dwTimeout [I] Timeout in milliseconds.
3395  *  cHandles  [I] Number of handles pointed to by pHandles.
3396  *  pHandles  [I] Handles to wait for.
3397  *  lpdwindex [O] Index of handle that was signaled.
3398  *
3399  * RETURNS
3400  *  Success: S_OK.
3401  *  Failure: RPC_S_CALLPENDING on timeout.
3402  *
3403  * NOTES
3404  *
3405  * The dwFlags parameter can be zero or more of the following:
3406  *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
3407  *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
3408  *
3409  * SEE ALSO
3410  *  MsgWaitForMultipleObjects, WaitForMultipleObjects.
3411  */
3412 HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout,
3413     ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex)
3414 {
3415     HRESULT hr = S_OK;
3416     DWORD start_time = GetTickCount();
3417     APARTMENT *apt = COM_CurrentApt();
3418     BOOL message_loop = apt && !apt->multi_threaded;
3419
3420     TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags, dwTimeout, cHandles,
3421         pHandles, lpdwindex);
3422
3423     while (TRUE)
3424     {
3425         DWORD now = GetTickCount();
3426         DWORD res;
3427
3428         if ((dwTimeout != INFINITE) && (start_time + dwTimeout >= now))
3429         {
3430             hr = RPC_S_CALLPENDING;
3431             break;
3432         }
3433
3434         if (message_loop)
3435         {
3436             DWORD wait_flags = (dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0 |
3437                     (dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0;
3438
3439             TRACE("waiting for rpc completion or window message\n");
3440
3441             res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
3442                 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3443                 QS_ALLINPUT, wait_flags);
3444
3445             if (res == WAIT_OBJECT_0 + cHandles)  /* messages available */
3446             {
3447                 MSG msg;
3448
3449                 /* call message filter */
3450
3451                 if (COM_CurrentApt()->filter)
3452                 {
3453                     PENDINGTYPE pendingtype =
3454                         COM_CurrentInfo()->pending_call_count_server ?
3455                             PENDINGTYPE_NESTED : PENDINGTYPE_TOPLEVEL;
3456                     DWORD be_handled = IMessageFilter_MessagePending(
3457                         COM_CurrentApt()->filter, 0 /* FIXME */,
3458                         now - start_time, pendingtype);
3459                     TRACE("IMessageFilter_MessagePending returned %d\n", be_handled);
3460                     switch (be_handled)
3461                     {
3462                     case PENDINGMSG_CANCELCALL:
3463                         WARN("call canceled\n");
3464                         hr = RPC_E_CALL_CANCELED;
3465                         break;
3466                     case PENDINGMSG_WAITNOPROCESS:
3467                     case PENDINGMSG_WAITDEFPROCESS:
3468                     default:
3469                         /* FIXME: MSDN is very vague about the difference
3470                          * between WAITNOPROCESS and WAITDEFPROCESS - there
3471                          * appears to be none, so it is possibly a left-over
3472                          * from the 16-bit world. */
3473                         break;
3474                     }
3475                 }
3476
3477                 /* note: using "if" here instead of "while" might seem less
3478                  * efficient, but only if we are optimising for quick delivery
3479                  * of pending messages, rather than quick completion of the
3480                  * COM call */
3481                 if (COM_PeekMessage(apt, &msg))
3482                 {
3483                     TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
3484                     TranslateMessage(&msg);
3485                     DispatchMessageW(&msg);
3486                     if (msg.message == WM_QUIT)
3487                     {
3488                         TRACE("resending WM_QUIT to outer message loop\n");
3489                         PostQuitMessage(msg.wParam);
3490                         /* no longer need to process messages */
3491                         message_loop = FALSE;
3492                     }
3493                 }
3494                 continue;
3495             }
3496         }
3497         else
3498         {
3499             TRACE("waiting for rpc completion\n");
3500
3501             res = WaitForMultipleObjectsEx(cHandles, pHandles,
3502                 (dwFlags & COWAIT_WAITALL) ? TRUE : FALSE,
3503                 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3504                 (dwFlags & COWAIT_ALERTABLE) ? TRUE : FALSE);
3505         }
3506
3507         if ((res >= WAIT_OBJECT_0) && (res < WAIT_OBJECT_0 + cHandles))
3508         {
3509             /* handle signaled, store index */
3510             *lpdwindex = (res - WAIT_OBJECT_0);
3511             break;
3512         }
3513         else if (res == WAIT_TIMEOUT)
3514         {
3515             hr = RPC_S_CALLPENDING;
3516             break;
3517         }
3518         else
3519         {
3520             ERR("Unexpected wait termination: %d, %d\n", res, GetLastError());
3521             hr = E_UNEXPECTED;
3522             break;
3523         }
3524     }
3525     TRACE("-- 0x%08x\n", hr);
3526     return hr;
3527 }
3528
3529
3530 /***********************************************************************
3531  *           CoGetObject [OLE32.@]
3532  *
3533  * Gets the object named by coverting the name to a moniker and binding to it.
3534  *
3535  * PARAMS
3536  *  pszName      [I] String representing the object.
3537  *  pBindOptions [I] Parameters affecting the binding to the named object.
3538  *  riid         [I] Interface to bind to on the objecct.
3539  *  ppv          [O] On output, the interface riid of the object represented
3540  *                   by pszName.
3541  *
3542  * RETURNS
3543  *  Success: S_OK.
3544  *  Failure: HRESULT code.
3545  *
3546  * SEE ALSO
3547  *  MkParseDisplayName.
3548  */
3549 HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions,
3550     REFIID riid, void **ppv)
3551 {
3552     IBindCtx *pbc;
3553     HRESULT hr;
3554
3555     *ppv = NULL;
3556
3557     hr = CreateBindCtx(0, &pbc);
3558     if (SUCCEEDED(hr))
3559     {
3560         if (pBindOptions)
3561             hr = IBindCtx_SetBindOptions(pbc, pBindOptions);
3562
3563         if (SUCCEEDED(hr))
3564         {
3565             ULONG chEaten;
3566             IMoniker *pmk;
3567
3568             hr = MkParseDisplayName(pbc, pszName, &chEaten, &pmk);
3569             if (SUCCEEDED(hr))
3570             {
3571                 hr = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppv);
3572                 IMoniker_Release(pmk);
3573             }
3574         }
3575
3576         IBindCtx_Release(pbc);
3577     }
3578     return hr;
3579 }
3580
3581 /***********************************************************************
3582  *           CoRegisterChannelHook [OLE32.@]
3583  *
3584  * Registers a process-wide hook that is called during ORPC calls.
3585  *
3586  * PARAMS
3587  *  guidExtension [I] GUID of the channel hook to register.
3588  *  pChannelHook  [I] Channel hook object to register.
3589  *
3590  * RETURNS
3591  *  Success: S_OK.
3592  *  Failure: HRESULT code.
3593  */
3594 HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *pChannelHook)
3595 {
3596     TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook);
3597
3598     return RPC_RegisterChannelHook(guidExtension, pChannelHook);
3599 }
3600
3601 typedef struct Context
3602 {
3603     const IComThreadingInfoVtbl *lpVtbl;
3604     LONG refs;
3605     APTTYPE apttype;
3606 } Context;
3607
3608 static HRESULT WINAPI Context_QueryInterface(IComThreadingInfo *iface, REFIID riid, LPVOID *ppv)
3609 {
3610     *ppv = NULL;
3611
3612     if (IsEqualIID(riid, &IID_IComThreadingInfo) ||
3613         IsEqualIID(riid, &IID_IUnknown))
3614     {
3615         *ppv = iface;
3616         IUnknown_AddRef(iface);
3617         return S_OK;
3618     }
3619
3620     FIXME("interface not implemented %s\n", debugstr_guid(riid));
3621     return E_NOINTERFACE;
3622 }
3623
3624 static ULONG WINAPI Context_AddRef(IComThreadingInfo *iface)
3625 {
3626     Context *This = (Context *)iface;
3627     return InterlockedIncrement(&This->refs);
3628 }
3629
3630 static ULONG WINAPI Context_Release(IComThreadingInfo *iface)
3631 {
3632     Context *This = (Context *)iface;
3633     ULONG refs = InterlockedDecrement(&This->refs);
3634     if (!refs)
3635         HeapFree(GetProcessHeap(), 0, This);
3636     return refs;
3637 }
3638
3639 static HRESULT WINAPI Context_GetCurrentApartmentType(IComThreadingInfo *iface, APTTYPE *apttype)
3640 {
3641     Context *This = (Context *)iface;
3642
3643     TRACE("(%p)\n", apttype);
3644
3645     *apttype = This->apttype;
3646     return S_OK;
3647 }
3648
3649 static HRESULT WINAPI Context_GetCurrentThreadType(IComThreadingInfo *iface, THDTYPE *thdtype)
3650 {
3651     Context *This = (Context *)iface;
3652
3653     TRACE("(%p)\n", thdtype);
3654
3655     switch (This->apttype)
3656     {
3657     case APTTYPE_STA:
3658     case APTTYPE_MAINSTA:
3659         *thdtype = THDTYPE_PROCESSMESSAGES;
3660         break;
3661     default:
3662         *thdtype = THDTYPE_BLOCKMESSAGES;
3663         break;
3664     }
3665     return S_OK;
3666 }
3667
3668 static HRESULT WINAPI Context_GetCurrentLogicalThreadId(IComThreadingInfo *iface, GUID *logical_thread_id)
3669 {
3670     FIXME("(%p): stub\n", logical_thread_id);
3671     return E_NOTIMPL;
3672 }
3673
3674 static HRESULT WINAPI Context_SetCurrentLogicalThreadId(IComThreadingInfo *iface, REFGUID logical_thread_id)
3675 {
3676     FIXME("(%s): stub\n", debugstr_guid(logical_thread_id));
3677     return E_NOTIMPL;
3678 }
3679
3680 static const IComThreadingInfoVtbl Context_Threading_Vtbl =
3681 {
3682     Context_QueryInterface,
3683     Context_AddRef,
3684     Context_Release,
3685     Context_GetCurrentApartmentType,
3686     Context_GetCurrentThreadType,
3687     Context_GetCurrentLogicalThreadId,
3688     Context_SetCurrentLogicalThreadId
3689 };
3690
3691 /***********************************************************************
3692  *           CoGetObjectContext [OLE32.@]
3693  *
3694  * Retrieves an object associated with the current context (i.e. apartment).
3695  *
3696  * PARAMS
3697  *  riid [I] ID of the interface of the object to retrieve.
3698  *  ppv  [O] Address where object will be stored on return.
3699  *
3700  * RETURNS
3701  *  Success: S_OK.
3702  *  Failure: HRESULT code.
3703  */
3704 HRESULT WINAPI CoGetObjectContext(REFIID riid, void **ppv)
3705 {
3706     APARTMENT *apt = COM_CurrentApt();
3707     Context *context;
3708     HRESULT hr;
3709
3710     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
3711
3712     *ppv = NULL;
3713     if (!apt)
3714     {
3715         ERR("apartment not initialised\n");
3716         return CO_E_NOTINITIALIZED;
3717     }
3718
3719     context = HeapAlloc(GetProcessHeap(), 0, sizeof(*context));
3720     if (!context)
3721         return E_OUTOFMEMORY;
3722
3723     context->lpVtbl = &Context_Threading_Vtbl;
3724     context->refs = 1;
3725     if (apt->multi_threaded)
3726         context->apttype = APTTYPE_MTA;
3727     else if (apt->main)
3728         context->apttype = APTTYPE_MAINSTA;
3729     else
3730         context->apttype = APTTYPE_STA;
3731
3732     hr = IUnknown_QueryInterface((IUnknown *)&context->lpVtbl, riid, ppv);
3733     IUnknown_Release((IUnknown *)&context->lpVtbl);
3734
3735     return hr;
3736 }
3737
3738 /***********************************************************************
3739  *              DllMain (OLE32.@)
3740  */
3741 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
3742 {
3743     TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
3744
3745     switch(fdwReason) {
3746     case DLL_PROCESS_ATTACH:
3747         OLE32_hInstance = hinstDLL;
3748         COMPOBJ_InitProcess();
3749         if (TRACE_ON(ole)) CoRegisterMallocSpy((LPVOID)-1);
3750         break;
3751
3752     case DLL_PROCESS_DETACH:
3753         if (TRACE_ON(ole)) CoRevokeMallocSpy();
3754         OLEDD_UnInitialize();
3755         COMPOBJ_UninitProcess();
3756         RPC_UnregisterAllChannelHooks();
3757         COMPOBJ_DllList_Free();
3758         OLE32_hInstance = 0;
3759         break;
3760
3761     case DLL_THREAD_DETACH:
3762         COM_TlsDestroy();
3763         break;
3764     }
3765     return TRUE;
3766 }
3767
3768 /* NOTE: DllRegisterServer and DllUnregisterServer are in regsvr.c */