winaspi.dll16: Simplify the "pointer to start of array" idiom.
[wine/multimedia.git] / dlls / ole32 / compobj.c
blobff8f9610c6e09ac65531c08f28c68e0fe2040141
1 /*
2 * COMPOBJ library
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)
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.
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.
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
26 * Note
27 * 1. COINIT_MULTITHREADED is 0; it is the lack of COINIT_APARTMENTTHREADED
28 * Therefore do not test against COINIT_MULTITHREADED
30 * TODO list: (items bunched together depend on each other)
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
39 #include "config.h"
41 #include <stdarg.h>
42 #include <stdio.h>
43 #include <string.h>
44 #include <assert.h>
46 #define COBJMACROS
47 #define NONAMELESSUNION
48 #define NONAMELESSSTRUCT
50 #include "windef.h"
51 #include "winbase.h"
52 #include "winerror.h"
53 #include "winreg.h"
54 #include "winuser.h"
55 #define USE_COM_CONTEXT_DEF
56 #include "objbase.h"
57 #include "ole2.h"
58 #include "ole2ver.h"
59 #include "ctxtcall.h"
60 #include "dde.h"
62 #include "initguid.h"
63 #include "compobj_private.h"
64 #include "moniker.h"
66 #include "wine/unicode.h"
67 #include "wine/debug.h"
69 WINE_DEFAULT_DEBUG_CHANNEL(ole);
71 #define ARRAYSIZE(array) (sizeof(array)/sizeof((array)[0]))
73 /****************************************************************************
74 * This section defines variables internal to the COM module.
77 static APARTMENT *MTA; /* protected by csApartment */
78 static APARTMENT *MainApartment; /* the first STA apartment */
79 static struct list apts = LIST_INIT( apts ); /* protected by csApartment */
81 static CRITICAL_SECTION csApartment;
82 static CRITICAL_SECTION_DEBUG critsect_debug =
84 0, 0, &csApartment,
85 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
86 0, 0, { (DWORD_PTR)(__FILE__ ": csApartment") }
88 static CRITICAL_SECTION csApartment = { &critsect_debug, -1, 0, 0, 0, 0 };
90 struct registered_psclsid
92 struct list entry;
93 IID iid;
94 CLSID clsid;
98 * This lock count counts the number of times CoInitialize is called. It is
99 * decreased every time CoUninitialize is called. When it hits 0, the COM
100 * libraries are freed
102 static LONG s_COMLockCount = 0;
103 /* Reference count used by CoAddRefServerProcess/CoReleaseServerProcess */
104 static LONG s_COMServerProcessReferences = 0;
107 * This linked list contains the list of registered class objects. These
108 * are mostly used to register the factories for out-of-proc servers of OLE
109 * objects.
111 * TODO: Make this data structure aware of inter-process communication. This
112 * means that parts of this will be exported to rpcss.
114 typedef struct tagRegisteredClass
116 struct list entry;
117 CLSID classIdentifier;
118 OXID apartment_id;
119 LPUNKNOWN classObject;
120 DWORD runContext;
121 DWORD connectFlags;
122 DWORD dwCookie;
123 LPSTREAM pMarshaledData; /* FIXME: only really need to store OXID and IPID */
124 void *RpcRegistration;
125 } RegisteredClass;
127 static struct list RegisteredClassList = LIST_INIT(RegisteredClassList);
129 static CRITICAL_SECTION csRegisteredClassList;
130 static CRITICAL_SECTION_DEBUG class_cs_debug =
132 0, 0, &csRegisteredClassList,
133 { &class_cs_debug.ProcessLocksList, &class_cs_debug.ProcessLocksList },
134 0, 0, { (DWORD_PTR)(__FILE__ ": csRegisteredClassList") }
136 static CRITICAL_SECTION csRegisteredClassList = { &class_cs_debug, -1, 0, 0, 0, 0 };
138 /*****************************************************************************
139 * This section contains OpenDllList definitions
141 * The OpenDllList contains only handles of dll loaded by CoGetClassObject or
142 * other functions that do LoadLibrary _without_ giving back a HMODULE.
143 * Without this list these handles would never be freed.
145 * FIXME: a DLL that says OK when asked for unloading is unloaded in the
146 * next unload-call but not before 600 sec.
149 typedef HRESULT (CALLBACK *DllGetClassObjectFunc)(REFCLSID clsid, REFIID iid, LPVOID *ppv);
150 typedef HRESULT (WINAPI *DllCanUnloadNowFunc)(void);
152 typedef struct tagOpenDll
154 LONG refs;
155 LPWSTR library_name;
156 HANDLE library;
157 DllGetClassObjectFunc DllGetClassObject;
158 DllCanUnloadNowFunc DllCanUnloadNow;
159 struct list entry;
160 } OpenDll;
162 static struct list openDllList = LIST_INIT(openDllList);
164 static CRITICAL_SECTION csOpenDllList;
165 static CRITICAL_SECTION_DEBUG dll_cs_debug =
167 0, 0, &csOpenDllList,
168 { &dll_cs_debug.ProcessLocksList, &dll_cs_debug.ProcessLocksList },
169 0, 0, { (DWORD_PTR)(__FILE__ ": csOpenDllList") }
171 static CRITICAL_SECTION csOpenDllList = { &dll_cs_debug, -1, 0, 0, 0, 0 };
173 struct apartment_loaded_dll
175 struct list entry;
176 OpenDll *dll;
177 DWORD unload_time;
178 BOOL multi_threaded;
181 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',' ',
182 '0','x','#','#','#','#','#','#','#','#',' ',0};
184 /*****************************************************************************
185 * This section contains OpenDllList implementation
188 static OpenDll *COMPOBJ_DllList_Get(LPCWSTR library_name)
190 OpenDll *ptr;
191 OpenDll *ret = NULL;
192 EnterCriticalSection(&csOpenDllList);
193 LIST_FOR_EACH_ENTRY(ptr, &openDllList, OpenDll, entry)
195 if (!strcmpiW(library_name, ptr->library_name) &&
196 (InterlockedIncrement(&ptr->refs) != 1) /* entry is being destroy if == 1 */)
198 ret = ptr;
199 break;
202 LeaveCriticalSection(&csOpenDllList);
203 return ret;
206 /* caller must ensure that library_name is not already in the open dll list */
207 static HRESULT COMPOBJ_DllList_Add(LPCWSTR library_name, OpenDll **ret)
209 OpenDll *entry;
210 int len;
211 HRESULT hr = S_OK;
212 HANDLE hLibrary;
213 DllCanUnloadNowFunc DllCanUnloadNow;
214 DllGetClassObjectFunc DllGetClassObject;
216 TRACE("\n");
218 *ret = COMPOBJ_DllList_Get(library_name);
219 if (*ret) return S_OK;
221 /* do this outside the csOpenDllList to avoid creating a lock dependency on
222 * the loader lock */
223 hLibrary = LoadLibraryExW(library_name, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
224 if (!hLibrary)
226 ERR("couldn't load in-process dll %s\n", debugstr_w(library_name));
227 /* failure: DLL could not be loaded */
228 return E_ACCESSDENIED; /* FIXME: or should this be CO_E_DLLNOTFOUND? */
231 DllCanUnloadNow = (void *)GetProcAddress(hLibrary, "DllCanUnloadNow");
232 /* Note: failing to find DllCanUnloadNow is not a failure */
233 DllGetClassObject = (void *)GetProcAddress(hLibrary, "DllGetClassObject");
234 if (!DllGetClassObject)
236 /* failure: the dll did not export DllGetClassObject */
237 ERR("couldn't find function DllGetClassObject in %s\n", debugstr_w(library_name));
238 FreeLibrary(hLibrary);
239 return CO_E_DLLNOTFOUND;
242 EnterCriticalSection( &csOpenDllList );
244 *ret = COMPOBJ_DllList_Get(library_name);
245 if (*ret)
247 /* another caller to this function already added the dll while we
248 * weren't in the critical section */
249 FreeLibrary(hLibrary);
251 else
253 len = strlenW(library_name);
254 entry = HeapAlloc(GetProcessHeap(),0, sizeof(OpenDll));
255 if (entry)
256 entry->library_name = HeapAlloc(GetProcessHeap(), 0, (len + 1)*sizeof(WCHAR));
257 if (entry && entry->library_name)
259 memcpy(entry->library_name, library_name, (len + 1)*sizeof(WCHAR));
260 entry->library = hLibrary;
261 entry->refs = 1;
262 entry->DllCanUnloadNow = DllCanUnloadNow;
263 entry->DllGetClassObject = DllGetClassObject;
264 list_add_tail(&openDllList, &entry->entry);
266 else
268 HeapFree(GetProcessHeap(), 0, entry);
269 hr = E_OUTOFMEMORY;
270 FreeLibrary(hLibrary);
272 *ret = entry;
275 LeaveCriticalSection( &csOpenDllList );
277 return hr;
280 /* pass FALSE for free_entry to release a reference without destroying the
281 * entry if it reaches zero or TRUE otherwise */
282 static void COMPOBJ_DllList_ReleaseRef(OpenDll *entry, BOOL free_entry)
284 if (!InterlockedDecrement(&entry->refs) && free_entry)
286 EnterCriticalSection(&csOpenDllList);
287 list_remove(&entry->entry);
288 LeaveCriticalSection(&csOpenDllList);
290 TRACE("freeing %p\n", entry->library);
291 FreeLibrary(entry->library);
293 HeapFree(GetProcessHeap(), 0, entry->library_name);
294 HeapFree(GetProcessHeap(), 0, entry);
298 /* frees memory associated with active dll list */
299 static void COMPOBJ_DllList_Free(void)
301 OpenDll *entry, *cursor2;
302 EnterCriticalSection(&csOpenDllList);
303 LIST_FOR_EACH_ENTRY_SAFE(entry, cursor2, &openDllList, OpenDll, entry)
305 list_remove(&entry->entry);
307 HeapFree(GetProcessHeap(), 0, entry->library_name);
308 HeapFree(GetProcessHeap(), 0, entry);
310 LeaveCriticalSection(&csOpenDllList);
311 DeleteCriticalSection(&csOpenDllList);
314 /******************************************************************************
315 * Manage apartments.
318 static DWORD apartment_addref(struct apartment *apt)
320 DWORD refs = InterlockedIncrement(&apt->refs);
321 TRACE("%s: before = %d\n", wine_dbgstr_longlong(apt->oxid), refs - 1);
322 return refs;
325 /* allocates memory and fills in the necessary fields for a new apartment
326 * object. must be called inside apartment cs */
327 static APARTMENT *apartment_construct(DWORD model)
329 APARTMENT *apt;
331 TRACE("creating new apartment, model=%d\n", model);
333 apt = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*apt));
334 apt->tid = GetCurrentThreadId();
336 list_init(&apt->proxies);
337 list_init(&apt->stubmgrs);
338 list_init(&apt->psclsids);
339 list_init(&apt->loaded_dlls);
340 apt->ipidc = 0;
341 apt->refs = 1;
342 apt->remunk_exported = FALSE;
343 apt->oidc = 1;
344 InitializeCriticalSection(&apt->cs);
345 DEBUG_SET_CRITSEC_NAME(&apt->cs, "apartment");
347 apt->multi_threaded = !(model & COINIT_APARTMENTTHREADED);
349 if (apt->multi_threaded)
351 /* FIXME: should be randomly generated by in an RPC call to rpcss */
352 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | 0xcafe;
354 else
356 /* FIXME: should be randomly generated by in an RPC call to rpcss */
357 apt->oxid = ((OXID)GetCurrentProcessId() << 32) | GetCurrentThreadId();
360 TRACE("Created apartment on OXID %s\n", wine_dbgstr_longlong(apt->oxid));
362 list_add_head(&apts, &apt->entry);
364 return apt;
367 /* gets and existing apartment if one exists or otherwise creates an apartment
368 * structure which stores OLE apartment-local information and stores a pointer
369 * to it in the thread-local storage */
370 static APARTMENT *apartment_get_or_create(DWORD model)
372 APARTMENT *apt = COM_CurrentApt();
374 if (!apt)
376 if (model & COINIT_APARTMENTTHREADED)
378 EnterCriticalSection(&csApartment);
380 apt = apartment_construct(model);
381 if (!MainApartment)
383 MainApartment = apt;
384 apt->main = TRUE;
385 TRACE("Created main-threaded apartment with OXID %s\n", wine_dbgstr_longlong(apt->oxid));
388 LeaveCriticalSection(&csApartment);
390 if (apt->main)
391 apartment_createwindowifneeded(apt);
393 else
395 EnterCriticalSection(&csApartment);
397 /* The multi-threaded apartment (MTA) contains zero or more threads interacting
398 * with free threaded (ie thread safe) COM objects. There is only ever one MTA
399 * in a process */
400 if (MTA)
402 TRACE("entering the multithreaded apartment %s\n", wine_dbgstr_longlong(MTA->oxid));
403 apartment_addref(MTA);
405 else
406 MTA = apartment_construct(model);
408 apt = MTA;
410 LeaveCriticalSection(&csApartment);
412 COM_CurrentInfo()->apt = apt;
415 return apt;
418 static inline BOOL apartment_is_model(const APARTMENT *apt, DWORD model)
420 return (apt->multi_threaded == !(model & COINIT_APARTMENTTHREADED));
423 static void COM_RevokeRegisteredClassObject(RegisteredClass *curClass)
425 list_remove(&curClass->entry);
427 if (curClass->runContext & CLSCTX_LOCAL_SERVER)
428 RPC_StopLocalServer(curClass->RpcRegistration);
431 * Release the reference to the class object.
433 IUnknown_Release(curClass->classObject);
435 if (curClass->pMarshaledData)
437 LARGE_INTEGER zero;
438 memset(&zero, 0, sizeof(zero));
439 IStream_Seek(curClass->pMarshaledData, zero, STREAM_SEEK_SET, NULL);
440 CoReleaseMarshalData(curClass->pMarshaledData);
441 IStream_Release(curClass->pMarshaledData);
444 HeapFree(GetProcessHeap(), 0, curClass);
447 static void COM_RevokeAllClasses(const struct apartment *apt)
449 RegisteredClass *curClass, *cursor;
451 EnterCriticalSection( &csRegisteredClassList );
453 LIST_FOR_EACH_ENTRY_SAFE(curClass, cursor, &RegisteredClassList, RegisteredClass, entry)
455 if (curClass->apartment_id == apt->oxid)
456 COM_RevokeRegisteredClassObject(curClass);
459 LeaveCriticalSection( &csRegisteredClassList );
462 /******************************************************************************
463 * Implementation of the manual reset event object. (CLSID_ManualResetEvent)
466 typedef struct ManualResetEvent {
467 ISynchronize ISynchronize_iface;
468 LONG ref;
469 HANDLE event;
470 } MREImpl;
472 static inline MREImpl *impl_from_ISynchronize(ISynchronize *iface)
474 return CONTAINING_RECORD(iface, MREImpl, ISynchronize_iface);
477 static HRESULT WINAPI ISynchronize_fnQueryInterface(ISynchronize *iface, REFIID riid, void **ppv)
479 MREImpl *This = impl_from_ISynchronize(iface);
480 TRACE("%p (%s, %p)\n", This, debugstr_guid(riid), ppv);
482 *ppv = NULL;
483 if(IsEqualGUID(riid, &IID_IUnknown) ||
484 IsEqualGUID(riid, &IID_ISynchronize))
485 *ppv = This;
486 else
487 ERR("Unknown interface %s requested.\n", debugstr_guid(riid));
489 if(*ppv)
491 IUnknown_AddRef((IUnknown*)*ppv);
492 return S_OK;
495 return E_NOINTERFACE;
498 static ULONG WINAPI ISynchronize_fnAddRef(ISynchronize *iface)
500 MREImpl *This = impl_from_ISynchronize(iface);
501 LONG ref = InterlockedIncrement(&This->ref);
502 TRACE("%p - ref %d\n", This, ref);
504 return ref;
507 static ULONG WINAPI ISynchronize_fnRelease(ISynchronize *iface)
509 MREImpl *This = impl_from_ISynchronize(iface);
510 LONG ref = InterlockedDecrement(&This->ref);
511 TRACE("%p - ref %d\n", This, ref);
513 if(!ref)
515 CloseHandle(This->event);
516 HeapFree(GetProcessHeap(), 0, This);
519 return ref;
522 static HRESULT WINAPI ISynchronize_fnWait(ISynchronize *iface, DWORD dwFlags, DWORD dwMilliseconds)
524 MREImpl *This = impl_from_ISynchronize(iface);
525 UINT index;
526 TRACE("%p (%08x, %08x)\n", This, dwFlags, dwMilliseconds);
527 return CoWaitForMultipleHandles(dwFlags, dwMilliseconds, 1, &This->event, &index);
530 static HRESULT WINAPI ISynchronize_fnSignal(ISynchronize *iface)
532 MREImpl *This = impl_from_ISynchronize(iface);
533 TRACE("%p\n", This);
534 SetEvent(This->event);
535 return S_OK;
538 static HRESULT WINAPI ISynchronize_fnReset(ISynchronize *iface)
540 MREImpl *This = impl_from_ISynchronize(iface);
541 TRACE("%p\n", This);
542 ResetEvent(This->event);
543 return S_OK;
546 static ISynchronizeVtbl vt_ISynchronize = {
547 ISynchronize_fnQueryInterface,
548 ISynchronize_fnAddRef,
549 ISynchronize_fnRelease,
550 ISynchronize_fnWait,
551 ISynchronize_fnSignal,
552 ISynchronize_fnReset
555 static HRESULT ManualResetEvent_Construct(IUnknown *punkouter, REFIID iid, void **ppv)
557 MREImpl *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(MREImpl));
558 HRESULT hr;
560 if(punkouter)
561 FIXME("Aggregation not implemented.\n");
563 This->ref = 1;
564 This->ISynchronize_iface.lpVtbl = &vt_ISynchronize;
565 This->event = CreateEventW(NULL, TRUE, FALSE, NULL);
567 hr = ISynchronize_QueryInterface(&This->ISynchronize_iface, iid, ppv);
568 ISynchronize_Release(&This->ISynchronize_iface);
569 return hr;
572 /***********************************************************************
573 * CoRevokeClassObject [OLE32.@]
575 * Removes a class object from the class registry.
577 * PARAMS
578 * dwRegister [I] Cookie returned from CoRegisterClassObject().
580 * RETURNS
581 * Success: S_OK.
582 * Failure: HRESULT code.
584 * NOTES
585 * Must be called from the same apartment that called CoRegisterClassObject(),
586 * otherwise it will fail with RPC_E_WRONG_THREAD.
588 * SEE ALSO
589 * CoRegisterClassObject
591 HRESULT WINAPI CoRevokeClassObject(
592 DWORD dwRegister)
594 HRESULT hr = E_INVALIDARG;
595 RegisteredClass *curClass;
596 APARTMENT *apt;
598 TRACE("(%08x)\n",dwRegister);
600 apt = COM_CurrentApt();
601 if (!apt)
603 ERR("COM was not initialized\n");
604 return CO_E_NOTINITIALIZED;
607 EnterCriticalSection( &csRegisteredClassList );
609 LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
612 * Check if we have a match on the cookie.
614 if (curClass->dwCookie == dwRegister)
616 if (curClass->apartment_id == apt->oxid)
618 COM_RevokeRegisteredClassObject(curClass);
619 hr = S_OK;
621 else
623 ERR("called from wrong apartment, should be called from %s\n",
624 wine_dbgstr_longlong(curClass->apartment_id));
625 hr = RPC_E_WRONG_THREAD;
627 break;
631 LeaveCriticalSection( &csRegisteredClassList );
633 return hr;
636 /* frees unused libraries loaded by apartment_getclassobject by calling the
637 * DLL's DllCanUnloadNow entry point */
638 static void apartment_freeunusedlibraries(struct apartment *apt, DWORD delay)
640 struct apartment_loaded_dll *entry, *next;
641 EnterCriticalSection(&apt->cs);
642 LIST_FOR_EACH_ENTRY_SAFE(entry, next, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
644 if (entry->dll->DllCanUnloadNow && (entry->dll->DllCanUnloadNow() == S_OK))
646 DWORD real_delay = delay;
648 if (real_delay == INFINITE)
650 /* DLLs that return multi-threaded objects aren't unloaded
651 * straight away to cope for programs that have races between
652 * last object destruction and threads in the DLLs that haven't
653 * finished, despite DllCanUnloadNow returning S_OK */
654 if (entry->multi_threaded)
655 real_delay = 10 * 60 * 1000; /* 10 minutes */
656 else
657 real_delay = 0;
660 if (!real_delay || (entry->unload_time && (entry->unload_time < GetTickCount())))
662 list_remove(&entry->entry);
663 COMPOBJ_DllList_ReleaseRef(entry->dll, TRUE);
664 HeapFree(GetProcessHeap(), 0, entry);
666 else
667 entry->unload_time = GetTickCount() + real_delay;
669 else if (entry->unload_time)
670 entry->unload_time = 0;
672 LeaveCriticalSection(&apt->cs);
675 DWORD apartment_release(struct apartment *apt)
677 DWORD ret;
679 EnterCriticalSection(&csApartment);
681 ret = InterlockedDecrement(&apt->refs);
682 TRACE("%s: after = %d\n", wine_dbgstr_longlong(apt->oxid), ret);
683 /* destruction stuff that needs to happen under csApartment CS */
684 if (ret == 0)
686 if (apt == MTA) MTA = NULL;
687 else if (apt == MainApartment) MainApartment = NULL;
688 list_remove(&apt->entry);
691 LeaveCriticalSection(&csApartment);
693 if (ret == 0)
695 struct list *cursor, *cursor2;
697 TRACE("destroying apartment %p, oxid %s\n", apt, wine_dbgstr_longlong(apt->oxid));
699 /* Release the references to the registered class objects */
700 COM_RevokeAllClasses(apt);
702 /* no locking is needed for this apartment, because no other thread
703 * can access it at this point */
705 apartment_disconnectproxies(apt);
707 if (apt->win) DestroyWindow(apt->win);
708 if (apt->host_apt_tid) PostThreadMessageW(apt->host_apt_tid, WM_QUIT, 0, 0);
710 LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->stubmgrs)
712 struct stub_manager *stubmgr = LIST_ENTRY(cursor, struct stub_manager, entry);
713 /* release the implicit reference given by the fact that the
714 * stub has external references (it must do since it is in the
715 * stub manager list in the apartment and all non-apartment users
716 * must have a ref on the apartment and so it cannot be destroyed).
718 stub_manager_int_release(stubmgr);
721 LIST_FOR_EACH_SAFE(cursor, cursor2, &apt->psclsids)
723 struct registered_psclsid *registered_psclsid =
724 LIST_ENTRY(cursor, struct registered_psclsid, entry);
726 list_remove(&registered_psclsid->entry);
727 HeapFree(GetProcessHeap(), 0, registered_psclsid);
730 /* if this assert fires, then another thread took a reference to a
731 * stub manager without taking a reference to the containing
732 * apartment, which it must do. */
733 assert(list_empty(&apt->stubmgrs));
735 if (apt->filter) IUnknown_Release(apt->filter);
737 /* free as many unused libraries as possible... */
738 apartment_freeunusedlibraries(apt, 0);
740 /* ... and free the memory for the apartment loaded dll entry and
741 * release the dll list reference without freeing the library for the
742 * rest */
743 while ((cursor = list_head(&apt->loaded_dlls)))
745 struct apartment_loaded_dll *apartment_loaded_dll = LIST_ENTRY(cursor, struct apartment_loaded_dll, entry);
746 COMPOBJ_DllList_ReleaseRef(apartment_loaded_dll->dll, FALSE);
747 list_remove(cursor);
748 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
751 DEBUG_CLEAR_CRITSEC_NAME(&apt->cs);
752 DeleteCriticalSection(&apt->cs);
754 HeapFree(GetProcessHeap(), 0, apt);
757 return ret;
760 /* The given OXID must be local to this process:
762 * The ref parameter is here mostly to ensure people remember that
763 * they get one, you should normally take a ref for thread safety.
765 APARTMENT *apartment_findfromoxid(OXID oxid, BOOL ref)
767 APARTMENT *result = NULL;
768 struct list *cursor;
770 EnterCriticalSection(&csApartment);
771 LIST_FOR_EACH( cursor, &apts )
773 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
774 if (apt->oxid == oxid)
776 result = apt;
777 if (ref) apartment_addref(result);
778 break;
781 LeaveCriticalSection(&csApartment);
783 return result;
786 /* gets the apartment which has a given creator thread ID. The caller must
787 * release the reference from the apartment as soon as the apartment pointer
788 * is no longer required. */
789 APARTMENT *apartment_findfromtid(DWORD tid)
791 APARTMENT *result = NULL;
792 struct list *cursor;
794 EnterCriticalSection(&csApartment);
795 LIST_FOR_EACH( cursor, &apts )
797 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
798 if (apt->tid == tid)
800 result = apt;
801 apartment_addref(result);
802 break;
805 LeaveCriticalSection(&csApartment);
807 return result;
810 /* gets the main apartment if it exists. The caller must
811 * release the reference from the apartment as soon as the apartment pointer
812 * is no longer required. */
813 static APARTMENT *apartment_findmain(void)
815 APARTMENT *result;
817 EnterCriticalSection(&csApartment);
819 result = MainApartment;
820 if (result) apartment_addref(result);
822 LeaveCriticalSection(&csApartment);
824 return result;
827 /* gets the multi-threaded apartment if it exists. The caller must
828 * release the reference from the apartment as soon as the apartment pointer
829 * is no longer required. */
830 static APARTMENT *apartment_find_multi_threaded(void)
832 APARTMENT *result = NULL;
833 struct list *cursor;
835 EnterCriticalSection(&csApartment);
837 LIST_FOR_EACH( cursor, &apts )
839 struct apartment *apt = LIST_ENTRY( cursor, struct apartment, entry );
840 if (apt->multi_threaded)
842 result = apt;
843 apartment_addref(result);
844 break;
848 LeaveCriticalSection(&csApartment);
849 return result;
852 /* gets the specified class object by loading the appropriate DLL, if
853 * necessary and calls the DllGetClassObject function for the DLL */
854 static HRESULT apartment_getclassobject(struct apartment *apt, LPCWSTR dllpath,
855 BOOL apartment_threaded,
856 REFCLSID rclsid, REFIID riid, void **ppv)
858 static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
859 HRESULT hr = S_OK;
860 BOOL found = FALSE;
861 struct apartment_loaded_dll *apartment_loaded_dll;
863 if (!strcmpiW(dllpath, wszOle32))
865 /* we don't need to control the lifetime of this dll, so use the local
866 * implementation of DllGetClassObject directly */
867 TRACE("calling ole32!DllGetClassObject\n");
868 hr = DllGetClassObject(rclsid, riid, ppv);
870 if (hr != S_OK)
871 ERR("DllGetClassObject returned error 0x%08x\n", hr);
873 return hr;
876 EnterCriticalSection(&apt->cs);
878 LIST_FOR_EACH_ENTRY(apartment_loaded_dll, &apt->loaded_dlls, struct apartment_loaded_dll, entry)
879 if (!strcmpiW(dllpath, apartment_loaded_dll->dll->library_name))
881 TRACE("found %s already loaded\n", debugstr_w(dllpath));
882 found = TRUE;
883 break;
886 if (!found)
888 apartment_loaded_dll = HeapAlloc(GetProcessHeap(), 0, sizeof(*apartment_loaded_dll));
889 if (!apartment_loaded_dll)
890 hr = E_OUTOFMEMORY;
891 if (SUCCEEDED(hr))
893 apartment_loaded_dll->unload_time = 0;
894 apartment_loaded_dll->multi_threaded = FALSE;
895 hr = COMPOBJ_DllList_Add( dllpath, &apartment_loaded_dll->dll );
896 if (FAILED(hr))
897 HeapFree(GetProcessHeap(), 0, apartment_loaded_dll);
899 if (SUCCEEDED(hr))
901 TRACE("added new loaded dll %s\n", debugstr_w(dllpath));
902 list_add_tail(&apt->loaded_dlls, &apartment_loaded_dll->entry);
906 LeaveCriticalSection(&apt->cs);
908 if (SUCCEEDED(hr))
910 /* one component being multi-threaded overrides any number of
911 * apartment-threaded components */
912 if (!apartment_threaded)
913 apartment_loaded_dll->multi_threaded = TRUE;
915 TRACE("calling DllGetClassObject %p\n", apartment_loaded_dll->dll->DllGetClassObject);
916 /* OK: get the ClassObject */
917 hr = apartment_loaded_dll->dll->DllGetClassObject(rclsid, riid, ppv);
919 if (hr != S_OK)
920 ERR("DllGetClassObject returned error 0x%08x\n", hr);
923 return hr;
926 /***********************************************************************
927 * COM_RegReadPath [internal]
929 * Reads a registry value and expands it when necessary
931 static DWORD COM_RegReadPath(HKEY hkeyroot, const WCHAR *keyname, const WCHAR *valuename, WCHAR * dst, DWORD dstlen)
933 DWORD ret;
934 HKEY key;
935 DWORD keytype;
936 WCHAR src[MAX_PATH];
937 DWORD dwLength = dstlen * sizeof(WCHAR);
939 if((ret = RegOpenKeyExW(hkeyroot, keyname, 0, KEY_READ, &key)) == ERROR_SUCCESS) {
940 if( (ret = RegQueryValueExW(key, NULL, NULL, &keytype, (LPBYTE)src, &dwLength)) == ERROR_SUCCESS ) {
941 if (keytype == REG_EXPAND_SZ) {
942 if (dstlen <= ExpandEnvironmentStringsW(src, dst, dstlen)) ret = ERROR_MORE_DATA;
943 } else {
944 const WCHAR *quote_start;
945 quote_start = strchrW(src, '\"');
946 if (quote_start) {
947 const WCHAR *quote_end = strchrW(quote_start + 1, '\"');
948 if (quote_end) {
949 memmove(src, quote_start + 1,
950 (quote_end - quote_start - 1) * sizeof(WCHAR));
951 src[quote_end - quote_start - 1] = '\0';
954 lstrcpynW(dst, src, dstlen);
957 RegCloseKey (key);
959 return ret;
962 struct host_object_params
964 HKEY hkeydll;
965 CLSID clsid; /* clsid of object to marshal */
966 IID iid; /* interface to marshal */
967 HANDLE event; /* event signalling when ready for multi-threaded case */
968 HRESULT hr; /* result for multi-threaded case */
969 IStream *stream; /* stream that the object will be marshaled into */
970 BOOL apartment_threaded; /* is the component purely apartment-threaded? */
973 static HRESULT apartment_hostobject(struct apartment *apt,
974 const struct host_object_params *params)
976 IUnknown *object;
977 HRESULT hr;
978 static const LARGE_INTEGER llZero;
979 WCHAR dllpath[MAX_PATH+1];
981 TRACE("clsid %s, iid %s\n", debugstr_guid(&params->clsid), debugstr_guid(&params->iid));
983 if (COM_RegReadPath(params->hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
985 /* failure: CLSID is not found in registry */
986 WARN("class %s not registered inproc\n", debugstr_guid(&params->clsid));
987 return REGDB_E_CLASSNOTREG;
990 hr = apartment_getclassobject(apt, dllpath, params->apartment_threaded,
991 &params->clsid, &params->iid, (void **)&object);
992 if (FAILED(hr))
993 return hr;
995 hr = CoMarshalInterface(params->stream, &params->iid, object, MSHCTX_INPROC, NULL, MSHLFLAGS_NORMAL);
996 if (FAILED(hr))
997 IUnknown_Release(object);
998 IStream_Seek(params->stream, llZero, STREAM_SEEK_SET, NULL);
1000 return hr;
1003 static LRESULT CALLBACK apartment_wndproc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
1005 switch (msg)
1007 case DM_EXECUTERPC:
1008 RPC_ExecuteCall((struct dispatch_params *)lParam);
1009 return 0;
1010 case DM_HOSTOBJECT:
1011 return apartment_hostobject(COM_CurrentApt(), (const struct host_object_params *)lParam);
1012 default:
1013 return DefWindowProcW(hWnd, msg, wParam, lParam);
1017 struct host_thread_params
1019 COINIT threading_model;
1020 HANDLE ready_event;
1021 HWND apartment_hwnd;
1024 /* thread for hosting an object to allow an object to appear to be created in
1025 * an apartment with an incompatible threading model */
1026 static DWORD CALLBACK apartment_hostobject_thread(LPVOID p)
1028 struct host_thread_params *params = p;
1029 MSG msg;
1030 HRESULT hr;
1031 struct apartment *apt;
1033 TRACE("\n");
1035 hr = CoInitializeEx(NULL, params->threading_model);
1036 if (FAILED(hr)) return hr;
1038 apt = COM_CurrentApt();
1039 if (params->threading_model == COINIT_APARTMENTTHREADED)
1041 apartment_createwindowifneeded(apt);
1042 params->apartment_hwnd = apartment_getwindow(apt);
1044 else
1045 params->apartment_hwnd = NULL;
1047 /* force the message queue to be created before signaling parent thread */
1048 PeekMessageW(&msg, NULL, WM_USER, WM_USER, PM_NOREMOVE);
1050 SetEvent(params->ready_event);
1051 params = NULL; /* can't touch params after here as it may be invalid */
1053 while (GetMessageW(&msg, NULL, 0, 0))
1055 if (!msg.hwnd && (msg.message == DM_HOSTOBJECT))
1057 struct host_object_params *obj_params = (struct host_object_params *)msg.lParam;
1058 obj_params->hr = apartment_hostobject(apt, obj_params);
1059 SetEvent(obj_params->event);
1061 else
1063 TranslateMessage(&msg);
1064 DispatchMessageW(&msg);
1068 TRACE("exiting\n");
1070 CoUninitialize();
1072 return S_OK;
1075 /* finds or creates a host apartment, creates the object inside it and returns
1076 * a proxy to it so that the object can be used in the apartment of the
1077 * caller of this function */
1078 static HRESULT apartment_hostobject_in_hostapt(
1079 struct apartment *apt, BOOL multi_threaded, BOOL main_apartment,
1080 HKEY hkeydll, REFCLSID rclsid, REFIID riid, void **ppv)
1082 struct host_object_params params;
1083 HWND apartment_hwnd = NULL;
1084 DWORD apartment_tid = 0;
1085 HRESULT hr;
1087 if (!multi_threaded && main_apartment)
1089 APARTMENT *host_apt = apartment_findmain();
1090 if (host_apt)
1092 apartment_hwnd = apartment_getwindow(host_apt);
1093 apartment_release(host_apt);
1097 if (!apartment_hwnd)
1099 EnterCriticalSection(&apt->cs);
1101 if (!apt->host_apt_tid)
1103 struct host_thread_params thread_params;
1104 HANDLE handles[2];
1105 DWORD wait_value;
1107 thread_params.threading_model = multi_threaded ? COINIT_MULTITHREADED : COINIT_APARTMENTTHREADED;
1108 handles[0] = thread_params.ready_event = CreateEventW(NULL, FALSE, FALSE, NULL);
1109 thread_params.apartment_hwnd = NULL;
1110 handles[1] = CreateThread(NULL, 0, apartment_hostobject_thread, &thread_params, 0, &apt->host_apt_tid);
1111 if (!handles[1])
1113 CloseHandle(handles[0]);
1114 LeaveCriticalSection(&apt->cs);
1115 return E_OUTOFMEMORY;
1117 wait_value = WaitForMultipleObjects(2, handles, FALSE, INFINITE);
1118 CloseHandle(handles[0]);
1119 CloseHandle(handles[1]);
1120 if (wait_value == WAIT_OBJECT_0)
1121 apt->host_apt_hwnd = thread_params.apartment_hwnd;
1122 else
1124 LeaveCriticalSection(&apt->cs);
1125 return E_OUTOFMEMORY;
1129 if (multi_threaded || !main_apartment)
1131 apartment_hwnd = apt->host_apt_hwnd;
1132 apartment_tid = apt->host_apt_tid;
1135 LeaveCriticalSection(&apt->cs);
1138 /* another thread may have become the main apartment in the time it took
1139 * us to create the thread for the host apartment */
1140 if (!apartment_hwnd && !multi_threaded && main_apartment)
1142 APARTMENT *host_apt = apartment_findmain();
1143 if (host_apt)
1145 apartment_hwnd = apartment_getwindow(host_apt);
1146 apartment_release(host_apt);
1150 params.hkeydll = hkeydll;
1151 params.clsid = *rclsid;
1152 params.iid = *riid;
1153 hr = CreateStreamOnHGlobal(NULL, TRUE, &params.stream);
1154 if (FAILED(hr))
1155 return hr;
1156 params.apartment_threaded = !multi_threaded;
1157 if (multi_threaded)
1159 params.hr = S_OK;
1160 params.event = CreateEventW(NULL, FALSE, FALSE, NULL);
1161 if (!PostThreadMessageW(apartment_tid, DM_HOSTOBJECT, 0, (LPARAM)&params))
1162 hr = E_OUTOFMEMORY;
1163 else
1165 WaitForSingleObject(params.event, INFINITE);
1166 hr = params.hr;
1168 CloseHandle(params.event);
1170 else
1172 if (!apartment_hwnd)
1174 ERR("host apartment didn't create window\n");
1175 hr = E_OUTOFMEMORY;
1177 else
1178 hr = SendMessageW(apartment_hwnd, DM_HOSTOBJECT, 0, (LPARAM)&params);
1180 if (SUCCEEDED(hr))
1181 hr = CoUnmarshalInterface(params.stream, riid, ppv);
1182 IStream_Release(params.stream);
1183 return hr;
1186 /* create a window for the apartment or return the current one if one has
1187 * already been created */
1188 HRESULT apartment_createwindowifneeded(struct apartment *apt)
1190 if (apt->multi_threaded)
1191 return S_OK;
1193 if (!apt->win)
1195 HWND hwnd = CreateWindowW(wszAptWinClass, NULL, 0,
1196 0, 0, 0, 0,
1197 HWND_MESSAGE, 0, hProxyDll, NULL);
1198 if (!hwnd)
1200 ERR("CreateWindow failed with error %d\n", GetLastError());
1201 return HRESULT_FROM_WIN32(GetLastError());
1203 if (InterlockedCompareExchangePointer((PVOID *)&apt->win, hwnd, NULL))
1204 /* someone beat us to it */
1205 DestroyWindow(hwnd);
1208 return S_OK;
1211 /* retrieves the window for the main- or apartment-threaded apartment */
1212 HWND apartment_getwindow(const struct apartment *apt)
1214 assert(!apt->multi_threaded);
1215 return apt->win;
1218 void apartment_joinmta(void)
1220 apartment_addref(MTA);
1221 COM_CurrentInfo()->apt = MTA;
1224 static void COMPOBJ_InitProcess( void )
1226 WNDCLASSW wclass;
1228 /* Dispatching to the correct thread in an apartment is done through
1229 * window messages rather than RPC transports. When an interface is
1230 * marshalled into another apartment in the same process, a window of the
1231 * following class is created. The *caller* of CoMarshalInterface (i.e., the
1232 * application) is responsible for pumping the message loop in that thread.
1233 * The WM_USER messages which point to the RPCs are then dispatched to
1234 * apartment_wndproc by the user's code from the apartment in which the
1235 * interface was unmarshalled.
1237 memset(&wclass, 0, sizeof(wclass));
1238 wclass.lpfnWndProc = apartment_wndproc;
1239 wclass.hInstance = hProxyDll;
1240 wclass.lpszClassName = wszAptWinClass;
1241 RegisterClassW(&wclass);
1244 static void COMPOBJ_UninitProcess( void )
1246 UnregisterClassW(wszAptWinClass, hProxyDll);
1249 static void COM_TlsDestroy(void)
1251 struct oletls *info = NtCurrentTeb()->ReservedForOle;
1252 if (info)
1254 if (info->apt) apartment_release(info->apt);
1255 if (info->errorinfo) IErrorInfo_Release(info->errorinfo);
1256 if (info->state) IUnknown_Release(info->state);
1257 if (info->spy) IUnknown_Release(info->spy);
1258 if (info->context_token) IObjContext_Release(info->context_token);
1259 HeapFree(GetProcessHeap(), 0, info);
1260 NtCurrentTeb()->ReservedForOle = NULL;
1264 /******************************************************************************
1265 * CoBuildVersion [OLE32.@]
1267 * Gets the build version of the DLL.
1269 * PARAMS
1271 * RETURNS
1272 * Current build version, hiword is majornumber, loword is minornumber
1274 DWORD WINAPI CoBuildVersion(void)
1276 TRACE("Returning version %d, build %d.\n", rmm, rup);
1277 return (rmm<<16)+rup;
1280 /******************************************************************************
1281 * CoRegisterInitializeSpy [OLE32.@]
1283 * Add a Spy that watches CoInitializeEx calls
1285 * PARAMS
1286 * spy [I] Pointer to IUnknown interface that will be QueryInterface'd.
1287 * cookie [II] cookie receiver
1289 * RETURNS
1290 * Success: S_OK if not already initialized, S_FALSE otherwise.
1291 * Failure: HRESULT code.
1293 * SEE ALSO
1294 * CoInitializeEx
1296 HRESULT WINAPI CoRegisterInitializeSpy(IInitializeSpy *spy, ULARGE_INTEGER *cookie)
1298 struct oletls *info = COM_CurrentInfo();
1299 HRESULT hr;
1301 TRACE("(%p, %p)\n", spy, cookie);
1303 if (!spy || !cookie || !info)
1305 if (!info)
1306 WARN("Could not allocate tls\n");
1307 return E_INVALIDARG;
1310 if (info->spy)
1312 FIXME("Already registered?\n");
1313 return E_UNEXPECTED;
1316 hr = IUnknown_QueryInterface(spy, &IID_IInitializeSpy, (void **) &info->spy);
1317 if (SUCCEEDED(hr))
1319 cookie->QuadPart = (DWORD_PTR)spy;
1320 return S_OK;
1322 return hr;
1325 /******************************************************************************
1326 * CoRevokeInitializeSpy [OLE32.@]
1328 * Remove a spy that previously watched CoInitializeEx calls
1330 * PARAMS
1331 * cookie [I] The cookie obtained from a previous CoRegisterInitializeSpy call
1333 * RETURNS
1334 * Success: S_OK if a spy is removed
1335 * Failure: E_INVALIDARG
1337 * SEE ALSO
1338 * CoInitializeEx
1340 HRESULT WINAPI CoRevokeInitializeSpy(ULARGE_INTEGER cookie)
1342 struct oletls *info = COM_CurrentInfo();
1343 TRACE("(%s)\n", wine_dbgstr_longlong(cookie.QuadPart));
1345 if (!info || !info->spy || cookie.QuadPart != (DWORD_PTR)info->spy)
1346 return E_INVALIDARG;
1348 IUnknown_Release(info->spy);
1349 info->spy = NULL;
1350 return S_OK;
1354 /******************************************************************************
1355 * CoInitialize [OLE32.@]
1357 * Initializes the COM libraries by calling CoInitializeEx with
1358 * COINIT_APARTMENTTHREADED, ie it enters a STA thread.
1360 * PARAMS
1361 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1363 * RETURNS
1364 * Success: S_OK if not already initialized, S_FALSE otherwise.
1365 * Failure: HRESULT code.
1367 * SEE ALSO
1368 * CoInitializeEx
1370 HRESULT WINAPI CoInitialize(LPVOID lpReserved)
1373 * Just delegate to the newer method.
1375 return CoInitializeEx(lpReserved, COINIT_APARTMENTTHREADED);
1378 /******************************************************************************
1379 * CoInitializeEx [OLE32.@]
1381 * Initializes the COM libraries.
1383 * PARAMS
1384 * lpReserved [I] Pointer to IMalloc interface (obsolete, should be NULL).
1385 * dwCoInit [I] One or more flags from the COINIT enumeration. See notes.
1387 * RETURNS
1388 * S_OK if successful,
1389 * S_FALSE if this function was called already.
1390 * RPC_E_CHANGED_MODE if a previous call to CoInitializeEx specified another
1391 * threading model.
1393 * NOTES
1395 * The behavior used to set the IMalloc used for memory management is
1396 * obsolete.
1397 * The dwCoInit parameter must specify one of the following apartment
1398 * threading models:
1399 *| COINIT_APARTMENTTHREADED - A single-threaded apartment (STA).
1400 *| COINIT_MULTITHREADED - A multi-threaded apartment (MTA).
1401 * The parameter may also specify zero or more of the following flags:
1402 *| COINIT_DISABLE_OLE1DDE - Don't use DDE for OLE1 support.
1403 *| COINIT_SPEED_OVER_MEMORY - Trade memory for speed.
1405 * SEE ALSO
1406 * CoUninitialize
1408 HRESULT WINAPI CoInitializeEx(LPVOID lpReserved, DWORD dwCoInit)
1410 struct oletls *info = COM_CurrentInfo();
1411 HRESULT hr = S_OK;
1412 APARTMENT *apt;
1414 TRACE("(%p, %x)\n", lpReserved, (int)dwCoInit);
1416 if (lpReserved!=NULL)
1418 ERR("(%p, %x) - Bad parameter passed-in %p, must be an old Windows Application\n", lpReserved, (int)dwCoInit, lpReserved);
1422 * Check the lock count. If this is the first time going through the initialize
1423 * process, we have to initialize the libraries.
1425 * And crank-up that lock count.
1427 if (InterlockedExchangeAdd(&s_COMLockCount,1)==0)
1430 * Initialize the various COM libraries and data structures.
1432 TRACE("() - Initializing the COM libraries\n");
1434 /* we may need to defer this until after apartment initialisation */
1435 RunningObjectTableImpl_Initialize();
1438 if (info->spy)
1439 IInitializeSpy_PreInitialize(info->spy, dwCoInit, info->inits);
1441 if (!(apt = info->apt))
1443 apt = apartment_get_or_create(dwCoInit);
1444 if (!apt) return E_OUTOFMEMORY;
1446 else if (!apartment_is_model(apt, dwCoInit))
1448 /* Changing the threading model after it's been set is illegal. If this warning is triggered by Wine
1449 code then we are probably using the wrong threading model to implement that API. */
1450 ERR("Attempt to change threading model of this apartment from %s to %s\n",
1451 apt->multi_threaded ? "multi-threaded" : "apartment threaded",
1452 dwCoInit & COINIT_APARTMENTTHREADED ? "apartment threaded" : "multi-threaded");
1453 return RPC_E_CHANGED_MODE;
1455 else
1456 hr = S_FALSE;
1458 info->inits++;
1460 if (info->spy)
1461 IInitializeSpy_PostInitialize(info->spy, hr, dwCoInit, info->inits);
1463 return hr;
1466 /***********************************************************************
1467 * CoUninitialize [OLE32.@]
1469 * This method will decrement the refcount on the current apartment, freeing
1470 * the resources associated with it if it is the last thread in the apartment.
1471 * If the last apartment is freed, the function will additionally release
1472 * any COM resources associated with the process.
1474 * PARAMS
1476 * RETURNS
1477 * Nothing.
1479 * SEE ALSO
1480 * CoInitializeEx
1482 void WINAPI CoUninitialize(void)
1484 struct oletls * info = COM_CurrentInfo();
1485 LONG lCOMRefCnt;
1487 TRACE("()\n");
1489 /* will only happen on OOM */
1490 if (!info) return;
1492 if (info->spy)
1493 IInitializeSpy_PreUninitialize(info->spy, info->inits);
1495 /* sanity check */
1496 if (!info->inits)
1498 ERR("Mismatched CoUninitialize\n");
1500 if (info->spy)
1501 IInitializeSpy_PostUninitialize(info->spy, info->inits);
1502 return;
1505 if (!--info->inits)
1507 apartment_release(info->apt);
1508 info->apt = NULL;
1512 * Decrease the reference count.
1513 * If we are back to 0 locks on the COM library, make sure we free
1514 * all the associated data structures.
1516 lCOMRefCnt = InterlockedExchangeAdd(&s_COMLockCount,-1);
1517 if (lCOMRefCnt==1)
1519 TRACE("() - Releasing the COM libraries\n");
1521 RunningObjectTableImpl_UnInitialize();
1523 else if (lCOMRefCnt<1) {
1524 ERR( "CoUninitialize() - not CoInitialized.\n" );
1525 InterlockedExchangeAdd(&s_COMLockCount,1); /* restore the lock count. */
1527 if (info->spy)
1528 IInitializeSpy_PostUninitialize(info->spy, info->inits);
1531 /******************************************************************************
1532 * CoDisconnectObject [OLE32.@]
1534 * Disconnects all connections to this object from remote processes. Dispatches
1535 * pending RPCs while blocking new RPCs from occurring, and then calls
1536 * IMarshal::DisconnectObject on the given object.
1538 * Typically called when the object server is forced to shut down, for instance by
1539 * the user.
1541 * PARAMS
1542 * lpUnk [I] The object whose stub should be disconnected.
1543 * reserved [I] Reserved. Should be set to 0.
1545 * RETURNS
1546 * Success: S_OK.
1547 * Failure: HRESULT code.
1549 * SEE ALSO
1550 * CoMarshalInterface, CoReleaseMarshalData, CoLockObjectExternal
1552 HRESULT WINAPI CoDisconnectObject( LPUNKNOWN lpUnk, DWORD reserved )
1554 HRESULT hr;
1555 IMarshal *marshal;
1556 APARTMENT *apt;
1558 TRACE("(%p, 0x%08x)\n", lpUnk, reserved);
1560 if (!lpUnk) return E_INVALIDARG;
1562 hr = IUnknown_QueryInterface(lpUnk, &IID_IMarshal, (void **)&marshal);
1563 if (hr == S_OK)
1565 hr = IMarshal_DisconnectObject(marshal, reserved);
1566 IMarshal_Release(marshal);
1567 return hr;
1570 apt = COM_CurrentApt();
1571 if (!apt)
1572 return CO_E_NOTINITIALIZED;
1574 apartment_disconnectobject(apt, lpUnk);
1576 /* Note: native is pretty broken here because it just silently
1577 * fails, without returning an appropriate error code if the object was
1578 * not found, making apps think that the object was disconnected, when
1579 * it actually wasn't */
1581 return S_OK;
1584 /******************************************************************************
1585 * CoCreateGuid [OLE32.@]
1587 * Simply forwards to UuidCreate in RPCRT4.
1589 * PARAMS
1590 * pguid [O] Points to the GUID to initialize.
1592 * RETURNS
1593 * Success: S_OK.
1594 * Failure: HRESULT code.
1596 * SEE ALSO
1597 * UuidCreate
1599 HRESULT WINAPI CoCreateGuid(GUID *pguid)
1601 DWORD status = UuidCreate(pguid);
1602 if (status == RPC_S_OK || status == RPC_S_UUID_LOCAL_ONLY) return S_OK;
1603 return HRESULT_FROM_WIN32( status );
1606 static inline BOOL is_valid_hex(WCHAR c)
1608 if (!(((c >= '0') && (c <= '9')) ||
1609 ((c >= 'a') && (c <= 'f')) ||
1610 ((c >= 'A') && (c <= 'F'))))
1611 return FALSE;
1612 return TRUE;
1615 /******************************************************************************
1616 * CLSIDFromString [OLE32.@]
1617 * IIDFromString [OLE32.@]
1619 * Converts a unique identifier from its string representation into
1620 * the GUID struct.
1622 * PARAMS
1623 * idstr [I] The string representation of the GUID.
1624 * id [O] GUID converted from the string.
1626 * RETURNS
1627 * S_OK on success
1628 * CO_E_CLASSSTRING if idstr is not a valid CLSID
1630 * SEE ALSO
1631 * StringFromCLSID
1633 static HRESULT __CLSIDFromString(LPCWSTR s, LPCLSID id)
1635 int i;
1636 BYTE table[256];
1638 if (!s || s[0]!='{') {
1639 memset( id, 0, sizeof (CLSID) );
1640 if(!s) return S_OK;
1641 return CO_E_CLASSSTRING;
1644 TRACE("%s -> %p\n", debugstr_w(s), id);
1646 /* quick lookup table */
1647 memset(table, 0, 256);
1649 for (i = 0; i < 10; i++) {
1650 table['0' + i] = i;
1652 for (i = 0; i < 6; i++) {
1653 table['A' + i] = i+10;
1654 table['a' + i] = i+10;
1657 /* in form {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX} */
1659 id->Data1 = 0;
1660 for (i = 1; i < 9; i++) {
1661 if (!is_valid_hex(s[i])) return CO_E_CLASSSTRING;
1662 id->Data1 = (id->Data1 << 4) | table[s[i]];
1664 if (s[9]!='-') return CO_E_CLASSSTRING;
1666 id->Data2 = 0;
1667 for (i = 10; i < 14; i++) {
1668 if (!is_valid_hex(s[i])) return CO_E_CLASSSTRING;
1669 id->Data2 = (id->Data2 << 4) | table[s[i]];
1671 if (s[14]!='-') return CO_E_CLASSSTRING;
1673 id->Data3 = 0;
1674 for (i = 15; i < 19; i++) {
1675 if (!is_valid_hex(s[i])) return CO_E_CLASSSTRING;
1676 id->Data3 = (id->Data3 << 4) | table[s[i]];
1678 if (s[19]!='-') return CO_E_CLASSSTRING;
1680 for (i = 20; i < 37; i+=2) {
1681 if (i == 24) {
1682 if (s[i]!='-') return CO_E_CLASSSTRING;
1683 i++;
1685 if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return CO_E_CLASSSTRING;
1686 id->Data4[(i-20)/2] = table[s[i]] << 4 | table[s[i+1]];
1689 if (s[37] == '}' && s[38] == '\0')
1690 return S_OK;
1692 return CO_E_CLASSSTRING;
1695 /*****************************************************************************/
1697 HRESULT WINAPI CLSIDFromString(LPCOLESTR idstr, LPCLSID id )
1699 HRESULT ret;
1701 if (!id)
1702 return E_INVALIDARG;
1704 ret = __CLSIDFromString(idstr, id);
1705 if(ret != S_OK) { /* It appears a ProgID is also valid */
1706 CLSID tmp_id;
1707 ret = CLSIDFromProgID(idstr, &tmp_id);
1708 if(SUCCEEDED(ret))
1709 *id = tmp_id;
1711 return ret;
1715 /******************************************************************************
1716 * StringFromCLSID [OLE32.@]
1717 * StringFromIID [OLE32.@]
1719 * Converts a GUID into the respective string representation.
1720 * The target string is allocated using the OLE IMalloc.
1722 * PARAMS
1723 * id [I] the GUID to be converted.
1724 * idstr [O] A pointer to a to-be-allocated pointer pointing to the resulting string.
1726 * RETURNS
1727 * S_OK
1728 * E_FAIL
1730 * SEE ALSO
1731 * StringFromGUID2, CLSIDFromString
1733 HRESULT WINAPI StringFromCLSID(REFCLSID id, LPOLESTR *idstr)
1735 HRESULT ret;
1736 LPMALLOC mllc;
1738 if ((ret = CoGetMalloc(0,&mllc))) return ret;
1739 if (!(*idstr = IMalloc_Alloc( mllc, CHARS_IN_GUID * sizeof(WCHAR) ))) return E_OUTOFMEMORY;
1740 StringFromGUID2( id, *idstr, CHARS_IN_GUID );
1741 return S_OK;
1744 /******************************************************************************
1745 * StringFromGUID2 [OLE32.@]
1747 * Modified version of StringFromCLSID that allows you to specify max
1748 * buffer size.
1750 * PARAMS
1751 * id [I] GUID to convert to string.
1752 * str [O] Buffer where the result will be stored.
1753 * cmax [I] Size of the buffer in characters.
1755 * RETURNS
1756 * Success: The length of the resulting string in characters.
1757 * Failure: 0.
1759 INT WINAPI StringFromGUID2(REFGUID id, LPOLESTR str, INT cmax)
1761 static const WCHAR formatW[] = { '{','%','0','8','X','-','%','0','4','X','-',
1762 '%','0','4','X','-','%','0','2','X','%','0','2','X','-',
1763 '%','0','2','X','%','0','2','X','%','0','2','X','%','0','2','X',
1764 '%','0','2','X','%','0','2','X','}',0 };
1765 if (!id || cmax < CHARS_IN_GUID) return 0;
1766 sprintfW( str, formatW, id->Data1, id->Data2, id->Data3,
1767 id->Data4[0], id->Data4[1], id->Data4[2], id->Data4[3],
1768 id->Data4[4], id->Data4[5], id->Data4[6], id->Data4[7] );
1769 return CHARS_IN_GUID;
1772 /* open HKCR\\CLSID\\{string form of clsid}\\{keyname} key */
1773 HRESULT COM_OpenKeyForCLSID(REFCLSID clsid, LPCWSTR keyname, REGSAM access, HKEY *subkey)
1775 static const WCHAR wszCLSIDSlash[] = {'C','L','S','I','D','\\',0};
1776 WCHAR path[CHARS_IN_GUID + ARRAYSIZE(wszCLSIDSlash) - 1];
1777 LONG res;
1778 HKEY key;
1780 strcpyW(path, wszCLSIDSlash);
1781 StringFromGUID2(clsid, path + strlenW(wszCLSIDSlash), CHARS_IN_GUID);
1782 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, keyname ? KEY_READ : access, &key);
1783 if (res == ERROR_FILE_NOT_FOUND)
1784 return REGDB_E_CLASSNOTREG;
1785 else if (res != ERROR_SUCCESS)
1786 return REGDB_E_READREGDB;
1788 if (!keyname)
1790 *subkey = key;
1791 return S_OK;
1794 res = RegOpenKeyExW(key, keyname, 0, access, subkey);
1795 RegCloseKey(key);
1796 if (res == ERROR_FILE_NOT_FOUND)
1797 return REGDB_E_KEYMISSING;
1798 else if (res != ERROR_SUCCESS)
1799 return REGDB_E_READREGDB;
1801 return S_OK;
1804 /* open HKCR\\AppId\\{string form of appid clsid} key */
1805 HRESULT COM_OpenKeyForAppIdFromCLSID(REFCLSID clsid, REGSAM access, HKEY *subkey)
1807 static const WCHAR szAppId[] = { 'A','p','p','I','d',0 };
1808 static const WCHAR szAppIdKey[] = { 'A','p','p','I','d','\\',0 };
1809 DWORD res;
1810 WCHAR buf[CHARS_IN_GUID];
1811 WCHAR keyname[ARRAYSIZE(szAppIdKey) + CHARS_IN_GUID];
1812 DWORD size;
1813 HKEY hkey;
1814 DWORD type;
1815 HRESULT hr;
1817 /* read the AppID value under the class's key */
1818 hr = COM_OpenKeyForCLSID(clsid, NULL, KEY_READ, &hkey);
1819 if (FAILED(hr))
1820 return hr;
1822 size = sizeof(buf);
1823 res = RegQueryValueExW(hkey, szAppId, NULL, &type, (LPBYTE)buf, &size);
1824 RegCloseKey(hkey);
1825 if (res == ERROR_FILE_NOT_FOUND)
1826 return REGDB_E_KEYMISSING;
1827 else if (res != ERROR_SUCCESS || type!=REG_SZ)
1828 return REGDB_E_READREGDB;
1830 strcpyW(keyname, szAppIdKey);
1831 strcatW(keyname, buf);
1832 res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, access, subkey);
1833 if (res == ERROR_FILE_NOT_FOUND)
1834 return REGDB_E_KEYMISSING;
1835 else if (res != ERROR_SUCCESS)
1836 return REGDB_E_READREGDB;
1838 return S_OK;
1841 /******************************************************************************
1842 * ProgIDFromCLSID [OLE32.@]
1844 * Converts a class id into the respective program ID.
1846 * PARAMS
1847 * clsid [I] Class ID, as found in registry.
1848 * ppszProgID [O] Associated ProgID.
1850 * RETURNS
1851 * S_OK
1852 * E_OUTOFMEMORY
1853 * REGDB_E_CLASSNOTREG if the given clsid has no associated ProgID
1855 HRESULT WINAPI ProgIDFromCLSID(REFCLSID clsid, LPOLESTR *ppszProgID)
1857 static const WCHAR wszProgID[] = {'P','r','o','g','I','D',0};
1858 HKEY hkey;
1859 HRESULT ret;
1860 LONG progidlen = 0;
1862 if (!ppszProgID)
1864 ERR("ppszProgId isn't optional\n");
1865 return E_INVALIDARG;
1868 *ppszProgID = NULL;
1869 ret = COM_OpenKeyForCLSID(clsid, wszProgID, KEY_READ, &hkey);
1870 if (FAILED(ret))
1871 return ret;
1873 if (RegQueryValueW(hkey, NULL, NULL, &progidlen))
1874 ret = REGDB_E_CLASSNOTREG;
1876 if (ret == S_OK)
1878 *ppszProgID = CoTaskMemAlloc(progidlen * sizeof(WCHAR));
1879 if (*ppszProgID)
1881 if (RegQueryValueW(hkey, NULL, *ppszProgID, &progidlen))
1882 ret = REGDB_E_CLASSNOTREG;
1884 else
1885 ret = E_OUTOFMEMORY;
1888 RegCloseKey(hkey);
1889 return ret;
1892 /******************************************************************************
1893 * CLSIDFromProgID [OLE32.@]
1895 * Converts a program id into the respective GUID.
1897 * PARAMS
1898 * progid [I] Unicode program ID, as found in registry.
1899 * clsid [O] Associated CLSID.
1901 * RETURNS
1902 * Success: S_OK
1903 * Failure: CO_E_CLASSSTRING - the given ProgID cannot be found.
1905 HRESULT WINAPI CLSIDFromProgID(LPCOLESTR progid, LPCLSID clsid)
1907 static const WCHAR clsidW[] = { '\\','C','L','S','I','D',0 };
1908 WCHAR buf2[CHARS_IN_GUID];
1909 LONG buf2len = sizeof(buf2);
1910 HKEY xhkey;
1911 WCHAR *buf;
1913 if (!progid || !clsid)
1915 ERR("neither progid (%p) nor clsid (%p) are optional\n", progid, clsid);
1916 return E_INVALIDARG;
1919 /* initialise clsid in case of failure */
1920 memset(clsid, 0, sizeof(*clsid));
1922 buf = HeapAlloc( GetProcessHeap(),0,(strlenW(progid)+8) * sizeof(WCHAR) );
1923 strcpyW( buf, progid );
1924 strcatW( buf, clsidW );
1925 if (RegOpenKeyW(HKEY_CLASSES_ROOT,buf,&xhkey))
1927 HeapFree(GetProcessHeap(),0,buf);
1928 WARN("couldn't open key for ProgID %s\n", debugstr_w(progid));
1929 return CO_E_CLASSSTRING;
1931 HeapFree(GetProcessHeap(),0,buf);
1933 if (RegQueryValueW(xhkey,NULL,buf2,&buf2len))
1935 RegCloseKey(xhkey);
1936 WARN("couldn't query clsid value for ProgID %s\n", debugstr_w(progid));
1937 return CO_E_CLASSSTRING;
1939 RegCloseKey(xhkey);
1940 return __CLSIDFromString(buf2,clsid);
1944 /*****************************************************************************
1945 * CoGetPSClsid [OLE32.@]
1947 * Retrieves the CLSID of the proxy/stub factory that implements
1948 * IPSFactoryBuffer for the specified interface.
1950 * PARAMS
1951 * riid [I] Interface whose proxy/stub CLSID is to be returned.
1952 * pclsid [O] Where to store returned proxy/stub CLSID.
1954 * RETURNS
1955 * S_OK
1956 * E_OUTOFMEMORY
1957 * REGDB_E_IIDNOTREG if no PSFactoryBuffer is associated with the IID, or it could not be parsed
1959 * NOTES
1961 * The standard marshaller activates the object with the CLSID
1962 * returned and uses the CreateProxy and CreateStub methods on its
1963 * IPSFactoryBuffer interface to construct the proxies and stubs for a
1964 * given object.
1966 * CoGetPSClsid determines this CLSID by searching the
1967 * HKEY_CLASSES_ROOT\Interface\{string form of riid}\ProxyStubClsid32
1968 * in the registry and any interface id registered by
1969 * CoRegisterPSClsid within the current process.
1971 * BUGS
1973 * Native returns S_OK for interfaces with a key in HKCR\Interface, but
1974 * without a ProxyStubClsid32 key and leaves garbage in pclsid. This should be
1975 * considered a bug in native unless an application depends on this (unlikely).
1977 * SEE ALSO
1978 * CoRegisterPSClsid.
1980 HRESULT WINAPI CoGetPSClsid(REFIID riid, CLSID *pclsid)
1982 static const WCHAR wszInterface[] = {'I','n','t','e','r','f','a','c','e','\\',0};
1983 static const WCHAR wszPSC[] = {'\\','P','r','o','x','y','S','t','u','b','C','l','s','i','d','3','2',0};
1984 WCHAR path[ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1 + ARRAYSIZE(wszPSC)];
1985 WCHAR value[CHARS_IN_GUID];
1986 LONG len;
1987 HKEY hkey;
1988 APARTMENT *apt = COM_CurrentApt();
1989 struct registered_psclsid *registered_psclsid;
1991 TRACE("() riid=%s, pclsid=%p\n", debugstr_guid(riid), pclsid);
1993 if (!apt)
1995 ERR("apartment not initialised\n");
1996 return CO_E_NOTINITIALIZED;
1999 if (!pclsid)
2001 ERR("pclsid isn't optional\n");
2002 return E_INVALIDARG;
2005 EnterCriticalSection(&apt->cs);
2007 LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
2008 if (IsEqualIID(&registered_psclsid->iid, riid))
2010 *pclsid = registered_psclsid->clsid;
2011 LeaveCriticalSection(&apt->cs);
2012 return S_OK;
2015 LeaveCriticalSection(&apt->cs);
2017 /* Interface\\{string form of riid}\\ProxyStubClsid32 */
2018 strcpyW(path, wszInterface);
2019 StringFromGUID2(riid, path + ARRAYSIZE(wszInterface) - 1, CHARS_IN_GUID);
2020 strcpyW(path + ARRAYSIZE(wszInterface) - 1 + CHARS_IN_GUID - 1, wszPSC);
2022 /* Open the key.. */
2023 if (RegOpenKeyExW(HKEY_CLASSES_ROOT, path, 0, KEY_READ, &hkey))
2025 WARN("No PSFactoryBuffer object is registered for IID %s\n", debugstr_guid(riid));
2026 return REGDB_E_IIDNOTREG;
2029 /* ... Once we have the key, query the registry to get the
2030 value of CLSID as a string, and convert it into a
2031 proper CLSID structure to be passed back to the app */
2032 len = sizeof(value);
2033 if (ERROR_SUCCESS != RegQueryValueW(hkey, NULL, value, &len))
2035 RegCloseKey(hkey);
2036 return REGDB_E_IIDNOTREG;
2038 RegCloseKey(hkey);
2040 /* We have the CLSID we want back from the registry as a string, so
2041 let's convert it into a CLSID structure */
2042 if (CLSIDFromString(value, pclsid) != NOERROR)
2043 return REGDB_E_IIDNOTREG;
2045 TRACE ("() Returning CLSID=%s\n", debugstr_guid(pclsid));
2046 return S_OK;
2049 /*****************************************************************************
2050 * CoRegisterPSClsid [OLE32.@]
2052 * Register a proxy/stub CLSID for the given interface in the current process
2053 * only.
2055 * PARAMS
2056 * riid [I] Interface whose proxy/stub CLSID is to be registered.
2057 * rclsid [I] CLSID of the proxy/stub.
2059 * RETURNS
2060 * Success: S_OK
2061 * Failure: E_OUTOFMEMORY
2063 * NOTES
2065 * This function does not add anything to the registry and the effects are
2066 * limited to the lifetime of the current process.
2068 * SEE ALSO
2069 * CoGetPSClsid.
2071 HRESULT WINAPI CoRegisterPSClsid(REFIID riid, REFCLSID rclsid)
2073 APARTMENT *apt = COM_CurrentApt();
2074 struct registered_psclsid *registered_psclsid;
2076 TRACE("(%s, %s)\n", debugstr_guid(riid), debugstr_guid(rclsid));
2078 if (!apt)
2080 ERR("apartment not initialised\n");
2081 return CO_E_NOTINITIALIZED;
2084 EnterCriticalSection(&apt->cs);
2086 LIST_FOR_EACH_ENTRY(registered_psclsid, &apt->psclsids, struct registered_psclsid, entry)
2087 if (IsEqualIID(&registered_psclsid->iid, riid))
2089 registered_psclsid->clsid = *rclsid;
2090 LeaveCriticalSection(&apt->cs);
2091 return S_OK;
2094 registered_psclsid = HeapAlloc(GetProcessHeap(), 0, sizeof(struct registered_psclsid));
2095 if (!registered_psclsid)
2097 LeaveCriticalSection(&apt->cs);
2098 return E_OUTOFMEMORY;
2101 registered_psclsid->iid = *riid;
2102 registered_psclsid->clsid = *rclsid;
2103 list_add_head(&apt->psclsids, &registered_psclsid->entry);
2105 LeaveCriticalSection(&apt->cs);
2107 return S_OK;
2111 /***
2112 * COM_GetRegisteredClassObject
2114 * This internal method is used to scan the registered class list to
2115 * find a class object.
2117 * Params:
2118 * rclsid Class ID of the class to find.
2119 * dwClsContext Class context to match.
2120 * ppv [out] returns a pointer to the class object. Complying
2121 * to normal COM usage, this method will increase the
2122 * reference count on this object.
2124 static HRESULT COM_GetRegisteredClassObject(const struct apartment *apt, REFCLSID rclsid,
2125 DWORD dwClsContext, LPUNKNOWN* ppUnk)
2127 HRESULT hr = S_FALSE;
2128 RegisteredClass *curClass;
2130 EnterCriticalSection( &csRegisteredClassList );
2132 LIST_FOR_EACH_ENTRY(curClass, &RegisteredClassList, RegisteredClass, entry)
2135 * Check if we have a match on the class ID and context.
2137 if ((apt->oxid == curClass->apartment_id) &&
2138 (dwClsContext & curClass->runContext) &&
2139 IsEqualGUID(&(curClass->classIdentifier), rclsid))
2142 * We have a match, return the pointer to the class object.
2144 *ppUnk = curClass->classObject;
2146 IUnknown_AddRef(curClass->classObject);
2148 hr = S_OK;
2149 break;
2153 LeaveCriticalSection( &csRegisteredClassList );
2155 return hr;
2158 /******************************************************************************
2159 * CoRegisterClassObject [OLE32.@]
2161 * Registers the class object for a given class ID. Servers housed in EXE
2162 * files use this method instead of exporting DllGetClassObject to allow
2163 * other code to connect to their objects.
2165 * PARAMS
2166 * rclsid [I] CLSID of the object to register.
2167 * pUnk [I] IUnknown of the object.
2168 * dwClsContext [I] CLSCTX flags indicating the context in which to run the executable.
2169 * flags [I] REGCLS flags indicating how connections are made.
2170 * lpdwRegister [I] A unique cookie that can be passed to CoRevokeClassObject.
2172 * RETURNS
2173 * S_OK on success,
2174 * E_INVALIDARG if lpdwRegister or pUnk are NULL,
2175 * CO_E_OBJISREG if the object is already registered. We should not return this.
2177 * SEE ALSO
2178 * CoRevokeClassObject, CoGetClassObject
2180 * NOTES
2181 * In-process objects are only registered for the current apartment.
2182 * CoGetClassObject() and CoCreateInstance() will not return objects registered
2183 * in other apartments.
2185 * BUGS
2186 * MSDN claims that multiple interface registrations are legal, but we
2187 * can't do that with our current implementation.
2189 HRESULT WINAPI CoRegisterClassObject(
2190 REFCLSID rclsid,
2191 LPUNKNOWN pUnk,
2192 DWORD dwClsContext,
2193 DWORD flags,
2194 LPDWORD lpdwRegister)
2196 static LONG next_cookie;
2197 RegisteredClass* newClass;
2198 LPUNKNOWN foundObject;
2199 HRESULT hr;
2200 APARTMENT *apt;
2202 TRACE("(%s,%p,0x%08x,0x%08x,%p)\n",
2203 debugstr_guid(rclsid),pUnk,dwClsContext,flags,lpdwRegister);
2205 if ( (lpdwRegister==0) || (pUnk==0) )
2206 return E_INVALIDARG;
2208 apt = COM_CurrentApt();
2209 if (!apt)
2211 ERR("COM was not initialized\n");
2212 return CO_E_NOTINITIALIZED;
2215 *lpdwRegister = 0;
2217 /* REGCLS_MULTIPLEUSE implies registering as inproc server. This is what
2218 * differentiates the flag from REGCLS_MULTI_SEPARATE. */
2219 if (flags & REGCLS_MULTIPLEUSE)
2220 dwClsContext |= CLSCTX_INPROC_SERVER;
2223 * First, check if the class is already registered.
2224 * If it is, this should cause an error.
2226 hr = COM_GetRegisteredClassObject(apt, rclsid, dwClsContext, &foundObject);
2227 if (hr == S_OK) {
2228 if (flags & REGCLS_MULTIPLEUSE) {
2229 if (dwClsContext & CLSCTX_LOCAL_SERVER)
2230 hr = CoLockObjectExternal(foundObject, TRUE, FALSE);
2231 IUnknown_Release(foundObject);
2232 return hr;
2234 IUnknown_Release(foundObject);
2235 ERR("object already registered for class %s\n", debugstr_guid(rclsid));
2236 return CO_E_OBJISREG;
2239 newClass = HeapAlloc(GetProcessHeap(), 0, sizeof(RegisteredClass));
2240 if ( newClass == NULL )
2241 return E_OUTOFMEMORY;
2243 newClass->classIdentifier = *rclsid;
2244 newClass->apartment_id = apt->oxid;
2245 newClass->runContext = dwClsContext;
2246 newClass->connectFlags = flags;
2247 newClass->pMarshaledData = NULL;
2248 newClass->RpcRegistration = NULL;
2250 if (!(newClass->dwCookie = InterlockedIncrement( &next_cookie )))
2251 newClass->dwCookie = InterlockedIncrement( &next_cookie );
2254 * Since we're making a copy of the object pointer, we have to increase its
2255 * reference count.
2257 newClass->classObject = pUnk;
2258 IUnknown_AddRef(newClass->classObject);
2260 EnterCriticalSection( &csRegisteredClassList );
2261 list_add_tail(&RegisteredClassList, &newClass->entry);
2262 LeaveCriticalSection( &csRegisteredClassList );
2264 *lpdwRegister = newClass->dwCookie;
2266 if (dwClsContext & CLSCTX_LOCAL_SERVER) {
2267 hr = CreateStreamOnHGlobal(0, TRUE, &newClass->pMarshaledData);
2268 if (hr) {
2269 FIXME("Failed to create stream on hglobal, %x\n", hr);
2270 return hr;
2272 hr = CoMarshalInterface(newClass->pMarshaledData, &IID_IUnknown,
2273 newClass->classObject, MSHCTX_LOCAL, NULL,
2274 MSHLFLAGS_TABLESTRONG);
2275 if (hr) {
2276 FIXME("CoMarshalInterface failed, %x!\n",hr);
2277 return hr;
2280 hr = RPC_StartLocalServer(&newClass->classIdentifier,
2281 newClass->pMarshaledData,
2282 flags & (REGCLS_MULTIPLEUSE|REGCLS_MULTI_SEPARATE),
2283 &newClass->RpcRegistration);
2285 return S_OK;
2288 static void get_threading_model(HKEY key, LPWSTR value, DWORD len)
2290 static const WCHAR wszThreadingModel[] = {'T','h','r','e','a','d','i','n','g','M','o','d','e','l',0};
2291 DWORD keytype;
2292 DWORD ret;
2293 DWORD dwLength = len * sizeof(WCHAR);
2295 ret = RegQueryValueExW(key, wszThreadingModel, NULL, &keytype, (LPBYTE)value, &dwLength);
2296 if ((ret != ERROR_SUCCESS) || (keytype != REG_SZ))
2297 value[0] = '\0';
2300 static HRESULT get_inproc_class_object(APARTMENT *apt, HKEY hkeydll,
2301 REFCLSID rclsid, REFIID riid,
2302 BOOL hostifnecessary, void **ppv)
2304 WCHAR dllpath[MAX_PATH+1];
2305 BOOL apartment_threaded;
2307 if (hostifnecessary)
2309 static const WCHAR wszApartment[] = {'A','p','a','r','t','m','e','n','t',0};
2310 static const WCHAR wszFree[] = {'F','r','e','e',0};
2311 static const WCHAR wszBoth[] = {'B','o','t','h',0};
2312 WCHAR threading_model[10 /* strlenW(L"apartment")+1 */];
2314 get_threading_model(hkeydll, threading_model, ARRAYSIZE(threading_model));
2315 /* "Apartment" */
2316 if (!strcmpiW(threading_model, wszApartment))
2318 apartment_threaded = TRUE;
2319 if (apt->multi_threaded)
2320 return apartment_hostobject_in_hostapt(apt, FALSE, FALSE, hkeydll, rclsid, riid, ppv);
2322 /* "Free" */
2323 else if (!strcmpiW(threading_model, wszFree))
2325 apartment_threaded = FALSE;
2326 if (!apt->multi_threaded)
2327 return apartment_hostobject_in_hostapt(apt, TRUE, FALSE, hkeydll, rclsid, riid, ppv);
2329 /* everything except "Apartment", "Free" and "Both" */
2330 else if (strcmpiW(threading_model, wszBoth))
2332 apartment_threaded = TRUE;
2333 /* everything else is main-threaded */
2334 if (threading_model[0])
2335 FIXME("unrecognised threading model %s for object %s, should be main-threaded?\n",
2336 debugstr_w(threading_model), debugstr_guid(rclsid));
2338 if (apt->multi_threaded || !apt->main)
2339 return apartment_hostobject_in_hostapt(apt, FALSE, TRUE, hkeydll, rclsid, riid, ppv);
2341 else
2342 apartment_threaded = FALSE;
2344 else
2345 apartment_threaded = !apt->multi_threaded;
2347 if (COM_RegReadPath(hkeydll, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) != ERROR_SUCCESS)
2349 /* failure: CLSID is not found in registry */
2350 WARN("class %s not registered inproc\n", debugstr_guid(rclsid));
2351 return REGDB_E_CLASSNOTREG;
2354 return apartment_getclassobject(apt, dllpath, apartment_threaded,
2355 rclsid, riid, ppv);
2358 /***********************************************************************
2359 * CoGetClassObject [OLE32.@]
2361 * Creates an object of the specified class.
2363 * PARAMS
2364 * rclsid [I] Class ID to create an instance of.
2365 * dwClsContext [I] Flags to restrict the location of the created instance.
2366 * pServerInfo [I] Optional. Details for connecting to a remote server.
2367 * iid [I] The ID of the interface of the instance to return.
2368 * ppv [O] On returns, contains a pointer to the specified interface of the object.
2370 * RETURNS
2371 * Success: S_OK
2372 * Failure: HRESULT code.
2374 * NOTES
2375 * The dwClsContext parameter can be one or more of the following:
2376 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2377 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2378 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2379 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2381 * SEE ALSO
2382 * CoCreateInstance()
2384 HRESULT WINAPI CoGetClassObject(
2385 REFCLSID rclsid, DWORD dwClsContext, COSERVERINFO *pServerInfo,
2386 REFIID iid, LPVOID *ppv)
2388 LPUNKNOWN regClassObject;
2389 HRESULT hres = E_UNEXPECTED;
2390 APARTMENT *apt;
2391 BOOL release_apt = FALSE;
2393 TRACE("CLSID: %s,IID: %s\n", debugstr_guid(rclsid), debugstr_guid(iid));
2395 if (!ppv)
2396 return E_INVALIDARG;
2398 *ppv = NULL;
2400 if (!(apt = COM_CurrentApt()))
2402 if (!(apt = apartment_find_multi_threaded()))
2404 ERR("apartment not initialised\n");
2405 return CO_E_NOTINITIALIZED;
2407 release_apt = TRUE;
2410 if (pServerInfo) {
2411 FIXME("pServerInfo->name=%s pAuthInfo=%p\n",
2412 debugstr_w(pServerInfo->pwszName), pServerInfo->pAuthInfo);
2416 * First, try and see if we can't match the class ID with one of the
2417 * registered classes.
2419 if (S_OK == COM_GetRegisteredClassObject(apt, rclsid, dwClsContext,
2420 &regClassObject))
2422 /* Get the required interface from the retrieved pointer. */
2423 hres = IUnknown_QueryInterface(regClassObject, iid, ppv);
2426 * Since QI got another reference on the pointer, we want to release the
2427 * one we already have. If QI was unsuccessful, this will release the object. This
2428 * is good since we are not returning it in the "out" parameter.
2430 IUnknown_Release(regClassObject);
2431 if (release_apt) apartment_release(apt);
2432 return hres;
2435 /* First try in-process server */
2436 if (CLSCTX_INPROC_SERVER & dwClsContext)
2438 static const WCHAR wszInprocServer32[] = {'I','n','p','r','o','c','S','e','r','v','e','r','3','2',0};
2439 HKEY hkey;
2441 if (IsEqualCLSID(rclsid, &CLSID_InProcFreeMarshaler))
2443 if (release_apt) apartment_release(apt);
2444 return FTMarshalCF_Create(iid, ppv);
2447 hres = COM_OpenKeyForCLSID(rclsid, wszInprocServer32, KEY_READ, &hkey);
2448 if (FAILED(hres))
2450 if (hres == REGDB_E_CLASSNOTREG)
2451 ERR("class %s not registered\n", debugstr_guid(rclsid));
2452 else if (hres == REGDB_E_KEYMISSING)
2454 WARN("class %s not registered as in-proc server\n", debugstr_guid(rclsid));
2455 hres = REGDB_E_CLASSNOTREG;
2459 if (SUCCEEDED(hres))
2461 hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2462 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2463 RegCloseKey(hkey);
2466 /* return if we got a class, otherwise fall through to one of the
2467 * other types */
2468 if (SUCCEEDED(hres))
2470 if (release_apt) apartment_release(apt);
2471 return hres;
2475 /* Next try in-process handler */
2476 if (CLSCTX_INPROC_HANDLER & dwClsContext)
2478 static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
2479 HKEY hkey;
2481 hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
2482 if (FAILED(hres))
2484 if (hres == REGDB_E_CLASSNOTREG)
2485 ERR("class %s not registered\n", debugstr_guid(rclsid));
2486 else if (hres == REGDB_E_KEYMISSING)
2488 WARN("class %s not registered in-proc handler\n", debugstr_guid(rclsid));
2489 hres = REGDB_E_CLASSNOTREG;
2493 if (SUCCEEDED(hres))
2495 hres = get_inproc_class_object(apt, hkey, rclsid, iid,
2496 !(dwClsContext & WINE_CLSCTX_DONT_HOST), ppv);
2497 RegCloseKey(hkey);
2500 /* return if we got a class, otherwise fall through to one of the
2501 * other types */
2502 if (SUCCEEDED(hres))
2504 if (release_apt) apartment_release(apt);
2505 return hres;
2508 if (release_apt) apartment_release(apt);
2510 /* Next try out of process */
2511 if (CLSCTX_LOCAL_SERVER & dwClsContext)
2513 hres = RPC_GetLocalClassObject(rclsid,iid,ppv);
2514 if (SUCCEEDED(hres))
2515 return hres;
2518 /* Finally try remote: this requires networked DCOM (a lot of work) */
2519 if (CLSCTX_REMOTE_SERVER & dwClsContext)
2521 FIXME ("CLSCTX_REMOTE_SERVER not supported\n");
2522 hres = REGDB_E_CLASSNOTREG;
2525 if (FAILED(hres))
2526 ERR("no class object %s could be created for context 0x%x\n",
2527 debugstr_guid(rclsid), dwClsContext);
2528 return hres;
2531 /***********************************************************************
2532 * CoResumeClassObjects (OLE32.@)
2534 * Resumes all class objects registered with REGCLS_SUSPENDED.
2536 * RETURNS
2537 * Success: S_OK.
2538 * Failure: HRESULT code.
2540 HRESULT WINAPI CoResumeClassObjects(void)
2542 FIXME("stub\n");
2543 return S_OK;
2546 /***********************************************************************
2547 * CoCreateInstance [OLE32.@]
2549 * Creates an instance of the specified class.
2551 * PARAMS
2552 * rclsid [I] Class ID to create an instance of.
2553 * pUnkOuter [I] Optional outer unknown to allow aggregation with another object.
2554 * dwClsContext [I] Flags to restrict the location of the created instance.
2555 * iid [I] The ID of the interface of the instance to return.
2556 * ppv [O] On returns, contains a pointer to the specified interface of the instance.
2558 * RETURNS
2559 * Success: S_OK
2560 * Failure: HRESULT code.
2562 * NOTES
2563 * The dwClsContext parameter can be one or more of the following:
2564 *| CLSCTX_INPROC_SERVER - Use an in-process server, such as from a DLL.
2565 *| CLSCTX_INPROC_HANDLER - Use an in-process object which handles certain functions for an object running in another process.
2566 *| CLSCTX_LOCAL_SERVER - Connect to an object running in another process.
2567 *| CLSCTX_REMOTE_SERVER - Connect to an object running on another machine.
2569 * Aggregation is the concept of deferring the IUnknown of an object to another
2570 * object. This allows a separate object to behave as though it was part of
2571 * the object and to allow this the pUnkOuter parameter can be set. Note that
2572 * not all objects support having an outer of unknown.
2574 * SEE ALSO
2575 * CoGetClassObject()
2577 HRESULT WINAPI CoCreateInstance(
2578 REFCLSID rclsid,
2579 LPUNKNOWN pUnkOuter,
2580 DWORD dwClsContext,
2581 REFIID iid,
2582 LPVOID *ppv)
2584 HRESULT hres;
2585 LPCLASSFACTORY lpclf = 0;
2586 APARTMENT *apt;
2588 TRACE("(rclsid=%s, pUnkOuter=%p, dwClsContext=%08x, riid=%s, ppv=%p)\n", debugstr_guid(rclsid),
2589 pUnkOuter, dwClsContext, debugstr_guid(iid), ppv);
2592 * Sanity check
2594 if (ppv==0)
2595 return E_POINTER;
2598 * Initialize the "out" parameter
2600 *ppv = 0;
2602 if (!(apt = COM_CurrentApt()))
2604 if (!(apt = apartment_find_multi_threaded()))
2606 ERR("apartment not initialised\n");
2607 return CO_E_NOTINITIALIZED;
2609 apartment_release(apt);
2613 * The Standard Global Interface Table (GIT) object is a process-wide singleton.
2614 * Rather than create a class factory, we can just check for it here
2616 if (IsEqualIID(rclsid, &CLSID_StdGlobalInterfaceTable)) {
2617 if (StdGlobalInterfaceTableInstance == NULL)
2618 StdGlobalInterfaceTableInstance = StdGlobalInterfaceTable_Construct();
2619 hres = IGlobalInterfaceTable_QueryInterface( (IGlobalInterfaceTable*) StdGlobalInterfaceTableInstance, iid, ppv);
2620 if (hres) return hres;
2622 TRACE("Retrieved GIT (%p)\n", *ppv);
2623 return S_OK;
2626 if (IsEqualCLSID(rclsid, &CLSID_ManualResetEvent))
2627 return ManualResetEvent_Construct(pUnkOuter, iid, ppv);
2630 * Get a class factory to construct the object we want.
2632 hres = CoGetClassObject(rclsid,
2633 dwClsContext,
2634 NULL,
2635 &IID_IClassFactory,
2636 (LPVOID)&lpclf);
2638 if (FAILED(hres))
2639 return hres;
2642 * Create the object and don't forget to release the factory
2644 hres = IClassFactory_CreateInstance(lpclf, pUnkOuter, iid, ppv);
2645 IClassFactory_Release(lpclf);
2646 if(FAILED(hres))
2648 if (hres == CLASS_E_NOAGGREGATION && pUnkOuter)
2649 FIXME("Class %s does not support aggregation\n", debugstr_guid(rclsid));
2650 else
2651 FIXME("no instance created for interface %s of class %s, hres is 0x%08x\n", debugstr_guid(iid), debugstr_guid(rclsid),hres);
2654 return hres;
2657 /***********************************************************************
2658 * CoCreateInstanceEx [OLE32.@]
2660 HRESULT WINAPI CoCreateInstanceEx(
2661 REFCLSID rclsid,
2662 LPUNKNOWN pUnkOuter,
2663 DWORD dwClsContext,
2664 COSERVERINFO* pServerInfo,
2665 ULONG cmq,
2666 MULTI_QI* pResults)
2668 IUnknown* pUnk = NULL;
2669 HRESULT hr;
2670 ULONG index;
2671 ULONG successCount = 0;
2674 * Sanity check
2676 if ( (cmq==0) || (pResults==NULL))
2677 return E_INVALIDARG;
2679 if (pServerInfo!=NULL)
2680 FIXME("() non-NULL pServerInfo not supported!\n");
2683 * Initialize all the "out" parameters.
2685 for (index = 0; index < cmq; index++)
2687 pResults[index].pItf = NULL;
2688 pResults[index].hr = E_NOINTERFACE;
2692 * Get the object and get its IUnknown pointer.
2694 hr = CoCreateInstance(rclsid,
2695 pUnkOuter,
2696 dwClsContext,
2697 &IID_IUnknown,
2698 (VOID**)&pUnk);
2700 if (hr)
2701 return hr;
2704 * Then, query for all the interfaces requested.
2706 for (index = 0; index < cmq; index++)
2708 pResults[index].hr = IUnknown_QueryInterface(pUnk,
2709 pResults[index].pIID,
2710 (VOID**)&(pResults[index].pItf));
2712 if (pResults[index].hr == S_OK)
2713 successCount++;
2717 * Release our temporary unknown pointer.
2719 IUnknown_Release(pUnk);
2721 if (successCount == 0)
2722 return E_NOINTERFACE;
2724 if (successCount!=cmq)
2725 return CO_S_NOTALLINTERFACES;
2727 return S_OK;
2730 /***********************************************************************
2731 * CoLoadLibrary (OLE32.@)
2733 * Loads a library.
2735 * PARAMS
2736 * lpszLibName [I] Path to library.
2737 * bAutoFree [I] Whether the library should automatically be freed.
2739 * RETURNS
2740 * Success: Handle to loaded library.
2741 * Failure: NULL.
2743 * SEE ALSO
2744 * CoFreeLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2746 HINSTANCE WINAPI CoLoadLibrary(LPOLESTR lpszLibName, BOOL bAutoFree)
2748 TRACE("(%s, %d)\n", debugstr_w(lpszLibName), bAutoFree);
2750 return LoadLibraryExW(lpszLibName, 0, LOAD_WITH_ALTERED_SEARCH_PATH);
2753 /***********************************************************************
2754 * CoFreeLibrary [OLE32.@]
2756 * Unloads a library from memory.
2758 * PARAMS
2759 * hLibrary [I] Handle to library to unload.
2761 * RETURNS
2762 * Nothing
2764 * SEE ALSO
2765 * CoLoadLibrary, CoFreeAllLibraries, CoFreeUnusedLibraries
2767 void WINAPI CoFreeLibrary(HINSTANCE hLibrary)
2769 FreeLibrary(hLibrary);
2773 /***********************************************************************
2774 * CoFreeAllLibraries [OLE32.@]
2776 * Function for backwards compatibility only. Does nothing.
2778 * RETURNS
2779 * Nothing.
2781 * SEE ALSO
2782 * CoLoadLibrary, CoFreeLibrary, CoFreeUnusedLibraries
2784 void WINAPI CoFreeAllLibraries(void)
2786 /* NOP */
2789 /***********************************************************************
2790 * CoFreeUnusedLibrariesEx [OLE32.@]
2792 * Frees any previously unused libraries whose delay has expired and marks
2793 * currently unused libraries for unloading. Unused are identified as those that
2794 * return S_OK from their DllCanUnloadNow function.
2796 * PARAMS
2797 * dwUnloadDelay [I] Unload delay in milliseconds.
2798 * dwReserved [I] Reserved. Set to 0.
2800 * RETURNS
2801 * Nothing.
2803 * SEE ALSO
2804 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2806 void WINAPI CoFreeUnusedLibrariesEx(DWORD dwUnloadDelay, DWORD dwReserved)
2808 struct apartment *apt = COM_CurrentApt();
2809 if (!apt)
2811 ERR("apartment not initialised\n");
2812 return;
2815 apartment_freeunusedlibraries(apt, dwUnloadDelay);
2818 /***********************************************************************
2819 * CoFreeUnusedLibraries [OLE32.@]
2821 * Frees any unused libraries. Unused are identified as those that return
2822 * S_OK from their DllCanUnloadNow function.
2824 * RETURNS
2825 * Nothing.
2827 * SEE ALSO
2828 * CoLoadLibrary, CoFreeAllLibraries, CoFreeLibrary
2830 void WINAPI CoFreeUnusedLibraries(void)
2832 CoFreeUnusedLibrariesEx(INFINITE, 0);
2835 /***********************************************************************
2836 * CoFileTimeNow [OLE32.@]
2838 * Retrieves the current time in FILETIME format.
2840 * PARAMS
2841 * lpFileTime [O] The current time.
2843 * RETURNS
2844 * S_OK.
2846 HRESULT WINAPI CoFileTimeNow( FILETIME *lpFileTime )
2848 GetSystemTimeAsFileTime( lpFileTime );
2849 return S_OK;
2852 /******************************************************************************
2853 * CoLockObjectExternal [OLE32.@]
2855 * Increments or decrements the external reference count of a stub object.
2857 * PARAMS
2858 * pUnk [I] Stub object.
2859 * fLock [I] If TRUE then increments the external ref-count,
2860 * otherwise decrements.
2861 * fLastUnlockReleases [I] If TRUE then the last unlock has the effect of
2862 * calling CoDisconnectObject.
2864 * RETURNS
2865 * Success: S_OK.
2866 * Failure: HRESULT code.
2868 * NOTES
2869 * If fLock is TRUE and an object is passed in that doesn't have a stub
2870 * manager then a new stub manager is created for the object.
2872 HRESULT WINAPI CoLockObjectExternal(
2873 LPUNKNOWN pUnk,
2874 BOOL fLock,
2875 BOOL fLastUnlockReleases)
2877 struct stub_manager *stubmgr;
2878 struct apartment *apt;
2880 TRACE("pUnk=%p, fLock=%s, fLastUnlockReleases=%s\n",
2881 pUnk, fLock ? "TRUE" : "FALSE", fLastUnlockReleases ? "TRUE" : "FALSE");
2883 apt = COM_CurrentApt();
2884 if (!apt) return CO_E_NOTINITIALIZED;
2886 stubmgr = get_stub_manager_from_object(apt, pUnk);
2888 if (stubmgr)
2890 if (fLock)
2891 stub_manager_ext_addref(stubmgr, 1, FALSE);
2892 else
2893 stub_manager_ext_release(stubmgr, 1, FALSE, fLastUnlockReleases);
2895 stub_manager_int_release(stubmgr);
2897 return S_OK;
2899 else if (fLock)
2901 stubmgr = new_stub_manager(apt, pUnk);
2903 if (stubmgr)
2905 stub_manager_ext_addref(stubmgr, 1, FALSE);
2906 stub_manager_int_release(stubmgr);
2909 return S_OK;
2911 else
2913 WARN("stub object not found %p\n", pUnk);
2914 /* Note: native is pretty broken here because it just silently
2915 * fails, without returning an appropriate error code, making apps
2916 * think that the object was disconnected, when it actually wasn't */
2917 return S_OK;
2921 /***********************************************************************
2922 * CoInitializeWOW (OLE32.@)
2924 * WOW equivalent of CoInitialize?
2926 * PARAMS
2927 * x [I] Unknown.
2928 * y [I] Unknown.
2930 * RETURNS
2931 * Unknown.
2933 HRESULT WINAPI CoInitializeWOW(DWORD x,DWORD y)
2935 FIXME("(0x%08x,0x%08x),stub!\n",x,y);
2936 return 0;
2939 /***********************************************************************
2940 * CoGetState [OLE32.@]
2942 * Retrieves the thread state object previously stored by CoSetState().
2944 * PARAMS
2945 * ppv [I] Address where pointer to object will be stored.
2947 * RETURNS
2948 * Success: S_OK.
2949 * Failure: E_OUTOFMEMORY.
2951 * NOTES
2952 * Crashes on all invalid ppv addresses, including NULL.
2953 * If the function returns a non-NULL object then the caller must release its
2954 * reference on the object when the object is no longer required.
2956 * SEE ALSO
2957 * CoSetState().
2959 HRESULT WINAPI CoGetState(IUnknown ** ppv)
2961 struct oletls *info = COM_CurrentInfo();
2962 if (!info) return E_OUTOFMEMORY;
2964 *ppv = NULL;
2966 if (info->state)
2968 IUnknown_AddRef(info->state);
2969 *ppv = info->state;
2970 TRACE("apt->state=%p\n", info->state);
2973 return S_OK;
2976 /***********************************************************************
2977 * CoSetState [OLE32.@]
2979 * Sets the thread state object.
2981 * PARAMS
2982 * pv [I] Pointer to state object to be stored.
2984 * NOTES
2985 * The system keeps a reference on the object while the object stored.
2987 * RETURNS
2988 * Success: S_OK.
2989 * Failure: E_OUTOFMEMORY.
2991 HRESULT WINAPI CoSetState(IUnknown * pv)
2993 struct oletls *info = COM_CurrentInfo();
2994 if (!info) return E_OUTOFMEMORY;
2996 if (pv) IUnknown_AddRef(pv);
2998 if (info->state)
3000 TRACE("-- release %p now\n", info->state);
3001 IUnknown_Release(info->state);
3004 info->state = pv;
3006 return S_OK;
3010 /******************************************************************************
3011 * CoTreatAsClass [OLE32.@]
3013 * Sets the TreatAs value of a class.
3015 * PARAMS
3016 * clsidOld [I] Class to set TreatAs value on.
3017 * clsidNew [I] The class the clsidOld should be treated as.
3019 * RETURNS
3020 * Success: S_OK.
3021 * Failure: HRESULT code.
3023 * SEE ALSO
3024 * CoGetTreatAsClass
3026 HRESULT WINAPI CoTreatAsClass(REFCLSID clsidOld, REFCLSID clsidNew)
3028 static const WCHAR wszAutoTreatAs[] = {'A','u','t','o','T','r','e','a','t','A','s',0};
3029 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
3030 HKEY hkey = NULL;
3031 WCHAR szClsidNew[CHARS_IN_GUID];
3032 HRESULT res = S_OK;
3033 WCHAR auto_treat_as[CHARS_IN_GUID];
3034 LONG auto_treat_as_size = sizeof(auto_treat_as);
3035 CLSID id;
3037 res = COM_OpenKeyForCLSID(clsidOld, NULL, KEY_READ | KEY_WRITE, &hkey);
3038 if (FAILED(res))
3039 goto done;
3040 if (!memcmp( clsidOld, clsidNew, sizeof(*clsidOld) ))
3042 if (!RegQueryValueW(hkey, wszAutoTreatAs, auto_treat_as, &auto_treat_as_size) &&
3043 CLSIDFromString(auto_treat_as, &id) == S_OK)
3045 if (RegSetValueW(hkey, wszTreatAs, REG_SZ, auto_treat_as, sizeof(auto_treat_as)))
3047 res = REGDB_E_WRITEREGDB;
3048 goto done;
3051 else
3053 RegDeleteKeyW(hkey, wszTreatAs);
3054 goto done;
3057 else if (!StringFromGUID2(clsidNew, szClsidNew, ARRAYSIZE(szClsidNew)) &&
3058 !RegSetValueW(hkey, wszTreatAs, REG_SZ, szClsidNew, sizeof(szClsidNew)))
3060 res = REGDB_E_WRITEREGDB;
3061 goto done;
3064 done:
3065 if (hkey) RegCloseKey(hkey);
3066 return res;
3069 /******************************************************************************
3070 * CoGetTreatAsClass [OLE32.@]
3072 * Gets the TreatAs value of a class.
3074 * PARAMS
3075 * clsidOld [I] Class to get the TreatAs value of.
3076 * clsidNew [I] The class the clsidOld should be treated as.
3078 * RETURNS
3079 * Success: S_OK.
3080 * Failure: HRESULT code.
3082 * SEE ALSO
3083 * CoSetTreatAsClass
3085 HRESULT WINAPI CoGetTreatAsClass(REFCLSID clsidOld, LPCLSID clsidNew)
3087 static const WCHAR wszTreatAs[] = {'T','r','e','a','t','A','s',0};
3088 HKEY hkey = NULL;
3089 WCHAR szClsidNew[CHARS_IN_GUID];
3090 HRESULT res = S_OK;
3091 LONG len = sizeof(szClsidNew);
3093 TRACE("(%s,%p)\n", debugstr_guid(clsidOld), clsidNew);
3094 *clsidNew = *clsidOld; /* copy over old value */
3096 res = COM_OpenKeyForCLSID(clsidOld, wszTreatAs, KEY_READ, &hkey);
3097 if (FAILED(res))
3099 res = S_FALSE;
3100 goto done;
3102 if (RegQueryValueW(hkey, NULL, szClsidNew, &len))
3104 res = S_FALSE;
3105 goto done;
3107 res = CLSIDFromString(szClsidNew,clsidNew);
3108 if (FAILED(res))
3109 ERR("Failed CLSIDFromStringA(%s), hres 0x%08x\n", debugstr_w(szClsidNew), res);
3110 done:
3111 if (hkey) RegCloseKey(hkey);
3112 return res;
3115 /******************************************************************************
3116 * CoGetCurrentProcess [OLE32.@]
3118 * Gets the current process ID.
3120 * RETURNS
3121 * The current process ID.
3123 * NOTES
3124 * Is DWORD really the correct return type for this function?
3126 DWORD WINAPI CoGetCurrentProcess(void)
3128 return GetCurrentProcessId();
3131 /******************************************************************************
3132 * CoRegisterMessageFilter [OLE32.@]
3134 * Registers a message filter.
3136 * PARAMS
3137 * lpMessageFilter [I] Pointer to interface.
3138 * lplpMessageFilter [O] Indirect pointer to prior instance if non-NULL.
3140 * RETURNS
3141 * Success: S_OK.
3142 * Failure: HRESULT code.
3144 * NOTES
3145 * Both lpMessageFilter and lplpMessageFilter are optional. Passing in a NULL
3146 * lpMessageFilter removes the message filter.
3148 * If lplpMessageFilter is not NULL the previous message filter will be
3149 * returned in the memory pointer to this parameter and the caller is
3150 * responsible for releasing the object.
3152 * The current thread be in an apartment otherwise the function will crash.
3154 HRESULT WINAPI CoRegisterMessageFilter(
3155 LPMESSAGEFILTER lpMessageFilter,
3156 LPMESSAGEFILTER *lplpMessageFilter)
3158 struct apartment *apt;
3159 IMessageFilter *lpOldMessageFilter;
3161 TRACE("(%p, %p)\n", lpMessageFilter, lplpMessageFilter);
3163 apt = COM_CurrentApt();
3165 /* can't set a message filter in a multi-threaded apartment */
3166 if (!apt || apt->multi_threaded)
3168 WARN("can't set message filter in MTA or uninitialized apt\n");
3169 return CO_E_NOT_SUPPORTED;
3172 if (lpMessageFilter)
3173 IMessageFilter_AddRef(lpMessageFilter);
3175 EnterCriticalSection(&apt->cs);
3177 lpOldMessageFilter = apt->filter;
3178 apt->filter = lpMessageFilter;
3180 LeaveCriticalSection(&apt->cs);
3182 if (lplpMessageFilter)
3183 *lplpMessageFilter = lpOldMessageFilter;
3184 else if (lpOldMessageFilter)
3185 IMessageFilter_Release(lpOldMessageFilter);
3187 return S_OK;
3190 /***********************************************************************
3191 * CoIsOle1Class [OLE32.@]
3193 * Determines whether the specified class an OLE v1 class.
3195 * PARAMS
3196 * clsid [I] Class to test.
3198 * RETURNS
3199 * TRUE if the class is an OLE v1 class, or FALSE otherwise.
3201 BOOL WINAPI CoIsOle1Class(REFCLSID clsid)
3203 FIXME("%s\n", debugstr_guid(clsid));
3204 return FALSE;
3207 /***********************************************************************
3208 * IsEqualGUID [OLE32.@]
3210 * Compares two Unique Identifiers.
3212 * PARAMS
3213 * rguid1 [I] The first GUID to compare.
3214 * rguid2 [I] The other GUID to compare.
3216 * RETURNS
3217 * TRUE if equal
3219 #undef IsEqualGUID
3220 BOOL WINAPI IsEqualGUID(
3221 REFGUID rguid1,
3222 REFGUID rguid2)
3224 return !memcmp(rguid1,rguid2,sizeof(GUID));
3227 /***********************************************************************
3228 * CoInitializeSecurity [OLE32.@]
3230 HRESULT WINAPI CoInitializeSecurity(PSECURITY_DESCRIPTOR pSecDesc, LONG cAuthSvc,
3231 SOLE_AUTHENTICATION_SERVICE* asAuthSvc,
3232 void* pReserved1, DWORD dwAuthnLevel,
3233 DWORD dwImpLevel, void* pReserved2,
3234 DWORD dwCapabilities, void* pReserved3)
3236 FIXME("(%p,%d,%p,%p,%d,%d,%p,%d,%p) - stub!\n", pSecDesc, cAuthSvc,
3237 asAuthSvc, pReserved1, dwAuthnLevel, dwImpLevel, pReserved2,
3238 dwCapabilities, pReserved3);
3239 return S_OK;
3242 /***********************************************************************
3243 * CoSuspendClassObjects [OLE32.@]
3245 * Suspends all registered class objects to prevent further requests coming in
3246 * for those objects.
3248 * RETURNS
3249 * Success: S_OK.
3250 * Failure: HRESULT code.
3252 HRESULT WINAPI CoSuspendClassObjects(void)
3254 FIXME("\n");
3255 return S_OK;
3258 /***********************************************************************
3259 * CoAddRefServerProcess [OLE32.@]
3261 * Helper function for incrementing the reference count of a local-server
3262 * process.
3264 * RETURNS
3265 * New reference count.
3267 * SEE ALSO
3268 * CoReleaseServerProcess().
3270 ULONG WINAPI CoAddRefServerProcess(void)
3272 ULONG refs;
3274 TRACE("\n");
3276 EnterCriticalSection(&csRegisteredClassList);
3277 refs = ++s_COMServerProcessReferences;
3278 LeaveCriticalSection(&csRegisteredClassList);
3280 TRACE("refs before: %d\n", refs - 1);
3282 return refs;
3285 /***********************************************************************
3286 * CoReleaseServerProcess [OLE32.@]
3288 * Helper function for decrementing the reference count of a local-server
3289 * process.
3291 * RETURNS
3292 * New reference count.
3294 * NOTES
3295 * When reference count reaches 0, this function suspends all registered
3296 * classes so no new connections are accepted.
3298 * SEE ALSO
3299 * CoAddRefServerProcess(), CoSuspendClassObjects().
3301 ULONG WINAPI CoReleaseServerProcess(void)
3303 ULONG refs;
3305 TRACE("\n");
3307 EnterCriticalSection(&csRegisteredClassList);
3309 refs = --s_COMServerProcessReferences;
3310 /* FIXME: if (!refs) COM_SuspendClassObjects(); */
3312 LeaveCriticalSection(&csRegisteredClassList);
3314 TRACE("refs after: %d\n", refs);
3316 return refs;
3319 /***********************************************************************
3320 * CoIsHandlerConnected [OLE32.@]
3322 * Determines whether a proxy is connected to a remote stub.
3324 * PARAMS
3325 * pUnk [I] Pointer to object that may or may not be connected.
3327 * RETURNS
3328 * TRUE if pUnk is not a proxy or if pUnk is connected to a remote stub, or
3329 * FALSE otherwise.
3331 BOOL WINAPI CoIsHandlerConnected(IUnknown *pUnk)
3333 FIXME("%p\n", pUnk);
3335 return TRUE;
3338 /***********************************************************************
3339 * CoAllowSetForegroundWindow [OLE32.@]
3342 HRESULT WINAPI CoAllowSetForegroundWindow(IUnknown *pUnk, void *pvReserved)
3344 FIXME("(%p, %p): stub\n", pUnk, pvReserved);
3345 return S_OK;
3348 /***********************************************************************
3349 * CoQueryProxyBlanket [OLE32.@]
3351 * Retrieves the security settings being used by a proxy.
3353 * PARAMS
3354 * pProxy [I] Pointer to the proxy object.
3355 * pAuthnSvc [O] The type of authentication service.
3356 * pAuthzSvc [O] The type of authorization service.
3357 * ppServerPrincName [O] Optional. The server prinicple name.
3358 * pAuthnLevel [O] The authentication level.
3359 * pImpLevel [O] The impersonation level.
3360 * ppAuthInfo [O] Information specific to the authorization/authentication service.
3361 * pCapabilities [O] Flags affecting the security behaviour.
3363 * RETURNS
3364 * Success: S_OK.
3365 * Failure: HRESULT code.
3367 * SEE ALSO
3368 * CoCopyProxy, CoSetProxyBlanket.
3370 HRESULT WINAPI CoQueryProxyBlanket(IUnknown *pProxy, DWORD *pAuthnSvc,
3371 DWORD *pAuthzSvc, OLECHAR **ppServerPrincName, DWORD *pAuthnLevel,
3372 DWORD *pImpLevel, void **ppAuthInfo, DWORD *pCapabilities)
3374 IClientSecurity *pCliSec;
3375 HRESULT hr;
3377 TRACE("%p\n", pProxy);
3379 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3380 if (SUCCEEDED(hr))
3382 hr = IClientSecurity_QueryBlanket(pCliSec, pProxy, pAuthnSvc,
3383 pAuthzSvc, ppServerPrincName,
3384 pAuthnLevel, pImpLevel, ppAuthInfo,
3385 pCapabilities);
3386 IClientSecurity_Release(pCliSec);
3389 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3390 return hr;
3393 /***********************************************************************
3394 * CoSetProxyBlanket [OLE32.@]
3396 * Sets the security settings for a proxy.
3398 * PARAMS
3399 * pProxy [I] Pointer to the proxy object.
3400 * AuthnSvc [I] The type of authentication service.
3401 * AuthzSvc [I] The type of authorization service.
3402 * pServerPrincName [I] The server prinicple name.
3403 * AuthnLevel [I] The authentication level.
3404 * ImpLevel [I] The impersonation level.
3405 * pAuthInfo [I] Information specific to the authorization/authentication service.
3406 * Capabilities [I] Flags affecting the security behaviour.
3408 * RETURNS
3409 * Success: S_OK.
3410 * Failure: HRESULT code.
3412 * SEE ALSO
3413 * CoQueryProxyBlanket, CoCopyProxy.
3415 HRESULT WINAPI CoSetProxyBlanket(IUnknown *pProxy, DWORD AuthnSvc,
3416 DWORD AuthzSvc, OLECHAR *pServerPrincName, DWORD AuthnLevel,
3417 DWORD ImpLevel, void *pAuthInfo, DWORD Capabilities)
3419 IClientSecurity *pCliSec;
3420 HRESULT hr;
3422 TRACE("%p\n", pProxy);
3424 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3425 if (SUCCEEDED(hr))
3427 hr = IClientSecurity_SetBlanket(pCliSec, pProxy, AuthnSvc,
3428 AuthzSvc, pServerPrincName,
3429 AuthnLevel, ImpLevel, pAuthInfo,
3430 Capabilities);
3431 IClientSecurity_Release(pCliSec);
3434 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3435 return hr;
3438 /***********************************************************************
3439 * CoCopyProxy [OLE32.@]
3441 * Copies a proxy.
3443 * PARAMS
3444 * pProxy [I] Pointer to the proxy object.
3445 * ppCopy [O] Copy of the proxy.
3447 * RETURNS
3448 * Success: S_OK.
3449 * Failure: HRESULT code.
3451 * SEE ALSO
3452 * CoQueryProxyBlanket, CoSetProxyBlanket.
3454 HRESULT WINAPI CoCopyProxy(IUnknown *pProxy, IUnknown **ppCopy)
3456 IClientSecurity *pCliSec;
3457 HRESULT hr;
3459 TRACE("%p\n", pProxy);
3461 hr = IUnknown_QueryInterface(pProxy, &IID_IClientSecurity, (void **)&pCliSec);
3462 if (SUCCEEDED(hr))
3464 hr = IClientSecurity_CopyProxy(pCliSec, pProxy, ppCopy);
3465 IClientSecurity_Release(pCliSec);
3468 if (FAILED(hr)) ERR("-- failed with 0x%08x\n", hr);
3469 return hr;
3473 /***********************************************************************
3474 * CoGetCallContext [OLE32.@]
3476 * Gets the context of the currently executing server call in the current
3477 * thread.
3479 * PARAMS
3480 * riid [I] Context interface to return.
3481 * ppv [O] Pointer to memory that will receive the context on return.
3483 * RETURNS
3484 * Success: S_OK.
3485 * Failure: HRESULT code.
3487 HRESULT WINAPI CoGetCallContext(REFIID riid, void **ppv)
3489 struct oletls *info = COM_CurrentInfo();
3491 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
3493 if (!info)
3494 return E_OUTOFMEMORY;
3496 if (!info->call_state)
3497 return RPC_E_CALL_COMPLETE;
3499 return IUnknown_QueryInterface(info->call_state, riid, ppv);
3502 /***********************************************************************
3503 * CoSwitchCallContext [OLE32.@]
3505 * Switches the context of the currently executing server call in the current
3506 * thread.
3508 * PARAMS
3509 * pObject [I] Pointer to new context object
3510 * ppOldObject [O] Pointer to memory that will receive old context object pointer
3512 * RETURNS
3513 * Success: S_OK.
3514 * Failure: HRESULT code.
3516 HRESULT WINAPI CoSwitchCallContext(IUnknown *pObject, IUnknown **ppOldObject)
3518 struct oletls *info = COM_CurrentInfo();
3520 TRACE("(%p, %p)\n", pObject, ppOldObject);
3522 if (!info)
3523 return E_OUTOFMEMORY;
3525 *ppOldObject = info->call_state;
3526 info->call_state = pObject; /* CoSwitchCallContext does not addref nor release objects */
3528 return S_OK;
3531 /***********************************************************************
3532 * CoQueryClientBlanket [OLE32.@]
3534 * Retrieves the authentication information about the client of the currently
3535 * executing server call in the current thread.
3537 * PARAMS
3538 * pAuthnSvc [O] Optional. The type of authentication service.
3539 * pAuthzSvc [O] Optional. The type of authorization service.
3540 * pServerPrincName [O] Optional. The server prinicple name.
3541 * pAuthnLevel [O] Optional. The authentication level.
3542 * pImpLevel [O] Optional. The impersonation level.
3543 * pPrivs [O] Optional. Information about the privileges of the client.
3544 * pCapabilities [IO] Optional. Flags affecting the security behaviour.
3546 * RETURNS
3547 * Success: S_OK.
3548 * Failure: HRESULT code.
3550 * SEE ALSO
3551 * CoImpersonateClient, CoRevertToSelf, CoGetCallContext.
3553 HRESULT WINAPI CoQueryClientBlanket(
3554 DWORD *pAuthnSvc,
3555 DWORD *pAuthzSvc,
3556 OLECHAR **pServerPrincName,
3557 DWORD *pAuthnLevel,
3558 DWORD *pImpLevel,
3559 RPC_AUTHZ_HANDLE *pPrivs,
3560 DWORD *pCapabilities)
3562 IServerSecurity *pSrvSec;
3563 HRESULT hr;
3565 TRACE("(%p, %p, %p, %p, %p, %p, %p)\n",
3566 pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel, pImpLevel,
3567 pPrivs, pCapabilities);
3569 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3570 if (SUCCEEDED(hr))
3572 hr = IServerSecurity_QueryBlanket(
3573 pSrvSec, pAuthnSvc, pAuthzSvc, pServerPrincName, pAuthnLevel,
3574 pImpLevel, pPrivs, pCapabilities);
3575 IServerSecurity_Release(pSrvSec);
3578 return hr;
3581 /***********************************************************************
3582 * CoImpersonateClient [OLE32.@]
3584 * Impersonates the client of the currently executing server call in the
3585 * current thread.
3587 * PARAMS
3588 * None.
3590 * RETURNS
3591 * Success: S_OK.
3592 * Failure: HRESULT code.
3594 * NOTES
3595 * If this function fails then the current thread will not be impersonating
3596 * the client and all actions will take place on behalf of the server.
3597 * Therefore, it is important to check the return value from this function.
3599 * SEE ALSO
3600 * CoRevertToSelf, CoQueryClientBlanket, CoGetCallContext.
3602 HRESULT WINAPI CoImpersonateClient(void)
3604 IServerSecurity *pSrvSec;
3605 HRESULT hr;
3607 TRACE("\n");
3609 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3610 if (SUCCEEDED(hr))
3612 hr = IServerSecurity_ImpersonateClient(pSrvSec);
3613 IServerSecurity_Release(pSrvSec);
3616 return hr;
3619 /***********************************************************************
3620 * CoRevertToSelf [OLE32.@]
3622 * Ends the impersonation of the client of the currently executing server
3623 * call in the current thread.
3625 * PARAMS
3626 * None.
3628 * RETURNS
3629 * Success: S_OK.
3630 * Failure: HRESULT code.
3632 * SEE ALSO
3633 * CoImpersonateClient, CoQueryClientBlanket, CoGetCallContext.
3635 HRESULT WINAPI CoRevertToSelf(void)
3637 IServerSecurity *pSrvSec;
3638 HRESULT hr;
3640 TRACE("\n");
3642 hr = CoGetCallContext(&IID_IServerSecurity, (void **)&pSrvSec);
3643 if (SUCCEEDED(hr))
3645 hr = IServerSecurity_RevertToSelf(pSrvSec);
3646 IServerSecurity_Release(pSrvSec);
3649 return hr;
3652 static BOOL COM_PeekMessage(struct apartment *apt, MSG *msg)
3654 /* first try to retrieve messages for incoming COM calls to the apartment window */
3655 return PeekMessageW(msg, apt->win, 0, 0, PM_REMOVE|PM_NOYIELD) ||
3656 /* next retrieve other messages necessary for the app to remain responsive */
3657 PeekMessageW(msg, NULL, WM_DDE_FIRST, WM_DDE_LAST, PM_REMOVE|PM_NOYIELD) ||
3658 PeekMessageW(msg, NULL, 0, 0, PM_QS_PAINT|PM_QS_SENDMESSAGE|PM_REMOVE|PM_NOYIELD);
3661 /***********************************************************************
3662 * CoWaitForMultipleHandles [OLE32.@]
3664 * Waits for one or more handles to become signaled.
3666 * PARAMS
3667 * dwFlags [I] Flags. See notes.
3668 * dwTimeout [I] Timeout in milliseconds.
3669 * cHandles [I] Number of handles pointed to by pHandles.
3670 * pHandles [I] Handles to wait for.
3671 * lpdwindex [O] Index of handle that was signaled.
3673 * RETURNS
3674 * Success: S_OK.
3675 * Failure: RPC_S_CALLPENDING on timeout.
3677 * NOTES
3679 * The dwFlags parameter can be zero or more of the following:
3680 *| COWAIT_WAITALL - Wait for all of the handles to become signaled.
3681 *| COWAIT_ALERTABLE - Allows a queued APC to run during the wait.
3683 * SEE ALSO
3684 * MsgWaitForMultipleObjects, WaitForMultipleObjects.
3686 HRESULT WINAPI CoWaitForMultipleHandles(DWORD dwFlags, DWORD dwTimeout,
3687 ULONG cHandles, LPHANDLE pHandles, LPDWORD lpdwindex)
3689 HRESULT hr = S_OK;
3690 DWORD start_time = GetTickCount();
3691 APARTMENT *apt = COM_CurrentApt();
3692 BOOL message_loop = apt && !apt->multi_threaded;
3694 TRACE("(0x%08x, 0x%08x, %d, %p, %p)\n", dwFlags, dwTimeout, cHandles,
3695 pHandles, lpdwindex);
3697 while (TRUE)
3699 DWORD now = GetTickCount();
3700 DWORD res;
3702 if (now - start_time > dwTimeout)
3704 hr = RPC_S_CALLPENDING;
3705 break;
3708 if (message_loop)
3710 DWORD wait_flags = ((dwFlags & COWAIT_WAITALL) ? MWMO_WAITALL : 0) |
3711 ((dwFlags & COWAIT_ALERTABLE ) ? MWMO_ALERTABLE : 0);
3713 TRACE("waiting for rpc completion or window message\n");
3715 res = MsgWaitForMultipleObjectsEx(cHandles, pHandles,
3716 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3717 QS_SENDMESSAGE | QS_ALLPOSTMESSAGE | QS_PAINT, wait_flags);
3719 if (res == WAIT_OBJECT_0 + cHandles) /* messages available */
3721 MSG msg;
3723 /* call message filter */
3725 if (COM_CurrentApt()->filter)
3727 PENDINGTYPE pendingtype =
3728 COM_CurrentInfo()->pending_call_count_server ?
3729 PENDINGTYPE_NESTED : PENDINGTYPE_TOPLEVEL;
3730 DWORD be_handled = IMessageFilter_MessagePending(
3731 COM_CurrentApt()->filter, 0 /* FIXME */,
3732 now - start_time, pendingtype);
3733 TRACE("IMessageFilter_MessagePending returned %d\n", be_handled);
3734 switch (be_handled)
3736 case PENDINGMSG_CANCELCALL:
3737 WARN("call canceled\n");
3738 hr = RPC_E_CALL_CANCELED;
3739 break;
3740 case PENDINGMSG_WAITNOPROCESS:
3741 case PENDINGMSG_WAITDEFPROCESS:
3742 default:
3743 /* FIXME: MSDN is very vague about the difference
3744 * between WAITNOPROCESS and WAITDEFPROCESS - there
3745 * appears to be none, so it is possibly a left-over
3746 * from the 16-bit world. */
3747 break;
3751 while (COM_PeekMessage(apt, &msg))
3753 TRACE("received message whilst waiting for RPC: 0x%04x\n", msg.message);
3754 TranslateMessage(&msg);
3755 DispatchMessageW(&msg);
3756 if (msg.message == WM_QUIT)
3758 TRACE("resending WM_QUIT to outer message loop\n");
3759 PostQuitMessage(msg.wParam);
3760 /* no longer need to process messages */
3761 message_loop = FALSE;
3762 break;
3765 continue;
3768 else
3770 TRACE("waiting for rpc completion\n");
3772 res = WaitForMultipleObjectsEx(cHandles, pHandles,
3773 (dwFlags & COWAIT_WAITALL) ? TRUE : FALSE,
3774 (dwTimeout == INFINITE) ? INFINITE : start_time + dwTimeout - now,
3775 (dwFlags & COWAIT_ALERTABLE) ? TRUE : FALSE);
3778 switch (res)
3780 case WAIT_TIMEOUT:
3781 hr = RPC_S_CALLPENDING;
3782 break;
3783 case WAIT_FAILED:
3784 hr = HRESULT_FROM_WIN32( GetLastError() );
3785 break;
3786 default:
3787 *lpdwindex = res;
3788 break;
3790 break;
3792 TRACE("-- 0x%08x\n", hr);
3793 return hr;
3797 /***********************************************************************
3798 * CoGetObject [OLE32.@]
3800 * Gets the object named by converting the name to a moniker and binding to it.
3802 * PARAMS
3803 * pszName [I] String representing the object.
3804 * pBindOptions [I] Parameters affecting the binding to the named object.
3805 * riid [I] Interface to bind to on the objecct.
3806 * ppv [O] On output, the interface riid of the object represented
3807 * by pszName.
3809 * RETURNS
3810 * Success: S_OK.
3811 * Failure: HRESULT code.
3813 * SEE ALSO
3814 * MkParseDisplayName.
3816 HRESULT WINAPI CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions,
3817 REFIID riid, void **ppv)
3819 IBindCtx *pbc;
3820 HRESULT hr;
3822 *ppv = NULL;
3824 hr = CreateBindCtx(0, &pbc);
3825 if (SUCCEEDED(hr))
3827 if (pBindOptions)
3828 hr = IBindCtx_SetBindOptions(pbc, pBindOptions);
3830 if (SUCCEEDED(hr))
3832 ULONG chEaten;
3833 IMoniker *pmk;
3835 hr = MkParseDisplayName(pbc, pszName, &chEaten, &pmk);
3836 if (SUCCEEDED(hr))
3838 hr = IMoniker_BindToObject(pmk, pbc, NULL, riid, ppv);
3839 IMoniker_Release(pmk);
3843 IBindCtx_Release(pbc);
3845 return hr;
3848 /***********************************************************************
3849 * CoRegisterChannelHook [OLE32.@]
3851 * Registers a process-wide hook that is called during ORPC calls.
3853 * PARAMS
3854 * guidExtension [I] GUID of the channel hook to register.
3855 * pChannelHook [I] Channel hook object to register.
3857 * RETURNS
3858 * Success: S_OK.
3859 * Failure: HRESULT code.
3861 HRESULT WINAPI CoRegisterChannelHook(REFGUID guidExtension, IChannelHook *pChannelHook)
3863 TRACE("(%s, %p)\n", debugstr_guid(guidExtension), pChannelHook);
3865 return RPC_RegisterChannelHook(guidExtension, pChannelHook);
3868 typedef struct Context
3870 IComThreadingInfo IComThreadingInfo_iface;
3871 IContextCallback IContextCallback_iface;
3872 IObjContext IObjContext_iface;
3873 LONG refs;
3874 APTTYPE apttype;
3875 } Context;
3877 static inline Context *impl_from_IComThreadingInfo( IComThreadingInfo *iface )
3879 return CONTAINING_RECORD(iface, Context, IComThreadingInfo_iface);
3882 static inline Context *impl_from_IContextCallback( IContextCallback *iface )
3884 return CONTAINING_RECORD(iface, Context, IContextCallback_iface);
3887 static inline Context *impl_from_IObjContext( IObjContext *iface )
3889 return CONTAINING_RECORD(iface, Context, IObjContext_iface);
3892 static HRESULT Context_QueryInterface(Context *iface, REFIID riid, LPVOID *ppv)
3894 *ppv = NULL;
3896 if (IsEqualIID(riid, &IID_IComThreadingInfo) ||
3897 IsEqualIID(riid, &IID_IUnknown))
3899 *ppv = &iface->IComThreadingInfo_iface;
3901 else if (IsEqualIID(riid, &IID_IContextCallback))
3903 *ppv = &iface->IContextCallback_iface;
3905 else if (IsEqualIID(riid, &IID_IObjContext))
3907 *ppv = &iface->IObjContext_iface;
3910 if (*ppv)
3912 IUnknown_AddRef((IUnknown*)*ppv);
3913 return S_OK;
3916 FIXME("interface not implemented %s\n", debugstr_guid(riid));
3917 return E_NOINTERFACE;
3920 static ULONG Context_AddRef(Context *This)
3922 return InterlockedIncrement(&This->refs);
3925 static ULONG Context_Release(Context *This)
3927 ULONG refs = InterlockedDecrement(&This->refs);
3928 if (!refs)
3929 HeapFree(GetProcessHeap(), 0, This);
3930 return refs;
3933 static HRESULT WINAPI Context_CTI_QueryInterface(IComThreadingInfo *iface, REFIID riid, LPVOID *ppv)
3935 Context *This = impl_from_IComThreadingInfo(iface);
3936 return Context_QueryInterface(This, riid, ppv);
3939 static ULONG WINAPI Context_CTI_AddRef(IComThreadingInfo *iface)
3941 Context *This = impl_from_IComThreadingInfo(iface);
3942 return Context_AddRef(This);
3945 static ULONG WINAPI Context_CTI_Release(IComThreadingInfo *iface)
3947 Context *This = impl_from_IComThreadingInfo(iface);
3948 return Context_Release(This);
3951 static HRESULT WINAPI Context_CTI_GetCurrentApartmentType(IComThreadingInfo *iface, APTTYPE *apttype)
3953 Context *This = impl_from_IComThreadingInfo(iface);
3955 TRACE("(%p)\n", apttype);
3957 *apttype = This->apttype;
3958 return S_OK;
3961 static HRESULT WINAPI Context_CTI_GetCurrentThreadType(IComThreadingInfo *iface, THDTYPE *thdtype)
3963 Context *This = impl_from_IComThreadingInfo(iface);
3965 TRACE("(%p)\n", thdtype);
3967 switch (This->apttype)
3969 case APTTYPE_STA:
3970 case APTTYPE_MAINSTA:
3971 *thdtype = THDTYPE_PROCESSMESSAGES;
3972 break;
3973 default:
3974 *thdtype = THDTYPE_BLOCKMESSAGES;
3975 break;
3977 return S_OK;
3980 static HRESULT WINAPI Context_CTI_GetCurrentLogicalThreadId(IComThreadingInfo *iface, GUID *logical_thread_id)
3982 FIXME("(%p): stub\n", logical_thread_id);
3983 return E_NOTIMPL;
3986 static HRESULT WINAPI Context_CTI_SetCurrentLogicalThreadId(IComThreadingInfo *iface, REFGUID logical_thread_id)
3988 FIXME("(%s): stub\n", debugstr_guid(logical_thread_id));
3989 return E_NOTIMPL;
3992 static const IComThreadingInfoVtbl Context_Threading_Vtbl =
3994 Context_CTI_QueryInterface,
3995 Context_CTI_AddRef,
3996 Context_CTI_Release,
3997 Context_CTI_GetCurrentApartmentType,
3998 Context_CTI_GetCurrentThreadType,
3999 Context_CTI_GetCurrentLogicalThreadId,
4000 Context_CTI_SetCurrentLogicalThreadId
4003 static HRESULT WINAPI Context_CC_QueryInterface(IContextCallback *iface, REFIID riid, LPVOID *ppv)
4005 Context *This = impl_from_IContextCallback(iface);
4006 return Context_QueryInterface(This, riid, ppv);
4009 static ULONG WINAPI Context_CC_AddRef(IContextCallback *iface)
4011 Context *This = impl_from_IContextCallback(iface);
4012 return Context_AddRef(This);
4015 static ULONG WINAPI Context_CC_Release(IContextCallback *iface)
4017 Context *This = impl_from_IContextCallback(iface);
4018 return Context_Release(This);
4021 static HRESULT WINAPI Context_CC_ContextCallback(IContextCallback *iface, PFNCONTEXTCALL pCallback,
4022 ComCallData *param, REFIID riid, int method, IUnknown *punk)
4024 Context *This = impl_from_IContextCallback(iface);
4026 FIXME("(%p/%p)->(%p, %p, %s, %d, %p)\n", This, iface, pCallback, param, debugstr_guid(riid), method, punk);
4027 return E_NOTIMPL;
4030 static const IContextCallbackVtbl Context_Callback_Vtbl =
4032 Context_CC_QueryInterface,
4033 Context_CC_AddRef,
4034 Context_CC_Release,
4035 Context_CC_ContextCallback
4038 static HRESULT WINAPI Context_OC_QueryInterface(IObjContext *iface, REFIID riid, LPVOID *ppv)
4040 Context *This = impl_from_IObjContext(iface);
4041 return Context_QueryInterface(This, riid, ppv);
4044 static ULONG WINAPI Context_OC_AddRef(IObjContext *iface)
4046 Context *This = impl_from_IObjContext(iface);
4047 return Context_AddRef(This);
4050 static ULONG WINAPI Context_OC_Release(IObjContext *iface)
4052 Context *This = impl_from_IObjContext(iface);
4053 return Context_Release(This);
4056 static HRESULT WINAPI Context_OC_SetProperty(IObjContext *iface, REFGUID propid, CPFLAGS flags, IUnknown *punk)
4058 Context *This = impl_from_IObjContext(iface);
4060 FIXME("(%p/%p)->(%s, %x, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
4061 return E_NOTIMPL;
4064 static HRESULT WINAPI Context_OC_RemoveProperty(IObjContext *iface, REFGUID propid)
4066 Context *This = impl_from_IObjContext(iface);
4068 FIXME("(%p/%p)->(%s)\n", This, iface, debugstr_guid(propid));
4069 return E_NOTIMPL;
4072 static HRESULT WINAPI Context_OC_GetProperty(IObjContext *iface, REFGUID propid, CPFLAGS *flags, IUnknown **punk)
4074 Context *This = impl_from_IObjContext(iface);
4076 FIXME("(%p/%p)->(%s, %p, %p)\n", This, iface, debugstr_guid(propid), flags, punk);
4077 return E_NOTIMPL;
4080 static HRESULT WINAPI Context_OC_EnumContextProps(IObjContext *iface, IEnumContextProps **props)
4082 Context *This = impl_from_IObjContext(iface);
4084 FIXME("(%p/%p)->(%p)\n", This, iface, props);
4085 return E_NOTIMPL;
4088 static void WINAPI Context_OC_Reserved1(IObjContext *iface)
4090 Context *This = impl_from_IObjContext(iface);
4091 FIXME("(%p/%p)\n", This, iface);
4094 static void WINAPI Context_OC_Reserved2(IObjContext *iface)
4096 Context *This = impl_from_IObjContext(iface);
4097 FIXME("(%p/%p)\n", This, iface);
4100 static void WINAPI Context_OC_Reserved3(IObjContext *iface)
4102 Context *This = impl_from_IObjContext(iface);
4103 FIXME("(%p/%p)\n", This, iface);
4106 static void WINAPI Context_OC_Reserved4(IObjContext *iface)
4108 Context *This = impl_from_IObjContext(iface);
4109 FIXME("(%p/%p)\n", This, iface);
4112 static void WINAPI Context_OC_Reserved5(IObjContext *iface)
4114 Context *This = impl_from_IObjContext(iface);
4115 FIXME("(%p/%p)\n", This, iface);
4118 static void WINAPI Context_OC_Reserved6(IObjContext *iface)
4120 Context *This = impl_from_IObjContext(iface);
4121 FIXME("(%p/%p)\n", This, iface);
4124 static void WINAPI Context_OC_Reserved7(IObjContext *iface)
4126 Context *This = impl_from_IObjContext(iface);
4127 FIXME("(%p/%p)\n", This, iface);
4130 static const IObjContextVtbl Context_Object_Vtbl =
4132 Context_OC_QueryInterface,
4133 Context_OC_AddRef,
4134 Context_OC_Release,
4135 Context_OC_SetProperty,
4136 Context_OC_RemoveProperty,
4137 Context_OC_GetProperty,
4138 Context_OC_EnumContextProps,
4139 Context_OC_Reserved1,
4140 Context_OC_Reserved2,
4141 Context_OC_Reserved3,
4142 Context_OC_Reserved4,
4143 Context_OC_Reserved5,
4144 Context_OC_Reserved6,
4145 Context_OC_Reserved7
4148 /***********************************************************************
4149 * CoGetObjectContext [OLE32.@]
4151 * Retrieves an object associated with the current context (i.e. apartment).
4153 * PARAMS
4154 * riid [I] ID of the interface of the object to retrieve.
4155 * ppv [O] Address where object will be stored on return.
4157 * RETURNS
4158 * Success: S_OK.
4159 * Failure: HRESULT code.
4161 HRESULT WINAPI CoGetObjectContext(REFIID riid, void **ppv)
4163 APARTMENT *apt = COM_CurrentApt();
4164 Context *context;
4165 HRESULT hr;
4167 TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
4169 *ppv = NULL;
4170 if (!apt)
4172 if (!(apt = apartment_find_multi_threaded()))
4174 ERR("apartment not initialised\n");
4175 return CO_E_NOTINITIALIZED;
4177 apartment_release(apt);
4180 context = HeapAlloc(GetProcessHeap(), 0, sizeof(*context));
4181 if (!context)
4182 return E_OUTOFMEMORY;
4184 context->IComThreadingInfo_iface.lpVtbl = &Context_Threading_Vtbl;
4185 context->IContextCallback_iface.lpVtbl = &Context_Callback_Vtbl;
4186 context->IObjContext_iface.lpVtbl = &Context_Object_Vtbl;
4187 context->refs = 1;
4188 if (apt->multi_threaded)
4189 context->apttype = APTTYPE_MTA;
4190 else if (apt->main)
4191 context->apttype = APTTYPE_MAINSTA;
4192 else
4193 context->apttype = APTTYPE_STA;
4195 hr = IUnknown_QueryInterface((IUnknown *)&context->IComThreadingInfo_iface, riid, ppv);
4196 IUnknown_Release((IUnknown *)&context->IComThreadingInfo_iface);
4198 return hr;
4202 /***********************************************************************
4203 * CoGetContextToken [OLE32.@]
4205 HRESULT WINAPI CoGetContextToken( ULONG_PTR *token )
4207 struct oletls *info = COM_CurrentInfo();
4209 TRACE("(%p)\n", token);
4211 if (!info)
4212 return E_OUTOFMEMORY;
4214 if (!info->apt)
4216 APARTMENT *apt;
4217 if (!(apt = apartment_find_multi_threaded()))
4219 ERR("apartment not initialised\n");
4220 return CO_E_NOTINITIALIZED;
4222 apartment_release(apt);
4225 if (!token)
4226 return E_POINTER;
4228 if (!info->context_token)
4230 HRESULT hr;
4231 IObjContext *ctx;
4233 hr = CoGetObjectContext(&IID_IObjContext, (void **)&ctx);
4234 if (FAILED(hr)) return hr;
4235 info->context_token = ctx;
4238 *token = (ULONG_PTR)info->context_token;
4239 TRACE("apt->context_token=%p\n", info->context_token);
4241 return S_OK;
4244 HRESULT Handler_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
4246 static const WCHAR wszInprocHandler32[] = {'I','n','p','r','o','c','H','a','n','d','l','e','r','3','2',0};
4247 HKEY hkey;
4248 HRESULT hres;
4250 hres = COM_OpenKeyForCLSID(rclsid, wszInprocHandler32, KEY_READ, &hkey);
4251 if (SUCCEEDED(hres))
4253 WCHAR dllpath[MAX_PATH+1];
4255 if (COM_RegReadPath(hkey, NULL, NULL, dllpath, ARRAYSIZE(dllpath)) == ERROR_SUCCESS)
4257 static const WCHAR wszOle32[] = {'o','l','e','3','2','.','d','l','l',0};
4258 if (!strcmpiW(dllpath, wszOle32))
4260 RegCloseKey(hkey);
4261 return HandlerCF_Create(rclsid, riid, ppv);
4264 else
4265 WARN("not creating object for inproc handler path %s\n", debugstr_w(dllpath));
4266 RegCloseKey(hkey);
4269 return CLASS_E_CLASSNOTAVAILABLE;
4272 /***********************************************************************
4273 * DllMain (OLE32.@)
4275 BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID fImpLoad)
4277 TRACE("%p 0x%x %p\n", hinstDLL, fdwReason, fImpLoad);
4279 switch(fdwReason) {
4280 case DLL_PROCESS_ATTACH:
4281 hProxyDll = hinstDLL;
4282 COMPOBJ_InitProcess();
4283 break;
4285 case DLL_PROCESS_DETACH:
4286 COMPOBJ_UninitProcess();
4287 RPC_UnregisterAllChannelHooks();
4288 COMPOBJ_DllList_Free();
4289 DeleteCriticalSection(&csRegisteredClassList);
4290 DeleteCriticalSection(&csApartment);
4291 break;
4293 case DLL_THREAD_DETACH:
4294 COM_TlsDestroy();
4295 break;
4297 return TRUE;
4300 /***********************************************************************
4301 * DllRegisterServer (OLE32.@)
4303 HRESULT WINAPI DllRegisterServer(void)
4305 return OLE32_DllRegisterServer();
4308 /***********************************************************************
4309 * DllUnregisterServer (OLE32.@)
4311 HRESULT WINAPI DllUnregisterServer(void)
4313 return OLE32_DllUnregisterServer();